static void fs_rawudp_component_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { FsRawUdpComponent *self = FS_RAWUDP_COMPONENT (object); switch (prop_id) { case PROP_SENDING: FS_RAWUDP_COMPONENT_LOCK (self); g_value_set_boolean (value, self->priv->sending); FS_RAWUDP_COMPONENT_UNLOCK (self); break; case PROP_FORCED_CANDIDATE: FS_RAWUDP_COMPONENT_LOCK (self); g_value_set_boxed (value, self->priv->local_forced_candidate); FS_RAWUDP_COMPONENT_UNLOCK (self); break; case PROP_COMPONENT: g_value_set_uint (value, self->priv->component); break; #ifdef HAVE_GUPNP case PROP_UPNP_MAPPING: g_value_set_boolean (value, self->priv->upnp_mapping); break; case PROP_UPNP_DISCOVERY: g_value_set_boolean (value, self->priv->upnp_discovery); break; case PROP_UPNP_MAPPING_TIMEOUT: g_value_set_uint (value, self->priv->upnp_mapping_timeout); break; case PROP_UPNP_DISCOVERY_TIMEOUT: g_value_set_uint (value, self->priv->upnp_discovery_timeout); break; #endif default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void gst_cmml_tag_stream_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) { GstCmmlTagStream *stream = GST_CMML_TAG_STREAM (object); switch (property_id) { case GST_CMML_TAG_STREAM_TIMEBASE: g_value_set_string (value, (gchar *) stream->timebase); break; case GST_CMML_TAG_STREAM_UTC: g_value_set_string (value, (gchar *) stream->utc); break; case GST_CMML_TAG_STREAM_IMPORTS: g_value_set_boxed (value, stream->imports); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); } }
static void _ncm_mpi_job_mcmc_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { NcmMPIJobMCMC *mjmcmc = NCM_MPI_JOB_MCMC (object); NcmMPIJobMCMCPrivate * const self = mjmcmc->priv; g_return_if_fail (NCM_IS_MPI_JOB_MCMC (object)); switch (prop_id) { case PROP_FIT: g_value_set_object (value, self->fit); break; case PROP_FUNC_ARRAY: g_value_set_boxed (value, self->func_oa); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void gst_cmml_tag_head_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) { GstCmmlTagHead *head = GST_CMML_TAG_HEAD (object); switch (property_id) { case GST_CMML_TAG_HEAD_TITLE: g_value_set_string (value, (gchar *) head->title); break; case GST_CMML_TAG_HEAD_BASE: g_value_set_string (value, (gchar *) head->base); break; case GST_CMML_TAG_HEAD_META: g_value_set_boxed (value, head->meta); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); } }
static gboolean ip_addresses_check_and_copy (GBinding *binding, const GValue *source_value, GValue *target_value, gpointer user_data) { int family = GPOINTER_TO_INT (user_data); char **strings; int i; strings = g_value_get_boxed (source_value); for (i = 0; strings[i]; i++) { if (!nm_utils_ipaddr_valid (family, strings[i])) return FALSE; } g_value_set_boxed (target_value, strings); return TRUE; }
static void jana_gtk_recurrence_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { JanaGtkRecurrencePrivate *priv = RECURRENCE_PRIVATE (object); switch (property_id) { case PROP_RECUR : g_value_set_boxed (value, priv->recur); break; case PROP_TIME : g_value_set_object (value, priv->time); break; case PROP_EDITABLE : g_value_set_boolean (value, priv->editable); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); } }
static void nmt_route_table_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { NmtRouteTablePrivate *priv = NMT_ROUTE_TABLE_GET_PRIVATE (object); switch (prop_id) { case PROP_FAMILY: g_value_set_int (value, priv->family); break; case PROP_ROUTES: g_value_set_boxed (value, priv->routes); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void browser_tabs_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { BrowserTabs *bt = BROWSER_TABS (object); switch (prop_id) { case PROP_NOTEBOOK: g_value_set_object (value, bt->priv->notebook); break; case PROP_HEAD_LINES: g_value_set_object (value, bt->priv->headlines); break; case PROP_TAB_INFO_LIST: g_value_set_boxed (value, bt->priv->list); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void clutter_input_device_evdev_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { ClutterInputDeviceEvdev *device = CLUTTER_INPUT_DEVICE_EVDEV (object); switch (prop_id) { case PROP_DEVICE_MATRIX: g_value_set_boxed (value, &device->device_matrix); break; case PROP_OUTPUT_ASPECT_RATIO: g_value_set_double (value, device->output_ratio); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); } }
/** * vips_value_set_ref_string: * @value: (out): GValue to set * @str: C string to copy into the GValue * * Copies the C string @str into @value. * * vips_ref_string are immutable C strings that are copied between images by * copying reference-counted pointers, making the much more efficient than * regular GValue strings. * * Returns: 0 on success, -1 otherwise. */ int vips_value_set_ref_string( GValue *value, const char *str ) { VipsArea *area; char *str_copy; g_assert( G_VALUE_TYPE( value ) == VIPS_TYPE_REF_STRING ); str_copy = g_strdup( str ); area = vips_area_new( (VipsCallbackFn) vips_free, str_copy ); /* Handy place to cache this. */ area->length = strlen( str ); g_value_set_boxed( value, area ); vips_area_unref( area ); return( 0 ); }
static void clutter_widget_get_property ( GObject *_object, guint _prop_id, GValue *_value, GParamSpec *_pspec ) { ClutterWidget *widget = CLUTTER_WIDGET(_object); ClutterColor color; switch (_prop_id) { case PROP_BORDER_COLOR: clutter_widget_get_border_color (widget, &color); g_value_set_boxed (_value, &color); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (_object, _prop_id, _pspec); break; } }
GVariant * _tp_boxed_to_variant (GType gtype, const gchar *variant_type, gpointer boxed) { GValue v = G_VALUE_INIT; GVariant *ret; g_return_val_if_fail (boxed != NULL, NULL); g_value_init (&v, gtype); g_value_set_boxed (&v, boxed); ret = dbus_g_value_build_g_variant (&v); g_return_val_if_fail (!tp_strdiff (g_variant_get_type_string (ret), variant_type), NULL); g_value_unset (&v); return g_variant_ref_sink (ret); }
static void get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { NMDhcpConfig *self = NM_DHCP_CONFIG (object); switch (prop_id) { case PROP_FAMILY: g_value_set_int (value, nm_dhcp_config_get_family (self)); break; case PROP_OPTIONS: g_value_set_boxed (value, nm_dhcp_config_get_options (self)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void soup_request_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { SoupRequest *request = SOUP_REQUEST (object); switch (prop_id) { case PROP_URI: g_value_set_boxed (value, request->priv->uri); break; case PROP_SESSION: g_value_set_object (value, request->priv->session); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void names_model_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { NamesModel *names_model; names_model = NAMES_MODEL (object); switch (prop_id) { case PROP_CONNECTION: g_value_set_boxed (value, names_model->connection); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void __bluetooth_ptr_array_free(gpointer data) { GValue value = { 0, }; gchar *name = NULL; gchar *type = NULL; if(data == NULL) return; g_value_init(&value, DBUS_STRUCT_STRING_STRING); g_value_set_boxed(&value, data); dbus_g_type_struct_get(&value, 0, &name, 1, &type, G_MAXUINT); g_free(name); g_free(type); }
static void gvir_storage_vol_get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { GVirStorageVol *vol = GVIR_STORAGE_VOL(object); GVirStorageVolPrivate *priv = vol->priv; switch (prop_id) { case PROP_HANDLE: g_value_set_boxed(value, priv->handle); break; case PROP_POOL: g_value_set_object(value, priv->pool); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); } }
static void rc_ui_scrollable_label_get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { RCUiScrollableLabel *text = RC_UI_SCROLLABLE_LABEL(object); RCUiScrollableLabelPrivate *priv = text->priv; switch(prop_id) { case PROP_TEXT: g_value_set_string(value, priv->text); break; case PROP_ATTRS: g_value_set_boxed(value, priv->attrs); break; case PROP_PERCENT: g_value_set_double(value, priv->percent); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); break; } }
static void gst_jack_audio_src_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { GstJackAudioSrc *src = GST_JACK_AUDIO_SRC (object); switch (prop_id) { case PROP_CONNECT: g_value_set_enum (value, src->connect); break; case PROP_SERVER: g_value_set_string (value, src->server); break; case PROP_CLIENT: g_value_set_boxed (value, src->jclient); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void nemo_preview_cover_art_fetcher_get_property (GObject *gobject, guint prop_id, GValue *value, GParamSpec *pspec) { NemoPreviewCoverArtFetcher *self = NEMO_PREVIEW_COVER_ART_FETCHER (gobject); NemoPreviewCoverArtFetcherPrivate *priv = NEMO_PREVIEW_COVER_ART_FETCHER_GET_PRIVATE (self); switch (prop_id) { case PROP_COVER: g_value_set_object (value, priv->cover); break; case PROP_TAGLIST: g_value_set_boxed (value, priv->taglist); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec); break; } }
/** * convert enumerated handler chunks to a UINT_ARRAY GValue */ static GValue* handler_to_val(nm_handler_t *handler, configuration_attribute_type_t type) { GValue *val; GArray *array; enumerator_t *enumerator; chunk_t chunk; enumerator = handler->create_enumerator(handler, type); array = g_array_new (FALSE, TRUE, sizeof (guint32)); while (enumerator->enumerate(enumerator, &chunk)) { g_array_append_val (array, *(u_int32_t*)chunk.ptr); } enumerator->destroy(enumerator); val = g_slice_new0 (GValue); g_value_init (val, DBUS_TYPE_G_UINT_ARRAY); g_value_set_boxed (val, array); return val; }
static void gkm_secret_item_get_property (GObject *obj, guint prop_id, GValue *value, GParamSpec *pspec) { GkmSecretItem *self = GKM_SECRET_ITEM (obj); switch (prop_id) { case PROP_COLLECTION: g_value_set_object (value, gkm_secret_item_get_collection (self)); break; case PROP_FIELDS: g_value_set_boxed (value, gkm_secret_item_get_fields (self)); break; case PROP_SCHEMA: g_value_set_string (value, gkm_secret_item_get_schema (self)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, prop_id, pspec); break; } }
void v8_to_gvalue(Handle<Value> v, GValue *gv, GParamSpec *spec) { if(v->IsNumber()) { g_value_init(gv, G_TYPE_FLOAT); g_value_set_float(gv, v->NumberValue()); } else if(v->IsString()) { String::Utf8Value value(v->ToString()); if(spec->value_type == GST_TYPE_CAPS) { GstCaps* caps = gst_caps_from_string(*value); g_value_init(gv, GST_TYPE_CAPS); g_value_set_boxed(gv, caps); } else { g_value_init(gv, G_TYPE_STRING); g_value_set_string(gv, *value); } } else if(v->IsBoolean()) { g_value_init(gv, G_TYPE_BOOLEAN); g_value_set_boolean(gv, v->BooleanValue()); } return; }
static void seahorse_gpgme_uid_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { SeahorseGpgmeUid *self = SEAHORSE_GPGME_UID (object); switch (prop_id) { case PROP_PUBKEY: g_value_set_boxed (value, seahorse_gpgme_uid_get_pubkey (self)); break; case PROP_USERID: g_value_set_pointer (value, seahorse_gpgme_uid_get_userid (self)); break; case PROP_GPGME_INDEX: g_value_set_uint (value, seahorse_gpgme_uid_get_gpgme_index (self)); break; case PROP_ACTUAL_INDEX: g_value_set_uint (value, seahorse_gpgme_uid_get_actual_index (self)); break; } }
static void static_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { TpStaticHandleRepo *self = TP_STATIC_HANDLE_REPO (object); switch (property_id) { case PROP_HANDLE_TYPE: g_value_set_uint (value, self->handle_type); break; case PROP_HANDLE_NAMES: g_value_set_boxed (value, g_strdupv (self->handle_names)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
static void byzanz_recorder_get_property (GObject *object, guint param_id, GValue *value, GParamSpec * pspec) { ByzanzRecorder *recorder = BYZANZ_RECORDER (object); switch (param_id) { case PROP_WINDOW: g_value_set_object (value, recorder->window); break; case PROP_AREA: g_value_set_boxed (value, &recorder->area); break; case PROP_RECORDING: g_value_set_boolean (value, byzanz_recorder_get_recording (recorder)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec); break; } }
static void get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { BMRemoteSettingsPrivate *priv = BM_REMOTE_SETTINGS_GET_PRIVATE (object); switch (prop_id) { case PROP_BUS: g_value_set_boxed (value, priv->bus); break; case PROP_SCOPE: g_value_set_uint (value, priv->scope); break; case PROP_SERVICE_RUNNING: g_value_set_boolean (value, priv->service_running); 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) { NMSettingOlpcMesh *setting = NM_SETTING_OLPC_MESH (object); switch (prop_id) { case PROP_SSID: g_value_set_boxed (value, nm_setting_olpc_mesh_get_ssid (setting)); break; case PROP_CHANNEL: g_value_set_uint (value, nm_setting_olpc_mesh_get_channel (setting)); break; case PROP_DHCP_ANYCAST_ADDRESS: g_value_set_string (value, nm_setting_olpc_mesh_get_dhcp_anycast_address (setting)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static gboolean gst_rtp_jitter_buffer_get_clock_rate (GstRtpJitterBuffer * jitterbuffer, guint8 pt) { GValue ret = { 0 }; GValue args[2] = { {0}, {0} }; GstCaps *caps; gboolean res; g_value_init (&args[0], GST_TYPE_ELEMENT); g_value_set_object (&args[0], jitterbuffer); g_value_init (&args[1], G_TYPE_UINT); g_value_set_uint (&args[1], pt); g_value_init (&ret, GST_TYPE_CAPS); g_value_set_boxed (&ret, NULL); g_signal_emitv (args, gst_rtp_jitter_buffer_signals[SIGNAL_REQUEST_PT_MAP], 0, &ret); g_value_unset (&args[0]); g_value_unset (&args[1]); caps = (GstCaps *) g_value_dup_boxed (&ret); g_value_unset (&ret); if (!caps) goto no_caps; res = gst_jitter_buffer_sink_parse_caps (jitterbuffer, caps); gst_caps_unref (caps); return res; /* ERRORS */ no_caps: { GST_DEBUG_OBJECT (jitterbuffer, "could not get caps"); return FALSE; } }
static gboolean border_value_parse (GtkCssParser *parser, GFile *base, GValue *value) { GtkBorder border = { 0, }; guint i, numbers[4]; for (i = 0; i < G_N_ELEMENTS (numbers); i++) { if (!_gtk_css_parser_try_uint (parser, &numbers[i])) break; /* XXX: shouldn't allow spaces here? */ _gtk_css_parser_try (parser, "px", TRUE); } if (i == 0) { _gtk_css_parser_error (parser, "Expected valid border"); return FALSE; } border.top = numbers[0]; if (i > 1) border.right = numbers[1]; else border.right = border.top; if (i > 2) border.bottom = numbers[2]; else border.bottom = border.top; if (i > 3) border.left = numbers[3]; else border.left = border.right; g_value_set_boxed (value, &border); return TRUE; }