static gpointer value_as_pointer (GValue *value) { if (g_value_fits_pointer (value)) return g_value_peek_pointer (value); if (G_VALUE_HOLDS_BOOLEAN (value)) return (void*) g_value_get_boolean (value); if (G_VALUE_HOLDS_CHAR (value)) return (void*) (gssize) g_value_get_char (value); if (G_VALUE_HOLDS_UCHAR (value)) return (void*) (gsize) g_value_get_uchar (value); if (G_VALUE_HOLDS_INT (value)) return (void*) g_value_get_int (value); if (G_VALUE_HOLDS_UINT (value)) return (void*) g_value_get_uint (value); if (G_VALUE_HOLDS_LONG (value)) return (void*) g_value_get_long (value); if (G_VALUE_HOLDS_ULONG (value)) return (void*) g_value_get_ulong (value); if (G_VALUE_HOLDS_FLOAT (value)) return (void*) (gssize) g_value_get_float (value); if (G_VALUE_HOLDS_DOUBLE (value)) return (void*) (gssize) g_value_get_double (value); if (G_VALUE_HOLDS_ENUM (value)) return (void*) (gssize) g_value_get_enum (value); if (G_VALUE_HOLDS_FLAGS (value)) return (void*) (gsize) g_value_get_flags (value); return (void*) 0x1373babe; }
static void gst_ss_demux_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstSSDemux *demux = GST_SS_DEMUX (object); switch (prop_id) { case PROP_COOKIES: g_strfreev (demux->cookies); demux->cookies = g_strdupv (g_value_get_boxed (value)); break; case PROP_ALLOW_AUDIO_ONLY: demux->allow_audio_only = g_value_get_boolean (value); break; case PROP_FRAGMENTS_CACHE: demux->fragments_cache = g_value_get_uint (value); break; case PROP_BITRATE_SWITCH_TOLERANCE: demux->bitrate_switch_tol = g_value_get_float (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
double AccessibilityUIElement::intValue() const { if (!ATK_IS_OBJECT(m_element.get())) return 0; if (ATK_IS_VALUE(m_element.get())) { GValue value = G_VALUE_INIT; atk_value_get_current_value(ATK_VALUE(m_element.get()), &value); if (!G_VALUE_HOLDS_FLOAT(&value)) return 0; return g_value_get_float(&value); } // Consider headings as an special case when returning the "int value" of // an AccessibilityUIElement, so we can reuse some tests to check the level // both for HTML headings and objects with the aria-level attribute. if (atk_object_get_role(ATK_OBJECT(m_element.get())) == ATK_ROLE_HEADING) { String headingLevel = getAttributeSetValueForId(ATK_OBJECT(m_element.get()), ObjectAttributeType, "level"); bool ok; double headingLevelValue = headingLevel.toDouble(&ok); if (ok) return headingLevelValue; } return 0; }
static void clutter_align_constraint_set_property (GObject *gobject, guint prop_id, const GValue *value, GParamSpec *pspec) { ClutterAlignConstraint *align = CLUTTER_ALIGN_CONSTRAINT (gobject); switch (prop_id) { case PROP_SOURCE: clutter_align_constraint_set_source (align, g_value_get_object (value)); break; case PROP_ALIGN_AXIS: clutter_align_constraint_set_align_axis (align, g_value_get_enum (value)); break; case PROP_FACTOR: clutter_align_constraint_set_factor (align, g_value_get_float (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec); break; } }
static double qof_gobject_double_getter (gpointer data, QofParam *getter) { GObject *gob = data; double fval; GParamSpec *gps = getter->param_userdata; /* Note that the return type must actually be of type * getter->param_type but we just follow the hard-coded * mapping below ... */ if (G_IS_PARAM_SPEC_FLOAT(gps)) { GValue gval = {G_TYPE_INVALID}; g_value_init (&gval, G_TYPE_FLOAT); g_object_get_property (gob, getter->param_name, &gval); fval = g_value_get_float (&gval); return fval; } else if (G_IS_PARAM_SPEC_DOUBLE(gps)) { GValue gval = {G_TYPE_INVALID}; g_value_init (&gval, G_TYPE_DOUBLE); g_object_get_property (gob, getter->param_name, &gval); fval = g_value_get_double (&gval); return fval; } PWARN ("unhandled parameter type %s for paramter %s", G_PARAM_SPEC_TYPE_NAME(gps), getter->param_name); return 0.0; }
static void clutter_bind_constraint_set_property (GObject *gobject, guint prop_id, const GValue *value, GParamSpec *pspec) { ClutterBindConstraint *bind = CLUTTER_BIND_CONSTRAINT (gobject); switch (prop_id) { case PROP_SOURCE: clutter_bind_constraint_set_source (bind, g_value_get_object (value)); break; case PROP_COORDINATE: clutter_bind_constraint_set_coordinate (bind, g_value_get_enum (value)); break; case PROP_OFFSET: clutter_bind_constraint_set_offset (bind, g_value_get_float (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec); break; } }
static void gst_webp_enc_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstWebpEnc *webpenc = GST_WEBP_ENC (object); switch (prop_id) { case PROP_LOSSLESS: webpenc->lossless = g_value_get_boolean (value); break; case PROP_QUALITY: webpenc->quality = g_value_get_float (value); break; case PROP_SPEED: webpenc->speed = g_value_get_uint (value); break; case PROP_PRESET: webpenc->preset = g_value_get_enum (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void handle_fraction (IrisProgressWatch *watch, IrisMessage *message) { const GValue *value = iris_message_get_data (message); watch->fraction = g_value_get_float (value); }
/* Set/get properties */ static void _xfdashboard_fill_box_layout_set_property(GObject *inObject, guint inPropID, const GValue *inValue, GParamSpec *inSpec) { XfdashboardFillBoxLayout *self=XFDASHBOARD_FILL_BOX_LAYOUT(inObject); switch(inPropID) { case PROP_ORIENTATION: xfdashboard_fill_box_layout_set_orientation(self, g_value_get_enum(inValue)); break; case PROP_SPACING: xfdashboard_fill_box_layout_set_spacing(self, g_value_get_float(inValue)); break; case PROP_HOMOGENEOUS: xfdashboard_fill_box_layout_set_homogeneous(self, g_value_get_boolean(inValue)); break; case PROP_KEEP_ASPECT: xfdashboard_fill_box_layout_set_keep_aspect(self, g_value_get_boolean(inValue)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(inObject, inPropID, inSpec); break; } }
static void clutter_snap_constraint_set_property (GObject *gobject, guint prop_id, const GValue *value, GParamSpec *pspec) { ClutterSnapConstraint *self = CLUTTER_SNAP_CONSTRAINT (gobject); switch (prop_id) { case PROP_SOURCE: clutter_snap_constraint_set_source (self, g_value_get_object (value)); break; case PROP_FROM_EDGE: clutter_snap_constraint_set_edges (self, g_value_get_enum (value), self->to_edge); break; case PROP_TO_EDGE: clutter_snap_constraint_set_edges (self, self->from_edge, g_value_get_enum (value)); break; case PROP_OFFSET: clutter_snap_constraint_set_offset (self, g_value_get_float (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec); break; } }
static inline gboolean gtk_argloc_set_from_value (GtkArg *arg, GValue *value, gboolean copy_string) { switch (G_TYPE_FUNDAMENTAL (arg->type)) { case G_TYPE_CHAR: *GTK_RETLOC_CHAR (*arg) = g_value_get_char (value); break; case G_TYPE_UCHAR: *GTK_RETLOC_UCHAR (*arg) = g_value_get_uchar (value); break; case G_TYPE_BOOLEAN: *GTK_RETLOC_BOOL (*arg) = g_value_get_boolean (value); break; case G_TYPE_INT: *GTK_RETLOC_INT (*arg) = g_value_get_int (value); break; case G_TYPE_UINT: *GTK_RETLOC_UINT (*arg) = g_value_get_uint (value); break; case G_TYPE_LONG: *GTK_RETLOC_LONG (*arg) = g_value_get_long (value); break; case G_TYPE_ULONG: *GTK_RETLOC_ULONG (*arg) = g_value_get_ulong (value); break; case G_TYPE_ENUM: *GTK_RETLOC_ENUM (*arg) = g_value_get_enum (value); break; case G_TYPE_FLAGS: *GTK_RETLOC_FLAGS (*arg) = g_value_get_flags (value); break; case G_TYPE_FLOAT: *GTK_RETLOC_FLOAT (*arg) = g_value_get_float (value); break; case G_TYPE_DOUBLE: *GTK_RETLOC_DOUBLE (*arg) = g_value_get_double (value); break; case G_TYPE_BOXED: *GTK_RETLOC_BOXED (*arg) = g_value_get_boxed (value); break; case G_TYPE_POINTER: *GTK_RETLOC_POINTER (*arg) = g_value_get_pointer (value); break; case G_TYPE_OBJECT: *GTK_RETLOC_POINTER (*arg) = g_value_get_object (value); break; case G_TYPE_STRING: if (copy_string) *GTK_RETLOC_STRING (*arg) = g_value_dup_string (value); else *GTK_RETLOC_STRING (*arg) = (char *) g_value_get_string (value); break; default: return FALSE; } return TRUE; }
/* Set/get properties */ static void _xfdashboard_viewpad_set_property(GObject *inObject, guint inPropID, const GValue *inValue, GParamSpec *inSpec) { XfdashboardViewpad *self=XFDASHBOARD_VIEWPAD(inObject); switch(inPropID) { case PROP_SPACING: xfdashboard_viewpad_set_spacing(self, g_value_get_float(inValue)); break; case PROP_HSCROLLBAR_POLICY: xfdashboard_viewpad_set_horizontal_scrollbar_policy(self, (XfdashboardPolicy)g_value_get_enum(inValue)); break; case PROP_VSCROLLBAR_POLICY: xfdashboard_viewpad_set_vertical_scrollbar_policy(self, (XfdashboardPolicy)g_value_get_enum(inValue)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(inObject, inPropID, inSpec); break; } }
static void gst_ladspa_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstSignalProcessor *gsp; GstSignalProcessorClass *gsp_class; gsp = GST_SIGNAL_PROCESSOR (object); gsp_class = GST_SIGNAL_PROCESSOR_GET_CLASS (object); /* remember, properties have an offset of 1 */ prop_id--; /* only input ports */ g_return_if_fail (prop_id < gsp_class->num_control_in); /* now see what type it is */ switch (pspec->value_type) { case G_TYPE_BOOLEAN: gsp->control_in[prop_id] = g_value_get_boolean (value) ? 1.f : 0.f; break; case G_TYPE_INT: gsp->control_in[prop_id] = g_value_get_int (value); break; case G_TYPE_FLOAT: gsp->control_in[prop_id] = g_value_get_float (value); break; default: g_assert_not_reached (); } }
/* Set/get properties */ static void _xfdashboard_view_selector_set_property(GObject *inObject, guint inPropID, const GValue *inValue, GParamSpec *inSpec) { XfdashboardViewSelector *self=XFDASHBOARD_VIEW_SELECTOR(inObject); switch(inPropID) { case PROP_VIEWPAD: xfdashboard_view_selector_set_viewpad(self, XFDASHBOARD_VIEWPAD(g_value_get_object(inValue))); break; case PROP_SPACING: xfdashboard_view_selector_set_spacing(self, g_value_get_float(inValue)); break; case PROP_ORIENTATION: xfdashboard_view_selector_set_orientation(self, g_value_get_enum(inValue)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(inObject, inPropID, inSpec); break; } }
/** * clutter_shader_set_uniform: * @shader: a #ClutterShader. * @name: name of uniform in GLSL shader program to set. * @value: a #ClutterShaderFloat, #ClutterShaderInt or #ClutterShaderMatrix * #GValue. * * Sets a user configurable variable in the GLSL shader programs attached to * a #ClutterShader. * * Since: 1.0 */ void clutter_shader_set_uniform (ClutterShader *shader, const gchar *name, const GValue *value) { ClutterShaderPrivate *priv; GLint location = 0; gsize size; g_return_if_fail (CLUTTER_IS_SHADER (shader)); g_return_if_fail (name != NULL); g_return_if_fail (value != NULL); g_return_if_fail (CLUTTER_VALUE_HOLDS_SHADER_FLOAT (value) || CLUTTER_VALUE_HOLDS_SHADER_INT (value) || CLUTTER_VALUE_HOLDS_SHADER_MATRIX (value) || G_VALUE_HOLDS_FLOAT (value) || G_VALUE_HOLDS_INT (value)); priv = shader->priv; g_return_if_fail (priv->program != COGL_INVALID_HANDLE); location = cogl_program_get_uniform_location (priv->program, name); if (CLUTTER_VALUE_HOLDS_SHADER_FLOAT (value)) { const GLfloat *floats; floats = clutter_value_get_shader_float (value, &size); cogl_program_uniform_float (location, size, 1, floats); } else if (CLUTTER_VALUE_HOLDS_SHADER_INT (value)) { const int *ints; ints = clutter_value_get_shader_int (value, &size); cogl_program_uniform_int (location, size, 1, ints); } else if (CLUTTER_VALUE_HOLDS_SHADER_MATRIX (value)) { const GLfloat *matrix; matrix = clutter_value_get_shader_matrix (value, &size); cogl_program_uniform_matrix (location, size, 1, FALSE, matrix); } else if (G_VALUE_HOLDS_FLOAT (value)) { GLfloat float_val = g_value_get_float (value); cogl_program_uniform_float (location, 1, 1, &float_val); } else if (G_VALUE_HOLDS_INT (value)) { int int_val = g_value_get_int (value); cogl_program_uniform_int (location, 1, 1, &int_val); } else g_assert_not_reached (); }
void ags_port_real_safe_write(AgsPort *port, GValue *value) { guint overall_size; gpointer data; if(port == NULL){ return; } overall_size = port->port_value_length * port->port_value_size; pthread_mutex_lock(&(port->mutex)); if(!port->port_value_is_pointer){ if(port->port_value_type == G_TYPE_BOOLEAN){ port->port_value.ags_port_boolean = g_value_get_boolean(value); }else if(port->port_value_type == G_TYPE_INT64){ port->port_value.ags_port_int = g_value_get_int64(value); }else if(port->port_value_type == G_TYPE_UINT64){ port->port_value.ags_port_uint = g_value_get_uint64(value); }else if(port->port_value_type == G_TYPE_FLOAT){ port->port_value.ags_port_float = (gfloat) g_value_get_float(value); }else if(port->port_value_type == G_TYPE_DOUBLE){ port->port_value.ags_port_double = g_value_get_double(value); }else if(port->port_value_type == G_TYPE_POINTER){ port->port_value.ags_port_pointer = g_value_get_pointer(value); }else if(port->port_value_type == G_TYPE_OBJECT){ port->port_value.ags_port_object = g_value_get_object(value); }else{ g_warning("ags_port.c: unknown type\0"); } }else{ data = g_value_get_pointer(value); if(port->port_value_type == G_TYPE_BOOLEAN){ memcpy(port->port_value.ags_port_boolean_ptr, data, overall_size); }else if(port->port_value_type == G_TYPE_INT64){ memcpy(port->port_value.ags_port_int_ptr, data, overall_size); }else if(port->port_value_type == G_TYPE_UINT64){ memcpy(port->port_value.ags_port_uint_ptr, data, overall_size); }else if(port->port_value_type == G_TYPE_DOUBLE){ memcpy(port->port_value.ags_port_double_ptr, data, overall_size); }else if(port->port_value_type == G_TYPE_POINTER){ port->port_value.ags_port_pointer = data; }else{ data = g_value_get_object(value); if(port->port_value_type == G_TYPE_OBJECT){ port->port_value.ags_port_object = data; }else{ g_warning("ags_port.c: unknown type\0"); } } } pthread_mutex_unlock(&(port->mutex)); }
static char * float_value_to_string (const GValue *value) { char buf[G_ASCII_DTOSTR_BUF_SIZE]; g_ascii_dtostr (buf, sizeof (buf), g_value_get_float (value)); return g_strdup (buf); }
static void float_changed (GObject *object, GParamSpec *pspec, gpointer data) { GtkAdjustment *adj = GTK_ADJUSTMENT (data); GValue val = G_VALUE_INIT; g_value_init (&val, G_TYPE_FLOAT); get_property_value (object, pspec, &val); if (g_value_get_float (&val) != (float) gtk_adjustment_get_value (adj)) { block_controller (G_OBJECT (adj)); gtk_adjustment_set_value (adj, g_value_get_float (&val)); unblock_controller (G_OBJECT (adj)); } g_value_unset (&val); }
static gchar * gnac_properties_dup_framerate(const GValue *value) { gfloat val = g_value_get_float(value); if (val == 0) return NULL; /* Translators: framerate */ return g_strdup_printf(_("%.3lf fps"), val); }
static void gst_shape_wipe_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstShapeWipe *self = GST_SHAPE_WIPE (object); switch (prop_id) { case PROP_POSITION: self->mask_position = g_value_get_float (value); break; case PROP_BORDER: self->mask_border = g_value_get_float (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void _vala_soy_atoms_vector_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) { soyatomsVector * self; self = G_TYPE_CHECK_INSTANCE_CAST (object, SOY_ATOMS_TYPE_VECTOR, soyatomsVector); switch (property_id) { case SOY_ATOMS_VECTOR_X: soy_atoms_vector_set_x (self, g_value_get_float (value)); break; case SOY_ATOMS_VECTOR_Y: soy_atoms_vector_set_y (self, g_value_get_float (value)); break; case SOY_ATOMS_VECTOR_Z: soy_atoms_vector_set_z (self, g_value_get_float (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
static void gst_gl_alpha_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstGLAlpha *alpha = GST_GL_ALPHA (object); GST_OBJECT_LOCK (alpha); switch (prop_id) { case PROP_METHOD:{ alpha->method = g_value_get_enum (value); break; } case PROP_ALPHA:{ alpha->alpha = g_value_get_double (value); break; } case PROP_TARGET_R: alpha->target_r = g_value_get_uint (value); break; case PROP_TARGET_G: alpha->target_g = g_value_get_uint (value); break; case PROP_TARGET_B: alpha->target_b = g_value_get_uint (value); break; case PROP_ANGLE: alpha->angle = g_value_get_float (value); break; case PROP_NOISE_LEVEL: alpha->noise_level = g_value_get_float (value); break; case PROP_BLACK_SENSITIVITY: alpha->black_sensitivity = g_value_get_uint (value); break; case PROP_WHITE_SENSITIVITY: alpha->white_sensitivity = g_value_get_uint (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } GST_OBJECT_UNLOCK (alpha); gst_gl_alpha_update_properties (alpha); }
static void gst_bgfg_acmmm2003_set_property(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { GstBgFgACMMM2003 *filter = GST_BGFG_ACMMM2003(object); switch (prop_id) { case PROP_VERBOSE: filter->verbose = g_value_get_boolean(value); break; case PROP_DISPLAY: filter->display = g_value_get_boolean(value); break; case PROP_MASK: filter->send_mask_events = g_value_get_boolean(value); break; case PROP_ROI: filter->send_roi_events = g_value_get_boolean(value); break; case PROP_CONVEX_HULL: filter->convex_hull = g_value_get_boolean(value); break; case PROP_PERIMETER_SCALE: filter->perimeter_scale = g_value_get_float(value); break; case PROP_MIN_AREA: filter->min_area = g_value_get_float(value); if (filter->model != NULL) ((CvFGDStatModel*)filter->model)->params.minArea = filter->min_area; break; case PROP_NUM_ERODE_ITERATIONS: filter->n_erode_iterations = g_value_get_uint(value); if (filter->model != NULL) ((CvFGDStatModel*)filter->model)->params.erode_iterations = filter->n_erode_iterations; break; case PROP_NUM_DILATE_ITERATIONS: filter->n_dilate_iterations = g_value_get_uint(value); if (filter->model != NULL) ((CvFGDStatModel*)filter->model)->params.dilate_iterations = filter->n_dilate_iterations; break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); break; } }
static void gst_base_camera_src_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstBaseCameraSrc *self = GST_BASE_CAMERA_SRC (object); switch (prop_id) { case PROP_MODE: gst_base_camera_src_set_mode (GST_BASE_CAMERA_SRC (self), g_value_get_enum (value)); break; case PROP_ZOOM:{ self->zoom = g_value_get_float (value); /* limit to max-zoom */ if (self->zoom > self->max_zoom) { GST_DEBUG_OBJECT (self, "Clipping zoom %f to max-zoom %f", self->zoom, self->max_zoom); self->zoom = self->max_zoom; } /* does not set it if in NULL, the src is not created yet */ if (GST_STATE (self) != GST_STATE_NULL) gst_base_camera_src_setup_zoom (self); break; } case PROP_POST_PREVIEW: self->post_preview = g_value_get_boolean (value); break; case PROP_PREVIEW_CAPS:{ GstCaps *new_caps = NULL; new_caps = (GstCaps *) gst_value_get_caps (value); if (!gst_caps_is_equal (self->preview_caps, new_caps)) { gst_caps_replace (&self->preview_caps, new_caps); gst_base_camera_src_setup_preview (self, new_caps); } else { GST_DEBUG_OBJECT (self, "New preview caps equal current preview caps"); } } break; case PROP_PREVIEW_FILTER: if (self->preview_filter) gst_object_unref (self->preview_filter); self->preview_filter = g_value_dup_object (value); if (!gst_camerabin_preview_set_filter (self->preview_pipeline, self->preview_filter)) { GST_WARNING_OBJECT (self, "Cannot change preview filter, is element in NULL state?"); } break; case PROP_AUTO_START: self->auto_start = g_value_get_boolean (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (self, prop_id, pspec); break; } }
static void gst_freeverb_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstFreeverb *filter = GST_FREEVERB (object); GstFreeverbPrivate *priv = filter->priv; gint i; switch (prop_id) { case PROP_ROOM_SIZE: filter->room_size = g_value_get_float (value); priv->roomsize = (filter->room_size * scaleroom) + offsetroom; for (i = 0; i < numcombs; i++) { freeverb_comb_setfeedback (&priv->combL[i], priv->roomsize); freeverb_comb_setfeedback (&priv->combR[i], priv->roomsize); } break; case PROP_DAMPING: filter->damping = g_value_get_float (value); priv->damp = filter->damping * scaledamp; for (i = 0; i < numcombs; i++) { freeverb_comb_setdamp (&priv->combL[i], priv->damp); freeverb_comb_setdamp (&priv->combR[i], priv->damp); } break; case PROP_PAN_WIDTH: filter->pan_width = g_value_get_float (value); priv->width = filter->pan_width; priv->wet1 = priv->wet * (priv->width / 2.0f + 0.5f); priv->wet2 = priv->wet * ((1.0f - priv->width) / 2.0f); break; case PROP_LEVEL: filter->level = g_value_get_float (value); priv->wet = filter->level * scalewet; priv->dry = (1.0 - filter->level) * scaledry; priv->wet1 = priv->wet * (priv->width / 2.0f + 0.5f); priv->wet2 = priv->wet * ((1.0f - priv->width) / 2.0f); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void gst_gl_transformation_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstGLTransformation *filter = GST_GL_TRANSFORMATION (object); switch (prop_id) { case PROP_FOV: filter->fov = g_value_get_float (value); break; case PROP_ORTHO: filter->ortho = g_value_get_boolean (value); break; case PROP_TRANSLATION_X: filter->xtranslation = g_value_get_float (value); break; case PROP_TRANSLATION_Y: filter->ytranslation = g_value_get_float (value); break; case PROP_TRANSLATION_Z: filter->ztranslation = g_value_get_float (value); break; case PROP_ROTATION_X: filter->xrotation = g_value_get_float (value); break; case PROP_ROTATION_Y: filter->yrotation = g_value_get_float (value); break; case PROP_ROTATION_Z: filter->zrotation = g_value_get_float (value); break; case PROP_SCALE_X: filter->xscale = g_value_get_float (value); break; case PROP_SCALE_Y: filter->yscale = g_value_get_float (value); break; case PROP_MVP: if (g_value_get_boxed (value) != NULL) filter->mvp_matrix = *((graphene_matrix_t *) g_value_get_boxed (value)); return; break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } gst_gl_transformation_build_mvp (filter); }
static void gst_identity_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstIdentity *identity; identity = GST_IDENTITY (object); switch (prop_id) { case PROP_SLEEP_TIME: identity->sleep_time = g_value_get_uint (value); break; case PROP_SILENT: identity->silent = g_value_get_boolean (value); break; case PROP_SINGLE_SEGMENT: identity->single_segment = g_value_get_boolean (value); break; case PROP_DUMP: identity->dump = g_value_get_boolean (value); break; case PROP_ERROR_AFTER: identity->error_after = g_value_get_int (value); break; case PROP_DROP_PROBABILITY: identity->drop_probability = g_value_get_float (value); break; case PROP_DROP_BUFFER_FLAGS: identity->drop_buffer_flags = g_value_get_flags (value); break; case PROP_DATARATE: identity->datarate = g_value_get_int (value); break; case PROP_SYNC: identity->sync = g_value_get_boolean (value); break; case PROP_CHECK_IMPERFECT_TIMESTAMP: identity->check_imperfect_timestamp = g_value_get_boolean (value); break; case PROP_CHECK_IMPERFECT_OFFSET: identity->check_imperfect_offset = g_value_get_boolean (value); break; case PROP_SIGNAL_HANDOFFS: identity->signal_handoffs = g_value_get_boolean (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } if (identity->datarate > 0 || identity->single_segment) gst_base_transform_set_passthrough (GST_BASE_TRANSFORM (identity), FALSE); else gst_base_transform_set_passthrough (GST_BASE_TRANSFORM (identity), TRUE); }
static void __get_expression_value (GdaConnection *cnc, GValue *src, GString *str) { gchar *escaped_string = NULL; switch (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (src))) { case G_TYPE_STRING: escaped_string = gda_connection_value_to_sql_string(cnc, src); g_string_append_printf (str, "%s", escaped_string); g_free(escaped_string); break; case G_TYPE_UINT: g_string_append_printf (str, "%d", g_value_get_uint (src)); break; case G_TYPE_INT: g_string_append_printf (str, "%d", g_value_get_int (src)); break; case G_TYPE_FLOAT: g_string_append_printf (str, "%.04f", g_value_get_float (src)); break; case G_TYPE_BOOLEAN: g_string_append_printf (str, "%d", g_value_get_boolean (src)); break; case G_TYPE_BOXED: if (G_VALUE_TYPE (src) == G_TYPE_VALUE_ARRAY) { GValueArray *array = (GValueArray *) g_value_get_boxed (src); if (!array) { /* FIXME, add this to validate */ g_warning ("Empty array given"); return; } guint i; for (i = 0; i < array->n_values; i++) { if (i > 0) g_string_append (str, ", "); __get_expression_value (cnc, g_value_array_get_nth (array, i), str); } } else { /*FIXME, add this to validate */ g_warning ("BOXED type '%s' not implemented \n", G_VALUE_TYPE_NAME (src)); } break; default: break; } return; }
double AccessibilityUIElement::maxValue() { if (!ATK_IS_VALUE(m_element)) return 0; GValue value = G_VALUE_INIT; atk_value_get_maximum_value(ATK_VALUE(m_element), &value); if (!G_VALUE_HOLDS_FLOAT(&value)) return 0; return g_value_get_float(&value); }
static void _vala_soy_atoms_radius_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) { soyatomsRadius * self; self = G_TYPE_CHECK_INSTANCE_CAST (object, SOY_ATOMS_TYPE_RADIUS, soyatomsRadius); switch (property_id) { case SOY_ATOMS_RADIUS_LENGTH: soy_atoms_radius_set_length (self, g_value_get_float (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }