|  |  |  | GObject Reference Manual |  | 
|---|
| Enums and FlagsEnums and Flags — Enumeration and flags types | 
#include <glib-object.h>
            GEnumClass;
            GFlagsClass;
#define     G_ENUM_CLASS_TYPE               (class)
#define     G_ENUM_CLASS_TYPE_NAME          (class)
#define     G_TYPE_IS_ENUM                  (type)
#define     G_ENUM_CLASS                    (class)
#define     G_IS_ENUM_CLASS                 (class)
#define     G_TYPE_IS_FLAGS                 (type)
#define     G_FLAGS_CLASS                   (class)
#define     G_IS_FLAGS_CLASS                (class)
#define     G_FLAGS_CLASS_TYPE              (class)
#define     G_FLAGS_CLASS_TYPE_NAME         (class)
            GEnumValue;
            GFlagsValue;
GEnumValue* g_enum_get_value                (GEnumClass *enum_class,
                                             gint value);
GEnumValue* g_enum_get_value_by_name        (GEnumClass *enum_class,
                                             const gchar *name);
GEnumValue* g_enum_get_value_by_nick        (GEnumClass *enum_class,
                                             const gchar *nick);
GFlagsValue* g_flags_get_first_value        (GFlagsClass *flags_class,
                                             guint value);
GFlagsValue* g_flags_get_value_by_name      (GFlagsClass *flags_class,
                                             const gchar *name);
GFlagsValue* g_flags_get_value_by_nick      (GFlagsClass *flags_class,
                                             const gchar *nick);
GType       g_enum_register_static          (const gchar *name,
                                             const GEnumValue *const_static_values);
GType       g_flags_register_static         (const gchar *name,
                                             const GFlagsValue *const_static_values);
void        g_enum_complete_type_info       (GType g_enum_type,
                                             GTypeInfo *info,
                                             const GEnumValue *const_values);
void        g_flags_complete_type_info      (GType g_flags_type,
                                             GTypeInfo *info,
                                             const GFlagsValue *const_values);
