#include <gtk/gtk.h>

/* Since we're trying all possible combinations of a set of discrete values,
 * it's convenient to have "dummy" enum types even for parameters than aren't
 * really enums, e.g. just three different types for a size parameter (very
 * small, medium, very large), in order to take advantage of the GEnumClass
 * for these too.
 */

/* The "detail" paint parameter */

typedef enum {
  GTK_DETAIL_DUMMY_TRY,
  GTK_DETAIL_DUMMY_NULL
} GtkDetailDummyType;

GType
gtk_detail_dummy_get_type (void)
{
  static GType etype = 0;
  if (etype == 0) {
    static const GEnumValue values[] = {
      { GTK_DETAIL_DUMMY_TRY, "GTK_DETAIL_DUMMY_TRY", "Random detail string" },
      { GTK_DETAIL_DUMMY_NULL, "GTK_DETAIL_DUMMY_NULL", "Null string" },
      { 0, NULL, NULL }
    };
    etype = g_enum_register_static ("GtkDetailDummyType", values);
  }
  return etype;
}

#define GTK_DUMMY_TYPE_DETAIL (gtk_detail_dummy_get_type ())

/* The "area" paint parameter */

typedef enum {
  GTK_AREA_DUMMY_SMALL,
  GTK_AREA_DUMMY_MEDIUM,
  GTK_AREA_DUMMY_LARGE,
  GTK_AREA_DUMMY_NULL
} GtkAreaDummyType;

GType
gtk_area_dummy_get_type (void)
{
  static GType etype = 0;
  if (etype == 0) {
    static const GEnumValue values[] = {
      { GTK_AREA_DUMMY_SMALL, "GTK_AREA_DUMMY_SMALL", "Small area size" },
      { GTK_AREA_DUMMY_MEDIUM, "GTK_AREA_DUMMY_MEDIUM", "Medium area size" },
      { GTK_AREA_DUMMY_LARGE, "GTK_AREA_DUMMY_LARGE", "Large area size" },
      { GTK_AREA_DUMMY_NULL, "GTK_AREA_DUMMY_NULL", "Null area" },
      { 0, NULL, NULL }
    };
    etype = g_enum_register_static ("GtkAreaDummyType", values);
  }
  return etype;
}

#define GTK_DUMMY_TYPE_AREA (gtk_area_dummy_get_type ())

/* Any boolean paint parameter */

typedef enum {
  GTK_BOOL_DUMMY_TRUE,
  GTK_BOOL_DUMMY_FALSE
} GtkBoolDummyType;

GType
gtk_bool_dummy_get_type (void)
{
  static GType etype = 0;
  if (etype == 0) {
    static const GEnumValue values[] = {
      { GTK_BOOL_DUMMY_TRUE, "GTK_BOOL_DUMMY_TRUE", "True" },
      { GTK_BOOL_DUMMY_FALSE, "GTK_BOOL_DUMMY_FALSE", "False" },
      { 0, NULL, NULL }
    };
    etype = g_enum_register_static ("GtkBoolDummyType", values);
  }
  return etype;
}

#define GTK_DUMMY_TYPE_BOOL (gtk_bool_dummy_get_type ())

/* The "width" and "height" paint parameters */

typedef enum {
  GTK_SIZE_DUMMY_SMALL,
  GTK_SIZE_DUMMY_MEDIUM,
  GTK_SIZE_DUMMY_LARGE
} GtkSizeDummyType;

GType
gtk_size_dummy_get_type (void)
{
  static GType etype = 0;
  if (etype == 0) {
    static const GEnumValue values[] = {
      { GTK_SIZE_DUMMY_SMALL, "GTK_SIZE_DUMMY_SMALL", "Small size" },
      { GTK_SIZE_DUMMY_MEDIUM, "GTK_SIZE_DUMMY_MEDIUM", "Medium size" },
      { GTK_SIZE_DUMMY_LARGE, "GTK_SIZE_DUMMY_LARGE", "Large size" },
      { 0, NULL, NULL }
    };
    etype = g_enum_register_static ("GtkSizeDummyType", values);
  }
  return etype;
}

#define GTK_DUMMY_TYPE_SIZE (gtk_size_dummy_get_type ())

/* The "Gap x" paint parameter */

typedef enum {
  GTK_GAP_X_DUMMY_SMALL,
  GTK_GAP_X_DUMMY_MEDIUM,
  GTK_GAP_X_DUMMY_LARGE,
} GtkGapXDummyType;

GType
gtk_gap_x_dummy_get_type (void)
{
  static GType etype = 0;
  if (etype == 0) {
    static const GEnumValue values[] = {
      { GTK_GAP_X_DUMMY_SMALL, "GTK_GAP_X_DUMMY_SMALL", "Small X Gap" },
      { GTK_GAP_X_DUMMY_MEDIUM, "GTK_GAP_X_DUMMY_MEDIUM", "Medium X Gap" },
      { GTK_GAP_X_DUMMY_LARGE, "GTK_GAP_X_DUMMY_LARGE", "Large X Gap" },
      { 0, NULL, NULL }
    };
    etype = g_enum_register_static ("GtkGapXDummyType", values);
  }
  return etype;
}

#define GTK_DUMMY_TYPE_GAP_X (gtk_gap_x_dummy_get_type ())

/* The "Gap width" paint parameter */

typedef enum {
  GTK_GAP_WIDTH_DUMMY_SMALL,
  GTK_GAP_WIDTH_DUMMY_MEDIUM,
  GTK_GAP_WIDTH_DUMMY_LARGE,
} GtkGapWidthDummyType;

GType
gtk_gap_width_dummy_get_type (void)
{
  static GType etype = 0;
  if (etype == 0) {
    static const GEnumValue values[] = {
      { GTK_GAP_WIDTH_DUMMY_SMALL, "GTK_GAP_WIDTH_DUMMY_SMALL", "Small Gap width" },
      { GTK_GAP_WIDTH_DUMMY_MEDIUM, "GTK_GAP_WIDTH_DUMMY_MEDIUM", "Medium gap width" },
      { GTK_GAP_WIDTH_DUMMY_LARGE, "GTK_GAP_WIDTH_DUMMY_LARGE", "Large Gap width" },
      { 0, NULL, NULL }
    };
    etype = g_enum_register_static ("GtkGapWidthDummyType", values);
  }
  return etype;
}

#define GTK_DUMMY_TYPE_GAP_WIDTH (gtk_gap_width_dummy_get_type ())

/* The "" paint parameter */

/* Template
typedef enum {
  GTK__DUMMY_TRUE,
  GTK__DUMMY_FALSE
} Gtk.DummyType;

GType
gtk__dummy_get_type (void)
{
  static GType etype = 0;
  if (etype == 0) {
    static const GEnumValue values[] = {
      { GTK__DUMMY_UP, "GTK__DUMMY_", "" },
      { 0, NULL, NULL }
    };
    etype = g_enum_register_static ("Gtk.DummyType", values);
  }
  return etype;
}

#define GTK_DUMMY_TYPE_ (gtk__dummy_get_type ())
*/