自学教程：C++ G_OBJECT_WARN_INVALID_PROPERTY_ID函数代码示例

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

//.........这里部分代码省略.........			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;		}}

//.........这里部分代码省略.........        {          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 voidgst_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}

//.........这里部分代码省略.........    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;    }}

//.........这里部分代码省略.........    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 voidgst_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 voidset_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], &param);					g_return_if_fail (nBufferCountActual >= param.nBufferCountMin);					param.nBufferCountActual = nBufferCountActual;					G_OMX_PORT_SET_DEFINITION (self->in_port[i], &param);				}            }            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, &param);				g_return_if_fail (nBufferCountActual >= param.nBufferCountMin);				param.nBufferCountActual = nBufferCountActual;				G_OMX_PORT_SET_DEFINITION (self->out_port, &param);            }            break;        default:            G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, prop_id, pspec);            break;    }}

static voidgst_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 voidset_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 voidget_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 voidpenge_grid_view_get_property (GObject *object, guint property_id,                              GValue *value, GParamSpec *pspec){  G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);}

static voidset_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 voidbse_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 voidimpl_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 voidset_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec){	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);}

static voidrss_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);	}}

//.........这里部分代码省略.........      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 voidgst_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;  }}

//.........这里部分代码省略.........      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);}

//.........这里部分代码省略.........      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 voidgimp_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 voidgst_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;  }}

//.........这里部分代码省略.........    {    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 voidgst_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 voidgst_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 voidplaces_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 voidgimp_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 (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 voidgst_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;  }}