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