/* LIBPIKA - The PIKA Library
 * Copyright (C) 1995-2003 Peter Mattis and Spencer Kimball
 *
 * pikaparamspecs.h
 *
 * This library is free software: you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 3 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library.  If not, see
 * <https://www.gnu.org/licenses/>.
 */

#if !defined (__PIKA_H_INSIDE__) && !defined (PIKA_COMPILATION)
#error "Only <libpika/pika.h> can be included directly."
#endif

#ifndef __LIBPIKA_PIKA_PARAM_SPECS_H__
#define __LIBPIKA_PIKA_PARAM_SPECS_H__

G_BEGIN_DECLS

/* For information look into the C source or the html documentation */


/*
 * PIKA_TYPE_PARAM_IMAGE
 */

#define PIKA_VALUE_HOLDS_IMAGE(value)   (G_TYPE_CHECK_VALUE_TYPE ((value),\
                                         PIKA_TYPE_IMAGE))

#define PIKA_TYPE_PARAM_IMAGE           (pika_param_image_get_type ())
#define PIKA_PARAM_SPEC_IMAGE(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), PIKA_TYPE_PARAM_IMAGE, PikaParamSpecImage))
#define PIKA_IS_PARAM_SPEC_IMAGE(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), PIKA_TYPE_PARAM_IMAGE))

typedef struct _PikaParamSpecImage PikaParamSpecImage;

struct _PikaParamSpecImage
{
  GParamSpecObject  parent_instance;

  gboolean          none_ok;
};

GType        pika_param_image_get_type (void) G_GNUC_CONST;

GParamSpec * pika_param_spec_image     (const gchar  *name,
                                        const gchar  *nick,
                                        const gchar  *blurb,
                                        gboolean      none_ok,
                                        GParamFlags   flags);


/*
 * PIKA_TYPE_PARAM_ITEM
 */

#define PIKA_VALUE_HOLDS_ITEM(value)   (G_TYPE_CHECK_VALUE_TYPE ((value),\
                                        PIKA_TYPE_ITEM))

#define PIKA_TYPE_PARAM_ITEM           (pika_param_item_get_type ())
#define PIKA_PARAM_SPEC_ITEM(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), PIKA_TYPE_PARAM_ITEM, PikaParamSpecItem))
#define PIKA_IS_PARAM_SPEC_ITEM(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), PIKA_TYPE_PARAM_ITEM))

typedef struct _PikaParamSpecItem PikaParamSpecItem;

struct _PikaParamSpecItem
{
  GParamSpecObject  parent_instance;

  gboolean          none_ok;
};

GType        pika_param_item_get_type (void) G_GNUC_CONST;

GParamSpec * pika_param_spec_item     (const gchar  *name,
                                       const gchar  *nick,
                                       const gchar  *blurb,
                                       gboolean      none_ok,
                                       GParamFlags   flags);


/*
 * PIKA_TYPE_PARAM_DRAWABLE
 */

#define PIKA_VALUE_HOLDS_DRAWABLE(value)   (G_TYPE_CHECK_VALUE_TYPE ((value),\
                                            PIKA_TYPE_DRAWABLE))

#define PIKA_TYPE_PARAM_DRAWABLE           (pika_param_drawable_get_type ())
#define PIKA_PARAM_SPEC_DRAWABLE(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), PIKA_TYPE_PARAM_DRAWABLE, PikaParamSpecDrawable))
#define PIKA_IS_PARAM_SPEC_DRAWABLE(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), PIKA_TYPE_PARAM_DRAWABLE))

typedef struct _PikaParamSpecDrawable PikaParamSpecDrawable;

struct _PikaParamSpecDrawable
{
  PikaParamSpecItem parent_instance;
};

GType        pika_param_drawable_get_type (void) G_GNUC_CONST;

GParamSpec * pika_param_spec_drawable     (const gchar  *name,
                                           const gchar  *nick,
                                           const gchar  *blurb,
                                           gboolean      none_ok,
                                           GParamFlags   flags);


/*
 * PIKA_TYPE_PARAM_LAYER
 */

#define PIKA_VALUE_HOLDS_LAYER(value)   (G_TYPE_CHECK_VALUE_TYPE ((value),\
                                         PIKA_TYPE_LAYER))

#define PIKA_TYPE_PARAM_LAYER           (pika_param_layer_get_type ())
#define PIKA_PARAM_SPEC_LAYER(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), PIKA_TYPE_PARAM_LAYER, PikaParamSpecLayer))
#define PIKA_IS_PARAM_SPEC_LAYER(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), PIKA_TYPE_PARAM_LAYER))

typedef struct _PikaParamSpecLayer PikaParamSpecLayer;

