static void theora_enc_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { GstTheoraEnc *enc = GST_THEORA_ENC (object); switch (prop_id) { case PROP_CENTER: g_value_set_boolean (value, TRUE); break; case PROP_BORDER: g_value_set_enum (value, BORDER_BLACK); break; case PROP_BITRATE: GST_OBJECT_LOCK (enc); g_value_set_int (value, enc->video_bitrate / 1000); GST_OBJECT_UNLOCK (enc); break; case PROP_QUALITY: GST_OBJECT_LOCK (enc); g_value_set_int (value, enc->video_quality); GST_OBJECT_UNLOCK (enc); break; case PROP_QUICK: g_value_set_boolean (value, TRUE); break; case PROP_KEYFRAME_AUTO: g_value_set_boolean (value, enc->keyframe_auto); break; case PROP_KEYFRAME_FREQ: g_value_set_int (value, enc->keyframe_freq); break; case PROP_KEYFRAME_FREQ_FORCE: g_value_set_int (value, enc->keyframe_force); break; case PROP_KEYFRAME_THRESHOLD: g_value_set_int (value, 80); break; case PROP_KEYFRAME_MINDISTANCE: g_value_set_int (value, 8); break; case PROP_NOISE_SENSITIVITY: g_value_set_int (value, 1); break; case PROP_SHARPNESS: g_value_set_int (value, 0); break; case PROP_SPEEDLEVEL: g_value_set_int (value, enc->speed_level); break; case PROP_VP3_COMPATIBLE: g_value_set_boolean (value, enc->vp3_compatible); break; case PROP_DROP_FRAMES: g_value_set_boolean (value, enc->drop_frames); break; case PROP_CAP_OVERFLOW: g_value_set_boolean (value, enc->cap_overflow); break; case PROP_CAP_UNDERFLOW: g_value_set_boolean (value, enc->cap_underflow); break; case PROP_RATE_BUFFER: g_value_set_int (value, enc->rate_buffer); break; case PROP_MULTIPASS_CACHE_FILE: g_value_set_string (value, enc->multipass_cache_file); break; case PROP_MULTIPASS_MODE: g_value_set_enum (value, enc->multipass_mode); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
GimpValueArray * gimp_procedure_get_return_values (GimpProcedure *procedure, gboolean success, const GError *error) { GimpValueArray *args; GValue value = { 0, }; gint i; g_return_val_if_fail (success == FALSE || GIMP_IS_PROCEDURE (procedure), NULL); if (success) { args = gimp_value_array_new (procedure->num_values + 1); g_value_init (&value, GIMP_TYPE_PDB_STATUS_TYPE); g_value_set_enum (&value, GIMP_PDB_SUCCESS); gimp_value_array_append (args, &value); g_value_unset (&value); for (i = 0; i < procedure->num_values; i++) { g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (procedure->values[i])); gimp_value_array_append (args, &value); g_value_unset (&value); } } else { args = gimp_value_array_new ((error && error->message) ? 2 : 1); g_value_init (&value, GIMP_TYPE_PDB_STATUS_TYPE); /* errors in the GIMP_PDB_ERROR domain are calling errors */ if (error && error->domain == GIMP_PDB_ERROR) { switch ((GimpPdbErrorCode) error->code) { case GIMP_PDB_ERROR_FAILED: case GIMP_PDB_ERROR_PROCEDURE_NOT_FOUND: case GIMP_PDB_ERROR_INVALID_ARGUMENT: case GIMP_PDB_ERROR_INVALID_RETURN_VALUE: case GIMP_PDB_ERROR_INTERNAL_ERROR: g_value_set_enum (&value, GIMP_PDB_CALLING_ERROR); break; case GIMP_PDB_ERROR_CANCELLED: g_value_set_enum (&value, GIMP_PDB_CANCEL); break; default: g_assert_not_reached (); } } else { g_value_set_enum (&value, GIMP_PDB_EXECUTION_ERROR); } gimp_value_array_append (args, &value); g_value_unset (&value); if (error && error->message) { g_value_init (&value, G_TYPE_STRING); g_value_set_string (&value, error->message); gimp_value_array_append (args, &value); g_value_unset (&value); } } return args; }
static gboolean gst_interpolation_control_source_bind (GstControlSource * source, GParamSpec * pspec) { GType type, base; GstInterpolationControlSource *self = GST_INTERPOLATION_CONTROL_SOURCE (source); gboolean ret = TRUE; /* get the fundamental base type */ self->priv->type = base = type = G_PARAM_SPEC_VALUE_TYPE (pspec); while ((type = g_type_parent (type))) base = type; self->priv->base = base; /* restore type */ type = self->priv->type; if (!gst_interpolation_control_source_set_interpolation_mode (self, self->priv->interpolation_mode)) return FALSE; switch (base) { case G_TYPE_INT:{ GParamSpecInt *tpspec = G_PARAM_SPEC_INT (pspec); g_value_init (&self->priv->default_value, type); g_value_set_int (&self->priv->default_value, tpspec->default_value); g_value_init (&self->priv->minimum_value, type); g_value_set_int (&self->priv->minimum_value, tpspec->minimum); g_value_init (&self->priv->maximum_value, type); g_value_set_int (&self->priv->maximum_value, tpspec->maximum); break; } case G_TYPE_UINT:{ GParamSpecUInt *tpspec = G_PARAM_SPEC_UINT (pspec); g_value_init (&self->priv->default_value, type); g_value_set_uint (&self->priv->default_value, tpspec->default_value); g_value_init (&self->priv->minimum_value, type); g_value_set_uint (&self->priv->minimum_value, tpspec->minimum); g_value_init (&self->priv->maximum_value, type); g_value_set_uint (&self->priv->maximum_value, tpspec->maximum); break; } case G_TYPE_LONG:{ GParamSpecLong *tpspec = G_PARAM_SPEC_LONG (pspec); g_value_init (&self->priv->default_value, type); g_value_set_long (&self->priv->default_value, tpspec->default_value); g_value_init (&self->priv->minimum_value, type); g_value_set_long (&self->priv->minimum_value, tpspec->minimum); g_value_init (&self->priv->maximum_value, type); g_value_set_long (&self->priv->maximum_value, tpspec->maximum); break; } case G_TYPE_ULONG:{ GParamSpecULong *tpspec = G_PARAM_SPEC_ULONG (pspec); g_value_init (&self->priv->default_value, type); g_value_set_ulong (&self->priv->default_value, tpspec->default_value); g_value_init (&self->priv->minimum_value, type); g_value_set_ulong (&self->priv->minimum_value, tpspec->minimum); g_value_init (&self->priv->maximum_value, type); g_value_set_ulong (&self->priv->maximum_value, tpspec->maximum); break; } case G_TYPE_INT64:{ GParamSpecInt64 *tpspec = G_PARAM_SPEC_INT64 (pspec); g_value_init (&self->priv->default_value, type); g_value_set_int64 (&self->priv->default_value, tpspec->default_value); g_value_init (&self->priv->minimum_value, type); g_value_set_int64 (&self->priv->minimum_value, tpspec->minimum); g_value_init (&self->priv->maximum_value, type); g_value_set_int64 (&self->priv->maximum_value, tpspec->maximum); break; } case G_TYPE_UINT64:{ GParamSpecUInt64 *tpspec = G_PARAM_SPEC_UINT64 (pspec); g_value_init (&self->priv->default_value, type); g_value_set_uint64 (&self->priv->default_value, tpspec->default_value); g_value_init (&self->priv->minimum_value, type); g_value_set_uint64 (&self->priv->minimum_value, tpspec->minimum); g_value_init (&self->priv->maximum_value, type); g_value_set_uint64 (&self->priv->maximum_value, tpspec->maximum); break; } case G_TYPE_FLOAT:{ GParamSpecFloat *tpspec = G_PARAM_SPEC_FLOAT (pspec); g_value_init (&self->priv->default_value, type); g_value_set_float (&self->priv->default_value, tpspec->default_value); g_value_init (&self->priv->minimum_value, type); g_value_set_float (&self->priv->minimum_value, tpspec->minimum); g_value_init (&self->priv->maximum_value, type); g_value_set_float (&self->priv->maximum_value, tpspec->maximum); break; } case G_TYPE_DOUBLE:{ GParamSpecDouble *tpspec = G_PARAM_SPEC_DOUBLE (pspec); g_value_init (&self->priv->default_value, type); g_value_set_double (&self->priv->default_value, tpspec->default_value); g_value_init (&self->priv->minimum_value, type); g_value_set_double (&self->priv->minimum_value, tpspec->minimum); g_value_init (&self->priv->maximum_value, type); g_value_set_double (&self->priv->maximum_value, tpspec->maximum); break; } case G_TYPE_BOOLEAN:{ GParamSpecBoolean *tpspec = G_PARAM_SPEC_BOOLEAN (pspec); g_value_init (&self->priv->default_value, type); g_value_set_boolean (&self->priv->default_value, tpspec->default_value); break; } case G_TYPE_ENUM:{ GParamSpecEnum *tpspec = G_PARAM_SPEC_ENUM (pspec); g_value_init (&self->priv->default_value, type); g_value_set_enum (&self->priv->default_value, tpspec->default_value); break; } case G_TYPE_STRING:{ GParamSpecString *tpspec = G_PARAM_SPEC_STRING (pspec); g_value_init (&self->priv->default_value, type); g_value_set_string (&self->priv->default_value, tpspec->default_value); break; } default: GST_WARNING ("incomplete implementation for paramspec type '%s'", G_PARAM_SPEC_TYPE_NAME (pspec)); ret = FALSE; break; } if (ret) { self->priv->valid_cache = FALSE; self->priv->nvalues = 0; } else { gst_interpolation_control_source_reset (self); } return ret; }
/* --- 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_schar, 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 */ }
static void gimp_core_config_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { GimpCoreConfig *core_config = GIMP_CORE_CONFIG (object); switch (property_id) { case PROP_LANGUAGE: g_value_set_string (value, core_config->language); break; case PROP_INTERPOLATION_TYPE: g_value_set_enum (value, core_config->interpolation_type); break; case PROP_DEFAULT_THRESHOLD: g_value_set_int (value, core_config->default_threshold); break; case PROP_PLUG_IN_PATH: g_value_set_string (value, core_config->plug_in_path); break; case PROP_MODULE_PATH: g_value_set_string (value, core_config->module_path); break; case PROP_INTERPRETER_PATH: g_value_set_string (value, core_config->interpreter_path); break; case PROP_ENVIRON_PATH: g_value_set_string (value, core_config->environ_path); break; case PROP_BRUSH_PATH: g_value_set_string (value, core_config->brush_path); break; case PROP_BRUSH_PATH_WRITABLE: g_value_set_string (value, core_config->brush_path_writable); break; case PROP_DYNAMICS_PATH: g_value_set_string (value, core_config->dynamics_path); break; case PROP_DYNAMICS_PATH_WRITABLE: g_value_set_string (value, core_config->dynamics_path_writable); break; case PROP_MYPAINT_BRUSH_PATH: g_value_set_string (value, core_config->mypaint_brush_path); break; case PROP_MYPAINT_BRUSH_PATH_WRITABLE: g_value_set_string (value, core_config->mypaint_brush_path_writable); break; case PROP_PATTERN_PATH: g_value_set_string (value, core_config->pattern_path); break; case PROP_PATTERN_PATH_WRITABLE: g_value_set_string (value, core_config->pattern_path_writable); break; case PROP_PALETTE_PATH: g_value_set_string (value, core_config->palette_path); break; case PROP_PALETTE_PATH_WRITABLE: g_value_set_string (value, core_config->palette_path_writable); break; case PROP_GRADIENT_PATH: g_value_set_string (value, core_config->gradient_path); break; case PROP_GRADIENT_PATH_WRITABLE: g_value_set_string (value, core_config->gradient_path_writable); break; case PROP_TOOL_PRESET_PATH: g_value_set_string (value, core_config->tool_preset_path); break; case PROP_TOOL_PRESET_PATH_WRITABLE: g_value_set_string (value, core_config->tool_preset_path_writable); break; case PROP_FONT_PATH: g_value_set_string (value, core_config->font_path); break; case PROP_FONT_PATH_WRITABLE: g_value_set_string (value, core_config->font_path_writable); break; case PROP_DEFAULT_BRUSH: g_value_set_string (value, core_config->default_brush); break; case PROP_DEFAULT_DYNAMICS: g_value_set_string (value, core_config->default_dynamics); break; case PROP_DEFAULT_MYPAINT_BRUSH: g_value_set_string (value, core_config->default_mypaint_brush); break; case PROP_DEFAULT_PATTERN: g_value_set_string (value, core_config->default_pattern); break; case PROP_DEFAULT_PALETTE: g_value_set_string (value, core_config->default_palette); break; case PROP_DEFAULT_GRADIENT: g_value_set_string (value, core_config->default_gradient); break; case PROP_DEFAULT_TOOL_PRESET: g_value_set_string (value, core_config->default_tool_preset); break; case PROP_DEFAULT_FONT: g_value_set_string (value, core_config->default_font); break; case PROP_GLOBAL_BRUSH: g_value_set_boolean (value, core_config->global_brush); break; case PROP_GLOBAL_DYNAMICS: g_value_set_boolean (value, core_config->global_dynamics); break; case PROP_GLOBAL_PATTERN: g_value_set_boolean (value, core_config->global_pattern); break; case PROP_GLOBAL_PALETTE: g_value_set_boolean (value, core_config->global_palette); break; case PROP_GLOBAL_GRADIENT: g_value_set_boolean (value, core_config->global_gradient); break; case PROP_GLOBAL_FONT: g_value_set_boolean (value, core_config->global_font); break; case PROP_DEFAULT_IMAGE: g_value_set_object (value, core_config->default_image); break; case PROP_DEFAULT_GRID: g_value_set_object (value, core_config->default_grid); break; case PROP_FILTER_HISTORY_SIZE: g_value_set_int (value, core_config->filter_history_size); break; case PROP_UNDO_LEVELS: g_value_set_int (value, core_config->levels_of_undo); break; case PROP_UNDO_SIZE: g_value_set_uint64 (value, core_config->undo_size); break; case PROP_UNDO_PREVIEW_SIZE: g_value_set_enum (value, core_config->undo_preview_size); break; case PROP_PLUGINRC_PATH: g_value_set_string (value, core_config->plug_in_rc_path); break; case PROP_LAYER_PREVIEWS: g_value_set_boolean (value, core_config->layer_previews); break; case PROP_GROUP_LAYER_PREVIEWS: g_value_set_boolean (value, core_config->group_layer_previews); break; case PROP_LAYER_PREVIEW_SIZE: g_value_set_enum (value, core_config->layer_preview_size); break; case PROP_THUMBNAIL_SIZE: g_value_set_enum (value, core_config->thumbnail_size); break; case PROP_THUMBNAIL_FILESIZE_LIMIT: g_value_set_uint64 (value, core_config->thumbnail_filesize_limit); break; case PROP_COLOR_MANAGEMENT: g_value_set_object (value, core_config->color_management); break; case PROP_SAVE_DOCUMENT_HISTORY: g_value_set_boolean (value, core_config->save_document_history); break; case PROP_QUICK_MASK_COLOR: gimp_value_set_rgb (value, &core_config->quick_mask_color); break; case PROP_IMPORT_PROMOTE_FLOAT: g_value_set_boolean (value, core_config->import_promote_float); break; case PROP_IMPORT_PROMOTE_DITHER: g_value_set_boolean (value, core_config->import_promote_dither); break; case PROP_IMPORT_ADD_ALPHA: g_value_set_boolean (value, core_config->import_add_alpha); break; case PROP_IMPORT_RAW_PLUG_IN: g_value_set_string (value, core_config->import_raw_plug_in); break; case PROP_EXPORT_FILE_TYPE: g_value_set_enum (value, core_config->export_file_type); break; case PROP_EXPORT_COLOR_PROFILE: g_value_set_boolean (value, core_config->export_color_profile); break; case PROP_EXPORT_METADATA_EXIF: g_value_set_boolean (value, core_config->export_metadata_exif); break; case PROP_EXPORT_METADATA_XMP: g_value_set_boolean (value, core_config->export_metadata_xmp); break; case PROP_EXPORT_METADATA_IPTC: g_value_set_boolean (value, core_config->export_metadata_iptc); break; case PROP_DEBUG_POLICY: g_value_set_enum (value, core_config->debug_policy); break; case PROP_INSTALL_COLORMAP: case PROP_MIN_COLORS: /* ignored */ break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
static void gimp_pdb_context_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { GimpPDBContext *options = GIMP_PDB_CONTEXT (object); switch (property_id) { case PROP_ANTIALIAS: g_value_set_boolean (value, options->antialias); break; case PROP_FEATHER: g_value_set_boolean (value, options->feather); break; case PROP_FEATHER_RADIUS_X: g_value_set_double (value, options->feather_radius_x); break; case PROP_FEATHER_RADIUS_Y: g_value_set_double (value, options->feather_radius_y); break; case PROP_SAMPLE_MERGED: g_value_set_boolean (value, options->sample_merged); break; case PROP_SAMPLE_CRITERION: g_value_set_enum (value, options->sample_criterion); break; case PROP_SAMPLE_THRESHOLD: g_value_set_double (value, options->sample_threshold); break; case PROP_SAMPLE_TRANSPARENT: g_value_set_boolean (value, options->sample_transparent); break; case PROP_INTERPOLATION: g_value_set_enum (value, options->interpolation); break; case PROP_TRANSFORM_DIRECTION: g_value_set_enum (value, options->transform_direction); break; case PROP_TRANSFORM_RESIZE: g_value_set_enum (value, options->transform_resize); break; case PROP_TRANSFORM_RECURSION: g_value_set_int (value, options->transform_recursion); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
static void terminal_profile_gsettings_notify_cb (GSettings *settings, gchar *key, gpointer user_data) { TerminalProfile *profile = TERMINAL_PROFILE (user_data); TerminalProfilePrivate *priv = profile->priv; TerminalProfileClass *klass; GVariant *settings_value; GParamSpec *pspec; GValue value = { 0, }; gboolean equal; gboolean force_set = FALSE; if (!key) return; _terminal_debug_print (TERMINAL_DEBUG_PROFILE, "GSettings notification for key %s [%s]\n", key, g_settings_is_writable (settings, key) ? "writable" : "LOCKED"); klass = TERMINAL_PROFILE_GET_CLASS (profile); pspec = g_hash_table_lookup (klass->gsettings_keys, key); if (!pspec) return; /* ignore unknown keys, for future extensibility */ priv->locked[pspec->param_id] = !g_settings_is_writable (settings, key); settings_value = g_settings_get_value (settings, key); if (!settings_value) return; g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (pspec)); if (G_IS_PARAM_SPEC_BOOLEAN (pspec)) { if (!g_variant_is_of_type (settings_value, G_VARIANT_TYPE_BOOLEAN)) goto out; g_value_set_boolean (&value, g_variant_get_boolean (settings_value)); } else if (G_IS_PARAM_SPEC_STRING (pspec)) { if (!g_variant_is_of_type (settings_value, G_VARIANT_TYPE_STRING)) goto out; g_value_set_string (&value, g_variant_get_string (settings_value, NULL)); } else if (G_IS_PARAM_SPEC_ENUM (pspec)) { if (!g_variant_is_of_type (settings_value, G_VARIANT_TYPE_STRING)) goto out; g_value_set_enum (&value, g_settings_get_enum (settings, key)); } else if (G_PARAM_SPEC_VALUE_TYPE (pspec) == GDK_TYPE_COLOR) { GdkColor color; if (!g_variant_is_of_type (settings_value, G_VARIANT_TYPE_STRING)) goto out; if (!gdk_color_parse (g_variant_get_string (settings_value, NULL), &color)) goto out; g_value_set_boxed (&value, &color); } else if (G_PARAM_SPEC_VALUE_TYPE (pspec) == PANGO_TYPE_FONT_DESCRIPTION) { if (!g_variant_is_of_type (settings_value, G_VARIANT_TYPE_STRING)) goto out; g_value_take_boxed (&value, pango_font_description_from_string (g_variant_get_string (settings_value, NULL))); } else if (G_IS_PARAM_SPEC_DOUBLE (pspec)) { if (!g_variant_is_of_type (settings_value, G_VARIANT_TYPE_DOUBLE)) goto out; g_value_set_double (&value, g_variant_get_double (settings_value)); } else if (G_IS_PARAM_SPEC_INT (pspec)) { if (!g_variant_is_of_type (settings_value, G_VARIANT_TYPE_INT16) && !g_variant_is_of_type (settings_value, G_VARIANT_TYPE_INT32) && !g_variant_is_of_type (settings_value, G_VARIANT_TYPE_INT64)) goto out; g_value_set_int (&value, g_settings_get_int(settings, key)); } else if (G_IS_PARAM_SPEC_VALUE_ARRAY (pspec) && G_PARAM_SPEC_VALUE_TYPE (G_PARAM_SPEC_VALUE_ARRAY (pspec)->element_spec) == GDK_TYPE_COLOR) { char **color_strings; GdkColor *colors; int n_colors, i; if (!g_variant_is_of_type (settings_value, G_VARIANT_TYPE_STRING)) goto out; color_strings = g_strsplit (g_variant_get_string (settings_value, NULL), ":", -1); if (!color_strings) goto out; n_colors = g_strv_length (color_strings); colors = g_new0 (GdkColor, n_colors); for (i = 0; i < n_colors; ++i) { if (!gdk_color_parse (color_strings[i], &colors[i])) continue; /* ignore errors */ } g_strfreev (color_strings); /* We continue even with a palette size != TERMINAL_PALETTE_SIZE, * so we can change the palette size in future versions without * causing too many issues. */ set_value_from_palette (&value, colors, n_colors); g_free (colors); } else { g_printerr ("Unhandled value type %s of pspec %s\n", g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec)), pspec->name); goto out; } if (g_param_value_validate (pspec, &value)) { _terminal_debug_print (TERMINAL_DEBUG_PROFILE, "Invalid value in GSettings for key %s was changed to comply with pspec %s\n", key, pspec->name); force_set = TRUE; } /* Only set the property if the value is different than our current value, * so we don't go into an infinite loop. */ equal = values_equal (pspec, &value, g_value_array_get_nth (priv->properties, pspec->param_id)); #ifdef MATE_ENABLE_DEBUG _TERMINAL_DEBUG_IF (TERMINAL_DEBUG_PROFILE) { if (!equal) _terminal_debug_print (TERMINAL_DEBUG_PROFILE, "Setting property %s to a different value\n" " now: %s\n" " new: %s\n", pspec->name, g_strdup_value_contents (g_value_array_get_nth (priv->properties, pspec->param_id)), g_strdup_value_contents (&value)); } #endif if (!equal || force_set) { priv->gsettings_notification_pspec = pspec; g_object_set_property (G_OBJECT (profile), pspec->name, &value); priv->gsettings_notification_pspec = NULL; } out: /* FIXME: if we arrive here through goto in the error cases, * should we maybe reset the property to its default value? */ g_value_unset (&value); g_variant_unref (settings_value); }
static void gst_fake_src_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { GstFakeSrc *src; GstBaseSrc *basesrc; g_return_if_fail (GST_IS_FAKE_SRC (object)); src = GST_FAKE_SRC (object); basesrc = GST_BASE_SRC (object); switch (prop_id) { case PROP_OUTPUT: g_value_set_enum (value, src->output); break; case PROP_DATA: g_value_set_enum (value, src->data); break; case PROP_SIZETYPE: g_value_set_enum (value, src->sizetype); break; case PROP_SIZEMIN: g_value_set_int (value, src->sizemin); break; case PROP_SIZEMAX: g_value_set_int (value, src->sizemax); break; case PROP_PARENTSIZE: g_value_set_int (value, src->parentsize); break; case PROP_FILLTYPE: g_value_set_enum (value, src->filltype); break; case PROP_DATARATE: g_value_set_int (value, src->datarate); break; case PROP_SYNC: g_value_set_boolean (value, src->sync); break; case PROP_PATTERN: g_value_set_string (value, src->pattern); break; case PROP_SILENT: g_value_set_boolean (value, src->silent); break; case PROP_SIGNAL_HANDOFFS: g_value_set_boolean (value, src->signal_handoffs); break; case PROP_DUMP: g_value_set_boolean (value, src->dump); break; case PROP_LAST_MESSAGE: GST_OBJECT_LOCK (src); g_value_set_string (value, src->last_message); GST_OBJECT_UNLOCK (src); break; case PROP_CAN_ACTIVATE_PUSH: g_value_set_boolean (value, GST_BASE_SRC (src)->can_activate_push); break; case PROP_CAN_ACTIVATE_PULL: g_value_set_boolean (value, src->can_activate_pull); break; case PROP_IS_LIVE: g_value_set_boolean (value, gst_base_src_is_live (basesrc)); break; case PROP_FORMAT: g_value_set_enum (value, src->format); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void gimp_transform_options_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { GimpTransformOptions *options = GIMP_TRANSFORM_OPTIONS (object); switch (property_id) { case PROP_TYPE: g_value_set_enum (value, options->type); break; case PROP_DIRECTION: g_value_set_enum (value, options->direction); break; case PROP_INTERPOLATION: g_value_set_enum (value, options->interpolation); break; case PROP_CLIP: g_value_set_enum (value, options->clip); break; case PROP_SHOW_PREVIEW: g_value_set_boolean (value, options->show_preview); break; case PROP_PREVIEW_OPACITY: g_value_set_double (value, options->preview_opacity); break; case PROP_GRID_TYPE: g_value_set_enum (value, options->grid_type); break; case PROP_GRID_SIZE: g_value_set_int (value, options->grid_size); break; case PROP_CONSTRAIN_MOVE: g_value_set_boolean (value, options->constrain_move); break; case PROP_CONSTRAIN_SCALE: g_value_set_boolean (value, options->constrain_scale); break; case PROP_CONSTRAIN_ROTATE: g_value_set_boolean (value, options->constrain_rotate); break; case PROP_CONSTRAIN_SHEAR: g_value_set_boolean (value, options->constrain_shear); break; case PROP_CONSTRAIN_PERSPECTIVE: g_value_set_boolean (value, options->constrain_perspective); break; case PROP_FROMPIVOT_SCALE: g_value_set_boolean (value, options->frompivot_scale); break; case PROP_FROMPIVOT_SHEAR: g_value_set_boolean (value, options->frompivot_shear); break; case PROP_FROMPIVOT_PERSPECTIVE: g_value_set_boolean (value, options->frompivot_perspective); break; case PROP_CORNERSNAP: g_value_set_boolean (value, options->cornersnap); break; case PROP_FIXEDPIVOT: g_value_set_boolean (value, options->fixedpivot); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
gboolean json_deserialize_pspec (GValue *value, GParamSpec *pspec, JsonNode *node) { GValue node_value = { 0, }; gboolean retval = FALSE; if (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (value)) == G_TYPE_BOXED) { JsonNodeType node_type = json_node_get_node_type (node); GType boxed_type = G_VALUE_TYPE (value); if (json_boxed_can_deserialize (boxed_type, node_type)) { gpointer boxed = json_boxed_deserialize (boxed_type, node); g_value_take_boxed (value, boxed); return TRUE; } } switch (JSON_NODE_TYPE (node)) { case JSON_NODE_OBJECT: if (g_type_is_a (G_VALUE_TYPE (value), G_TYPE_OBJECT)) { GObject *object; object = json_gobject_new (G_VALUE_TYPE (value), json_node_get_object (node)); if (object != NULL) g_value_take_object (value, object); else g_value_set_object (value, NULL); retval = TRUE; } break; case JSON_NODE_ARRAY: if (G_VALUE_HOLDS (value, G_TYPE_STRV)) { JsonArray *array = json_node_get_array (node); guint i, array_len = json_array_get_length (array); GPtrArray *str_array = g_ptr_array_sized_new (array_len + 1); for (i = 0; i < array_len; i++) { JsonNode *val = json_array_get_element (array, i); if (JSON_NODE_TYPE (val) != JSON_NODE_VALUE) continue; if (json_node_get_string (val) != NULL) g_ptr_array_add (str_array, (gpointer) json_node_get_string (val)); } g_ptr_array_add (str_array, NULL); g_value_set_boxed (value, str_array->pdata); g_ptr_array_free (str_array, TRUE); retval = TRUE; } break; case JSON_NODE_VALUE: json_node_get_value (node, &node_value); #if 0 { gchar *node_str = g_strdup_value_contents (&node_value); g_debug ("%s: value type '%s' := node value type '%s' -> '%s'", G_STRLOC, g_type_name (G_VALUE_TYPE (value)), g_type_name (G_VALUE_TYPE (&node_value)), node_str); g_free (node_str); } #endif switch (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (value))) { case G_TYPE_BOOLEAN: case G_TYPE_INT64: case G_TYPE_STRING: if (G_VALUE_HOLDS (&node_value, G_VALUE_TYPE (value))) { g_value_copy (&node_value, value); retval = TRUE; } break; case G_TYPE_INT: if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64)) { g_value_set_int (value, (gint) g_value_get_int64 (&node_value)); retval = TRUE; } break; case G_TYPE_CHAR: if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64)) { g_value_set_schar (value, (gchar) g_value_get_int64 (&node_value)); retval = TRUE; } break; case G_TYPE_UINT: if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64)) { g_value_set_uint (value, (guint) g_value_get_int64 (&node_value)); retval = TRUE; } break; case G_TYPE_UCHAR: if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64)) { g_value_set_uchar (value, (guchar) g_value_get_int64 (&node_value)); retval = TRUE; } break; case G_TYPE_LONG: if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64)) { g_value_set_long (value, (glong) g_value_get_int64 (&node_value)); retval = TRUE; } break; case G_TYPE_ULONG: if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64)) { g_value_set_ulong (value, (gulong) g_value_get_int64 (&node_value)); retval = TRUE; } break; case G_TYPE_UINT64: if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64)) { g_value_set_uint64 (value, (guint64) g_value_get_int64 (&node_value)); retval = TRUE; } break; case G_TYPE_DOUBLE: if (G_VALUE_HOLDS (&node_value, G_TYPE_DOUBLE)) { g_value_set_double (value, g_value_get_double (&node_value)); retval = TRUE; } else if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64)) { g_value_set_double (value, (gdouble) g_value_get_int64 (&node_value)); retval = TRUE; } break; case G_TYPE_FLOAT: if (G_VALUE_HOLDS (&node_value, G_TYPE_DOUBLE)) { g_value_set_float (value, (gfloat) g_value_get_double (&node_value)); retval = TRUE; } else if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64)) { g_value_set_float (value, (gfloat) g_value_get_int64 (&node_value)); retval = TRUE; } break; case G_TYPE_ENUM: { gint enum_value = 0; if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64)) { enum_value = g_value_get_int64 (&node_value); retval = TRUE; } else if (G_VALUE_HOLDS (&node_value, G_TYPE_STRING)) { retval = enum_from_string (G_VALUE_TYPE (value), g_value_get_string (&node_value), &enum_value); } if (retval) g_value_set_enum (value, enum_value); } break; case G_TYPE_FLAGS: { gint flags_value = 0; if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64)) { flags_value = g_value_get_int64 (&node_value); retval = TRUE; } else if (G_VALUE_HOLDS (&node_value, G_TYPE_STRING)) { retval = flags_from_string (G_VALUE_TYPE (value), g_value_get_string (&node_value), &flags_value); } if (retval) g_value_set_flags (value, flags_value); } break; default: retval = FALSE; break; } g_value_unset (&node_value); break; case JSON_NODE_NULL: if (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (value)) == G_TYPE_STRING) { g_value_set_string (value, NULL); retval = TRUE; } else if (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (value)) == G_TYPE_OBJECT) { g_value_set_object (value, NULL); retval = TRUE; } else retval = FALSE; break; } return retval; }
static void gst_vp8_enc_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { GstVP8Enc *gst_vp8_enc; g_return_if_fail (GST_IS_VP8_ENC (object)); gst_vp8_enc = GST_VP8_ENC (object); switch (prop_id) { case PROP_BITRATE: g_value_set_int (value, gst_vp8_enc->bitrate); break; case PROP_MODE: g_value_set_enum (value, gst_vp8_enc->mode); break; case PROP_MINSECTION_PCT: g_value_set_uint (value, gst_vp8_enc->minsection_pct); break; case PROP_MAXSECTION_PCT: g_value_set_uint (value, gst_vp8_enc->maxsection_pct); break; case PROP_MIN_QUANTIZER: g_value_set_int (value, gst_vp8_enc->min_quantizer); break; case PROP_MAX_QUANTIZER: g_value_set_int (value, gst_vp8_enc->max_quantizer); break; case PROP_QUALITY: g_value_set_double (value, gst_vp8_enc->quality); break; case PROP_ERROR_RESILIENT: g_value_set_boolean (value, gst_vp8_enc->error_resilient); break; case PROP_MAX_LATENCY: g_value_set_int (value, gst_vp8_enc->max_latency); break; case PROP_MAX_KEYFRAME_DISTANCE: g_value_set_int (value, gst_vp8_enc->max_keyframe_distance); break; case PROP_SPEED: g_value_set_int (value, gst_vp8_enc->speed); break; case PROP_THREADS: g_value_set_int (value, gst_vp8_enc->threads); break; case PROP_MULTIPASS_MODE: g_value_set_enum (value, gst_vp8_enc->multipass_mode); break; case PROP_MULTIPASS_CACHE_FILE: g_value_set_string (value, gst_vp8_enc->multipass_cache_file); break; case PROP_AUTO_ALT_REF_FRAMES: g_value_set_boolean (value, gst_vp8_enc->auto_alt_ref_frames); break; case PROP_LAG_IN_FRAMES: g_value_set_uint (value, gst_vp8_enc->lag_in_frames); break; case PROP_SHARPNESS: g_value_set_int (value, gst_vp8_enc->sharpness); break; case PROP_NOISE_SENSITIVITY: g_value_set_int (value, gst_vp8_enc->noise_sensitivity); break; case PROP_TUNE: #ifdef HAVE_VP8ENC_TUNING g_value_set_enum (value, gst_vp8_enc->tuning); #else GST_WARNING_OBJECT (gst_vp8_enc, "The tuning property is unsupported by this libvpx"); #endif break; case PROP_STATIC_THRESHOLD: g_value_set_int (value, gst_vp8_enc->static_threshold); break; case PROP_DROP_FRAME: g_value_set_int (value, gst_vp8_enc->drop_frame); break; case PROP_RESIZE_ALLOWED: g_value_set_boolean (value, gst_vp8_enc->resize_allowed); break; case PROP_TOKEN_PARTS: g_value_set_int (value, gst_vp8_enc->partitions); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void gst_video_test_src_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { GstVideoTestSrc *src = GST_VIDEO_TEST_SRC (object); switch (prop_id) { case PROP_PATTERN: g_value_set_enum (value, src->pattern_type); break; case PROP_TIMESTAMP_OFFSET: g_value_set_int64 (value, src->timestamp_offset); break; case PROP_IS_LIVE: g_value_set_boolean (value, gst_base_src_is_live (GST_BASE_SRC (src))); break; case PROP_K0: g_value_set_int (value, src->k0); break; case PROP_KX: g_value_set_int (value, src->kx); break; case PROP_KY: g_value_set_int (value, src->ky); break; case PROP_KT: g_value_set_int (value, src->kt); break; case PROP_KXT: g_value_set_int (value, src->kxt); break; case PROP_KYT: g_value_set_int (value, src->kyt); break; case PROP_KXY: g_value_set_int (value, src->kxy); break; case PROP_KX2: g_value_set_int (value, src->kx2); break; case PROP_KY2: g_value_set_int (value, src->ky2); break; case PROP_KT2: g_value_set_int (value, src->kt2); break; case PROP_XOFFSET: g_value_set_int (value, src->xoffset); break; case PROP_YOFFSET: g_value_set_int (value, src->yoffset); break; case PROP_FOREGROUND_COLOR: g_value_set_uint (value, src->foreground_color); break; case PROP_BACKGROUND_COLOR: g_value_set_uint (value, src->background_color); break; case PROP_HORIZONTAL_SPEED: g_value_set_int (value, src->horizontal_speed); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void gst_imx_v4l2src_get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { GstImxV4l2VideoSrc *v4l2src = GST_IMX_V4L2SRC(object); switch (prop_id) { case IMX_V4L2SRC_CAPTURE_MODE: g_value_set_int(value, v4l2src->capture_mode); break; case IMX_V4L2SRC_FRAMERATE_NUM: g_value_set_int(value, v4l2src->fps_n); break; case IMX_V4L2SRC_INPUT: g_value_set_int(value, v4l2src->input); break; case IMX_V4L2SRC_DEVICE: g_value_set_string(value, v4l2src->devicename); break; case IMX_V4L2SRC_QUEUE_SIZE: g_value_set_int(value, v4l2src->queue_size); break; case IMX_V4L2SRC_CROP_META_X: g_value_set_int(value, v4l2src->metaCropX); break; case IMX_V4L2SRC_CROP_META_Y: g_value_set_int(value, v4l2src->metaCropY); break; case IMX_V4L2SRC_CROP_META_WIDTH: g_value_set_int(value, v4l2src->metaCropWidth); break; case IMX_V4L2SRC_CROP_META_HEIGHT: g_value_set_int(value, v4l2src->metaCropHeight); break; case PROP_FOCUS_MODE: { GstPhotographyFocusMode focus_mode; gst_imx_v4l2src_get_focus_mode(GST_PHOTOGRAPHY(v4l2src), &focus_mode); g_value_set_enum(value, focus_mode); } break; case PROP_WB_MODE: g_value_set_enum(value, GST_PHOTOGRAPHY_WB_MODE_AUTO); break; case PROP_COLOR_TONE: g_value_set_enum(value, GST_PHOTOGRAPHY_COLOR_TONE_MODE_NORMAL); break; case PROP_SCENE_MODE: g_value_set_enum(value, GST_TYPE_PHOTOGRAPHY_SCENE_MODE); break; case PROP_FLASH_MODE: g_value_set_enum(value, GST_PHOTOGRAPHY_FLASH_MODE_AUTO); break; case PROP_FLICKER_MODE: g_value_set_enum(value, GST_PHOTOGRAPHY_FLICKER_REDUCTION_OFF); break; case PROP_CAPABILITIES: g_value_set_ulong(value, GST_PHOTOGRAPHY_CAPS_NONE); break; case PROP_EV_COMP: g_value_set_float(value, 0.0f); break; case PROP_ISO_SPEED: g_value_set_uint(value, 0); break; case PROP_APERTURE: g_value_set_uint(value, 0); break; case PROP_EXPOSURE_TIME: g_value_set_uint(value, 0); break; case PROP_IMAGE_CAPTURE_SUPPORTED_CAPS: case PROP_IMAGE_PREVIEW_SUPPORTED_CAPS: if (v4l2src->fd_obj_v4l) gst_value_set_caps(value, gst_imx_v4l2src_caps_for_current_setup(v4l2src)); else GST_DEBUG_OBJECT(v4l2src, "not connected to hardware, don't know supported caps"); break; case PROP_ZOOM: g_value_set_float(value, 1.0f); break; case PROP_COLOR_TEMPERATURE: g_value_set_uint(value, 0); break; case PROP_WHITE_POINT: g_value_set_boxed(value, NULL); break; case PROP_ANALOG_GAIN: g_value_set_float(value, 1.0f); break; case PROP_LENS_FOCUS: g_value_set_float(value, 0.0f); break; case PROP_MIN_EXPOSURE_TIME: g_value_set_uint(value, 0); break; case PROP_MAX_EXPOSURE_TIME: g_value_set_uint(value, 0); break; case PROP_NOISE_REDUCTION: g_value_set_flags(value, 0); default: G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); break; } }
/* ** Perform a reduce action and the shift that must immediately ** follow the reduce. */ static void yy_reduce( yyParser *yypParser, /* The parser */ int yyruleno /* Number of the rule by which to reduce */ ){ int yygoto; /* The next state */ int yyact; /* The next action */ YYMINORTYPE yygotominor; /* The LHS of the rule reduced */ yyStackEntry *yymsp; /* The top of the parser's stack */ int yysize; /* Amount to pop the stack */ BbParseARG_FETCH; yymsp = &yypParser->yystack[yypParser->yyidx]; #ifndef NDEBUG if( yyTraceFILE && yyruleno>=0 && yyruleno<sizeof(yyRuleName)/sizeof(yyRuleName[0]) ){ fprintf(yyTraceFILE, "%sReduce [%s].\n", yyTracePrompt, yyRuleName[yyruleno]); } #endif /* NDEBUG */ switch( yyruleno ){ /* Beginning here are the reduction cases. A typical example ** follows: ** case 0: ** #line <lineno> <grammarfile> ** { ... } // User supplied code ** #line <lineno> <thisfile> ** break; */ case 0: #line 28 "core/bb-p.lemon" { yygotominor.yy5 = bb_program_new (); bb_program_add_function_begin (yygotominor.yy5); bb_program_append_program (yygotominor.yy5, yymsp[-2].minor.yy5); bb_program_append_program (yygotominor.yy5, yymsp[0].minor.yy5); bb_program_add_lazy_function (yygotominor.yy5, "add"); yy_destructor(2,&yymsp[-1].minor); } #line 592 "core/bb-p.c" break; case 1: #line 34 "core/bb-p.lemon" { yygotominor.yy5 = bb_program_new (); bb_program_add_function_begin (yygotominor.yy5); bb_program_append_program (yygotominor.yy5, yymsp[-2].minor.yy5); bb_program_append_program (yygotominor.yy5, yymsp[0].minor.yy5); bb_program_add_lazy_function (yygotominor.yy5, "mul"); yy_destructor(4,&yymsp[-1].minor); } #line 602 "core/bb-p.c" break; case 2: #line 40 "core/bb-p.lemon" { yygotominor.yy5 = bb_program_new (); bb_program_add_function_begin (yygotominor.yy5); bb_program_append_program (yygotominor.yy5, yymsp[-2].minor.yy5); bb_program_append_program (yygotominor.yy5, yymsp[0].minor.yy5); bb_program_add_lazy_function (yygotominor.yy5, "sub"); yy_destructor(3,&yymsp[-1].minor); } #line 612 "core/bb-p.c" break; case 3: #line 46 "core/bb-p.lemon" { yygotominor.yy5 = bb_program_new (); bb_program_add_function_begin (yygotominor.yy5); bb_program_append_program (yygotominor.yy5, yymsp[0].minor.yy5); bb_program_add_lazy_function (yygotominor.yy5, "neg"); yy_destructor(3,&yymsp[-1].minor); } #line 621 "core/bb-p.c" break; case 4: #line 51 "core/bb-p.lemon" { yygotominor.yy5 = bb_program_new (); bb_program_add_function_begin (yygotominor.yy5); bb_program_append_program (yygotominor.yy5, yymsp[-2].minor.yy5); bb_program_append_program (yygotominor.yy5, yymsp[0].minor.yy5); bb_program_add_lazy_function (yygotominor.yy5, "div"); yy_destructor(5,&yymsp[-1].minor); } #line 631 "core/bb-p.c" break; case 5: #line 58 "core/bb-p.lemon" { yygotominor.yy5 = bb_program_new (); bb_program_append_program (yygotominor.yy5, yymsp[-1].minor.yy5); yy_destructor(7,&yymsp[-2].minor); yy_destructor(8,&yymsp[0].minor); } #line 639 "core/bb-p.c" break; case 6: #line 61 "core/bb-p.lemon" { yygotominor.yy5 = bb_program_new (); bb_program_append_program (yygotominor.yy5, yymsp[-2].minor.yy5); bb_program_append_program (yygotominor.yy5, yymsp[0].minor.yy5); yy_destructor(1,&yymsp[-1].minor); } #line 647 "core/bb-p.c" break; case 7: #line 65 "core/bb-p.lemon" { GValue value; char *end; gdouble nvalue = strtod (yymsp[0].minor.yy0, &end); if (yymsp[0].minor.yy0 == end) g_error ("error parsing number from %s", yymsp[0].minor.yy0); memset (&value, 0, sizeof (value)); if (strcmp (end, "sec") == 0 || strcmp (end, "s") == 0) { g_value_init (&value, BB_TYPE_DURATION); bb_value_set_duration (&value, BB_DURATION_UNITS_SECONDS, nvalue); } else if (strcmp (end, "samp") == 0) { g_value_init (&value, BB_TYPE_DURATION); bb_value_set_duration (&value, BB_DURATION_UNITS_SAMPLES, nvalue); } else if (strcmp (end, "beat") == 0 || strcmp (end, "b") == 0) { g_value_init (&value, BB_TYPE_DURATION); bb_value_set_duration (&value, BB_DURATION_UNITS_BEATS, nvalue); } else if (strcmp (end, "%") == 0) { g_value_init (&value, BB_TYPE_DURATION); bb_value_set_duration (&value, BB_DURATION_UNITS_NOTE_LENGTHS, nvalue * 0.01); } else if (*end != 0) { g_error ("garbage after number (garbage is '%s'", end); } else { g_value_init (&value, G_TYPE_DOUBLE); g_value_set_double (&value, nvalue); } yygotominor.yy5 = bb_program_new (); bb_program_add_push (yygotominor.yy5, &value); } #line 688 "core/bb-p.c" break; case 8: #line 104 "core/bb-p.lemon" { /* find or allocate parameter */ guint i; for (i = 0; i < context->pspec_array->len; i++) { GParamSpec *p = g_ptr_array_index (context->pspec_array, i); if (bb_param_spec_names_equal (p->name, yymsp[0].minor.yy0)) break; } if (i == context->pspec_array->len) { for (i = 0; i < context->n_source_pspecs; i++) if (bb_param_spec_names_equal (yymsp[0].minor.yy0, context->source_pspecs[i]->name)) break; if (i == context->n_source_pspecs) { g_message ("warning: allocating double parameter named %s", yymsp[0].minor.yy0); g_ptr_array_add (context->pspec_array, g_param_spec_double (yymsp[0].minor.yy0,yymsp[0].minor.yy0,NULL, -1e9,1e9,0,G_PARAM_READWRITE)); } else g_ptr_array_add (context->pspec_array, context->source_pspecs[i]); i = context->pspec_array->len - 1; } yygotominor.yy5 = bb_program_new (); bb_program_add_push_param (yygotominor.yy5, i); } #line 718 "core/bb-p.c" break; case 9: #line 132 "core/bb-p.lemon" { BbBuiltinFunc f; yygotominor.yy5 = bb_program_new (); f = bb_builtin_lookup (yymsp[-3].minor.yy0); if (f != NULL) { bb_program_append_program (yygotominor.yy5, yymsp[-1].minor.yy5); bb_program_add_builtin (yygotominor.yy5, yymsp[-3].minor.yy0, f); } else { /* TODO: try resolving the function now */ bb_program_add_function_begin (yygotominor.yy5); bb_program_append_program (yygotominor.yy5, yymsp[-1].minor.yy5); bb_program_add_lazy_function (yygotominor.yy5, yymsp[-3].minor.yy0); } yy_destructor(7,&yymsp[-2].minor); yy_destructor(8,&yymsp[0].minor); } #line 740 "core/bb-p.c" break; case 10: #line 149 "core/bb-p.lemon" { BbBuiltinFunc f; yygotominor.yy5 = bb_program_new (); f = bb_builtin_lookup (yymsp[-2].minor.yy0); if (f != NULL) bb_program_add_builtin (yygotominor.yy5, yymsp[-2].minor.yy0, f); else { bb_program_add_function_begin (yygotominor.yy5); bb_program_add_lazy_function (yygotominor.yy5, yymsp[-2].minor.yy0); } yy_destructor(7,&yymsp[-1].minor); yy_destructor(8,&yymsp[0].minor); } #line 757 "core/bb-p.c" break; case 11: #line 163 "core/bb-p.lemon" { GType type = g_type_from_name (yymsp[-2].minor.yy0); guint v; GValue ev; if (type == 0 || !g_type_is_a (type, G_TYPE_ENUM)) g_error ("no enum named '%s'", yymsp[-2].minor.yy0); if (!bb_enum_value_lookup (type, yymsp[0].minor.yy0, &v)) g_error ("no value of %s named %s", yymsp[-2].minor.yy0, yymsp[0].minor.yy0); memset (&ev, 0, sizeof (ev)); g_value_init (&ev, type); g_value_set_enum (&ev, v); yygotominor.yy5 = bb_program_new (); bb_program_add_push (yygotominor.yy5, &ev); yy_destructor(6,&yymsp[-1].minor); } #line 775 "core/bb-p.c" break; case 12: #line 178 "core/bb-p.lemon" { yygotominor.yy5 = bb_program_new (); bb_program_add_push_special (yygotominor.yy5, BB_VM_SPECIAL_ARRAY_BEGIN); bb_program_append_program (yygotominor.yy5, yymsp[-1].minor.yy5); bb_program_add_builtin (yygotominor.yy5, "create_array", bb_builtin_create_array); yy_destructor(11,&yymsp[-2].minor); yy_destructor(12,&yymsp[0].minor); } #line 785 "core/bb-p.c" break; case 13: #line 184 "core/bb-p.lemon" { GValue v = BB_VALUE_INIT; yygotominor.yy5 = bb_program_new (); g_value_init (&v, G_TYPE_STRING); g_value_set_string (&v, yymsp[0].minor.yy0); bb_program_add_push (yygotominor.yy5, &v); } #line 794 "core/bb-p.c" break; case 14: #line 191 "core/bb-p.lemon" { if (context->program) { g_warning ("got two programs"); } else { context->program = bb_program_ref (yymsp[0].minor.yy5); } } #line 803 "core/bb-p.c" break; }; yygoto = yyRuleInfo[yyruleno].lhs; yysize = yyRuleInfo[yyruleno].nrhs; yypParser->yyidx -= yysize; yyact = yy_find_reduce_action(yypParser,yygoto); if( yyact < YYNSTATE ){ yy_shift(yypParser,yyact,yygoto,&yygotominor); }else if( yyact == YYNSTATE + YYNRULE + 1 ){ yy_accept(yypParser); } }
static void gimp_curve_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { GimpCurve *curve = GIMP_CURVE (object); switch (property_id) { case PROP_CURVE_TYPE: g_value_set_enum (value, curve->curve_type); break; case PROP_N_POINTS: g_value_set_int (value, curve->n_points); break; case PROP_POINTS: { GimpValueArray *array = gimp_value_array_new (curve->n_points * 2); GValue v = { 0, }; gint i; g_value_init (&v, G_TYPE_DOUBLE); for (i = 0; i < curve->n_points; i++) { g_value_set_double (&v, curve->points[i].x); gimp_value_array_append (array, &v); g_value_set_double (&v, curve->points[i].y); gimp_value_array_append (array, &v); } g_value_unset (&v); g_value_take_boxed (value, array); } break; case PROP_N_SAMPLES: g_value_set_int (value, curve->n_samples); break; case PROP_SAMPLES: { GimpValueArray *array = gimp_value_array_new (curve->n_samples); GValue v = { 0, }; gint i; g_value_init (&v, G_TYPE_DOUBLE); for (i = 0; i < curve->n_samples; i++) { g_value_set_double (&v, curve->samples[i]); gimp_value_array_append (array, &v); } g_value_unset (&v); g_value_take_boxed (value, array); } break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
static void gst_dvbsrc_get_property (GObject * _object, guint prop_id, GValue * value, GParamSpec * pspec) { GstDvbSrc *object; g_return_if_fail (GST_IS_DVBSRC (_object)); object = GST_DVBSRC (_object); switch (prop_id) { case ARG_DVBSRC_ADAPTER: g_value_set_int (value, object->adapter_number); break; case ARG_DVBSRC_FRONTEND: g_value_set_int (value, object->frontend_number); break; case ARG_DVBSRC_FREQUENCY: g_value_set_uint (value, object->freq); break; case ARG_DVBSRC_POLARITY: if (object->pol == DVB_POL_H) g_value_set_static_string (value, "H"); else g_value_set_static_string (value, "V"); break; case ARG_DVBSRC_SYM_RATE: g_value_set_uint (value, object->sym_rate); break; case ARG_DVBSRC_DISEQC_SRC: g_value_set_int (value, object->diseqc_src); break; case ARG_DVBSRC_BANDWIDTH: g_value_set_enum (value, object->bandwidth); break; case ARG_DVBSRC_CODE_RATE_HP: g_value_set_enum (value, object->code_rate_hp); break; case ARG_DVBSRC_CODE_RATE_LP: g_value_set_enum (value, object->code_rate_lp); break; case ARG_DVBSRC_GUARD: g_value_set_enum (value, object->guard_interval); break; case ARG_DVBSRC_MODULATION: g_value_set_enum (value, object->modulation); break; case ARG_DVBSRC_TRANSMISSION_MODE: g_value_set_enum (value, object->transmission_mode); break; case ARG_DVBSRC_HIERARCHY_INF: g_value_set_enum (value, object->hierarchy_information); break; case ARG_DVBSRC_INVERSION: g_value_set_enum (value, object->inversion); break; case ARG_DVBSRC_STATS_REPORTING_INTERVAL: g_value_set_uint (value, object->stats_interval); break; case ARG_DVBSRC_TIMEOUT: g_value_set_uint64 (value, object->timeout); break; case ARG_DVBSRC_DVB_BUFFER_SIZE: g_value_set_uint (value, object->dvb_buffer_size); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); } }
static void uca_camera_get_property(GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { UcaCameraPrivate *priv = UCA_CAMERA_GET_PRIVATE (object); switch (property_id) { case PROP_IS_RECORDING: g_value_set_boolean (value, priv->is_recording); break; case PROP_IS_READOUT: g_value_set_boolean (value, priv->is_readout); break; case PROP_TRANSFER_ASYNCHRONOUSLY: g_value_set_boolean (value, priv->transfer_async); break; case PROP_TRIGGER_SOURCE: g_value_set_enum (value, priv->trigger_source); break; case PROP_TRIGGER_TYPE: g_value_set_enum (value, priv->trigger_type); break; case PROP_FRAMES_PER_SECOND: { gdouble exposure_time; g_object_get (object, "exposure-time", &exposure_time, NULL); if (exposure_time > 0.0) g_value_set_double (value, 1. / exposure_time); else g_warning ("Invalid `::exposure-time' set"); } break; case PROP_RECORDED_FRAMES: g_value_set_uint (value, 0); break; case PROP_SENSOR_PIXEL_WIDTH: /* 10um is an arbitrary default, cameras should definitely override * this. */ g_value_set_double (value, 10e-6); break; case PROP_SENSOR_PIXEL_HEIGHT: g_value_set_double (value, 10e-6); break; case PROP_SENSOR_HORIZONTAL_BINNING: g_value_set_uint (value, 1); break; case PROP_SENSOR_VERTICAL_BINNING: g_value_set_uint (value, 1); break; case PROP_ROI_WIDTH_MULTIPLIER: g_value_set_uint (value, 1); break; case PROP_ROI_HEIGHT_MULTIPLIER: g_value_set_uint (value, 1); break; case PROP_BUFFERED: g_value_set_boolean (value, priv->buffered); break; case PROP_NUM_BUFFERS: g_value_set_uint (value, priv->num_buffers); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec); } }
static void gst_rpi_cam_src_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { GstRpiCamSrc *src = GST_RPICAMSRC (object); g_mutex_lock (&src->config_lock); switch (prop_id) { case PROP_CAMERA_NUMBER: g_value_set_int (value, src->capture_config.cameraNum); break; case PROP_BITRATE: g_value_set_int (value, src->capture_config.bitrate); break; case PROP_KEYFRAME_INTERVAL: g_value_set_int (value, src->capture_config.intraperiod); break; case PROP_PREVIEW: g_value_set_boolean (value, src->capture_config.preview_parameters.wantPreview); break; case PROP_PREVIEW_ENCODED: g_value_set_boolean (value, src->capture_config.immutableInput); break; case PROP_FULLSCREEN: g_value_set_boolean (value, src->capture_config.preview_parameters.wantFullScreenPreview); break; case PROP_PREVIEW_OPACITY: g_value_set_int (value, src->capture_config.preview_parameters.opacity); break; case PROP_SHARPNESS: g_value_set_int (value, src->capture_config.camera_parameters.sharpness); break; case PROP_CONTRAST: g_value_set_int (value, src->capture_config.camera_parameters.contrast); break; case PROP_BRIGHTNESS: g_value_set_int (value, src->capture_config.camera_parameters.brightness); break; case PROP_SATURATION: g_value_set_int (value, src->capture_config.camera_parameters.saturation); break; case PROP_ISO: g_value_set_int (value, src->capture_config.camera_parameters.ISO); break; case PROP_VIDEO_STABILISATION: g_value_set_boolean (value, ! !(src->capture_config.camera_parameters.videoStabilisation)); break; case PROP_EXPOSURE_COMPENSATION: g_value_set_int (value, src->capture_config.camera_parameters.exposureCompensation); break; case PROP_EXPOSURE_MODE: g_value_set_enum (value, src->capture_config.camera_parameters.exposureMode); break; case PROP_EXPOSURE_METERING_MODE: g_value_set_enum (value, src->capture_config.camera_parameters.exposureMeterMode); break; case PROP_ROTATION: g_value_set_int (value, src->capture_config.camera_parameters.rotation); break; case PROP_AWB_MODE: g_value_set_enum (value, src->capture_config.camera_parameters.awbMode); break; case PROP_AWB_GAIN_RED: g_value_set_float (value, src->capture_config.camera_parameters.awb_gains_r); break; case PROP_AWB_GAIN_BLUE: g_value_set_float (value, src->capture_config.camera_parameters.awb_gains_b); break; case PROP_IMAGE_EFFECT: g_value_set_enum (value, src->capture_config.camera_parameters.imageEffect); break; case PROP_HFLIP: g_value_set_boolean (value, ! !(src->capture_config.camera_parameters.hflip)); break; case PROP_VFLIP: g_value_set_boolean (value, ! !(src->capture_config.camera_parameters.vflip)); break; case PROP_ROI_X: g_value_set_float (value, src->capture_config.camera_parameters.roi.x); break; case PROP_ROI_Y: g_value_set_float (value, src->capture_config.camera_parameters.roi.y); break; case PROP_ROI_W: g_value_set_float (value, src->capture_config.camera_parameters.roi.w); break; case PROP_ROI_H: g_value_set_float (value, src->capture_config.camera_parameters.roi.h); break; case PROP_QUANTISATION_PARAMETER: g_value_set_int (value, src->capture_config.quantisationParameter); break; case PROP_INLINE_HEADERS: g_value_set_boolean (value, src->capture_config.bInlineHeaders); break; case PROP_SHUTTER_SPEED: g_value_set_int (value, src->capture_config.camera_parameters.shutter_speed); break; case PROP_DRC: g_value_set_enum (value, src->capture_config.camera_parameters.drc_level); break; case PROP_SENSOR_MODE: g_value_set_enum (value, src->capture_config.sensor_mode); break; case PROP_ANNOTATION_MODE: g_value_set_flags (value, src->capture_config.camera_parameters.enable_annotate); break; case PROP_ANNOTATION_TEXT: g_value_set_string (value, src->capture_config.camera_parameters.annotate_string); break; case PROP_INTRA_REFRESH_TYPE: g_value_set_enum (value, src->capture_config.intra_refresh_type); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } g_mutex_unlock (&src->config_lock); }
static GimpValueArray * procedural_db_proc_arg_invoker (GimpProcedure *procedure, Gimp *gimp, GimpContext *context, GimpProgress *progress, const GimpValueArray *args, GError **error) { gboolean success = TRUE; GimpValueArray *return_vals; const gchar *procedure_name; gint32 arg_num; gint32 arg_type = 0; gchar *arg_name = NULL; gchar *arg_desc = NULL; procedure_name = g_value_get_string (gimp_value_array_index (args, 0)); arg_num = g_value_get_int (gimp_value_array_index (args, 1)); if (success) { GimpProcedure *proc; gchar *canonical; canonical = gimp_canonicalize_identifier (procedure_name); proc = gimp_pdb_lookup_procedure (gimp->pdb, canonical); if (! proc) { const gchar *compat_name; compat_name = gimp_pdb_lookup_compat_proc_name (gimp->pdb, canonical); if (compat_name) proc = gimp_pdb_lookup_procedure (gimp->pdb, compat_name); } g_free (canonical); if (proc && (arg_num >= 0 && arg_num < proc->num_args)) { GParamSpec *pspec = proc->args[arg_num]; arg_type = gimp_pdb_compat_arg_type_from_gtype (G_PARAM_SPEC_VALUE_TYPE (pspec)); arg_name = g_strdup (g_param_spec_get_name (pspec)); arg_desc = gimp_param_spec_get_desc (pspec); } else success = FALSE; } return_vals = gimp_procedure_get_return_values (procedure, success, error ? *error : NULL); if (success) { g_value_set_enum (gimp_value_array_index (return_vals, 1), arg_type); g_value_take_string (gimp_value_array_index (return_vals, 2), arg_name); g_value_take_string (gimp_value_array_index (return_vals, 3), arg_desc); } return return_vals; }
static void inf_tcp_connection_get_property(GObject* object, guint prop_id, GValue* value, GParamSpec* pspec) { InfTcpConnection* connection; InfTcpConnectionPrivate* priv; InfIpAddress* address; guint port; GError* error; #ifndef G_OS_WIN32 char device_name[IF_NAMESIZE]; #endif connection = INF_TCP_CONNECTION(object); priv = INF_TCP_CONNECTION_PRIVATE(connection); switch(prop_id) { case PROP_IO: g_value_set_object(value, G_OBJECT(priv->io)); break; case PROP_RESOLVER: g_value_set_object(value, G_OBJECT(priv->resolver)); break; case PROP_KEEPALIVE: g_value_set_boxed(value, &priv->keepalive); break; case PROP_STATUS: g_value_set_enum(value, priv->status); break; case PROP_REMOTE_ADDRESS: g_value_set_static_boxed(value, priv->remote_address); break; case PROP_REMOTE_PORT: g_value_set_uint(value, priv->remote_port); break; case PROP_LOCAL_ADDRESS: g_assert(priv->socket != INVALID_SOCKET); error = NULL; inf_tcp_connection_addr_info(priv->socket, TRUE, &address, NULL, &error); if(error != NULL) { g_warning(_("Failed to retrieve local address: %s"), error->message); g_error_free(error); g_value_set_boxed(value, NULL); } else { g_value_take_boxed(value, address); } break; case PROP_LOCAL_PORT: g_assert(priv->socket != INVALID_SOCKET); error = NULL; inf_tcp_connection_addr_info(priv->socket, TRUE, NULL, &port, &error); if(error != NULL) { g_warning(_("Failed to retrieve local port: %s"), error->message); g_error_free(error); g_value_set_uint(value, 0); } else { g_value_set_uint(value, port); } break; case PROP_DEVICE_INDEX: g_value_set_uint(value, priv->device_index); break; case PROP_DEVICE_NAME: #ifdef G_OS_WIN32 /* TODO: We can probably implement this using GetInterfaceInfo() */ g_warning(_("The device-name property is not implemented on Win32")); g_value_set_string(value, NULL); #else if(priv->device_index == 0) { g_value_set_string(value, NULL); } else { if(if_indextoname(priv->device_index, device_name) == NULL) { g_warning( /* Failed to get name for device <Index>: <Reason> */ _("Failed to get name for device %u: %s"), priv->device_index, strerror(errno) ); g_value_set_string(value, NULL); } else { g_value_set_string(value, device_name); } } #endif break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); break; } }