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;
}
}