struct _PikaParamSpecLayer
{
  PikaParamSpecDrawable parent_instance;
};

GType        pika_param_layer_get_type (void) G_GNUC_CONST;

GParamSpec * pika_param_spec_layer     (const gchar  *name,
                                        const gchar  *nick,
                                        const gchar  *blurb,
                                        gboolean      none_ok,
                                        GParamFlags   flags);


/*
 * PIKA_TYPE_PARAM_TEXT_LAYER
 */

#define PIKA_VALUE_HOLDS_TEXT_LAYER(value)   (G_TYPE_CHECK_VALUE_TYPE ((value),\
                                              PIKA_TYPE_TEXT_LAYER))

#define PIKA_TYPE_PARAM_TEXT_LAYER           (pika_param_text_layer_get_type ())
#define PIKA_PARAM_SPEC_TEXT_LAYER(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), PIKA_TYPE_PARAM_TEXT_LAYER, PikaParamSpecTextLayer))
#define PIKA_IS_PARAM_SPEC_TEXT_LAYER(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), PIKA_TYPE_PARAM_TEXT_LAYER))

typedef struct _PikaParamSpecTextLayer PikaParamSpecTextLayer;

struct _PikaParamSpecTextLayer
{
  PikaParamSpecLayer parent_instance;
};

GType        pika_param_text_layer_get_type (void) G_GNUC_CONST;

GParamSpec * pika_param_spec_text_layer     (const gchar  *name,
                                             const gchar  *nick,
                                             const gchar  *blurb,
                                             gboolean      none_ok,
                                             GParamFlags   flags);

/*
 * PIKA_TYPE_PARAM_CHANNEL
 */

#define PIKA_VALUE_HOLDS_CHANNEL(value)   (G_TYPE_CHECK_VALUE_TYPE ((value),\
                                           PIKA_TYPE_CHANNEL))

#define PIKA_TYPE_PARAM_CHANNEL           (pika_param_channel_get_type ())
#define PIKA_PARAM_SPEC_CHANNEL(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), PIKA_TYPE_PARAM_CHANNEL, PikaParamSpecChannel))
#define PIKA_IS_PARAM_SPEC_CHANNEL(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), PIKA_TYPE_PARAM_CHANNEL))

typedef struct _PikaParamSpecChannel PikaParamSpecChannel;

struct _PikaParamSpecChannel
{
  PikaParamSpecDrawable parent_instance;
};

GType        pika_param_channel_get_type (void) G_GNUC_CONST;

GParamSpec * pika_param_spec_channel     (const gchar  *name,
                                          const gchar  *nick,
                                          const gchar  *blurb,
                                          gboolean      none_ok,
                                          GParamFlags   flags);


/*
 * PIKA_TYPE_PARAM_LAYER_MASK
 */

#define PIKA_VALUE_HOLDS_LAYER_MASK(value)   (G_TYPE_CHECK_VALUE_TYPE ((value),\
                                              PIKA_TYPE_LAYER_MASK))

#define PIKA_TYPE_PARAM_LAYER_MASK           (pika_param_layer_mask_get_type ())
#define PIKA_PARAM_SPEC_LAYER_MASK(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), PIKA_TYPE_PARAM_LAYER_MASK, PikaParamSpecLayerMask))
#define PIKA_IS_PARAM_SPEC_LAYER_MASK(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), PIKA_TYPE_PARAM_LAYER_MASK))

typedef struct _PikaParamSpecLayerMask PikaParamSpecLayerMask;

struct _PikaParamSpecLayerMask
{
  PikaParamSpecChannel parent_instance;
};

GType        pika_param_layer_mask_get_type (void) G_GNUC_CONST;

GParamSpec * pika_param_spec_layer_mask     (const gchar   *name,
                                             const gchar   *nick,
                                             const gchar   *blurb,
                                             gboolean       none_ok,
                                             GParamFlags    flags);


/*
 * PIKA_TYPE_PARAM_SELECTION
 */

#define PIKA_VALUE_HOLDS_SELECTION(value)   (G_TYPE_CHECK_VALUE_TYPE ((value),\
                                             PIKA_TYPE_SELECTION))

#define PIKA_TYPE_PARAM_SELECTION           (pika_param_selection_get_type ())
#define PIKA_PARAM_SPEC_SELECTION(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), PIKA_TYPE_PARAM_SELECTION, PikaParamSpecSelection))
#define PIKA_IS_PARAM_SPEC_SELECTION(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), PIKA_TYPE_PARAM_SELECTION))

typedef struct _PikaParamSpecSelection PikaParamSpecSelection;

