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; }
static GValueArray * gst_dshowaudiosrc_get_device_name_values (GstDshowAudioSrc * src) { GValueArray *array = g_value_array_new (0); ICreateDevEnum *devices_enum = NULL; IEnumMoniker *moniker_enum = NULL; IMoniker *moniker = NULL; HRESULT hres = S_FALSE; ULONG fetched; hres = CoCreateInstance (CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC_SERVER, IID_ICreateDevEnum, (LPVOID *) & devices_enum); if (hres != S_OK) { GST_ERROR ("Can't create an instance of the system device enumerator (error=0x%x)", hres); array = NULL; goto clean; } hres = devices_enum->CreateClassEnumerator (CLSID_AudioInputDeviceCategory, &moniker_enum, 0); if (hres != S_OK || !moniker_enum) { GST_ERROR ("Can't get enumeration of audio devices (error=0x%x)", hres); array = NULL; goto clean; } moniker_enum->Reset (); while (hres = moniker_enum->Next (1, &moniker, &fetched), hres == S_OK) { IPropertyBag *property_bag = NULL; hres = moniker->BindToStorage (NULL, NULL, IID_IPropertyBag, (LPVOID *) & property_bag); if (SUCCEEDED (hres) && property_bag) { VARIANT varFriendlyName; VariantInit (&varFriendlyName); hres = property_bag->Read (L"FriendlyName", &varFriendlyName, NULL); if (hres == S_OK && varFriendlyName.bstrVal) { gchar *friendly_name = g_utf16_to_utf8 ((const gunichar2 *) varFriendlyName.bstrVal, wcslen (varFriendlyName.bstrVal), NULL, NULL, NULL); GValue value = { 0 }; g_value_init (&value, G_TYPE_STRING); g_value_set_string (&value, friendly_name); g_value_array_append (array, &value); g_value_unset (&value); g_free (friendly_name); SysFreeString (varFriendlyName.bstrVal); } property_bag->Release (); } moniker->Release (); } clean: if (moniker_enum) moniker_enum->Release (); if (devices_enum) devices_enum->Release (); return array; }
//Draws the text for the 'value' column. void value_data_func(GtkTreeViewColumn *tree_column, GtkCellRenderer *cell, GtkTreeModel *tree_model, GtkTreeIter *iter, gpointer data) { GValue val_str, val_addr, val_type, val_offset; char str[512]; //just to be safe; 'double' values can be up to 307-digit numbers! possibly more! uint32 addr, type, offset = 0; uint64 magic; memset(&val_str, 0, sizeof(val_str)); //why do I have to do this? ._. memset(&val_addr, 0, sizeof(val_addr)); memset(&val_type, 0, sizeof(val_type)); memset(&val_offset, 0, sizeof(val_offset)); g_value_init(&val_str, G_TYPE_STRING); //Get the address, offset and type gtk_tree_model_get_value(tree_model, iter, Col_Address, &val_addr); addr = g_value_get_int(&val_addr); gtk_tree_model_get_value(tree_model, iter, Col_Offset, &val_offset); offset = g_value_get_int(&val_offset); gtk_tree_model_get_value(tree_model, iter, Col_Type, &val_type); type = g_value_get_int(&val_type); //If it's a pointer, follow it. if(type & Type_pointer) { type &= ~Type_pointer; addr = read_memory_32_unaligned(addr) + offset; //not that it makes a lot of sense to read a pointer from an unaligned //address, but let them do it if they want... } if(get_memory_flags(addr) & MEM_FLAG_READABLE) { //Read the variable and format it for display. switch(type) { case Type_int8: sprintf(str, "%d", (char)read_memory_8(addr)); break; case Type_int16: sprintf(str, "%d", (short)read_memory_16(addr)); break; case Type_int32: sprintf(str, "%d", (int)read_memory_32_unaligned(addr)); break; case Type_int64: sprintf(str, "%" PRId64, (long long int)read_memory_64_unaligned(addr)); break; case Type_uint8: sprintf(str, "%u", (unsigned char)read_memory_8(addr)); break; case Type_uint16: sprintf(str, "%u", (unsigned short)read_memory_16(addr)); break; case Type_uint32: sprintf(str, "%u", (unsigned int)read_memory_32_unaligned(addr)); break; case Type_uint64: sprintf(str, "%" PRIu64, (unsigned long long int)read_memory_64_unaligned(addr)); break; case Type_hex8: sprintf(str, "%02X", read_memory_8(addr)); break; case Type_hex16: sprintf(str, "%04X", read_memory_16(addr)); break; case Type_hex32: sprintf(str, "%08X", read_memory_32_unaligned(addr)); break; case Type_hex64: sprintf(str, "%08X %08X", read_memory_32_unaligned(addr), read_memory_32_unaligned(addr + 4)); break; case Type_float: addr = read_memory_32_unaligned(addr); sprintf(str, "%g", *((float*)&addr)); //magic conversion to IEEE754. I have no idea how this works. break; case Type_double: magic = read_memory_64_unaligned(addr); sprintf(str, "%lg", *((double*)&magic)); break; default: sprintf(str, "??? (%X)", type); break; } } else strcpy(str, "-"); //unreadable //Set the cell text. g_value_set_string(&val_str, str); g_object_set_property(G_OBJECT(cell), "text", &val_str); }
static void mame_gui_prefs_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { MameGuiPrefs *prefs = MAME_GUI_PREFS (object); if ((prop_id < NUM_PROPERTIES) && (prop_id >= PROP_DIR_CFG)) { /* This clause deals with the non-configurable user directories */ gchar *dir; dir = g_build_filename (g_get_user_config_dir (), "mame", prefs->priv->directories[prop_id - PROP_DIR_ARTWORK], NULL); GMAMEUI_DEBUG ("Getting the directory value at %d with value %s (%s)", (prop_id - PROP_DIR_ARTWORK), dir, prefs->priv->directories[prop_id - PROP_DIR_ARTWORK]); g_value_set_string (value, dir); g_free (dir); return; } if ((prop_id < NUM_PROPERTIES) && (prop_id >= PROP_DIR_ARTWORK)) { /* This clause deals with the configurable directories */ GMAMEUI_DEBUG ("Getting the directory value at %d with value %s", (prop_id - PROP_DIR_ARTWORK), prefs->priv->directories[prop_id - PROP_DIR_ARTWORK]); /* We are processing a directory property */ g_value_set_string (value, prefs->priv->directories[prop_id - PROP_DIR_ARTWORK]); /* Note we use prop_id - PROP_DIR_ARTWORK since PDA is the first of the directory properties */ return; } switch (prop_id) { case PROP_UI_WIDTH: g_value_set_int (value, prefs->priv->ui_width); break; case PROP_UI_HEIGHT: g_value_set_int (value, prefs->priv->ui_height); break; case PROP_SHOW_TOOLBAR: g_value_set_boolean (value, prefs->priv->show_toolbar); break; case PROP_SHOW_STATUSBAR: g_value_set_boolean (value, prefs->priv->show_statusbar); break; case PROP_SHOW_FILTERLIST: g_value_set_boolean (value, prefs->priv->show_filterlist); break; case PROP_SHOW_SCREENSHOT: g_value_set_boolean (value, prefs->priv->show_screenshot); break; case PROP_XPOS_FILTERS: g_value_set_int (value, prefs->priv->xpos_filters); break; case PROP_XPOS_GAMELIST: g_value_set_int (value, prefs->priv->xpos_gamelist); break; case PROP_GAMECHECK: g_value_set_boolean (value, prefs->priv->GameCheck); break; case PROP_VERSIONCHECK: g_value_set_boolean (value, prefs->priv->VersionCheck); break; case PROP_USEXMAMEOPTIONS: g_value_set_boolean (value, prefs->priv->use_xmame_options); break; case PROP_PREFERCUSTOMICONS: g_value_set_boolean (value, prefs->priv->prefercustomicons); break; case PROP_USEJOYINGUI: g_value_set_boolean (value, prefs->priv->gui_joy); break; case PROP_JOYSTICKNAME: g_value_set_string (value, prefs->priv->joystick_name); break; case PROP_THEPREFIX: g_value_set_boolean (value, prefs->priv->theprefix); break; case PROP_CURRENT_ROM: //g_value_set_object (value, prefs->priv->current_rom); g_value_set_string (value, prefs->priv->current_rom_name); break; case PROP_CURRENT_EXECUTABLE: g_value_set_string (value, prefs->priv->current_executable_name); break; case PROP_EXECUTABLE_PATHS: g_value_set_boxed (value, prefs->priv->executable_paths); break; case PROP_ROM_PATHS: g_value_set_boxed (value, prefs->priv->rom_paths); break; case PROP_SAMPLE_PATHS: g_value_set_boxed (value, prefs->priv->sample_paths); break; case PROP_CURRENT_ROMFILTER: g_value_set_int (value, prefs->priv->current_rom_filter); break; case PROP_CURRENT_MODE: g_value_set_int (value, prefs->priv->current_mode); break; case PROP_PREVIOUS_MODE: g_value_set_int (value, prefs->priv->previous_mode); break; case PROP_COLS_SHOWN: g_value_set_boxed (value, prefs->priv->cols_shown); break; case PROP_COLS_WIDTH: g_value_set_boxed (value, prefs->priv->cols_width); break; case PROP_SORT_COL: g_value_set_int (value, prefs->priv->sort_col); break; case PROP_SORT_COL_DIR: g_value_set_int (value, prefs->priv->sort_col_direction); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
void eServiceMP3Record::handleUridecNotifySource(GObject *object, GParamSpec *unused, gpointer user_data) { GstElement *source = NULL; eServiceMP3Record *_this = (eServiceMP3Record*)user_data; g_object_get(object, "source", &source, NULL); if (source) { if (g_object_class_find_property(G_OBJECT_GET_CLASS(source), "ssl-strict") != 0) { g_object_set(G_OBJECT(source), "ssl-strict", FALSE, NULL); } if (g_object_class_find_property(G_OBJECT_GET_CLASS(source), "user-agent") != 0 && !_this->m_useragent.empty()) { g_object_set(G_OBJECT(source), "user-agent", _this->m_useragent.c_str(), NULL); } if (g_object_class_find_property(G_OBJECT_GET_CLASS(source), "extra-headers") != 0 && !_this->m_extra_headers.empty()) { #if GST_VERSION_MAJOR < 1 GstStructure *extras = gst_structure_empty_new("extras"); #else GstStructure *extras = gst_structure_new_empty("extras"); #endif size_t pos = 0; while (pos != std::string::npos) { std::string name, value; size_t start = pos; size_t len = std::string::npos; pos = _this->m_extra_headers.find('=', pos); if (pos != std::string::npos) { len = pos - start; pos++; name = _this->m_extra_headers.substr(start, len); start = pos; len = std::string::npos; pos = _this->m_extra_headers.find('&', pos); if (pos != std::string::npos) { len = pos - start; pos++; } value = _this->m_extra_headers.substr(start, len); } if (!name.empty() && !value.empty()) { GValue header; eDebug("[eServiceMP3Record] handleUridecNotifySource setting extra-header '%s:%s'", name.c_str(), value.c_str()); memset(&header, 0, sizeof(GValue)); g_value_init(&header, G_TYPE_STRING); g_value_set_string(&header, value.c_str()); gst_structure_set_value(extras, name.c_str(), &header); } else { eDebug("[eServiceMP3Record] handleUridecNotifySource invalid header format %s", _this->m_extra_headers.c_str()); break; } } if (gst_structure_n_fields(extras) > 0) { g_object_set(G_OBJECT(source), "extra-headers", extras, NULL); } gst_structure_free(extras); } gst_object_unref(source); } }
static void clutter_backend_x11_xsettings_notify (const char *name, XSettingsAction action, XSettingsSetting *setting, void *cb_data) { ClutterSettings *settings = clutter_settings_get_default (); gint i; if (name == NULL || *name == '\0') return; if (setting == NULL) return; g_object_freeze_notify (G_OBJECT (settings)); for (i = 0; i < _n_clutter_settings_map; i++) { if (g_strcmp0 (name, CLUTTER_SETTING_X11_NAME (i)) == 0) { GValue value = { 0, }; switch (setting->type) { case XSETTINGS_TYPE_INT: g_value_init (&value, G_TYPE_INT); g_value_set_int (&value, setting->data.v_int); break; case XSETTINGS_TYPE_STRING: g_value_init (&value, G_TYPE_STRING); g_value_set_string (&value, setting->data.v_string); break; case XSETTINGS_TYPE_COLOR: { ClutterColor color; color.red = (guint8) ((float) setting->data.v_color.red / 65535.0 * 255); color.green = (guint8) ((float) setting->data.v_color.green / 65535.0 * 255); color.blue = (guint8) ((float) setting->data.v_color.blue / 65535.0 * 255); color.alpha = (guint8) ((float) setting->data.v_color.alpha / 65535.0 * 255); g_value_init (&value, G_TYPE_BOXED); clutter_value_set_color (&value, &color); } break; } CLUTTER_NOTE (BACKEND, "Mapping XSETTING '%s' to 'ClutterSettings:%s'", CLUTTER_SETTING_X11_NAME (i), CLUTTER_SETTING_PROPERTY (i)); g_object_set_property (G_OBJECT (settings), CLUTTER_SETTING_PROPERTY (i), &value); g_value_unset (&value); break; } } g_object_thaw_notify (G_OBJECT (settings)); }
GtkWidget * relations_diagram_new_with_fav_id (TConnection *tcnc, gint fav_id, GError **error) { RelationsDiagram *diagram = NULL; TFavoritesAttributes fav; xmlDocPtr doc = NULL; if (! t_favorites_get (t_connection_get_favorites (tcnc), fav_id, &fav, error)) return FALSE; doc = xmlParseDoc (BAD_CAST fav.contents); if (!doc) { g_set_error (error, T_ERROR, T_INTERNAL_COMMAND_ERROR, "%s", _("Error parsing favorite's contents")); goto out; } /* create diagram */ diagram = RELATIONS_DIAGRAM (relations_diagram_new (tcnc)); if (!diagram) goto out; gchar *str, *tmp; tmp = g_markup_printf_escaped (_("'%s' diagram"), fav.name); str = g_strdup_printf ("<b>%s</b>\n%s", _("Relations diagram"), tmp); g_free (tmp); gdaui_bar_set_text (diagram->priv->header, str); g_free (str); diagram->priv->fav_id = fav_id; relations_diagram_set_fav_id (diagram, fav_id, NULL); /* fill the diagram */ xmlNodePtr root, node; root = xmlDocGetRootElement (doc); if (!root) goto out; for (node = root->children; node; node = node->next) { if (!strcmp ((gchar*) node->name, "table")) { xmlChar *schema; xmlChar *name; schema = xmlGetProp (node, BAD_CAST "schema"); name = xmlGetProp (node, BAD_CAST "name"); if (schema && name) { BrowserCanvasTable *table; GValue *v1, *v2; g_value_set_string ((v1 = gda_value_new (G_TYPE_STRING)), (gchar*) schema); g_value_set_string ((v2 = gda_value_new (G_TYPE_STRING)), (gchar*) name); xmlFree (schema); xmlFree (name); table = browser_canvas_db_relations_add_table (BROWSER_CANVAS_DB_RELATIONS (diagram->priv->canvas), NULL, v1, v2); gda_value_free (v1); gda_value_free (v2); if (table) { xmlChar *x, *y; x = xmlGetProp (node, BAD_CAST "x"); y = xmlGetProp (node, BAD_CAST "y"); browser_canvas_translate_item (BROWSER_CANVAS (diagram->priv->canvas), (BrowserCanvasItem*) table, x ? g_ascii_strtod ((gchar*) x, NULL) : 0., y ? g_ascii_strtod ((gchar*) y, NULL) : 0.); if (x) xmlFree (x); if (y) xmlFree (y); } } else { if (schema) xmlFree (schema); if (name) xmlFree (name); g_set_error (error, T_ERROR, T_STORED_DATA_ERROR, "%s", _("Missing table attribute in favorite's contents")); gtk_widget_destroy ((GtkWidget*) diagram); diagram = NULL; goto out; } } } out: t_favorites_reset_attributes (&fav); if (doc) xmlFreeDoc (doc); return (GtkWidget*) diagram; }
static void get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) { ExampleCallableMediaChannel *self = EXAMPLE_CALLABLE_MEDIA_CHANNEL (object); switch (property_id) { case PROP_OBJECT_PATH: g_value_set_string (value, self->priv->object_path); break; case PROP_CHANNEL_TYPE: g_value_set_static_string (value, TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA); break; case PROP_HANDLE_TYPE: g_value_set_uint (value, TP_HANDLE_TYPE_CONTACT); break; case PROP_HANDLE: g_value_set_uint (value, self->priv->handle); break; case PROP_TARGET_ID: { TpHandleRepoIface *contact_repo = tp_base_connection_get_handles ( self->priv->conn, TP_HANDLE_TYPE_CONTACT); g_value_set_string (value, tp_handle_inspect (contact_repo, self->priv->handle)); } break; case PROP_REQUESTED: g_value_set_boolean (value, self->priv->locally_requested); break; case PROP_INITIATOR_HANDLE: g_value_set_uint (value, self->priv->initiator); break; case PROP_INITIATOR_ID: { TpHandleRepoIface *contact_repo = tp_base_connection_get_handles ( self->priv->conn, TP_HANDLE_TYPE_CONTACT); g_value_set_string (value, tp_handle_inspect (contact_repo, self->priv->initiator)); } break; case PROP_CONNECTION: g_value_set_object (value, self->priv->conn); break; case PROP_INTERFACES: g_value_set_boxed (value, example_callable_media_channel_interfaces); break; case PROP_CHANNEL_DESTROYED: g_value_set_boolean (value, (self->priv->progress == PROGRESS_ENDED)); break; case PROP_CHANNEL_PROPERTIES: g_value_take_boxed (value, tp_dbus_properties_mixin_make_properties_hash (object, TP_IFACE_CHANNEL, "ChannelType", TP_IFACE_CHANNEL, "TargetHandleType", TP_IFACE_CHANNEL, "TargetHandle", TP_IFACE_CHANNEL, "TargetID", TP_IFACE_CHANNEL, "InitiatorHandle", TP_IFACE_CHANNEL, "InitiatorID", TP_IFACE_CHANNEL, "Requested", TP_IFACE_CHANNEL, "Interfaces", NULL)); break; case PROP_SIMULATION_DELAY: g_value_set_uint (value, self->priv->simulation_delay); break; case PROP_INITIAL_AUDIO: g_value_set_boolean (value, self->priv->initial_audio); break; case PROP_INITIAL_VIDEO: g_value_set_boolean (value, self->priv->initial_video); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
static void get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { NMSettingVxlan *setting = NM_SETTING_VXLAN (object); NMSettingVxlanPrivate *priv = NM_SETTING_VXLAN_GET_PRIVATE (setting); switch (prop_id) { case PROP_PARENT: g_value_set_string (value, priv->parent); break; case PROP_ID: g_value_set_uint (value, priv->id); break; case PROP_LOCAL: g_value_set_string (value, priv->local); break; case PROP_REMOTE: g_value_set_string (value, priv->remote); break; case PROP_SOURCE_PORT_MIN: g_value_set_uint (value, priv->source_port_min); break; case PROP_SOURCE_PORT_MAX: g_value_set_uint (value, priv->source_port_max); break; case PROP_DESTINATION_PORT: g_value_set_uint (value, priv->destination_port); break; case PROP_TOS: g_value_set_uint (value, priv->tos); break; case PROP_AGEING: g_value_set_uint (value, priv->ageing); break; case PROP_LIMIT: g_value_set_uint (value, priv->limit); break; case PROP_PROXY: g_value_set_boolean (value, priv->proxy); break; case PROP_TTL: g_value_set_uint (value, priv->ttl); break; case PROP_LEARNING: g_value_set_boolean (value, priv->learning); break; case PROP_RSC: g_value_set_boolean (value, priv->rsc); break; case PROP_L2_MISS: g_value_set_boolean (value, priv->l2_miss); break; case PROP_L3_MISS: g_value_set_boolean (value, priv->l3_miss); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void gst_fake_src_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { GstFakeSrc *src; GstBaseSrc *basesrc; g_return_if_fail (GST_IS_FAKE_SRC (object)); src = GST_FAKE_SRC (object); basesrc = GST_BASE_SRC (object); switch (prop_id) { case PROP_OUTPUT: g_value_set_enum (value, src->output); break; case PROP_DATA: g_value_set_enum (value, src->data); break; case PROP_SIZETYPE: g_value_set_enum (value, src->sizetype); break; case PROP_SIZEMIN: g_value_set_int (value, src->sizemin); break; case PROP_SIZEMAX: g_value_set_int (value, src->sizemax); break; case PROP_PARENTSIZE: g_value_set_int (value, src->parentsize); break; case PROP_FILLTYPE: g_value_set_enum (value, src->filltype); break; case PROP_DATARATE: g_value_set_int (value, src->datarate); break; case PROP_SYNC: g_value_set_boolean (value, src->sync); break; case PROP_PATTERN: g_value_set_string (value, src->pattern); break; case PROP_SILENT: g_value_set_boolean (value, src->silent); break; case PROP_SIGNAL_HANDOFFS: g_value_set_boolean (value, src->signal_handoffs); break; case PROP_DUMP: g_value_set_boolean (value, src->dump); break; case PROP_LAST_MESSAGE: GST_OBJECT_LOCK (src); g_value_set_string (value, src->last_message); GST_OBJECT_UNLOCK (src); break; case PROP_CAN_ACTIVATE_PUSH: g_value_set_boolean (value, GST_BASE_SRC (src)->can_activate_push); break; case PROP_CAN_ACTIVATE_PULL: g_value_set_boolean (value, src->can_activate_pull); break; case PROP_IS_LIVE: g_value_set_boolean (value, gst_base_src_is_live (basesrc)); break; case PROP_FORMAT: g_value_set_enum (value, src->format); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
/* Note that g_value_set_object() refs the object, as does * g_object_get(). But g_object_get() only unrefs once when it disgorges * the object, leaving an unbalanced ref, which leaks. So instead of * using g_value_set_object(), use g_value_take_object() which doesn't * ref the object when used in get_property(). */ static void gnc_schedxaction_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { SchedXaction *sx; g_return_if_fail(GNC_IS_SCHEDXACTION(object)); sx = GNC_SCHEDXACTION(object); switch (prop_id) { case PROP_NAME: g_value_set_string(value, sx->name); break; case PROP_ENABLED: g_value_set_boolean(value, sx->enabled); break; case PROP_NUM_OCCURANCE: g_value_set_int(value, sx->num_occurances_total); break; case PROP_REM_OCCURANCE: g_value_set_int(value, sx->num_occurances_remain); break; case PROP_AUTO_CREATE: g_value_set_boolean(value, sx->autoCreateOption); break; case PROP_AUTO_CREATE_NOTIFY: g_value_set_boolean(value, sx->autoCreateNotify); break; case PROP_ADVANCE_CREATION_DAYS: g_value_set_int(value, sx->advanceCreateDays); break; case PROP_ADVANCE_REMINDER_DAYS: g_value_set_int(value, sx->advanceRemindDays); break; case PROP_START_DATE: g_value_set_boxed(value, &sx->start_date); break; case PROP_END_DATE: /* g_value_set_boxed raises a critical error if sx->end_date * is invalid */ if (g_date_valid (&sx->end_date)) g_value_set_boxed(value, &sx->end_date); break; case PROP_LAST_OCCURANCE_DATE: /* g_value_set_boxed raises a critical error if sx->last_date * is invalid */ if (g_date_valid (&sx->last_date)) g_value_set_boxed(value, &sx->last_date); break; case PROP_INSTANCE_COUNT: g_value_set_int(value, sx->instance_num); break; case PROP_TEMPLATE_ACCOUNT: g_value_take_object(value, sx->template_acct); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); break; } }
static void mud_subwindow_get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { MudSubwindow *self; self = MUD_SUBWINDOW(object); switch(prop_id) { case PROP_TITLE: g_value_set_string(value, self->priv->title); break; case PROP_IDENT: g_value_set_string(value, self->priv->identifier); break; case PROP_SCROLL: g_value_set_boolean(value, self->priv->scroll); break; case PROP_WIDTH: g_value_set_uint(value, self->priv->width); break; case PROP_HEIGHT: g_value_set_uint(value, self->priv->height); break; case PROP_OLD_HEIGHT: g_value_set_uint(value, self->priv->old_height); break; case PROP_OLD_WIDTH: g_value_set_uint(value, self->priv->old_width); break; case PROP_VISIBLE: g_value_set_boolean(value, self->priv->visible); break; case PROP_VIEW_HIDDEN: g_value_set_boolean(value, self->priv->view_hidden); break; case PROP_INPUT: g_value_set_boolean(value, self->priv->input_enabled); break; case PROP_PARENT: g_value_take_object(value, self->priv->parent_view); 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) { MMPlugin *self = MM_PLUGIN (object); switch (prop_id) { case PROP_NAME: g_value_set_string (value, self->priv->name); break; case PROP_ALLOWED_SUBSYSTEMS: g_value_set_boxed (value, self->priv->subsystems); break; case PROP_ALLOWED_DRIVERS: g_value_set_boxed (value, self->priv->drivers); break; case PROP_FORBIDDEN_DRIVERS: g_value_set_boxed (value, self->priv->forbidden_drivers); break; case PROP_ALLOWED_VENDOR_IDS: g_value_set_boxed (value, self->priv->vendor_ids); break; case PROP_ALLOWED_PRODUCT_IDS: g_value_set_boxed (value, self->priv->product_ids); break; case PROP_FORBIDDEN_PRODUCT_IDS: g_value_set_boxed (value, self->priv->forbidden_product_ids); break; case PROP_ALLOWED_VENDOR_STRINGS: g_value_set_boxed (value, self->priv->vendor_strings); break; case PROP_ALLOWED_PRODUCT_STRINGS: g_value_set_boxed (value, self->priv->product_strings); break; case PROP_FORBIDDEN_PRODUCT_STRINGS: g_value_set_boxed (value, self->priv->forbidden_product_strings); break; case PROP_ALLOWED_AT: g_value_set_boolean (value, self->priv->at); break; case PROP_ALLOWED_SINGLE_AT: g_value_set_boolean (value, self->priv->single_at); break; case PROP_ALLOWED_QCDM: g_value_set_boolean (value, self->priv->qcdm); break; case PROP_ALLOWED_UDEV_TAGS: g_value_set_boxed (value, self->priv->udev_tags); break; case PROP_ICERA_PROBE: g_value_set_boolean (value, self->priv->icera_probe); break; case PROP_ALLOWED_ICERA: g_value_set_boolean (value, self->priv->allowed_icera); break; case PROP_FORBIDDEN_ICERA: g_value_set_boolean (value, self->priv->forbidden_icera); break; case PROP_CUSTOM_AT_PROBE: g_value_set_boxed (value, self->priv->custom_at_probe); break; case PROP_CUSTOM_INIT: g_value_set_boxed (value, self->priv->custom_init); break; case PROP_SEND_DELAY: g_value_set_uint64 (value, self->priv->send_delay); break; case PROP_REMOVE_ECHO: g_value_set_boolean (value, self->priv->remove_echo); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void gst_vp8_enc_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { GstVP8Enc *gst_vp8_enc; g_return_if_fail (GST_IS_VP8_ENC (object)); gst_vp8_enc = GST_VP8_ENC (object); switch (prop_id) { case PROP_BITRATE: g_value_set_int (value, gst_vp8_enc->bitrate); break; case PROP_MODE: g_value_set_enum (value, gst_vp8_enc->mode); break; case PROP_MINSECTION_PCT: g_value_set_uint (value, gst_vp8_enc->minsection_pct); break; case PROP_MAXSECTION_PCT: g_value_set_uint (value, gst_vp8_enc->maxsection_pct); break; case PROP_MIN_QUANTIZER: g_value_set_int (value, gst_vp8_enc->min_quantizer); break; case PROP_MAX_QUANTIZER: g_value_set_int (value, gst_vp8_enc->max_quantizer); break; case PROP_QUALITY: g_value_set_double (value, gst_vp8_enc->quality); break; case PROP_ERROR_RESILIENT: g_value_set_boolean (value, gst_vp8_enc->error_resilient); break; case PROP_MAX_LATENCY: g_value_set_int (value, gst_vp8_enc->max_latency); break; case PROP_MAX_KEYFRAME_DISTANCE: g_value_set_int (value, gst_vp8_enc->max_keyframe_distance); break; case PROP_SPEED: g_value_set_int (value, gst_vp8_enc->speed); break; case PROP_THREADS: g_value_set_int (value, gst_vp8_enc->threads); break; case PROP_MULTIPASS_MODE: g_value_set_enum (value, gst_vp8_enc->multipass_mode); break; case PROP_MULTIPASS_CACHE_FILE: g_value_set_string (value, gst_vp8_enc->multipass_cache_file); break; case PROP_AUTO_ALT_REF_FRAMES: g_value_set_boolean (value, gst_vp8_enc->auto_alt_ref_frames); break; case PROP_LAG_IN_FRAMES: g_value_set_uint (value, gst_vp8_enc->lag_in_frames); break; case PROP_SHARPNESS: g_value_set_int (value, gst_vp8_enc->sharpness); break; case PROP_NOISE_SENSITIVITY: g_value_set_int (value, gst_vp8_enc->noise_sensitivity); break; case PROP_TUNE: #ifdef HAVE_VP8ENC_TUNING g_value_set_enum (value, gst_vp8_enc->tuning); #else GST_WARNING_OBJECT (gst_vp8_enc, "The tuning property is unsupported by this libvpx"); #endif break; case PROP_STATIC_THRESHOLD: g_value_set_int (value, gst_vp8_enc->static_threshold); break; case PROP_DROP_FRAME: g_value_set_int (value, gst_vp8_enc->drop_frame); break; case PROP_RESIZE_ALLOWED: g_value_set_boolean (value, gst_vp8_enc->resize_allowed); break; case PROP_TOKEN_PARTS: g_value_set_int (value, gst_vp8_enc->partitions); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
int main (int argc, char *argv[]) { gda_init (); GdaConnection *cnc; GError *error = NULL; GdaStatement *stmt; GdaDataModel *model; gchar *str; GValue *name; /* open connection */ cnc = open_connection (); /* begin transaction */ if (! gda_connection_begin_transaction (cnc, NULL, GDA_TRANSACTION_ISOLATION_UNKNOWN, &error)) { g_print ("Could not begin transaction: %s\n", error && error->message ? error->message : "No detail"); exit (1); } /* execute SELECT */ stmt = gda_sql_parser_parse_string (parser, "SELECT id, name FROM customers ORDER BY id", NULL, NULL); g_assert (stmt); model = gda_connection_statement_execute_select (cnc, stmt, NULL, &error); g_object_unref (stmt); if (!model) { g_print ("Could not execute SELECT statement: %s\n", error && error->message ? error->message : "No detail"); exit (1); } g_print ("** Data model is:\n"); gda_data_model_dump (model, stdout); /* * make sure the mete data is up to date */ g_print ("Computing meta data, this may take a while; in real applications, this should be cached to avoid waiting\n"); if (! gda_connection_update_meta_store (cnc, NULL, &error)) { g_print ("Could not fetch meta data: %s\n", error && error->message ? error->message : "No detail"); exit (1); } /* * Make the data model compute the modification statements which * will actually be executed when the data model is modified */ if (! gda_data_select_compute_modification_statements (GDA_DATA_SELECT (model), &error)) { g_print ("Could not compute modification statements: %s\n", error && error->message ? error->message : "No detail"); exit (1); } g_object_get (G_OBJECT (model), "update-stmt", &stmt, NULL); str = gda_statement_to_sql (stmt, NULL, NULL); g_print ("Computed UPDATE: %s\n", str); g_free (str); g_object_unref (stmt); g_object_get (G_OBJECT (model), "delete-stmt", &stmt, NULL); str = gda_statement_to_sql (stmt, NULL, NULL); g_print ("Computed DELETE: %s\n", str); g_free (str); g_object_unref (stmt); g_object_get (G_OBJECT (model), "insert-stmt", &stmt, NULL); str = gda_statement_to_sql (stmt, NULL, NULL); g_print ("Computed INSERT: %s\n", str); g_free (str); g_object_unref (stmt); /* * remove row 0 (1st row) */ g_print ("\n\n** Removing row 0\n"); if (! gda_data_model_remove_row (model, 0, &error)) { g_print ("Could not remove row 0: %s\n", error && error->message ? error->message : "No detail"); exit (1); } g_print ("** Data model is now:\n"); gda_data_model_dump (model, stdout); g_print ("** Table's contents is now:\n"); display_customers (cnc); /* * add a row: the row's values is a list of GValue pointers * (or NULL pointers where the default value should be inserted */ GList *list; g_print ("\n\n** Adding a row\n"); list = g_list_append (NULL, NULL); g_value_set_string ((name = gda_value_new (G_TYPE_STRING)), "Hiro"); list = g_list_append (list, name); if (gda_data_model_append_values (model, list, &error) == -1) { g_print ("Could not add a row: %s\n", error && error->message ? error->message : "No detail"); exit (1); } gda_value_free (name); g_list_free (list); g_print ("** Data model is now:\n"); gda_data_model_dump (model, stdout); g_print ("** Table's contents is now:\n"); display_customers (cnc); /* * alter row 2 */ g_print ("\n\n** Modifying row 2\n"); g_value_set_string ((name = gda_value_new (G_TYPE_STRING)), "Tom"); if (! gda_data_model_set_value_at (model, 1, 2, name, &error)) { g_print ("Could not modify row 2: %s\n", error && error->message ? error->message : "No detail"); exit (1); } gda_value_free (name); g_print ("** Data model is now:\n"); gda_data_model_dump (model, stdout); g_print ("** Table's contents is now:\n"); display_customers (cnc); /* rollback transaction */ gda_connection_rollback_transaction (cnc, NULL, NULL); gda_connection_close (cnc); return 0; }
static void aur_client_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { AurClient *client = (AurClient *) (object); switch (prop_id) { case PROP_SERVER_HOST:{ char *tmp = NULL; if (client->server_host) tmp = g_strdup_printf ("%s:%u", client->server_host, client->server_port); g_value_take_string (value, tmp); break; } case PROP_FLAGS:{ g_value_set_uint (value, client->flags); break; } case PROP_PAUSED:{ g_value_set_boolean (value, client->paused); break; } case PROP_BASE_TIME:{ g_value_set_uint64 (value, client->base_time); break; } case PROP_POSITION:{ g_value_set_uint64 (value, client->position); break; } case PROP_MEDIA_URI:{ g_value_set_string (value, client->uri); break; } case PROP_VOLUME:{ g_value_set_double (value, client->volume); break; } case PROP_CONNECTED_SERVER:{ char *tmp = NULL; if (client->connected_server) tmp = g_strdup_printf ("%s:%u", client->connected_server, client->connected_port); g_value_take_string (value, tmp); break; } case PROP_LANGUAGE:{ g_value_set_string (value, client->language); break; } case PROP_ASYNC_MAIN_CONTEXT:{ g_value_set_boxed (value, client->context); break; } default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static GstCaps * gst_cv_sobel_transform_caps (GstBaseTransform * trans, GstPadDirection dir, GstCaps * caps, GstCaps * filter) { GstCaps *to, *ret; GstCaps *templ; GstStructure *structure; GstPad *other; guint i; to = gst_caps_new_empty (); for (i = 0; i < gst_caps_get_size (caps); i++) { const GValue *v; GValue list = { 0, }; GValue val = { 0, }; structure = gst_structure_copy (gst_caps_get_structure (caps, i)); g_value_init (&list, GST_TYPE_LIST); g_value_init (&val, G_TYPE_STRING); g_value_set_string (&val, "GRAY8"); gst_value_list_append_value (&list, &val); g_value_unset (&val); g_value_init (&val, G_TYPE_STRING); #if G_BYTE_ORDER == G_BIG_ENDIAN g_value_set_string (&val, "GRAY16_BE"); #else g_value_set_string (&val, "GRAY16_LE"); #endif gst_value_list_append_value (&list, &val); g_value_unset (&val); v = gst_structure_get_value (structure, "format"); gst_value_list_merge (&val, v, &list); gst_structure_set_value (structure, "format", &val); g_value_unset (&val); g_value_unset (&list); gst_structure_remove_field (structure, "colorimetry"); gst_structure_remove_field (structure, "chroma-site"); gst_caps_append_structure (to, structure); } /* filter against set allowed caps on the pad */ other = (dir == GST_PAD_SINK) ? trans->srcpad : trans->sinkpad; templ = gst_pad_get_pad_template_caps (other); ret = gst_caps_intersect (to, templ); gst_caps_unref (to); gst_caps_unref (templ); if (ret && filter) { GstCaps *intersection; intersection = gst_caps_intersect_full (filter, ret, GST_CAPS_INTERSECT_FIRST); gst_caps_unref (ret); ret = intersection; } return ret; }
static void nautilus_list_model_get_value (GtkTreeModel *tree_model, GtkTreeIter *iter, int column, GValue *value) { NautilusListModel *model; FileEntry *file_entry; NautilusFile *file; char *str; GdkPixbuf *icon, *rendered_icon; int icon_size, icon_scale; NautilusListZoomLevel zoom_level; NautilusFileIconFlags flags; cairo_surface_t *surface; model = (NautilusListModel *)tree_model; g_return_if_fail (model->details->stamp == iter->stamp); g_return_if_fail (!g_sequence_iter_is_end (iter->user_data)); file_entry = g_sequence_get (iter->user_data); file = file_entry->file; switch (column) { case NAUTILUS_LIST_MODEL_FILE_COLUMN: g_value_init (value, NAUTILUS_TYPE_FILE); g_value_set_object (value, file); break; case NAUTILUS_LIST_MODEL_SUBDIRECTORY_COLUMN: g_value_init (value, NAUTILUS_TYPE_DIRECTORY); g_value_set_object (value, file_entry->subdirectory); break; case NAUTILUS_LIST_MODEL_SMALL_ICON_COLUMN: case NAUTILUS_LIST_MODEL_STANDARD_ICON_COLUMN: case NAUTILUS_LIST_MODEL_LARGE_ICON_COLUMN: g_value_init (value, CAIRO_GOBJECT_TYPE_SURFACE); if (file != NULL) { zoom_level = nautilus_list_model_get_zoom_level_from_column_id (column); icon_size = nautilus_list_model_get_icon_size_for_zoom_level (zoom_level); icon_scale = nautilus_list_model_get_icon_scale (model); flags = NAUTILUS_FILE_ICON_FLAGS_USE_THUMBNAILS | NAUTILUS_FILE_ICON_FLAGS_FORCE_THUMBNAIL_SIZE | NAUTILUS_FILE_ICON_FLAGS_USE_EMBLEMS | NAUTILUS_FILE_ICON_FLAGS_USE_ONE_EMBLEM; if (model->details->drag_view != NULL) { GtkTreePath *path_a, *path_b; gtk_tree_view_get_drag_dest_row (model->details->drag_view, &path_a, NULL); if (path_a != NULL) { path_b = gtk_tree_model_get_path (tree_model, iter); if (gtk_tree_path_compare (path_a, path_b) == 0) { flags |= NAUTILUS_FILE_ICON_FLAGS_FOR_DRAG_ACCEPT; } gtk_tree_path_free (path_a); gtk_tree_path_free (path_b); } } icon = nautilus_file_get_icon_pixbuf (file, icon_size, TRUE, icon_scale, flags); if (model->details->highlight_files != NULL && g_list_find_custom (model->details->highlight_files, file, (GCompareFunc) nautilus_file_compare_location)) { rendered_icon = eel_create_spotlight_pixbuf (icon); if (rendered_icon != NULL) { g_object_unref (icon); icon = rendered_icon; } } surface = gdk_cairo_surface_create_from_pixbuf (icon, icon_scale, NULL); g_value_take_boxed (value, surface); g_object_unref (icon); } break; case NAUTILUS_LIST_MODEL_FILE_NAME_IS_EDITABLE_COLUMN: g_value_init (value, G_TYPE_BOOLEAN); g_value_set_boolean (value, file != NULL && nautilus_file_can_rename (file)); break; default: if (column >= NAUTILUS_LIST_MODEL_NUM_COLUMNS || column < NAUTILUS_LIST_MODEL_NUM_COLUMNS + model->details->columns->len) { NautilusColumn *nautilus_column; GQuark attribute; nautilus_column = model->details->columns->pdata[column - NAUTILUS_LIST_MODEL_NUM_COLUMNS]; g_value_init (value, G_TYPE_STRING); g_object_get (nautilus_column, "attribute_q", &attribute, NULL); if (file != NULL) { str = nautilus_file_get_string_attribute_with_default_q (file, attribute); g_value_take_string (value, str); } else if (attribute == attribute_name_q) { if (file_entry->parent->loaded) { g_value_set_string (value, _("(Empty)")); } else { g_value_set_string (value, _("Loading…")); } } } else { g_assert_not_reached (); } } }
static RhythmDBEntry * create_entry_for_media (RhythmDB *db, RhythmDBEntryType *entry_type, GrlData *data, GrlData *container) { RhythmDBEntry *entry; RBGriloEntryData *entry_data; entry = rhythmdb_entry_lookup_by_location (db, grl_media_get_url (GRL_MEDIA (data))); if (entry != NULL) { return entry; } rb_debug ("creating entry for %s / %s", grl_media_get_url (GRL_MEDIA (data)), grl_media_get_id (GRL_MEDIA (data))); entry = rhythmdb_entry_new (db, entry_type, grl_media_get_url (GRL_MEDIA (data))); /* just use the url? */ if (entry == NULL) { /* crap. */ return NULL; } set_string_prop_from_key (db, entry, RHYTHMDB_PROP_TITLE, data, GRL_METADATA_KEY_TITLE); set_string_prop_from_key (db, entry, RHYTHMDB_PROP_ALBUM, data, GRL_METADATA_KEY_ALBUM); set_string_prop_from_key (db, entry, RHYTHMDB_PROP_ARTIST, data, GRL_METADATA_KEY_ARTIST); set_string_prop_from_key (db, entry, RHYTHMDB_PROP_GENRE, data, GRL_METADATA_KEY_GENRE); set_string_prop_from_key (db, entry, RHYTHMDB_PROP_TITLE, data, GRL_METADATA_KEY_TITLE); if (grl_data_has_key (data, GRL_METADATA_KEY_PUBLICATION_DATE)) { /* something - grilo has this as a string? */ } if (grl_data_has_key (data, GRL_METADATA_KEY_BITRATE)) { GValue v = {0,}; g_value_init (&v, G_TYPE_ULONG); g_value_set_ulong (&v, grl_data_get_int (data, GRL_METADATA_KEY_BITRATE)); rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_BITRATE, &v); g_value_unset (&v); } if (grl_data_has_key (data, GRL_METADATA_KEY_DURATION)) { /* this is probably in seconds */ GValue v = {0,}; g_value_init (&v, G_TYPE_ULONG); g_value_set_ulong (&v, grl_data_get_int (data, GRL_METADATA_KEY_DURATION)); rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_DURATION, &v); g_value_unset (&v); } if (grl_data_has_key (data, GRL_METADATA_KEY_MIME)) { const char *media_type; media_type = rb_gst_mime_type_to_media_type (grl_data_get_string (data, GRL_METADATA_KEY_MIME)); if (media_type) { GValue v = {0,}; g_value_init (&v, G_TYPE_STRING); g_value_set_string (&v, media_type); rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_MEDIA_TYPE, &v); g_value_unset (&v); } } if (grl_data_has_key (data, GRL_METADATA_KEY_TRACK_NUMBER)) { GValue v = {0,}; g_value_init (&v, G_TYPE_ULONG); g_value_set_ulong (&v, grl_data_get_int (data, GRL_METADATA_KEY_TRACK_NUMBER)); rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_TRACK_NUMBER, &v); g_value_unset (&v); } /* rating and play count? */ entry_data = RHYTHMDB_ENTRY_GET_TYPE_DATA (entry, RBGriloEntryData); entry_data->grilo_data = g_object_ref (data); if (container != NULL) { entry_data->grilo_container = g_object_ref (container); } /* might want to consider batching this */ rhythmdb_commit (db); return entry; }
static void gegl_buffer_get_property (GObject *gobject, guint property_id, GValue *value, GParamSpec *pspec) { GeglBuffer *buffer = GEGL_BUFFER (gobject); switch (property_id) { case PROP_WIDTH: g_value_set_int (value, buffer->extent.width); break; case PROP_HEIGHT: g_value_set_int (value, buffer->extent.height); break; case PROP_TILE_WIDTH: g_value_set_int (value, buffer->tile_width); break; case PROP_TILE_HEIGHT: g_value_set_int (value, buffer->tile_height); break; case PROP_PATH: { GeglTileBackend *backend = gegl_buffer_backend (buffer); if (GEGL_IS_TILE_BACKEND_FILE(backend)) { if (buffer->path) g_free (buffer->path); buffer->path = NULL; g_object_get (backend, "path", &buffer->path, NULL); } } g_value_set_string (value, buffer->path); break; case PROP_PIXELS: g_value_set_int (value, buffer->extent.width * buffer->extent.height); break; case PROP_PX_SIZE: g_value_set_int (value, buffer->tile_storage->px_size); break; case PROP_FORMAT: /* might already be set the first time, if it was set during * construction, we're caching the value in the buffer itself, * since it will never change. */ { const Babl *format; format = buffer->soft_format; if (format == NULL) format = buffer->format; if (format == NULL) format = gegl_buffer_internal_get_format (buffer); g_value_set_pointer (value, (void*)format); } break; case PROP_BACKEND: g_value_set_pointer (value, buffer->backend); break; case PROP_X: g_value_set_int (value, buffer->extent.x); break; case PROP_Y: g_value_set_int (value, buffer->extent.y); break; case PROP_SHIFT_X: g_value_set_int (value, buffer->shift_x); break; case PROP_SHIFT_Y: g_value_set_int (value, buffer->shift_y); break; case PROP_ABYSS_X: g_value_set_int (value, buffer->abyss.x); break; case PROP_ABYSS_Y: g_value_set_int (value, buffer->abyss.y); break; case PROP_ABYSS_WIDTH: g_value_set_int (value, buffer->abyss.width); break; case PROP_ABYSS_HEIGHT: g_value_set_int (value, buffer->abyss.height); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, property_id, pspec); break; } }
int bt_obex(int argc, char *argv[]) { GError *error = NULL; GOptionContext *context; /* Query current locale */ setlocale(LC_CTYPE, ""); g_type_init(); dbus_init(); context = g_option_context_new(" - a bluetooth OBEX client/server"); g_option_context_add_main_entries(context, entries, NULL); g_option_context_set_summary(context, "Version "PACKAGE_VERSION); g_option_context_set_description(context, "Server Options:\n" " -s, --server [<path>]\n" " Register self at OBEX server and use given `path` as OPP save directory\n" " If `path` does not specified - use current directory\n\n" "OPP Options:\n" " -p, --opp <name|mac> <file>\n" " Send `file` to remote device using Object Push Profile\n\n" //"Report bugs to <"PACKAGE_BUGREPORT">." "Project home page <"PACKAGE_URL">." ); if (!g_option_context_parse(context, &argc, &argv, &error)) { g_print("%s: %s\n", g_get_prgname(), error->message); g_print("Try `%s --help` for more information.\n", g_get_prgname()); exit(EXIT_FAILURE); } else if (!server_arg && !opp_arg && (!ftp_arg || strlen(ftp_arg) == 0)) { g_print("%s", g_option_context_get_help(context, FALSE, NULL)); exit(EXIT_FAILURE); } else if (server_arg && argc != 1 && (argc != 2 || strlen(argv[1]) == 0)) { g_print("%s: Invalid arguments for --server\n", g_get_prgname()); g_print("Try `%s --help` for more information.\n", g_get_prgname()); exit(EXIT_FAILURE); } else if (opp_arg && (argc != 3 || strlen(argv[1]) == 0 || strlen(argv[2]) == 0)) { g_print("%s: Invalid arguments for --opp\n", g_get_prgname()); g_print("Try `%s --help` for more information.\n", g_get_prgname()); exit(EXIT_FAILURE); } g_option_context_free(context); if (!dbus_system_connect(&error)) { g_printerr("Couldn't connect to DBus system bus: %s\n", error->message); exit(EXIT_FAILURE); } if (!dbus_session_connect(&error)) { g_printerr("Couldn't connect to DBus session bus: %s\n", error->message); exit(EXIT_FAILURE); } /* Check, that bluetooth daemon is running */ if (!intf_supported(BLUEZ_DBUS_NAME, MANAGER_DBUS_PATH, MANAGER_DBUS_INTERFACE)) { g_printerr("%s: bluez service is not found\n", g_get_prgname()); g_printerr("Did you forget to run bluetoothd?\n"); exit(EXIT_FAILURE); } /* Check, that obexd daemon is running */ if (!intf_supported(OBEXS_DBUS_NAME, OBEXMANAGER_DBUS_PATH, OBEXMANAGER_DBUS_INTERFACE)) { g_printerr("%s: obex service is not found\n", g_get_prgname()); g_printerr("Did you forget to run obexd?\n"); exit(EXIT_FAILURE); } if (server_arg) { if (argc == 2) { server_path_arg = argv[1]; } /* Check that `path` is valid */ gchar *root_folder = server_path_arg == NULL ? g_get_current_dir() : g_strdup(server_path_arg); if (!is_dir(root_folder, &error)) { exit_if_error(error); } server_transfers = g_hash_table_new(g_str_hash, g_str_equal); OBEXManager *manager = g_object_new(OBEXMANAGER_TYPE, NULL); g_signal_connect(manager, "SessionCreated", G_CALLBACK(obexmanager_session_created), NULL); g_signal_connect(manager, "SessionRemoved", G_CALLBACK(obexmanager_session_removed), NULL); g_signal_connect(manager, "TransferStarted", G_CALLBACK(obexmanager_transfer_started), NULL); g_signal_connect(manager, "TransferCompleted", G_CALLBACK(obexmanager_transfer_completed), NULL); OBEXAgent *agent = g_object_new(OBEXAGENT_TYPE, "RootFolder", root_folder, NULL); g_free(root_folder); obexmanager_register_agent(manager, OBEXAGENT_DBUS_PATH, &error); exit_if_error(error); mainloop = g_main_loop_new(NULL, FALSE); /* Add SIGTERM && SIGINT handlers */ struct sigaction sa; memset(&sa, 0, sizeof(sa)); sa.sa_handler = sigterm_handler; sigaction(SIGTERM, &sa, NULL); sigaction(SIGINT, &sa, NULL); g_main_loop_run(mainloop); /* Waiting for connections... */ g_main_loop_unref(mainloop); /* Stop active transfers */ GHashTableIter iter; gpointer key, value; g_hash_table_iter_init(&iter, server_transfers); while (g_hash_table_iter_next(&iter, &key, &value)) { OBEXTransfer *t = OBEXTRANSFER(value); obextransfer_cancel(t, NULL); // skip errors g_object_unref(t); g_hash_table_iter_remove(&iter); } g_hash_table_unref(server_transfers); obexmanager_unregister_agent(manager, OBEXAGENT_DBUS_PATH, &error); g_object_unref(agent); g_object_unref(manager); } else if (opp_arg) { opp_device_arg = argv[1]; opp_file_arg = argv[2]; /* Check that `file` is valid */ if (!is_file(opp_file_arg, &error)) { exit_if_error(error); } gchar * files_to_send[] = {NULL, NULL}; files_to_send[0] = g_path_is_absolute(opp_file_arg) ? g_strdup(opp_file_arg) : get_absolute_path(opp_file_arg); /* Get source address (address of adapter) */ Adapter *adapter = find_adapter(adapter_arg, &error); exit_if_error(error); gchar *src_address = g_strdup(adapter_get_address(adapter)); /* Get destination address (address of remote device) */ gchar *dst_address = NULL; if (g_regex_match_simple("^\\x{2}:\\x{2}:\\x{2}:\\x{2}:\\x{2}:\\x{2}$", opp_device_arg, 0, 0)) { dst_address = g_strdup(opp_device_arg); } else { Device *device = find_device(adapter, opp_device_arg, &error); exit_if_error(error); dst_address = g_strdup(device_get_address(device)); g_object_unref(device); } g_object_unref(adapter); /* Build arguments */ GHashTable *device_dict = g_hash_table_new(g_str_hash, g_str_equal); GValue src_v = {0}; GValue dst_v = {0}; g_value_init(&src_v, G_TYPE_STRING); g_value_init(&dst_v, G_TYPE_STRING); g_value_set_string(&src_v, src_address); g_value_set_string(&dst_v, dst_address); g_hash_table_insert(device_dict, "Source", &src_v); g_hash_table_insert(device_dict, "Destination", &dst_v); mainloop = g_main_loop_new(NULL, FALSE); OBEXClient *client = g_object_new(OBEXCLIENT_TYPE, NULL); OBEXAgent *agent = g_object_new(OBEXAGENT_TYPE, NULL); g_signal_connect(agent, "AgentReleased", G_CALLBACK(agent_released), mainloop); /* Sending file(s) */ obexclient_send_files(client, device_dict, files_to_send, OBEXAGENT_DBUS_PATH, &error); exit_if_error(error); /* Add SIGTERM && SIGINT handlers */ struct sigaction sa; memset(&sa, 0, sizeof(sa)); sa.sa_handler = sigterm_handler; sigaction(SIGTERM, &sa, NULL); sigaction(SIGINT, &sa, NULL); g_main_loop_run(mainloop); /* Sending files process here ?? */ g_main_loop_unref(mainloop); g_object_unref(agent); g_object_unref(client); g_value_unset(&src_v); g_value_unset(&dst_v); g_hash_table_unref(device_dict); g_free(src_address); g_free(dst_address); g_free(files_to_send[0]); files_to_send[0] = NULL; } else if (ftp_arg) { /* Get source address (address of adapter) */ Adapter *adapter = find_adapter(adapter_arg, &error); exit_if_error(error); gchar *src_address = g_strdup(adapter_get_address(adapter)); /* Get destination address (address of remote device) */ Device *device = find_device(adapter, ftp_arg, &error); exit_if_error(error); gchar *dst_address = g_strdup(device == NULL ? ftp_arg : device_get_address(device)); g_object_unref(device); g_object_unref(adapter); /* Build arguments */ GHashTable *device_dict = g_hash_table_new(g_str_hash, g_str_equal); GValue src_v = {0}; GValue dst_v = {0}; GValue target_v = {0}; g_value_init(&src_v, G_TYPE_STRING); g_value_init(&dst_v, G_TYPE_STRING); g_value_init(&target_v, G_TYPE_STRING); g_value_set_string(&src_v, src_address); g_value_set_string(&dst_v, dst_address); g_value_set_string(&target_v, "FTP"); g_hash_table_insert(device_dict, "Source", &src_v); g_hash_table_insert(device_dict, "Destination", &dst_v); g_hash_table_insert(device_dict, "Target", &target_v); OBEXClient *client = g_object_new(OBEXCLIENT_TYPE, NULL); OBEXAgent *agent = g_object_new(OBEXAGENT_TYPE, NULL); /* Create FTP session */ gchar *session_path = obexclient_create_session(client, device_dict, &error); exit_if_error(error); OBEXClientFileTransfer *ftp_session = g_object_new(OBEXCLIENT_FILE_TRANSFER_TYPE, "DBusObjectPath", session_path, NULL); g_free(session_path); g_print("FTP session opened\n"); while (TRUE) { gchar *cmd; /* cmd = readline("> "); if (cmd == NULL) { continue; } else { add_history(cmd); } */ gint f_argc; gchar **f_argv; /* Parsing command line */ if (!g_shell_parse_argv(cmd, &f_argc, &f_argv, &error)) { g_print("%s\n", error->message); g_error_free(error); error = NULL; g_free(cmd); continue; } /* Execute commands */ if (g_strcmp0(f_argv[0], "cd") == 0) { if (f_argc != 2 || strlen(f_argv[1]) == 0) { g_print("invalid arguments\n"); } else { obexclient_file_transfer_change_folder(ftp_session, f_argv[1], &error); if (error) { g_print("%s\n", error->message); g_error_free(error); error = NULL; } } } else if (g_strcmp0(f_argv[0], "mkdir") == 0) { if (f_argc != 2 || strlen(f_argv[1]) == 0) { g_print("invalid arguments\n"); } else { obexclient_file_transfer_create_folder(ftp_session, f_argv[1], &error); if (error) { g_print("%s\n", error->message); g_error_free(error); error = NULL; } } } else if (g_strcmp0(f_argv[0], "ls") == 0) { if (f_argc != 1) { g_print("invalid arguments\n"); } else { GPtrArray *folders = obexclient_file_transfer_list_folder(ftp_session, &error); if (error) { g_print("%s\n", error->message); g_error_free(error); error = NULL; } else { for (int i = 0; i < folders->len; i++) { GHashTable *el = g_ptr_array_index(folders, i); g_print( "%s\t%llu\t%s\n", g_value_get_string(g_hash_table_lookup(el, "Type")), G_VALUE_HOLDS_UINT64(g_hash_table_lookup(el, "Size")) ? g_value_get_uint64(g_hash_table_lookup(el, "Size")) : 0, g_value_get_string(g_hash_table_lookup(el, "Name")) ); } } if (folders) g_ptr_array_unref(folders); /*obexclient_remove_session(client, obexclient_file_transfer_get_dbus_object_path(ftp_session), &error); exit_if_error(error); g_object_unref(ftp_session); session_path = obexclient_create_session(client, device_dict, &error); exit_if_error(error); ftp_session = g_object_new(OBEXCLIENT_FILE_TRANSFER_TYPE, "DBusObjectPath", session_path, NULL); g_free(session_path);*/ } } else if (g_strcmp0(f_argv[0], "get") == 0) { if (f_argc != 3 || strlen(f_argv[1]) == 0 || strlen(f_argv[2]) == 0) { g_print("invalid arguments\n"); } else { gchar *abs_dst_path = get_absolute_path(f_argv[2]); gchar *dir = g_path_get_dirname(abs_dst_path); if (!is_dir(dir, &error)) { g_print("%s\n", error->message); g_error_free(error); error = NULL; } else { obexclient_file_transfer_get_file(ftp_session, abs_dst_path, f_argv[1], &error); if (error) { g_print("%s\n", error->message); g_error_free(error); error = NULL; } } g_free(dir); g_free(abs_dst_path); } } else if (g_strcmp0(f_argv[0], "put") == 0) { if (f_argc != 3 || strlen(f_argv[1]) == 0 || strlen(f_argv[2]) == 0) { g_print("invalid arguments\n"); } else { gchar *abs_src_path = get_absolute_path(f_argv[1]); if (!is_file(abs_src_path, &error)) { g_print("%s\n", error->message); g_error_free(error); error = NULL; } else { obexclient_file_transfer_put_file(ftp_session, abs_src_path, f_argv[2], &error); if (error) { g_print("%s\n", error->message); g_error_free(error); error = NULL; } } g_free(abs_src_path); } } else if (g_strcmp0(f_argv[0], "cp") == 0) { if (f_argc != 3 || strlen(f_argv[1]) == 0 || strlen(f_argv[2]) == 0) { g_print("invalid arguments\n"); } else { obexclient_file_transfer_copy_file(ftp_session, f_argv[1], f_argv[2], &error); if (error) { g_print("%s\n", error->message); g_error_free(error); error = NULL; } } } else if (g_strcmp0(f_argv[0], "mv") == 0) { if (f_argc != 3 || strlen(f_argv[1]) == 0 || strlen(f_argv[2]) == 0) { g_print("invalid arguments\n"); } else { obexclient_file_transfer_move_file(ftp_session, f_argv[1], f_argv[2], &error); if (error) { g_print("%s\n", error->message); g_error_free(error); error = NULL; } } } else if (g_strcmp0(f_argv[0], "rm") == 0) { if (f_argc != 2 || strlen(f_argv[1]) == 0) { g_print("invalid arguments\n"); } else { obexclient_file_transfer_delete(ftp_session, f_argv[1], &error); if (error) { g_print("%s\n", error->message); g_error_free(error); error = NULL; } } } else if (g_strcmp0(f_argv[0], "help") == 0) { g_print( "help\t\t\tShow this message\n" "exit\t\t\tClose FTP session\n" "cd <folder>\t\tChange the current folder of the remote device\n" "mkdir <folder>\t\tCreate a new folder in the remote device\n" "ls\t\t\tList folder contents\n" "get <src> <dst>\t\tCopy the src file (from remote device) to the dst file (on local filesystem)\n" "put <src> <dst>\t\tCopy the src file (from local filesystem) to the dst file (on remote device)\n" "cp <src> <dst>\t\tCopy a file within the remote device from src file to dst file\n" "mv <src> <dst>\t\tMove a file within the remote device from src file to dst file\n" "rm <target>\t\tDeletes the specified file/folder\n" ); } else if (g_strcmp0(f_argv[0], "exit") == 0 || g_strcmp0(f_argv[0], "quit") == 0) { obexclient_remove_session(client, obexclient_file_transfer_get_dbus_object_path(ftp_session), &error); exit_if_error(error); g_strfreev(f_argv); g_free(cmd); break; } else { g_print("invalid command\n"); } g_strfreev(f_argv); g_free(cmd); } g_object_unref(agent); g_object_unref(client); g_object_unref(ftp_session); g_value_unset(&src_v); g_value_unset(&dst_v); g_value_unset(&target_v); g_hash_table_unref(device_dict); g_free(src_address); g_free(dst_address); } dbus_disconnect(); exit(EXIT_SUCCESS); }
static void search_get_value (gint row, gint column, gpointer _dd, GValue *value) { DialogState *dd = (DialogState *)_dd; GnumericLazyList *ll = GNUMERIC_LAZY_LIST (gtk_tree_view_get_model (dd->matches_table)); GnmSearchFilterResult *item = g_ptr_array_index (dd->matches, row); GnmCell *cell; GnmComment *comment; if (item->locus == GNM_SRL_COMMENT) { cell = NULL; comment = sheet_get_comment (item->ep.sheet, &item->ep.eval); } else { cell = sheet_cell_get (item->ep.sheet, item->ep.eval.col, item->ep.eval.row); comment = NULL; } g_value_init (value, ll->column_headers[column]); #if 0 g_print ("col=%d,row=%d\n", column, row); #endif switch (column) { case COL_SHEET: g_value_set_string (value, item->ep.sheet->name_unquoted); return; case COL_CELL: g_value_set_string (value, cellpos_as_string (&item->ep.eval)); return; case COL_TYPE: switch (item->locus) { case GNM_SRL_COMMENT: g_value_set_static_string (value, _("Comment")); return; case GNM_SRL_VALUE: g_value_set_static_string (value, _("Result")); return; case GNM_SRL_CONTENTS: { GnmValue *v = cell ? cell->value : NULL; char const *type; gboolean is_expr = cell && gnm_cell_has_expr (cell); gboolean is_value = !is_expr && !gnm_cell_is_empty (cell) && v; if (!cell) type = _("Deleted"); else if (is_expr) type = _("Expression"); else if (is_value && VALUE_IS_STRING (v)) type = _("String"); else if (is_value && VALUE_IS_FLOAT (v)) type = _("Number"); else type = _("Other value"); g_value_set_static_string (value, type); return; } #ifndef DEBUG_SWITCH_ENUM default: g_assert_not_reached (); #endif } case COL_CONTENTS: switch (item->locus) { case GNM_SRL_COMMENT: if (comment) g_value_set_string (value, cell_comment_text_get (comment)); else g_value_set_static_string (value, _("Deleted")); return; case GNM_SRL_VALUE: if (cell && cell->value) g_value_take_string (value, value_get_as_string (cell->value)); else g_value_set_static_string (value, _("Deleted")); return; case GNM_SRL_CONTENTS: if (cell) g_value_take_string (value, gnm_cell_get_entered_text (cell)); else g_value_set_static_string (value, _("Deleted")); return; #ifndef DEBUG_SWITCH_ENUM default: g_assert_not_reached (); #endif } #ifndef DEBUG_SWITCH_ENUM default: g_assert_not_reached (); #endif } }
/* --- test functions --- */ static void pspec_select_value (GParamSpec *pspec, GValue *value, double dvalue) { /* generate a value suitable for pspec */ if (G_IS_PARAM_SPEC_CHAR (pspec)) ASSIGN_VALUE (g_value_set_schar, value, GParamSpecChar*, pspec, default_value, minimum, maximum, dvalue); else if (G_IS_PARAM_SPEC_UCHAR (pspec)) ASSIGN_VALUE (g_value_set_uchar, value, GParamSpecUChar*, pspec, default_value, minimum, maximum, dvalue); else if (G_IS_PARAM_SPEC_INT (pspec)) ASSIGN_VALUE (g_value_set_int, value, GParamSpecInt*, pspec, default_value, minimum, maximum, dvalue); else if (G_IS_PARAM_SPEC_UINT (pspec)) ASSIGN_VALUE (g_value_set_uint, value, GParamSpecUInt*, pspec, default_value, minimum, maximum, dvalue); else if (G_IS_PARAM_SPEC_LONG (pspec)) ASSIGN_VALUE (g_value_set_long, value, GParamSpecLong*, pspec, default_value, minimum, maximum, dvalue); else if (G_IS_PARAM_SPEC_ULONG (pspec)) ASSIGN_VALUE (g_value_set_ulong, value, GParamSpecULong*, pspec, default_value, minimum, maximum, dvalue); else if (G_IS_PARAM_SPEC_INT64 (pspec)) ASSIGN_VALUE (g_value_set_int64, value, GParamSpecInt64*, pspec, default_value, minimum, maximum, dvalue); else if (G_IS_PARAM_SPEC_UINT64 (pspec)) ASSIGN_VALUE (g_value_set_uint64, value, GParamSpecUInt64*, pspec, default_value, minimum, maximum, dvalue); else if (G_IS_PARAM_SPEC_FLOAT (pspec)) ASSIGN_VALUE (g_value_set_float, value, GParamSpecFloat*, pspec, default_value, minimum, maximum, dvalue); else if (G_IS_PARAM_SPEC_DOUBLE (pspec)) ASSIGN_VALUE (g_value_set_double, value, GParamSpecDouble*, pspec, default_value, minimum, maximum, dvalue); else if (G_IS_PARAM_SPEC_BOOLEAN (pspec)) g_value_set_boolean (value, SELECT_VALUE (dvalue, ((GParamSpecBoolean*) pspec)->default_value, FALSE, TRUE)); else if (G_IS_PARAM_SPEC_UNICHAR (pspec)) g_value_set_uint (value, SELECT_VALUE (dvalue, ((GParamSpecUnichar*) pspec)->default_value, FALSE, TRUE)); else if (G_IS_PARAM_SPEC_GTYPE (pspec)) g_value_set_gtype (value, SELECT_VALUE ((int) dvalue, ((GParamSpecGType*) pspec)->is_a_type, 0, GTK_TYPE_WIDGET)); else if (G_IS_PARAM_SPEC_STRING (pspec)) { GParamSpecString *sspec = (GParamSpecString*) pspec; if (dvalue >= +2) g_value_set_string (value, sspec->default_value); if (dvalue > 0 && sspec->cset_first && sspec->cset_nth) g_value_take_string (value, g_strdup_printf ("%c%c", sspec->cset_first[0], sspec->cset_nth[0])); else /* if (sspec->ensure_non_null) */ g_value_set_string (value, ""); } else if (G_IS_PARAM_SPEC_ENUM (pspec)) { GParamSpecEnum *espec = (GParamSpecEnum*) pspec; if (dvalue >= +2) g_value_set_enum (value, espec->default_value); if (dvalue >= 0 && dvalue <= 1) g_value_set_enum (value, espec->enum_class->values[(int) ((espec->enum_class->n_values - 1) * dvalue)].value); else if (dvalue <= -1) g_value_set_enum (value, espec->enum_class->values[g_test_rand_int_range (0, espec->enum_class->n_values)].value); } else if (G_IS_PARAM_SPEC_FLAGS (pspec)) { GParamSpecFlags *fspec = (GParamSpecFlags*) pspec; if (dvalue >= +2) g_value_set_flags (value, fspec->default_value); if (dvalue >= 0 && dvalue <= 1) g_value_set_flags (value, fspec->flags_class->values[(int) ((fspec->flags_class->n_values - 1) * dvalue)].value); else if (dvalue <= -1) g_value_set_flags (value, fspec->flags_class->values[g_test_rand_int_range (0, fspec->flags_class->n_values)].value); } /* unimplemented: * G_IS_PARAM_SPEC_PARAM * G_IS_PARAM_SPEC_BOXED * G_IS_PARAM_SPEC_POINTER * G_IS_PARAM_SPEC_VALUE_ARRAY * G_IS_PARAM_SPEC_OBJECT */ }
static void format_contact(DBusContact* contact, ContactData* c) { gchar* firstname; gchar* lastname; GValueArray* email = NULL; GValue email_member = {0}; gchar* str; gchar* image = NULL; gsize size; contact->data = hash_table_new(); contact->emails = g_value_email_new(); firstname = lastname = NULL; if (c->name) { gchar* pos = strchr(c->name, ' '); if (pos) { firstname = g_strndup(c->name, pos - c->name); lastname = g_strdup(++pos); g_hash_table_replace(contact->data, g_strdup("first-name"), convert_2_utf8(firstname)); g_hash_table_replace(contact->data, g_strdup("last-name"), convert_2_utf8(lastname)); } else { lastname = g_strdup(c->name); g_hash_table_replace(contact->data, g_strdup("last-name"), convert_2_utf8(lastname)); } g_free(firstname); g_free(lastname); } if (c->cn) { g_hash_table_replace(contact->data, g_strdup("cn"), convert_2_utf8(c->cn)); } if (c->picture) { gdk_pixbuf_save_to_buffer( c->picture, &image, &size, "png", NULL, NULL); g_hash_table_replace(contact->data, g_strdup("image"), g_base64_encode((const guchar *) image, size)); } email = g_value_array_new(0); /* Alias is not available but needed so make an empty string */ g_value_init(&email_member, G_TYPE_STRING); g_value_set_string(&email_member, ""); g_value_array_append(email, &email_member); g_value_unset(&email_member); if (c->email) str = convert_2_utf8(c->email); else str = g_strdup(""); g_value_init(&email_member, G_TYPE_STRING); g_value_set_string(&email_member, str); g_value_array_append(email, &email_member); g_value_unset(&email_member); g_free(str); if (c->remarks) str = convert_2_utf8(c->remarks); else str = g_strdup(""); g_value_init(&email_member, G_TYPE_STRING); g_value_set_string(&email_member, str); g_value_array_append(email, &email_member); g_value_unset(&email_member); g_free(str); g_ptr_array_add(contact->emails, email); }
static void nemo_list_model_get_value (GtkTreeModel *tree_model, GtkTreeIter *iter, int column, GValue *value) { NemoListModel *model; FileEntry *file_entry; NemoFile *file; char *str; GdkPixbuf *icon, *rendered_icon; GIcon *gicon, *emblemed_icon, *emblem_icon; NemoIconInfo *icon_info; GEmblem *emblem; GList *emblem_icons, *l; int icon_size; NemoZoomLevel zoom_level; NemoFile *parent_file; char *emblems_to_ignore[3]; int i; NemoFileIconFlags flags; model = (NemoListModel *)tree_model; g_return_if_fail (model->details->stamp == iter->stamp); g_return_if_fail (!g_sequence_iter_is_end (iter->user_data)); file_entry = g_sequence_get (iter->user_data); file = file_entry->file; switch (column) { case NEMO_LIST_MODEL_FILE_COLUMN: g_value_init (value, NEMO_TYPE_FILE); g_value_set_object (value, file); break; case NEMO_LIST_MODEL_SUBDIRECTORY_COLUMN: g_value_init (value, NEMO_TYPE_DIRECTORY); g_value_set_object (value, file_entry->subdirectory); break; case NEMO_LIST_MODEL_SMALLEST_ICON_COLUMN: case NEMO_LIST_MODEL_SMALLER_ICON_COLUMN: case NEMO_LIST_MODEL_SMALL_ICON_COLUMN: case NEMO_LIST_MODEL_STANDARD_ICON_COLUMN: case NEMO_LIST_MODEL_LARGE_ICON_COLUMN: case NEMO_LIST_MODEL_LARGER_ICON_COLUMN: case NEMO_LIST_MODEL_LARGEST_ICON_COLUMN: g_value_init (value, GDK_TYPE_PIXBUF); if (file != NULL) { zoom_level = nemo_list_model_get_zoom_level_from_column_id (column); icon_size = nemo_get_icon_size_for_zoom_level (zoom_level); flags = NEMO_FILE_ICON_FLAGS_USE_THUMBNAILS | NEMO_FILE_ICON_FLAGS_FORCE_THUMBNAIL_SIZE | NEMO_FILE_ICON_FLAGS_USE_MOUNT_ICON_AS_EMBLEM; if (model->details->drag_view != NULL) { GtkTreePath *path_a, *path_b; gtk_tree_view_get_drag_dest_row (model->details->drag_view, &path_a, NULL); if (path_a != NULL) { path_b = gtk_tree_model_get_path (tree_model, iter); if (gtk_tree_path_compare (path_a, path_b) == 0) { flags |= NEMO_FILE_ICON_FLAGS_FOR_DRAG_ACCEPT; } gtk_tree_path_free (path_a); gtk_tree_path_free (path_b); } } gicon = G_ICON (nemo_file_get_icon_pixbuf (file, icon_size, TRUE, flags)); /* render emblems with GEmblemedIcon */ parent_file = nemo_file_get_parent (file); i = 0; emblems_to_ignore[i++] = NEMO_FILE_EMBLEM_NAME_TRASH; if (parent_file) { if (!nemo_file_can_write (parent_file)) { emblems_to_ignore[i++] = NEMO_FILE_EMBLEM_NAME_CANT_WRITE; } nemo_file_unref (parent_file); } emblems_to_ignore[i++] = NULL; emblem_icons = nemo_file_get_emblem_icons (file, emblems_to_ignore); /* pick only the first emblem we can render for the list view */ for (l = emblem_icons; l != NULL; l = l->next) { emblem_icon = l->data; if (nemo_icon_theme_can_render (G_THEMED_ICON (emblem_icon))) { emblem = g_emblem_new (emblem_icon); emblemed_icon = g_emblemed_icon_new (gicon, emblem); g_object_unref (gicon); g_object_unref (emblem); gicon = emblemed_icon; break; } } g_list_free_full (emblem_icons, g_object_unref); icon_info = nemo_icon_info_lookup (gicon, icon_size); icon = nemo_icon_info_get_pixbuf_at_size (icon_info, icon_size); g_object_unref (icon_info); g_object_unref (gicon); if (model->details->highlight_files != NULL && g_list_find_custom (model->details->highlight_files, file, (GCompareFunc) nemo_file_compare_location)) { rendered_icon = eel_create_spotlight_pixbuf (icon); if (rendered_icon != NULL) { g_object_unref (icon); icon = rendered_icon; } } g_value_set_object (value, icon); g_object_unref (icon); } break; case NEMO_LIST_MODEL_FILE_NAME_IS_EDITABLE_COLUMN: g_value_init (value, G_TYPE_BOOLEAN); g_value_set_boolean (value, file != NULL && nemo_file_can_rename (file)); break; default: if (column >= NEMO_LIST_MODEL_NUM_COLUMNS || column < NEMO_LIST_MODEL_NUM_COLUMNS + model->details->columns->len) { NemoColumn *nemo_column; GQuark attribute; nemo_column = model->details->columns->pdata[column - NEMO_LIST_MODEL_NUM_COLUMNS]; g_value_init (value, G_TYPE_STRING); g_object_get (nemo_column, "attribute_q", &attribute, NULL); if (file != NULL) { str = nemo_file_get_string_attribute_with_default_q (file, attribute); g_value_take_string (value, str); } else if (attribute == attribute_name_q) { if (file_entry->parent->loaded) { g_value_set_string (value, _("(Empty)")); } else { g_value_set_string (value, _("Loading...")); } } } else { g_assert_not_reached (); } } }
gboolean gst_frei0r_get_property (f0r_instance_t * instance, GstFrei0rFuncTable * ftable, GstFrei0rProperty * properties, gint n_properties, GstFrei0rPropertyValue * property_cache, guint prop_id, GValue * value) { gint i; GstFrei0rProperty *prop = NULL; for (i = 0; i < n_properties; i++) { if (properties[i].prop_id <= prop_id && properties[i].prop_id + properties[i].n_prop_ids > prop_id) { prop = &properties[i]; break; } } if (!prop) return FALSE; switch (prop->info.type) { case F0R_PARAM_BOOL:{ gdouble d; if (instance) ftable->get_param_value (instance, &d, prop->prop_idx); else d = property_cache[prop->prop_idx].data.b; g_value_set_boolean (value, (d < 0.5) ? FALSE : TRUE); break; } case F0R_PARAM_DOUBLE:{ gdouble d; if (instance) ftable->get_param_value (instance, &d, prop->prop_idx); else d = property_cache[prop->prop_idx].data.d; g_value_set_double (value, d); break; } case F0R_PARAM_STRING:{ const gchar *s; if (instance) ftable->get_param_value (instance, &s, prop->prop_idx); else s = property_cache[prop->prop_idx].data.s; g_value_set_string (value, s); break; } case F0R_PARAM_COLOR:{ f0r_param_color_t color; if (instance) ftable->get_param_value (instance, &color, prop->prop_idx); else color = property_cache[prop->prop_idx].data.color; switch (prop_id - prop->prop_id) { case 0: g_value_set_float (value, color.r); break; case 1: g_value_set_float (value, color.g); break; case 2: g_value_set_float (value, color.b); break; } break; } case F0R_PARAM_POSITION:{ f0r_param_position_t position; if (instance) ftable->get_param_value (instance, &position, prop->prop_idx); else position = property_cache[prop->prop_idx].data.position; switch (prop_id - prop->prop_id) { case 0: g_value_set_double (value, position.x); break; case 1: g_value_set_double (value, position.y); break; } break; } default: g_assert_not_reached (); break; } return TRUE; }
void rb_iradio_source_add_station (RBIRadioSource *source, const char *uri, const char *title, const char *genre) { RhythmDBEntry *entry; GValue val = { 0, }; char *real_uri = NULL; char *fixed_title; char *fixed_genre = NULL; RhythmDBEntryType *entry_type; real_uri = guess_uri_scheme (uri); if (real_uri) uri = real_uri; entry = rhythmdb_entry_lookup_by_location (source->priv->db, uri); if (entry) { rb_debug ("uri %s already in db", uri); g_free (real_uri); return; } g_object_get (source, "entry-type", &entry_type, NULL); entry = rhythmdb_entry_new (source->priv->db, entry_type, uri); g_object_unref (entry_type); if (entry == NULL) { g_free (real_uri); return; } g_value_init (&val, G_TYPE_STRING); if (title) { fixed_title = rb_make_valid_utf8 (title, '?'); } else { fixed_title = g_uri_unescape_string (uri, NULL); } g_value_take_string (&val, fixed_title); rhythmdb_entry_set (source->priv->db, entry, RHYTHMDB_PROP_TITLE, &val); g_value_reset (&val); if ((!genre) || (strcmp (genre, "") == 0)) { genre = _("Unknown"); } else { fixed_genre = rb_make_valid_utf8 (genre, '?'); genre = fixed_genre; } g_value_set_string (&val, genre); rhythmdb_entry_set (source->priv->db, entry, RHYTHMDB_PROP_GENRE, &val); g_value_unset (&val); g_free (fixed_genre); g_value_init (&val, G_TYPE_DOUBLE); g_value_set_double (&val, 0.0); rhythmdb_entry_set (source->priv->db, entry, RHYTHMDB_PROP_RATING, &val); g_value_unset (&val); rhythmdb_commit (source->priv->db); g_free (real_uri); }
static void gst_rpi_cam_src_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { GstRpiCamSrc *src = GST_RPICAMSRC (object); g_mutex_lock (&src->config_lock); switch (prop_id) { case PROP_CAMERA_NUMBER: g_value_set_int (value, src->capture_config.cameraNum); break; case PROP_BITRATE: g_value_set_int (value, src->capture_config.bitrate); break; case PROP_KEYFRAME_INTERVAL: g_value_set_int (value, src->capture_config.intraperiod); break; case PROP_PREVIEW: g_value_set_boolean (value, src->capture_config.preview_parameters.wantPreview); break; case PROP_PREVIEW_ENCODED: g_value_set_boolean (value, src->capture_config.immutableInput); break; case PROP_FULLSCREEN: g_value_set_boolean (value, src->capture_config.preview_parameters.wantFullScreenPreview); break; case PROP_PREVIEW_OPACITY: g_value_set_int (value, src->capture_config.preview_parameters.opacity); break; case PROP_SHARPNESS: g_value_set_int (value, src->capture_config.camera_parameters.sharpness); break; case PROP_CONTRAST: g_value_set_int (value, src->capture_config.camera_parameters.contrast); break; case PROP_BRIGHTNESS: g_value_set_int (value, src->capture_config.camera_parameters.brightness); break; case PROP_SATURATION: g_value_set_int (value, src->capture_config.camera_parameters.saturation); break; case PROP_ISO: g_value_set_int (value, src->capture_config.camera_parameters.ISO); break; case PROP_VIDEO_STABILISATION: g_value_set_boolean (value, ! !(src->capture_config.camera_parameters.videoStabilisation)); break; case PROP_EXPOSURE_COMPENSATION: g_value_set_int (value, src->capture_config.camera_parameters.exposureCompensation); break; case PROP_EXPOSURE_MODE: g_value_set_enum (value, src->capture_config.camera_parameters.exposureMode); break; case PROP_EXPOSURE_METERING_MODE: g_value_set_enum (value, src->capture_config.camera_parameters.exposureMeterMode); break; case PROP_ROTATION: g_value_set_int (value, src->capture_config.camera_parameters.rotation); break; case PROP_AWB_MODE: g_value_set_enum (value, src->capture_config.camera_parameters.awbMode); break; case PROP_AWB_GAIN_RED: g_value_set_float (value, src->capture_config.camera_parameters.awb_gains_r); break; case PROP_AWB_GAIN_BLUE: g_value_set_float (value, src->capture_config.camera_parameters.awb_gains_b); break; case PROP_IMAGE_EFFECT: g_value_set_enum (value, src->capture_config.camera_parameters.imageEffect); break; case PROP_HFLIP: g_value_set_boolean (value, ! !(src->capture_config.camera_parameters.hflip)); break; case PROP_VFLIP: g_value_set_boolean (value, ! !(src->capture_config.camera_parameters.vflip)); break; case PROP_ROI_X: g_value_set_float (value, src->capture_config.camera_parameters.roi.x); break; case PROP_ROI_Y: g_value_set_float (value, src->capture_config.camera_parameters.roi.y); break; case PROP_ROI_W: g_value_set_float (value, src->capture_config.camera_parameters.roi.w); break; case PROP_ROI_H: g_value_set_float (value, src->capture_config.camera_parameters.roi.h); break; case PROP_QUANTISATION_PARAMETER: g_value_set_int (value, src->capture_config.quantisationParameter); break; case PROP_INLINE_HEADERS: g_value_set_boolean (value, src->capture_config.bInlineHeaders); break; case PROP_SHUTTER_SPEED: g_value_set_int (value, src->capture_config.camera_parameters.shutter_speed); break; case PROP_DRC: g_value_set_enum (value, src->capture_config.camera_parameters.drc_level); break; case PROP_SENSOR_MODE: g_value_set_enum (value, src->capture_config.sensor_mode); break; case PROP_ANNOTATION_MODE: g_value_set_flags (value, src->capture_config.camera_parameters.enable_annotate); break; case PROP_ANNOTATION_TEXT: g_value_set_string (value, src->capture_config.camera_parameters.annotate_string); break; case PROP_INTRA_REFRESH_TYPE: g_value_set_enum (value, src->capture_config.intra_refresh_type); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } g_mutex_unlock (&src->config_lock); }
//Cell edit handler. //Todo: why is this getting called on double-click when the text box hasn't //popped up yet? static void on_cell_edit(GtkCellRendererText *renderer, gchar *path, gchar *new_text, gpointer user_data) { int i, j; GtkTreeIter iter; GValue newval, val_addr, val_type, val_offset; uint32 addr, type, value, offset; uint64 value64; float valuef; double valued; char formatted[18]; //for reading hex64 values gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(store), &iter, path); memset(&newval, 0, sizeof(newval)); memset(&val_addr, 0, sizeof(val_addr)); memset(&val_type, 0, sizeof(val_type)); memset(&val_offset, 0, sizeof(val_offset)); switch((long)user_data) //column number { case Col_Name: g_value_init(&newval, G_TYPE_STRING); g_value_set_string(&newval, new_text); break; case Col_Value: //Get address gtk_tree_model_get_value(GTK_TREE_MODEL(store), &iter, Col_Address, &val_addr); addr = g_value_get_int(&val_addr); //Get type gtk_tree_model_get_value(GTK_TREE_MODEL(store), &iter, Col_Type, &val_type); type = g_value_get_int(&val_type); //Get offset gtk_tree_model_get_value(GTK_TREE_MODEL(store), &iter, Col_Offset, &val_offset); offset = g_value_get_int(&val_offset); //If pointer, follow it. if(type & Type_pointer) { type &= ~Type_pointer; addr = read_memory_32(addr) + offset; } //Get new value and write. //Todo: should not write if value is invalid, or strip any non- //numeric characters from value, to avoid the annoying bug where //you make a typo and it gets set to zero. //If we just copy the current value into the variables sscanf() is //supposed to set, it won't change them when the format string is //invalid. Not sure what happens if it's too long. switch(type) { case Type_int8: sscanf(new_text, "%d", &value); write_memory_8(addr, value); break; case Type_int16: sscanf(new_text, "%d", &value); write_memory_16(addr, value); break; case Type_int32: sscanf(new_text, "%d", &value); write_memory_32(addr, value); break; case Type_int64: sscanf(new_text, "%" PRId64, &value64); write_memory_64(addr, value64); break; case Type_uint8: sscanf(new_text, "%u", &value); write_memory_8(addr, value); break; case Type_uint16: sscanf(new_text, "%u", &value); write_memory_16(addr, value); break; case Type_uint32: sscanf(new_text, "%u", &value); write_memory_32(addr, value); break; case Type_uint64: sscanf(new_text, "%" PRIu64, &value64); write_memory_64(addr, value64); break; case Type_hex8: sscanf(new_text, "%X", &value); write_memory_8(addr, value); break; case Type_hex16: sscanf(new_text, "%X", &value); write_memory_16(addr, value); break; case Type_hex32: sscanf(new_text, "%X", &value); write_memory_32(addr, value); break; case Type_hex64: //Copy new text without spaces so it can be parsed correctly. j = 0; for(i=0; new_text[i]; i++) { if(new_text[i] == ' ') continue; formatted[j] = new_text[i]; j++; } formatted[j] = '\0'; sscanf(formatted, "%" PRIX64, &value64); write_memory_64(addr, value64); break; case Type_float: //todo: the value needs to be converted to IEEE 754 somehow. sscanf(new_text, "%f", &valuef); write_memory_32(addr, (int)value); break; case Type_double: sscanf(new_text, "%lf", &valued); write_memory_64(addr, (uint64)value); break; default: printf("on_cell_edit(): unknown type %d in \"%s\", col %d\n", type, path, (int)(long)user_data); return; break; } break; case Col_Address: g_value_init(&newval, G_TYPE_INT); sscanf(new_text, "%X", &addr); g_value_set_int(&newval, addr); break; case Col_Type: //todo - this should actually be a dropdown list, not editable, //if I had any idea how to do that. if(strlen(new_text) > 2) return; //so "float" doesn't get parsed as 0xF addr = 0x7F; g_value_init(&newval, G_TYPE_INT); sscanf(new_text, "%X", &addr); if((addr & 0x7F) >= Num_Types) return; g_value_set_int(&newval, addr); break; case Col_Offset: g_value_init(&newval, G_TYPE_INT); sscanf(new_text, "%X", &addr); g_value_set_int(&newval, addr); break; } if((long)user_data != Col_Value) gtk_tree_store_set_value(store, &iter, (int)(long)user_data, &newval); }
static void gst_imx_v4l2src_get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { GstImxV4l2VideoSrc *v4l2src = GST_IMX_V4L2SRC(object); switch (prop_id) { case IMX_V4L2SRC_CAPTURE_MODE: g_value_set_int(value, v4l2src->capture_mode); break; case IMX_V4L2SRC_FRAMERATE_NUM: g_value_set_int(value, v4l2src->fps_n); break; case IMX_V4L2SRC_INPUT: g_value_set_int(value, v4l2src->input); break; case IMX_V4L2SRC_DEVICE: g_value_set_string(value, v4l2src->devicename); break; case IMX_V4L2SRC_QUEUE_SIZE: g_value_set_int(value, v4l2src->queue_size); break; case IMX_V4L2SRC_CROP_META_X: g_value_set_int(value, v4l2src->metaCropX); break; case IMX_V4L2SRC_CROP_META_Y: g_value_set_int(value, v4l2src->metaCropY); break; case IMX_V4L2SRC_CROP_META_WIDTH: g_value_set_int(value, v4l2src->metaCropWidth); break; case IMX_V4L2SRC_CROP_META_HEIGHT: g_value_set_int(value, v4l2src->metaCropHeight); break; case PROP_FOCUS_MODE: { GstPhotographyFocusMode focus_mode; gst_imx_v4l2src_get_focus_mode(GST_PHOTOGRAPHY(v4l2src), &focus_mode); g_value_set_enum(value, focus_mode); } break; case PROP_WB_MODE: g_value_set_enum(value, GST_PHOTOGRAPHY_WB_MODE_AUTO); break; case PROP_COLOR_TONE: g_value_set_enum(value, GST_PHOTOGRAPHY_COLOR_TONE_MODE_NORMAL); break; case PROP_SCENE_MODE: g_value_set_enum(value, GST_TYPE_PHOTOGRAPHY_SCENE_MODE); break; case PROP_FLASH_MODE: g_value_set_enum(value, GST_PHOTOGRAPHY_FLASH_MODE_AUTO); break; case PROP_FLICKER_MODE: g_value_set_enum(value, GST_PHOTOGRAPHY_FLICKER_REDUCTION_OFF); break; case PROP_CAPABILITIES: g_value_set_ulong(value, GST_PHOTOGRAPHY_CAPS_NONE); break; case PROP_EV_COMP: g_value_set_float(value, 0.0f); break; case PROP_ISO_SPEED: g_value_set_uint(value, 0); break; case PROP_APERTURE: g_value_set_uint(value, 0); break; case PROP_EXPOSURE_TIME: g_value_set_uint(value, 0); break; case PROP_IMAGE_CAPTURE_SUPPORTED_CAPS: case PROP_IMAGE_PREVIEW_SUPPORTED_CAPS: if (v4l2src->fd_obj_v4l) gst_value_set_caps(value, gst_imx_v4l2src_caps_for_current_setup(v4l2src)); else GST_DEBUG_OBJECT(v4l2src, "not connected to hardware, don't know supported caps"); break; case PROP_ZOOM: g_value_set_float(value, 1.0f); break; case PROP_COLOR_TEMPERATURE: g_value_set_uint(value, 0); break; case PROP_WHITE_POINT: g_value_set_boxed(value, NULL); break; case PROP_ANALOG_GAIN: g_value_set_float(value, 1.0f); break; case PROP_LENS_FOCUS: g_value_set_float(value, 0.0f); break; case PROP_MIN_EXPOSURE_TIME: g_value_set_uint(value, 0); break; case PROP_MAX_EXPOSURE_TIME: g_value_set_uint(value, 0); break; case PROP_NOISE_REDUCTION: g_value_set_flags(value, 0); default: G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); break; } }