gboolean
stetic_param_spec_get_default (GParamSpec *pspec, GValue *value)
{
g_value_init (value, pspec->value_type);
if (G_IS_PARAM_SPEC_CHAR (pspec))
g_value_set_char (value, G_PARAM_SPEC_CHAR (pspec)->default_value);
else if (G_IS_PARAM_SPEC_UCHAR (pspec))
g_value_set_uchar (value, G_PARAM_SPEC_UCHAR (pspec)->default_value);
else if (G_IS_PARAM_SPEC_INT (pspec))
g_value_set_int (value, G_PARAM_SPEC_INT (pspec)->default_value);
else if (G_IS_PARAM_SPEC_UINT (pspec))
g_value_set_uint (value, G_PARAM_SPEC_UINT (pspec)->default_value);
else if (G_IS_PARAM_SPEC_LONG (pspec))
g_value_set_long (value, G_PARAM_SPEC_LONG (pspec)->default_value);
else if (G_IS_PARAM_SPEC_ULONG (pspec))
g_value_set_ulong (value, G_PARAM_SPEC_ULONG (pspec)->default_value);
else if (G_IS_PARAM_SPEC_INT64 (pspec))
g_value_set_int64 (value, G_PARAM_SPEC_INT64 (pspec)->default_value);
else if (G_IS_PARAM_SPEC_UINT64 (pspec))
g_value_set_uint64 (value, G_PARAM_SPEC_UINT64 (pspec)->default_value);
else if (G_IS_PARAM_SPEC_FLOAT (pspec))
g_value_set_float (value, G_PARAM_SPEC_FLOAT (pspec)->default_value);
else if (G_IS_PARAM_SPEC_DOUBLE (pspec))
g_value_set_double (value, G_PARAM_SPEC_DOUBLE (pspec)->default_value);
else if (G_IS_PARAM_SPEC_BOOLEAN (pspec))
g_value_set_boolean (value, G_PARAM_SPEC_BOOLEAN (pspec)->default_value);
else if (G_IS_PARAM_SPEC_UNICHAR (pspec))
g_value_set_uint (value, G_PARAM_SPEC_UNICHAR (pspec)->default_value);
else if (G_IS_PARAM_SPEC_STRING (pspec))
g_value_set_static_string (value, G_PARAM_SPEC_STRING (pspec)->default_value);
else
return FALSE;
return TRUE;
}
gboolean
stetic_param_spec_get_maximum (GParamSpec *pspec, GValue *value)
{
g_value_init (value, pspec->value_type);
if (G_IS_PARAM_SPEC_CHAR (pspec))
g_value_set_char (value, G_PARAM_SPEC_CHAR (pspec)->maximum);
else if (G_IS_PARAM_SPEC_UCHAR (pspec))
g_value_set_uchar (value, G_PARAM_SPEC_UCHAR (pspec)->maximum);
else if (G_IS_PARAM_SPEC_INT (pspec))
g_value_set_int (value, G_PARAM_SPEC_INT (pspec)->maximum);
else if (G_IS_PARAM_SPEC_UINT (pspec))
g_value_set_uint (value, G_PARAM_SPEC_UINT (pspec)->maximum);
else if (G_IS_PARAM_SPEC_LONG (pspec))
g_value_set_long (value, G_PARAM_SPEC_LONG (pspec)->maximum);
else if (G_IS_PARAM_SPEC_ULONG (pspec))
g_value_set_ulong (value, G_PARAM_SPEC_ULONG (pspec)->maximum);
else if (G_IS_PARAM_SPEC_INT64 (pspec))
g_value_set_int64 (value, G_PARAM_SPEC_INT64 (pspec)->maximum);
else if (G_IS_PARAM_SPEC_UINT64 (pspec))
g_value_set_uint64 (value, G_PARAM_SPEC_UINT64 (pspec)->maximum);
else if (G_IS_PARAM_SPEC_FLOAT (pspec))
g_value_set_float (value, G_PARAM_SPEC_FLOAT (pspec)->maximum);
else if (G_IS_PARAM_SPEC_DOUBLE (pspec))
g_value_set_double (value, G_PARAM_SPEC_DOUBLE (pspec)->maximum);
else
return FALSE;
return TRUE;
}
/* XXX Historical note, originally I tried (ab)using override properties
* in ESourceCamel, which redirected to the equivalent CamelSettings
* property. Seemed to work at first, and I was proud of my clever
* hack, but it turns out g_object_class_list_properties() excludes
* override properties. So the ESourceCamel properties were being
* skipped in source_load_from_key_file() (e-source.c). */
static GParamSpec *
param_spec_clone (GParamSpec *pspec)
{
GParamSpec *clone;
GParamFlags flags;
const gchar *name, *nick, *blurb;
name = g_param_spec_get_name (pspec);
nick = g_param_spec_get_nick (pspec);
blurb = g_param_spec_get_blurb (pspec);
flags = (pspec->flags & ~(G_PARAM_STATIC_STRINGS));
if (G_IS_PARAM_SPEC_BOOLEAN (pspec)) {
GParamSpecBoolean *pspec_boolean = G_PARAM_SPEC_BOOLEAN (pspec);
clone = g_param_spec_boolean (name, nick, blurb,
pspec_boolean->default_value,
flags);
} else if (G_IS_PARAM_SPEC_CHAR (pspec)) {
GParamSpecChar *pspec_char = G_PARAM_SPEC_CHAR (pspec);
clone = g_param_spec_char (name, nick, blurb,
pspec_char->minimum,
pspec_char->maximum,
pspec_char->default_value,
flags);
} else if (G_IS_PARAM_SPEC_UCHAR (pspec)) {
GParamSpecUChar *pspec_uchar = G_PARAM_SPEC_UCHAR (pspec);
clone = g_param_spec_uchar (name, nick, blurb,
pspec_uchar->minimum,
pspec_uchar->maximum,
pspec_uchar->default_value,
flags);
} else if (G_IS_PARAM_SPEC_INT (pspec)) {
GParamSpecInt *pspec_int = G_PARAM_SPEC_INT (pspec);
clone = g_param_spec_int (name, nick, blurb,
pspec_int->minimum,
pspec_int->maximum,
pspec_int->default_value,
flags);
} else if (G_IS_PARAM_SPEC_UINT (pspec)) {
GParamSpecUInt *pspec_uint = G_PARAM_SPEC_UINT (pspec);
clone = g_param_spec_uint (name, nick, blurb,
pspec_uint->minimum,
pspec_uint->maximum,
pspec_uint->default_value,
flags);
} else if (G_IS_PARAM_SPEC_LONG (pspec)) {
GParamSpecLong *pspec_long = G_PARAM_SPEC_LONG (pspec);
clone = g_param_spec_long (name, nick, blurb,
pspec_long->minimum,
pspec_long->maximum,
pspec_long->default_value,
flags);
} else if (G_IS_PARAM_SPEC_ULONG (pspec)) {
GParamSpecULong *pspec_ulong = G_PARAM_SPEC_ULONG (pspec);
clone = g_param_spec_ulong (name, nick, blurb,
pspec_ulong->minimum,
pspec_ulong->maximum,
pspec_ulong->default_value,
flags);
} else if (G_IS_PARAM_SPEC_INT64 (pspec)) {
GParamSpecInt64 *pspec_int64 = G_PARAM_SPEC_INT64 (pspec);
clone = g_param_spec_int64 (name, nick, blurb,
pspec_int64->minimum,
pspec_int64->maximum,
pspec_int64->default_value,
flags);
} else if (G_IS_PARAM_SPEC_UINT64 (pspec)) {
GParamSpecUInt64 *pspec_uint64 = G_PARAM_SPEC_UINT64 (pspec);
clone = g_param_spec_uint64 (name, nick, blurb,
pspec_uint64->minimum,
pspec_uint64->maximum,
pspec_uint64->default_value,
flags);
} else if (G_IS_PARAM_SPEC_FLOAT (pspec)) {
GParamSpecFloat *pspec_float = G_PARAM_SPEC_FLOAT (pspec);
clone = g_param_spec_float (name, nick, blurb,
pspec_float->minimum,
pspec_float->maximum,
pspec_float->default_value,
flags);
} else if (G_IS_PARAM_SPEC_DOUBLE (pspec)) {
GParamSpecDouble *pspec_double = G_PARAM_SPEC_DOUBLE (pspec);
clone = g_param_spec_double (name, nick, blurb,
pspec_double->minimum,
pspec_double->maximum,
pspec_double->default_value,
flags);
} else if (G_IS_PARAM_SPEC_ENUM (pspec)) {
GParamSpecEnum *pspec_enum = G_PARAM_SPEC_ENUM (pspec);
clone = g_param_spec_enum (name, nick, blurb,
pspec->value_type,
pspec_enum->default_value,
flags);
} else if (G_IS_PARAM_SPEC_FLAGS (pspec)) {
GParamSpecFlags *pspec_flags = G_PARAM_SPEC_FLAGS (pspec);
clone = g_param_spec_flags (name, nick, blurb,
pspec->value_type,
pspec_flags->default_value,
flags);
} else if (G_IS_PARAM_SPEC_STRING (pspec)) {
GParamSpecString *pspec_string = G_PARAM_SPEC_STRING (pspec);
clone = g_param_spec_string (name, nick, blurb,
pspec_string->default_value,
flags);
} else if (G_IS_PARAM_SPEC_PARAM (pspec)) {
clone = g_param_spec_param (name, nick, blurb,
pspec->value_type,
flags);
} else if (G_IS_PARAM_SPEC_BOXED (pspec)) {
clone = g_param_spec_boxed (name, nick, blurb,
pspec->value_type,
flags);
} else if (G_IS_PARAM_SPEC_POINTER (pspec)) {
clone = g_param_spec_pointer (name, nick, blurb, flags);
} else if (G_IS_PARAM_SPEC_OBJECT (pspec)) {
clone = g_param_spec_object (name, nick, blurb,
pspec->value_type,
flags);
} else if (G_IS_PARAM_SPEC_UNICHAR (pspec)) {
GParamSpecUnichar *pspec_unichar = G_PARAM_SPEC_UNICHAR (pspec);
clone = g_param_spec_unichar (name, nick, blurb,
pspec_unichar->default_value,
flags);
} else if (G_IS_PARAM_SPEC_GTYPE (pspec)) {
GParamSpecGType *pspec_gtype = G_PARAM_SPEC_GTYPE (pspec);
clone = g_param_spec_gtype (name, nick, blurb,
pspec_gtype->is_a_type,
flags);
} else if (G_IS_PARAM_SPEC_VARIANT (pspec)) {
GParamSpecVariant *pspec_variant = G_PARAM_SPEC_VARIANT (pspec);
clone = g_param_spec_variant (name, nick, blurb,
pspec_variant->type,
pspec_variant->default_value,
flags);
} else {
g_warn_if_reached ();
}
return clone;
}
/* --- test functions --- */
static void
pspec_select_value (GParamSpec *pspec,
GValue *value,
double dvalue)
{
/* generate a value suitable for pspec */
if (G_IS_PARAM_SPEC_CHAR (pspec))
ASSIGN_VALUE (g_value_set_char, value, GParamSpecChar*, pspec, default_value, minimum, maximum, dvalue);
else if (G_IS_PARAM_SPEC_UCHAR (pspec))
ASSIGN_VALUE (g_value_set_uchar, value, GParamSpecUChar*, pspec, default_value, minimum, maximum, dvalue);
else if (G_IS_PARAM_SPEC_INT (pspec))
ASSIGN_VALUE (g_value_set_int, value, GParamSpecInt*, pspec, default_value, minimum, maximum, dvalue);
else if (G_IS_PARAM_SPEC_UINT (pspec))
ASSIGN_VALUE (g_value_set_uint, value, GParamSpecUInt*, pspec, default_value, minimum, maximum, dvalue);
else if (G_IS_PARAM_SPEC_LONG (pspec))
ASSIGN_VALUE (g_value_set_long, value, GParamSpecLong*, pspec, default_value, minimum, maximum, dvalue);
else if (G_IS_PARAM_SPEC_ULONG (pspec))
ASSIGN_VALUE (g_value_set_ulong, value, GParamSpecULong*, pspec, default_value, minimum, maximum, dvalue);
else if (G_IS_PARAM_SPEC_INT64 (pspec))
ASSIGN_VALUE (g_value_set_int64, value, GParamSpecInt64*, pspec, default_value, minimum, maximum, dvalue);
else if (G_IS_PARAM_SPEC_UINT64 (pspec))
ASSIGN_VALUE (g_value_set_uint64, value, GParamSpecUInt64*, pspec, default_value, minimum, maximum, dvalue);
else if (G_IS_PARAM_SPEC_FLOAT (pspec))
ASSIGN_VALUE (g_value_set_float, value, GParamSpecFloat*, pspec, default_value, minimum, maximum, dvalue);
else if (G_IS_PARAM_SPEC_DOUBLE (pspec))
ASSIGN_VALUE (g_value_set_double, value, GParamSpecDouble*, pspec, default_value, minimum, maximum, dvalue);
else if (G_IS_PARAM_SPEC_BOOLEAN (pspec))
g_value_set_boolean (value, SELECT_VALUE (dvalue, ((GParamSpecBoolean*) pspec)->default_value, FALSE, TRUE));
else if (G_IS_PARAM_SPEC_UNICHAR (pspec))
g_value_set_uint (value, SELECT_VALUE (dvalue, ((GParamSpecUnichar*) pspec)->default_value, FALSE, TRUE));
else if (G_IS_PARAM_SPEC_GTYPE (pspec))
g_value_set_gtype (value, SELECT_VALUE ((int) dvalue, ((GParamSpecGType*) pspec)->is_a_type, 0, GTK_TYPE_WIDGET));
else if (G_IS_PARAM_SPEC_STRING (pspec))
{
GParamSpecString *sspec = (GParamSpecString*) pspec;
if (dvalue >= +2)
g_value_set_string (value, sspec->default_value);
if (dvalue > 0 && sspec->cset_first && sspec->cset_nth)
g_value_take_string (value, g_strdup_printf ("%c%c", sspec->cset_first[0], sspec->cset_nth[0]));
else /* if (sspec->ensure_non_null) */
g_value_set_string (value, "");
}
else if (G_IS_PARAM_SPEC_ENUM (pspec))
{
GParamSpecEnum *espec = (GParamSpecEnum*) pspec;
if (dvalue >= +2)
g_value_set_enum (value, espec->default_value);
if (dvalue >= 0 && dvalue <= 1)
g_value_set_enum (value, espec->enum_class->values[(int) ((espec->enum_class->n_values - 1) * dvalue)].value);
else if (dvalue <= -1)
g_value_set_enum (value, espec->enum_class->values[g_test_rand_int_range (0, espec->enum_class->n_values)].value);
}
else if (G_IS_PARAM_SPEC_FLAGS (pspec))
{
GParamSpecFlags *fspec = (GParamSpecFlags*) pspec;
if (dvalue >= +2)
g_value_set_flags (value, fspec->default_value);
if (dvalue >= 0 && dvalue <= 1)
g_value_set_flags (value, fspec->flags_class->values[(int) ((fspec->flags_class->n_values - 1) * dvalue)].value);
else if (dvalue <= -1)
g_value_set_flags (value, fspec->flags_class->values[g_test_rand_int_range (0, fspec->flags_class->n_values)].value);
}
/* unimplemented:
* G_IS_PARAM_SPEC_PARAM
* G_IS_PARAM_SPEC_BOXED
* G_IS_PARAM_SPEC_POINTER
* G_IS_PARAM_SPEC_VALUE_ARRAY
* G_IS_PARAM_SPEC_OBJECT
*/
}
void
qof_gobject_register (QofType e_type, GObjectClass *obclass)
{
int i;
int j;
QofParam *qof_param_list, *qpar;
QofObject *class_def;
GParamSpec **prop_list, *gparam;
guint n_props;
/* Get the GObject properties, convert to QOF properties */
prop_list = g_object_class_list_properties (obclass, &n_props);
qof_param_list = g_new0 (QofParam, n_props);
paramList = g_slist_prepend (paramList, qof_param_list);
PINFO ("object %s has %d props", e_type, n_props);
j = 0;
for (i = 0; i < n_props; i++)
{
gparam = prop_list[i];
qpar = &qof_param_list[j];
PINFO ("param %d %s is type %s",
i, gparam->name, G_PARAM_SPEC_TYPE_NAME(gparam));
qpar->param_name = g_param_spec_get_name (gparam);
qpar->param_getfcn = (QofAccessFunc)qof_gobject_getter;
qpar->param_setfcn = NULL;
qpar->param_userdata = gparam;
if ((G_IS_PARAM_SPEC_INT(gparam)) ||
(G_IS_PARAM_SPEC_UINT(gparam)) ||
(G_IS_PARAM_SPEC_ENUM(gparam)) ||
(G_IS_PARAM_SPEC_FLAGS(gparam)))
{
qpar->param_type = QOF_TYPE_INT32;
j++;
}
else if ((G_IS_PARAM_SPEC_INT64(gparam)) ||
(G_IS_PARAM_SPEC_UINT64(gparam)))
{
qpar->param_type = QOF_TYPE_INT64;
j++;
}
else if (G_IS_PARAM_SPEC_BOOLEAN(gparam))
{
qpar->param_type = QOF_TYPE_BOOLEAN;
j++;
}
else if (G_IS_PARAM_SPEC_STRING(gparam))
{
qpar->param_type = QOF_TYPE_STRING;
j++;
}
else if ((G_IS_PARAM_SPEC_POINTER(gparam)) ||
(G_IS_PARAM_SPEC_OBJECT(gparam)))
{
/* No-op, silently ignore. Someday we should handle this ... */
}
else if ((G_IS_PARAM_SPEC_FLOAT(gparam)) ||
(G_IS_PARAM_SPEC_DOUBLE(gparam)))
{
qpar->param_getfcn = (QofAccessFunc) qof_gobject_double_getter;
qpar->param_type = QOF_TYPE_DOUBLE;
j++;
}
else if (G_IS_PARAM_SPEC_CHAR(gparam))
{
qpar->param_type = QOF_TYPE_CHAR;
j++;
}
else
{
PWARN ("Unknown/unhandled parameter type %s on %s:%s\n",
G_PARAM_SPEC_TYPE_NAME(gparam), e_type, qpar->param_name);
}
}
/* NULL-terminated list! */
qof_param_list[j].param_type = NULL;
qof_class_register (e_type, NULL, qof_param_list);
/* ------------------------------------------------------ */
/* Now do the class itself */
class_def = g_new0 (QofObject, 1);
classList = g_slist_prepend (classList, class_def);
class_def->interface_version = QOF_OBJECT_VERSION;
class_def->e_type = e_type;
/* We could let the user specify a "nick" here, but
* the actual class name seems reasonable, e.g. for debugging. */
class_def->type_label = G_OBJECT_CLASS_NAME (obclass);
class_def->create = NULL;
class_def->book_begin = NULL;
class_def->book_end = NULL;
class_def->is_dirty = NULL;
class_def->mark_clean = NULL;
class_def->foreach = qof_gobject_foreach;
class_def->printable = NULL;
class_def->version_cmp = NULL;
qof_object_register (class_def);
}