struct _PikaParamSpecSelection
{
  PikaParamSpecChannel parent_instance;
};

GType        pika_param_selection_get_type (void) G_GNUC_CONST;

GParamSpec * pika_param_spec_selection     (const gchar   *name,
                                            const gchar   *nick,
                                            const gchar   *blurb,
                                            gboolean       none_ok,
                                            GParamFlags    flags);


/*
 * PIKA_TYPE_PARAM_VECTORS
 */

#define PIKA_VALUE_HOLDS_VECTORS(value)   (G_TYPE_CHECK_VALUE_TYPE ((value),\
                                           PIKA_TYPE_VECTORS))

#define PIKA_TYPE_PARAM_VECTORS           (pika_param_vectors_get_type ())
#define PIKA_PARAM_SPEC_VECTORS(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), PIKA_TYPE_PARAM_VECTORS, PikaParamSpecVectors))
#define PIKA_IS_PARAM_SPEC_VECTORS(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), PIKA_TYPE_PARAM_VECTORS))

typedef struct _PikaParamSpecVectors PikaParamSpecVectors;

struct _PikaParamSpecVectors
{
  PikaParamSpecItem parent_instance;
};

GType        pika_param_vectors_get_type (void) G_GNUC_CONST;

GParamSpec * pika_param_spec_vectors     (const gchar  *name,
                                          const gchar  *nick,
                                          const gchar  *blurb,
                                          gboolean      none_ok,
                                          GParamFlags   flags);


/*
 * PIKA_TYPE_PARAM_DISPLAY
 */

#define PIKA_VALUE_HOLDS_DISPLAY(value)   (G_TYPE_CHECK_VALUE_TYPE ((value),\
                                           PIKA_TYPE_DISPLAY))

#define PIKA_TYPE_PARAM_DISPLAY           (pika_param_display_get_type ())
#define PIKA_PARAM_SPEC_DISPLAY(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), PIKA_TYPE_PARAM_DISPLAY, PikaParamSpecDisplay))
#define PIKA_IS_PARAM_SPEC_DISPLAY(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), PIKA_TYPE_PARAM_DISPLAY))

typedef struct _PikaParamSpecDisplay PikaParamSpecDisplay;

struct _PikaParamSpecDisplay
{
  GParamSpecObject  parent_instance;

  gboolean          none_ok;
};

GType        pika_param_display_get_type (void) G_GNUC_CONST;

GParamSpec * pika_param_spec_display     (const gchar  *name,
                                          const gchar  *nick,
                                          const gchar  *blurb,
                                          gboolean      none_ok,
                                          GParamFlags   flags);


/*
 * PIKA_TYPE_PARAM_RESOURCE
 */

#define PIKA_VALUE_HOLDS_RESOURCE(value)   (G_TYPE_CHECK_VALUE_TYPE ((value), \
                                            PIKA_TYPE_RESOURCE))

#define PIKA_TYPE_PARAM_RESOURCE           (pika_param_resource_get_type ())
#define PIKA_PARAM_SPEC_RESOURCE(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), PIKA_TYPE_PARAM_RESOURCE, PikaParamSpecResource))
#define PIKA_IS_PARAM_SPEC_RESOURCE(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), PIKA_TYPE_PARAM_RESOURCE))

typedef struct _PikaParamSpecResource PikaParamSpecResource;

struct _PikaParamSpecResource
{
  GParamSpecObject  parent_instance;

  gboolean          none_ok;
};

GType        pika_param_resource_get_type (void) G_GNUC_CONST;

GParamSpec * pika_param_spec_resource     (const gchar  *name,
                                           const gchar  *nick,
                                           const gchar  *blurb,
                                           gboolean      none_ok,
                                           GParamFlags   flags);


/*
 * PIKA_TYPE_PARAM_BRUSH
 */

#define PIKA_VALUE_HOLDS_BRUSH(value)   (G_TYPE_CHECK_VALUE_TYPE ((value), \
                                         PIKA_TYPE_BRUSH))

#define PIKA_TYPE_PARAM_BRUSH           (pika_param_brush_get_type ())
#define PIKA_PARAM_SPEC_BRUSH(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), PIKA_TYPE_PARAM_BRUSH, PikaParamSpecBrush))
#define PIKA_IS_PARAM_SPEC_BRUSH(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), PIKA_TYPE_PARAM_BRUSH))

typedef struct _PikaParamSpecBrush PikaParamSpecBrush;

struct _PikaParamSpecBrush
{
  PikaParamSpecResource  parent_instance;
};

GType        pika_param_brush_get_type (void) G_GNUC_CONST;

