static gboolean _combo_box_set_active_text(GtkComboBox *cb,gchar *text)
{
gboolean found=FALSE;
gchar *sv=NULL;
GtkTreeIter iter;
GtkTreeModel *tm=gtk_combo_box_get_model(cb);
if( gtk_tree_model_get_iter_first (tm,&iter) )
{
do
{
GValue value = { 0, };
gtk_tree_model_get_value(tm,&iter,0,&value);
if (G_VALUE_HOLDS_STRING (&value))
if( (sv=(gchar *)g_value_get_string(&value))!=NULL && strcmp(sv,text)==0)
{
gtk_combo_box_set_active_iter(cb, &iter);
found=TRUE;
break;
}
}
while( gtk_tree_model_iter_next(tm,&iter) );
}
return found;
}
/*
* Obtain the name of the directory (a string) where cached tiles should be
* stored.
*/
void
ph_config_get_tile_cache_location(GValue *value)
{
gchar *location;
static gchar *default_location = NULL;
g_return_if_fail(ph_config != NULL);
g_return_if_fail(G_VALUE_HOLDS_STRING(value));
location = g_key_file_get_string(ph_config->key_file,
"tile-cache", "location",
NULL);
if (location == NULL) {
if (default_location == NULL)
default_location = g_build_filename(g_get_user_cache_dir(),
g_get_prgname(),
"map-tiles",
NULL);
g_value_set_static_string(value, default_location);
}
else
g_value_take_string(value, location);
}
static void
gimp_thumbnail_debug_notify (GObject *object,
GParamSpec *pspec)
{
GValue value = { 0, };
gchar *str = NULL;
const gchar *name;
g_value_init (&value, pspec->value_type);
g_object_get_property (object, pspec->name, &value);
if (G_VALUE_HOLDS_STRING (&value))
{
str = g_value_dup_string (&value);
}
else if (g_value_type_transformable (pspec->value_type, G_TYPE_STRING))
{
GValue tmp = { 0, };
g_value_init (&tmp, G_TYPE_STRING);
g_value_transform (&value, &tmp);
str = g_value_dup_string (&tmp);
g_value_unset (&tmp);
}
g_value_unset (&value);
name = GIMP_THUMBNAIL (object)->image_uri;
g_printerr (" GimpThumb (%s) %s: %s\n",
name ? name : "(null)", pspec->name, str);
g_free (str);
}
/* ================================================================= */
static void
load_taxtable_guid( const GncSqlBackend* be, GncSqlRow* row,
QofSetterFunc setter, gpointer pObject,
const GncSqlColumnTableEntry* table_row )
{
const GValue* val;
GncGUID guid;
GncTaxTable* taxtable = NULL;
g_return_if_fail( be != NULL );
g_return_if_fail( row != NULL );
g_return_if_fail( pObject != NULL );
g_return_if_fail( table_row != NULL );
val = gnc_sql_row_get_value_at_col_name( row, table_row->col_name );
if ( val != NULL && G_VALUE_HOLDS_STRING( val ) && g_value_get_string( val ) != NULL )
{
string_to_guid( g_value_get_string( val ), &guid );
taxtable = gncTaxTableLookup( be->book, &guid );
if ( taxtable != NULL )
{
if ( table_row->gobj_param_name != NULL )
{
g_object_set( pObject, table_row->gobj_param_name, taxtable, NULL );
}
else
{
(*setter)( pObject, (const gpointer)taxtable );
}
}
else
{
PWARN( "Taxtable ref '%s' not found", g_value_get_string( val ) );
}
}
}
static gboolean
cc_sharing_panel_networks_to_label_transform_func (GBinding *binding,
const GValue *source_value,
GValue *target_value,
CcSharingPanel *self)
{
CcSharingStatus status;
if (!G_VALUE_HOLDS_UINT (source_value))
return FALSE;
if (!G_VALUE_HOLDS_STRING (target_value))
return FALSE;
status = g_value_get_uint (source_value);
switch (status) {
case CC_SHARING_STATUS_OFF:
g_value_set_string (target_value, C_("service is disabled", "Off"));
break;
case CC_SHARING_STATUS_ENABLED:
g_value_set_string (target_value, C_("service is enabled", "Enabled"));
break;
case CC_SHARING_STATUS_ACTIVE:
g_value_set_string (target_value, C_("service is active", "Active"));
break;
default:
return FALSE;
}
/* ensure the master switch is active if one of the services is active */
if (status != CC_SHARING_STATUS_OFF)
gtk_switch_set_active (GTK_SWITCH (self->priv->master_switch), TRUE);
return TRUE;
}
static GObject *
g_local_directory_monitor_constructor (GType type,
guint n_construct_properties,
GObjectConstructParam *construct_properties)
{
GObject *obj;
GLocalDirectoryMonitorClass *klass;
GObjectClass *parent_class;
GLocalDirectoryMonitor *local_monitor;
GFileMonitorFlags flags = 0;
const gchar *dirname = NULL;
gint i;
klass = G_LOCAL_DIRECTORY_MONITOR_CLASS (g_type_class_peek (G_TYPE_LOCAL_DIRECTORY_MONITOR));
parent_class = G_OBJECT_CLASS (g_type_class_peek_parent (klass));
obj = parent_class->constructor (type,
n_construct_properties,
construct_properties);
local_monitor = G_LOCAL_DIRECTORY_MONITOR (obj);
for (i = 0; i < n_construct_properties; i++)
{
if (strcmp ("dirname", g_param_spec_get_name (construct_properties[i].pspec)) == 0)
{
g_warn_if_fail (G_VALUE_HOLDS_STRING (construct_properties[i].value));
dirname = g_value_get_string (construct_properties[i].value);
}
if (strcmp ("flags", g_param_spec_get_name (construct_properties[i].pspec)) == 0)
{
g_warn_if_fail (G_VALUE_HOLDS_FLAGS (construct_properties[i].value));
flags = g_value_get_flags (construct_properties[i].value);
}
}
local_monitor->dirname = g_strdup (dirname);
local_monitor->flags = flags;
if (!klass->mount_notify &&
(flags & G_FILE_MONITOR_WATCH_MOUNTS))
{
#ifdef G_OS_WIN32
/*claim everything was mounted */
local_monitor->was_mounted = TRUE;
#else
GUnixMountEntry *mount;
/* Emulate unmount detection */
mount = g_unix_mount_at (local_monitor->dirname, NULL);
local_monitor->was_mounted = mount != NULL;
if (mount)
g_unix_mount_free (mount);
local_monitor->mount_monitor = g_unix_mount_monitor_new ();
g_signal_connect_object (local_monitor->mount_monitor, "mounts-changed",
G_CALLBACK (mounts_changed), local_monitor, 0);
#endif
}
return obj;
}
static GtkCellEditable *
parasite_property_cell_renderer_start_editing(GtkCellRenderer *renderer,
GdkEvent *event,
GtkWidget *widget,
const gchar *path,
GdkRectangle *background_area,
GdkRectangle *cell_area,
GtkCellRendererState flags)
{
PangoFontDescription *font_desc;
GtkCellEditable *editable = NULL;
GObject *object;
const char *name;
GValue gvalue = {0};
GParamSpec *prop;
g_object_get(renderer,
"object", &object,
"name", &name,
NULL);
prop = g_object_class_find_property(G_OBJECT_GET_CLASS(object), name);
if (!(prop->flags & G_PARAM_WRITABLE))
return NULL;
g_value_init(&gvalue, prop->value_type);
g_object_get_property(object, name, &gvalue);
if (G_VALUE_HOLDS_ENUM(&gvalue) || G_VALUE_HOLDS_BOOLEAN(&gvalue))
{
GtkWidget *combobox = gtk_combo_box_new_text();
gtk_widget_show(combobox);
g_object_set(G_OBJECT(combobox), "has-frame", FALSE, NULL);
GList *renderers;
if (G_VALUE_HOLDS_BOOLEAN(&gvalue))
{
gtk_combo_box_append_text(GTK_COMBO_BOX(combobox), "FALSE");
gtk_combo_box_append_text(GTK_COMBO_BOX(combobox), "TRUE");
gtk_combo_box_set_active(GTK_COMBO_BOX(combobox),
g_value_get_boolean(&gvalue) ? 1 : 0);
}
else if (G_VALUE_HOLDS_ENUM(&gvalue))
{
gint value = g_value_get_enum(&gvalue);
GEnumClass *enum_class = G_PARAM_SPEC_ENUM(prop)->enum_class;
guint i;
for (i = 0; i < enum_class->n_values; i++)
{
GEnumValue *enum_value = &enum_class->values[i];
gtk_combo_box_append_text(GTK_COMBO_BOX(combobox),
enum_value->value_name);
if (enum_value->value == value)
gtk_combo_box_set_active(GTK_COMBO_BOX(combobox), i);
}
}
renderers = gtk_cell_layout_get_cells(GTK_CELL_LAYOUT(combobox));
g_object_set(G_OBJECT(renderers->data), "scale", TREE_TEXT_SCALE, NULL);
g_list_free(renderers);
editable = GTK_CELL_EDITABLE(combobox);
}
else if (G_VALUE_HOLDS_STRING(&gvalue))
{
GtkWidget *entry = gtk_entry_new();
gtk_widget_show(entry);
gtk_entry_set_text(GTK_ENTRY(entry), g_value_get_string(&gvalue));
editable = GTK_CELL_EDITABLE(entry);
}
else if (G_VALUE_HOLDS_INT(&gvalue) ||
G_VALUE_HOLDS_UINT(&gvalue) ||
G_VALUE_HOLDS_INT64(&gvalue) ||
G_VALUE_HOLDS_UINT64(&gvalue) ||
G_VALUE_HOLDS_LONG(&gvalue) ||
G_VALUE_HOLDS_ULONG(&gvalue) ||
G_VALUE_HOLDS_DOUBLE(&gvalue))
{
double min, max, value;
GtkWidget *spinbutton;
guint digits = 0;
if (G_VALUE_HOLDS_INT(&gvalue))
{
GParamSpecInt *paramspec = G_PARAM_SPEC_INT(prop);
min = paramspec->minimum;
max = paramspec->maximum;
value = g_value_get_int(&gvalue);
}
else if (G_VALUE_HOLDS_UINT(&gvalue))
{
GParamSpecUInt *paramspec = G_PARAM_SPEC_UINT(prop);
min = paramspec->minimum;
max = paramspec->maximum;
value = g_value_get_uint(&gvalue);
}
else if (G_VALUE_HOLDS_INT64(&gvalue))
{
GParamSpecInt64 *paramspec = G_PARAM_SPEC_INT64(prop);
min = paramspec->minimum;
max = paramspec->maximum;
value = g_value_get_int64(&gvalue);
}
else if (G_VALUE_HOLDS_UINT64(&gvalue))
{
GParamSpecUInt64 *paramspec = G_PARAM_SPEC_UINT64(prop);
min = paramspec->minimum;
max = paramspec->maximum;
value = g_value_get_uint64(&gvalue);
}
else if (G_VALUE_HOLDS_LONG(&gvalue))
{
GParamSpecLong *paramspec = G_PARAM_SPEC_LONG(prop);
min = paramspec->minimum;
max = paramspec->maximum;
value = g_value_get_long(&gvalue);
}
else if (G_VALUE_HOLDS_ULONG(&gvalue))
{
GParamSpecULong *paramspec = G_PARAM_SPEC_ULONG(prop);
min = paramspec->minimum;
max = paramspec->maximum;
value = g_value_get_ulong(&gvalue);
}
else if (G_VALUE_HOLDS_DOUBLE(&gvalue))
{
GParamSpecDouble *paramspec = G_PARAM_SPEC_DOUBLE(prop);
min = paramspec->minimum;
max = paramspec->maximum;
value = g_value_get_double(&gvalue);
digits = 2;
}
else
{
// Shouldn't really be able to happen.
return NULL;
}
spinbutton = gtk_spin_button_new_with_range(min, max, 1);
gtk_widget_show(spinbutton);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(spinbutton), value);
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(spinbutton), digits);
editable = GTK_CELL_EDITABLE(spinbutton);
}
font_desc = pango_font_description_new();
pango_font_description_set_size(font_desc, 8 * PANGO_SCALE);
gtk_widget_modify_font(GTK_WIDGET(editable), font_desc);
pango_font_description_free(font_desc);
g_value_unset(&gvalue);
g_signal_connect(G_OBJECT(editable), "editing_done",
G_CALLBACK(parasite_property_cell_renderer_stop_editing),
renderer);
g_object_set_data_full(G_OBJECT(editable), "_prop_name", g_strdup(name),
g_free);
g_object_set_data(G_OBJECT(editable), "_prop_object", object);
return editable;
}
GList *
midgard_core_qb_set_object_from_query (MidgardQueryBuilder *builder, guint select_type, MidgardObject **nobject)
{
g_assert(builder != NULL);
guint ret_rows, ret_fields;
MidgardConnection *mgd = builder->priv->mgd;
gchar *sql = midgard_core_qb_get_sql(
builder, select_type,
midgard_query_builder_get_object_select(builder, select_type));
GSList *olist = NULL;
MidgardDBObjectClass *dbklass = MIDGARD_DBOBJECT_CLASS(g_type_class_peek(builder->priv->type));
if (!dbklass) {
MIDGARD_ERRNO_SET_STRING (mgd, MGD_ERR_INTERNAL, "Failed to peek MidgardDBObjectClass pointer");
return NULL;
}
if (dbklass->dbpriv->set_from_sql) {
if (select_type != MQB_SELECT_GUID) {
olist = dbklass->dbpriv->set_from_sql(mgd, builder->priv->type, ((const gchar *)sql));
g_free(sql);
return (GList *)olist;
}
}
GdaDataModel *model = midgard_core_query_get_model(builder->priv->mgd, sql);
g_free(sql);
if(!model)
return NULL;
MidgardObject *object = NULL;
gint rows, columns;
const GValue *gvalue = NULL;
ret_rows = gda_data_model_get_n_rows(model);
ret_fields = gda_data_model_get_n_columns(model);
/* records found , allocate as many objects as many returned rows */
GList *list = NULL;
if(ret_rows == 0) {
g_object_unref(model);
return list;
}
/* We count rows only */
if(select_type == MQB_SELECT_GUID) {
gvalue = midgard_data_model_get_value_at(model, 0, 0);
if (!gvalue || !G_IS_VALUE (gvalue)) {
g_object_unref (model);
return 0;
}
MidgardTypeHolder *holder = g_new(MidgardTypeHolder, 1);
GValue val = {0, };
g_value_init (&val, G_TYPE_INT64);
g_value_transform (gvalue, &val);
holder->elements = (guint)g_value_get_int64((GValue*)&val);
list = g_list_append(list, holder);
g_object_unref(model);
g_value_unset (&val);
return list;
}
/* Get every row */
for (rows = 0; rows < ret_rows; rows++) {
if(!nobject)
object = g_object_new (builder->priv->type, "connection", mgd, NULL);
else
object = *nobject;
MGD_OBJECT_IN_STORAGE (object) = TRUE;
if(dbklass->dbpriv->__set_from_sql != NULL) {
dbklass->dbpriv->__set_from_sql(MIDGARD_DBOBJECT(object),
model, rows);
} else {
/* Compute number of metadata properties */
guint n_md_props = 0;
MidgardMetadata *mklass = (MidgardMetadata *)MGD_DBCLASS_METADATA_CLASS (dbklass);
if (mklass)
n_md_props = g_hash_table_size (MGD_DBCLASS_STORAGE_DATA (mklass)->prophash);
guint __cols = n_md_props + 1; /* Add one for guid */
/* we have guid and metadata columns first */
for (columns = __cols; columns < ret_fields; columns++) {
gvalue = midgard_data_model_get_value_at(model, columns, rows);
const gchar *coltitle =
gda_data_model_get_column_title(model, columns);
GParamSpec *pspec =
g_object_class_find_property(G_OBJECT_GET_CLASS(object), coltitle);
if(G_IS_VALUE(gvalue)) {
if (!pspec) {
g_warning("Failed to found (unregistered) %s property (%s class)",
coltitle, G_OBJECT_TYPE_NAME(object));
continue;
}
if (G_VALUE_TYPE (gvalue) == GDA_TYPE_BINARY
&& G_TYPE_FUNDAMENTAL (pspec->value_type) == G_TYPE_STRING) {
gchar *stringified = midgard_core_query_binary_stringify ((GValue *)gvalue);
g_object_set (G_OBJECT (object), coltitle, stringified, NULL);
g_free (stringified);
} else if (pspec->value_type != G_VALUE_TYPE (gvalue)) {
GValue _convert = {0, };
g_value_init (&_convert, pspec->value_type);
if (g_value_transform (gvalue, &_convert)) {
/* FIXME, remove workaround once it's fixed in GDA */
/* https://bugzilla.gnome.org/show_bug.cgi?id=617550 */
guint dbtype = mgd->priv->config->priv->dbtype;
if (dbtype == MIDGARD_DB_TYPE_MYSQL && G_VALUE_TYPE (gvalue) == GDA_TYPE_BLOB) {
gchar *tmp_str = __default_unescape_string (g_value_get_string (&_convert));
if (tmp_str)
g_value_take_string (&_convert, tmp_str);
}
g_object_set_property (G_OBJECT (object), coltitle, &_convert);
} else {
g_warning ("Failed to convert %s to %s for %s property",
G_VALUE_TYPE_NAME (gvalue),
G_VALUE_TYPE_NAME (&_convert),
coltitle);
}
g_value_unset (&_convert);
} else {
g_object_set_property(G_OBJECT(object), coltitle, gvalue);
}
} else if (gda_value_is_null(gvalue)) {
switch (pspec->value_type) {
case G_TYPE_INT:
case G_TYPE_UINT:
g_object_set(G_OBJECT(object), coltitle, 0, NULL);
break;
case G_TYPE_STRING:
g_object_set(G_OBJECT(object), coltitle, "", NULL);
break;
default:
g_warning("Found (%s) not a value at %d.%d (%s)",
g_type_name(pspec->value_type),
columns, rows,
gda_data_model_get_column_title(model, columns));
break;
}
}
}
}
/* Set guid */
const gchar *guid;
gvalue = midgard_data_model_get_value_at(model, 0, rows);
if(G_IS_VALUE(gvalue) && G_VALUE_HOLDS_STRING(gvalue)){
guid = g_value_get_string(gvalue);
g_free((gchar *)MIDGARD_DBOBJECT(object)->dbpriv->guid);
MIDGARD_DBOBJECT(object)->dbpriv->guid = g_strdup(guid);
}
/* Set metadata */
MidgardMetadata *metadata = MGD_DBOBJECT_METADATA (object);
if (metadata) {
GParamSpec *pspec = g_object_class_find_property(G_OBJECT_GET_CLASS(object), "metadata");
if (pspec)
__mqb_set_metadata(metadata, model, rows);
}
list = g_list_append(list, G_OBJECT(object));
}
g_object_unref(model);
return list;
}
static gboolean _extract_metadata (GHashTable *pMetadata)
{
gboolean bTrackHasChanged = FALSE;
GValue *v;
const gchar *str = NULL;
v = g_hash_table_lookup (pMetadata, "mpris:trackid"); // a string or a dbus object path that uniquely identifies the track within the scope of the playlist
if (v != NULL)
{
if (G_VALUE_HOLDS (v, DBUS_TYPE_G_OBJECT_PATH)) // now this attribute should be of D-Bus type "o"
str = (gchar*) g_value_get_boxed (v);
else if (G_VALUE_HOLDS_STRING (v)) // but can be a string... e.g. with Rhythmbox
str = g_value_get_string (v);
bTrackHasChanged = _is_a_new_track (str);
}
v = g_hash_table_lookup (pMetadata, "mpris:length"); // length of the track, in microseconds (signed 64-bit integer)
if (v != NULL)
{
if (G_VALUE_HOLDS_INT64 (v)) // should be a int64
myData.iSongLength = g_value_get_int64 (v) / 1000000;
else if (G_VALUE_HOLDS_INT (v)) // but some players doesn't respect that... maybe a limitation?
myData.iSongLength = g_value_get_int (v) / 1000000;
else
cd_warning ("Length has a wrong type");
cd_debug ("Length: %d", myData.iSongLength);
}
gchar *cOldArtist = myData.cArtist;
myData.cArtist = NULL;
v = (GValue *) g_hash_table_lookup(pMetadata, "xesam:artist");
if (v != NULL && G_VALUE_HOLDS(v, G_TYPE_STRV))
{
gchar **artists = g_value_get_boxed(v);
if (artists != NULL)
myData.cArtist = g_strjoinv (NULL, artists);
}
cd_message (" cArtist <- %s", myData.cArtist);
// maybe the user has renamed the tags of the current song...
if (! bTrackHasChanged && cairo_dock_strings_differ (myData.cArtist, cOldArtist))
bTrackHasChanged = TRUE;
g_free (cOldArtist);
g_free (myData.cAlbum);
myData.cAlbum = NULL;
v = (GValue *) g_hash_table_lookup(pMetadata, "xesam:album");
if (v != NULL && G_VALUE_HOLDS_STRING(v))
{
str = g_value_get_string(v);
if (str && *str != '\0')
myData.cAlbum = g_strdup (str);
}
cd_message (" cAlbum <- %s", myData.cAlbum);
gchar *cOldTitle = myData.cTitle;
myData.cTitle = NULL;
v = (GValue *) g_hash_table_lookup(pMetadata, "xesam:title");
if (v != NULL && G_VALUE_HOLDS_STRING(v))
{
str = g_value_get_string(v);
if (str && *str != '\0')
myData.cTitle = g_strdup (str);
}
cd_message (" cTitle <- %s", myData.cTitle);
/* some players doesn't support (well) the trackid. Even if this is not our
* problem, it can be interesting to also check if the title has changed.
*/
if (! bTrackHasChanged && cairo_dock_strings_differ (myData.cTitle, cOldTitle))
bTrackHasChanged = TRUE;
g_free (cOldTitle);
g_free (myData.cPlayingUri);
myData.cPlayingUri = NULL;
v = (GValue *) g_hash_table_lookup(pMetadata, "xesam:url");
if (!v)
v = (GValue *) g_hash_table_lookup(pMetadata, "xesam:uri");
if (v != NULL && G_VALUE_HOLDS_STRING(v))
{
str = g_value_get_string(v);
if (str && *str != '\0')
myData.cPlayingUri = g_strdup (str);
}
cd_message (" cUri <- %s", myData.cPlayingUri);
myData.iTrackNumber = 0; // not really useful, it's the track-number in the album.
v = (GValue *) g_hash_table_lookup(pMetadata, "xesam:trackNumber");
if (v != NULL && G_VALUE_HOLDS_INT(v))
{
myData.iTrackNumber = g_value_get_int (v);
}
cd_message (" iTrackNumber <- %d", myData.iTrackNumber);
const gchar *cCoverPath = NULL;
v = g_hash_table_lookup(pMetadata, "mpris:artUrl");
if (v != NULL && G_VALUE_HOLDS_STRING(v))
{
cCoverPath = g_value_get_string(v);
}
cd_musicplayer_set_cover_path (cCoverPath); // do it at the end (we have to know the artist and the album if (cCoverPath == NULL))
/// we miss iTrackListIndex and tracklist-length ...
return bTrackHasChanged;
}
//! edit
gboolean modifEdi(GtkWidget* parent , gpointer data){
gboolean status = FALSE;
gint id = GPOINTER_TO_INT(data);
gint result = GTK_RESPONSE_OK;
if(data == NULL){
GtkWidget *comboId = gtk_combo_box_new ();
GtkWidget *dialog = modifGetPilihanId(comboId);
gtk_widget_show_all(dialog);
result = gtk_dialog_run (dialog); // block
id = globalConStrToInt(gtk_combo_box_get_active_text(comboId));
gtk_widget_destroy(dialog);
}
if(result==GTK_RESPONSE_OK){
modifStruct_ *modif = struct_new(modifStruct_);
gchar *title = g_strdup_printf ("Edit Data dengan id %d", id);
GtkWidget *dialog = modifGetDialogWithStruct(parent , modif , title);
//! mengambil data dari database
GValueArray* varr = g_value_array_new (-1);
GValue a = {0};
g_assert (!G_VALUE_HOLDS_STRING (&a));
g_value_init (&a, G_TYPE_INT);
g_value_set_int (&a, id );
varr = g_value_array_append(varr,&a);
gchar *sql = g_strdup_printf ("%s and isi.id=?", globalGetDefCom() );
GValueArray *hasil = databaseGetDatasFromDb( sql , varr , &status);
modifSetItemToWidget(modif,hasil);
//! show
gtk_widget_show_all(dialog);
result = gtk_dialog_run (dialog); // block
if (result==GTK_RESPONSE_OK){
//! sekarang kita akan masuk pada database
//! mengambil data
char *filename;
char* jamchar = globalPutZeroToWkt(gtk_spin_button_get_value_as_int(modif->jam));
char* mntchar = globalPutZeroToWkt(gtk_spin_button_get_value_as_int(modif->mnt));
gchar *jamMnt = g_strdup_printf ("%s:%s", jamchar,mntchar);
gchar * hari = gtk_combo_box_get_active_text ( modif->hari);
gchar * bagian = gtk_combo_box_get_active_text ( modif->bagian );
gint total = gtk_spin_button_get_value_as_int (modif->total);
filename = fuGetNameFile( gtk_button_get_label(modif->filePilih));
//! update database
gint idHari = databaseGetIdHari(hari);
GValueArray* varr = g_value_array_new (-1);
GValue a = {0};
g_assert (!G_VALUE_HOLDS_STRING (&a));
g_value_init (&a, G_TYPE_INT);
g_value_set_int (&a, idHari); //! 1
varr = g_value_array_append(varr,&a);
g_value_set_int (&a, total); //! 2
varr = g_value_array_append(varr,&a);
g_value_unset (&a);
g_value_init (&a, G_TYPE_STRING);
g_value_set_string (&a, jamMnt); //! 3
varr = g_value_array_append(varr,&a);
g_value_set_string (&a, bagian); //! 4
varr = g_value_array_append(varr,&a);
g_value_set_string (&a, filename); //! 5
varr = g_value_array_append(varr,&a);
g_value_unset (&a);
g_value_init (&a, G_TYPE_INT);
g_value_set_int (&a, id); //! 6
varr = g_value_array_append(varr,&a);
GValueArray *hasil = databaseGetDatasFromDb("update isi set dal=? , X=?,jam=?,bagian=?,alarm=? where id = ?" , varr,&status);
//! free
g_value_array_free (varr);
g_value_array_free (hasil);
//! aslinya harus di cek kembali
status = TRUE;
}
else{
}
//! free all
g_value_array_free (varr);
g_value_array_free (hasil);
gtk_widget_destroy(dialog);
}
return TRUE;
}
gint64
gimp_g_value_get_memsize (GValue *value)
{
gint64 memsize = 0;
if (! value)
return 0;
if (G_VALUE_HOLDS_STRING (value))
{
memsize += gimp_string_get_memsize (g_value_get_string (value));
}
else if (G_VALUE_HOLDS_BOXED (value))
{
if (GIMP_VALUE_HOLDS_RGB (value))
{
memsize += sizeof (GimpRGB);
}
else if (GIMP_VALUE_HOLDS_MATRIX2 (value))
{
memsize += sizeof (GimpMatrix2);
}
else if (GIMP_VALUE_HOLDS_PARASITE (value))
{
memsize += gimp_parasite_get_memsize (g_value_get_boxed (value),
NULL);
}
else if (GIMP_VALUE_HOLDS_ARRAY (value) ||
GIMP_VALUE_HOLDS_INT8_ARRAY (value) ||
GIMP_VALUE_HOLDS_INT16_ARRAY (value) ||
GIMP_VALUE_HOLDS_INT32_ARRAY (value) ||
GIMP_VALUE_HOLDS_FLOAT_ARRAY (value))
{
GimpArray *array = g_value_get_boxed (value);
if (array)
memsize += (sizeof (GimpArray) +
array->static_data ? 0 : array->length);
}
else if (GIMP_VALUE_HOLDS_STRING_ARRAY (value))
{
GimpArray *array = g_value_get_boxed (value);
if (array)
{
memsize += sizeof (GimpArray);
if (! array->static_data)
{
gchar **tmp = (gchar **) array->data;
gint i;
memsize += array->length * sizeof (gchar *);
for (i = 0; i < array->length; i++)
memsize += gimp_string_get_memsize (tmp[i]);
}
}
}
else
{
g_printerr ("%s: unhandled boxed value type: %s\n",
G_STRFUNC, G_VALUE_TYPE_NAME (value));
}
}
else if (G_VALUE_HOLDS_OBJECT (value))
{
g_printerr ("%s: unhandled object value type: %s\n",
G_STRFUNC, G_VALUE_TYPE_NAME (value));
}
return memsize + sizeof (GValue);
}
int
main (int argc,
char *argv[])
{
/* Initialisation */
gst_init (&argc, &argv);
GList *element_list = gst_element_factory_list_get_elements (GST_ELEMENT_FACTORY_TYPE_DEPAYLOADER,
GST_RANK_NONE);
GList *iter = element_list;
while (iter != NULL)
{
g_print ("+++++\n");
g_print ("%s -- ", gst_element_factory_get_longname ((GstElementFactory *)iter->data));
g_print ("%s\n", gst_plugin_feature_get_name ((GstPluginFeature *)iter->data));
const GList *static_pads =
gst_element_factory_get_static_pad_templates ((GstElementFactory *)iter->data);
while (NULL != static_pads)
{
GstStaticPadTemplate *pad = (GstStaticPadTemplate *)static_pads->data;
//the following is EMPTY gchar *caps_str = gst_caps_to_string (&pad->static_caps.caps);
//g_free (caps_str);
/* g_print ("string: %s\n", */
/* pad->static_caps.string); */
GstCaps *caps = gst_caps_from_string (pad->static_caps.string);
guint caps_size = gst_caps_get_size (caps);
if (! gst_caps_is_any (caps))
for (guint i = caps_size; i > 0; i--)
{
GstStructure *caps_struct = gst_caps_get_structure (caps, i-1);
if (gst_structure_has_name (caps_struct,"application/x-rtp"))
{
g_print ("string: %s\n",
gst_structure_to_string (caps_struct));
{//payload
const GValue *val = gst_structure_get_value (caps_struct, "payload");
if (NULL != val)
{
//g_print ("payload struct type %s\n", G_VALUE_TYPE_NAME (val));
if(GST_VALUE_HOLDS_INT_RANGE(val))
{
g_print ("payload min %d\n", gst_value_get_int_range_min (val));
}
if (GST_VALUE_HOLDS_LIST(val))
{
for (guint i = 0; i < gst_value_list_get_size (val); i++)
{
const GValue *item_val = gst_value_list_get_value (val, i);
g_print ("payload list %d\n", g_value_get_int (item_val));
}
}
if (G_VALUE_HOLDS_INT (val))
{
g_print ("payload int %d\n", g_value_get_int (val));
}
}
}
{ //encodeing-name
const GValue *val = gst_structure_get_value (caps_struct, "encoding-name");
if (NULL != val)
{
//g_print ("encoding-name struct type %s\n", G_VALUE_TYPE_NAME (val));
if (GST_VALUE_HOLDS_LIST(val))
{
for (guint i = 0; i < gst_value_list_get_size (val); i++)
{
const GValue *item_val = gst_value_list_get_value (val, i);
g_print ("encoding-name list %s\n", g_value_get_string (item_val));
}
}
if (G_VALUE_HOLDS_STRING (val))
{
g_print ("encoding-name string %s\n", g_value_get_string (val));
}
}
}
{//media
const GValue *val = gst_structure_get_value (caps_struct, "media");
if (NULL != val)
{
if (GST_VALUE_HOLDS_LIST(val))
{
for (guint i = 0; i < gst_value_list_get_size (val); i++)
{
const GValue *item_val = gst_value_list_get_value (val, i);
g_print ("media list %s\n", g_value_get_string (item_val));
}
}
if (G_VALUE_HOLDS_STRING (val))
{
g_print ("media string %s\n", g_value_get_string (val));
}
}
}
{//clock rate
const GValue *val = gst_structure_get_value (caps_struct, "clock-rate");
if (NULL != val)
{
//g_print ("payload struct type %s\n", G_VALUE_TYPE_NAME (val));
if(GST_VALUE_HOLDS_INT_RANGE(val))
{
g_print ("clock-rate min %d\n", gst_value_get_int_range_min (val));
}
if (GST_VALUE_HOLDS_LIST(val))
{
for (guint i = 0; i < gst_value_list_get_size (val); i++)
{
const GValue *item_val = gst_value_list_get_value (val, i);
g_print ("clock-rate list %d\n", g_value_get_int (item_val));
}
}
if (G_VALUE_HOLDS_INT (val))
{
g_print ("clock-rate int %d\n", g_value_get_int (val));
}
}
}
/* g_print ("\nencoding-name %s\n", */
/* gst_structure_get_string (caps_struct, */
/* "encoding-name")); */
}
}
static_pads = g_list_next (static_pads);
gst_caps_unref (caps);
}
iter = g_list_next (iter);
}
gst_plugin_feature_list_free (element_list);
return 0;
}
/* Recupere les infos de la chanson courante, y compris le chemin de la couverture (la telecharge au besoin).
*/
static void cd_rhythmbox_getSongInfos (gboolean bGetAll)
{
GHashTable *data_list = NULL;
GValue *value;
const gchar *data;
if(dbus_g_proxy_call (myData.dbus_proxy_shell, "getSongProperties", NULL,
G_TYPE_STRING, myData.cPlayingUri,
G_TYPE_INVALID,
MP_DBUS_TYPE_SONG_METADATA,
&data_list,
G_TYPE_INVALID))
{
if (bGetAll)
{
g_free (myData.cArtist);
value = (GValue *) g_hash_table_lookup(data_list, "artist");
if (value != NULL && G_VALUE_HOLDS_STRING(value)) myData.cArtist = g_strdup (g_value_get_string(value));
else myData.cArtist = NULL;
cd_message (" cArtist <- %s", myData.cArtist);
g_free (myData.cAlbum);
value = (GValue *) g_hash_table_lookup(data_list, "album");
if (value != NULL && G_VALUE_HOLDS_STRING(value)) myData.cAlbum = g_strdup (g_value_get_string(value));
else myData.cAlbum = NULL;
cd_message (" cAlbum <- %s", myData.cAlbum);
g_free (myData.cTitle);
value = (GValue *) g_hash_table_lookup(data_list, "title");
if (value != NULL && G_VALUE_HOLDS_STRING(value)) myData.cTitle = g_strdup (g_value_get_string(value));
else myData.cTitle = NULL;
cd_message (" cTitle <- %s", myData.cTitle);
value = (GValue *) g_hash_table_lookup(data_list, "track-number");
if (value != NULL && G_VALUE_HOLDS_UINT(value)) myData.iTrackNumber = g_value_get_uint(value);
else myData.iTrackNumber = 0;
cd_message (" iTrackNumber <- %d", myData.iTrackNumber);
value = (GValue *) g_hash_table_lookup(data_list, "duration");
if (value != NULL && G_VALUE_HOLDS_UINT(value)) myData.iSongLength = g_value_get_uint(value);
else myData.iSongLength = 0;
cd_message (" iSongLength <- %ds", myData.iSongLength);
myData.bCoverNeedsTest = FALSE;
}
const gchar *cString = NULL;
value = (GValue *) g_hash_table_lookup(data_list, "rb:coverArt-uri");
if (value != NULL && G_VALUE_HOLDS_STRING(value)) // RB nous donne une adresse, eventuellement distante.
cString = g_value_get_string(value);
cd_musicplayer_get_cover_path (cString, ! bGetAll); // la 2eme fois on ne recupere que la couverture et donc on cherche aussi en cache.
g_print ("MP : cCoverPath <- %s\n", myData.cCoverPath);
g_hash_table_destroy (data_list);
}
else
{
cd_warning (" can't get song properties");
g_free (myData.cPlayingUri);
myData.cPlayingUri = NULL;
g_free (myData.cTitle);
myData.cTitle = NULL;
g_free (myData.cAlbum);
myData.cAlbum = NULL;
g_free (myData.cCoverPath);
myData.cCoverPath = NULL;
}
}
gboolean cd_NetworkMonitor_get_active_connection_info (void)
{
cd_debug ("%s ()", __func__);
//\_____________ on reset tout.
myData.bWiredExt = myData.bWirelessExt = FALSE;
g_free (myData.cDevice);
myData.cDevice = NULL;
g_free (myData.cInterface);
myData.cInterface = NULL;
g_free (myData.cAccessPoint);
myData.cAccessPoint = NULL;
_reset_proxy (myData.dbus_proxy_ActiveConnection);
_reset_proxy (myData.dbus_proxy_ActiveConnection_prop);
_reset_proxy (myData.dbus_proxy_Device);
_reset_proxy (myData.dbus_proxy_Device_prop);
_reset_proxy (myData.dbus_proxy_ActiveAccessPoint);
_reset_proxy (myData.dbus_proxy_ActiveAccessPoint_prop);
_reset_proxy (myData.dbus_proxy_WirelessDevice);
_reset_proxy (myData.dbus_proxy_WiredDevice);
DBusGProxy *dbus_proxy_ActiveConnection_prop = NULL;
DBusGProxy *dbus_proxy_Device_prop = NULL;
uint j,k;
GPtrArray *paActiveConnections = NULL;
gchar *cActiveConnection, *cDevice, *cAccessPointPath, *cConnection;
const gchar *cServiceName;
//\_____________ On recupere la liste des connexions actives (ce sont les configs tout-en-un de NM qui sont actuellement utilisees).
paActiveConnections = (GPtrArray*) cairo_dock_dbus_get_property_as_boxed (myData.dbus_proxy_NM_prop, "org.freedesktop.NetworkManager", "ActiveConnections");
cd_debug ("%d connections", paActiveConnections->len);
for (j=0; j < paActiveConnections->len; j++)
{
cActiveConnection = (gchar *)g_ptr_array_index(paActiveConnections,j);
cd_debug ("Network-Monitor : Active Connection path : %s", cActiveConnection);
// on recupere les proprietes de la connexion.
dbus_proxy_ActiveConnection_prop = cairo_dock_create_new_system_proxy (
"org.freedesktop.NetworkManager",
cActiveConnection,
"org.freedesktop.DBus.Properties");
GHashTable *props = cairo_dock_dbus_get_all_properties (dbus_proxy_ActiveConnection_prop, "org.freedesktop.NetworkManager.Connection.Active");
if (props == NULL)
{
g_object_unref (dbus_proxy_ActiveConnection_prop);
continue;
}
// on regarde si c'est la connexion par defaut.
GValue *v = g_hash_table_lookup (props, "Default");
if (!v || !G_VALUE_HOLDS_BOOLEAN (v) || ! g_value_get_boolean (v))
{
g_hash_table_unref (props);
g_object_unref (dbus_proxy_ActiveConnection_prop);
continue;
}
cd_debug (" c'est la connexion par defaut\n");
myData.cActiveConnection = g_strdup (cActiveConnection);
// on recupere le SpecificObject qui contient le point d'acces courant.
cAccessPointPath=NULL;
v = g_hash_table_lookup (props, "SpecificObject");
if (v && G_VALUE_HOLDS_BOXED (v))
{
cAccessPointPath = g_value_get_boxed (v);
cd_debug (" cAccessPointPath : %s", cAccessPointPath);
}
// on recupere le nom du service qui fournit cette connexion.
cServiceName=NULL;
v = g_hash_table_lookup (props, "ServiceName");
if (v && G_VALUE_HOLDS_STRING (v))
{
cServiceName = g_value_get_string (v);
cd_debug (" cServiceName : %s", cServiceName);
}
// on recupere le chemin de la connection.
cConnection=NULL;
v = g_hash_table_lookup (props, "Connection");
if (v && G_VALUE_HOLDS (v, DBUS_TYPE_G_OBJECT_PATH))
{
cConnection = g_value_get_boxed (v);
cd_debug (" cConnectionPath : %s", cConnection);
}
// on parcourt la liste des devices associes.
v = g_hash_table_lookup (props, "Devices");
if (v && G_VALUE_HOLDS_BOXED (v))
{
GPtrArray *paDevices = g_value_get_boxed (v);
cd_debug (" %d devices", paDevices->len);
for (k=0; k < paDevices->len; k++)
{
// on recupere le device.
cDevice = (gchar *)g_ptr_array_index(paDevices,k);
cd_debug (" device path : %s", cDevice);
dbus_proxy_Device_prop = cairo_dock_create_new_system_proxy (
"org.freedesktop.NetworkManager",
cDevice,
"org.freedesktop.DBus.Properties");
// on regarde son type.
guint iDeviceType = cairo_dock_dbus_get_property_as_uint (dbus_proxy_Device_prop, "org.freedesktop.NetworkManager.Device", "DeviceType"); // 1 : ethernet, 2 : wifi
cd_debug (" device type : %d", iDeviceType);
if (iDeviceType != 1 && iDeviceType != 2) // ne nous insteresse pas.
{
g_object_unref (dbus_proxy_Device_prop);
continue;
}
// on recupere son interface.
gchar *cInterface = cairo_dock_dbus_get_property_as_string (dbus_proxy_Device_prop, "org.freedesktop.NetworkManager.Device", "Interface");
cd_debug (" interface :%s", cInterface);
// on garde toutes les infos en memoire.
myData.cInterface = cInterface;
myData.cDevice = g_strdup(cDevice);
myData.cServiceName = g_strdup (cServiceName);
myData.cConnection = g_strdup (cConnection);
myData.dbus_proxy_ActiveConnection_prop = dbus_proxy_ActiveConnection_prop;
myData.dbus_proxy_ActiveConnection = cairo_dock_create_new_system_proxy (
"org.freedesktop.NetworkManager",
myData.cActiveConnection,
"org.freedesktop.NetworkManager.Connection.Active");
dbus_g_proxy_add_signal(myData.dbus_proxy_ActiveConnection, "PropertiesChanged", CD_DBUS_TYPE_HASH_TABLE, G_TYPE_INVALID);
dbus_g_proxy_connect_signal(myData.dbus_proxy_ActiveConnection, "PropertiesChanged",
G_CALLBACK(onChangeActiveConnectionProperties), NULL, NULL);
myData.dbus_proxy_Device_prop = dbus_proxy_Device_prop;
myData.dbus_proxy_Device = cairo_dock_create_new_system_proxy (
"org.freedesktop.NetworkManager",
cDevice,
"org.freedesktop.NetworkManager.Device");
if (cAccessPointPath && strncmp (cAccessPointPath, "/org/freedesktop/NetworkManager/AccessPoint/", 44) == 0)
{
myData.cAccessPoint = g_strdup (cAccessPointPath);
myData.dbus_proxy_ActiveAccessPoint_prop = cairo_dock_create_new_system_proxy (
"org.freedesktop.NetworkManager",
cAccessPointPath,
"org.freedesktop.DBus.Properties");
myData.dbus_proxy_ActiveAccessPoint = cairo_dock_create_new_system_proxy (
"org.freedesktop.NetworkManager",
cAccessPointPath,
"org.freedesktop.NetworkManager.AccessPoint");
dbus_g_proxy_add_signal(myData.dbus_proxy_ActiveAccessPoint, "PropertiesChanged", CD_DBUS_TYPE_HASH_TABLE, G_TYPE_INVALID);
dbus_g_proxy_connect_signal(myData.dbus_proxy_ActiveAccessPoint, "PropertiesChanged",
G_CALLBACK(onChangeAccessPointProperties), NULL, NULL);
}
if (iDeviceType == 1)
{
cd_debug (" => Network-Monitor : Connexion filaire\n");
myData.bWiredExt = TRUE;
// on se connecte au changement de la propriete Carrier.
myData.dbus_proxy_WiredDevice = cairo_dock_create_new_system_proxy (
"org.freedesktop.NetworkManager",
myData.cDevice,
"org.freedesktop.NetworkManager.Device.Wired");
dbus_g_proxy_add_signal(myData.dbus_proxy_WiredDevice, "PropertiesChanged", CD_DBUS_TYPE_HASH_TABLE, G_TYPE_INVALID);
dbus_g_proxy_connect_signal(myData.dbus_proxy_WiredDevice, "PropertiesChanged",
G_CALLBACK(onChangeWiredDeviceProperties), NULL, NULL);
// on recupere les proprietes de la carte reseau, et de son etat connecte ou non.
cd_NetworkMonitor_get_wired_connection_infos();
}
else
{
cd_debug (" => Network-Monitor : Connexion sans fil\n");
myData.bWirelessExt = TRUE;
// on se connecte au changement de la propriete ActiveAccessPoint.
myData.dbus_proxy_WirelessDevice = cairo_dock_create_new_system_proxy (
"org.freedesktop.NetworkManager",
myData.cDevice,
"org.freedesktop.NetworkManager.Device.Wireless");
dbus_g_proxy_add_signal(myData.dbus_proxy_WirelessDevice, "PropertiesChanged", CD_DBUS_TYPE_HASH_TABLE, G_TYPE_INVALID);
dbus_g_proxy_connect_signal(myData.dbus_proxy_WirelessDevice, "PropertiesChanged",
G_CALLBACK(onChangeWirelessDeviceProperties), NULL, NULL);
// Recuperation de l'AP active.
cd_NetworkMonitor_get_wireless_connection_infos();
// Calcul de la qualite du signal
cd_NetworkMonitor_quality();
}
cd_NetworkMonitor_draw_icon ();
break ;
} // fin de la liste des devices.
}
g_hash_table_unref (props);
break; // on prend la premierr connexion.
}
g_ptr_array_free(paActiveConnections,TRUE);
return (myData.bWiredExt || myData.bWirelessExt);
}
static GstCaps *
gst_avdtp_src_getcaps (GstBaseSrc * bsrc, GstCaps * filter)
{
GstAvdtpSrc *avdtpsrc = GST_AVDTP_SRC (bsrc);
GstCaps *caps = NULL, *ret = NULL;
if (avdtpsrc->dev_caps) {
const GValue *value;
const char *format;
int rate;
GstStructure *structure = gst_caps_get_structure (avdtpsrc->dev_caps, 0);
format = gst_structure_get_name (structure);
if (g_str_equal (format, "audio/x-sbc")) {
/* FIXME: we can return a fixed payload type once we
* are in PLAYING */
caps = gst_caps_new_simple ("application/x-rtp",
"media", G_TYPE_STRING, "audio",
"payload", GST_TYPE_INT_RANGE, 96, 127,
"encoding-name", G_TYPE_STRING, "SBC", NULL);
} else if (g_str_equal (format, "audio/mpeg")) {
caps = gst_caps_new_simple ("application/x-rtp",
"media", G_TYPE_STRING, "audio",
"payload", GST_TYPE_INT_RANGE, 96, 127,
"encoding-name", G_TYPE_STRING, "MP4A-LATM", NULL);
value = gst_structure_get_value (structure, "mpegversion");
if (!value || !G_VALUE_HOLDS_INT (value)) {
GST_ERROR_OBJECT (avdtpsrc, "Failed to get mpegversion");
gst_caps_unref (caps);
return NULL;
}
gst_caps_set_simple (caps, "mpegversion", G_TYPE_INT,
g_value_get_int (value), NULL);
value = gst_structure_get_value (structure, "channels");
if (!value || !G_VALUE_HOLDS_INT (value)) {
GST_ERROR_OBJECT (avdtpsrc, "Failed to get channels");
gst_caps_unref (caps);
return NULL;
}
gst_caps_set_simple (caps, "channels", G_TYPE_INT,
g_value_get_int (value), NULL);
value = gst_structure_get_value (structure, "base-profile");
if (!value || !G_VALUE_HOLDS_STRING (value)) {
GST_ERROR_OBJECT (avdtpsrc, "Failed to get base-profile");
gst_caps_unref (caps);
return NULL;
}
gst_caps_set_simple (caps, "base-profile", G_TYPE_STRING,
g_value_get_string (value), NULL);
} else {
GST_ERROR_OBJECT (avdtpsrc,
"Only SBC and MPEG-2/4 are supported at the moment");
}
value = gst_structure_get_value (structure, "rate");
if (!value || !G_VALUE_HOLDS_INT (value)) {
GST_ERROR_OBJECT (avdtpsrc, "Failed to get sample rate");
gst_caps_unref (caps);
return NULL;
}
rate = g_value_get_int (value);
gst_caps_set_simple (caps, "clock-rate", G_TYPE_INT, rate, NULL);
if (filter) {
ret = gst_caps_intersect_full (filter, caps, GST_CAPS_INTERSECT_FIRST);
gst_caps_unref (caps);
} else
ret = caps;
} else {
GST_DEBUG_OBJECT (avdtpsrc, "device not open, using template caps");
ret = GST_BASE_SRC_CLASS (parent_class)->get_caps (bsrc, filter);
}
return ret;
}
/* returns static descriptions and dynamic ones (such as video/x-raw-yuv),
* or NULL if caps aren't known at all */
static gchar *
format_info_get_desc (const FormatInfo * info, const GstCaps * caps)
{
const GstStructure *s;
g_assert (info != NULL);
if (info->desc != NULL)
return g_strdup (_(info->desc));
s = gst_caps_get_structure (caps, 0);
if (strcmp (info->type, "video/x-raw-yuv") == 0) {
const gchar *ret = NULL;
guint32 fourcc = 0;
gst_structure_get_fourcc (s, "format", &fourcc);
switch (fourcc) {
case GST_MAKE_FOURCC ('I', '4', '2', '0'):
ret = _("Uncompressed planar YUV 4:2:0");
break;
case GST_MAKE_FOURCC ('Y', 'V', '1', '2'):
ret = _("Uncompressed planar YVU 4:2:0");
break;
case GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'):
ret = _("Uncompressed packed YUV 4:2:2");
break;
case GST_MAKE_FOURCC ('Y', 'U', 'V', '9'):
ret = _("Uncompressed packed YUV 4:1:0");
break;
case GST_MAKE_FOURCC ('Y', 'V', 'U', '9'):
ret = _("Uncompressed packed YVU 4:1:0");
break;
case GST_MAKE_FOURCC ('Y', 'V', 'Y', 'U'):
case GST_MAKE_FOURCC ('U', 'Y', 'V', 'Y'):
ret = _("Uncompressed packed YUV 4:2:2");
break;
case GST_MAKE_FOURCC ('Y', '4', '1', 'P'):
ret = _("Uncompressed packed YUV 4:1:1");
break;
case GST_MAKE_FOURCC ('I', 'Y', 'U', '2'):
ret = _("Uncompressed packed YUV 4:4:4");
break;
case GST_MAKE_FOURCC ('Y', '4', '2', 'B'):
ret = _("Uncompressed planar YUV 4:2:2");
break;
case GST_MAKE_FOURCC ('Y', '4', '1', 'B'):
ret = _("Uncompressed planar YUV 4:1:1");
break;
case GST_MAKE_FOURCC ('Y', '8', '0', '0'):
ret = _("Uncompressed black and white Y-plane");
break;
default:
ret = _("Uncompressed YUV");
break;
}
return g_strdup (ret);
} else if (strcmp (info->type, "video/x-raw-rgb") == 0) {
const gchar *rgb_str;
gint depth = 0;
gst_structure_get_int (s, "depth", &depth);
rgb_str = gst_structure_has_field (s, "alpha_mask") ? "RGBA" : "RGB";
if (gst_structure_has_field (s, "paletted_data")) {
return g_strdup_printf (_("Uncompressed palettized %d-bit %s"), depth,
rgb_str);
} else {
return g_strdup_printf ("Uncompressed %d-bit %s", depth, rgb_str);
}
} else if (strcmp (info->type, "video/x-h263") == 0) {
const gchar *variant, *ret;
variant = gst_structure_get_string (s, "variant");
if (variant == NULL)
ret = "H.263";
else if (strcmp (variant, "itu") == 0)
ret = "ITU H.26n"; /* why not ITU H.263? (tpm) */
else if (strcmp (variant, "lead") == 0)
ret = "Lead H.263";
else if (strcmp (variant, "microsoft") == 0)
ret = "Microsoft H.263";
else if (strcmp (variant, "vdolive") == 0)
ret = "VDOLive";
else if (strcmp (variant, "vivo") == 0)
ret = "Vivo H.263";
else if (strcmp (variant, "xirlink") == 0)
ret = "Xirlink H.263";
else {
GST_WARNING ("Unknown H263 variant '%s'", variant);
ret = "H.263";
}
return g_strdup (ret);
} else if (strcmp (info->type, "video/x-h264") == 0) {
const gchar *variant, *ret;
variant = gst_structure_get_string (s, "variant");
if (variant == NULL)
ret = "H.264";
else if (strcmp (variant, "itu") == 0)
ret = "ITU H.264";
else if (strcmp (variant, "videosoft") == 0)
ret = "Videosoft H.264";
else if (strcmp (variant, "lead") == 0)
ret = "Lead H.264";
else {
GST_WARNING ("Unknown H264 variant '%s'", variant);
ret = "H.264";
}
return g_strdup (ret);
} else if (strcmp (info->type, "video/x-divx") == 0) {
gint ver = 0;
if (!gst_structure_get_int (s, "divxversion", &ver) || ver <= 2) {
GST_WARNING ("Unexpected DivX version in %" GST_PTR_FORMAT, caps);
return g_strdup ("DivX MPEG-4");
}
return g_strdup_printf (_("DivX MPEG-4 Version %d"), ver);
} else if (strcmp (info->type, "video/x-msmpeg") == 0) {
gint ver = 0;
if (!gst_structure_get_int (s, "msmpegversion", &ver) ||
ver < 40 || ver > 49) {
GST_WARNING ("Unexpected msmpegversion in %" GST_PTR_FORMAT, caps);
return g_strdup ("Microsoft MPEG-4 4.x");
}
return g_strdup_printf ("Microsoft MPEG-4 4.%d", ver % 10);
} else if (strcmp (info->type, "video/x-truemotion") == 0) {
gint ver = 0;
gst_structure_get_int (s, "trueversion", &ver);
switch (ver) {
case 1:
return g_strdup_printf ("Duck TrueMotion 1");
case 2:
return g_strdup_printf ("TrueMotion 2.0");
default:
GST_WARNING ("Unexpected trueversion in %" GST_PTR_FORMAT, caps);
break;
}
return g_strdup_printf ("TrueMotion");
} else if (strcmp (info->type, "video/x-xan") == 0) {
gint ver = 0;
if (!gst_structure_get_int (s, "wcversion", &ver) || ver < 1) {
GST_WARNING ("Unexpected wcversion in %" GST_PTR_FORMAT, caps);
return g_strdup ("Xan Wing Commander");
}
return g_strdup_printf ("Xan Wing Commander %u", ver);
} else if (strcmp (info->type, "video/x-indeo") == 0) {
gint ver = 0;
if (!gst_structure_get_int (s, "indeoversion", &ver) || ver < 2) {
GST_WARNING ("Unexpected indeoversion in %" GST_PTR_FORMAT, caps);
return g_strdup ("Intel Indeo");
}
return g_strdup_printf ("Intel Indeo %u", ver);
} else if (strcmp (info->type, "audio/x-wma") == 0) {
gint ver = 0;
gst_structure_get_int (s, "wmaversion", &ver);
switch (ver) {
case 1:
case 2:
case 3:
return g_strdup_printf ("Windows Media Audio %d", ver + 6);
default:
break;
}
GST_WARNING ("Unexpected wmaversion in %" GST_PTR_FORMAT, caps);
return g_strdup ("Windows Media Audio");
} else if (strcmp (info->type, "video/x-wmv") == 0) {
gint ver = 0;
gst_structure_get_int (s, "wmvversion", &ver);
switch (ver) {
case 1:
case 2:
case 3:
return g_strdup_printf ("Windows Media Video %d", ver + 6);
default:
break;
}
GST_WARNING ("Unexpected wmvversion in %" GST_PTR_FORMAT, caps);
return g_strdup ("Windows Media Video");
} else if (strcmp (info->type, "audio/x-mace") == 0) {
gint ver = 0;
gst_structure_get_int (s, "maceversion", &ver);
if (ver == 3 || ver == 6) {
return g_strdup_printf ("MACE-%d", ver);
} else {
GST_WARNING ("Unexpected maceversion in %" GST_PTR_FORMAT, caps);
return g_strdup ("MACE");
}
} else if (strcmp (info->type, "video/x-svq") == 0) {
gint ver = 0;
gst_structure_get_int (s, "svqversion", &ver);
if (ver == 1 || ver == 3) {
return g_strdup_printf ("Sorensen Video %d", ver);
} else {
GST_WARNING ("Unexpected svqversion in %" GST_PTR_FORMAT, caps);
return g_strdup ("Sorensen Video");
}
} else if (strcmp (info->type, "video/x-asus") == 0) {
gint ver = 0;
gst_structure_get_int (s, "asusversion", &ver);
if (ver == 1 || ver == 2) {
return g_strdup_printf ("Asus Video %d", ver);
} else {
GST_WARNING ("Unexpected asusversion in %" GST_PTR_FORMAT, caps);
return g_strdup ("Asus Video");
}
} else if (strcmp (info->type, "video/x-ati-vcr") == 0) {
gint ver = 0;
gst_structure_get_int (s, "vcrversion", &ver);
if (ver == 1 || ver == 2) {
return g_strdup_printf ("ATI VCR %d", ver);
} else {
GST_WARNING ("Unexpected acrversion in %" GST_PTR_FORMAT, caps);
return g_strdup ("ATI VCR");
}
} else if (strcmp (info->type, "audio/x-adpcm") == 0) {
const GValue *layout_val;
layout_val = gst_structure_get_value (s, "layout");
if (layout_val != NULL && G_VALUE_HOLDS_STRING (layout_val)) {
const gchar *layout;
if ((layout = g_value_get_string (layout_val))) {
gchar *layout_upper, *ret;
if (strcmp (layout, "swf") == 0)
return g_strdup ("Shockwave ADPCM");
if (strcmp (layout, "microsoft") == 0)
return g_strdup ("Microsoft ADPCM");
if (strcmp (layout, "quicktime") == 0)
return g_strdup ("Quicktime ADPCM");
if (strcmp (layout, "westwood") == 0)
return g_strdup ("Westwood ADPCM");
if (strcmp (layout, "yamaha") == 0)
return g_strdup ("Yamaha ADPCM");
/* FIXME: other layouts: sbpro2, sbpro3, sbpro4, ct, g726, ea,
* adx, xa, 4xm, smjpeg, dk4, dk3, dvi */
layout_upper = g_ascii_strup (layout, -1);
ret = g_strdup_printf ("%s ADPCM", layout_upper);
g_free (layout_upper);
return ret;
}
}
return g_strdup ("ADPCM");
} else if (strcmp (info->type, "audio/mpeg") == 0) {
gint ver = 0, layer = 0;
gst_structure_get_int (s, "mpegversion", &ver);
switch (ver) {
case 1:
gst_structure_get_int (s, "layer", &layer);
switch (layer) {
case 1:
case 2:
case 3:
return g_strdup_printf ("MPEG-1 Layer %d (MP%d)", layer, layer);
default:
break;
}
GST_WARNING ("Unexpected MPEG-1 layer in %" GST_PTR_FORMAT, caps);
return g_strdup ("MPEG-1 Audio");
case 4:
return g_strdup ("MPEG-4 AAC");
default:
break;
}
GST_WARNING ("Unexpected audio mpegversion in %" GST_PTR_FORMAT, caps);
return g_strdup ("MPEG Audio");
} else if (strcmp (info->type, "audio/x-pn-realaudio") == 0) {
gint ver = 0;
gst_structure_get_int (s, "raversion", &ver);
switch (ver) {
case 1:
return g_strdup ("RealAudio 14k4bps");
case 2:
return g_strdup ("RealAudio 28k8bps");
case 8:
return g_strdup ("RealAudio G2 (Cook)");
default:
break;
}
GST_WARNING ("Unexpected raversion in %" GST_PTR_FORMAT, caps);
return g_strdup ("RealAudio");
} else if (strcmp (info->type, "video/x-pn-realvideo") == 0) {
gint ver = 0;
gst_structure_get_int (s, "rmversion", &ver);
switch (ver) {
case 1:
return g_strdup ("RealVideo 1.0");
case 2:
return g_strdup ("RealVideo 2.0");
case 3:
return g_strdup ("RealVideo 3.0");
case 4:
return g_strdup ("RealVideo 4.0");
default:
break;
}
GST_WARNING ("Unexpected rmversion in %" GST_PTR_FORMAT, caps);
return g_strdup ("RealVideo");
} else if (strcmp (info->type, "video/mpeg") == 0) {
gboolean sysstream;
gint ver = 0;
if (!gst_structure_get_boolean (s, "systemstream", &sysstream) ||
!gst_structure_get_int (s, "mpegversion", &ver) || ver < 1 || ver > 4) {
GST_WARNING ("Missing fields in mpeg video caps %" GST_PTR_FORMAT, caps);
} else {
if (sysstream) {
return g_strdup_printf ("MPEG-%d System Stream", ver);
} else {
return g_strdup_printf ("MPEG-%d Video", ver);
}
}
return g_strdup ("MPEG Video");
} else if (strcmp (info->type, "audio/x-raw-int") == 0) {
gint bitdepth = 0;
/* 8-bit pcm might not have depth field (?) */
if (!gst_structure_get_int (s, "depth", &bitdepth))
gst_structure_get_int (s, "width", &bitdepth);
if (bitdepth != 0)
return g_strdup_printf (_("Raw %d-bit PCM audio"), bitdepth);
else
return g_strdup (_("Raw PCM audio"));
} else if (strcmp (info->type, "audio/x-raw-float") == 0) {
gint bitdepth = 0;
gst_structure_get_int (s, "width", &bitdepth);
if (bitdepth != 0)
return g_strdup_printf (_("Raw %d-bit floating-point audio"), bitdepth);
else
return g_strdup (_("Raw floating-point audio"));
}
return NULL;
}
static void
load_owner( const GncSqlBackend* be, GncSqlRow* row,
QofSetterFunc setter, gpointer pObject,
const GncSqlColumnTableEntry* table_row )
{
const GValue* val;
gchar* buf;
GncOwnerType type;
GncGUID guid;
QofBook* book;
GncOwner owner;
GncGUID* pGuid = NULL;
g_return_if_fail( be != NULL );
g_return_if_fail( row != NULL );
g_return_if_fail( pObject != NULL );
g_return_if_fail( table_row != NULL );
book = be->primary_book;
buf = g_strdup_printf( "%s_type", table_row->col_name );
val = gnc_sql_row_get_value_at_col_name( row, buf );
type = (GncOwnerType)gnc_sql_get_integer_value( val );
g_free( buf );
buf = g_strdup_printf( "%s_guid", table_row->col_name );
val = gnc_sql_row_get_value_at_col_name( row, buf );
g_free( buf );
if ( val != NULL && G_VALUE_HOLDS_STRING( val ) && g_value_get_string( val ) != NULL )
{
string_to_guid( g_value_get_string( val ), &guid );
pGuid = &guid;
}
switch ( type )
{
case GNC_OWNER_CUSTOMER:
{
GncCustomer *cust = NULL;
if ( pGuid != NULL )
{
cust = gncCustomerLookup( book, pGuid );
if ( cust == NULL )
{
cust = gncCustomerCreate( book );
gncCustomerSetGUID( cust, &guid );
}
}
gncOwnerInitCustomer( &owner, cust );
break;
}
case GNC_OWNER_JOB:
{
GncJob *job = NULL;
if ( pGuid != NULL )
{
job = gncJobLookup( book, pGuid );
if ( job == NULL )
{
job = gncJobCreate( book );
gncJobSetGUID( job, &guid );
}
}
gncOwnerInitJob( &owner, job );
break;
}
case GNC_OWNER_VENDOR:
{
GncVendor *vendor = NULL;
if ( pGuid != NULL )
{
vendor = gncVendorLookup( book, pGuid );
if ( vendor == NULL )
{
vendor = gncVendorCreate( book );
gncVendorSetGUID( vendor, &guid );
}
}
gncOwnerInitVendor( &owner, vendor );
break;
}
case GNC_OWNER_EMPLOYEE:
{
GncEmployee *employee = NULL;
if ( pGuid != NULL )
{
employee = gncEmployeeLookup( book, pGuid );
if ( employee == NULL )
{
employee = gncEmployeeCreate( book );
gncEmployeeSetGUID( employee, &guid );
}
}
gncOwnerInitEmployee( &owner, employee );
break;
}
default:
PWARN("Invalid owner type: %d\n", type );
}
if ( table_row->gobj_param_name != NULL )
{
g_object_set( pObject, table_row->gobj_param_name, &owner, NULL );
}
else
{
(*setter)( pObject, &owner );
}
}
std::string
get_property_with_node_name(
GParamSpec* pParamSpec, const std::string& strObjectName, const std::string& strNodeName)
{
std::string strResult;
// Name and type:
const std::string strName = g_param_spec_get_name(pParamSpec);
const std::string strTypeName = G_PARAM_SPEC_TYPE_NAME(pParamSpec);
const gchar* pchBlurb = g_param_spec_get_blurb(pParamSpec);
std::string strDocs = (pchBlurb) ? pchBlurb : "";
// Quick hack to get rid of nested double quotes:
std::replace(strDocs.begin(), strDocs.end(), '"', '\'');
strResult += "(" + strNodeName + " " + strName + "\n";
strResult += " (of-object \"" + strObjectName + "\")\n";
strResult += " (prop-type \"" + strTypeName + "\")\n";
strResult += " (docs \"" + strDocs + "\")\n";
// Flags:
GParamFlags flags = pParamSpec->flags;
bool bReadable = (flags & G_PARAM_READABLE) == G_PARAM_READABLE;
bool bWritable = (flags & G_PARAM_WRITABLE) == G_PARAM_WRITABLE;
bool bConstructOnly = (flags & G_PARAM_CONSTRUCT_ONLY) == G_PARAM_CONSTRUCT_ONLY;
bool bDeprecated = (flags & G_PARAM_DEPRECATED) == G_PARAM_DEPRECATED;
//#t and #f aren't documented, but I guess that it's correct based on the example in the .defs
// spec.
const std::string strTrue = "#t";
const std::string strFalse = "#f";
strResult += " (readable " + (bReadable ? strTrue : strFalse) + ")\n";
strResult += " (writable " + (bWritable ? strTrue : strFalse) + ")\n";
strResult += " (construct-only " + (bConstructOnly ? strTrue : strFalse) + ")\n";
if (bDeprecated)
strResult += " (deprecated #t)\n"; // Default: not deprecated
// Default value:
const GValue* defValue = g_param_spec_get_default_value(pParamSpec);
std::string defString;
bool defValueExists = false;
if (G_VALUE_HOLDS_STRING(defValue))
{
defValueExists = true;
const char* defCString = g_value_get_string(defValue);
if (defCString)
{
// Replace newlines with \n.
// A string default value can contain newline characters.
// gmmproc removes all newlines when it reads .defs files.
defString = std::regex_replace(defCString, std::regex("\n"), "\\n");
}
else
defString = ""; // A NULL string pointer becomes an empty string.
}
else if (G_VALUE_HOLDS_FLOAT(defValue) || G_VALUE_HOLDS_DOUBLE(defValue))
{
// g_value_transform() can transform a floating point value to a terrible
// string, especially if the value is huge.
defValueExists = true;
const double defDouble = G_VALUE_HOLDS_FLOAT(defValue) ?
g_value_get_float(defValue) : g_value_get_double(defValue);
std::ostringstream defStringStream;
defStringStream << defDouble;
defString = defStringStream.str();
}
else
{
GValue defStringValue = G_VALUE_INIT;
g_value_init(&defStringValue, G_TYPE_STRING);
if (g_value_transform(defValue, &defStringValue))
{
const char* defCString = g_value_get_string(&defStringValue);
if (defCString)
{
defValueExists = true;
defString = defCString;
}
}
g_value_unset(&defStringValue);
}
if (defValueExists)
strResult += " (default-value \"" + defString + "\")\n";
strResult += ")\n\n"; // close (strNodeName
return strResult;
}
GValueArray *
gimp_procedure_execute (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
GValueArray *args,
GError **error)
{
GValueArray *return_vals;
GError *pdb_error = NULL;
g_return_val_if_fail (GIMP_IS_PROCEDURE (procedure), NULL);
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress), NULL);
g_return_val_if_fail (args != NULL, NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
if (! gimp_procedure_validate_args (procedure,
procedure->args, procedure->num_args,
args, FALSE, &pdb_error))
{
return_vals = gimp_procedure_get_return_values (procedure, FALSE,
pdb_error);
g_propagate_error (error, pdb_error);
return return_vals;
}
if (GIMP_IS_PDB_CONTEXT (context))
context = g_object_ref (context);
else
context = gimp_pdb_context_new (gimp, context, TRUE);
/* call the procedure */
return_vals = GIMP_PROCEDURE_GET_CLASS (procedure)->execute (procedure,
gimp,
context,
progress,
args,
error);
g_object_unref (context);
if (return_vals)
{
switch (g_value_get_enum (&return_vals->values[0]))
{
case GIMP_PDB_CALLING_ERROR:
case GIMP_PDB_EXECUTION_ERROR:
/* If the error has not already been set, construct one
* from the error message that is optionally passed with
* the return values.
*/
if (error && *error == NULL)
{
if (return_vals->n_values > 1 &&
G_VALUE_HOLDS_STRING (&return_vals->values[1]))
{
g_set_error_literal (error, GIMP_PDB_ERROR, GIMP_PDB_FAILED,
g_value_get_string (&return_vals->values[1]));
}
}
break;
default:
break;
}
}
else
{
g_warning ("%s: no return values, shouldn't happen", G_STRFUNC);
pdb_error = g_error_new (GIMP_PDB_ERROR, GIMP_PDB_INVALID_RETURN_VALUE,
_("Procedure '%s' returned no return values"),
gimp_object_get_name (procedure));
return_vals = gimp_procedure_get_return_values (procedure, FALSE,
pdb_error);
if (error && *error == NULL)
g_propagate_error (error, pdb_error);
else
g_error_free (pdb_error);
}
return return_vals;
}
/**
* g_strdup_value_contents:
* @value: #GValue which contents are to be described.
*
* Return a newly allocated string, which describes the contents of a
* #GValue. The main purpose of this function is to describe #GValue
* contents for debugging output, the way in which the contents are
* described may change between different GLib versions.
*
* Returns: Newly allocated string.
*/
gchar*
g_strdup_value_contents (const GValue *value)
{
const gchar *src;
gchar *contents;
g_return_val_if_fail (G_IS_VALUE (value), NULL);
if (G_VALUE_HOLDS_STRING (value))
{
src = g_value_get_string (value);
if (!src)
contents = g_strdup ("NULL");
else
{
gchar *s = g_strescape (src, NULL);
contents = g_strdup_printf ("\"%s\"", s);
g_free (s);
}
}
else if (g_value_type_transformable (G_VALUE_TYPE (value), G_TYPE_STRING))
{
GValue tmp_value = { 0, };
gchar *s;
g_value_init (&tmp_value, G_TYPE_STRING);
g_value_transform (value, &tmp_value);
s = g_strescape (g_value_get_string (&tmp_value), NULL);
g_value_unset (&tmp_value);
if (G_VALUE_HOLDS_ENUM (value) || G_VALUE_HOLDS_FLAGS (value))
contents = g_strdup_printf ("((%s) %s)",
g_type_name (G_VALUE_TYPE (value)),
s);
else
contents = g_strdup (s ? s : "NULL");
g_free (s);
}
else if (g_value_fits_pointer (value))
{
gpointer p = g_value_peek_pointer (value);
if (!p)
contents = g_strdup ("NULL");
else if (G_VALUE_HOLDS_OBJECT (value))
contents = g_strdup_printf ("((%s*) %p)", G_OBJECT_TYPE_NAME (p), p);
else if (G_VALUE_HOLDS_PARAM (value))
contents = g_strdup_printf ("((%s*) %p)", G_PARAM_SPEC_TYPE_NAME (p), p);
else if (G_VALUE_HOLDS (value, G_TYPE_STRV))
{
GStrv strv = g_value_get_boxed (value);
GString *tmp = g_string_new ("[");
while (*strv != NULL)
{
gchar *escaped = g_strescape (*strv, NULL);
g_string_append_printf (tmp, "\"%s\"", escaped);
g_free (escaped);
if (*++strv != NULL)
g_string_append (tmp, ", ");
}
g_string_append (tmp, "]");
contents = g_string_free (tmp, FALSE);
}
else if (G_VALUE_HOLDS_BOXED (value))
contents = g_strdup_printf ("((%s*) %p)", g_type_name (G_VALUE_TYPE (value)), p);
else if (G_VALUE_HOLDS_POINTER (value))
contents = g_strdup_printf ("((gpointer) %p)", p);
else
contents = g_strdup ("???");
}
else
contents = g_strdup ("???");
return contents;
}
static G_CONST_RETURN gchar*
gail_item_get_name (AtkObject *obj)
{
G_CONST_RETURN gchar* name;
g_return_val_if_fail (GAIL_IS_ITEM (obj), NULL);
name = ATK_OBJECT_CLASS (parent_class)->get_name (obj);
if (name == NULL)
{
/*
* Get the label child
*/
GtkWidget *widget;
GtkWidget *label;
widget = GTK_ACCESSIBLE (obj)->widget;
if (widget == NULL)
/*
* State is defunct
*/
return NULL;
label = get_label_from_container (widget);
if (GTK_IS_LABEL (label))
return gtk_label_get_text (GTK_LABEL(label));
/*
* If we have a menu item in a menu attached to a GtkOptionMenu
* the label of the selected item is detached from the menu item
*/
else if (GTK_IS_MENU_ITEM (widget))
{
GtkWidget *parent;
GtkWidget *attach;
GList *list;
AtkObject *parent_obj;
gint index;
parent = gtk_widget_get_parent (widget);
if (GTK_IS_MENU (parent))
{
attach = gtk_menu_get_attach_widget (GTK_MENU (parent));
if (GTK_IS_OPTION_MENU (attach))
{
label = get_label_from_container (attach);
if (GTK_IS_LABEL (label))
return gtk_label_get_text (GTK_LABEL(label));
}
list = gtk_container_get_children (GTK_CONTAINER (parent));
index = g_list_index (list, widget);
if (index < 0 || index > g_list_length (list))
{
g_list_free (list);
return NULL;
}
g_list_free (list);
parent_obj = atk_object_get_parent (gtk_widget_get_accessible (parent));
if (GTK_IS_ACCESSIBLE (parent_obj))
{
parent = GTK_ACCESSIBLE (parent_obj)->widget;
if (GTK_IS_COMBO_BOX (parent))
{
GtkTreeModel *model;
GtkTreeIter iter;
GailItem *item;
gint n_columns, i;
model = gtk_combo_box_get_model (GTK_COMBO_BOX (parent));
item = GAIL_ITEM (obj);
if (gtk_tree_model_iter_nth_child (model, &iter, NULL, index))
{
n_columns = gtk_tree_model_get_n_columns (model);
for (i = 0; i < n_columns; i++)
{
GValue value = { 0, };
gtk_tree_model_get_value (model, &iter, i, &value);
if (G_VALUE_HOLDS_STRING (&value))
{
g_free (item->text);
item->text = (gchar *) g_value_dup_string (&value);
g_value_unset (&value);
break;
}
}
}
name = item->text;
}
}
}
}
}
return name;
}
static void
_set_from_data_model (MidgardDBObject *self, GdaDataModel *model, gint row, guint column_id)
{
g_return_if_fail (self != NULL);
g_return_if_fail (model != NULL);
g_return_if_fail (row > -1);
GError *error = NULL;
const GValue *value;
MidgardWorkspace *ws = MIDGARD_WORKSPACE (self);
/* guid */
value = gda_data_model_get_value_at (model, MGD_WORKSPACE_FIELD_IDX_GUID, row, &error);
if (!value) {
g_warning ("Failed to get workspace guid field: %s", error && error->message ? error->message : "Unknown reason");
if (error)
g_clear_error (&error);
} else {
g_free ((gchar *)MGD_OBJECT_GUID (ws));
if (G_VALUE_HOLDS_STRING (value))
MGD_OBJECT_GUID (ws) = g_value_dup_string (value);
else {
GValue strval = {0, };
g_value_init (&strval, G_TYPE_STRING);
g_value_transform (value, &strval);
MGD_OBJECT_GUID (ws) = g_value_dup_string (&strval);
g_value_unset (&strval);
}
}
if (error) g_clear_error (&error);
/* id */
value = gda_data_model_get_value_at (model, MGD_WORKSPACE_FIELD_IDX_ID, row, &error);
if (!value) {
g_warning ("Failed to get workspace id field: %s", error && error->message ? error->message : "Unknown reason");
if (error)
g_clear_error (&error);
} else {
if (G_VALUE_HOLDS_UINT (value))
ws->priv->id = g_value_get_uint (value);
else {
GValue intval = {0, };
g_value_init (&intval, G_TYPE_UINT);
g_value_transform (value, &intval);
ws->priv->id = (guint) g_value_get_uint (&intval);
g_value_unset (&intval);
}
}
if (error) g_clear_error (&error);
/* up */
value = gda_data_model_get_value_at (model, MGD_WORKSPACE_FIELD_IDX_UP, row, &error);
if (!value) {
g_warning ("Failed to get workspace up field: %s", error && error->message ? error->message : "Unknown reason");
if (error)
g_clear_error (&error);
} else {
if (G_VALUE_HOLDS_UINT (value))
ws->priv->up_id = g_value_get_uint (value);
else
ws->priv->up_id = (guint) g_value_get_int (value);
}
if (error) g_clear_error (&error);
/* name */
value = gda_data_model_get_value_at (model, MGD_WORKSPACE_FIELD_IDX_NAME, row, &error);
if (!value) {
g_warning ("Failed to get workspace name field: %s", error && error->message ? error->message : "Unknown reason");
if (error)
g_clear_error (&error);
} else {
g_free (ws->priv->name);
ws->priv->name = g_value_dup_string (value);
}
if (error) g_clear_error (&error);
return;
}
static void __mqb_set_metadata(MidgardMetadata *mdata, GdaDataModel *model, gint i)
{
guint col = 0;
const GValue *gvalue;
GValue mt = {0, };
/* creator */
gvalue = midgard_data_model_get_value_at(model, ++col, i);
midgard_core_metadata_set_creator (mdata, gvalue);
/* created */
gvalue = midgard_data_model_get_value_at(model, ++col, i);
_SET_METADATA_TIMESTAMP(created);
/* revisor */
gvalue = midgard_data_model_get_value_at(model, ++col, i);
if(G_VALUE_HOLDS_STRING (gvalue))
midgard_core_metadata_set_revisor (mdata, gvalue);
/* revised */
gvalue = midgard_data_model_get_value_at(model, ++col, i);
_SET_METADATA_TIMESTAMP(revised);
/* revision */
gvalue = midgard_data_model_get_value_at(model, ++col, i);
mdata->priv->revision = 0;
_SET_METADATA_UINT(mdata->priv->revision, gvalue);
/* locker */
gvalue = midgard_data_model_get_value_at(model, ++col, i);
if(G_VALUE_HOLDS_STRING (gvalue))
midgard_core_metadata_set_locker (mdata, gvalue);
/* locked */
gvalue = midgard_data_model_get_value_at(model, ++col, i);
_SET_METADATA_TIMESTAMP(locked);
/* approver */
gvalue = midgard_data_model_get_value_at(model, ++col, i);
if(G_VALUE_HOLDS_STRING (gvalue))
midgard_core_metadata_set_approver (mdata, gvalue);
/* approved */
gvalue = midgard_data_model_get_value_at(model, ++col, i);
_SET_METADATA_TIMESTAMP(approved);
/* authors */
gvalue = midgard_data_model_get_value_at(model, ++col, i);
if(G_VALUE_HOLDS_STRING (gvalue))
midgard_core_metadata_set_authors (mdata, gvalue);
/* owner */
gvalue = midgard_data_model_get_value_at(model, ++col, i);
if(G_VALUE_HOLDS_STRING (gvalue))
midgard_core_metadata_set_owner (mdata, gvalue);
/* schedule_start */
gvalue = midgard_data_model_get_value_at(model, ++col, i);
_SET_METADATA_TIMESTAMP (schedule_start);
/* schedule_end */
gvalue = midgard_data_model_get_value_at(model, ++col, i);
_SET_METADATA_TIMESTAMP (schedule_end);
/* hidden */
gvalue = midgard_data_model_get_value_at(model, ++col, i);
mdata->priv->hidden = FALSE;
if(G_VALUE_HOLDS_BOOLEAN(gvalue)) {
mdata->priv->hidden =
g_value_get_boolean(gvalue);
}
/* nav_noentry */
gvalue = midgard_data_model_get_value_at(model, ++col, i);
mdata->priv->nav_noentry = FALSE;
if(G_VALUE_HOLDS_BOOLEAN(gvalue)) {
mdata->priv->nav_noentry =
g_value_get_boolean(gvalue);
}
/* size */
gvalue = midgard_data_model_get_value_at(model, ++col, i);
mdata->priv->size = 0;
if(G_VALUE_HOLDS_INT(gvalue)) {
mdata->priv->size = (guint) g_value_get_int(gvalue);
}
/* published */
gvalue = midgard_data_model_get_value_at(model, ++col, i);
_SET_METADATA_TIMESTAMP (published);
/* exported */
gvalue = midgard_data_model_get_value_at(model, ++col, i);
_SET_METADATA_TIMESTAMP(exported);
/* imported */
gvalue = midgard_data_model_get_value_at(model, ++col, i);
_SET_METADATA_TIMESTAMP(imported);
/* deleted */
gvalue = midgard_data_model_get_value_at(model, ++col, i);
mdata->priv->deleted = FALSE;
if(G_VALUE_HOLDS_BOOLEAN(gvalue)) {
mdata->priv->deleted =
g_value_get_boolean(gvalue);
}
/* score */
gvalue = midgard_data_model_get_value_at(model, ++col, i);
mdata->priv->score = 0;
if(G_VALUE_HOLDS_INT(gvalue)) {
mdata->priv->score =
g_value_get_int(gvalue);
}
/* islocked */
gvalue = midgard_data_model_get_value_at(model, ++col, i);
if(G_VALUE_HOLDS_BOOLEAN(gvalue)) {
mdata->priv->is_locked =
g_value_get_boolean(gvalue);
}
/* isapproved */
gvalue = midgard_data_model_get_value_at(model, ++col, i);
if(G_VALUE_HOLDS_BOOLEAN(gvalue)) {
mdata->priv->is_approved =
g_value_get_boolean(gvalue);
}
return;
}
static void
check_pad_template (GstPadTemplate * tmpl)
{
const GValue *list_val, *fmt_val;
GstStructure *s;
gboolean *formats_supported;
GstCaps *caps;
guint i, num_formats;
num_formats = get_num_formats ();
formats_supported = g_new0 (gboolean, num_formats);
caps = gst_pad_template_get_caps (tmpl);
/* If this fails, we need to update this unit test */
fail_unless_equals_int (gst_caps_get_size (caps), 2);
/* Remove the ANY caps features structure */
caps = gst_caps_truncate (caps);
s = gst_caps_get_structure (caps, 0);
fail_unless (gst_structure_has_name (s, "video/x-raw"));
list_val = gst_structure_get_value (s, "format");
fail_unless (list_val != NULL);
/* If this fails, we need to update this unit test */
fail_unless (GST_VALUE_HOLDS_LIST (list_val));
for (i = 0; i < gst_value_list_get_size (list_val); ++i) {
GstVideoFormat fmt;
const gchar *fmt_str;
fmt_val = gst_value_list_get_value (list_val, i);
fail_unless (G_VALUE_HOLDS_STRING (fmt_val));
fmt_str = g_value_get_string (fmt_val);
GST_LOG ("format string: '%s'", fmt_str);
fmt = gst_video_format_from_string (fmt_str);
if (fmt == GST_VIDEO_FORMAT_UNKNOWN)
g_error ("Unknown raw format '%s' in pad template caps", fmt_str);
formats_supported[(guint) fmt] = TRUE;
}
gst_caps_unref (caps);
for (i = 2; i < num_formats; ++i) {
if (!formats_supported[i]) {
const gchar *fmt_str = gst_video_format_to_string ((GstVideoFormat) i);
switch (i) {
case GST_VIDEO_FORMAT_v210:
case GST_VIDEO_FORMAT_v216:
case GST_VIDEO_FORMAT_NV12:
case GST_VIDEO_FORMAT_NV16:
case GST_VIDEO_FORMAT_NV21:
case GST_VIDEO_FORMAT_NV24:
case GST_VIDEO_FORMAT_UYVP:
case GST_VIDEO_FORMAT_A420:
case GST_VIDEO_FORMAT_YUV9:
case GST_VIDEO_FORMAT_YVU9:
case GST_VIDEO_FORMAT_IYU1:
case GST_VIDEO_FORMAT_r210:{
static gboolean shown_fixme[100] = { FALSE, };
if (!shown_fixme[i]) {
GST_FIXME ("FIXME: add %s support to videoscale", fmt_str);
shown_fixme[i] = TRUE;
}
break;
}
case GST_VIDEO_FORMAT_BGR16:
case GST_VIDEO_FORMAT_BGR15:
case GST_VIDEO_FORMAT_RGB8P:
case GST_VIDEO_FORMAT_I420_10BE:
case GST_VIDEO_FORMAT_I420_10LE:
case GST_VIDEO_FORMAT_I422_10BE:
case GST_VIDEO_FORMAT_I422_10LE:
case GST_VIDEO_FORMAT_Y444_10BE:
case GST_VIDEO_FORMAT_Y444_10LE:
case GST_VIDEO_FORMAT_GBR:
case GST_VIDEO_FORMAT_GBR_10BE:
case GST_VIDEO_FORMAT_GBR_10LE:
GST_LOG ("Ignoring lack of support for format %s", fmt_str);
break;
default:
g_error ("videoscale doesn't support format '%s'", fmt_str);
break;
}
}
}
g_free (formats_supported);
}
void LayoutTestController::overridePreference(JSStringRef key, JSStringRef value)
{
GOwnPtr<gchar> originalName(JSStringCopyUTF8CString(key));
GOwnPtr<gchar> valueAsString(JSStringCopyUTF8CString(value));
WebKitWebView* view = webkit_web_frame_get_web_view(mainFrame);
ASSERT(view);
// This transformation could be handled by a hash table (and it once was), but
// having it prominent, makes it easier for people from other ports to keep the
// list up to date.
const gchar* propertyName = 0;
if (g_str_equal(originalName.get(), "WebKitJavaScriptEnabled"))
propertyName = "enable-scripts";
else if (g_str_equal(originalName.get(), "WebKitDefaultFontSize"))
propertyName = "default-font-size";
else if (g_str_equal(originalName.get(), "WebKitEnableCaretBrowsing"))
propertyName = "enable-caret-browsing";
else if (g_str_equal(originalName.get(), "WebKitUsesPageCachePreferenceKey"))
propertyName = "enable-page-cache";
else if (g_str_equal(originalName.get(), "WebKitPluginsEnabled"))
propertyName = "enable-plugins";
else if (g_str_equal(originalName.get(), "WebKitHyperlinkAuditingEnabled"))
propertyName = "enable-hyperlink-auditing";
else if (g_str_equal(originalName.get(), "WebKitWebGLEnabled"))
propertyName = "enable-webgl";
else if (g_str_equal(originalName.get(), "WebKitWebAudioEnabled"))
propertyName = "enable-webaudio";
else if (g_str_equal(originalName.get(), "WebKitTabToLinksPreferenceKey")) {
DumpRenderTreeSupportGtk::setLinksIncludedInFocusChain(booleanFromValue(valueAsString.get()));
return;
} else if (g_str_equal(originalName.get(), "WebKitHixie76WebSocketProtocolEnabled")) {
DumpRenderTreeSupportGtk::setHixie76WebSocketProtocolEnabled(webkit_web_frame_get_web_view(mainFrame), booleanFromValue(valueAsString.get()));
return;
} else if (g_str_equal(originalName.get(), "WebKitPageCacheSupportsPluginsPreferenceKey")) {
DumpRenderTreeSupportGtk::setPageCacheSupportsPlugins(webkit_web_frame_get_web_view(mainFrame), booleanFromValue(valueAsString.get()));
return;
} else {
fprintf(stderr, "LayoutTestController::overridePreference tried to override "
"unknown preference '%s'.\n", originalName.get());
return;
}
WebKitWebSettings* settings = webkit_web_view_get_settings(view);
GParamSpec* pspec = g_object_class_find_property(G_OBJECT_CLASS(
WEBKIT_WEB_SETTINGS_GET_CLASS(settings)), propertyName);
GValue currentPropertyValue = { 0, { { 0 } } };
g_value_init(¤tPropertyValue, pspec->value_type);
if (G_VALUE_HOLDS_STRING(¤tPropertyValue))
g_object_set(settings, propertyName, valueAsString.get(), NULL);
else if (G_VALUE_HOLDS_BOOLEAN(¤tPropertyValue))
g_object_set(G_OBJECT(settings), propertyName, booleanFromValue(valueAsString.get()), NULL);
else if (G_VALUE_HOLDS_INT(¤tPropertyValue))
g_object_set(G_OBJECT(settings), propertyName, atoi(valueAsString.get()), NULL);
else if (G_VALUE_HOLDS_FLOAT(¤tPropertyValue)) {
gfloat newValue = g_ascii_strtod(valueAsString.get(), 0);
g_object_set(G_OBJECT(settings), propertyName, newValue, NULL);
} else
fprintf(stderr, "LayoutTestController::overridePreference failed to override "
"preference '%s'.\n", originalName.get());
}
void _camera_import_dialog_run(_camera_import_dialog_t *data)
{
gtk_widget_show_all(data->dialog);
// Populate store
// Setup a listener for previews of all files on camera
// then initiate fetch of all previews from camera
if(data->params->camera!=NULL)
{
/* setup a camctl listener */
dt_camctl_listener_t listener= {0};
listener.data=data;
listener.control_status=_control_status;
listener.camera_storage_image_filename=_camera_storage_image_filename;
dt_job_t job;
dt_camera_get_previews_job_init(&job,data->params->camera, &listener, CAMCTL_IMAGE_PREVIEW_DATA);
dt_control_job_set_state_callback(&job,_preview_job_state_changed,data);
dt_control_add_job(darktable.control, &job);
}
else
return;
// Lets run dialog
gtk_label_set_text(GTK_LABEL(data->import.info),_("select the images from the list below that you want to import into a new filmroll"));
gboolean all_good=FALSE;
g_signal_connect(G_OBJECT(data->dialog),"delete-event",G_CALLBACK(_dialog_close),data);
while(!all_good)
{
gint result = gtk_dialog_run (GTK_DIALOG (data->dialog));
if( result == GTK_RESPONSE_ACCEPT)
{
GtkTreeIter iter;
all_good=TRUE;
GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(gtk_bin_get_child(GTK_BIN(data->import.treeview))));
// Now build up result from store into GList **result
if(data->params->result)
g_list_free(data->params->result);
data->params->result=NULL;
GtkTreeModel *model=GTK_TREE_MODEL(data->store);
GList *sp= gtk_tree_selection_get_selected_rows(selection,&model);
if( sp )
{
do
{
GValue value = { 0, };
gtk_tree_model_get_iter(GTK_TREE_MODEL (data->store),&iter,(GtkTreePath*)sp->data);
gtk_tree_model_get_value(GTK_TREE_MODEL (data->store),&iter,1,&value);
if (G_VALUE_HOLDS_STRING (&value))
data->params->result = g_list_append(data->params->result,g_strdup(g_value_get_string(&value)) );
}
while( (sp=g_list_next(sp)) );
}
/* get jobcode from import dialog */
data->params->jobcode = data->import.jobname->value;
/* get time override if used */
data->params->time_override = 0;
if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data->settings.general.date_override)))
data->params->time_override = parse_date_time(gtk_entry_get_text(GTK_ENTRY(data->settings.general.date_entry)));
if( data->params->jobcode == NULL || data->params->jobcode[0] == '\0' )
{
g_free(data->params->jobcode); // might just be a string of length 0
data->params->jobcode = dt_conf_get_string("plugins/capture/camera/import/jobcode");
}
else if( gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data->settings.general.date_override)) && data->params->time_override == 0)
{
GtkWidget *dialog=gtk_message_dialog_new(NULL,GTK_DIALOG_DESTROY_WITH_PARENT,GTK_MESSAGE_ERROR,GTK_BUTTONS_OK,_("please use YYYY-MM-DD format for date override"));
g_signal_connect_swapped (dialog, "response",G_CALLBACK (gtk_widget_destroy),dialog);
gtk_dialog_run (GTK_DIALOG (dialog));
all_good=FALSE;
}
}
else
{
data->params->result=NULL;
all_good=TRUE;
}
}
// Destroy and quit
gtk_widget_destroy (data->dialog);
}
static void
modem_get_all_cb (DBusGProxy *proxy, DBusGProxyCall *call, gpointer user_data)
{
NmaBtDevice *self = NMA_BT_DEVICE (user_data);
NmaBtDevicePrivate *priv = NMA_BT_DEVICE_GET_PRIVATE (self);
const char *path;
GHashTable *properties = NULL;
GError *error = NULL;
GValue *value;
NMDeviceType devtype = NM_DEVICE_TYPE_UNKNOWN;
path = dbus_g_proxy_get_path (proxy);
g_message ("%s: (%s) processing GetAll reply", __func__, path);
if (!dbus_g_proxy_end_call (proxy, call, &error,
DBUS_TYPE_G_MAP_OF_VARIANT, &properties,
G_TYPE_INVALID)) {
g_warning ("%s: (%s) Error getting modem properties: (%d) %s",
__func__,
path,
error ? error->code : -1,
(error && error->message) ? error->message : "(unknown)");
g_error_free (error);
goto out;
}
/* check whether this is the device we care about */
value = g_hash_table_lookup (properties, "Device");
if (value && G_VALUE_HOLDS_STRING (value) && g_value_get_string (value)) {
char *iface_basename = g_path_get_basename (priv->rfcomm_iface);
const char *modem_iface = g_value_get_string (value);
if (strcmp (iface_basename, modem_iface) == 0) {
/* yay, found it! */
value = g_hash_table_lookup (properties, "Type");
if (value && G_VALUE_HOLDS_UINT (value)) {
switch (g_value_get_uint (value)) {
case 1:
devtype = NM_DEVICE_MODEM_CAPABILITY_GSM_UMTS;
break;
case 2:
devtype = NM_DEVICE_MODEM_CAPABILITY_CDMA_EVDO;
break;
default:
g_message ("%s: (%s) unknown modem type", __func__, path);
break;
}
}
} else {
g_message ("%s: (%s) (%s) not the modem we're looking for (%s)",
__func__, path, modem_iface, iface_basename);
}
g_free (iface_basename);
} else
g_message ("%s: (%s) modem had no 'Device' property", __func__, path);
g_hash_table_unref (properties);
/* Launch wizard! */
start_wizard (self, path, devtype);
out:
g_message ("%s: finished", __func__);
}
void
getSongInfos(void)
{
GHashTable *data_list = NULL;
GValue *value;
const gchar *data;
if(dbus_g_proxy_call (dbus_proxy_shell, "getSongProperties", NULL,
G_TYPE_STRING, musicData.playing_uri,
G_TYPE_INVALID,
dbus_g_type_get_map("GHashTable",G_TYPE_STRING, G_TYPE_VALUE),
&data_list,
G_TYPE_INVALID)) {
g_free (musicData.playing_artist);
value = (GValue *) g_hash_table_lookup(data_list, "artist");
if (value != NULL && G_VALUE_HOLDS_STRING(value))
musicData.playing_artist = g_strdup (g_value_get_string(value));
else
musicData.playing_artist = NULL;
cid_message (" playing_artist <- %s\n", musicData.playing_artist);
g_free (musicData.playing_album);
value = (GValue *) g_hash_table_lookup(data_list, "album");
if (value != NULL && G_VALUE_HOLDS_STRING(value))
musicData.playing_album = g_strdup (g_value_get_string(value));
else
musicData.playing_album = NULL;
cid_message (" playing_album <- %s\n", musicData.playing_album);
g_free (musicData.playing_title);
value = (GValue *) g_hash_table_lookup(data_list, "title");
if (value != NULL && G_VALUE_HOLDS_STRING(value))
musicData.playing_title = g_strdup (g_value_get_string(value));
else
musicData.playing_title = NULL;
cid_message (" playing_title <- %s\n", musicData.playing_title);
value = (GValue *) g_hash_table_lookup(data_list, "track-number");
if (value != NULL && G_VALUE_HOLDS_UINT(value))
musicData.playing_track = g_value_get_uint(value);
else
musicData.playing_track = 0;
cid_message (" playing_track <- %d\n", musicData.playing_track);
value = (GValue *) g_hash_table_lookup(data_list, "duration");
if (value != NULL && G_VALUE_HOLDS_UINT(value))
musicData.playing_duration = g_value_get_uint(value);
else
musicData.playing_duration = 0;
cid_message (" playing_duration <- %ds\n", musicData.playing_duration);
value = (GValue *) g_hash_table_lookup(data_list, "rb:coverArt-uri");
g_free (musicData.playing_cover);
if (value != NULL && G_VALUE_HOLDS_STRING(value))
{
GError *erreur = NULL;
const gchar *cString = g_value_get_string(value);
if (cString != NULL && strncmp (cString, "file://", 7) == 0)
{
musicData.playing_cover = g_filename_from_uri (cString, NULL, &erreur);
if (erreur != NULL)
{
cid_warning ("Attention : %s\n", erreur->message);
g_error_free (erreur);
}
}
else
{
musicData.playing_cover = g_strdup (cString);
}
}
else
{
CidDataTable *p_tabFiles = cid_create_datatable(G_TYPE_STRING,"cover","album","albumart",
".folder",".cover","folder","Cover","Folder",
G_TYPE_INVALID);
gchar *cSongPath = g_filename_from_uri (musicData.playing_uri, NULL, NULL); // on teste d'abord dans le repertoire de la chanson.
if (cSongPath != NULL)
{
gchar *cSongDir = g_path_get_dirname (cSongPath);
g_free (cSongPath);
musicData.playing_cover = g_strdup_printf ("%s/%s - %s.jpg", cSongDir, musicData.playing_artist, musicData.playing_album);
cid_debug (" test de %s\n", musicData.playing_cover);
BEGIN_FOREACH_DT(p_tabFiles)
if (g_file_test (musicData.playing_cover, G_FILE_TEST_EXISTS))
break;
g_free (musicData.playing_cover);
musicData.playing_cover = g_strdup_printf ("%s/%s.jpg", cSongDir, p_temp->content->string);
cid_debug (" test de %s\n", musicData.playing_cover);
END_FOREACH_DT
if (! g_file_test (musicData.playing_cover, G_FILE_TEST_EXISTS))
{
cid_debug (" test de %s (.gnome2)\n", musicData.playing_cover);
g_free (musicData.playing_cover);
musicData.playing_cover = g_strdup_printf("%s/.gnome2/rhythmbox/covers/%s - %s.jpg", g_getenv("HOME"),musicData.playing_artist, musicData.playing_album);
}
if (! g_file_test (musicData.playing_cover, G_FILE_TEST_EXISTS))
{
cid_debug (" test de %s (.cache)\n", musicData.playing_cover);
g_free (musicData.playing_cover);
musicData.playing_cover = g_strdup_printf("%s/.cache/rhythmbox/covers/%s - %s.jpg", g_getenv("HOME"),musicData.playing_artist, musicData.playing_album);
}
g_free (cSongDir);
if (! g_file_test (musicData.playing_cover, G_FILE_TEST_EXISTS))
{
cid->runtime->iCheckIter = 0;
if (musicData.iSidCheckCover == 0 && cid->config->iPlayer != PLAYER_NONE)
{
cid_debug ("l'image n'existe pas encore => on boucle.\n");
musicData.iSidCheckCover = g_timeout_add (1 SECONDES, (GSourceFunc) _check_cover_is_present, (gpointer) NULL);
}
}
}
}
static gboolean
compare_record_property (DMAPRecord * record, const gchar * property_name,
const gchar * property_value)
{
GParamSpec *pspec;
GValue value = { 0, };
/* Note that this string belongs to value and will not be freed explicitely. */
const gchar *str_value;
gboolean accept;
pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (record),
property_name);
if (pspec == NULL)
// Can't find the property in this record, so don't accept it.
return FALSE;
// Get the property value as a GValue set to the type of this
// property.
g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (pspec));
g_object_get_property (G_OBJECT (record), property_name, &value);
if (G_VALUE_HOLDS_STRING (&value)) {
str_value = g_value_get_string (&value);
} else if (G_VALUE_HOLDS_BOOLEAN (&value)) {
g_debug ("Compare %s (boolean): %d %s", property_name, g_value_get_boolean (&value), property_value);
accept = (g_value_get_boolean (&value) &&
g_strcmp0 (property_value, "1") == 0);
g_value_unset (&value);
return accept;
} else if (g_value_type_transformable
(G_VALUE_TYPE (&value), G_TYPE_LONG)) {
// Prefer integer conversion.
GValue dest = { 0, };
g_value_init (&dest, G_TYPE_LONG);
if (!g_value_transform (&value, &dest)) {
g_warning
("Failed to convert value into long for property %s",
property_name);
g_value_unset (&value);
return FALSE;
}
g_debug ("Compare %s (long): %ld %s", property_name, g_value_get_long (&dest), property_value);
accept = (g_value_get_long (&dest) ==
strtol (property_value, NULL, 10));
g_value_unset (&value);
return accept;
} else if (g_value_type_transformable
(G_VALUE_TYPE (&value), G_TYPE_STRING)) {
// Use standard transform functions from GLib (note that these
// functions are unreliable and known cases should be handled
// above).
GValue dest;
g_value_init (&dest, G_TYPE_STRING);
if (!g_value_transform (&value, &dest)) {
g_warning
("Failed to convert value into string for property %s",
property_name);
g_value_unset (&value);
return FALSE;
}
str_value = g_value_dup_string (&dest);
g_value_reset (&value);
//Sets the string to value so that it will be freed later.
g_value_take_string (&value, (gchar *) str_value);
g_value_unset (&dest);
} else {
g_warning ("Attempt to compare unhandled type");
g_value_unset (&value);
return FALSE;
}
// Only arrive here if we are handling strings.
g_debug ("Compare %s (string): %s %s", property_name, str_value, property_value);
if (str_value != NULL && property_value != NULL &&
g_ascii_strcasecmp (str_value, property_value) == 0) {
accept = TRUE;
} else if (str_value == NULL && property_value == NULL) {
accept = TRUE;
} else {
accept = FALSE;
}
// This will destroy str_value since it belongs to value.
g_value_unset (&value);
return accept;
}
static void
modem_get_all_cb (DBusGProxy *proxy, DBusGProxyCall *call, gpointer user_data)
{
PluginInfo *info = user_data;
const char *path;
GHashTable *properties = NULL;
GError *error = NULL;
GValue *value;
BMDeviceType devtype = BM_DEVICE_TYPE_UNKNOWN;
path = dbus_g_proxy_get_path (proxy);
g_message ("%s: (%s) processing GetAll reply", __func__, path);
if (!dbus_g_proxy_end_call (proxy, call, &error,
DBUS_TYPE_G_MAP_OF_VARIANT, &properties,
G_TYPE_INVALID)) {
g_warning ("%s: (%s) Error getting modem properties: (%d) %s",
__func__,
path,
error ? error->code : -1,
(error && error->message) ? error->message : "(unknown)");
g_error_free (error);
goto out;
}
/* check whether this is the device we care about */
value = g_hash_table_lookup (properties, "Device");
if (value && G_VALUE_HOLDS_STRING (value) && g_value_get_string (value)) {
char *iface_basename = g_path_get_basename (info->rfcomm_iface);
const char *modem_iface = g_value_get_string (value);
if (!strcmp (iface_basename, modem_iface)) {
/* yay, found it! */
value = g_hash_table_lookup (properties, "Type");
if (value && G_VALUE_HOLDS_UINT (value)) {
switch (g_value_get_uint (value)) {
case 1:
devtype = BM_DEVICE_TYPE_GSM;
break;
case 2:
devtype = BM_DEVICE_TYPE_CDMA;
break;
default:
g_message ("%s: (%s) unknown modem type", __func__, path);
break;
}
}
} else {
g_message ("%s: (%s) (%s) not the modem we're looking for (%s)",
__func__, path, modem_iface, iface_basename);
}
g_free (iface_basename);
} else
g_message ("%s: (%s) modem had no 'Device' property", __func__, path);
g_hash_table_unref (properties);
if (devtype != BM_DEVICE_TYPE_UNKNOWN) {
GtkWidget *parent;
if (info->wizard) {
g_message ("%s: (%s) oops! not starting Wizard as one is already in progress", __func__, path);
goto out;
}
g_message ("%s: (%s) starting the mobile wizard", __func__, path);
g_source_remove (info->dun_timeout_id);
info->dun_timeout_id = 0;
parent = gtk_widget_get_toplevel (info->hbox);
#if GTK_CHECK_VERSION(2,18,0)
if (gtk_widget_is_toplevel (parent)) {
#else
if (GTK_WIDGET_TOPLEVEL (parent)) {
#endif
info->window_group = gtk_window_group_new ();
gtk_window_group_add_window (info->window_group, GTK_WINDOW (parent));
} else {
parent = NULL;
info->window_group = NULL;
}
/* Start the mobile wizard */
info->wizard = mobile_wizard_new (parent ? GTK_WINDOW (parent) : NULL,
info->window_group,
devtype,
FALSE,
wizard_done_cb,
info);
mobile_wizard_present (info->wizard);
}
out:
g_message ("%s: finished", __func__);
}
static void
modem_added (DBusGProxy *proxy, const char *path, gpointer user_data)
{
PluginInfo *info = user_data;
DBusGProxy *props_proxy;
g_return_if_fail (path != NULL);
g_message ("%s: (%s) modem found", __func__, path);
/* Create a proxy for the modem and get its properties */
props_proxy = dbus_g_proxy_new_for_name (info->bus,
MM_SERVICE,
path,
"org.freedesktop.DBus.Properties");
g_assert (proxy);
info->modem_proxies = g_slist_append (info->modem_proxies, props_proxy);
g_message ("%s: (%s) calling GetAll...", __func__, path);
dbus_g_proxy_begin_call (props_proxy, "GetAll",
modem_get_all_cb,
info,
NULL,
G_TYPE_STRING, MM_MODEM_INTERFACE,
G_TYPE_INVALID);
}
