void
gst_soup_http_client_sink_set_property (GObject * object, guint property_id,
const GValue * value, GParamSpec * pspec)
{
GstSoupHttpClientSink *souphttpsink = GST_SOUP_HTTP_CLIENT_SINK (object);
g_mutex_lock (&souphttpsink->mutex);
switch (property_id) {
case PROP_SESSION:
if (souphttpsink->prop_session) {
g_object_unref (souphttpsink->prop_session);
}
souphttpsink->prop_session = g_value_dup_object (value);
break;
case PROP_LOCATION:
g_free (souphttpsink->location);
souphttpsink->location = g_value_dup_string (value);
souphttpsink->offset = 0;
if ((souphttpsink->location == NULL)
|| !gst_uri_is_valid (souphttpsink->location)) {
GST_WARNING_OBJECT (souphttpsink,
"The location (\"%s\") set, is not a valid uri.",
souphttpsink->location);
g_free (souphttpsink->location);
souphttpsink->location = NULL;
}
break;
case PROP_USER_AGENT:
g_free (souphttpsink->user_agent);
souphttpsink->user_agent = g_value_dup_string (value);
break;
case PROP_AUTOMATIC_REDIRECT:
souphttpsink->automatic_redirect = g_value_get_boolean (value);
break;
case PROP_USER_ID:
g_free (souphttpsink->user_id);
souphttpsink->user_id = g_value_dup_string (value);
break;
case PROP_USER_PW:
g_free (souphttpsink->user_pw);
souphttpsink->user_pw = g_value_dup_string (value);
break;
case PROP_PROXY_ID:
g_free (souphttpsink->proxy_id);
souphttpsink->proxy_id = g_value_dup_string (value);
break;
case PROP_PROXY_PW:
g_free (souphttpsink->proxy_pw);
souphttpsink->proxy_pw = g_value_dup_string (value);
break;
case PROP_PROXY:
{
const gchar *proxy;
proxy = g_value_get_string (value);
if (proxy == NULL) {
GST_WARNING ("proxy property cannot be NULL");
goto done;
}
if (!gst_soup_http_client_sink_set_proxy (souphttpsink, proxy)) {
GST_WARNING ("badly formatted proxy URI");
goto done;
}
break;
}
case PROP_COOKIES:
g_strfreev (souphttpsink->cookies);
souphttpsink->cookies = g_strdupv (g_value_get_boxed (value));
break;
case PROP_SOUP_LOG_LEVEL:
souphttpsink->log_level = g_value_get_enum (value);
break;
case PROP_RETRY_DELAY:
souphttpsink->retry_delay = g_value_get_int (value);
break;
case PROP_RETRIES:
souphttpsink->retries = g_value_get_int (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
done:
g_mutex_unlock (&souphttpsink->mutex);
}
static void
horizon_post_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
HorizonPost *self = HORIZON_POST (object);
switch (property_id)
{
case PROP_POST_NUMBER:
self->priv->post_number = g_value_get_int64 (value);
break;
case PROP_RESTO:
self->priv->resto = g_value_get_int64 (value);
break;
case PROP_STICKY:
self->priv->sticky = g_value_get_int (value);
break;
case PROP_CLOSED:
self->priv->closed = g_value_get_int (value);
break;
case PROP_NOW:
g_free (self->priv->now);
self->priv->now = g_value_dup_string (value);
break;
case PROP_TIME:
self->priv->time = g_value_get_int64 (value);
break;
case PROP_NAME:
g_free (self->priv->name);
self->priv->name = g_value_dup_string (value);
break;
case PROP_TRIP:
g_free (self->priv->trip);
self->priv->trip = g_value_dup_string (value);
break;
case PROP_ID:
g_free (self->priv->id);
self->priv->id = g_value_dup_string (value);
break;
case PROP_CAPCODE:
g_free (self->priv->capcode);
self->priv->capcode = g_value_dup_string (value);
break;
case PROP_COUNTRY:
g_free (self->priv->country_code);
self->priv->country_code = g_value_dup_string (value);
break;
case PROP_COUNTRY_NAME:
g_free (self->priv->country_name);
self->priv->country_name = g_value_dup_string (value);
break;
case PROP_EMAIL:
g_free (self->priv->email);
self->priv->email = g_value_dup_string (value);
break;
case PROP_SUBJECT:
g_free (self->priv->subject);
self->priv->subject = g_value_dup_string (value);
break;
case PROP_COMMENT:
g_free (self->priv->comment);
self->priv->comment = g_value_dup_string (value);
break;
case PROP_RENAMED_FILENAME:
self->priv->renamed_filename = g_value_get_int64 (value);
break;
case PROP_FILENAME:
g_free (self->priv->filename);
self->priv->filename = g_value_dup_string (value);
break;
case PROP_EXT:
g_free (self->priv->ext);
self->priv->ext = g_value_dup_string (value);
break;
case PROP_FSIZE:
self->priv->fsize = g_value_get_int64 (value);
break;
case PROP_MD5:
g_free (self->priv->md5);
self->priv->md5 = g_value_dup_string (value);
break;
case PROP_WIDTH:
self->priv->image_width = g_value_get_int (value);
break;
case PROP_HEIGHT:
self->priv->image_height = g_value_get_int (value);
break;
case PROP_THUMBNAIL_WIDTH:
self->priv->thumbnail_width = g_value_get_int (value);
break;
case PROP_THUMBNAIL_HEIGHT:
self->priv->thumbnail_height = g_value_get_int (value);
break;
case PROP_FILEDELETED:
self->priv->is_file_deleted = g_value_get_int (value);
break;
case PROP_SPOILER:
self->priv->is_spoiler = g_value_get_int (value);
break;
case PROP_CUSTOM_SPOILER:
self->priv->custom_spoiler = g_value_get_int (value);
break;
case PROP_REPLIES:
self->priv->replies = g_value_get_int(value);
break;
case PROP_IMAGES:
self->priv->images = g_value_get_int(value);
break;
case PROP_BUMPLIMIT:
self->priv->bumplimit = g_value_get_int(value);
break;
case PROP_IMAGELIMIT:
self->priv->imagelimit = g_value_get_int(value);
break;
case PROP_IMAGE_URL:
g_free(self->priv->image_url);
self->priv->image_url = g_value_dup_string (value);
break;
case PROP_THUMB_URL:
g_free(self->priv->thumb_url);
self->priv->thumb_url = g_value_dup_string (value);
break;
case PROP_BOARD:
g_free(self->priv->board);
self->priv->board = g_value_dup_string (value);
break;
case PROP_RENDERED:
self->priv->rendered = g_value_get_boolean (value);
break;
case PROP_THREAD_ID:
self->priv->thread_id = g_value_get_int64 (value);
break;
default:
/* We don't have any other property... */
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
places_cfg_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
PlacesCfg *cfg = XFCE_PLACES_CFG (object);
gint val;
const char *text;
DBG ("Property changed");
switch (prop_id)
{
case PROP_SHOW_BUTTON_TYPE:
val = g_value_get_uint (value);
if (cfg->show_button_icon != (val == 0 || val == 2))
{
cfg->show_button_icon = (val == 0 || val == 2);
g_signal_emit (G_OBJECT (cfg), places_cfg_signals[BUTTON_CHANGED], 0);
}
if (cfg->show_button_label != (val == 1 || val == 2))
{
cfg->show_button_label = (val == 1 || val == 2);
g_signal_emit (G_OBJECT (cfg), places_cfg_signals[BUTTON_CHANGED], 0);
}
break;
case PROP_BUTTON_LABEL:
text = g_value_get_string (value);
if (strcmp(cfg->label, text))
{
if (cfg->label != NULL)
g_free (cfg->label);
cfg->label = g_value_dup_string (value);
g_signal_emit (G_OBJECT (cfg), places_cfg_signals[BUTTON_CHANGED], 0);
}
break;
case PROP_SHOW_ICONS:
val = g_value_get_boolean (value);
if (cfg->show_icons != val)
{
cfg->show_icons = val;
g_signal_emit (G_OBJECT (cfg), places_cfg_signals[MENU_CHANGED], 0);
}
break;
case PROP_SHOW_VOLUMES:
val = g_value_get_boolean (value);
if (cfg->show_volumes != val)
{
cfg->show_volumes = val;
g_signal_emit (G_OBJECT (cfg), places_cfg_signals[MODEL_CHANGED], 0);
}
break;
case PROP_MOUNT_OPEN_VOLUMES:
val = g_value_get_boolean (value);
if (cfg->mount_open_volumes != val)
{
cfg->mount_open_volumes = val;
g_signal_emit (G_OBJECT (cfg), places_cfg_signals[MODEL_CHANGED], 0);
}
break;
case PROP_SHOW_BOOKMARKS:
val = g_value_get_boolean (value);
if (cfg->show_bookmarks != val)
{
cfg->show_bookmarks = val;
g_signal_emit (G_OBJECT (cfg), places_cfg_signals[MODEL_CHANGED], 0);
}
break;
case PROP_SERVER_CONNECT_CMD:
text = g_value_get_string (value);
if (strcmp(cfg->server_connect_cmd, text))
{
if (cfg->server_connect_cmd != NULL)
g_free (cfg->server_connect_cmd);
cfg->server_connect_cmd = g_value_dup_string (value);
g_signal_emit (G_OBJECT (cfg), places_cfg_signals[MENU_CHANGED], 0);
}
break;
case PROP_NETWORK_CMD:
text = g_value_get_string (value);
if (strcmp(cfg->network_cmd, text))
{
if (cfg->network_cmd != NULL)
g_free (cfg->network_cmd);
cfg->network_cmd = g_value_dup_string (value);
g_signal_emit (G_OBJECT (cfg), places_cfg_signals[MENU_CHANGED], 0);
}
break;
#if USE_RECENT_DOCUMENTS
case PROP_SHOW_RECENT:
val = g_value_get_boolean (value);
if (cfg->show_recent != val)
{
cfg->show_recent = val;
g_signal_emit (G_OBJECT (cfg), places_cfg_signals[MENU_CHANGED], 0);
}
break;
case PROP_SHOW_RECENT_CLEAR:
val = g_value_get_boolean (value);
if (cfg->show_recent_clear != val)
{
cfg->show_recent_clear = val;
g_signal_emit (G_OBJECT (cfg), places_cfg_signals[MENU_CHANGED], 0);
}
break;
case PROP_SHOW_RECENT_NUMBER:
val = g_value_get_uint (value);
if (cfg->show_recent_number != val)
{
cfg->show_recent_number = val;
g_signal_emit (G_OBJECT (cfg), places_cfg_signals[MENU_CHANGED], 0);
}
break;
#endif
case PROP_SEARCH_CMD:
text = g_value_get_string (value);
if (strcmp(cfg->search_cmd, text))
{
if (cfg->search_cmd != NULL)
g_free (cfg->search_cmd);
cfg->search_cmd = g_value_dup_string (value);
g_signal_emit (G_OBJECT (cfg), places_cfg_signals[MENU_CHANGED], 0);
}
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gst_opus_enc_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstOpusEnc *enc;
enc = GST_OPUS_ENC (object);
#define GST_OPUS_UPDATE_PROPERTY(prop,type,ctl) do { \
g_mutex_lock (&enc->property_lock); \
enc->prop = g_value_get_##type (value); \
if (enc->state) { \
opus_multistream_encoder_ctl (enc->state, OPUS_SET_##ctl (enc->prop)); \
} \
g_mutex_unlock (&enc->property_lock); \
} while(0)
switch (prop_id) {
case PROP_AUDIO:
enc->audio_or_voip = g_value_get_boolean (value);
break;
case PROP_BITRATE:
GST_OPUS_UPDATE_PROPERTY (bitrate, int, BITRATE);
break;
case PROP_BANDWIDTH:
GST_OPUS_UPDATE_PROPERTY (bandwidth, enum, BANDWIDTH);
break;
case PROP_FRAME_SIZE:
g_mutex_lock (&enc->property_lock);
enc->frame_size = g_value_get_enum (value);
enc->frame_samples = gst_opus_enc_get_frame_samples (enc);
gst_opus_enc_setup_base_class (enc, GST_AUDIO_ENCODER (enc));
g_mutex_unlock (&enc->property_lock);
break;
case PROP_CBR:
/* this one has an opposite meaning to the opus ctl... */
g_mutex_lock (&enc->property_lock);
enc->cbr = g_value_get_boolean (value);
if (enc->state)
opus_multistream_encoder_ctl (enc->state, OPUS_SET_VBR (!enc->cbr));
g_mutex_unlock (&enc->property_lock);
break;
case PROP_CONSTRAINED_VBR:
GST_OPUS_UPDATE_PROPERTY (constrained_vbr, boolean, VBR_CONSTRAINT);
break;
case PROP_COMPLEXITY:
GST_OPUS_UPDATE_PROPERTY (complexity, int, COMPLEXITY);
break;
case PROP_INBAND_FEC:
GST_OPUS_UPDATE_PROPERTY (inband_fec, boolean, INBAND_FEC);
break;
case PROP_DTX:
GST_OPUS_UPDATE_PROPERTY (dtx, boolean, DTX);
break;
case PROP_PACKET_LOSS_PERCENT:
GST_OPUS_UPDATE_PROPERTY (packet_loss_percentage, int, PACKET_LOSS_PERC);
break;
case PROP_MAX_PAYLOAD_SIZE:
g_mutex_lock (&enc->property_lock);
enc->max_payload_size = g_value_get_uint (value);
g_mutex_unlock (&enc->property_lock);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
#undef GST_OPUS_UPDATE_PROPERTY
}
static void
gimp_gui_config_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
GimpGuiConfig *gui_config = GIMP_GUI_CONFIG (object);
switch (property_id)
{
case PROP_MOVE_TOOL_CHANGES_ACTIVE:
g_value_set_boolean (value, gui_config->move_tool_changes_active);
break;
case PROP_IMAGE_MAP_TOOL_MAX_RECENT:
g_value_set_int (value, gui_config->image_map_tool_max_recent);
break;
case PROP_TRUST_DIRTY_FLAG:
g_value_set_boolean (value, gui_config->trust_dirty_flag);
break;
case PROP_SAVE_DEVICE_STATUS:
g_value_set_boolean (value, gui_config->save_device_status);
break;
case PROP_SAVE_SESSION_INFO:
g_value_set_boolean (value, gui_config->save_session_info);
break;
case PROP_RESTORE_SESSION:
g_value_set_boolean (value, gui_config->restore_session);
break;
case PROP_RESTORE_MONITOR:
g_value_set_boolean (value, gui_config->restore_monitor);
break;
case PROP_SAVE_TOOL_OPTIONS:
g_value_set_boolean (value, gui_config->save_tool_options);
break;
case PROP_SHOW_TOOLTIPS:
g_value_set_boolean (value, gui_config->show_tooltips);
break;
case PROP_TEAROFF_MENUS:
g_value_set_boolean (value, gui_config->tearoff_menus);
break;
case PROP_CAN_CHANGE_ACCELS:
g_value_set_boolean (value, gui_config->can_change_accels);
break;
case PROP_SAVE_ACCELS:
g_value_set_boolean (value, gui_config->save_accels);
break;
case PROP_RESTORE_ACCELS:
g_value_set_boolean (value, gui_config->restore_accels);
break;
case PROP_LAST_OPENED_SIZE:
g_value_set_int (value, gui_config->last_opened_size);
break;
case PROP_MAX_NEW_IMAGE_SIZE:
g_value_set_uint64 (value, gui_config->max_new_image_size);
break;
case PROP_TOOLBOX_COLOR_AREA:
g_value_set_boolean (value, gui_config->toolbox_color_area);
break;
case PROP_TOOLBOX_FOO_AREA:
g_value_set_boolean (value, gui_config->toolbox_foo_area);
break;
case PROP_TOOLBOX_IMAGE_AREA:
g_value_set_boolean (value, gui_config->toolbox_image_area);
break;
case PROP_TOOLBOX_WILBER:
g_value_set_boolean (value, gui_config->toolbox_wilber);
break;
case PROP_THEME_PATH:
g_value_set_string (value, gui_config->theme_path);
break;
case PROP_THEME:
g_value_set_string (value, gui_config->theme);
break;
case PROP_USE_HELP:
g_value_set_boolean (value, gui_config->use_help);
break;
case PROP_SHOW_HELP_BUTTON:
g_value_set_boolean (value, gui_config->show_help_button);
break;
case PROP_HELP_LOCALES:
g_value_set_string (value, gui_config->help_locales);
break;
case PROP_HELP_BROWSER:
g_value_set_enum (value, gui_config->help_browser);
break;
case PROP_SEARCH_SHOW_UNAVAILABLE_ACTIONS:
g_value_set_boolean (value, gui_config->search_show_unavailable);
break;
case PROP_ACTION_HISTORY_SIZE:
g_value_set_int (value, gui_config->action_history_size);
break;
case PROP_USER_MANUAL_ONLINE:
g_value_set_boolean (value, gui_config->user_manual_online);
break;
case PROP_USER_MANUAL_ONLINE_URI:
g_value_set_string (value, gui_config->user_manual_online_uri);
break;
case PROP_DOCK_WINDOW_HINT:
g_value_set_enum (value, gui_config->dock_window_hint);
break;
case PROP_CURSOR_HANDEDNESS:
g_value_set_enum (value, gui_config->cursor_handedness);
break;
case PROP_PLAYGROUND_NPD_TOOL:
g_value_set_boolean (value, gui_config->playground_npd_tool);
break;
case PROP_PLAYGROUND_HANDLE_TRANSFORM_TOOL:
g_value_set_boolean (value, gui_config->playground_handle_transform_tool);
break;
case PROP_PLAYGROUND_MYBRUSH_TOOL:
g_value_set_boolean (value, gui_config->playground_mybrush_tool);
break;
case PROP_PLAYGROUND_SEAMLESS_CLONE_TOOL:
g_value_set_boolean (value, gui_config->playground_seamless_clone_tool);
break;
case PROP_HIDE_DOCKS:
g_value_set_boolean (value, gui_config->hide_docks);
break;
case PROP_SINGLE_WINDOW_MODE:
g_value_set_boolean (value, gui_config->single_window_mode);
break;
case PROP_TABS_POSITION:
g_value_set_enum (value, gui_config->tabs_position);
break;
case PROP_LAST_TIP_SHOWN:
g_value_set_int (value, gui_config->last_tip_shown);
break;
case PROP_CURSOR_FORMAT:
case PROP_INFO_WINDOW_PER_DISPLAY:
case PROP_MENU_MNEMONICS:
case PROP_SHOW_TOOL_TIPS:
case PROP_SHOW_TIPS:
case PROP_TOOLBOX_WINDOW_HINT:
case PROP_TRANSIENT_DOCKS:
case PROP_WEB_BROWSER:
/* ignored */
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
gimp_core_config_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
GimpCoreConfig *core_config = GIMP_CORE_CONFIG (object);
switch (property_id)
{
case PROP_LANGUAGE:
g_free (core_config->language);
core_config->language = g_value_dup_string (value);
break;
case PROP_INTERPOLATION_TYPE:
core_config->interpolation_type = g_value_get_enum (value);
break;
case PROP_DEFAULT_THRESHOLD:
core_config->default_threshold = g_value_get_int (value);
break;
case PROP_PLUG_IN_PATH:
g_free (core_config->plug_in_path);
core_config->plug_in_path = g_value_dup_string (value);
break;
case PROP_MODULE_PATH:
g_free (core_config->module_path);
core_config->module_path = g_value_dup_string (value);
break;
case PROP_INTERPRETER_PATH:
g_free (core_config->interpreter_path);
core_config->interpreter_path = g_value_dup_string (value);
break;
case PROP_ENVIRON_PATH:
g_free (core_config->environ_path);
core_config->environ_path = g_value_dup_string (value);
break;
case PROP_BRUSH_PATH:
g_free (core_config->brush_path);
core_config->brush_path = g_value_dup_string (value);
break;
case PROP_BRUSH_PATH_WRITABLE:
g_free (core_config->brush_path_writable);
core_config->brush_path_writable = g_value_dup_string (value);
break;
case PROP_DYNAMICS_PATH:
g_free (core_config->dynamics_path);
core_config->dynamics_path = g_value_dup_string (value);
break;
case PROP_DYNAMICS_PATH_WRITABLE:
g_free (core_config->dynamics_path_writable);
core_config->dynamics_path_writable = g_value_dup_string (value);
break;
case PROP_MYPAINT_BRUSH_PATH:
g_free (core_config->mypaint_brush_path);
core_config->mypaint_brush_path = g_value_dup_string (value);
break;
case PROP_MYPAINT_BRUSH_PATH_WRITABLE:
g_free (core_config->mypaint_brush_path_writable);
core_config->mypaint_brush_path_writable = g_value_dup_string (value);
break;
case PROP_PATTERN_PATH:
g_free (core_config->pattern_path);
core_config->pattern_path = g_value_dup_string (value);
break;
case PROP_PATTERN_PATH_WRITABLE:
g_free (core_config->pattern_path_writable);
core_config->pattern_path_writable = g_value_dup_string (value);
break;
case PROP_PALETTE_PATH:
g_free (core_config->palette_path);
core_config->palette_path = g_value_dup_string (value);
break;
case PROP_PALETTE_PATH_WRITABLE:
g_free (core_config->palette_path_writable);
core_config->palette_path_writable = g_value_dup_string (value);
break;
case PROP_GRADIENT_PATH:
g_free (core_config->gradient_path);
core_config->gradient_path = g_value_dup_string (value);
break;
case PROP_GRADIENT_PATH_WRITABLE:
g_free (core_config->gradient_path_writable);
core_config->gradient_path_writable = g_value_dup_string (value);
break;
case PROP_TOOL_PRESET_PATH:
g_free (core_config->tool_preset_path);
core_config->tool_preset_path = g_value_dup_string (value);
break;
case PROP_TOOL_PRESET_PATH_WRITABLE:
g_free (core_config->tool_preset_path_writable);
core_config->tool_preset_path_writable = g_value_dup_string (value);
break;
case PROP_FONT_PATH:
g_free (core_config->font_path);
core_config->font_path = g_value_dup_string (value);
break;
case PROP_FONT_PATH_WRITABLE:
g_free (core_config->font_path_writable);
core_config->font_path_writable = g_value_dup_string (value);
break;
case PROP_DEFAULT_BRUSH:
g_free (core_config->default_brush);
core_config->default_brush = g_value_dup_string (value);
break;
case PROP_DEFAULT_DYNAMICS:
g_free (core_config->default_dynamics);
core_config->default_dynamics = g_value_dup_string (value);
break;
case PROP_DEFAULT_MYPAINT_BRUSH:
g_free (core_config->default_mypaint_brush);
core_config->default_mypaint_brush = g_value_dup_string (value);
break;
case PROP_DEFAULT_PATTERN:
g_free (core_config->default_pattern);
core_config->default_pattern = g_value_dup_string (value);
break;
case PROP_DEFAULT_PALETTE:
g_free (core_config->default_palette);
core_config->default_palette = g_value_dup_string (value);
break;
case PROP_DEFAULT_GRADIENT:
g_free (core_config->default_gradient);
core_config->default_gradient = g_value_dup_string (value);
break;
case PROP_DEFAULT_TOOL_PRESET:
g_free (core_config->default_tool_preset);
core_config->default_tool_preset = g_value_dup_string (value);
break;
case PROP_DEFAULT_FONT:
g_free (core_config->default_font);
core_config->default_font = g_value_dup_string (value);
break;
case PROP_GLOBAL_BRUSH:
core_config->global_brush = g_value_get_boolean (value);
break;
case PROP_GLOBAL_DYNAMICS:
core_config->global_dynamics = g_value_get_boolean (value);
break;
case PROP_GLOBAL_PATTERN:
core_config->global_pattern = g_value_get_boolean (value);
break;
case PROP_GLOBAL_PALETTE:
core_config->global_palette = g_value_get_boolean (value);
break;
case PROP_GLOBAL_GRADIENT:
core_config->global_gradient = g_value_get_boolean (value);
break;
case PROP_GLOBAL_FONT:
core_config->global_font = g_value_get_boolean (value);
break;
case PROP_DEFAULT_IMAGE:
if (g_value_get_object (value))
gimp_config_sync (g_value_get_object (value) ,
G_OBJECT (core_config->default_image), 0);
break;
case PROP_DEFAULT_GRID:
if (g_value_get_object (value))
gimp_config_sync (g_value_get_object (value),
G_OBJECT (core_config->default_grid), 0);
break;
case PROP_FILTER_HISTORY_SIZE:
core_config->filter_history_size = g_value_get_int (value);
break;
case PROP_UNDO_LEVELS:
core_config->levels_of_undo = g_value_get_int (value);
break;
case PROP_UNDO_SIZE:
core_config->undo_size = g_value_get_uint64 (value);
break;
case PROP_UNDO_PREVIEW_SIZE:
core_config->undo_preview_size = g_value_get_enum (value);
break;
case PROP_PLUGINRC_PATH:
g_free (core_config->plug_in_rc_path);
core_config->plug_in_rc_path = g_value_dup_string (value);
break;
case PROP_LAYER_PREVIEWS:
core_config->layer_previews = g_value_get_boolean (value);
break;
case PROP_GROUP_LAYER_PREVIEWS:
core_config->group_layer_previews = g_value_get_boolean (value);
break;
case PROP_LAYER_PREVIEW_SIZE:
core_config->layer_preview_size = g_value_get_enum (value);
break;
case PROP_THUMBNAIL_SIZE:
core_config->thumbnail_size = g_value_get_enum (value);
break;
case PROP_THUMBNAIL_FILESIZE_LIMIT:
core_config->thumbnail_filesize_limit = g_value_get_uint64 (value);
break;
case PROP_COLOR_MANAGEMENT:
if (g_value_get_object (value))
gimp_config_sync (g_value_get_object (value),
G_OBJECT (core_config->color_management), 0);
break;
case PROP_SAVE_DOCUMENT_HISTORY:
core_config->save_document_history = g_value_get_boolean (value);
break;
case PROP_QUICK_MASK_COLOR:
gimp_value_get_rgb (value, &core_config->quick_mask_color);
break;
case PROP_IMPORT_PROMOTE_FLOAT:
core_config->import_promote_float = g_value_get_boolean (value);
break;
case PROP_IMPORT_PROMOTE_DITHER:
core_config->import_promote_dither = g_value_get_boolean (value);
break;
case PROP_IMPORT_ADD_ALPHA:
core_config->import_add_alpha = g_value_get_boolean (value);
break;
case PROP_IMPORT_RAW_PLUG_IN:
g_free (core_config->import_raw_plug_in);
core_config->import_raw_plug_in = g_value_dup_string (value);
break;
case PROP_EXPORT_FILE_TYPE:
core_config->export_file_type = g_value_get_enum (value);
break;
case PROP_EXPORT_COLOR_PROFILE:
core_config->export_color_profile = g_value_get_boolean (value);
break;
case PROP_EXPORT_METADATA_EXIF:
core_config->export_metadata_exif = g_value_get_boolean (value);
break;
case PROP_EXPORT_METADATA_XMP:
core_config->export_metadata_xmp = g_value_get_boolean (value);
break;
case PROP_EXPORT_METADATA_IPTC:
core_config->export_metadata_iptc = g_value_get_boolean (value);
break;
case PROP_DEBUG_POLICY:
core_config->debug_policy = g_value_get_enum (value);
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
gst_vorbis_enc_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstVorbisEnc *vorbisenc;
g_return_if_fail (GST_IS_VORBISENC (object));
vorbisenc = GST_VORBISENC (object);
switch (prop_id) {
case ARG_MAX_BITRATE:
{
gboolean old_value = vorbisenc->managed;
vorbisenc->max_bitrate = g_value_get_int (value);
if (vorbisenc->max_bitrate >= 0
&& vorbisenc->max_bitrate < LOWEST_BITRATE) {
g_warning ("Lowest allowed bitrate is %d", LOWEST_BITRATE);
vorbisenc->max_bitrate = LOWEST_BITRATE;
}
if (vorbisenc->min_bitrate > 0 && vorbisenc->max_bitrate > 0)
vorbisenc->managed = TRUE;
else
vorbisenc->managed = FALSE;
if (old_value != vorbisenc->managed)
g_object_notify (object, "managed");
break;
}
case ARG_BITRATE:
vorbisenc->bitrate = g_value_get_int (value);
if (vorbisenc->bitrate >= 0 && vorbisenc->bitrate < LOWEST_BITRATE) {
g_warning ("Lowest allowed bitrate is %d", LOWEST_BITRATE);
vorbisenc->bitrate = LOWEST_BITRATE;
}
break;
case ARG_MIN_BITRATE:
{
gboolean old_value = vorbisenc->managed;
vorbisenc->min_bitrate = g_value_get_int (value);
if (vorbisenc->min_bitrate >= 0
&& vorbisenc->min_bitrate < LOWEST_BITRATE) {
g_warning ("Lowest allowed bitrate is %d", LOWEST_BITRATE);
vorbisenc->min_bitrate = LOWEST_BITRATE;
}
if (vorbisenc->min_bitrate > 0 && vorbisenc->max_bitrate > 0)
vorbisenc->managed = TRUE;
else
vorbisenc->managed = FALSE;
if (old_value != vorbisenc->managed)
g_object_notify (object, "managed");
break;
}
case ARG_QUALITY:
vorbisenc->quality = g_value_get_float (value);
if (vorbisenc->quality >= 0.0)
vorbisenc->quality_set = TRUE;
else
vorbisenc->quality_set = FALSE;
break;
case ARG_MANAGED:
vorbisenc->managed = g_value_get_boolean (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
set_property (GObject *obj,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GstOmxBaseFilter21 *self;
self = GST_OMX_BASE_FILTER21(obj);
switch (prop_id)
{
case ARG_COMPONENT_ROLE:
g_free (self->omx_role);
self->omx_role = g_value_dup_string (value);
break;
case ARG_COMPONENT_NAME:
g_free (self->omx_component);
self->omx_component = g_value_dup_string (value);
break;
case ARG_LIBRARY_NAME:
g_free (self->omx_library);
self->omx_library = g_value_dup_string (value);
break;
case ARG_USE_TIMESTAMPS:
self->gomx->use_timestamps = g_value_get_boolean (value);
break;
case ARG_GEN_TIMESTAMPS:
self->gomx->gen_timestamps = g_value_get_boolean (value);
break;
case ARG_X_SINK_0:
self->x[0] = g_value_get_uint(value);
break;
case ARG_Y_SINK_0:
self->y[0] = g_value_get_uint(value);
break;
case ARG_X_SINK_1:
self->x[1] = g_value_get_uint(value);
break;
case ARG_Y_SINK_1:
self->y[1] = g_value_get_uint(value);
break;
case ARG_NUM_INPUT_BUFFERS:
{
OMX_PARAM_PORTDEFINITIONTYPE param;
OMX_U32 nBufferCountActual = g_value_get_uint (value);
int i;
for (i = 0; i < NUM_INPUTS; i++) {
G_OMX_PORT_GET_DEFINITION (self->in_port[i], ¶m);
g_return_if_fail (nBufferCountActual >= param.nBufferCountMin);
param.nBufferCountActual = nBufferCountActual;
G_OMX_PORT_SET_DEFINITION (self->in_port[i], ¶m);
}
}
break;
case ARG_NUM_OUTPUT_BUFFERS:
{
OMX_PARAM_PORTDEFINITIONTYPE param;
OMX_U32 nBufferCountActual = g_value_get_uint (value);
G_OMX_PORT_GET_DEFINITION (self->out_port, ¶m);
g_return_if_fail (nBufferCountActual >= param.nBufferCountMin);
param.nBufferCountActual = nBufferCountActual;
G_OMX_PORT_SET_DEFINITION (self->out_port, ¶m);
}
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, prop_id, pspec);
break;
}
}
static void
gst_net_client_clock_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstNetClientClock *self = GST_NET_CLIENT_CLOCK (object);
gboolean update = FALSE;
switch (prop_id) {
case PROP_ADDRESS:
GST_OBJECT_LOCK (self);
g_free (self->priv->address);
self->priv->address = g_value_dup_string (value);
if (self->priv->address == NULL)
self->priv->address = g_strdup (DEFAULT_ADDRESS);
GST_OBJECT_UNLOCK (self);
break;
case PROP_PORT:
GST_OBJECT_LOCK (self);
self->priv->port = g_value_get_int (value);
GST_OBJECT_UNLOCK (self);
break;
case PROP_ROUNDTRIP_LIMIT:
GST_OBJECT_LOCK (self);
self->priv->roundtrip_limit = g_value_get_uint64 (value);
GST_OBJECT_UNLOCK (self);
update = TRUE;
break;
case PROP_MINIMUM_UPDATE_INTERVAL:
GST_OBJECT_LOCK (self);
self->priv->minimum_update_interval = g_value_get_uint64 (value);
GST_OBJECT_UNLOCK (self);
update = TRUE;
break;
case PROP_BUS:
GST_OBJECT_LOCK (self);
if (self->priv->bus)
gst_object_unref (self->priv->bus);
self->priv->bus = g_value_dup_object (value);
GST_OBJECT_UNLOCK (self);
update = TRUE;
break;
case PROP_BASE_TIME:{
GstClock *clock;
self->priv->base_time = g_value_get_uint64 (value);
clock = gst_system_clock_obtain ();
self->priv->internal_base_time = gst_clock_get_time (clock);
gst_object_unref (clock);
break;
}
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
if (update && self->priv->internal_clock) {
GList *l;
G_LOCK (clocks_lock);
for (l = clocks; l; l = l->next) {
ClockCache *cache = l->data;
if (cache->clock == self->priv->internal_clock) {
update_clock_cache (cache);
}
}
G_UNLOCK (clocks_lock);
}
}
static void
set_property (GObject *object, guint prop_id,
const GValue *value, GParamSpec *pspec)
{
NMSettingPPPPrivate *priv = NM_SETTING_PPP_GET_PRIVATE (object);
switch (prop_id) {
case PROP_NOAUTH:
priv->noauth = g_value_get_boolean (value);
break;
case PROP_REFUSE_EAP:
priv->refuse_eap = g_value_get_boolean (value);
break;
case PROP_REFUSE_PAP:
priv->refuse_pap = g_value_get_boolean (value);
break;
case PROP_REFUSE_CHAP:
priv->refuse_chap = g_value_get_boolean (value);
break;
case PROP_REFUSE_MSCHAP:
priv->refuse_mschap = g_value_get_boolean (value);
break;
case PROP_REFUSE_MSCHAPV2:
priv->refuse_mschapv2 = g_value_get_boolean (value);
break;
case PROP_NOBSDCOMP:
priv->nobsdcomp = g_value_get_boolean (value);
break;
case PROP_NODEFLATE:
priv->nodeflate = g_value_get_boolean (value);
break;
case PROP_NO_VJ_COMP:
priv->no_vj_comp = g_value_get_boolean (value);
break;
case PROP_REQUIRE_MPPE:
priv->require_mppe = g_value_get_boolean (value);
break;
case PROP_REQUIRE_MPPE_128:
priv->require_mppe_128 = g_value_get_boolean (value);
break;
case PROP_MPPE_STATEFUL:
priv->mppe_stateful = g_value_get_boolean (value);
break;
case PROP_CRTSCTS:
priv->crtscts = g_value_get_boolean (value);
break;
case PROP_BAUD:
priv->baud = g_value_get_uint (value);
break;
case PROP_MRU:
priv->mru = g_value_get_uint (value);
break;
case PROP_MTU:
priv->mtu = g_value_get_uint (value);
break;
case PROP_LCP_ECHO_FAILURE:
priv->lcp_echo_failure = g_value_get_uint (value);
break;
case PROP_LCP_ECHO_INTERVAL:
priv->lcp_echo_interval = g_value_get_uint (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
get_property (GObject *object, guint prop_id,
GValue *value, GParamSpec *pspec)
{
NMSettingPPP *setting = NM_SETTING_PPP (object);
switch (prop_id) {
case PROP_NOAUTH:
g_value_set_boolean (value, nm_setting_ppp_get_noauth (setting));
break;
case PROP_REFUSE_EAP:
g_value_set_boolean (value, nm_setting_ppp_get_refuse_eap (setting));
break;
case PROP_REFUSE_PAP:
g_value_set_boolean (value, nm_setting_ppp_get_refuse_pap (setting));
break;
case PROP_REFUSE_CHAP:
g_value_set_boolean (value, nm_setting_ppp_get_refuse_chap (setting));
break;
case PROP_REFUSE_MSCHAP:
g_value_set_boolean (value, nm_setting_ppp_get_refuse_mschap (setting));
break;
case PROP_REFUSE_MSCHAPV2:
g_value_set_boolean (value, nm_setting_ppp_get_refuse_mschapv2 (setting));
break;
case PROP_NOBSDCOMP:
g_value_set_boolean (value, nm_setting_ppp_get_nobsdcomp (setting));
break;
case PROP_NODEFLATE:
g_value_set_boolean (value, nm_setting_ppp_get_nodeflate (setting));
break;
case PROP_NO_VJ_COMP:
g_value_set_boolean (value, nm_setting_ppp_get_no_vj_comp (setting));
break;
case PROP_REQUIRE_MPPE:
g_value_set_boolean (value, nm_setting_ppp_get_require_mppe (setting));
break;
case PROP_REQUIRE_MPPE_128:
g_value_set_boolean (value, nm_setting_ppp_get_require_mppe_128 (setting));
break;
case PROP_MPPE_STATEFUL:
g_value_set_boolean (value, nm_setting_ppp_get_mppe_stateful (setting));
break;
case PROP_CRTSCTS:
g_value_set_boolean (value, nm_setting_ppp_get_crtscts (setting));
break;
case PROP_BAUD:
g_value_set_uint (value, nm_setting_ppp_get_baud (setting));
break;
case PROP_MRU:
g_value_set_uint (value, nm_setting_ppp_get_mru (setting));
break;
case PROP_MTU:
g_value_set_uint (value, nm_setting_ppp_get_mtu (setting));
break;
case PROP_LCP_ECHO_FAILURE:
g_value_set_uint (value, nm_setting_ppp_get_lcp_echo_failure (setting));
break;
case PROP_LCP_ECHO_INTERVAL:
g_value_set_uint (value, nm_setting_ppp_get_lcp_echo_interval (setting));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
penge_grid_view_get_property (GObject *object, guint property_id,
GValue *value, GParamSpec *pspec)
{
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}
static void
set_property (GObject *object, guint prop_id,
const GValue *value, GParamSpec *pspec)
{
NMSettingWiredPrivate *priv = NM_SETTING_WIRED_GET_PRIVATE (object);
GHashTable *new_hash;
switch (prop_id) {
case PROP_PORT:
g_free (priv->port);
priv->port = g_value_dup_string (value);
break;
case PROP_SPEED:
priv->speed = g_value_get_uint (value);
break;
case PROP_DUPLEX:
g_free (priv->duplex);
priv->duplex = g_value_dup_string (value);
break;
case PROP_AUTO_NEGOTIATE:
priv->auto_negotiate = g_value_get_boolean (value);
break;
case PROP_MAC_ADDRESS:
if (priv->device_mac_address)
g_byte_array_free (priv->device_mac_address, TRUE);
priv->device_mac_address = g_value_dup_boxed (value);
break;
case PROP_CLONED_MAC_ADDRESS:
if (priv->cloned_mac_address)
g_byte_array_free (priv->cloned_mac_address, TRUE);
priv->cloned_mac_address = g_value_dup_boxed (value);
break;
case PROP_MAC_ADDRESS_BLACKLIST:
g_slist_free_full (priv->mac_address_blacklist, g_free);
priv->mac_address_blacklist = g_value_dup_boxed (value);
break;
case PROP_MTU:
priv->mtu = g_value_get_uint (value);
break;
case PROP_S390_SUBCHANNELS:
if (priv->s390_subchannels) {
g_ptr_array_set_free_func (priv->s390_subchannels, g_free);
g_ptr_array_free (priv->s390_subchannels, TRUE);
}
priv->s390_subchannels = g_value_dup_boxed (value);
break;
case PROP_S390_NETTYPE:
g_free (priv->s390_nettype);
priv->s390_nettype = g_value_dup_string (value);
break;
case PROP_S390_OPTIONS:
/* Must make a deep copy of the hash table here... */
g_hash_table_remove_all (priv->s390_options);
new_hash = g_value_get_boxed (value);
if (new_hash)
g_hash_table_foreach (new_hash, copy_hash, priv->s390_options);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
bse_wave_osc_set_property (GObject *object,
guint param_id,
const GValue *value,
GParamSpec *pspec)
{
BseWaveOsc *self = BSE_WAVE_OSC (object);
switch (param_id)
{
BseWave *wave;
case PARAM_WAVE:
wave = bse_value_get_object (value);
if (wave != self->wave)
{
clear_wave_and_esample (self);
self->wave = wave;
if (self->wave)
{
bse_item_cross_link (BSE_ITEM (self), BSE_ITEM (self->wave), wave_osc_uncross_wave);
bse_object_proxy_notifies (self->wave, self, "notify::wave");
bse_wave_request_index (self->wave);
bse_wave_osc_update_config_wchunk (self);
bse_wave_osc_update_modules (self);
if (BSE_SOURCE_PREPARED (self))
{
/* need to make sure our modules know about BseWave vanishing
* before we return (so the wchunk update propagates)
*/
bse_engine_wait_on_trans ();
}
}
}
break;
case PARAM_CHANNEL:
self->config.channel = g_value_get_int (value) - 1;
bse_wave_osc_update_modules (self);
break;
case PARAM_FM_PERC:
self->fm_strength = sfi_value_get_real (value);
if (!self->config.exponential_fm)
{
self->config.fm_strength = self->fm_strength / 100.0;
bse_wave_osc_update_modules (self);
}
break;
case PARAM_FM_EXP:
self->config.exponential_fm = sfi_value_get_bool (value);
if (self->config.exponential_fm)
self->config.fm_strength = self->n_octaves;
else
self->config.fm_strength = self->fm_strength / 100.0;
bse_wave_osc_update_modules (self);
break;
case PARAM_FM_OCTAVES:
self->n_octaves = sfi_value_get_real (value);
if (self->config.exponential_fm)
{
self->config.fm_strength = self->n_octaves;
bse_wave_osc_update_modules (self);
}
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (self, param_id, pspec);
break;
}
}
static void
impl_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
RhythmDBImportJob *job = RHYTHMDB_IMPORT_JOB (object);
switch (prop_id) {
case PROP_DB:
g_value_set_object (value, job->priv->db);
break;
case PROP_ENTRY_TYPE:
g_value_set_object (value, job->priv->entry_type);
break;
case PROP_IGNORE_TYPE:
g_value_set_object (value, job->priv->ignore_type);
break;
case PROP_ERROR_TYPE:
g_value_set_object (value, job->priv->error_type);
break;
case PROP_TASK_LABEL:
g_value_set_string (value, job->priv->task_label);
break;
case PROP_TASK_DETAIL:
if (job->priv->scan_complete == FALSE) {
g_value_set_string (value, _("Scanning"));
} else if (job->priv->total > 0) {
g_value_take_string (value,
g_strdup_printf (_("%d of %d"),
job->priv->processed,
job->priv->total));
}
break;
case PROP_TASK_PROGRESS:
if (job->priv->scan_complete == FALSE) {
g_value_set_double (value, -1.0);
} else if (job->priv->total == 0) {
g_value_set_double (value, 0.0);
} else {
g_value_set_double (value, ((float)job->priv->processed / (float)job->priv->total));
}
break;
case PROP_TASK_OUTCOME:
if (job->priv->complete) {
g_value_set_enum (value, RB_TASK_OUTCOME_COMPLETE);
} else if (g_cancellable_is_cancelled (job->priv->cancel)) {
g_value_set_enum (value, RB_TASK_OUTCOME_CANCELLED);
} else {
g_value_set_enum (value, RB_TASK_OUTCOME_NONE);
}
break;
case PROP_TASK_NOTIFY:
g_value_set_boolean (value, job->priv->task_notify);
break;
case PROP_TASK_CANCELLABLE:
g_value_set_boolean (value, TRUE);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
{
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
static void
rss_document_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
RssDocumentPrivate *priv = RSS_DOCUMENT (object)->priv;
switch (property_id) {
case PROP_ENCODING:
g_value_set_string (value, priv->encoding);
break;
case PROP_GUID:
g_value_set_string (value, priv->guid);
break;
case PROP_TITLE:
g_value_set_string (value, priv->title);
break;
case PROP_DESCRIPTION:
g_value_set_string (value, priv->description);
break;
case PROP_LINK:
g_value_set_string (value, priv->link);
break;
case PROP_LANGUAGE:
g_value_set_string (value, priv->language);
break;
case PROP_RATING:
g_value_set_string (value, priv->rating);
break;
case PROP_COPYRIGHT:
g_value_set_string (value, priv->copyright);
break;
case PROP_PUB_DATE:
g_value_set_string (value, priv->pub_date);
break;
case PROP_EDITOR:
g_value_set_string (value, priv->editor);
break;
case PROP_EDITOR_EMAIL:
g_value_set_string (value, priv->editor_email);
break;
case PROP_EDITOR_URI:
g_value_set_string (value, priv->editor_uri);
break;
case PROP_ABOUT:
g_value_set_string (value, priv->about);
break;
case PROP_CONTRIBUTOR:
g_value_set_string (value, priv->contributor);
break;
case PROP_CONTRIBUTOR_EMAIL:
g_value_set_string (value, priv->contributor_email);
break;
case PROP_CONTRIBUTOR_URI:
g_value_set_string (value, priv->contributor_uri);
break;
case PROP_GENERATOR:
g_value_set_string (value, priv->generator);
break;
case PROP_GENERATOR_URI:
g_value_set_string (value, priv->generator_uri);
break;
case PROP_GENERATOR_VERSION:
g_value_set_string (value, priv->generator_version);
break;
case PROP_IMAGE_TITLE:
g_value_set_string (value, priv->image_title);
break;
case PROP_IMAGE_URL:
g_value_set_string (value, priv->image_url);
break;
case PROP_IMAGE_LINK:
g_value_set_string (value, priv->image_link);
break;
case PROP_TTL:
g_value_set_int (value, priv->ttl);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}
}
static void
gst_rpi_cam_src_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstRpiCamSrc *src = GST_RPICAMSRC (object);
g_mutex_lock (&src->config_lock);
switch (prop_id) {
case PROP_CAMERA_NUMBER:
src->capture_config.cameraNum = g_value_get_int (value);
break;
case PROP_BITRATE:
src->capture_config.bitrate = g_value_get_int (value);
src->capture_config.change_flags |= PROP_CHANGE_ENCODING;
break;
case PROP_KEYFRAME_INTERVAL:
src->capture_config.intraperiod = g_value_get_int (value);
src->capture_config.change_flags |= PROP_CHANGE_ENCODING;
break;
case PROP_PREVIEW:
src->capture_config.preview_parameters.wantPreview =
g_value_get_boolean (value);
src->capture_config.change_flags |= PROP_CHANGE_PREVIEW;
break;
case PROP_PREVIEW_ENCODED:
src->capture_config.immutableInput = g_value_get_boolean (value);
src->capture_config.change_flags |= PROP_CHANGE_PREVIEW;
break;
case PROP_FULLSCREEN:
src->capture_config.preview_parameters.wantFullScreenPreview =
g_value_get_boolean (value);
src->capture_config.change_flags |= PROP_CHANGE_PREVIEW;
break;
case PROP_PREVIEW_OPACITY:
src->capture_config.preview_parameters.opacity = g_value_get_int (value);
src->capture_config.change_flags |= PROP_CHANGE_PREVIEW;
break;
case PROP_SHARPNESS:
src->capture_config.camera_parameters.sharpness = g_value_get_int (value);
src->capture_config.change_flags |= PROP_CHANGE_COLOURBALANCE;
break;
case PROP_CONTRAST:
src->capture_config.camera_parameters.contrast = g_value_get_int (value);
src->capture_config.change_flags |= PROP_CHANGE_COLOURBALANCE;
break;
case PROP_BRIGHTNESS:
src->capture_config.camera_parameters.brightness =
g_value_get_int (value);
src->capture_config.change_flags |= PROP_CHANGE_COLOURBALANCE;
break;
case PROP_SATURATION:
src->capture_config.camera_parameters.saturation =
g_value_get_int (value);
src->capture_config.change_flags |= PROP_CHANGE_COLOURBALANCE;
break;
case PROP_ISO:
src->capture_config.camera_parameters.ISO = g_value_get_int (value);
src->capture_config.change_flags |= PROP_CHANGE_SENSOR_SETTINGS;
break;
case PROP_VIDEO_STABILISATION:
src->capture_config.camera_parameters.videoStabilisation =
g_value_get_boolean (value);
src->capture_config.change_flags |= PROP_CHANGE_VIDEO_STABILISATION;
break;
case PROP_EXPOSURE_COMPENSATION:
src->capture_config.camera_parameters.exposureCompensation =
g_value_get_int (value);
src->capture_config.change_flags |= PROP_CHANGE_SENSOR_SETTINGS;
break;
case PROP_EXPOSURE_MODE:
src->capture_config.camera_parameters.exposureMode =
g_value_get_enum (value);
src->capture_config.change_flags |= PROP_CHANGE_SENSOR_SETTINGS;
break;
case PROP_EXPOSURE_METERING_MODE:
src->capture_config.camera_parameters.exposureMeterMode =
g_value_get_enum (value);
src->capture_config.change_flags |= PROP_CHANGE_SENSOR_SETTINGS;
break;
case PROP_ROTATION:
src->capture_config.camera_parameters.rotation = g_value_get_int (value);
break;
case PROP_AWB_MODE:
src->capture_config.camera_parameters.awbMode = g_value_get_enum (value);
src->capture_config.change_flags |= PROP_CHANGE_AWB;
break;
case PROP_AWB_GAIN_RED:
src->capture_config.camera_parameters.awb_gains_r =
g_value_get_float (value);
src->capture_config.change_flags |= PROP_CHANGE_AWB;
break;
case PROP_AWB_GAIN_BLUE:
src->capture_config.camera_parameters.awb_gains_b =
g_value_get_float (value);
src->capture_config.change_flags |= PROP_CHANGE_AWB;
break;
case PROP_IMAGE_EFFECT:
src->capture_config.camera_parameters.imageEffect =
g_value_get_enum (value);
src->capture_config.change_flags |= PROP_CHANGE_IMAGE_COLOUR_EFFECT;
break;
case PROP_HFLIP:
src->capture_config.camera_parameters.hflip = g_value_get_boolean (value);
src->capture_config.change_flags |= PROP_CHANGE_ORIENTATION;
break;
case PROP_VFLIP:
src->capture_config.camera_parameters.vflip = g_value_get_boolean (value);
src->capture_config.change_flags |= PROP_CHANGE_ORIENTATION;
break;
case PROP_ROI_X:
src->capture_config.camera_parameters.roi.x = g_value_get_float (value);
src->capture_config.change_flags |= PROP_CHANGE_ROI;
break;
case PROP_ROI_Y:
src->capture_config.camera_parameters.roi.y = g_value_get_float (value);
src->capture_config.change_flags |= PROP_CHANGE_ROI;
break;
case PROP_ROI_W:
src->capture_config.camera_parameters.roi.w = g_value_get_float (value);
src->capture_config.change_flags |= PROP_CHANGE_ROI;
break;
case PROP_ROI_H:
src->capture_config.camera_parameters.roi.h = g_value_get_float (value);
src->capture_config.change_flags |= PROP_CHANGE_ROI;
break;
case PROP_QUANTISATION_PARAMETER:
src->capture_config.quantisationParameter = g_value_get_int (value);
src->capture_config.change_flags |= PROP_CHANGE_ENCODING;
break;
case PROP_INLINE_HEADERS:
src->capture_config.bInlineHeaders = g_value_get_boolean (value);
break;
case PROP_SHUTTER_SPEED:
src->capture_config.camera_parameters.shutter_speed =
g_value_get_int (value);
src->capture_config.change_flags |= PROP_CHANGE_SENSOR_SETTINGS;
break;
case PROP_DRC:
src->capture_config.camera_parameters.drc_level =
g_value_get_enum (value);
src->capture_config.change_flags |= PROP_CHANGE_SENSOR_SETTINGS;
break;
case PROP_SENSOR_MODE:
src->capture_config.sensor_mode = g_value_get_enum (value);
src->capture_config.change_flags |= PROP_CHANGE_SENSOR_SETTINGS;
break;
case PROP_ANNOTATION_MODE:
src->capture_config.camera_parameters.enable_annotate =
g_value_get_flags (value);
src->capture_config.change_flags |= PROP_CHANGE_ANNOTATION;
break;
case PROP_ANNOTATION_TEXT:
strncpy (src->capture_config.camera_parameters.annotate_string,
g_value_get_string (value), MMAL_CAMERA_ANNOTATE_MAX_TEXT_LEN_V2);
src->capture_config.
camera_parameters.annotate_string[MMAL_CAMERA_ANNOTATE_MAX_TEXT_LEN_V2
- 1] = '\0';
src->capture_config.change_flags |= PROP_CHANGE_ANNOTATION;
break;
case PROP_ANNOTATION_TEXT_SIZE:
src->capture_config.
camera_parameters.annotate_text_size = g_value_get_int (value);
src->capture_config.change_flags |= PROP_CHANGE_ANNOTATION;
break;
case PROP_ANNOTATION_TEXT_COLOUR:
src->capture_config.
camera_parameters.annotate_text_colour = g_value_get_int (value);
src->capture_config.change_flags |= PROP_CHANGE_ANNOTATION;
break;
case PROP_ANNOTATION_TEXT_BG_COLOUR:
src->capture_config.
camera_parameters.annotate_bg_colour = g_value_get_int (value);
src->capture_config.change_flags |= PROP_CHANGE_ANNOTATION;
break;
case PROP_INTRA_REFRESH_TYPE:
src->capture_config.intra_refresh_type = g_value_get_enum (value);
src->capture_config.change_flags |= PROP_CHANGE_ENCODING;
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
g_mutex_unlock (&src->config_lock);
}
static void
gst_capsfilter_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstCapsFilter *capsfilter = GST_CAPSFILTER (object);
switch (prop_id) {
case PROP_FILTER_CAPS:{
GstCaps *new_caps;
GstCaps *old_caps, *suggest, *nego;
const GstCaps *new_caps_val = gst_value_get_caps (value);
if (new_caps_val == NULL) {
new_caps = gst_caps_new_any ();
} else {
new_caps = (GstCaps *) new_caps_val;
gst_caps_ref (new_caps);
}
GST_OBJECT_LOCK (capsfilter);
old_caps = capsfilter->filter_caps;
capsfilter->filter_caps = new_caps;
GST_OBJECT_UNLOCK (capsfilter);
gst_caps_unref (old_caps);
GST_DEBUG_OBJECT (capsfilter, "set new caps %" GST_PTR_FORMAT, new_caps);
/* filter the currently negotiated format against the new caps */
GST_OBJECT_LOCK (GST_BASE_TRANSFORM_SINK_PAD (object));
nego = GST_PAD_CAPS (GST_BASE_TRANSFORM_SINK_PAD (object));
if (nego) {
GstStructure *s1, *s2;
/* first check if the name is the same */
s1 = gst_caps_get_structure (nego, 0);
s2 = gst_caps_get_structure (new_caps, 0);
GST_DEBUG_OBJECT (capsfilter, "we had negotiated caps %" GST_PTR_FORMAT,
nego);
if (gst_structure_get_name_id (s1) == gst_structure_get_name_id (s2)) {
/* same name, copy all fields from the new caps into the previously
* negotiated caps */
suggest = gst_caps_copy (nego);
s1 = gst_caps_get_structure (suggest, 0);
gst_structure_foreach (s2, (GstStructureForeachFunc) copy_func, s1);
GST_DEBUG_OBJECT (capsfilter, "copied structure fields");
} else {
GST_DEBUG_OBJECT (capsfilter, "different structure names");
/* different names, we can only suggest the complete caps */
suggest = gst_caps_copy (new_caps);
}
} else {
GST_DEBUG_OBJECT (capsfilter, "no negotiated caps");
/* no previous caps, the getcaps function will be used to find suitable
* caps */
suggest = NULL;
}
GST_OBJECT_UNLOCK (GST_BASE_TRANSFORM_SINK_PAD (object));
if (suggest) {
gst_base_transform_suggest (GST_BASE_TRANSFORM (object), suggest, 0);
gst_caps_unref (suggest);
}
/* FIXME: Need to activate these caps on the pads
* http://bugzilla.gnome.org/show_bug.cgi?id=361718
*/
break;
}
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
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_ANNOTATION_TEXT_SIZE:
g_value_set_int (value, src->capture_config.camera_parameters.annotate_text_size);
break;
case PROP_ANNOTATION_TEXT_COLOUR:
g_value_set_int (value, src->capture_config.camera_parameters.annotate_text_colour);
break;
case PROP_ANNOTATION_TEXT_BG_COLOUR:
g_value_set_int (value, src->capture_config.camera_parameters.annotate_bg_colour);
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);
}
void
ags_delay_audio_set_property(GObject *gobject,
guint prop_id,
const GValue *value,
GParamSpec *param_spec)
{
AgsDelayAudio *delay_audio;
delay_audio = AGS_DELAY_AUDIO(gobject);
switch(prop_id){
case PROP_BPM:
{
AgsPort *port;
port = (AgsPort *) g_value_get_object(value);
if(port == delay_audio->bpm){
return;
}
if(delay_audio->bpm != NULL){
g_object_unref(G_OBJECT(delay_audio->bpm));
}
if(port != NULL){
g_object_ref(G_OBJECT(port));
}
delay_audio->bpm = port;
}
break;
case PROP_TACT:
{
AgsPort *port;
port = (AgsPort *) g_value_get_object(value);
if(port == delay_audio->tact){
return;
}
if(delay_audio->tact != NULL){
g_object_unref(G_OBJECT(delay_audio->tact));
}
if(port != NULL){
g_object_ref(G_OBJECT(port));
}
delay_audio->tact = port;
}
break;
case PROP_NOTATION_DELAY:
{
AgsPort *port;
port = (AgsPort *) g_value_get_object(value);
if(port == delay_audio->notation_delay){
return;
}
if(delay_audio->notation_delay != NULL){
g_object_unref(G_OBJECT(delay_audio->notation_delay));
}
if(port != NULL){
g_object_ref(G_OBJECT(port));
}
delay_audio->notation_delay = port;
}
break;
case PROP_SEQUENCER_DELAY:
{
AgsPort *port;
port = (AgsPort *) g_value_get_object(value);
if(port == delay_audio->sequencer_delay){
return;
}
if(delay_audio->sequencer_delay != NULL){
g_object_unref(G_OBJECT(delay_audio->sequencer_delay));
}
if(port != NULL){
g_object_ref(G_OBJECT(port));
}
delay_audio->sequencer_delay = port;
}
break;
case PROP_NOTATION_DURATION:
{
AgsPort *port;
port = (AgsPort *) g_value_get_object(value);
if(port == delay_audio->notation_duration){
return;
}
if(delay_audio->notation_duration != NULL){
g_object_unref(G_OBJECT(delay_audio->notation_duration));
}
if(port != NULL){
g_object_ref(G_OBJECT(port));
}
delay_audio->notation_duration = port;
}
break;
case PROP_SEQUENCER_DURATION:
{
AgsPort *port;
port = (AgsPort *) g_value_get_object(value);
if(port == delay_audio->sequencer_duration){
return;
}
if(delay_audio->sequencer_duration != NULL){
g_object_unref(G_OBJECT(delay_audio->sequencer_duration));
}
if(port != NULL){
g_object_ref(G_OBJECT(port));
}
delay_audio->sequencer_duration = port;
}
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(gobject, prop_id, param_spec);
break;
}
}
static void
gimp_text_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
GimpText *text = GIMP_TEXT (object);
switch (property_id)
{
case PROP_TEXT:
g_value_set_string (value, text->text);
break;
case PROP_FONT:
g_value_set_string (value, text->font);
break;
case PROP_FONT_SIZE:
g_value_set_double (value, text->font_size);
break;
case PROP_UNIT:
g_value_set_int (value, text->unit);
break;
case PROP_HINTING:
g_value_set_boolean (value, text->hinting);
break;
case PROP_AUTOHINT:
g_value_set_boolean (value, text->autohint);
break;
case PROP_ANTIALIAS:
g_value_set_boolean (value, text->antialias);
break;
case PROP_KERNING:
g_value_set_boolean (value, text->kerning);
break;
case PROP_BASE_DIR:
g_value_set_enum (value, text->base_dir);
break;
case PROP_LANGUAGE:
g_value_set_string (value, text->language);
break;
case PROP_COLOR:
g_value_set_boxed (value, &text->color);
break;
case PROP_OUTLINE:
g_value_set_enum (value, text->outline);
break;
case PROP_JUSTIFICATION:
g_value_set_enum (value, text->justify);
break;
case PROP_INDENTATION:
g_value_set_double (value, text->indent);
break;
case PROP_LINE_SPACING:
g_value_set_double (value, text->line_spacing);
break;
case PROP_LETTER_SPACING:
g_value_set_double (value, text->letter_spacing);
break;
case PROP_BOX_MODE:
g_value_set_enum (value, text->box_mode);
break;
case PROP_BOX_WIDTH:
g_value_set_double (value, text->box_width);
break;
case PROP_BOX_HEIGHT:
g_value_set_double (value, text->box_height);
break;
case PROP_BOX_UNIT:
g_value_set_int (value, text->box_unit);
break;
case PROP_TRANSFORMATION:
g_value_set_boxed (value, &text->transformation);
break;
case PROP_OFFSET_X:
g_value_set_double (value, text->offset_x);
break;
case PROP_OFFSET_Y:
g_value_set_double (value, text->offset_y);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
gst_shout2send_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstShout2send *shout2send;
shout2send = GST_SHOUT2SEND (object);
switch (prop_id) {
case ARG_IP:
if (shout2send->ip)
g_free (shout2send->ip);
shout2send->ip = g_strdup (g_value_get_string (value));
break;
case ARG_PORT:
shout2send->port = g_value_get_int (value);
break;
case ARG_PASSWORD:
if (shout2send->password)
g_free (shout2send->password);
shout2send->password = g_strdup (g_value_get_string (value));
break;
case ARG_USERNAME:
if (shout2send->username)
g_free (shout2send->username);
shout2send->username = g_strdup (g_value_get_string (value));
break;
case ARG_PUBLIC:
shout2send->ispublic = g_value_get_boolean (value);
break;
case ARG_STREAMNAME: /* Name of the stream */
if (shout2send->streamname)
g_free (shout2send->streamname);
shout2send->streamname = g_strdup (g_value_get_string (value));
break;
case ARG_DESCRIPTION: /* Description of the stream */
if (shout2send->description)
g_free (shout2send->description);
shout2send->description = g_strdup (g_value_get_string (value));
break;
case ARG_GENRE: /* Genre of the stream */
if (shout2send->genre)
g_free (shout2send->genre);
shout2send->genre = g_strdup (g_value_get_string (value));
break;
case ARG_PROTOCOL: /* protocol to connect with */
shout2send->protocol = g_value_get_enum (value);
break;
case ARG_MOUNT: /* mountpoint of stream (icecast only) */
if (shout2send->mount)
g_free (shout2send->mount);
shout2send->mount = g_strdup (g_value_get_string (value));
break;
case ARG_URL: /* Url of the stream (I'm guessing) */
if (shout2send->url)
g_free (shout2send->url);
shout2send->url = g_strdup (g_value_get_string (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gimp_text_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
GimpText *text = GIMP_TEXT (object);
GimpRGB *color;
GimpMatrix2 *matrix;
switch (property_id)
{
case PROP_TEXT:
g_free (text->text);
text->text = g_value_dup_string (value);
break;
case PROP_FONT:
{
const gchar *font = g_value_get_string (value);
g_free (text->font);
if (font)
{
gsize len = strlen (font);
if (g_str_has_suffix (font, " Not-Rotated"))
len -= strlen ( " Not-Rotated");
text->font = g_strndup (font, len);
}
else
{
text->font = NULL;
}
}
break;
case PROP_FONT_SIZE:
text->font_size = g_value_get_double (value);
break;
case PROP_UNIT:
text->unit = g_value_get_int (value);
break;
case PROP_HINTING:
text->hinting = g_value_get_boolean (value);
break;
case PROP_AUTOHINT:
text->autohint = g_value_get_boolean (value);
break;
case PROP_ANTIALIAS:
text->antialias = g_value_get_boolean (value);
break;
case PROP_KERNING:
text->kerning = g_value_get_boolean (value);
break;
case PROP_LANGUAGE:
g_free (text->language);
text->language = g_value_dup_string (value);
break;
case PROP_BASE_DIR:
text->base_dir = g_value_get_enum (value);
break;
case PROP_COLOR:
color = g_value_get_boxed (value);
text->color = *color;
break;
case PROP_OUTLINE:
text->outline = g_value_get_enum (value);
break;
case PROP_JUSTIFICATION:
text->justify = g_value_get_enum (value);
break;
case PROP_INDENTATION:
text->indent = g_value_get_double (value);
break;
case PROP_LINE_SPACING:
text->line_spacing = g_value_get_double (value);
break;
case PROP_LETTER_SPACING:
text->letter_spacing = g_value_get_double (value);
break;
case PROP_BOX_MODE:
text->box_mode = g_value_get_enum (value);
break;
case PROP_BOX_WIDTH:
text->box_width = g_value_get_double (value);
break;
case PROP_BOX_HEIGHT:
text->box_height = g_value_get_double (value);
break;
case PROP_BOX_UNIT:
text->box_unit = g_value_get_int (value);
break;
case PROP_TRANSFORMATION:
matrix = g_value_get_boxed (value);
text->transformation = *matrix;
break;
case PROP_OFFSET_X:
text->offset_x = g_value_get_double (value);
break;
case PROP_OFFSET_Y:
text->offset_y = g_value_get_double (value);
break;
case PROP_BORDER:
text->border = g_value_get_int (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
gst_rsvg_overlay_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstRsvgOverlay *overlay = GST_RSVG_OVERLAY (object);
GST_RSVG_LOCK (overlay);
switch (prop_id) {
case PROP_DATA:
{
gst_rsvg_overlay_set_svg_data (overlay, g_value_get_string (value),
FALSE);
break;
}
case PROP_LOCATION:
{
gst_rsvg_overlay_set_svg_data (overlay, g_value_get_string (value), TRUE);
break;
}
case PROP_FIT_TO_FRAME:
{
if (g_value_get_boolean (value)) {
overlay->x_offset = 0;
overlay->y_offset = 0;
overlay->x_relative = 0.0;
overlay->y_relative = 0.0;
overlay->width = 0;
overlay->height = 0;
overlay->width_relative = 1.0;
overlay->height_relative = 1.0;
} else {
overlay->width_relative = 0;
overlay->height_relative = 0;
}
break;
}
case PROP_X:
{
overlay->x_offset = g_value_get_int (value);
break;
}
case PROP_Y:
{
overlay->y_offset = g_value_get_int (value);
break;
}
case PROP_X_RELATIVE:
{
overlay->x_relative = g_value_get_float (value);
break;
}
case PROP_Y_RELATIVE:
{
overlay->y_relative = g_value_get_float (value);
break;
}
case PROP_WIDTH:
{
overlay->width = g_value_get_int (value);
break;
}
case PROP_HEIGHT:
{
overlay->height = g_value_get_int (value);
break;
}
case PROP_WIDTH_RELATIVE:
{
overlay->width_relative = g_value_get_float (value);
break;
}
case PROP_HEIGHT_RELATIVE:
{
overlay->height_relative = g_value_get_float (value);
break;
}
default:
{
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
GST_RSVG_UNLOCK (overlay);
}
static void
gst_mfxpostproc_set_property (GObject * object,
guint prop_id, const GValue * value, GParamSpec * pspec)
{
GstMfxPostproc *const vpp = GST_MFXPOSTPROC (object);
switch (prop_id) {
case PROP_ASYNC_DEPTH:
vpp->async_depth = g_value_get_uint (value);
break;
case PROP_FORMAT:
vpp->format = g_value_get_enum (value);
break;
case PROP_WIDTH:
vpp->width = g_value_get_uint (value);
break;
case PROP_HEIGHT:
vpp->height = g_value_get_uint (value);
break;
case PROP_FORCE_ASPECT_RATIO:
vpp->keep_aspect = g_value_get_boolean (value);
break;
case PROP_DEINTERLACE_MODE:
vpp->deinterlace_mode = g_value_get_enum (value);
vpp->flags |= GST_MFX_POSTPROC_FLAG_DEINTERLACING;
break;
case PROP_DENOISE:
vpp->denoise_level = g_value_get_uint (value);
vpp->flags |= GST_MFX_POSTPROC_FLAG_DENOISE;
break;
case PROP_DETAIL:
vpp->detail_level = g_value_get_uint (value);
vpp->flags |= GST_MFX_POSTPROC_FLAG_DETAIL;
break;
case PROP_HUE:
if (vpp->hue != g_value_get_float (value)) {
vpp->hue = g_value_get_float (value);
vpp->flags |= GST_MFX_POSTPROC_FLAG_HUE;
vpp->cb_changed |= GST_MFX_POSTPROC_FLAG_HUE;
}
break;
case PROP_SATURATION:
if (vpp->saturation != g_value_get_float (value)) {
vpp->saturation = g_value_get_float (value);
vpp->flags |= GST_MFX_POSTPROC_FLAG_SATURATION;
vpp->cb_changed |= GST_MFX_POSTPROC_FLAG_SATURATION;
}
break;
case PROP_BRIGHTNESS:
if (vpp->brightness != g_value_get_float (value)) {
vpp->brightness = g_value_get_float (value);
vpp->flags |= GST_MFX_POSTPROC_FLAG_BRIGHTNESS;
vpp->cb_changed |= GST_MFX_POSTPROC_FLAG_BRIGHTNESS;
}
break;
case PROP_CONTRAST:
if (vpp->contrast != g_value_get_float (value)) {
vpp->contrast = g_value_get_float (value);
vpp->flags |= GST_MFX_POSTPROC_FLAG_CONTRAST;
vpp->cb_changed |= GST_MFX_POSTPROC_FLAG_CONTRAST;
}
break;
case PROP_ROTATION:
vpp->angle = g_value_get_enum (value);
vpp->flags |= GST_MFX_POSTPROC_FLAG_ROTATION;
break;
case PROP_FRAMERATE:
vpp->fps_n = gst_value_get_fraction_numerator (value);
vpp->fps_d = gst_value_get_fraction_denominator (value);
break;
case PROP_FRC_ALGORITHM:
vpp->alg = g_value_get_enum (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
places_cfg_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
PlacesCfg *cfg = XFCE_PLACES_CFG (object);
gint val;
switch (prop_id)
{
case PROP_SHOW_BUTTON_TYPE:
if ( cfg->show_button_icon && !cfg->show_button_label) val = 0;
else if ( cfg->show_button_icon && cfg->show_button_label) val = 2;
else val = 1;
g_value_set_uint (value, val);
break;
case PROP_BUTTON_LABEL:
g_value_set_string (value, cfg->label);
break;
case PROP_SHOW_ICONS:
g_value_set_boolean (value, cfg->show_icons);
break;
case PROP_SHOW_VOLUMES:
g_value_set_boolean (value, cfg->show_volumes);
break;
case PROP_MOUNT_OPEN_VOLUMES:
g_value_set_boolean (value, cfg->mount_open_volumes);
break;
case PROP_SHOW_BOOKMARKS:
g_value_set_boolean (value, cfg->show_bookmarks);
break;
case PROP_SERVER_CONNECT_CMD:
g_value_set_string (value, cfg->server_connect_cmd);
break;
case PROP_NETWORK_CMD:
g_value_set_string (value, cfg->network_cmd);
break;
#if USE_RECENT_DOCUMENTS
case PROP_SHOW_RECENT:
g_value_set_boolean (value, cfg->show_recent);
break;
case PROP_SHOW_RECENT_CLEAR:
g_value_set_boolean (value, cfg->show_recent_clear);
break;
case PROP_SHOW_RECENT_NUMBER:
g_value_set_uint (value, cfg->show_recent_number);
break;
#endif
case PROP_SEARCH_CMD:
g_value_set_string (value, cfg->search_cmd);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gimp_color_config_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
GimpColorConfig *color_config = GIMP_COLOR_CONFIG (object);
GError *error = NULL;
switch (property_id)
{
case PROP_MODE:
color_config->mode = g_value_get_enum (value);
break;
case PROP_RGB_PROFILE:
gimp_color_config_set_rgb_profile (color_config,
g_value_get_string (value),
&error);
break;
case PROP_CMYK_PROFILE:
gimp_color_config_set_cmyk_profile (color_config,
g_value_get_string (value),
&error);
break;
case PROP_DISPLAY_PROFILE:
gimp_color_config_set_display_profile (color_config,
g_value_get_string (value),
&error);
break;
case PROP_DISPLAY_PROFILE_FROM_GDK:
color_config->display_profile_from_gdk = g_value_get_boolean (value);
break;
case PROP_PRINTER_PROFILE:
gimp_color_config_set_printer_profile (color_config,
g_value_get_string (value),
&error);
break;
case PROP_DISPLAY_RENDERING_INTENT:
color_config->display_intent = g_value_get_enum (value);
break;
case PROP_DISPLAY_USE_BPC:
color_config->display_use_black_point_compensation = g_value_get_boolean (value);
break;
case PROP_SIMULATION_RENDERING_INTENT:
color_config->simulation_intent = g_value_get_enum (value);
break;
case PROP_SIMULATION_USE_BPC:
color_config->simulation_use_black_point_compensation = g_value_get_boolean (value);
break;
case PROP_SIMULATION_GAMUT_CHECK:
color_config->simulation_gamut_check = g_value_get_boolean (value);
break;
case PROP_OUT_OF_GAMUT_COLOR:
color_config->out_of_gamut_color = *(GimpRGB *) g_value_get_boxed (value);
break;
case PROP_DISPLAY_MODULE:
g_free (color_config->display_module);
color_config->display_module = g_value_dup_string (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
if (error)
{
g_message ("%s", error->message);
g_clear_error (&error);
}
}
/**
* up_device_set_property:
**/
static void
up_device_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
{
UpDevice *device = UP_DEVICE (object);
switch (prop_id) {
case PROP_NATIVE_PATH:
g_free (device->priv->native_path);
device->priv->native_path = g_strdup (g_value_get_string (value));
break;
case PROP_VENDOR:
g_free (device->priv->vendor);
device->priv->vendor = g_strdup (g_value_get_string (value));
break;
case PROP_MODEL:
g_free (device->priv->model);
device->priv->model = g_strdup (g_value_get_string (value));
break;
case PROP_SERIAL:
g_free (device->priv->serial);
device->priv->serial = g_strdup (g_value_get_string (value));
break;
case PROP_UPDATE_TIME:
device->priv->update_time = g_value_get_uint64 (value);
break;
case PROP_TYPE:
device->priv->type = g_value_get_uint (value);
break;
case PROP_POWER_SUPPLY:
device->priv->power_supply = g_value_get_boolean (value);
break;
case PROP_ONLINE:
device->priv->online = g_value_get_boolean (value);
break;
case PROP_IS_PRESENT:
device->priv->is_present = g_value_get_boolean (value);
break;
case PROP_IS_RECHARGEABLE:
device->priv->is_rechargeable = g_value_get_boolean (value);
break;
case PROP_HAS_HISTORY:
device->priv->has_history = g_value_get_boolean (value);
break;
case PROP_HAS_STATISTICS:
device->priv->has_statistics = g_value_get_boolean (value);
break;
case PROP_STATE:
device->priv->state = g_value_get_uint (value);
break;
case PROP_CAPACITY:
device->priv->capacity = g_value_get_double (value);
break;
case PROP_ENERGY:
device->priv->energy = g_value_get_double (value);
break;
case PROP_ENERGY_EMPTY:
device->priv->energy_empty = g_value_get_double (value);
break;
case PROP_ENERGY_FULL:
device->priv->energy_full = g_value_get_double (value);
break;
case PROP_ENERGY_FULL_DESIGN:
device->priv->energy_full_design = g_value_get_double (value);
break;
case PROP_ENERGY_RATE:
device->priv->energy_rate = g_value_get_double (value);
break;
case PROP_VOLTAGE:
device->priv->voltage = g_value_get_double (value);
break;
case PROP_LUMINOSITY:
device->priv->luminosity = g_value_get_double (value);
break;
case PROP_TIME_TO_EMPTY:
device->priv->time_to_empty = g_value_get_int64 (value);
break;
case PROP_TIME_TO_FULL:
device->priv->time_to_full = g_value_get_int64 (value);
break;
case PROP_PERCENTAGE:
device->priv->percentage = g_value_get_double (value);
break;
case PROP_TECHNOLOGY:
device->priv->technology = g_value_get_uint (value);
break;
case PROP_RECALL_NOTICE:
device->priv->recall_notice = g_value_get_boolean (value);
break;
case PROP_RECALL_VENDOR:
g_free (device->priv->recall_vendor);
device->priv->recall_vendor = g_strdup (g_value_get_string (value));
break;
case PROP_RECALL_URL:
g_free (device->priv->recall_url);
device->priv->recall_url = g_strdup (g_value_get_string (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gst_face_detect_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstFaceDetect *filter = GST_FACE_DETECT (object);
switch (prop_id) {
case PROP_FACE_PROFILE:
g_free (filter->face_profile);
if (filter->cvFaceDetect)
cvReleaseHaarClassifierCascade (&filter->cvFaceDetect);
filter->face_profile = g_value_dup_string (value);
filter->cvFaceDetect =
gst_face_detect_load_profile (filter, filter->face_profile);
break;
case PROP_NOSE_PROFILE:
g_free (filter->nose_profile);
if (filter->cvNoseDetect)
cvReleaseHaarClassifierCascade (&filter->cvNoseDetect);
filter->nose_profile = g_value_dup_string (value);
filter->cvNoseDetect =
gst_face_detect_load_profile (filter, filter->nose_profile);
break;
case PROP_MOUTH_PROFILE:
g_free (filter->mouth_profile);
if (filter->cvMouthDetect)
cvReleaseHaarClassifierCascade (&filter->cvMouthDetect);
filter->mouth_profile = g_value_dup_string (value);
filter->cvMouthDetect =
gst_face_detect_load_profile (filter, filter->mouth_profile);
break;
case PROP_EYES_PROFILE:
g_free (filter->eyes_profile);
if (filter->cvEyesDetect)
cvReleaseHaarClassifierCascade (&filter->cvEyesDetect);
filter->eyes_profile = g_value_dup_string (value);
filter->cvEyesDetect =
gst_face_detect_load_profile (filter, filter->eyes_profile);
break;
case PROP_DISPLAY:
filter->display = g_value_get_boolean (value);
break;
case PROP_SCALE_FACTOR:
filter->scale_factor = g_value_get_double (value);
break;
case PROP_MIN_NEIGHBORS:
filter->min_neighbors = g_value_get_int (value);
break;
case PROP_MIN_SIZE_WIDTH:
filter->min_size_width = g_value_get_int (value);
break;
case PROP_MIN_SIZE_HEIGHT:
filter->min_size_height = g_value_get_int (value);
break;
case PROP_FLAGS:
filter->flags = g_value_get_flags (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