GParamSpec * pika_param_spec_brush (const gchar  *name,
                                    const gchar  *nick,
                                    const gchar  *blurb,
                                    gboolean      none_ok,
                                    GParamFlags   flags);


/*
 * PIKA_TYPE_PARAM_PATTERN
 */

#define PIKA_VALUE_HOLDS_PATTERN(value)   (G_TYPE_CHECK_VALUE_TYPE ((value), \
                                           PIKA_TYPE_PATTERN))

#define PIKA_TYPE_PARAM_PATTERN           (pika_param_pattern_get_type ())
#define PIKA_PARAM_SPEC_PATTERN(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), PIKA_TYPE_PARAM_PATTERN, PikaParamSpecPattern))
#define PIKA_IS_PARAM_SPEC_PATTERN(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), PIKA_TYPE_PARAM_PATTERN))

typedef struct _PikaParamSpecPattern PikaParamSpecPattern;

struct _PikaParamSpecPattern
{
  PikaParamSpecResource  parent_instance;
};

GType        pika_param_pattern_get_type (void) G_GNUC_CONST;

GParamSpec * pika_param_spec_pattern (const gchar  *name,
                                      const gchar  *nick,
                                      const gchar  *blurb,
                                      gboolean      none_ok,
                                      GParamFlags   flags);


/*
 * PIKA_TYPE_PARAM_GRADIENT
 */

#define PIKA_VALUE_HOLDS_GRADIENT(value)   (G_TYPE_CHECK_VALUE_TYPE ((value), \
                                            PIKA_TYPE_GRADIENT))

#define PIKA_TYPE_PARAM_GRADIENT           (pika_param_gradient_get_type ())
#define PIKA_PARAM_SPEC_GRADIENT(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), PIKA_TYPE_PARAM_GRADIENT, PikaParamSpecGradient))
#define PIKA_IS_PARAM_SPEC_GRADIENT(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), PIKA_TYPE_PARAM_GRADIENT))

typedef struct _PikaParamSpecGradient PikaParamSpecGradient;

struct _PikaParamSpecGradient
{
  PikaParamSpecResource  parent_instance;
};

GType        pika_param_gradient_get_type (void) G_GNUC_CONST;

GParamSpec * pika_param_spec_gradient (const gchar  *name,
                                       const gchar  *nick,
                                       const gchar  *blurb,
                                       gboolean      none_ok,
                                       GParamFlags   flags);


/*
 * PIKA_TYPE_PARAM_PALETTE
 */

#define PIKA_VALUE_HOLDS_PALETTE(value)   (G_TYPE_CHECK_VALUE_TYPE ((value), \
                                           PIKA_TYPE_PALETTE))

#define PIKA_TYPE_PARAM_PALETTE           (pika_param_palette_get_type ())
#define PIKA_PARAM_SPEC_PALETTE(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), PIKA_TYPE_PARAM_PALETTE, PikaParamSpecPalette))
#define PIKA_IS_PARAM_SPEC_PALETTE(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), PIKA_TYPE_PARAM_PALETTE))

typedef struct _PikaParamSpecPalette PikaParamSpecPalette;

struct _PikaParamSpecPalette
{
  PikaParamSpecResource  parent_instance;
};

GType        pika_param_palette_get_type (void) G_GNUC_CONST;

GParamSpec * pika_param_spec_palette (const gchar  *name,
                                      const gchar  *nick,
                                      const gchar  *blurb,
                                      gboolean      none_ok,
                                      GParamFlags   flags);


/*
 * PIKA_TYPE_PARAM_FONT
 */

#define PIKA_VALUE_HOLDS_FONT(value)   (G_TYPE_CHECK_VALUE_TYPE ((value), \
                                        PIKA_TYPE_FONT))

#define PIKA_TYPE_PARAM_FONT           (pika_param_font_get_type ())
#define PIKA_PARAM_SPEC_FONT(pspec)    (G_TYPE_CHECK_INSTANCE_CAST ((pspec), PIKA_TYPE_PARAM_FONT, PikaParamSpecFont))
#define PIKA_IS_PARAM_SPEC_FONT(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), PIKA_TYPE_PARAM_FONT))

typedef struct _PikaParamSpecFont PikaParamSpecFont;

struct _PikaParamSpecFont
{
  PikaParamSpecResource  parent_instance;
};

GType        pika_param_font_get_type (void) G_GNUC_CONST;

GParamSpec * pika_param_spec_font (const gchar  *name,
                                   const gchar  *nick,
                                   const gchar  *blurb,
                                   gboolean      none_ok,
                                   GParamFlags   flags);


G_END_DECLS

#endif  /*  __LIBPIKA_PIKA_PARAM_SPECS_H__  */
