void
ags_recall_container_get_property(GObject *gobject,
guint prop_id,
GValue *value,
GParamSpec *param_spec)
{
AgsRecallContainer *recall_container;
recall_container = AGS_RECALL_CONTAINER(gobject);
switch(prop_id){
case PROP_RECALL_AUDIO_TYPE:
g_value_set_gtype(value, recall_container->recall_audio_type);
break;
case PROP_RECALL_AUDIO_RUN_TYPE:
g_value_set_gtype(value, recall_container->recall_audio_run_type);
break;
case PROP_RECALL_CHANNEL_TYPE:
g_value_set_gtype(value, recall_container->recall_channel_type);
break;
case PROP_RECALL_CHANNEL_RUN_TYPE:
g_value_set_gtype(value, recall_container->recall_channel_run_type);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(gobject, prop_id, param_spec);
break;
}
}
/**
* gom_command_builder_get_property:
* @object: (in): A #GObject.
* @prop_id: (in): The property identifier.
* @value: (out): The given property.
* @pspec: (in): A #ParamSpec.
*
* Get a given #GObject property.
*/
static void
gom_command_builder_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GomCommandBuilder *builder = GOM_COMMAND_BUILDER(object);
switch (prop_id) {
case PROP_ADAPTER:
g_value_set_object(value, builder->priv->adapter);
break;
case PROP_FILTER:
g_value_set_object(value, builder->priv->filter);
break;
case PROP_LIMIT:
g_value_set_uint(value, builder->priv->limit);
break;
case PROP_M2M_TABLE:
g_value_set_string(value, builder->priv->m2m_table);
break;
case PROP_M2M_TYPE:
g_value_set_gtype(value, builder->priv->m2m_type);
break;
case PROP_OFFSET:
g_value_set_uint(value, builder->priv->offset);
break;
case PROP_RESOURCE_TYPE:
g_value_set_gtype(value, builder->priv->resource_type);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
}
}
static void
web_service_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
WebService *self = WEB_SERVICE (object);
switch (property_id) {
case PROP_SERVICE_NAME:
g_value_set_string (value, self->priv->service_name);
break;
case PROP_SERVICE_ADDRESS:
g_value_set_string (value, self->priv->service_address);
break;
case PROP_SERVICE_PROTOCOL:
g_value_set_string (value, self->priv->service_protocol);
break;
case PROP_ACCOUNT_TYPE:
g_value_set_gtype (value, self->priv->account_type);
break;
case PROP_CANCELLABLE:
g_value_set_object (value, self->priv->cancellable);
break;
case PROP_BROWSER:
g_value_set_pointer (value, self->priv->browser);
break;
case PROP_DIALOG:
g_value_set_pointer (value, self->priv->dialog);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
nmt_device_entry_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
NmtDeviceEntryPrivate *priv = NMT_DEVICE_ENTRY_GET_PRIVATE (object);
switch (prop_id) {
case PROP_LABEL:
g_value_set_string (value, priv->label);
break;
case PROP_WIDTH:
g_value_set_int (value, nmt_newt_entry_get_width (priv->entry));
break;
case PROP_HARDWARE_TYPE:
g_value_set_gtype (value, priv->hardware_type);
break;
case PROP_INTERFACE_NAME:
g_value_set_string (value, priv->interface_name);
break;
case PROP_MAC_ADDRESS:
g_value_set_string (value, priv->mac_address);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
catch_resource_group_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
CatchResourceGroup *group = CATCH_RESOURCE_GROUP(object);
switch (prop_id) {
case PROP_COUNT:
g_value_set_uint(value, group->priv->count);
break;
case PROP_FILTER:
g_value_set_object(value, group->priv->filter);
break;
case PROP_GROUP:
g_value_set_object(value, group->priv->group);
break;
case PROP_RESOURCE_TYPE:
g_value_set_gtype(value, group->priv->resource_type);
break;
case PROP_SESSION:
g_value_set_object(value, group->priv->session);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
}
}
static void
mex_proxy_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
MexProxy *proxy = MEX_PROXY (object);
switch (property_id)
{
case PROP_MODEL:
g_value_set_object (value, mex_proxy_get_model (proxy));
break;
case PROP_TYPE:
g_value_set_gtype (value, mex_proxy_get_object_type (proxy));
break;
case PROP_LIMIT:
g_value_set_uint (value, mex_proxy_get_limit (proxy));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}
}
static void
gdaui_numeric_entry_get_property (GObject *object,
guint param_id,
GValue *value,
GParamSpec *pspec)
{
GdauiNumericEntry *entry;
entry = GDAUI_NUMERIC_ENTRY (object);
if (entry->priv) {
switch (param_id) {
case PROP_TYPE:
g_value_set_gtype (value, entry->priv->type);
break;
case PROP_N_DECIMALS:
g_value_set_uint (value, entry->priv->nb_decimals);
break;
case PROP_DECIMAL_SEP:
g_value_set_schar (value, (gint8) entry->priv->decimal_sep);
break;
case PROP_THOUSANDS_SEP:
g_value_set_schar (value, (gint8) entry->priv->thousands_sep);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
break;
}
}
}
static void
gtk_css_node_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
GtkCssNode *cssnode = GTK_CSS_NODE (object);
switch (property_id)
{
case PROP_CLASSES:
g_value_take_boxed (value, gtk_css_node_get_classes (cssnode));
break;
case PROP_ID:
g_value_set_string (value, gtk_css_node_get_id (cssnode));
break;
case PROP_STATE:
g_value_set_flags (value, gtk_css_node_get_state (cssnode));
break;
case PROP_VISIBLE:
g_value_set_boolean (value, gtk_css_node_get_visible (cssnode));
break;
case PROP_WIDGET_TYPE:
g_value_set_gtype (value, gtk_css_node_get_widget_type (cssnode));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}
}
static void
test_param_spec_gtype (void)
{
GParamSpec *pspec;
GValue value = { 0, };
gboolean modified;
pspec = g_param_spec_gtype ("gtype", "nick", "blurb",
G_TYPE_PARAM, G_PARAM_READWRITE);
g_value_init (&value, G_TYPE_GTYPE);
g_value_set_gtype (&value, G_TYPE_PARAM);
g_assert (g_param_value_defaults (pspec, &value));
g_value_set_gtype (&value, G_TYPE_INT);
modified = g_param_value_validate (pspec, &value);
g_assert (modified && g_value_get_gtype (&value) == G_TYPE_PARAM);
g_value_set_gtype (&value, G_TYPE_PARAM_INT);
modified = g_param_value_validate (pspec, &value);
g_assert (!modified && g_value_get_gtype (&value) == G_TYPE_PARAM_INT);
}
/**
* transform_hash_entry_to_gparameter: (skip)
* @key: #gpointer to the key value of the hash entry
* @value: #gpointer to the value of the hash entry
* @parameter: (out caller-allocates): Pointer to the #GParameter where key and value
* should be filled into
*
* Takes a Key/Value pair from a #GHashTable and puts its values into the given
* #GParameter.
* Note that this function uses g_strdup() to set the #GParameters name value. This
* needs to be cleaned up by the caller using g_free()
*
* Since: 1.7
*/
static void
transform_hash_entry_to_gparameter (gpointer key,
gpointer value,
ParamArray *params)
{
GParameter *parameter = &(params->p[params->idx]);
if (value)
parameter->value = *((GValue*)value);
else
g_value_set_gtype (&(parameter->value), G_TYPE_NONE);
parameter->name = g_strdup ((const gchar*)key);
params->idx++;
}
static void
ibus_server_get_property (IBusServer *server,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
IBusServerPrivate *priv;
priv = IBUS_SERVER_GET_PRIVATE (server);
switch (prop_id) {
case PROP_CONNECTION_TYPE:
g_value_set_gtype (value, priv->connection_type);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (server, prop_id, pspec);
}
}
/* GObject virtual methods implementation */
static void
ges_asset_get_property (GObject * object, guint property_id,
GValue * value, GParamSpec * pspec)
{
GESAsset *asset = GES_ASSET (object);
switch (property_id) {
case PROP_TYPE:
g_value_set_gtype (value, asset->priv->extractable_type);
break;
case PROP_ID:
g_value_set_string (value, asset->priv->id);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}
}
static void
gnm_font_button_get_property (GObject *object,
guint param_id,
GValue *value,
GParamSpec *pspec)
{
GnmFontButton *font_button = GNM_FONT_BUTTON (object);
switch (param_id)
{
case GTK_FONT_CHOOSER_PROP_PREVIEW_TEXT:
g_value_set_string (value, gnm_font_button_get_preview_text (font_button));
break;
case GTK_FONT_CHOOSER_PROP_SHOW_PREVIEW_ENTRY:
g_value_set_boolean (value, gnm_font_button_get_show_preview_entry (font_button));
break;
case PROP_TITLE:
g_value_set_string (value, gnm_font_button_get_title (font_button));
break;
case GTK_FONT_CHOOSER_PROP_FONT_DESC:
g_value_set_boxed (value, gnm_font_button_get_font_desc (font_button));
break;
case GTK_FONT_CHOOSER_PROP_FONT:
case PROP_FONT_NAME:
g_value_set_string (value, gnm_font_button_get_font_name (font_button));
break;
case PROP_USE_FONT:
g_value_set_boolean (value, gnm_font_button_get_use_font (font_button));
break;
case PROP_USE_SIZE:
g_value_set_boolean (value, gnm_font_button_get_use_size (font_button));
break;
case PROP_SHOW_STYLE:
g_value_set_boolean (value, gnm_font_button_get_show_style (font_button));
break;
case PROP_SHOW_SIZE:
g_value_set_boolean (value, gnm_font_button_get_show_size (font_button));
break;
case PROP_DIALOG_TYPE:
g_value_set_gtype (value, font_button->priv->dialog_type);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
break;
}
}
static void
gimp_int_store_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
GimpIntStorePrivate *priv = GIMP_INT_STORE_GET_PRIVATE (object);
switch (property_id)
{
case PROP_USER_DATA_TYPE:
g_value_set_gtype (value, priv->user_data_type);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
test_gtype_value (void)
{
GType type;
GValue value = { 0, };
GValue copy = { 0, };
g_value_init (&value, G_TYPE_GTYPE);
g_value_set_gtype (&value, G_TYPE_BOXED);
type = g_value_get_gtype (&value);
g_assert (type == G_TYPE_BOXED);
g_value_init (©, G_TYPE_GTYPE);
g_value_copy (&value, ©);
type = g_value_get_gtype (©);
g_assert (type == G_TYPE_BOXED);
}
void
ags_link_collection_editor_get_property(GObject *gobject,
guint prop_id,
GValue *value,
GParamSpec *param_spec)
{
AgsLinkCollectionEditor *link_collection_editor;
link_collection_editor = AGS_LINK_COLLECTION_EDITOR(gobject);
switch(prop_id){
case PROP_CHANNEL_TYPE:
g_value_set_gtype(value, link_collection_editor->channel_type);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(gobject, prop_id, param_spec);
break;
}
}
static void
peas_extension_set_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
PeasExtensionSet *set = PEAS_EXTENSION_SET (object);
switch (prop_id)
{
case PROP_ENGINE:
g_value_set_object (value, set->priv->engine);
break;
case PROP_EXTENSION_TYPE:
g_value_set_gtype (value, set->priv->exten_type);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void
moto_enum_store_get_property(GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
MotoEnumStore *store = MOTO_ENUM_STORE(object);
switch (property_id)
{
case PROP_ENUM_TYPE:
g_value_set_gtype(value, (store->enum_class ?
G_TYPE_FROM_CLASS (store->enum_class) :
G_TYPE_NONE));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
break;
}
}
static void
gtk_style_property_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GtkStyleProperty *property = GTK_STYLE_PROPERTY (object);
switch (prop_id)
{
case PROP_NAME:
g_value_set_string (value, property->name);
break;
case PROP_VALUE_TYPE:
g_value_set_gtype (value, property->value_type);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void ovirt_collection_get_property(GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
OvirtCollection *collection = OVIRT_COLLECTION(object);
switch (prop_id) {
case PROP_HREF:
g_value_set_string(value, collection->priv->href);
break;
case PROP_RESOURCE_TYPE:
g_value_set_gtype(value, collection->priv->resource_type);
break;
case PROP_RESOURCES:
g_value_set_boxed(value, collection->priv->resources);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
break;
}
}
static void
mx_list_view_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
MxListViewPrivate *priv = MX_LIST_VIEW (object)->priv;
switch (property_id)
{
case PROP_MODEL:
g_value_set_object (value, priv->model);
break;
case PROP_ITEM_TYPE:
g_value_set_gtype (value, priv->item_type);
break;
case PROP_FACTORY:
g_value_set_object (value, priv->factory);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}
}
static void
impl_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
{
RBDisplayPageMenu *menu = RB_DISPLAY_PAGE_MENU (object);
switch (prop_id) {
case PROP_MODEL:
g_value_set_object (value, menu->priv->model);
break;
case PROP_ROOT_PAGE:
g_value_set_object (value, menu->priv->root_page);
break;
case PROP_PAGE_TYPE:
g_value_set_gtype (value, menu->priv->page_type);
break;
case PROP_ACTION:
g_value_set_string (value, menu->priv->action);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
void
ags_port_get_property(GObject *gobject,
guint prop_id,
GValue *value,
GParamSpec *param_spec)
{
AgsPort *port;
port = AGS_PORT(gobject);
switch(prop_id){
case PROP_PLUGIN_NAME:
g_value_set_string(value, port->plugin_name);
break;
case PROP_SPECIFIER:
g_value_set_string(value, port->specifier);
break;
case PROP_CONTROL_PORT:
g_value_set_string(value, port->control_port);
break;
case PROP_PORT_VALUE_IS_POINTER:
g_value_set_boolean(value, port->port_value_is_pointer);
break;
case PROP_PORT_VALUE_TYPE:
g_value_set_gtype(value, port->port_value_type);
break;
case PROP_PORT_VALUE_SIZE:
g_value_set_uint(value, port->port_value_size);
break;
case PROP_PORT_VALUE_LENGTH:
g_value_set_uint(value, port->port_value_length);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(gobject, prop_id, param_spec);
break;
}
}
void g_sql_result_get_property(GObject *object, guint property_id,GValue *value, GParamSpec *pspec)
{
GSQLResult * mobj = (GSQLResult*) object;
g_return_if_fail(IS_G_SQL_RESULT(mobj));
switch (property_id)
{
case G_SQL_RESULT_PROPERTY_TYPE:
g_value_set_gtype(value, mobj->connector_type);
break;
case G_SQL_RESULT_PROPERTY_TYPE_INSTANCE:
g_value_set_object(value, mobj->connector);
break;
case G_SQL_RESULT_PROPERTY_RESULT:
g_value_set_pointer(value, mobj->result);
break;
case G_SQL_RESULT_PROPERTY_FIELDS:
g_value_set_int(value,mobj->fields);
break;
default:
g_warn_if_reached();
break;
}
}
static void
byzanz_session_get_property (GObject *object, guint param_id, GValue *value,
GParamSpec * pspec)
{
ByzanzSession *session = BYZANZ_SESSION (object);
switch (param_id) {
case PROP_ERROR:
g_value_set_pointer (value, session->error);
break;
case PROP_RECORDING:
g_value_set_boolean (value, byzanz_session_is_recording (session));
break;
case PROP_ENCODING:
g_value_set_boolean (value, byzanz_session_is_encoding (session));
break;
case PROP_FILE:
g_value_set_object (value, session->file);
break;
case PROP_AREA:
g_value_set_boxed (value, &session->area);
break;
case PROP_WINDOW:
g_value_set_object (value, session->window);
break;
case PROP_AUDIO:
g_value_set_boolean (value, session->record_audio);
break;
case PROP_ENCODER_TYPE:
g_value_set_gtype (value, session->encoder_type);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
break;
}
}
/* --- 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
*/
}
gint
pygi_set_property_value_real (PyGObject *instance,
const gchar *attr_name,
PyObject *py_value)
{
GType g_type;
GIPropertyInfo *property_info = NULL;
char *property_name = g_strdup (attr_name);
GITypeInfo *type_info = NULL;
GITypeTag type_tag;
GITransfer transfer;
GValue value = { 0, };
GIArgument arg = { 0, };
GParamSpec *pspec = NULL;
gint ret_value = -1;
canonicalize_key (property_name);
g_type = pyg_type_from_object ((PyObject *)instance);
property_info = _pygi_lookup_property_from_g_type (g_type, property_name);
if (property_info == NULL)
goto out;
pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (instance->obj),
attr_name);
if (pspec == NULL)
goto out;
if (! (pspec->flags & G_PARAM_WRITABLE))
goto out;
type_info = g_property_info_get_type (property_info);
transfer = g_property_info_get_ownership_transfer (property_info);
arg = _pygi_argument_from_object (py_value, type_info, transfer);
if (PyErr_Occurred())
goto out;
g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (pspec));
// FIXME: Lots of types still unhandled
type_tag = g_type_info_get_tag (type_info);
switch (type_tag) {
case GI_TYPE_TAG_INTERFACE:
{
GIBaseInfo *info;
GIInfoType info_type;
GType type;
info = g_type_info_get_interface (type_info);
type = g_registered_type_info_get_g_type (info);
info_type = g_base_info_get_type (info);
g_base_info_unref (info);
switch (info_type) {
case GI_INFO_TYPE_ENUM:
g_value_set_enum (&value, arg.v_int32);
break;
case GI_INFO_TYPE_INTERFACE:
case GI_INFO_TYPE_OBJECT:
g_value_set_object (&value, arg.v_pointer);
break;
case GI_INFO_TYPE_BOXED:
case GI_INFO_TYPE_STRUCT:
case GI_INFO_TYPE_UNION:
if (g_type_is_a (type, G_TYPE_BOXED)) {
g_value_set_boxed (&value, arg.v_pointer);
} else {
PyErr_Format (PyExc_NotImplementedError,
"Setting properties of type '%s' is not implemented",
g_type_name (type));
}
break;
default:
PyErr_Format (PyExc_NotImplementedError,
"Setting properties of type '%s' is not implemented",
g_type_name (type));
goto out;
}
break;
}
case GI_TYPE_TAG_BOOLEAN:
g_value_set_boolean (&value, arg.v_boolean);
break;
case GI_TYPE_TAG_INT8:
g_value_set_schar (&value, arg.v_int8);
break;
case GI_TYPE_TAG_INT16:
case GI_TYPE_TAG_INT32:
if (G_VALUE_HOLDS_LONG (&value))
g_value_set_long (&value, arg.v_long);
else
g_value_set_int (&value, arg.v_int);
break;
case GI_TYPE_TAG_INT64:
if (G_VALUE_HOLDS_LONG (&value))
g_value_set_long (&value, arg.v_long);
else
g_value_set_int64 (&value, arg.v_int64);
break;
case GI_TYPE_TAG_UINT8:
g_value_set_uchar (&value, arg.v_uint8);
break;
case GI_TYPE_TAG_UINT16:
case GI_TYPE_TAG_UINT32:
if (G_VALUE_HOLDS_ULONG (&value))
g_value_set_ulong (&value, arg.v_ulong);
else
g_value_set_uint (&value, arg.v_uint);
break;
case GI_TYPE_TAG_UINT64:
if (G_VALUE_HOLDS_ULONG (&value))
g_value_set_ulong (&value, arg.v_ulong);
else
g_value_set_uint64 (&value, arg.v_uint64);
break;
case GI_TYPE_TAG_FLOAT:
g_value_set_float (&value, arg.v_float);
break;
case GI_TYPE_TAG_DOUBLE:
g_value_set_double (&value, arg.v_double);
break;
case GI_TYPE_TAG_GTYPE:
g_value_set_gtype (&value, arg.v_size);
break;
case GI_TYPE_TAG_UTF8:
case GI_TYPE_TAG_FILENAME:
g_value_set_string (&value, arg.v_string);
break;
case GI_TYPE_TAG_GHASH:
g_value_set_boxed (&value, arg.v_pointer);
break;
case GI_TYPE_TAG_GLIST:
g_value_set_pointer (&value, arg.v_pointer);
break;
case GI_TYPE_TAG_ARRAY:
{
GArray *arg_items = (GArray*) arg.v_pointer;
gchar** strings;
int i;
if (arg_items == NULL)
goto out;
strings = g_new0 (char*, arg_items->len);
for (i = 0; i < arg_items->len; ++i) {
strings[i] = g_array_index (arg_items, GIArgument, i).v_string;
}
g_array_free (arg_items, TRUE);
g_value_set_boxed (&value, strings);
break;
}
default:
PyErr_Format (PyExc_NotImplementedError,
"Setting properties of type %s is not implemented",
g_type_tag_to_string (g_type_info_get_tag (type_info)));
goto out;
}
g_object_set_property (instance->obj, attr_name, &value);
ret_value = 0;
out:
g_free (property_name);
if (property_info != NULL)
g_base_info_unref (property_info);
if (type_info != NULL)
g_base_info_unref (type_info);
return ret_value;
}
void
gy_value_set_iarg(GValue* pval, GITypeInfo * info, int iarg)
{
GY_DEBUG("in gy_value_set_iarg\n");
GITypeTag type = g_type_info_get_tag(info);
GIBaseInfo * itrf;
switch (type) {
case GI_TYPE_TAG_BOOLEAN:
g_value_set_boolean(pval, ygets_c(iarg));
break;
case GI_TYPE_TAG_INT8:
g_value_set_schar(pval, ygets_c(iarg));
break;
case GI_TYPE_TAG_UINT8:
g_value_set_uchar(pval, ygets_c(iarg));
break;
case GI_TYPE_TAG_INT16:
case GI_TYPE_TAG_INT32:
g_value_set_int(pval, ygets_i(iarg));
break;
case GI_TYPE_TAG_UINT16:
case GI_TYPE_TAG_UINT32:
g_value_set_uint(pval, ygets_i(iarg));
break;
case GI_TYPE_TAG_INT64:
g_value_set_int64(pval, ygets_l(iarg));
break;
case GI_TYPE_TAG_UINT64:
g_value_set_uint64(pval, ygets_l(iarg));
break;
case GI_TYPE_TAG_FLOAT:
g_value_set_float(pval, ygets_f(iarg));
break;
case GI_TYPE_TAG_DOUBLE:
g_value_set_double(pval, ygets_d(iarg));
break;
case GI_TYPE_TAG_GTYPE:
g_value_set_gtype(pval, ygets_l(iarg));
break;
case GI_TYPE_TAG_UTF8:
case GI_TYPE_TAG_FILENAME:
g_value_set_static_string (pval, ygets_q(iarg));
GY_DEBUG("GValue is string: \"%s\"\n", ygets_q(iarg));
break;
/* interface types */
case GI_TYPE_TAG_INTERFACE:
itrf = g_type_info_get_interface(info);
switch(g_base_info_get_type (itrf)) {
case GI_INFO_TYPE_ENUM:
g_value_set_enum (pval, ygets_l(iarg));
break;
case GI_INFO_TYPE_OBJECT:
g_value_set_object(pval, yget_gy_Object(iarg)->object);
break;
default:
y_errorn("Unimplemented GValue interface type %ld",
g_base_info_get_type (itrf));
}
g_base_info_unref(itrf);
break;
case GI_TYPE_TAG_VOID:
default:
y_error("Unimplement property GValue type");
}
GY_DEBUG("out gy_iarg2gvalue\n");
}
static JSBool
gjs_value_to_g_value_internal(JSContext *context,
jsval value,
GValue *gvalue,
gboolean no_copy)
{
GType gtype;
gtype = G_VALUE_TYPE(gvalue);
if (gtype == 0) {
gtype = gjs_value_guess_g_type(context, value);
if (gtype == G_TYPE_INVALID) {
gjs_throw(context, "Could not guess unspecified GValue type");
return JS_FALSE;
}
gjs_debug_marshal(GJS_DEBUG_GCLOSURE,
"Guessed GValue type %s from JS Value",
g_type_name(gtype));
g_value_init(gvalue, gtype);
}
gjs_debug_marshal(GJS_DEBUG_GCLOSURE,
"Converting jsval to gtype %s",
g_type_name(gtype));
if (gtype == G_TYPE_STRING) {
/* Don't use ValueToString since we don't want to just toString()
* everything automatically
*/
if (JSVAL_IS_NULL(value)) {
g_value_set_string(gvalue, NULL);
} else if (JSVAL_IS_STRING(value)) {
gchar *utf8_string;
if (!gjs_string_to_utf8(context, value, &utf8_string))
return JS_FALSE;
g_value_take_string(gvalue, utf8_string);
} else {
gjs_throw(context,
"Wrong type %s; string expected",
gjs_get_type_name(value));
return JS_FALSE;
}
} else if (gtype == G_TYPE_CHAR) {
gint32 i;
if (JS_ValueToInt32(context, value, &i) && i >= SCHAR_MIN && i <= SCHAR_MAX) {
g_value_set_schar(gvalue, (signed char)i);
} else {
gjs_throw(context,
"Wrong type %s; char expected",
gjs_get_type_name(value));
return JS_FALSE;
}
} else if (gtype == G_TYPE_UCHAR) {
guint16 i;
if (JS_ValueToUint16(context, value, &i) && i <= UCHAR_MAX) {
g_value_set_uchar(gvalue, (unsigned char)i);
} else {
gjs_throw(context,
"Wrong type %s; unsigned char expected",
gjs_get_type_name(value));
return JS_FALSE;
}
} else if (gtype == G_TYPE_INT) {
gint32 i;
if (JS_ValueToInt32(context, value, &i)) {
g_value_set_int(gvalue, i);
} else {
gjs_throw(context,
"Wrong type %s; integer expected",
gjs_get_type_name(value));
return JS_FALSE;
}
} else if (gtype == G_TYPE_DOUBLE) {
gdouble d;
if (JS_ValueToNumber(context, value, &d)) {
g_value_set_double(gvalue, d);
} else {
gjs_throw(context,
"Wrong type %s; double expected",
gjs_get_type_name(value));
return JS_FALSE;
}
} else if (gtype == G_TYPE_FLOAT) {
gdouble d;
if (JS_ValueToNumber(context, value, &d)) {
g_value_set_float(gvalue, d);
} else {
gjs_throw(context,
"Wrong type %s; float expected",
gjs_get_type_name(value));
return JS_FALSE;
}
} else if (gtype == G_TYPE_UINT) {
guint32 i;
if (JS_ValueToECMAUint32(context, value, &i)) {
g_value_set_uint(gvalue, i);
} else {
gjs_throw(context,
"Wrong type %s; unsigned integer expected",
gjs_get_type_name(value));
return JS_FALSE;
}
} else if (gtype == G_TYPE_BOOLEAN) {
JSBool b;
/* JS_ValueToBoolean() pretty much always succeeds,
* which is maybe surprising sometimes, but could
* be handy also...
*/
if (JS_ValueToBoolean(context, value, &b)) {
g_value_set_boolean(gvalue, b);
} else {
gjs_throw(context,
"Wrong type %s; boolean expected",
gjs_get_type_name(value));
return JS_FALSE;
}
} else if (g_type_is_a(gtype, G_TYPE_OBJECT) || g_type_is_a(gtype, G_TYPE_INTERFACE)) {
GObject *gobj;
gobj = NULL;
if (JSVAL_IS_NULL(value)) {
/* nothing to do */
} else if (JSVAL_IS_OBJECT(value)) {
JSObject *obj;
obj = JSVAL_TO_OBJECT(value);
if (!gjs_typecheck_object(context, obj,
gtype, JS_TRUE))
return JS_FALSE;
gobj = gjs_g_object_from_object(context, obj);
} else {
gjs_throw(context,
"Wrong type %s; object %s expected",
gjs_get_type_name(value),
g_type_name(gtype));
return JS_FALSE;
}
g_value_set_object(gvalue, gobj);
} else if (gtype == G_TYPE_STRV) {
if (JSVAL_IS_NULL(value)) {
/* do nothing */
} else if (gjs_object_has_property(context,
JSVAL_TO_OBJECT(value),
"length")) {
jsval length_value;
guint32 length;
if (!gjs_object_require_property(context,
JSVAL_TO_OBJECT(value), NULL,
"length",
&length_value) ||
!JS_ValueToECMAUint32(context, length_value, &length)) {
gjs_throw(context,
"Wrong type %s; strv expected",
gjs_get_type_name(value));
return JS_FALSE;
} else {
void *result;
char **strv;
if (!gjs_array_to_strv (context,
value,
length, &result))
return JS_FALSE;
/* cast to strv in a separate step to avoid type-punning */
strv = result;
g_value_take_boxed (gvalue, strv);
}
} else {
gjs_throw(context,
"Wrong type %s; strv expected",
gjs_get_type_name(value));
return JS_FALSE;
}
} else if (g_type_is_a(gtype, G_TYPE_BOXED)) {
void *gboxed;
gboxed = NULL;
if (JSVAL_IS_NULL(value)) {
/* nothing to do */
} else if (JSVAL_IS_OBJECT(value)) {
JSObject *obj;
obj = JSVAL_TO_OBJECT(value);
if (g_type_is_a(gtype, G_TYPE_ERROR)) {
/* special case GError */
if (!gjs_typecheck_gerror(context, obj, JS_TRUE))
return JS_FALSE;
gboxed = gjs_gerror_from_error(context, obj);
} else {
/* First try a union, if that fails,
assume a boxed struct. Distinguishing
which one is expected would require checking
the associated GIBaseInfo, which is not necessary
possible, if e.g. we see the GType without
loading the typelib.
*/
if (gjs_typecheck_union(context, obj,
NULL, gtype, JS_FALSE)) {
gboxed = gjs_c_union_from_union(context, obj);
} else {
if (!gjs_typecheck_boxed(context, obj,
NULL, gtype, JS_TRUE))
return JS_FALSE;
gboxed = gjs_c_struct_from_boxed(context, obj);
}
}
} else {
gjs_throw(context,
"Wrong type %s; boxed type %s expected",
gjs_get_type_name(value),
g_type_name(gtype));
return JS_FALSE;
}
if (no_copy)
g_value_set_static_boxed(gvalue, gboxed);
else
g_value_set_boxed(gvalue, gboxed);
} else if (g_type_is_a(gtype, G_TYPE_VARIANT)) {
GVariant *variant = NULL;
if (JSVAL_IS_NULL(value)) {
/* nothing to do */
} else if (JSVAL_IS_OBJECT(value)) {
JSObject *obj = JSVAL_TO_OBJECT(value);
if (!gjs_typecheck_boxed(context, obj,
NULL, G_TYPE_VARIANT, JS_TRUE))
return JS_FALSE;
variant = gjs_c_struct_from_boxed(context, obj);
} else {
gjs_throw(context,
"Wrong type %s; boxed type %s expected",
gjs_get_type_name(value),
g_type_name(gtype));
return JS_FALSE;
}
g_value_set_variant (gvalue, variant);
} else if (g_type_is_a(gtype, G_TYPE_ENUM)) {
gint64 value_int64;
if (gjs_value_to_int64 (context, value, &value_int64)) {
GEnumValue *v;
/* See arg.c:_gjs_enum_to_int() */
v = g_enum_get_value(G_ENUM_CLASS(g_type_class_peek(gtype)),
(int)value_int64);
if (v == NULL) {
gjs_throw(context,
"%d is not a valid value for enumeration %s",
JSVAL_TO_INT(value), g_type_name(gtype));
return JS_FALSE;
}
g_value_set_enum(gvalue, v->value);
} else {
gjs_throw(context,
"Wrong type %s; enum %s expected",
gjs_get_type_name(value),
g_type_name(gtype));
return JS_FALSE;
}
} else if (g_type_is_a(gtype, G_TYPE_FLAGS)) {
gint64 value_int64;
if (gjs_value_to_int64 (context, value, &value_int64)) {
if (!_gjs_flags_value_is_valid(context, gtype, value_int64))
return JS_FALSE;
/* See arg.c:_gjs_enum_to_int() */
g_value_set_flags(gvalue, (int)value_int64);
} else {
gjs_throw(context,
"Wrong type %s; flags %s expected",
gjs_get_type_name(value),
g_type_name(gtype));
return JS_FALSE;
}
} else if (g_type_is_a(gtype, G_TYPE_PARAM)) {
void *gparam;
gparam = NULL;
if (JSVAL_IS_NULL(value)) {
/* nothing to do */
} else if (JSVAL_IS_OBJECT(value)) {
JSObject *obj;
obj = JSVAL_TO_OBJECT(value);
if (!gjs_typecheck_param(context, obj, gtype, JS_TRUE))
return JS_FALSE;
gparam = gjs_g_param_from_param(context, obj);
} else {
gjs_throw(context,
"Wrong type %s; param type %s expected",
gjs_get_type_name(value),
g_type_name(gtype));
return JS_FALSE;
}
g_value_set_param(gvalue, gparam);
} else if (g_type_is_a(gtype, G_TYPE_GTYPE)) {
GType type;
if (!JSVAL_IS_OBJECT(value)) {
gjs_throw(context, "Wrong type %s; expect a GType object",
gjs_get_type_name(value));
return JS_FALSE;
}
type = gjs_gtype_get_actual_gtype(context, JSVAL_TO_OBJECT(value));
g_value_set_gtype(gvalue, type);
} else if (g_type_is_a(gtype, G_TYPE_POINTER)) {
if (JSVAL_IS_NULL(value)) {
/* Nothing to do */
} else {
gjs_throw(context,
"Cannot convert non-null JS value to G_POINTER");
return JS_FALSE;
}
} else if (JSVAL_IS_NUMBER(value) &&
g_value_type_transformable(G_TYPE_INT, gtype)) {
/* Only do this crazy gvalue transform stuff after we've
* exhausted everything else. Adding this for
* e.g. ClutterUnit.
*/
gint32 i;
if (JS_ValueToInt32(context, value, &i)) {
GValue int_value = { 0, };
g_value_init(&int_value, G_TYPE_INT);
g_value_set_int(&int_value, i);
g_value_transform(&int_value, gvalue);
} else {
gjs_throw(context,
"Wrong type %s; integer expected",
gjs_get_type_name(value));
return JS_FALSE;
}
} else {
gjs_debug(GJS_DEBUG_GCLOSURE, "jsval is number %d gtype fundamental %d transformable to int %d from int %d",
JSVAL_IS_NUMBER(value),
G_TYPE_IS_FUNDAMENTAL(gtype),
g_value_type_transformable(gtype, G_TYPE_INT),
g_value_type_transformable(G_TYPE_INT, gtype));
gjs_throw(context,
"Don't know how to convert JavaScript object to GType %s",
g_type_name(gtype));
return JS_FALSE;
}
return JS_TRUE;
}
static void
test_copying (void)
{
GValue value = { 0, };
gchar *error;
{
gchar c = 0;
g_value_init (&value, G_TYPE_CHAR);
g_value_set_char (&value, 'c');
error = lcopy (&value, &c);
g_assert (error == NULL);
g_assert (c == 'c');
}
{
guchar c = 0;
g_value_unset (&value);
g_value_init (&value, G_TYPE_UCHAR);
g_value_set_uchar (&value, 129);
error = lcopy (&value, &c);
g_assert (error == NULL);
g_assert (c == 129);
}
{
gint c = 0;
g_value_unset (&value);
g_value_init (&value, G_TYPE_INT);
g_value_set_int (&value, G_MAXINT);
error = lcopy (&value, &c);
g_assert (error == NULL);
g_assert (c == G_MAXINT);
}
{
guint c = 0;
g_value_unset (&value);
g_value_init (&value, G_TYPE_UINT);
g_value_set_uint (&value, G_MAXUINT);
error = lcopy (&value, &c);
g_assert (error == NULL);
g_assert (c == G_MAXUINT);
}
{
glong c = 0;
g_value_unset (&value);
g_value_init (&value, G_TYPE_LONG);
g_value_set_long (&value, G_MAXLONG);
error = lcopy (&value, &c);
g_assert (error == NULL);
g_assert (c == G_MAXLONG);
}
{
gulong c = 0;
g_value_unset (&value);
g_value_init (&value, G_TYPE_ULONG);
g_value_set_ulong (&value, G_MAXULONG);
error = lcopy (&value, &c);
g_assert (error == NULL);
g_assert (c == G_MAXULONG);
}
{
gint64 c = 0;
g_value_unset (&value);
g_value_init (&value, G_TYPE_INT64);
g_value_set_int64 (&value, G_MAXINT64);
error = lcopy (&value, &c);
g_assert (error == NULL);
g_assert (c == G_MAXINT64);
}
{
guint64 c = 0;
g_value_unset (&value);
g_value_init (&value, G_TYPE_UINT64);
g_value_set_uint64 (&value, G_MAXUINT64);
error = lcopy (&value, &c);
g_assert (error == NULL);
g_assert (c == G_MAXUINT64);
}
{
gfloat c = 0;
g_value_unset (&value);
g_value_init (&value, G_TYPE_FLOAT);
g_value_set_float (&value, G_MAXFLOAT);
error = lcopy (&value, &c);
g_assert (error == NULL);
g_assert (c == G_MAXFLOAT);
}
{
gdouble c = 0;
g_value_unset (&value);
g_value_init (&value, G_TYPE_DOUBLE);
g_value_set_double (&value, G_MAXDOUBLE);
error = lcopy (&value, &c);
g_assert (error == NULL);
g_assert (c == G_MAXDOUBLE);
}
{
gchar *c = NULL;
g_value_unset (&value);
g_value_init (&value, G_TYPE_STRING);
g_value_set_string (&value, "string ?");
error = lcopy (&value, &c);
g_assert (error == NULL);
g_assert (strcmp (c, "string ?") == 0);
}
{
GType c = G_TYPE_NONE;
g_value_unset (&value);
g_value_init (&value, G_TYPE_GTYPE);
g_value_set_gtype (&value, G_TYPE_BOXED);
error = lcopy (&value, &c);
g_assert (error == NULL);
g_assert (c == G_TYPE_BOXED);
}
}
