static void gst_segmentation_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { GstSegmentation *filter = GST_SEGMENTATION (object); switch (prop_id) { case PROP_METHOD: g_value_set_enum (value, filter->method); break; case PROP_TEST_MODE: g_value_set_boolean (value, filter->test_mode); break; case PROP_LEARNING_RATE: g_value_set_float (value, filter->learning_rate); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void gst_stereo_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { GstStereo *stereo; g_return_if_fail (GST_IS_STEREO (object)); stereo = GST_STEREO (object); switch (prop_id) { case ARG_ACTIVE: g_value_set_boolean (value, stereo->active); break; case ARG_STEREO: g_value_set_float (value, stereo->stereo / 10.0); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void alterCurrentValue(PlatformUIElement element, int factor) { if (!element || !ATK_IS_VALUE(element.get())) return; GValue currentValue = G_VALUE_INIT; atk_value_get_current_value(ATK_VALUE(element.get()), ¤tValue); GValue increment = G_VALUE_INIT; atk_value_get_minimum_increment(ATK_VALUE(element.get()), &increment); GValue newValue = G_VALUE_INIT; g_value_init(&newValue, G_TYPE_DOUBLE); g_value_set_float(&newValue, g_value_get_float(¤tValue) + factor * g_value_get_float(&increment)); atk_value_set_current_value(ATK_VALUE(element.get()), &newValue); g_value_unset(&newValue); g_value_unset(&increment); g_value_unset(¤tValue); }
static void gst_hls_demux_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { GstHLSDemux *demux = GST_HLS_DEMUX (object); switch (prop_id) { case PROP_FRAGMENTS_CACHE: g_value_set_uint (value, demux->fragments_cache); break; case PROP_BITRATE_LIMIT: g_value_set_float (value, demux->bitrate_limit); break; case PROP_CONNECTION_SPEED: g_value_set_uint (value, demux->connection_speed / 1000); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, 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 mfw_gst_vpuenc_get_property(GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { GST_DEBUG("mfw_gst_vpuenc_get_property"); GstVPU_Enc *vpu_enc = MFW_GST_VPU_ENC(object); switch (prop_id) { case MFW_GST_VPU_PROF_ENABLE: g_value_set_boolean(value, vpu_enc->profile); break; case MFW_GST_VPU_DEVICE: g_value_set_string (value, vpu_enc->device); break; case MFW_GST_VPU_CODEC_TYPE: g_value_set_enum(value, vpu_enc->codec); break; case MFW_GST_VPUENC_BITRATE: g_value_set_int(value, vpu_enc->bitrate); break; case MFW_GST_VPUENC_FRAME_RATE: g_value_set_float(value, vpu_enc->framerate); break; case MFW_GST_VPUENC_GOP: g_value_set_int(value, vpu_enc->gopsize); break; case MFW_GST_VPUENC_MJPEG_QUALITY: g_value_set_int(value, vpu_enc->mjpeg_quality); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); break; } return; }
static void gst_lv2_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { #if 0 GstSignalProcessor *gsp; GstSignalProcessorClass *gsp_class; gfloat *controls; gsp = GST_SIGNAL_PROCESSOR (object); gsp_class = GST_SIGNAL_PROCESSOR_GET_CLASS (object); /* remember, properties have an offset of 1 */ prop_id--; if (prop_id < gsp_class->num_control_in) { controls = gsp->control_in; } else if (prop_id < gsp_class->num_control_in + gsp_class->num_control_out) { controls = gsp->control_out; prop_id -= gsp_class->num_control_in; } else { g_return_if_reached (); } /* now see what type it is */ switch (pspec->value_type) { case G_TYPE_BOOLEAN: g_value_set_boolean (value, controls[prop_id] > 0.5); break; case G_TYPE_INT: g_value_set_int (value, CLAMP (controls[prop_id], G_MININT, G_MAXINT)); break; case G_TYPE_FLOAT: g_value_set_float (value, controls[prop_id]); break; default: g_return_if_reached (); } #endif }
static void clutter_flow_layout_get_property (GObject *gobject, guint prop_id, GValue *value, GParamSpec *pspec) { ClutterFlowLayoutPrivate *priv = CLUTTER_FLOW_LAYOUT (gobject)->priv; switch (prop_id) { case PROP_ORIENTATION: g_value_set_enum (value, priv->orientation); break; case PROP_HOMOGENEOUS: g_value_set_boolean (value, priv->is_homogeneous); break; case PROP_COLUMN_SPACING: g_value_set_float (value, priv->col_spacing); break; case PROP_ROW_SPACING: g_value_set_float (value, priv->row_spacing); break; case PROP_MIN_COLUMN_WIDTH: g_value_set_float (value, priv->min_col_width); break; case PROP_MAX_COLUMN_WIDTH: g_value_set_float (value, priv->max_col_width); break; case PROP_MIN_ROW_HEGHT: g_value_set_float (value, priv->min_row_height); break; case PROP_MAX_ROW_HEIGHT: g_value_set_float (value, priv->max_row_height); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec); break; } }
static void clutter_path_constraint_get_property (GObject *gobject, guint prop_id, GValue *value, GParamSpec *pspec) { ClutterPathConstraint *self = CLUTTER_PATH_CONSTRAINT (gobject); switch (prop_id) { case PROP_PATH: g_value_set_object (value, self->path); break; case PROP_OFFSET: g_value_set_float (value, self->offset); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec); } }
static void mex_menu_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { MexMenuPrivate *priv = MEX_MENU (object)->priv; switch (property_id) { case PROP_DEPTH: g_value_set_int (value, priv->depth); break; case PROP_MIN_WIDTH: g_value_set_float (value, priv->min_width); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); } }
static void cheese_aspect_frame_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { CheeseAspectFrame *frame = CHEESE_ASPECT_FRAME (object); switch (property_id) { case PROP_EXPAND: g_value_set_boolean (value, cheese_aspect_frame_get_expand (frame)); break; case PROP_RATIO: g_value_set_float (value, cheese_aspect_frame_get_ratio (frame)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); } }
static void _xfdashboard_viewpad_get_property(GObject *inObject, guint inPropID, GValue *outValue, GParamSpec *inSpec) { XfdashboardViewpad *self=XFDASHBOARD_VIEWPAD(inObject); switch(inPropID) { case PROP_SPACING: g_value_set_float(outValue, self->priv->spacing); break; case PROP_ACTIVE_VIEW: g_value_set_object(outValue, self->priv->activeView); break; case PROP_HSCROLLBAR_POLICY: g_value_set_enum(outValue, self->priv->hScrollbarPolicy); break; case PROP_HSCROLLBAR_VISIBLE: g_value_set_boolean(outValue, self->priv->hScrollbarVisible); break; case PROP_VSCROLLBAR_POLICY: g_value_set_enum(outValue, self->priv->vScrollbarPolicy); break; case PROP_VSCROLLBAR_VISIBLE: g_value_set_boolean(outValue, self->priv->vScrollbarVisible); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(inObject, inPropID, inSpec); break; } }
static void gst_lv2_filter_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { GstLV2Filter *self = (GstLV2Filter *) (object); GstLV2FilterClass *klass = (GstLV2FilterClass *) GST_AUDIO_FILTER_GET_CLASS (object); gfloat *controls; /* remember, properties have an offset of 1 */ prop_id--; if (prop_id < klass->control_in_ports->len) { controls = self->ports.control.in; } else if (prop_id < klass->control_in_ports->len + klass->control_out_ports->len) { controls = self->ports.control.out; prop_id -= klass->control_in_ports->len; } else { g_return_if_reached (); } /* now see what type it is */ switch (pspec->value_type) { case G_TYPE_BOOLEAN: g_value_set_boolean (value, controls[prop_id] > 0.0f); break; case G_TYPE_INT: g_value_set_int (value, CLAMP (controls[prop_id], G_MININT, G_MAXINT)); break; case G_TYPE_FLOAT: g_value_set_float (value, controls[prop_id]); break; default: g_return_if_reached (); } }
/** * Implements * org.gnome.glib.GValue.g_value_init(float f) * called from * org.gnome.glib.GValue.createValue(float f) * * Allocate a GValue for a gfloat with GSlice, then initialize it and return * the pointer. */ JNIEXPORT jlong JNICALL Java_org_gnome_glib_GValue_g_1value_1init__F ( JNIEnv *env, jclass cls, jfloat _f ) { gfloat f; GValue* value; f = (gfloat) _f; // allocate it and set to zeros, per what g_value_init requires value = g_slice_new0(GValue); g_value_init(value, G_TYPE_FLOAT); // set the value g_value_set_float(value, f); // return address return (jlong) value; }
static void gst_haar_adjust_get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { GstHaarAdjust *filter = GST_HAARADJUST(object); switch (prop_id) { case PROP_VERBOSE: g_value_set_boolean(value, filter->verbose); break; case PROP_DISPLAY: g_value_set_boolean(value, filter->display); break; case PROP_OBJECT_TYPE: g_value_set_string(value, filter->object_type); break; case PROP_HEIGHT_ADJUSTMENT: g_value_set_float(value, filter->height_adjustment); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); break; } }
static gboolean string_to_num (GBinding *binding, const GValue *source_value, GValue *target_value, gpointer userdata) { if (G_VALUE_HOLDS_INT (target_value)) g_value_set_int (target_value, atoi (g_value_get_string (source_value))); else if (G_VALUE_HOLDS_UINT (target_value)) g_value_set_uint (target_value, atoi (g_value_get_string (source_value))); else if (G_VALUE_HOLDS_DOUBLE (target_value)) g_value_set_double (target_value, strtod (g_value_get_string (source_value), NULL)); else if (G_VALUE_HOLDS_FLOAT (target_value)) g_value_set_float (target_value, strtof (g_value_get_string (source_value), NULL)); else return FALSE; return TRUE; }
static void nautilus_column_get_property (GObject *object, guint param_id, GValue *value, GParamSpec *pspec) { NautilusColumn *column; column = NAUTILUS_COLUMN (object); switch (param_id) { case PROP_NAME : g_value_set_string (value, column->details->name); break; case PROP_ATTRIBUTE : g_value_set_string (value, g_quark_to_string (column->details->attribute)); break; case PROP_ATTRIBUTE_Q : g_value_set_uint (value, column->details->attribute); break; case PROP_LABEL : g_value_set_string (value, column->details->label); break; case PROP_DESCRIPTION : g_value_set_string (value, column->details->description); break; case PROP_XALIGN : g_value_set_float (value, column->details->xalign); break; case PROP_DEFAULT_SORT_ORDER : g_value_set_enum (value, column->details->default_sort_order); break; default : G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec); break; } }
static void gst_webp_enc_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { GstWebpEnc *webpenc = GST_WEBP_ENC (object); switch (prop_id) { case PROP_LOSSLESS: g_value_set_boolean (value, webpenc->lossless); break; case PROP_QUALITY: g_value_set_float (value, webpenc->quality); break; case PROP_SPEED: g_value_set_uint (value, webpenc->speed); break; case PROP_PRESET: g_value_set_enum (value, webpenc->preset); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void gst_audio_wsinclimit_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { GstAudioWSincLimit *self = GST_AUDIO_WSINC_LIMIT (object); switch (prop_id) { case PROP_LENGTH: g_value_set_int (value, self->kernel_length); break; case PROP_FREQUENCY: g_value_set_float (value, self->cutoff); break; case PROP_MODE: g_value_set_enum (value, self->mode); break; case PROP_WINDOW: g_value_set_enum (value, self->window); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void gst_ss_demux_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { GstSSDemux *demux = GST_SS_DEMUX (object); switch (prop_id) { case PROP_COOKIES: g_value_set_boxed (value, g_strdupv (demux->cookies)); break; case PROP_ALLOW_AUDIO_ONLY: g_value_set_boolean (value, demux->allow_audio_only); break; case PROP_FRAGMENTS_CACHE: g_value_set_uint (value, demux->fragments_cache); break; case PROP_BITRATE_SWITCH_TOLERANCE: g_value_set_float (value, demux->bitrate_switch_tol); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static GdaRow * new_row_from_mysql_stmt (GdaMysqlRecordset *imodel, G_GNUC_UNUSED gint rownum, GError **error) { //g_print ("%s(): NCOLS=%d ROWNUM=%d\n", __func__, ((GdaDataSelect *) imodel)->prep_stmt->ncols, rownum); int res; MYSQL_BIND *mysql_bind_result; g_return_val_if_fail (imodel->priv->mysql_stmt != NULL, NULL); mysql_bind_result = ((GdaMysqlPStmt *) ((GdaDataSelect *) imodel)->prep_stmt)->mysql_bind_result; g_assert (mysql_bind_result); res = mysql_stmt_fetch (imodel->priv->mysql_stmt); if (res == MYSQL_NO_DATA) { /* should not happen */ g_set_error (error, GDA_DATA_MODEL_ERROR, GDA_DATA_MODEL_ACCESS_ERROR, "%s", "No more data, please report this bug to " "http://bugzilla.gnome.org/ for the \"libgda\" product and the MySQL provider."); } else if (res == MYSQL_DATA_TRUNCATED) { GString *string; string = g_string_new ("Truncated data, please report this bug to " "http://bugzilla.gnome.org/ for the \"libgda\" product and the MySQL provider."); gint col; for (col = 0; col < ((GdaDataSelect *) imodel)->prep_stmt->ncols; ++col) { my_bool truncated; mysql_bind_result[col].error = &truncated; mysql_stmt_fetch_column (imodel->priv->mysql_stmt, &(mysql_bind_result[col]), (unsigned int)col, 0); if (truncated) g_string_append_printf (string, "\n column %d is truncated\n", col); mysql_bind_result[col].error = NULL; } g_set_error (error, GDA_DATA_MODEL_ERROR, GDA_DATA_MODEL_ACCESS_ERROR, "%s", string->str); g_string_free (string, TRUE); return NULL; } else if (res) { _gda_mysql_make_error (imodel->priv->cnc, NULL, imodel->priv->mysql_stmt, error); return NULL; } /* g_print ("%s: SQL=%s\n", __func__, ((GdaDataSelect *) imodel)->prep_stmt->sql); */ GdaRow *row = gda_row_new (((GdaDataSelect *) imodel)->prep_stmt->ncols); gint col; for (col = 0; col < ((GdaDataSelect *) imodel)->prep_stmt->ncols; ++col) { gint i = col; GValue *value = gda_row_get_value (row, i); GType type = ((GdaDataSelect *) imodel)->prep_stmt->types[i]; /*g_print ("%s: #%d : TYPE=%d, GTYPE=%s\n", __func__, i, mysql_bind_result[i].buffer_type, g_type_name (type));*/ my_bool is_null = FALSE; unsigned long length; g_memmove (&is_null, mysql_bind_result[i].is_null, sizeof (my_bool)); if (is_null) { gda_value_set_null (value); continue; } else gda_value_reset_with_type (value, type); switch (mysql_bind_result[i].buffer_type) { case MYSQL_TYPE_SHORT: { short int bvalue = 0; g_memmove (&bvalue, mysql_bind_result[i].buffer, sizeof (bvalue)); g_value_set_int (value, bvalue); break; } case MYSQL_TYPE_TINY: { signed char bvalue = 0; g_memmove (&bvalue, mysql_bind_result[i].buffer, sizeof (bvalue)); g_value_set_int (value, bvalue); break; } case MYSQL_TYPE_INT24: case MYSQL_TYPE_LONG: case MYSQL_TYPE_YEAR: { int bvalue = 0; g_memmove (&bvalue, mysql_bind_result[i].buffer, sizeof (bvalue)); if (type == G_TYPE_INT) g_value_set_int (value, bvalue); else if (type == G_TYPE_LONG) g_value_set_long (value, (long) bvalue); else if (type == G_TYPE_BOOLEAN) g_value_set_boolean (value, bvalue ? TRUE : FALSE); else { gda_row_invalidate_value (row, value); g_set_error (error, GDA_SERVER_PROVIDER_ERROR, GDA_SERVER_PROVIDER_DATA_ERROR, _("Type %s not mapped for value %d"), g_type_name (type), bvalue); } break; } case MYSQL_TYPE_LONGLONG: { long long bvalue = 0; g_memmove (&bvalue, mysql_bind_result[i].buffer, sizeof (bvalue)); if (type == G_TYPE_BOOLEAN) g_value_set_boolean (value, bvalue ? TRUE : FALSE); else if (type == G_TYPE_INT) g_value_set_int (value, bvalue); else if (type == G_TYPE_LONG) g_value_set_long (value, bvalue); else { gda_row_invalidate_value (row, value); g_set_error (error, GDA_SERVER_PROVIDER_ERROR, GDA_SERVER_PROVIDER_DATA_ERROR, _("Type %s not mapped for value %lld"), g_type_name (type), bvalue); } break; } case MYSQL_TYPE_NULL: gda_value_set_null (value); break; case MYSQL_TYPE_TIME: case MYSQL_TYPE_DATE: case MYSQL_TYPE_DATETIME: case MYSQL_TYPE_TIMESTAMP: { MYSQL_TIME bvalue = { 0, 0, 0, 0, 0, 0, 0, 0, 0 }; g_memmove (&bvalue, mysql_bind_result[i].buffer, sizeof (bvalue)); if (type == GDA_TYPE_TIME) { GdaTime time = { .hour = bvalue.hour, .minute = bvalue.minute, .second = bvalue.second, .fraction = bvalue.second_part, .timezone = 0 /* GMT */ }; gda_value_set_time (value, &time); } else if (type == G_TYPE_DATE) { GDate *date = g_date_new_dmy ((bvalue.day != 0) ? bvalue.day : 1, (bvalue.month != 0) ? bvalue.month : 1, (bvalue.year != 0) ? bvalue.year : 1970); g_value_take_boxed (value, date); } else if (type == GDA_TYPE_TIMESTAMP) { GdaTimestamp timestamp = { .year = bvalue.year, .month = bvalue.month, .day = bvalue.day, .hour = bvalue.hour, .minute = bvalue.minute, .second = bvalue.second, .fraction = bvalue.second_part, .timezone = 0 /* GMT */ }; gda_value_set_timestamp (value, ×tamp); } else { gda_row_invalidate_value (row, value); g_set_error (error, GDA_SERVER_PROVIDER_ERROR, GDA_SERVER_PROVIDER_DATA_ERROR, _("Type %s not mapped for value %d/%d/%d %d:%d:%d.%lu"), g_type_name (type), bvalue.year, bvalue.month, bvalue.day, bvalue.hour, bvalue.minute, bvalue.second, bvalue.second_part); } break; } case MYSQL_TYPE_FLOAT: { float bvalue = 0.; g_memmove (&bvalue, mysql_bind_result[i].buffer, sizeof (bvalue)); if (type == G_TYPE_FLOAT) g_value_set_float (value, (float) bvalue); else { gda_row_invalidate_value (row, value); g_set_error (error, GDA_SERVER_PROVIDER_ERROR, GDA_SERVER_PROVIDER_DATA_ERROR, _("Type %s not mapped for value %f"), g_type_name (type), bvalue); } break; } case MYSQL_TYPE_DOUBLE: { double bvalue = 0.0; g_memmove (&bvalue, mysql_bind_result[i].buffer, sizeof (bvalue)); if (type == G_TYPE_DOUBLE) g_value_set_double (value, bvalue); else { gda_row_invalidate_value (row, value); g_set_error (error, GDA_SERVER_PROVIDER_ERROR, GDA_SERVER_PROVIDER_DATA_ERROR, _("Type %s not mapped for value %f"), g_type_name (type), bvalue); } break; } case MYSQL_TYPE_STRING: case MYSQL_TYPE_VAR_STRING: case MYSQL_TYPE_BLOB: case MYSQL_TYPE_TINY_BLOB: case MYSQL_TYPE_MEDIUM_BLOB: case MYSQL_TYPE_LONG_BLOB: case MYSQL_TYPE_NEWDECIMAL: case MYSQL_TYPE_DECIMAL: case MYSQL_TYPE_BIT: { char *bvalue = NULL; g_memmove (&length, mysql_bind_result[i].length, sizeof (unsigned long)); if (length > 0) { bvalue = g_malloc (length + 1); memcpy (bvalue, mysql_bind_result[i].buffer, length); bvalue [length] = 0; } if (type == G_TYPE_STRING) g_value_set_string (value, bvalue); else if (type == GDA_TYPE_BINARY) { GdaBinary binary = { .data = (guchar*) bvalue, .binary_length = length }; gda_value_set_binary (value, &binary); } else if (type == GDA_TYPE_BLOB) { /* we don't use GdaMysqlBlobOp because it looks like the MySQL * API does not support BLOBs accessed in a random way, * so we return the whole BLOB at once */ GdaBlob blob = { {(guchar*) bvalue, length}, NULL }; gda_value_set_blob (value, &blob); } else if (type == GDA_TYPE_NUMERIC) { if (length > 0) { GdaNumeric *numeric; numeric = gda_numeric_new (); gda_numeric_set_from_string (numeric, bvalue); gda_numeric_set_precision (numeric, 6); gda_numeric_set_width (numeric, length); gda_value_set_numeric (value, numeric); gda_numeric_free (numeric); } } else if (type == G_TYPE_DOUBLE) { if (length > 0) g_value_set_double (value, g_ascii_strtod (bvalue, NULL)); else { /* error: wrong column type */ gda_row_invalidate_value (row, value); g_set_error (error, GDA_SERVER_PROVIDER_ERROR, GDA_SERVER_PROVIDER_DATA_ERROR, _("Invalid column bind data type. %d\n"), mysql_bind_result[i].buffer_type); break; } } else if (type == G_TYPE_INT) { if (length > 0) g_value_set_int (value, atoi (bvalue)); else { /* error: wrong column type */ gda_row_invalidate_value (row, value); g_set_error (error, GDA_SERVER_PROVIDER_ERROR, GDA_SERVER_PROVIDER_DATA_ERROR, _("Invalid column bind data type. %d\n"), mysql_bind_result[i].buffer_type); break; } } else if (type == G_TYPE_BOOLEAN) { if (length > 0) g_value_set_boolean (value, atoi (bvalue)); else { /* error: wrong column type */ gda_row_invalidate_value (row, value); g_set_error (error, GDA_SERVER_PROVIDER_ERROR, GDA_SERVER_PROVIDER_DATA_ERROR, _("Invalid column bind data type. %d\n"), mysql_bind_result[i].buffer_type); break; } } else { gda_row_invalidate_value (row, value); g_set_error (error, GDA_SERVER_PROVIDER_ERROR, GDA_SERVER_PROVIDER_DATA_ERROR, _("Type %s not mapped for value %s"), g_type_name (type), bvalue); } g_free (bvalue); break; }
void _gtk_tree_data_list_node_to_value (GtkTreeDataList *list, GType type, GValue *value) { g_value_init (value, type); switch (get_fundamental_type (type)) { case G_TYPE_BOOLEAN: g_value_set_boolean (value, (gboolean) list->data.v_int); break; case G_TYPE_CHAR: g_value_set_schar (value, (gchar) list->data.v_char); break; case G_TYPE_UCHAR: g_value_set_uchar (value, (guchar) list->data.v_uchar); break; case G_TYPE_INT: g_value_set_int (value, (gint) list->data.v_int); break; case G_TYPE_UINT: g_value_set_uint (value, (guint) list->data.v_uint); break; case G_TYPE_LONG: g_value_set_long (value, list->data.v_long); break; case G_TYPE_ULONG: g_value_set_ulong (value, list->data.v_ulong); break; case G_TYPE_INT64: g_value_set_int64 (value, list->data.v_int64); break; case G_TYPE_UINT64: g_value_set_uint64 (value, list->data.v_uint64); break; case G_TYPE_ENUM: g_value_set_enum (value, list->data.v_int); break; case G_TYPE_FLAGS: g_value_set_flags (value, list->data.v_uint); break; case G_TYPE_FLOAT: g_value_set_float (value, (gfloat) list->data.v_float); break; case G_TYPE_DOUBLE: g_value_set_double (value, (gdouble) list->data.v_double); break; case G_TYPE_STRING: g_value_set_string (value, (gchar *) list->data.v_pointer); break; case G_TYPE_POINTER: g_value_set_pointer (value, (gpointer) list->data.v_pointer); break; case G_TYPE_BOXED: g_value_set_boxed (value, (gpointer) list->data.v_pointer); break; case G_TYPE_VARIANT: g_value_set_variant (value, (gpointer) list->data.v_pointer); break; case G_TYPE_OBJECT: g_value_set_object (value, (GObject *) list->data.v_pointer); break; default: g_warning ("%s: Unsupported type (%s) retrieved.", G_STRLOC, g_type_name (value->g_type)); break; } }
void rbgobj_rvalue_to_gvalue(VALUE val, GValue* result) { GType type, fundamental_type; type = G_VALUE_TYPE(result); if (rbgobj_convert_rvalue2gvalue(type, val, result)) return; fundamental_type = G_TYPE_FUNDAMENTAL(type); switch (fundamental_type) { case G_TYPE_NONE: return; case G_TYPE_CHAR: g_value_set_char(result, NUM2INT(val)); return; case G_TYPE_UCHAR: g_value_set_uchar(result, NUM2UINT(val)); return; case G_TYPE_BOOLEAN: g_value_set_boolean(result, RVAL2CBOOL(val)); return; case G_TYPE_INT: g_value_set_int(result, NUM2INT(val)); return; case G_TYPE_UINT: g_value_set_uint(result, NUM2UINT(val)); return; case G_TYPE_LONG: g_value_set_long(result, NUM2LONG(val)); return; case G_TYPE_ULONG: g_value_set_ulong(result, NUM2ULONG(val)); return; case G_TYPE_INT64: g_value_set_int64(result, rbglib_num_to_int64(val)); return; case G_TYPE_UINT64: g_value_set_uint64(result, rbglib_num_to_uint64(val)); return; case G_TYPE_ENUM: g_value_set_enum(result, rbgobj_get_enum(val, G_VALUE_TYPE(result))); return; case G_TYPE_FLAGS: g_value_set_flags(result, rbgobj_get_flags(val, G_VALUE_TYPE(result))); return; case G_TYPE_FLOAT: g_value_set_float(result, NUM2DBL(val)); return; case G_TYPE_DOUBLE: g_value_set_double(result, NUM2DBL(val)); return; case G_TYPE_STRING: { if (SYMBOL_P(val)) val = rb_funcall(val, id_to_s, 0); g_value_set_string(result, RVAL2CSTR_ACCEPT_NIL(val)); return; } case G_TYPE_OBJECT: case G_TYPE_INTERFACE: g_value_set_object(result, NIL_P(val) ? NULL : RVAL2GOBJ(val)); return; case G_TYPE_PARAM: g_value_set_param(result, NIL_P(val) ? NULL : RVAL2GOBJ(val)); return; case G_TYPE_POINTER: g_value_set_pointer(result, NIL_P(val) ? NULL : rbgobj_ptr2cptr(val)); return; case G_TYPE_BOXED: { GType gtype; for (gtype = type; gtype != G_TYPE_INVALID; gtype = g_type_parent(gtype)) { RValueToGValueFunc func = g_type_get_qdata(gtype, qRValueToGValueFunc); if (!func) continue; func(val, result); return; } } default: if (!rbgobj_convert_rvalue2gvalue(fundamental_type, val, result)) { RValueToGValueFunc func = g_type_get_qdata(type, qRValueToGValueFunc); if (!func){ g_warning("rbgobj_rvalue_to_gvalue: unsupported type: %s\n", g_type_name(type)); } else { func(val, result); } } } }
void _clutter_settings_read_from_key_file (ClutterSettings *settings, GKeyFile *keyfile) { GObjectClass *settings_class; GObject *settings_obj; GParamSpec **pspecs; guint n_pspecs, i; if (!g_key_file_has_group (keyfile, SETTINGS_GROUP)) return; settings_obj = G_OBJECT (settings); settings_class = G_OBJECT_GET_CLASS (settings); pspecs = g_object_class_list_properties (settings_class, &n_pspecs); for (i = 0; i < n_pspecs; i++) { GParamSpec *pspec = pspecs[i]; const gchar *p_name = pspec->name; GType p_type = G_TYPE_FUNDAMENTAL (pspec->value_type); GValue value = G_VALUE_INIT; GError *key_error = NULL; g_value_init (&value, p_type); switch (p_type) { case G_TYPE_INT: case G_TYPE_UINT: { gint val; val = g_key_file_get_integer (keyfile, SETTINGS_GROUP, p_name, &key_error); if (p_type == G_TYPE_INT) g_value_set_int (&value, val); else g_value_set_uint (&value, val); } break; case G_TYPE_BOOLEAN: { gboolean val; val = g_key_file_get_boolean (keyfile, SETTINGS_GROUP, p_name, &key_error); g_value_set_boolean (&value, val); } break; case G_TYPE_FLOAT: case G_TYPE_DOUBLE: { gdouble val; val = g_key_file_get_double (keyfile, SETTINGS_GROUP, p_name, &key_error); if (p_type == G_TYPE_FLOAT) g_value_set_float (&value, val); else g_value_set_double (&value, val); } break; case G_TYPE_STRING: { gchar *val; val = g_key_file_get_string (keyfile, SETTINGS_GROUP, p_name, &key_error); g_value_take_string (&value, val); } break; } if (key_error != NULL && key_error->domain != G_KEY_FILE_ERROR && key_error->code != G_KEY_FILE_ERROR_KEY_NOT_FOUND) { g_critical ("Unable to read the value for setting '%s': %s", p_name, key_error->message); } if (key_error == NULL) g_object_set_property (settings_obj, p_name, &value); else g_error_free (key_error); g_value_unset (&value); } g_free (pspecs); }
static void _xfdashboard_text_box_get_property(GObject *inObject, guint inPropID, GValue *outValue, GParamSpec *inSpec) { XfdashboardTextBox *self=XFDASHBOARD_TEXT_BOX(inObject); XfdashboardTextBoxPrivate *priv=self->priv; switch(inPropID) { case PROP_PADDING: g_value_set_float(outValue, priv->padding); break; case PROP_SPACING: g_value_set_float(outValue, priv->spacing); break; case PROP_EDITABLE: g_value_set_boolean(outValue, priv->isEditable); break; case PROP_PRIMARY_ICON_NAME: g_value_set_string(outValue, priv->primaryIconName); break; case PROP_SECONDARY_ICON_NAME: g_value_set_string(outValue, priv->secondaryIconName); break; case PROP_TEXT: g_value_set_string(outValue, clutter_text_get_text(CLUTTER_TEXT(priv->actorTextBox))); break; case PROP_TEXT_FONT: g_value_set_string(outValue, priv->textFont); break; case PROP_TEXT_COLOR: clutter_value_set_color(outValue, priv->textColor); break; case PROP_SELECTION_TEXT_COLOR: clutter_value_set_color(outValue, priv->selectionTextColor); break; case PROP_SELECTION_BACKGROUND_COLOR: clutter_value_set_color(outValue, priv->selectionBackgroundColor); break; case PROP_HINT_TEXT: g_value_set_string(outValue, clutter_text_get_text(CLUTTER_TEXT(priv->actorHintLabel))); break; case PROP_HINT_TEXT_FONT: g_value_set_string(outValue, priv->hintTextFont); break; case PROP_HINT_TEXT_COLOR: clutter_value_set_color(outValue, priv->hintTextColor); break; case PROP_HINT_TEXT_SET: g_value_set_boolean(outValue, priv->hintTextSet); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(inObject, inPropID, inSpec); break; } }
gboolean json_deserialize_pspec (GValue *value, GParamSpec *pspec, JsonNode *node) { GValue node_value = { 0, }; gboolean retval = FALSE; if (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (value)) == G_TYPE_BOXED) { JsonNodeType node_type = json_node_get_node_type (node); GType boxed_type = G_VALUE_TYPE (value); if (json_boxed_can_deserialize (boxed_type, node_type)) { gpointer boxed = json_boxed_deserialize (boxed_type, node); g_value_take_boxed (value, boxed); return TRUE; } } switch (JSON_NODE_TYPE (node)) { case JSON_NODE_OBJECT: if (g_type_is_a (G_VALUE_TYPE (value), G_TYPE_OBJECT)) { GObject *object; object = json_gobject_new (G_VALUE_TYPE (value), json_node_get_object (node)); if (object != NULL) g_value_take_object (value, object); else g_value_set_object (value, NULL); retval = TRUE; } break; case JSON_NODE_ARRAY: if (G_VALUE_HOLDS (value, G_TYPE_STRV)) { JsonArray *array = json_node_get_array (node); guint i, array_len = json_array_get_length (array); GPtrArray *str_array = g_ptr_array_sized_new (array_len + 1); for (i = 0; i < array_len; i++) { JsonNode *val = json_array_get_element (array, i); if (JSON_NODE_TYPE (val) != JSON_NODE_VALUE) continue; if (json_node_get_string (val) != NULL) g_ptr_array_add (str_array, (gpointer) json_node_get_string (val)); } g_ptr_array_add (str_array, NULL); g_value_set_boxed (value, str_array->pdata); g_ptr_array_free (str_array, TRUE); retval = TRUE; } break; case JSON_NODE_VALUE: json_node_get_value (node, &node_value); #if 0 { gchar *node_str = g_strdup_value_contents (&node_value); g_debug ("%s: value type '%s' := node value type '%s' -> '%s'", G_STRLOC, g_type_name (G_VALUE_TYPE (value)), g_type_name (G_VALUE_TYPE (&node_value)), node_str); g_free (node_str); } #endif switch (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (value))) { case G_TYPE_BOOLEAN: case G_TYPE_INT64: case G_TYPE_STRING: if (G_VALUE_HOLDS (&node_value, G_VALUE_TYPE (value))) { g_value_copy (&node_value, value); retval = TRUE; } break; case G_TYPE_INT: if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64)) { g_value_set_int (value, (gint) g_value_get_int64 (&node_value)); retval = TRUE; } break; case G_TYPE_CHAR: if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64)) { g_value_set_schar (value, (gchar) g_value_get_int64 (&node_value)); retval = TRUE; } break; case G_TYPE_UINT: if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64)) { g_value_set_uint (value, (guint) g_value_get_int64 (&node_value)); retval = TRUE; } break; case G_TYPE_UCHAR: if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64)) { g_value_set_uchar (value, (guchar) g_value_get_int64 (&node_value)); retval = TRUE; } break; case G_TYPE_LONG: if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64)) { g_value_set_long (value, (glong) g_value_get_int64 (&node_value)); retval = TRUE; } break; case G_TYPE_ULONG: if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64)) { g_value_set_ulong (value, (gulong) g_value_get_int64 (&node_value)); retval = TRUE; } break; case G_TYPE_UINT64: if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64)) { g_value_set_uint64 (value, (guint64) g_value_get_int64 (&node_value)); retval = TRUE; } break; case G_TYPE_DOUBLE: if (G_VALUE_HOLDS (&node_value, G_TYPE_DOUBLE)) { g_value_set_double (value, g_value_get_double (&node_value)); retval = TRUE; } else if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64)) { g_value_set_double (value, (gdouble) g_value_get_int64 (&node_value)); retval = TRUE; } break; case G_TYPE_FLOAT: if (G_VALUE_HOLDS (&node_value, G_TYPE_DOUBLE)) { g_value_set_float (value, (gfloat) g_value_get_double (&node_value)); retval = TRUE; } else if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64)) { g_value_set_float (value, (gfloat) g_value_get_int64 (&node_value)); retval = TRUE; } break; case G_TYPE_ENUM: { gint enum_value = 0; if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64)) { enum_value = g_value_get_int64 (&node_value); retval = TRUE; } else if (G_VALUE_HOLDS (&node_value, G_TYPE_STRING)) { retval = enum_from_string (G_VALUE_TYPE (value), g_value_get_string (&node_value), &enum_value); } if (retval) g_value_set_enum (value, enum_value); } break; case G_TYPE_FLAGS: { gint flags_value = 0; if (G_VALUE_HOLDS (&node_value, G_TYPE_INT64)) { flags_value = g_value_get_int64 (&node_value); retval = TRUE; } else if (G_VALUE_HOLDS (&node_value, G_TYPE_STRING)) { retval = flags_from_string (G_VALUE_TYPE (value), g_value_get_string (&node_value), &flags_value); } if (retval) g_value_set_flags (value, flags_value); } break; default: retval = FALSE; break; } g_value_unset (&node_value); break; case JSON_NODE_NULL: if (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (value)) == G_TYPE_STRING) { g_value_set_string (value, NULL); retval = TRUE; } else if (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (value)) == G_TYPE_OBJECT) { g_value_set_object (value, NULL); retval = TRUE; } else retval = FALSE; break; } return retval; }
void gy_value_set_iarg(GValue* pval, GITypeInfo * info, int iarg) { GY_DEBUG("in gy_value_set_iarg\n"); GITypeTag type = g_type_info_get_tag(info); GIBaseInfo * itrf; switch (type) { case GI_TYPE_TAG_BOOLEAN: g_value_set_boolean(pval, ygets_c(iarg)); break; case GI_TYPE_TAG_INT8: g_value_set_schar(pval, ygets_c(iarg)); break; case GI_TYPE_TAG_UINT8: g_value_set_uchar(pval, ygets_c(iarg)); break; case GI_TYPE_TAG_INT16: case GI_TYPE_TAG_INT32: g_value_set_int(pval, ygets_i(iarg)); break; case GI_TYPE_TAG_UINT16: case GI_TYPE_TAG_UINT32: g_value_set_uint(pval, ygets_i(iarg)); break; case GI_TYPE_TAG_INT64: g_value_set_int64(pval, ygets_l(iarg)); break; case GI_TYPE_TAG_UINT64: g_value_set_uint64(pval, ygets_l(iarg)); break; case GI_TYPE_TAG_FLOAT: g_value_set_float(pval, ygets_f(iarg)); break; case GI_TYPE_TAG_DOUBLE: g_value_set_double(pval, ygets_d(iarg)); break; case GI_TYPE_TAG_GTYPE: g_value_set_gtype(pval, ygets_l(iarg)); break; case GI_TYPE_TAG_UTF8: case GI_TYPE_TAG_FILENAME: g_value_set_static_string (pval, ygets_q(iarg)); GY_DEBUG("GValue is string: \"%s\"\n", ygets_q(iarg)); break; /* interface types */ case GI_TYPE_TAG_INTERFACE: itrf = g_type_info_get_interface(info); switch(g_base_info_get_type (itrf)) { case GI_INFO_TYPE_ENUM: g_value_set_enum (pval, ygets_l(iarg)); break; case GI_INFO_TYPE_OBJECT: g_value_set_object(pval, yget_gy_Object(iarg)->object); break; default: y_errorn("Unimplemented GValue interface type %ld", g_base_info_get_type (itrf)); } g_base_info_unref(itrf); break; case GI_TYPE_TAG_VOID: default: y_error("Unimplement property GValue type"); } GY_DEBUG("out gy_iarg2gvalue\n"); }
gboolean _nodes2object(GObject *object, xmlNode *node, gboolean force) { g_assert(object); g_assert(node); xmlNode *cur = NULL; GObject *prop_object; gchar *nodeprop = NULL; xmlChar *decoded; xmlParserCtxtPtr parser; MidgardObject *mobject = NULL; MidgardObject *lobject = NULL; MidgardReflectionProperty *mrp = NULL; const gchar *linktype = NULL; if(MIDGARD_IS_OBJECT(object)) { mobject = MIDGARD_OBJECT(object); MidgardObjectClass *klass = MIDGARD_OBJECT_GET_CLASS(mobject); if(klass) mrp = midgard_reflection_property_new( MIDGARD_DBOBJECT_CLASS(klass)); } gpointer set_from_xml_func = MIDGARD_DBOBJECT_GET_CLASS(object)->dbpriv->set_from_xml_node; if(set_from_xml_func != NULL) { MIDGARD_DBOBJECT_GET_CLASS(object)->dbpriv->set_from_xml_node(MIDGARD_DBOBJECT(object), node); return TRUE; } for (cur = node; cur; cur = cur->next) { if (cur->type == XML_ELEMENT_NODE) { linktype = NULL; GParamSpec *pspec = g_object_class_find_property( G_OBJECT_GET_CLASS(G_OBJECT(object)), (const gchar *)cur->name); if(pspec) { GValue pval = {0, }; g_value_init(&pval, pspec->value_type); if(nodeprop) g_free(nodeprop); nodeprop = (gchar *)xmlNodeGetContent(cur); if(mrp) { if(midgard_reflection_property_is_link( mrp, pspec->name)){ linktype = midgard_reflection_property_get_link_name( mrp, pspec->name); } } /* moved out from mrp condition check to avoid nested indents */ if(linktype && midgard_is_guid( (const gchar *) nodeprop)){ /* Just set property quickly, if property holds a guid */ GType mtype = midgard_reflection_property_get_midgard_type(mrp, pspec->name); if (mtype == MGD_TYPE_GUID) { g_value_unset(&pval); g_object_set(mobject, (const gchar *)cur->name, nodeprop, NULL); continue; } /* we can use nodeprop directly */ lobject = midgard_schema_object_factory_get_object_by_guid ( MIDGARD_DBOBJECT (mobject)->dbpriv->mgd, (const gchar *) nodeprop); if(!lobject && !force){ g_object_unref(mrp); g_value_unset(&pval); midgard_set_error(MGD_OBJECT_CNC (mobject), MGD_GENERIC_ERROR, MGD_ERR_MISSED_DEPENDENCE, " Can not import %s. " "No '%s' object identified by '%s'", G_OBJECT_TYPE_NAME(object), linktype, nodeprop); g_clear_error(&MIDGARD_DBOBJECT (mobject)->dbpriv->mgd->err); return FALSE; } /* When force parameter is set we do not translate guids to ids */ if(force && !lobject && midgard_is_guid( (const gchar *) nodeprop)) { switch(pspec->value_type) { case G_TYPE_UINT: g_value_set_uint(&pval, 0); break; case G_TYPE_INT: g_value_set_int(&pval, 0); break; default: goto set_property_unchecked; break; } g_object_set_property( G_OBJECT(object), (const gchar *) cur->name, &pval); g_value_unset(&pval); continue; } GValue tval = {0, }; g_value_init(&tval, pspec->value_type); g_object_get_property(G_OBJECT(lobject), "id", &tval); if(G_VALUE_TYPE(&pval) == G_TYPE_INT) g_value_transform((const GValue *) &tval, &pval); else g_value_copy((const GValue*) &tval, &pval); g_object_set_property( G_OBJECT(object), (const gchar *) cur->name, &pval); g_value_unset(&pval); g_object_unref(lobject); g_value_unset(&tval); continue; } set_property_unchecked: switch (G_TYPE_FUNDAMENTAL (pspec->value_type)) { case G_TYPE_STRING: parser = xmlNewParserCtxt(); decoded = xmlStringDecodeEntities(parser, (const xmlChar *) nodeprop, XML_SUBSTITUTE_REF, 0, 0, 0); g_value_set_string(&pval, (gchar *)decoded); g_free(decoded); xmlFreeParserCtxt(parser); break; case G_TYPE_INT: if(nodeprop) g_value_set_int(&pval, (gint)atoi((gchar *)nodeprop)); break; case G_TYPE_UINT: if(nodeprop) g_value_set_uint(&pval, (guint)atoi((gchar *)nodeprop)); break; case G_TYPE_FLOAT: g_value_set_float(&pval, (gfloat)atof((gchar *)nodeprop)); break; case G_TYPE_BOOLEAN: g_value_set_boolean(&pval, (gboolean)atoi((gchar*)nodeprop)); break; case G_TYPE_OBJECT: g_object_get(G_OBJECT(object), (const gchar *) cur->name, &prop_object, NULL); if (prop_object) { _nodes2object(prop_object, cur->children, force); g_value_set_object(&pval, prop_object); } else { g_warning ("Failed to unserialize '%s' object property. Expected to be initialized by given '%s' instance", (const gchar *) cur->name, G_OBJECT_TYPE_NAME (object)); } break; default: /* do nothing */ break; } g_object_set_property( G_OBJECT(object), (const gchar *) cur->name, &pval); g_value_unset(&pval); } else { g_warning("Undefined property '%s' for '%s'", cur->name, G_OBJECT_TYPE_NAME(object)); } } } if(nodeprop) g_free(nodeprop); if(mrp) g_object_unref(mrp); return TRUE; }
static HaskellObj #ifdef GHC_RTS_USES_CAPABILITY gtk2hs_value_as_haskellobj(Capability *cap, const GValue *value) { #else gtk2hs_value_as_haskellobj(const GValue *value) { #endif switch (G_TYPE_FUNDAMENTAL(G_VALUE_TYPE(value))) { case G_TYPE_INTERFACE: if (g_type_is_a(G_VALUE_TYPE(value), G_TYPE_OBJECT)) return rts_mkPtr(CAP g_value_get_object(value)); else break; case G_TYPE_CHAR: return rts_mkChar(CAP g_value_get_schar(value)); case G_TYPE_UCHAR: return rts_mkChar(CAP g_value_get_uchar(value)); case G_TYPE_BOOLEAN: return rts_mkBool(CAP g_value_get_boolean(value)); case G_TYPE_INT: return rts_mkInt(CAP g_value_get_int(value)); case G_TYPE_UINT: return rts_mkWord(CAP g_value_get_uint(value)); case G_TYPE_LONG: return rts_mkInt(CAP g_value_get_long(value)); case G_TYPE_ULONG: return rts_mkWord(CAP g_value_get_ulong(value)); /* case G_TYPE_INT64: return rts_mkInt64(CAP g_value_get_int64(value)); case G_TYPE_UINT64: return rts_mkWord64(CAP g_value_get_uint64(value)); */ case G_TYPE_ENUM: return rts_mkInt(CAP g_value_get_enum(value)); case G_TYPE_FLAGS: return rts_mkWord(CAP g_value_get_enum(value)); case G_TYPE_FLOAT: return rts_mkFloat(CAP g_value_get_float(value)); case G_TYPE_DOUBLE: return rts_mkDouble(CAP g_value_get_double(value)); case G_TYPE_STRING: return rts_mkPtr(CAP (char *)g_value_get_string(value)); /* CHECKME: is the string freed? */ case G_TYPE_POINTER: return rts_mkPtr(CAP g_value_get_pointer(value)); case G_TYPE_BOXED: return rts_mkPtr(CAP g_value_get_boxed(value)); case G_TYPE_PARAM: return rts_mkPtr(CAP g_value_get_param(value)); case G_TYPE_OBJECT: return rts_mkPtr(CAP g_value_get_object(value)); } g_error("gtk2hs_value_as_haskellobj: unable to handle GValue with type %s\n" "please report this as a bug to [email protected]", g_type_name(G_VALUE_TYPE(value))); } void gtk2hs_value_from_haskellobj(GValue *value, HaskellObj obj) { switch (G_TYPE_FUNDAMENTAL(G_VALUE_TYPE(value))) { case G_TYPE_INVALID: case G_TYPE_NONE: return; case G_TYPE_INTERFACE: /* we only handle interface types that have a GObject prereq */ if (g_type_is_a(G_VALUE_TYPE(value), G_TYPE_OBJECT)) { g_value_set_object(value, rts_getPtr(obj)); } else { break; } return; case G_TYPE_CHAR: g_value_set_schar(value, rts_getChar(obj)); return; case G_TYPE_UCHAR: g_value_set_schar(value, rts_getChar(obj)); return; case G_TYPE_BOOLEAN: g_value_set_boolean(value, rts_getBool(obj)); return; case G_TYPE_INT: g_value_set_int(value, rts_getInt(obj)); return; case G_TYPE_UINT: g_value_set_uint(value, rts_getWord(obj)); return; case G_TYPE_LONG: g_value_set_long(value, rts_getInt(obj)); return; case G_TYPE_ULONG: g_value_set_ulong(value, rts_getWord(obj)); return; /* case G_TYPE_INT64: g_value_set_int64(value, rts_getInt64(obj)); return; case G_TYPE_UINT64: g_value_set_uint64(value, rts_getWord64(obj)); return; */ case G_TYPE_ENUM: g_value_set_enum(value, rts_getInt(obj)); return; case G_TYPE_FLAGS: g_value_set_flags(value, rts_getInt(obj)); return; case G_TYPE_FLOAT: g_value_set_float(value, rts_getFloat(obj)); return; case G_TYPE_DOUBLE: g_value_set_double(value, rts_getDouble(obj)); return; case G_TYPE_STRING: g_value_set_string(value, rts_getPtr(obj)); return; case G_TYPE_POINTER: g_value_set_pointer(value, rts_getPtr(obj)); return; /* case G_TYPE_BOXED: { g_value_set_boxed(value, obj); break; } case G_TYPE_PARAM: g_value_set_param(value, (obj)); break; */ case G_TYPE_OBJECT: g_value_set_object(value, rts_getPtr(obj)); return; } g_error("gtk2hs_value_from_haskellobj: unable to handle GValue with type %s\n" "please report this as a bug to [email protected]", g_type_name(G_VALUE_TYPE(value))); }
void ags_recall_dssi_run_run_pre(AgsRecall *recall) { AgsRecallDssi *recall_dssi; AgsRecallChannelRun *recall_channel_run; AgsRecallRecycling *recall_recycling; AgsRecallDssiRun *recall_dssi_run; AgsAudioSignal *audio_signal; AgsPort *current_port; AgsRecallID *recall_id; AgsRecyclingContext *parent_recycling_context, *recycling_context; AgsCountBeatsAudioRun *count_beats_audio_run; AgsRouteDssiAudioRun *route_dssi_audio_run; GList *list_start, *list; GList *port; GList *note_start, *note; snd_seq_event_t **event_buffer; unsigned long *event_count; gchar *specifier, *current_specifier; LADSPA_Data port_data; guint bank, program; guint output_lines, input_lines; guint notation_counter; guint x0, x1; guint port_count; guint copy_mode_in, copy_mode_out; guint buffer_size; guint i, i_stop; void (*parent_class_run_pre)(AgsRecall *recall); void (*select_program)(LADSPA_Handle Instance, unsigned long Bank, unsigned long Program); void (*run_synth)(LADSPA_Handle Instance, unsigned long SampleCount, snd_seq_event_t *Events, unsigned long EventCount); void (*run)(LADSPA_Handle Instance, unsigned long SampleCount); void (*deactivate)(LADSPA_Handle Instance); void (*cleanup)(LADSPA_Handle Instance); pthread_mutex_t *recall_dssi_mutex; pthread_mutex_t *port_mutex; /* get parent class */ pthread_mutex_lock(ags_recall_get_class_mutex()); parent_class_run_pre = AGS_RECALL_CLASS(ags_recall_dssi_run_parent_class)->run_pre; pthread_mutex_unlock(ags_recall_get_class_mutex()); /* call parent */ parent_class_run_pre(recall); g_object_get(recall, "recall-id", &recall_id, "source", &audio_signal, NULL); g_object_get(recall_id, "recycling-context", &recycling_context, NULL); g_object_get(recycling_context, "parent", &parent_recycling_context, NULL); g_object_get(audio_signal, "note", ¬e_start, NULL); if(ags_recall_global_get_rt_safe() && parent_recycling_context != NULL && note_start == NULL){ g_object_unref(recall_id); g_object_unref(audio_signal); g_object_unref(recycling_context); g_object_unref(parent_recycling_context); return; } g_list_free_full(note_start, g_object_unref); g_object_get(recall, "parent", &recall_recycling, NULL); g_object_get(recall_recycling, "parent", &recall_channel_run, NULL); g_object_get(recall_channel_run, "recall-channel", &recall_dssi, NULL); recall_dssi_run = AGS_RECALL_DSSI_RUN(recall); g_object_get(recall_dssi_run, "route-dssi-audio-run", &route_dssi_audio_run, NULL); if(route_dssi_audio_run == NULL){ g_object_unref(recall_id); g_object_unref(audio_signal); g_object_unref(recycling_context); g_object_unref(parent_recycling_context); g_object_unref(recall_recycling); g_object_unref(recall_channel_run); g_object_unref(recall_dssi); return; } /* get recall dssi mutex */ pthread_mutex_lock(ags_recall_get_class_mutex()); recall_dssi_mutex = AGS_RECALL(recall_dssi)->obj_mutex; pthread_mutex_unlock(ags_recall_get_class_mutex()); g_object_get(route_dssi_audio_run, "count-beats-audio-run", &count_beats_audio_run, NULL); g_object_get(audio_signal, "buffer-size", &buffer_size, NULL); /* get some fields */ pthread_mutex_lock(recall_dssi_mutex); output_lines = recall_dssi->output_lines; input_lines = recall_dssi->input_lines; pthread_mutex_unlock(recall_dssi_mutex); if(input_lines < output_lines){ i_stop = output_lines; }else{ i_stop = input_lines; } g_object_get(count_beats_audio_run, "notation-counter", ¬ation_counter, NULL); if(ags_recall_global_get_rt_safe()){ g_object_get(recall_dssi_run, "note", ¬e_start, NULL); note = note_start; while(note != NULL){ g_object_get(note->data, "x0", &x0, "x1", &x1, NULL); if((x1 + 1 <= notation_counter && !ags_note_test_flags(note->data, AGS_NOTE_FEED)) || x0 > notation_counter){ recall_dssi_run->note = g_list_remove(recall_dssi_run->note, note->data); g_object_unref(note->data); } note = note->next; } if(note_start == NULL){ memset(recall_dssi_run->event_buffer[0], 0, sizeof(snd_seq_event_t)); } g_list_free_full(note_start, g_object_unref); }else{ g_object_get(recall_dssi_run, "note", ¬e_start, NULL); g_object_get(note_start->data, "x0", &x0, "x1", &x1, NULL); if(audio_signal->stream_current == NULL || (x1 + 1 <= notation_counter && !ags_note_test_flags(note_start->data, AGS_NOTE_FEED)) || x0 > notation_counter){ // g_message("done"); pthread_mutex_lock(recall_dssi_mutex); deactivate = recall_dssi->plugin_descriptor->LADSPA_Plugin->deactivate; cleanup = recall_dssi->plugin_descriptor->LADSPA_Plugin->cleanup; pthread_mutex_unlock(recall_dssi_mutex); for(i = 0; i < i_stop; i++){ /* deactivate */ //TODO:JK: fix-me if(deactivate != NULL){ deactivate(recall_dssi_run->ladspa_handle[i]); } cleanup(recall_dssi_run->ladspa_handle[i]); } ags_recall_done(recall); g_list_free_full(note_start, g_object_unref); goto ags_recall_dssi_run_run_pre_END; } } /* get copy mode and clear buffer */ copy_mode_in = ags_audio_buffer_util_get_copy_mode(AGS_AUDIO_BUFFER_UTIL_FLOAT, ags_audio_buffer_util_format_from_soundcard(audio_signal->format)); copy_mode_out = ags_audio_buffer_util_get_copy_mode(ags_audio_buffer_util_format_from_soundcard(audio_signal->format), AGS_AUDIO_BUFFER_UTIL_FLOAT); if(recall_dssi_run->output != NULL){ ags_audio_buffer_util_clear_float(recall_dssi_run->output, output_lines, buffer_size); } if(recall_dssi_run->input != NULL){ ags_audio_buffer_util_clear_float(recall_dssi_run->input, input_lines, buffer_size); } /* copy data */ if(recall_dssi_run->input != NULL){ ags_audio_buffer_util_copy_buffer_to_buffer(recall_dssi_run->input, input_lines, 0, audio_signal->stream_current->data, 1, 0, buffer_size, copy_mode_in); } /* select program */ pthread_mutex_lock(recall_dssi_mutex); port_count = recall_dssi->plugin_descriptor->LADSPA_Plugin->PortCount; select_program = recall_dssi->plugin_descriptor->select_program; pthread_mutex_unlock(recall_dssi_mutex); /* cache port data */ g_object_get(recall_dssi, "port", &list_start, NULL); for(i = 0; i < port_count; i++){ pthread_mutex_lock(recall_dssi_mutex); specifier = g_strdup(recall_dssi->plugin_descriptor->LADSPA_Plugin->PortNames[i]); pthread_mutex_unlock(recall_dssi_mutex); list = list_start; while(list != NULL){ gboolean success; current_port = list->data; /* get port mutex */ pthread_mutex_lock(ags_port_get_class_mutex()); port_mutex = current_port->obj_mutex; pthread_mutex_unlock(ags_port_get_class_mutex()); /* check specifier */ pthread_mutex_lock(port_mutex); current_specifier = g_strdup(current_port->specifier); pthread_mutex_unlock(port_mutex); success = (!g_strcmp0(specifier, current_specifier)) ? TRUE: FALSE; g_free(current_specifier); if(success){ GValue value = {0,}; g_value_init(&value, G_TYPE_FLOAT); ags_port_safe_read(current_port, &value); recall_dssi_run->port_data[i] = g_value_get_float(&value); g_value_unset(&value); break; } list = list->next; } g_free(specifier); } g_object_get(recall_dssi, "bank", &bank, "program", &program, NULL); if(select_program != NULL){ for(i = 0; i < i_stop; i++){ select_program(recall_dssi_run->ladspa_handle[i], (unsigned long) bank, (unsigned long) program); // g_message("b p %u %u", bank, program); } } /* reset port data */ for(i = 0; i < port_count; i++){ pthread_mutex_lock(recall_dssi_mutex); specifier = g_strdup(recall_dssi->plugin_descriptor->LADSPA_Plugin->PortNames[i]); pthread_mutex_unlock(recall_dssi_mutex); list = list_start; current_port = NULL; while(list != NULL){ gboolean success; current_port = list->data; /* get port mutex */ pthread_mutex_lock(ags_port_get_class_mutex()); port_mutex = current_port->obj_mutex; pthread_mutex_unlock(ags_port_get_class_mutex()); /* check specifier */ pthread_mutex_lock(port_mutex); current_specifier = g_strdup(current_port->specifier); pthread_mutex_unlock(port_mutex); success = (!g_strcmp0(specifier, current_specifier)) ? TRUE: FALSE; g_free(current_specifier); if(success){ break; } list = list->next; } g_free(specifier); if(list != NULL){ GValue value = {0,}; g_value_init(&value, G_TYPE_FLOAT); port_data = recall_dssi_run->port_data[i]; g_value_set_float(&value, port_data); ags_port_safe_write(current_port, &value); g_value_unset(&value); } } g_list_free_full(list_start, g_object_unref); /* process data */ pthread_mutex_lock(recall_dssi_mutex); run_synth = recall_dssi->plugin_descriptor->run_synth; run = recall_dssi->plugin_descriptor->LADSPA_Plugin->run; pthread_mutex_unlock(recall_dssi_mutex); g_object_get(recall_dssi_run, "note", ¬e_start, NULL); note = note_start; while(note != NULL){ if(run_synth != NULL){ if(recall_dssi_run->event_buffer != NULL){ event_buffer = recall_dssi_run->event_buffer; event_count = recall_dssi_run->event_count; while(*event_buffer != NULL){ if(event_buffer[0]->type == SND_SEQ_EVENT_NOTEON){ run_synth(recall_dssi_run->ladspa_handle[0], (unsigned long) (output_lines * buffer_size), event_buffer[0], event_count[0]); } event_buffer++; event_count++; } } }else if(run != NULL){ run(recall_dssi_run->ladspa_handle[0], (unsigned long) buffer_size); } note = note->next; } g_list_free_full(note_start, g_object_unref); /* copy data */ if(recall_dssi_run->output != NULL){ ags_audio_buffer_util_clear_buffer(audio_signal->stream_current->data, 1, buffer_size, ags_audio_buffer_util_format_from_soundcard(audio_signal->format)); ags_audio_buffer_util_copy_buffer_to_buffer(audio_signal->stream_current->data, 1, 0, recall_dssi_run->output, output_lines, 0, buffer_size, copy_mode_out); } ags_recall_dssi_run_run_pre_END: g_object_unref(recall_id); g_object_unref(recycling_context); g_object_unref(parent_recycling_context); g_object_unref(recall_recycling); g_object_unref(recall_channel_run); g_object_unref(recall_dssi); g_object_unref(count_beats_audio_run); }