typedef struct {
  GTypeClass  g_type_class;
  gint	      minimum;
  gint	      maximum;
  guint	      n_values;
  GEnumValue *values;
} GEnumClass;
The class of an enumeration type holds information about its possible values.
| GTypeClass g_type_class; | |
| gint minimum; | the smallest possible value. | 
| gint maximum; | the largest possible value. | 
| guint n_values; | the number of possible values. | 
| GEnumValue * values; | an array of GEnumValue structs describing the individual values. | 
typedef struct {
  GTypeClass   g_type_class;
  
  guint	       mask;
  guint	       n_values;
  GFlagsValue *values;
} GFlagsClass;
The class of a flags type holds information about its possible values.
| GTypeClass g_type_class; | |
| guint mask; | a mask covering all possible values. | 
| guint n_values; | the number of possible values. | 
| GFlagsValue * values; | an array of GFlagsValue structs describing the individual values. | 
#define G_ENUM_CLASS_TYPE(class) (G_TYPE_FROM_CLASS (class))
Returns the type identifier from a given GEnumClass structure.
| class: | a GEnumClass | 
#define G_ENUM_CLASS_TYPE_NAME(class) (g_type_name (G_ENUM_CLASS_TYPE (class)))
Returns the static type name from a given GEnumClass structure.
| class: | a GEnumClass | 
#define G_TYPE_IS_ENUM(type) (G_TYPE_FUNDAMENTAL (type) == G_TYPE_ENUM)
Returns whether type "is a" G_TYPE_ENUM.
| type: | a GType ID. | 
#define G_ENUM_CLASS(class) (G_TYPE_CHECK_CLASS_CAST ((class), G_TYPE_ENUM, GEnumClass))
Casts a derived GEnumClass structure into a GEnumClass structure.
| class: | a valid GEnumClass | 
#define G_IS_ENUM_CLASS(class) (G_TYPE_CHECK_CLASS_TYPE ((class), G_TYPE_ENUM))
Checks whether class "is a" valid GEnumClass structure of type G_TYPE_ENUM
or derived.
| class: | a GEnumClass | 
#define G_TYPE_IS_FLAGS(type) (G_TYPE_FUNDAMENTAL (type) == G_TYPE_FLAGS)
Returns whether type "is a" G_TYPE_FLAGS.
| type: | a GType ID. | 
#define G_FLAGS_CLASS(class) (G_TYPE_CHECK_CLASS_CAST ((class), G_TYPE_FLAGS, GFlagsClass))
Casts a derived GFlagsClass structure into a GFlagsClass structure.
| class: | a valid GFlagsClass | 
#define G_IS_FLAGS_CLASS(class) (G_TYPE_CHECK_CLASS_TYPE ((class), G_TYPE_FLAGS))
Checks whether class "is a" valid GFlagsClass structure of type G_TYPE_FLAGS
or derived.
| class: | a GFlagsClass | 
#define G_FLAGS_CLASS_TYPE(class) (G_TYPE_FROM_CLASS (class))
Returns the type identifier from a given GFlagsClass structure.
| class: | a GFlagsClass | 
#define G_FLAGS_CLASS_TYPE_NAME(class) (g_type_name (G_FLAGS_TYPE (class)))
Returns the static type name from a given GFlagsClass structure.
| class: | a GFlagsClass | 
typedef struct {
  gint	 value;
  gchar *value_name;
  gchar *value_nick;
} GEnumValue;
A structure which contains a single enum value, it's name, and it's nickname.
typedef struct {
  guint	 value;
  gchar *value_name;
  gchar *value_nick;
} GFlagsValue;
A structure which contains a single flags value, it's name, and it's nickname.
GEnumValue* g_enum_get_value (GEnumClass *enum_class, gint value);
Returns the GEnumValue for a value.
| enum_class: | a GEnumClass | 
| value: | the value to look up | 
| Returns : | the GEnumValue for value, orNULLifvalueis not 
a member of the enumeration | 
GEnumValue* g_enum_get_value_by_name (GEnumClass *enum_class, const gchar *name);
Looks up a GEnumValue by name.
| enum_class: | a GEnumClass | 
| name: | the name to look up | 
| Returns : | the GEnumValue with name name, orNULLif the enumeration doesn'
t have a member with that name | 
GEnumValue* g_enum_get_value_by_nick (GEnumClass *enum_class, const gchar *nick);
Looks up a GEnumValue by nickname.
| enum_class: | a GEnumClass | 
| nick: | the nickname to look up | 
| Returns : | the GEnumValue with nickname nick, orNULLif the enumeration doesn'
t have a member with that nickname | 
GFlagsValue* g_flags_get_first_value (GFlagsClass *flags_class, guint value);
Returns the first GFlagsValue which is set in value.
| flags_class: | a GFlagsClass | 
| value: | the value | 
| Returns : | the first GFlagsValue which is set in value, orNULLif none is set | 
GFlagsValue* g_flags_get_value_by_name (GFlagsClass *flags_class, const gchar *name);
Looks up a GFlagsValue by name.
| flags_class: | a GFlagsClass | 
| name: | the name to look up | 
| Returns : | the GFlagsValue with name name, orNULLif there is no flag with
that name | 
GFlagsValue* g_flags_get_value_by_nick (GFlagsClass *flags_class, const gchar *nick);
Looks up a GFlagsValue by nickname.
| flags_class: | a GFlagsClass | 
| nick: | the nickname to look up | 
| Returns : | the GFlagsValue with nickname nick, orNULLif there is no flag
with that nickname | 
GType g_enum_register_static (const gchar *name, const GEnumValue *const_static_values);
Registers a new static enumeration type with the name name. 
It is normally more convenient to let 
glib-mkenums generate a 
my_enum_get_type() function from a usual C enumeration definition
than to write one yourself using g_enum_register_static().
| name: | A nul-terminated string used as the name of the new type. | 
| const_static_values: | An array of GEnumValue structs for the possible enumeration values. The array is terminated by a struct with all members being 0. | 
| Returns : | The new type identifier. | 
GType g_flags_register_static (const gchar *name, const GFlagsValue *const_static_values);
Registers a new static flags type with the name name. 
It is normally more convenient to let 
glib-mkenums generate a 
my_flags_get_type() function from a usual C enumeration definition
than to write one yourself using g_flags_register_static().
| name: | A nul-terminated string used as the name of the new type. | 
| const_static_values: | An array of GFlagsValue structs for the possible flags values. The array is terminated by a struct with all members being 0. | 
| Returns : | The new type identifier. | 
void g_enum_complete_type_info (GType g_enum_type, GTypeInfo *info, const GEnumValue *const_values);
This function is meant to be called from the complete_type_info() function 
of a GTypePlugin implementation, as in the following example:
static void
my_enum_complete_type_info (GTypePlugin     *plugin,
                            GType            g_type,
                            GTypeInfo       *info,
                            GTypeValueTable *value_table)
{
  static const GEnumValue values[] = {
    { MY_ENUM_FOO, "MY_ENUM_FOO", "foo" },
    { MY_ENUM_BAR, "MY_ENUM_BAR", "bar" },
    { 0, NULL, NULL }
  };  
   
  g_enum_complete_type_info (type, info, values);  
}
| g_enum_type: | the type identifier of the type being completed | 
| info: | the GTypeInfo struct to be filled in | 
| const_values: | An array of GEnumValue structs for the possible enumeration values. The array is terminated by a struct with all members being 0. | 
void g_flags_complete_type_info (GType g_flags_type, GTypeInfo *info, const GFlagsValue *const_values);
This function is meant to be called from the complete_type_info() function 
of a GTypePlugin implementation, see the example for 
g_enumeration_complete_type_info() above.
| g_flags_type: | the type identifier of the type being completed | 
| info: | the GTypeInfo struct to be filled in | 
| const_values: | An array of GFlagsValue structs for the possible enumeration values. The array is terminated by a struct with all members being 0. | 
| << GObject | GBoxed >> |