/** Refresh albums */
static void _piwigo_refresh_albums(dt_storage_piwigo_gui_data_t *ui, const gchar *select_album)
{
gtk_widget_set_sensitive(GTK_WIDGET(ui->album_list), FALSE);
gtk_widget_set_sensitive(GTK_WIDGET(ui->parent_album_list), FALSE);
if(ui->api == NULL || ui->api->authenticated == FALSE)
{
_piwigo_authenticate(ui);
if(ui->api == NULL || !ui->api->authenticated) return;
}
gchar *to_select;
int index = 0;
// get the new album name, it will be checked in the
if(select_album == NULL)
{
to_select = g_strdup(dt_bauhaus_combobox_get_text(ui->album_list));
if(to_select)
{
// cut the count of picture in album to get the name only
gchar *p = to_select;
while(*p)
{
if(*p == ' ' && *(p+1) == '(')
{
*p = '\0';
break;
}
p++;
}
}
}
else
to_select = g_strdup(select_album);
// First clear the combobox except first 2 items (none / create new album)
dt_bauhaus_combobox_clear(ui->album_list);
dt_bauhaus_combobox_clear(ui->parent_album_list);
g_list_free(ui->albums);
ui->albums = NULL;
GList *args = NULL;
args = _piwigo_query_add_arguments(args, "method", "pwg.categories.getList");
args = _piwigo_query_add_arguments(args, "cat_id", "0");
args = _piwigo_query_add_arguments(args, "recursive", "true");
_piwigo_api_post(ui->api, args, NULL, FALSE);
g_list_free(args);
if(ui->api->response && !ui->api->error_occured)
{
dt_bauhaus_combobox_add(ui->album_list, _("create new album"));
dt_bauhaus_combobox_add(ui->parent_album_list, _("---"));
JsonObject *result = json_node_get_object(json_object_get_member(ui->api->response, "result"));
JsonArray *albums = json_object_get_array_member(result, "categories");
if(json_array_get_length(albums)>0 && index==0) index = 1;
if(index > json_array_get_length(albums) - 1) index = json_array_get_length(albums) - 1;
for(int i = 0; i < json_array_get_length(albums); i++)
{
char data[MAX_ALBUM_NAME_SIZE] = { 0 };
JsonObject *album = json_array_get_object_element(albums, i);
_piwigo_album_t *new_album = g_malloc0(sizeof(struct _piwigo_album_t));
g_strlcpy(new_album->name, json_object_get_string_member(album, "name"), sizeof(new_album->name));
new_album->id = json_object_get_int_member(album, "id");
new_album->size = json_object_get_int_member(album, "nb_images");
const int isroot = json_object_get_null_member(album, "id_uppercat");
int indent = 0;
if(!isroot)
{
const char *hierarchy = json_object_get_string_member(album, "uppercats");
char const *p = hierarchy;
while(*p++) if(*p == ',') indent++;
}
snprintf(data, sizeof(data), "%*c%s (%"PRId64")", indent * 3, ' ', new_album->name, new_album->size);
if(to_select && !strcmp(new_album->name, to_select)) index = i + 1;
g_strlcpy(new_album->label, data, sizeof(new_album->label));
ui->albums = g_list_append(ui->albums, new_album);
dt_bauhaus_combobox_add_aligned(ui->album_list, data, DT_BAUHAUS_COMBOBOX_ALIGN_LEFT);
dt_bauhaus_combobox_add_aligned(ui->parent_album_list, data, DT_BAUHAUS_COMBOBOX_ALIGN_LEFT);
}
}
else
dt_control_log(_("cannot refresh albums"));
g_free(to_select);
gtk_widget_set_sensitive(GTK_WIDGET(ui->album_list), TRUE);
gtk_widget_set_sensitive(GTK_WIDGET(ui->parent_album_list), TRUE);
dt_bauhaus_combobox_set(ui->album_list, index);
}
static int
add_list_field(struct ha_msg* msg, char* name, size_t namelen,
void* value, size_t vallen, int depth)
{
int next;
int j;
GList* list = NULL;
int stringlen_add;
if ( !msg || !name || !value
|| namelen <= 0
|| vallen <= 0
|| depth < 0){
cl_log(LOG_ERR, "add_list_field:"
" invalid input argument");
return HA_FAIL;
}
for (j=0; j < msg->nfields; ++j) {
if (strcmp(name, msg->names[j]) == 0) {
break;
}
}
if ( j >= msg->nfields){
int listlen;
list = (GList*)value;
listlen = string_list_pack_length(list);
stringlen_add = list_stringlen(namelen,listlen , value);
next = msg->nfields;
msg->names[next] = name;
msg->nlens[next] = namelen;
msg->values[next] = value;
msg->vlens[next] = vallen;
msg->types[next] = FT_LIST;
msg->nfields++;
} else if( msg->types[j] == FT_LIST ){
GList* oldlist = (GList*) msg->values[j];
int oldlistlen = string_list_pack_length(oldlist);
int newlistlen;
size_t i;
for ( i =0; i < g_list_length((GList*)value); i++){
list = g_list_append(oldlist, g_list_nth_data((GList*)value, i));
}
if (list == NULL){
cl_log(LOG_ERR, "add_list_field:"
" g_list_append() failed");
return HA_FAIL;
}
newlistlen = string_list_pack_length(list);
stringlen_add = newlistlen - oldlistlen;
msg->values[j] = list;
msg->vlens[j] = string_list_pack_length(list);
g_list_free((GList*)value); /*we don't free each element
because they are used in new list*/
} else {
cl_log(LOG_ERR, "field already exists "
"with differnt type=%d", msg->types[j]);
return (HA_FAIL);
}
return HA_OK;
}
static void
add_to_submenus (AppletInfo *info,
const char *path,
const char *name,
AppletUserMenu *menu,
GtkWidget *submenu,
GList *user_menu)
{
char *n = g_strdup (name);
char *p = strchr (n, '/');
char *t;
AppletUserMenu *s_menu;
/*this is the last one*/
if (p == NULL) {
g_free (n);
setup_an_item (menu, submenu, FALSE);
return;
}
/*this is the last one and we are a submenu, we have already been
set up*/
if(p==(n + strlen(n) - 1)) {
g_free(n);
return;
}
*p = '\0';
p++;
t = g_strconcat (path, n, "/", NULL);
s_menu = mate_panel_applet_get_callback (user_menu, t);
/*the user did not give us this sub menu, whoops, will create an empty
one then*/
if (s_menu == NULL) {
s_menu = g_new0 (AppletUserMenu,1);
s_menu->name = g_strdup (t);
s_menu->stock_item = NULL;
s_menu->text = g_strdup (_("???"));
s_menu->sensitive = TRUE;
s_menu->info = info;
s_menu->menuitem = NULL;
s_menu->submenu = NULL;
info->user_menu = g_list_append (info->user_menu,s_menu);
user_menu = info->user_menu;
}
if (s_menu->submenu == NULL) {
s_menu->submenu = gtk_menu_new ();
/*a more elegant way to do this should be done
when I don't want to go to sleep */
if (s_menu->menuitem != NULL) {
gtk_widget_destroy (s_menu->menuitem);
s_menu->menuitem = NULL;
}
}
if (s_menu->menuitem == NULL)
setup_an_item (s_menu, submenu, TRUE);
add_to_submenus (info, t, p, menu, s_menu->submenu, user_menu);
g_free(t);
g_free(n);
}
/*
* Virtual methods
*/
static GList *
mb5_list_albums (SjMetadata *metadata, char **url, GError **error)
{
SjMetadataMusicbrainz5Private *priv;
GList *albums = NULL;
Mb5ReleaseList releases;
Mb5Release release;
const char *discid = NULL;
char buffer[1025];
int i;
g_return_val_if_fail (SJ_IS_METADATA_MUSICBRAINZ5 (metadata), NULL);
priv = GET_PRIVATE (metadata);
if (sj_metadata_helper_check_media (priv->cdrom, error) == FALSE) {
return NULL;
}
priv->disc = discid_new ();
if (priv->disc == NULL)
return NULL;
if (discid_read (priv->disc, priv->cdrom) == 0)
return NULL;
if (url != NULL)
*url = g_strdup (discid_get_submission_url (priv->disc));
if (g_getenv("MUSICBRAINZ_FORCE_DISC_ID")) {
discid = g_getenv("MUSICBRAINZ_FORCE_DISC_ID");
} else {
discid = discid_get_id (priv->disc);
}
releases = mb5_query_lookup_discid(priv->mb, discid);
if (releases == NULL) {
return NULL;
}
if (mb5_release_list_size (releases) == 0) {
return NULL;
}
for (i = 0; i < mb5_release_list_size (releases); i++) {
AlbumDetails *album;
release = mb5_release_list_item (releases, i);
if (release) {
char *releaseid = NULL;
Mb5Release full_release;
releaseid = NULL;
GET(releaseid, mb5_release_get_id, release);
full_release = mb5_query_lookup_release (priv->mb, releaseid);
g_free (releaseid);
if (full_release) {
Mb5MediumList media;
Mb5Metadata metadata = NULL;
Mb5ReleaseGroup group;
unsigned int j;
group = mb5_release_get_releasegroup (full_release);
if (group) {
/* The release-group information we can extract from the
* lookup_release query doesn't have the url relations for the
* release-group, so run a separate query to get these urls
*/
char *releasegroupid = NULL;
char *params_names[] = { "inc" };
char *params_values[] = { "artists url-rels" };
GET (releasegroupid, mb5_releasegroup_get_id, group);
metadata = mb5_query_query (priv->mb, "release-group", releasegroupid, "",
1, params_names, params_values);
g_free (releasegroupid);
}
if (metadata && mb5_metadata_get_releasegroup (metadata))
group = mb5_metadata_get_releasegroup (metadata);
media = mb5_release_media_matching_discid (full_release, discid);
for (j = 0; j < mb5_medium_list_size (media); j++) {
Mb5Medium medium;
medium = mb5_medium_list_item (media, j);
if (medium) {
album = make_album_from_release (group, full_release, medium);
album->metadata_source = SOURCE_MUSICBRAINZ;
albums = g_list_append (albums, album);
}
}
mb5_metadata_delete (metadata);
mb5_medium_list_delete (media);
mb5_release_delete (full_release);
}
}
}
mb5_release_list_delete (releases);
return albums;
}
static GList *
mb_list_albums (SjMetadata *metadata, char **url, GError **error)
{
SjMetadataMusicbrainz3Private *priv;
GList *albums = NULL;
MbQuery query;
MbReleaseFilter filter;
MbResultList results;
MbRelease release;
char *id = NULL;
char buffer[1024];
int i;
g_return_val_if_fail (SJ_IS_METADATA_MUSICBRAINZ3 (metadata), NULL);
priv = GET_PRIVATE (metadata);
if (sj_metadata_helper_check_media (priv->cdrom, error) == FALSE) {
return NULL;
}
priv->disc = mb_read_disc (priv->cdrom);
if (priv->disc == NULL)
return NULL;
if (url != NULL) {
mb_get_submission_url (priv->disc, NULL, 0, buffer, sizeof (buffer));
*url = g_strdup (buffer);
}
if (g_getenv("MUSICBRAINZ_FORCE_DISC_ID")) {
id = g_strdup (g_getenv("MUSICBRAINZ_FORCE_DISC_ID"));
} else {
GET(id, mb_disc_get_id, priv->disc);
}
query = mb_query_new (priv->mb, "sound-juicer");
filter = mb_release_filter_new ();
filter = mb_release_filter_disc_id (filter, id);
results = mb_query_get_releases (query, filter);
mb_release_filter_free (filter);
g_free (id);
if (results == NULL) {
mb_query_free (query);
return NULL;
}
if (mb_result_list_get_size (results) == 0) {
mb_result_list_free (results);
mb_query_free (query);
return NULL;
}
for (i = 0; i < mb_result_list_get_size (results); i++) {
AlbumDetails *album;
MbReleaseIncludes includes;
char buffer[512];
release = mb_result_list_get_release (results, i);
if(release) {
mb_release_get_id (release, buffer, sizeof (buffer));
includes = get_release_includes ();
release = mb_query_get_release_by_id (query, buffer, includes);
if(release) {
mb_release_includes_free (includes);
album = make_album_from_release (release);
album->metadata_source = SOURCE_MUSICBRAINZ;
fill_empty_durations (priv->disc, album);
albums = g_list_append (albums, album);
mb_release_free (release);
}
}
}
mb_result_list_free (results);
mb_query_free (query);
return albums;
}
/*
* Fetch the list of local interfaces with capture_interface_list()
* and set the list of "all interfaces" in *capture_opts to include
* those interfaces.
*/
void
scan_local_interfaces(void (*update_cb)(void))
{
GList *if_entry, *lt_entry, *if_list;
if_info_t *if_info, *temp;
char *if_string;
gchar *descr;
if_capabilities_t *caps=NULL;
gint linktype_count;
gboolean monitor_mode;
GSList *curr_addr;
int ips = 0, i, err;
guint count = 0, j;
if_addr_t *addr, *temp_addr;
link_row *link = NULL;
data_link_info_t *data_link_info;
interface_t device;
GString *ip_str;
interface_options interface_opts;
gboolean found = FALSE;
if (global_capture_opts.all_ifaces->len > 0) {
for (i = (int)global_capture_opts.all_ifaces->len-1; i >= 0; i--) {
device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
if (device.local && device.type != IF_PIPE && device.type != IF_STDIN) {
global_capture_opts.all_ifaces = g_array_remove_index(global_capture_opts.all_ifaces, i);
}
}
}
/* Scan through the list and build a list of strings to display. */
if_list = capture_interface_list(&err, NULL, update_cb);
count = 0;
for (if_entry = if_list; if_entry != NULL; if_entry = g_list_next(if_entry)) {
if_info = (if_info_t *)if_entry->data;
ip_str = g_string_new("");
ips = 0;
if (strstr(if_info->name, "rpcap:")) {
continue;
}
device.name = g_strdup(if_info->name);
if (if_info->friendly_name != NULL) {
device.friendly_name = g_strdup(if_info->friendly_name);
} else {
device.friendly_name = NULL;
}
device.hidden = FALSE;
device.locked = FALSE;
temp = (if_info_t *)g_malloc0(sizeof(if_info_t));
temp->name = g_strdup(if_info->name);
temp->friendly_name = g_strdup(if_info->friendly_name);
temp->vendor_description = g_strdup(if_info->vendor_description);
temp->loopback = if_info->loopback;
/* Is this interface hidden and, if so, should we include it anyway? */
/* Do we have a user-supplied description? */
descr = capture_dev_user_descr_find(if_info->name);
if (descr != NULL) {
/* Yes, we have a user-supplied description; use it. */
if_string = g_strdup_printf("%s: %s", descr, if_info->name);
g_free(descr);
} else {
/* No, we don't have a user-supplied description; did we get
one from the OS or libpcap? */
if (if_info->friendly_name != NULL) {
/* We have a friendly name from the OS, use it */
#ifdef _WIN32
/*
* On Windows, if we have a friendly name, just show it,
* don't show the name, as that's a string made out of
* the device GUID, and not at all friendly.
*/
if_string = g_strdup_printf("%s", if_info->friendly_name);
#else
/*
* On UN*X, if we have a friendly name, show it along
* with the interface name; the interface name is short
* and somewhat friendly, and many UN*X users are used
* to interface names, so we should show it.
*/
if_string = g_strdup_printf("%s: %s", if_info->friendly_name, if_info->name);
#endif
} else if (if_info->vendor_description != NULL) {
/* We have a device description from libpcap - use it. */
if_string = g_strdup_printf("%s: %s", if_info->vendor_description, if_info->name);
} else {
/* No. */
if_string = g_strdup(if_info->name);
}
}
device.display_name = if_string;
device.selected = FALSE;
if (prefs_is_capture_device_hidden(if_info->name)) {
device.hidden = TRUE;
}
device.type = if_info->type;
monitor_mode = prefs_capture_device_monitor_mode(if_info->name);
caps = capture_get_if_capabilities(if_info->name, monitor_mode, NULL, update_cb);
for (; (curr_addr = g_slist_nth(if_info->addrs, ips)) != NULL; ips++) {
temp_addr = (if_addr_t *)g_malloc0(sizeof(if_addr_t));
if (ips != 0) {
g_string_append(ip_str, "\n");
}
addr = (if_addr_t *)curr_addr->data;
if (addr) {
temp_addr->ifat_type = addr->ifat_type;
switch (addr->ifat_type) {
case IF_AT_IPv4:
temp_addr->addr.ip4_addr = addr->addr.ip4_addr;
g_string_append(ip_str, ip_to_str((guint8 *)&addr->addr.ip4_addr));
break;
case IF_AT_IPv6:
memcpy(temp_addr->addr.ip6_addr, addr->addr.ip6_addr, sizeof(addr->addr));
g_string_append(ip_str, ip6_to_str((struct e_in6_addr *)&addr->addr.ip6_addr));
break;
default:
/* In case we add non-IP addresses */
break;
}
} else {
g_free(temp_addr);
temp_addr = NULL;
}
if (temp_addr) {
temp->addrs = g_slist_append(temp->addrs, temp_addr);
}
}
#ifdef HAVE_PCAP_REMOTE
device.local = TRUE;
device.remote_opts.src_type = CAPTURE_IFLOCAL;
device.remote_opts.remote_host_opts.remote_host = g_strdup(global_capture_opts.default_options.remote_host);
device.remote_opts.remote_host_opts.remote_port = g_strdup(global_capture_opts.default_options.remote_port);
device.remote_opts.remote_host_opts.auth_type = global_capture_opts.default_options.auth_type;
device.remote_opts.remote_host_opts.auth_username = g_strdup(global_capture_opts.default_options.auth_username);
device.remote_opts.remote_host_opts.auth_password = g_strdup(global_capture_opts.default_options.auth_password);
device.remote_opts.remote_host_opts.datatx_udp = global_capture_opts.default_options.datatx_udp;
device.remote_opts.remote_host_opts.nocap_rpcap = global_capture_opts.default_options.nocap_rpcap;
device.remote_opts.remote_host_opts.nocap_local = global_capture_opts.default_options.nocap_local;
#endif
#ifdef HAVE_PCAP_SETSAMPLING
device.remote_opts.sampling_method = global_capture_opts.default_options.sampling_method;
device.remote_opts.sampling_param = global_capture_opts.default_options.sampling_param;
#endif
linktype_count = 0;
device.links = NULL;
if (caps != NULL) {
#if defined(HAVE_PCAP_CREATE)
device.monitor_mode_enabled = monitor_mode;
device.monitor_mode_supported = caps->can_set_rfmon;
#endif
/*
* If there's a preference for the link-layer header type for
* this interface, use it. If not, use the all-interface
* default; if that's not set on the command line, that will
* be -1, meaning "use per-interface defaults", otherwise
* we'll fail if it's not one of the types the interface
* supports.
*/
if ((device.active_dlt = capture_dev_user_linktype_find(if_info->name)) == -1) {
device.active_dlt = global_capture_opts.default_options.linktype;
}
/*
* Process the list of link-layer header types.
* If the active link-layer header type wasn't set from a
* preference or a global option (meaning it's -1), default
* to the first link-layer header type in the list.
*/
for (lt_entry = caps->data_link_types; lt_entry != NULL; lt_entry = g_list_next(lt_entry)) {
data_link_info = (data_link_info_t *)lt_entry->data;
if (linktype_count == 0 && device.active_dlt == -1) {
device.active_dlt = data_link_info->dlt;
}
link = (link_row *)g_malloc(sizeof(link_row));
if (data_link_info->description != NULL) {
link->dlt = data_link_info->dlt;
link->name = g_strdup_printf("%s", data_link_info->description);
} else {
link->dlt = -1;
link->name = g_strdup_printf("%s (not supported)", data_link_info->name);
}
device.links = g_list_append(device.links, link);
linktype_count++;
}
} else {
#if defined(HAVE_PCAP_CREATE)
device.monitor_mode_enabled = FALSE;
device.monitor_mode_supported = FALSE;
#endif
device.active_dlt = -1;
}
device.addresses = g_strdup(ip_str->str);
device.no_addresses = ips;
device.local = TRUE;
device.if_info = *temp;
device.last_packets = 0;
if ((device.pmode = capture_dev_user_pmode_find(if_info->name)) == -1) {
device.pmode = global_capture_opts.default_options.promisc_mode;
}
if ((device.has_snaplen = capture_dev_user_hassnap_find(if_info->name)) == -1) {
device.has_snaplen = global_capture_opts.default_options.has_snaplen;
}
if (capture_dev_user_snaplen_find(if_info->name) == -1) {
device.snaplen = global_capture_opts.default_options.snaplen;
} else {
device.snaplen = (guint)capture_dev_user_snaplen_find(if_info->name);
}
device.cfilter = g_strdup(global_capture_opts.default_options.cfilter);
#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
if ((device.buffer = capture_dev_user_buffersize_find(if_info->name)) == -1) {
device.buffer = global_capture_opts.default_options.buffer_size;
}
#endif
if (global_capture_opts.ifaces->len > 0) {
for (j = 0; j < global_capture_opts.ifaces->len; j++) {
interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, j);
if (strcmp(interface_opts.name, device.name) == 0) {
#if defined(HAVE_PCAP_CREATE)
device.buffer = interface_opts.buffer_size;
device.monitor_mode_enabled = interface_opts.monitor_mode;
#endif
device.pmode = interface_opts.promisc_mode;
device.has_snaplen = interface_opts.has_snaplen;
device.snaplen = interface_opts.snaplen;
device.cfilter = g_strdup(interface_opts.cfilter);
if (interface_opts.linktype != -1) {
device.active_dlt = interface_opts.linktype;
}
device.selected = TRUE;
global_capture_opts.num_selected++;
break;
}
}
}
if (global_capture_opts.all_ifaces->len <= count) {
g_array_append_val(global_capture_opts.all_ifaces, device);
count = global_capture_opts.all_ifaces->len;
} else {
g_array_insert_val(global_capture_opts.all_ifaces, count, device);
}
if (caps != NULL) {
free_if_capabilities(caps);
}
g_string_free(ip_str, TRUE);
count++;
}
free_interface_list(if_list);
/* see whether there are additional interfaces in ifaces */
for (j = 0; j < global_capture_opts.ifaces->len; j++) {
interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, j);
found = FALSE;
for (i = 0; i < (int)global_capture_opts.all_ifaces->len; i++) {
device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
if (strcmp(device.name, interface_opts.name) == 0) {
found = TRUE;
break;
}
}
if (!found) { /* new interface, maybe a pipe */
device.name = g_strdup(interface_opts.name);
device.display_name = g_strdup_printf("%s: %s", device.name, interface_opts.descr);
device.hidden = FALSE;
device.selected = TRUE;
device.type = IF_PIPE;
#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
device.buffer = interface_opts.buffer_size;
#endif
#if defined(HAVE_PCAP_CREATE)
device.monitor_mode_enabled = interface_opts.monitor_mode;
device.monitor_mode_supported = FALSE;
#endif
device.pmode = interface_opts.promisc_mode;
device.has_snaplen = interface_opts.has_snaplen;
device.snaplen = interface_opts.snaplen;
device.cfilter = g_strdup(interface_opts.cfilter);
device.active_dlt = interface_opts.linktype;
device.addresses = NULL;
device.no_addresses = 0;
device.last_packets = 0;
device.links = NULL;
device.local = TRUE;
device.locked = FALSE;
device.if_info.name = g_strdup(interface_opts.name);
device.if_info.friendly_name = NULL;
device.if_info.vendor_description = g_strdup(interface_opts.descr);
device.if_info.addrs = NULL;
device.if_info.loopback = FALSE;
g_array_append_val(global_capture_opts.all_ifaces, device);
global_capture_opts.num_selected++;
}
}
}
static void update(dt_lib_module_t *user_data, gboolean early_bark_out)
{
// early_bark_out = FALSE; // FIXME: when barking out early we don't update on ctrl-a/ctrl-shift-a. but
// otherwise it's impossible to edit text
const dt_lib_module_t *self = (dt_lib_module_t *)user_data;
dt_lib_metadata_t *d = (dt_lib_metadata_t *)self->data;
const int imgsel = dt_control_get_mouse_over_id();
if(early_bark_out && imgsel == d->imgsel) return;
d->imgsel = imgsel;
sqlite3_stmt *stmt;
GList *title = NULL;
uint32_t title_count = 0;
GList *description = NULL;
uint32_t description_count = 0;
GList *creator = NULL;
uint32_t creator_count = 0;
GList *publisher = NULL;
uint32_t publisher_count = 0;
GList *rights = NULL;
uint32_t rights_count = 0;
// using dt_metadata_get() is not possible here. we want to do all this in a single pass, everything else
// takes ages.
if(imgsel < 0) // selected images
{
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), "select key, value from meta_data where id in "
"(select imgid from selected_images) group by "
"key, value order by value",
-1, &stmt, NULL);
}
else // single image under mouse cursor
{
char query[1024];
snprintf(query, sizeof(query),
"select key, value from meta_data where id = %d group by key, value order by value", imgsel);
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), query, -1, &stmt, NULL);
}
while(sqlite3_step(stmt) == SQLITE_ROW)
{
char *value = g_strdup((char *)sqlite3_column_text(stmt, 1));
if(sqlite3_column_bytes(stmt, 1))
{
switch(sqlite3_column_int(stmt, 0))
{
case DT_METADATA_XMP_DC_CREATOR:
creator_count++;
creator = g_list_append(creator, value);
break;
case DT_METADATA_XMP_DC_PUBLISHER:
publisher_count++;
publisher = g_list_append(publisher, value);
break;
case DT_METADATA_XMP_DC_TITLE:
title_count++;
title = g_list_append(title, value);
break;
case DT_METADATA_XMP_DC_DESCRIPTION:
description_count++;
description = g_list_append(description, value);
break;
case DT_METADATA_XMP_DC_RIGHTS:
rights_count++;
rights = g_list_append(rights, value);
break;
}
}
}
sqlite3_finalize(stmt);
fill_combo_box_entry(&(d->title), title_count, &title, &(d->multi_title));
fill_combo_box_entry(&(d->description), description_count, &description, &(d->multi_description));
fill_combo_box_entry(&(d->rights), rights_count, &rights, &(d->multi_rights));
fill_combo_box_entry(&(d->creator), creator_count, &creator, &(d->multi_creator));
fill_combo_box_entry(&(d->publisher), publisher_count, &publisher, &(d->multi_publisher));
g_list_free(g_list_first(title));
g_list_free(g_list_first(description));
g_list_free(g_list_first(creator));
g_list_free(g_list_first(publisher));
g_list_free(g_list_first(rights));
}
/*
* Do all the bar display and register the events
*/
void
gc_config_start ()
{
GcomprisProperties *properties = gc_prop_get();
gint y_start = 0;
gint x_start = 0;
gint x_text_start = 0;
gint y = 0;
GooCanvasItem *item;
/* Pause the board */
gc_board_pause(TRUE);
if(rootitem)
{
gc_config_stop();
return;
}
gc_bar_hide(TRUE);
rootitem = goo_canvas_group_new (goo_canvas_get_root_item(gc_get_canvas()),
NULL);
item = goo_canvas_svg_new (rootitem,
gc_skin_rsvg_get(),
"svg-id", "#DIALOG",
"pointer-events", GOO_CANVAS_EVENTS_NONE,
NULL);
GooCanvasBounds bounds;
goo_canvas_item_get_bounds(item, &bounds);
x_start = bounds.x1;
y_start = bounds.y1;
y = bounds.y2 - 26;
goo_canvas_text_new (rootitem,
_("GCompris Configuration"),
(gdouble) BOARDWIDTH/2,
(gdouble) y_start + 40,
-1,
GTK_ANCHOR_CENTER,
"font", gc_skin_font_title,
"fill-color-rgba", gc_skin_color_title,
NULL);
pixmap_checked = "#CHECKED";
pixmap_unchecked = "#UNCHECKED";
pixmap_width = 30;
x_start += 150;
x_flag_start = x_start + 50;
x_text_start = x_start + 115;
//--------------------------------------------------
// Locale
y_start += 105;
display_previous_next(x_start, y_start, "locale_previous", "locale_next");
y_flag_start = y_start - pixmap_width/2;
/* Display a bad icon if this locale is not available */
item_bad_flag = goo_canvas_svg_new (rootitem,
gc_skin_rsvg_get(),
"svg-id", "#UNCHECKED",
"pointer-events", GOO_CANVAS_EVENTS_NONE,
NULL);
SET_ITEM_LOCATION(item_bad_flag,
x_flag_start + 5,
y_start - pixmap_width/2);
/* A repeat icon to reset the selection */
item = goo_canvas_svg_new (rootitem,
gc_skin_rsvg_get(),
"svg-id", "#REPEAT",
NULL);
goo_canvas_item_get_bounds(item, &bounds);
double zoom = 0.65;
goo_canvas_item_scale(item, zoom, zoom);
goo_canvas_item_translate(item,
(-1 * bounds.x1 + x_flag_start - 340) * zoom,
(-1 * bounds.y1 + y_start - 120) * zoom);
g_signal_connect(item, "button_press_event",
(GCallback) item_event_ok,
"locale_reset");
gc_item_focus_init(item, NULL);
/*
* The current locale is the one found in the config file
*/
current_locale = properties->locale;
set_locale_flag(current_locale);
item_locale_text = goo_canvas_text_new (rootitem,
gc_locale_get_name(current_locale),
(gdouble) x_text_start,
(gdouble) y_start,
-1,
GTK_ANCHOR_WEST,
"font", gc_skin_font_subtitle,
"fill-color-rgba", gc_skin_color_content,
NULL);
// Fullscreen / Window
y_start += Y_GAP;
item = goo_canvas_svg_new (rootitem,
gc_skin_rsvg_get(),
"svg-id", (properties->fullscreen ? pixmap_checked : pixmap_unchecked),
NULL);
SET_ITEM_LOCATION(item, x_start, y_start - pixmap_width/2);
g_signal_connect(item, "button_press_event",
(GCallback) item_event_ok,
"fullscreen");
gc_item_focus_init(item, NULL);
goo_canvas_text_new (rootitem,
_("Fullscreen"),
(gdouble) x_text_start,
(gdouble) y_start,
-1,
GTK_ANCHOR_WEST,
"font", gc_skin_font_subtitle,
"fill-color-rgba", gc_skin_color_content,
NULL);
// Music
y_start += Y_GAP;
item = goo_canvas_svg_new (rootitem,
gc_skin_rsvg_get(),
"svg-id", (properties->music ? pixmap_checked : pixmap_unchecked),
NULL);
SET_ITEM_LOCATION(item, x_start, y_start - pixmap_width/2);
g_signal_connect(item, "button_press_event",
(GCallback) item_event_ok,
"music");
gc_item_focus_init(item, NULL);
goo_canvas_text_new (rootitem,
_("Music"),
(gdouble) x_text_start,
(gdouble) y_start,
-1,
GTK_ANCHOR_WEST,
"font", gc_skin_font_subtitle,
"fill-color-rgba", gc_skin_color_content,
NULL);
// Effect
y_start += Y_GAP;
item = goo_canvas_svg_new (rootitem,
gc_skin_rsvg_get(),
"svg-id", (properties->fx ? pixmap_checked : pixmap_unchecked),
NULL);
SET_ITEM_LOCATION(item, x_start, y_start - pixmap_width/2);
g_signal_connect(item, "button_press_event",
(GCallback) item_event_ok,
"effect");
gc_item_focus_init(item, NULL);
goo_canvas_text_new (rootitem,
_("Effect"),
(gdouble) x_text_start,
(gdouble) y_start,
-1,
GTK_ANCHOR_WEST,
"font", gc_skin_font_subtitle,
"fill-color-rgba", gc_skin_color_content,
NULL);
// Zoom
y_start += Y_GAP;
item = goo_canvas_svg_new (rootitem,
gc_skin_rsvg_get(),
"svg-id", (properties->zoom ? pixmap_checked : pixmap_unchecked),
NULL);
SET_ITEM_LOCATION(item, x_start, y_start - pixmap_width/2);
g_signal_connect(item, "button_press_event",
(GCallback) item_event_ok,
"zoom");
gc_item_focus_init(item, NULL);
goo_canvas_text_new (rootitem,
_("Zoom"),
(gdouble) x_text_start,
(gdouble) y_start,
-1,
GTK_ANCHOR_WEST,
"font", gc_skin_font_subtitle,
"fill-color-rgba", gc_skin_color_content,
NULL);
// Timer
y_start += Y_GAP;
display_previous_next(x_start, y_start, "timer_previous", "timer_next");
item_timer_text = goo_canvas_text_new (rootitem,
gettext(timername[properties->timer]),
(gdouble) x_text_start,
(gdouble) y_start,
-1,
GTK_ANCHOR_WEST,
"font", gc_skin_font_subtitle,
"fill-color-rgba", gc_skin_color_content,
NULL);
// Skin
{
const gchar *one_dirent;
guint i;
GDir *dir;
gchar *skin_dir;
gchar *first_skin_name;
/* Load the Pixpmaps directory file names */
skin_dir = g_strconcat(properties->package_data_dir, "/skins", NULL);
dir = g_dir_open(skin_dir, 0, NULL);
if (!dir)
g_warning (_("Couldn't open skin dir: %s"), skin_dir);
/* Fill up the skin list */
while((one_dirent = g_dir_read_name(dir)) != NULL) {
if (one_dirent[0] != '.') {
gchar *filename;
/* Only directory here are skins */
filename = g_strdup_printf("%s/%s", properties->package_skin_dir, one_dirent);
if (g_file_test ((filename), G_FILE_TEST_IS_DIR)) {
gchar *skin_name = g_strdup_printf("%s", one_dirent);
skinlist = g_list_append (skinlist, skin_name);
}
g_free(filename);
}
}
g_dir_close(dir);
/* Find the current skin index */
skin_index = 0;
for(i=0; i<g_list_length(skinlist); i++)
if(!strcmp((char *)g_list_nth_data(skinlist, i), properties->skin))
skin_index = i;
y_start += Y_GAP;
/* Should not happen. It the user found the config, there should be a skin */
if(g_list_length(skinlist) > 0) {
g_warning("No skin found in %s\n", skin_dir);
display_previous_next(x_start, y_start, "skin_previous", "skin_next");
first_skin_name = g_strdup_printf(_("Skin : %s"), (char *)g_list_nth_data(skinlist, skin_index));
} else {
first_skin_name = g_strdup(_("SKINS NOT FOUND"));
}
item_skin_text = goo_canvas_text_new (rootitem,
first_skin_name,
(gdouble) x_text_start,
(gdouble) y_start,
-1,
GTK_ANCHOR_WEST,
"font", gc_skin_font_subtitle,
"fill-color-rgba", gc_skin_color_content,
NULL);
g_free(first_skin_name);
g_free(skin_dir);
}
// Difficulty Filter
y_start += Y_GAP;
stars_group_x = x_start + 45;
stars_group_y = y_start - 25;
gchar *text = g_strdup_printf("<i>%s</i>", gettext(filtername));
item_filter_text = goo_canvas_text_new (rootitem,
text,
x_text_start,
y_start,
400,
GTK_ANCHOR_WEST,
"use-markup", TRUE,
"font", gc_skin_font_subtitle,
"fill-color-rgba", gc_skin_color_content,
NULL);
g_free(text);
// OK
gc_util_button_text_svg(rootitem,
BOARDWIDTH * 0.5,
y,
"#BUTTON_TEXT",
_("OK"),
(GCallback) item_event_ok,
"ok");
is_displayed = TRUE;
}
void
qof_session_load (QofSession *session,
QofPercentageFunc percentage_func)
{
QofBook *newbook, *ob;
QofBookList *oldbooks, *node;
QofBackend *be;
QofBackendError err;
if (!session) return;
if (!session->book_id) return;
ENTER ("sess=%p book_id=%s", session, session->book_id
? session->book_id : "(null)");
/* At this point, we should are supposed to have a valid book
* id and a lock on the file. */
oldbooks = session->books;
/* XXX why are we creating a book here? I think the books
* need to be handled by the backend ... especially since
* the backend may need to load multiple books ... XXX. FIXME.
*/
newbook = qof_book_new();
session->books = g_list_append (NULL, newbook);
PINFO ("new book=%p", newbook);
qof_session_clear_error (session);
/* This code should be sufficient to initialize *any* backend,
* whether http, postgres, or anything else that might come along.
* Basically, the idea is that by now, a backend has already been
* created & set up. At this point, we only need to get the
* top-level account group out of the backend, and that is a
* generic, backend-independent operation.
*/
be = session->backend;
qof_book_set_backend(newbook, be);
/* Starting the session should result in a bunch of accounts
* and currencies being downloaded, but probably no transactions;
* The GUI will need to do a query for that.
*/
if (be)
{
be->percentage = percentage_func;
if (be->load)
{
be->load (be, newbook, LOAD_TYPE_INITIAL_LOAD);
qof_session_push_error (session, qof_backend_get_error(be), NULL);
}
}
/* XXX if the load fails, then we try to restore the old set of books;
* however, we don't undo the session id (the URL). Thus if the
* user attempts to save after a failed load, they weill be trying to
* save to some bogus URL. This is wrong. XXX FIXME.
*/
err = qof_session_get_error(session);
if ((err != ERR_BACKEND_NO_ERR) &&
(err != ERR_FILEIO_FILE_TOO_OLD) &&
(err != ERR_FILEIO_NO_ENCODING) &&
(err != ERR_SQL_DB_TOO_OLD))
{
/* Something broke, put back the old stuff */
qof_book_set_backend (newbook, NULL);
qof_book_destroy (newbook);
g_list_free (session->books);
session->books = oldbooks;
LEAVE("error from backend %d", qof_session_get_error(session));
return;
}
for (node = oldbooks; node; node = node->next)
{
ob = node->data;
qof_book_set_backend (ob, NULL);
qof_book_destroy (ob);
}
g_list_free (oldbooks);
LEAVE ("sess = %p, book_id=%s", session, session->book_id
? session->book_id : "(null)");
}
void siesta_animation_dialog(GtkWidget *w, struct model_pak *model)
{
GList *list;
GtkWidget *window, *box, *hbox, *hbox2, *vbox, *label, *hscale, *entry, *button, *spin;
gpointer dialog;
g_assert(model != NULL);
/* don't recalculate modes if already done */
if (!model->siesta.vibration_calc_complete)
if (siesta_phonon_calc(model))
return;
/* request a dialog */
dialog = dialog_request(100, "Vibrational viewer", NULL, NULL, model);
if (!dialog)
return;
window = dialog_window(dialog);
box = gtk_vbox_new(TRUE, 0);
gtk_container_add(GTK_CONTAINER(GTK_DIALOG(window)->vbox), box);
/* phonon selection */
vbox = gui_frame_vbox(NULL, FALSE, FALSE, box);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
/* phonon frequency */
label = gtk_label_new("Frequency ");
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
entry = gtk_entry_new_with_max_length(LINELEN);
gtk_entry_set_text(GTK_ENTRY(entry), " ");
gtk_entry_set_editable(GTK_ENTRY(entry), FALSE);
gtk_box_pack_start(GTK_BOX(hbox), entry, FALSE, FALSE, 0);
dialog_child_set(dialog, "phonon_entry", entry);
gui_button(" < ", gui_siesta_mode_prev, dialog, hbox, FF);
gui_button(" > ", gui_siesta_mode_next, dialog, hbox, FF);
/* phonon slider */
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
hscale = gtk_hscale_new_with_range(1.0, model->siesta.num_animations, 1.0);
gtk_box_pack_start(GTK_BOX(hbox), hscale, TRUE, TRUE, 0);
dialog_child_set(dialog, "phonon_slider", hscale);
g_signal_connect(GTK_OBJECT(hscale), "value_changed",
GTK_SIGNAL_FUNC(gui_siesta_slider_changed), dialog);
/* phonon display options */
vbox = gui_frame_vbox(NULL, FALSE, FALSE, box);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
button = new_check_button("Show eigenvectors", gui_siesta_mode_show, dialog, FALSE, hbox);
dialog_child_set(dialog, "phonon_toggle", button);
spin = new_spinner("Eigenvector scaling", 0.1, 9.9, 0.1, gui_siesta_mode_show, dialog, vbox);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin), 4.0);
dialog_child_set(dialog, "phonon_scaling", spin);
spin = new_spinner("Animation resolution", 5.0, 50.0, 1.0, NULL, NULL, vbox);
dialog_child_set(dialog, "phonon_resolution", spin);
/* phonon mode animation */
vbox = gui_frame_vbox(NULL, FALSE, FALSE, box);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
label = gtk_label_new("Animate mode ");
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
hbox2 = gtk_hbox_new(FALSE, 0);
gtk_box_pack_end(GTK_BOX(hbox), hbox2, FALSE, FALSE, 0);
gui_icon_button("GDIS_PLAY", NULL, siesta_phonon_start, dialog, hbox2);
gui_icon_button("GDIS_STOP", NULL, siesta_phonon_stop, dialog, hbox2);
/* phonon mode movie generation */
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
label = gtk_label_new("Create movie ");
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
entry = gtk_entry_new_with_max_length(LINELEN);
gtk_entry_set_text(GTK_ENTRY(entry), "movie_name");
gtk_entry_set_editable(GTK_ENTRY(entry), TRUE);
gtk_box_pack_start(GTK_BOX(hbox), entry, FALSE, FALSE, 0);
dialog_child_set(dialog, "phonon_movie_name", entry);
/* movie type */
list = NULL;
list = g_list_append(list, "gif");
list = g_list_append(list, "mpg");
entry = gui_pulldown_new(NULL, list, FALSE, hbox);
dialog_child_set(dialog, "phonon_movie_type", entry);
gui_button_x(NULL, siesta_phonon_movie, dialog, hbox);
/* init and display */
gui_siesta_frequency_set(dialog);
gtk_widget_show_all(window);
}
static GstFlowReturn
gst_base_video_encoder_chain (GstPad * pad, GstBuffer * buf)
{
GstBaseVideoEncoder *base_video_encoder;
GstBaseVideoEncoderClass *klass;
GstVideoFrame *frame;
GstFlowReturn ret = GST_FLOW_OK;
base_video_encoder = GST_BASE_VIDEO_ENCODER (gst_pad_get_parent (pad));
klass = GST_BASE_VIDEO_ENCODER_GET_CLASS (base_video_encoder);
g_return_val_if_fail (klass->handle_frame != NULL, GST_FLOW_ERROR);
if (!GST_PAD_CAPS (pad)) {
return GST_FLOW_NOT_NEGOTIATED;
}
GST_LOG_OBJECT (base_video_encoder,
"received buffer of size %d with ts %" GST_TIME_FORMAT
", duration %" GST_TIME_FORMAT, GST_BUFFER_SIZE (buf),
GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)),
GST_TIME_ARGS (GST_BUFFER_DURATION (buf)));
if (base_video_encoder->a.at_eos) {
return GST_FLOW_UNEXPECTED;
}
if (base_video_encoder->sink_clipping) {
gint64 start = GST_BUFFER_TIMESTAMP (buf);
gint64 stop = start + GST_BUFFER_DURATION (buf);
gint64 clip_start;
gint64 clip_stop;
if (!gst_segment_clip (&GST_BASE_VIDEO_CODEC (base_video_encoder)->segment,
GST_FORMAT_TIME, start, stop, &clip_start, &clip_stop)) {
GST_DEBUG_OBJECT (base_video_encoder,
"clipping to segment dropped frame");
goto done;
}
}
if (G_UNLIKELY (GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_DISCONT))) {
GST_LOG_OBJECT (base_video_encoder, "marked discont");
GST_BASE_VIDEO_CODEC (base_video_encoder)->discont = TRUE;
}
frame =
gst_base_video_codec_new_frame (GST_BASE_VIDEO_CODEC
(base_video_encoder));
frame->events = base_video_encoder->current_frame_events;
base_video_encoder->current_frame_events = NULL;
frame->sink_buffer = buf;
frame->presentation_timestamp = GST_BUFFER_TIMESTAMP (buf);
frame->presentation_duration = GST_BUFFER_DURATION (buf);
frame->presentation_frame_number =
base_video_encoder->presentation_frame_number;
base_video_encoder->presentation_frame_number++;
frame->force_keyframe = base_video_encoder->force_keyframe;
base_video_encoder->force_keyframe = FALSE;
GST_BASE_VIDEO_CODEC (base_video_encoder)->frames =
g_list_append (GST_BASE_VIDEO_CODEC (base_video_encoder)->frames, frame);
/* new data, more finish needed */
base_video_encoder->drained = FALSE;
GST_LOG_OBJECT (base_video_encoder, "passing frame pfn %d to subclass",
frame->presentation_frame_number);
ret = klass->handle_frame (base_video_encoder, frame);
done:
g_object_unref (base_video_encoder);
return ret;
}
gboolean
gnomegadu_protocol_loop (GIOChannel * source, GIOCondition condition, gpointer data)
{
static gint prev_check = GG_CHECK_READ;
gboolean ret = TRUE;
struct gg_event *e = NULL;
/* w przypadku bledu/utraty polaczenia postap tak jak w przypadku disconnect */
if (!gnomegadu_gadugadu_session || !(e = gg_watch_fd (gnomegadu_gadugadu_session)) || (condition & G_IO_ERR) ||
((condition & G_IO_HUP)
&& ((gnomegadu_gadugadu_session->state != GG_STATE_CONNECTING_GG) && (gnomegadu_gadugadu_session->check != GG_CHECK_WRITE))))
{
g_printerr ("gnomegadu_protocol_loop(): some kind of problem while processing\n");
gnomegadu_gadugadu_disconnect ();
prev_check = GG_CHECK_READ;
return FALSE;
}
switch (e->type)
{
case GG_EVENT_NONE:
g_print ("GG_EVENT_NONE\n");
break;
case GG_EVENT_PONG:
g_print ("GG_EVENT_PONG\n");
gg_ping (gnomegadu_gadugadu_session);
break;
case GG_EVENT_CONN_FAILED:
g_print ("GG_EVENT_CONN_FAILED\n");
gnomegadu_gadugadu_disconnect ();
ret = FALSE;
break;
case GG_EVENT_DISCONNECT:
g_print ("GG_EVENT_DISCONNECT\n");
gnomegadu_gadugadu_disconnect ();
ret = FALSE;
break;
case GG_EVENT_CONN_SUCCESS:
{
g_print ("GG_EVENT_CONN_SUCCESS\n");
//wysyłam swoją listę
gint i, j = 0;
uint32_t *uins;
GSList *contacts_list = gnomegadu_conf_get_contacts ();
GSList *contacts_list_start = contacts_list;
gnomegadu_protocol_is_connected = TRUE;
if (!contacts_list)
break;
i = g_slist_length (contacts_list);
uins = g_malloc0 (i * sizeof (uint32_t));
while (contacts_list)
{
gchar *uin_str;
gchar *path = (gchar *) contacts_list->data;
gchar *uin_path = g_strconcat (path, "/uin", NULL);
uin_str = gconf_client_get_string (gconf, uin_path, NULL);
uins[j++] = g_strtod (uin_str, NULL);
g_free (uin_path);
contacts_list = g_slist_next(contacts_list);
}
if (j > 0)
gg_notify (gnomegadu_gadugadu_session, uins, i);
/* pingpong */
g_timeout_add(100000, gnomegadu_protocol_ping, NULL);
g_slist_foreach (contacts_list_start, gnomegadu_conf_free_list_of_string, NULL);
g_slist_free (contacts_list_start);
g_free (uins);
}
break;
// case GG_EVENT_NOTIFY_DESCR:
case GG_EVENT_NOTIFY:
{
gint i;
g_print ("GG_EVENT_NOTIFY\n");
for (i = 0; e->event.notify[i].uin; i++)
{
gchar *uin_str = g_strdup_printf ("%d", e->event.notify[i].uin);
gint new_status = gnomegadu_gadugadu_from_protocol_status (e->event.notify[i].status);
gnomegadu_userlist_set_model_status (uin_str, new_status, NULL); //tutaj dodac obsluge opisów
g_free (uin_str);
}
}
break;
case GG_EVENT_NOTIFY60:
{
gint i;
g_print ("GG_EVENT_NOTIFY60\n");
for (i = 0; e->event.notify60[i].uin; i++)
{
gchar *descr_utf = NULL;
gchar *uin_str = g_strdup_printf ("%d", e->event.notify60[i].uin);
gint new_status = gnomegadu_gadugadu_from_protocol_status (e->event.notify60[i].status);
if (e->event.notify60[i].descr)
descr_utf =
g_convert (e->event.notify60[i].descr, strlen (e->event.notify60[i].descr), "UTF-8", "WINDOWS-1250", NULL, NULL, NULL);
gnomegadu_userlist_set_model_status (uin_str, new_status, descr_utf);
g_free (uin_str);
}
}
break;
case GG_EVENT_STATUS:
case GG_EVENT_STATUS60:
{
GdkPixbuf *pix = NULL;
gchar *descr_utf = NULL;
gchar *uuid = NULL;
gchar *display = NULL;
gchar *notify_txt = NULL;
gint new_status;
gchar *uin_str = NULL;
if (e->type == GG_EVENT_STATUS)
{
new_status = gnomegadu_gadugadu_from_protocol_status (e->event.status.status);
uin_str = g_strdup_printf ("%d", e->event.status.uin);
if (e->event.status.descr)
descr_utf = g_convert (e->event.status.descr, strlen (e->event.status.descr), "UTF-8", "WINDOWS-1250", NULL, NULL, NULL);
} else {
new_status = gnomegadu_gadugadu_from_protocol_status (e->event.status60.status);
uin_str = g_strdup_printf ("%d", e->event.status60.uin);
if (e->event.status60.descr)
descr_utf = g_convert (e->event.status60.descr, strlen (e->event.status60.descr), "UTF-8", "WINDOWS-1250", NULL, NULL, NULL);
}
gnomegadu_userlist_set_model_status (uin_str, new_status, descr_utf);
uuid = gnomegadu_conf_contact_get_uuid_for_uin(uin_str);
display = gnomegadu_conf_contact_get_display_for_uuid(uuid);
pix = gnomegadu_stock_get_pixbuf (gnomegadu_ui_status_get_icon_name (new_status));
notify_txt = g_strdup_printf("Status: %s\n<span size=\"smaller\" style=\"italic\">%s</span>",gnomegadu_protocol_status_txt(new_status),descr_utf ? descr_utf : "");
gnomegadu_ui_notify_show (display, notify_txt, pix);
g_object_unref (pix);
gnomegadu_tray_blinking(2000);
g_free (notify_txt);
g_free (display);
g_free (uuid);
g_free (uin_str);
}
break;
case GG_EVENT_USERLIST:
{
g_print ("GG_EVENT_USERLIST\n");
if (e->event.userlist.type == GG_USERLIST_GET_REPLY)
{
gint i;
gfloat step;
gchar **split_buf = NULL;
GtkWidget *progress = glade_xml_get_widget (gladexml_import_userlist_progress, "ImportUserlistServerProgress");
GtkWidget *progress_window = glade_xml_get_widget (gladexml_import_userlist_progress, "ImportUserlistServerProgressWindow");
if (!progress_window || !progress)
break;
gchar *buf = e->event.userlist.reply;
if (!buf)
{
gtk_widget_destroy(GTK_WIDGET(progress_window));
GtkDialog *msgdialog = gtk_message_dialog_new_with_markup (NULL, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_INFO, GTK_BUTTONS_CLOSE,
"<span weight=\"bold\"size=\"larger\">Lista jest pusta</span>\n\nLista kontaktów na serwerze jest pusta.");
gtk_dialog_run (GTK_DIALOG (msgdialog));
gtk_widget_destroy (GTK_WIDGET (msgdialog));
break;
}
GConfChangeSet *changeset = gconf_change_set_new();
split_buf = g_strsplit (buf, "\r\n", 2048);
step = 1 / (gfloat)g_strv_length (split_buf);
for (i = 0; i < g_strv_length (split_buf); i++)
{
gdouble percentage = gtk_progress_bar_get_fraction(GTK_PROGRESS_BAR (progress));
if (percentage < 1)
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (progress), percentage + step);
while (g_main_context_pending(NULL))
g_main_context_iteration(NULL,TRUE);
gnomegadu_ui_import_userlist_process_line (split_buf[i], changeset);
if (!gconf_client_commit_change_set(gconf, changeset, TRUE, NULL))
g_printerr("Some error while import");
}
gconf_change_set_unref(changeset);
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (progress), 1);
while (g_main_context_pending(NULL))
g_main_context_iteration(NULL,TRUE);
gtk_widget_destroy(GTK_WIDGET(progress_window));
}
}
break;
case GG_EVENT_MSG:
{
gchar *uin_sender = NULL;
if (e->event.msg.msgclass == GG_CLASS_CHAT)
{
gint i = 0;
uin_sender = g_strdup_printf("%d", e->event.msg.sender);
gchar *txt = g_strdup((gchar *)e->event.msg.message);
gchar *txt_utf = NULL;
GList *list = NULL;
g_print("message from sender: (%s):%s\n",uin_sender,txt);
/* first add sender */
list = g_list_append(list,g_strdup(uin_sender));
if (e->event.msg.recipients_count > 0)
{
gchar *uin_str_2 = NULL;
/* then add recipients */
for (i = 0; i < e->event.msg.recipients_count; i++)
{
uin_str_2 = g_strdup_printf("%d",e->event.msg.recipients[i]);
list = g_list_append(list,g_strdup(uin_str_2));
g_free(uin_str_2);
g_print("conference(%d): %s\n",e->event.msg.recipients_count,uin_str_2);
}
}
g_assert(list);
//chat window
GladeXML *chat_window_xml = gnomegadu_ui_chat_find(list,TRUE);
g_assert(chat_window_xml);
txt_utf = g_convert (txt, strlen (txt), "UTF-8", "WINDOWS-1250", NULL, NULL, NULL);
gnomegadu_ui_chat_append_text(chat_window_xml,txt_utf,GNOMEGADU_CHAT_RCV, uin_sender);
g_free(txt);
g_free(uin_sender);
}
}
break;
}
gg_free_event (e);
if (gnomegadu_gadugadu_session && prev_check != gnomegadu_gadugadu_session->check)
{
prev_check = gnomegadu_gadugadu_session->check;
if (gnomegadu_gadugadu_session->check == GG_CHECK_READ)
{
g_source_remove (gnomegadu_watch_protocol);
gnomegadu_watch_protocol = g_io_add_watch (gnomegadu_source_chan, G_IO_IN | G_IO_ERR | G_IO_HUP, gnomegadu_protocol_loop, NULL);
ret = FALSE;
}
if (gnomegadu_gadugadu_session->check == GG_CHECK_WRITE)
{
g_source_remove (gnomegadu_watch_protocol);
gnomegadu_watch_protocol = g_io_add_watch (gnomegadu_source_chan, G_IO_OUT | G_IO_ERR | G_IO_HUP, gnomegadu_protocol_loop, NULL);
ret = FALSE;
}
}
return ret;
}
int32_t dt_camera_capture_job_run(dt_job_t *job)
{
dt_camera_capture_t *t=(dt_camera_capture_t*)job->param;
int total;
char message[512]= {0};
double fraction=0;
total = t->total = t->brackets ? t->count * t->brackets : t->count;
snprintf(message, 512, ngettext ("capturing %d image", "capturing %d images", total), total );
pthread_mutex_init(&t->mutex, NULL);
pthread_cond_init(&t->done, NULL);
// register listener
dt_camctl_listener_t *listener;
listener = g_malloc(sizeof(dt_camctl_listener_t));
memset(listener, 0, sizeof(dt_camctl_listener_t));
listener->data=t;
listener->image_downloaded=_camera_capture_image_downloaded;
listener->request_image_path=_camera_request_image_path;
listener->request_image_filename=_camera_request_image_filename;
dt_camctl_register_listener(darktable.camctl, listener);
/* try to get exp program mode for nikon */
char *expprogram = (char *)dt_camctl_camera_get_property(darktable.camctl, NULL, "expprogram");
/* if fail, lets try fetching mode for cannon */
if(!expprogram)
expprogram = (char *)dt_camctl_camera_get_property(darktable.camctl, NULL, "autoexposuremode");
/* Fetch all values for shutterspeed and initialize current value */
GList *values=NULL;
gconstpointer original_value=NULL;
const char *cvalue = dt_camctl_camera_get_property(darktable.camctl, NULL, "shutterspeed");
const char *value = dt_camctl_camera_property_get_first_choice(darktable.camctl, NULL, "shutterspeed");
/* get values for bracketing */
if (t->brackets && expprogram && expprogram[0]=='M' && value && cvalue)
{
do
{
// Add value to list
values = g_list_append(values, g_strdup(value));
// Check if current values is the same as original value, then lets store item ptr
if (strcmp(value,cvalue) == 0)
original_value = g_list_last(values)->data;
}
while ((value = dt_camctl_camera_property_get_next_choice(darktable.camctl, NULL, "shutterspeed")) != NULL);
}
else
{
/* if this was an intended bracket capture bail out */
if(t->brackets)
{
dt_control_log(_("please set your camera to manual mode first!"));
return 1;
}
}
/* create the bgjob plate */
const guint *jid = dt_control_backgroundjobs_create(darktable.control, 0, message);
GList *current_value = g_list_find(values,original_value);
for(uint32_t i=0; i<t->count; i++)
{
// Delay if active
if(t->delay)
g_usleep(t->delay*G_USEC_PER_SEC);
for(uint32_t b=0; b<(t->brackets*2)+1; b++)
{
// If bracket capture, lets set change shutterspeed
if (t->brackets)
{
if (b == 0)
{
// First bracket, step down time with (steps*brackets), also check so we never set the longest shuttertime which would be bulb mode
for(uint32_t s=0; s<(t->steps*t->brackets); s++)
if (g_list_next(current_value) && g_list_next(g_list_next(current_value)))
current_value = g_list_next(current_value);
}
else
{
// Step up with (steps)
for(uint32_t s=0; s<t->steps; s++)
if(g_list_previous(current_value))
current_value = g_list_previous(current_value);
}
}
// set the time property for bracket capture
if (t->brackets && current_value)
dt_camctl_camera_set_property_string(darktable.camctl, NULL, "shutterspeed", current_value->data);
// Capture image
dt_camctl_camera_capture(darktable.camctl,NULL);
fraction += 1.0/total;
dt_control_backgroundjobs_progress(darktable.control, jid, fraction);
}
// lets reset to original value before continue
if (t->brackets)
{
current_value = g_list_find(values,original_value);
dt_camctl_camera_set_property_string(darktable.camctl, NULL, "shutterspeed", current_value->data);
}
}
/* wait for last image capture before exiting job */
pthread_mutex_lock(&t->mutex);
pthread_cond_wait(&t->done, &t->mutex);
pthread_mutex_unlock(&t->mutex);
pthread_mutex_destroy(&t->mutex);
pthread_cond_destroy(&t->done);
/* cleanup */
dt_control_backgroundjobs_destroy(darktable.control, jid);
dt_import_session_destroy(t->shared.session);
dt_camctl_unregister_listener(darktable.camctl, listener);
g_free(listener);
// free values
if(values)
{
g_list_free_full(values, g_free);
}
return 0;
}
gboolean
purple_plugin_load(PurplePlugin *plugin)
{
#ifdef PURPLE_PLUGINS
GList *dep_list = NULL;
GList *l;
g_return_val_if_fail(plugin != NULL, FALSE);
if (purple_plugin_is_loaded(plugin))
return TRUE;
if (purple_plugin_is_unloadable(plugin))
return FALSE;
g_return_val_if_fail(plugin->error == NULL, FALSE);
/*
* Go through the list of the plugin's dependencies.
*
* First pass: Make sure all the plugins needed are probed.
*/
for (l = plugin->info->dependencies; l != NULL; l = l->next)
{
const char *dep_name = (const char *)l->data;
PurplePlugin *dep_plugin;
dep_plugin = purple_plugins_find_with_id(dep_name);
if (dep_plugin == NULL)
{
char *tmp;
tmp = g_strdup_printf(_("The required plugin %s was not found. "
"Please install this plugin and try again."),
dep_name);
purple_notify_error(NULL, NULL,
_("Unable to load the plugin"), tmp);
g_free(tmp);
g_list_free(dep_list);
return FALSE;
}
dep_list = g_list_append(dep_list, dep_plugin);
}
/* Second pass: load all the required plugins. */
for (l = dep_list; l != NULL; l = l->next)
{
PurplePlugin *dep_plugin = (PurplePlugin *)l->data;
if (!purple_plugin_is_loaded(dep_plugin))
{
if (!purple_plugin_load(dep_plugin))
{
char *tmp;
tmp = g_strdup_printf(_("The required plugin %s was unable to load."),
plugin->info->name);
purple_notify_error(NULL, NULL,
_("Unable to load your plugin."), tmp);
g_free(tmp);
g_list_free(dep_list);
return FALSE;
}
}
}
/* Third pass: note that other plugins are dependencies of this plugin.
* This is done separately in case we had to bail out earlier. */
for (l = dep_list; l != NULL; l = l->next)
{
PurplePlugin *dep_plugin = (PurplePlugin *)l->data;
dep_plugin->dependent_plugins = g_list_prepend(dep_plugin->dependent_plugins, plugin->info->id);
}
g_list_free(dep_list);
if (plugin->native_plugin)
{
if (plugin->info != NULL && plugin->info->load != NULL)
{
if (!plugin->info->load(plugin))
return FALSE;
}
}
else {
PurplePlugin *loader;
PurplePluginLoaderInfo *loader_info;
loader = find_loader_for_plugin(plugin);
if (loader == NULL)
return FALSE;
loader_info = PURPLE_PLUGIN_LOADER_INFO(loader);
if (loader_info->load != NULL)
{
if (!loader_info->load(plugin))
return FALSE;
}
}
loaded_plugins = g_list_insert_sorted(loaded_plugins, plugin, compare_plugins);
plugin->loaded = TRUE;
if (load_cb != NULL)
load_cb(plugin, load_cb_data);
purple_signal_emit(purple_plugins_get_handle(), "plugin-load", plugin);
return TRUE;
#else
return TRUE;
#endif /* !PURPLE_PLUGINS */
}
static GstFlowReturn
gst_vp8_enc_process (GstVP8Enc * encoder)
{
vpx_codec_iter_t iter = NULL;
const vpx_codec_cx_pkt_t *pkt;
GstBaseVideoEncoder *base_video_encoder;
GstVP8EncCoderHook *hook;
GstVideoFrame *frame;
GstFlowReturn ret = GST_FLOW_OK;
base_video_encoder = GST_BASE_VIDEO_ENCODER (encoder);
pkt = vpx_codec_get_cx_data (&encoder->encoder, &iter);
while (pkt != NULL) {
GstBuffer *buffer;
gboolean invisible;
GST_DEBUG_OBJECT (encoder, "packet %u type %d", (guint) pkt->data.frame.sz,
pkt->kind);
if (pkt->kind == VPX_CODEC_STATS_PKT
&& encoder->multipass_mode == VPX_RC_FIRST_PASS) {
GST_LOG_OBJECT (encoder, "handling STATS packet");
g_byte_array_append (encoder->first_pass_cache_content,
pkt->data.twopass_stats.buf, pkt->data.twopass_stats.sz);
frame = gst_base_video_encoder_get_oldest_frame (base_video_encoder);
if (frame != NULL) {
buffer = gst_buffer_new ();
GST_BUFFER_FLAG_SET (buffer, GST_BUFFER_FLAG_PREROLL);
frame->src_buffer = buffer;
gst_base_video_encoder_finish_frame (base_video_encoder, frame);
}
pkt = vpx_codec_get_cx_data (&encoder->encoder, &iter);
continue;
} else if (pkt->kind != VPX_CODEC_CX_FRAME_PKT) {
GST_LOG_OBJECT (encoder, "non frame pkt: %d", pkt->kind);
pkt = vpx_codec_get_cx_data (&encoder->encoder, &iter);
continue;
}
invisible = (pkt->data.frame.flags & VPX_FRAME_IS_INVISIBLE) != 0;
frame = gst_base_video_encoder_get_oldest_frame (base_video_encoder);
g_assert (frame != NULL);
frame->is_sync_point = (pkt->data.frame.flags & VPX_FRAME_IS_KEY) != 0;
hook = frame->coder_hook;
buffer = gst_buffer_new_and_alloc (pkt->data.frame.sz);
memcpy (GST_BUFFER_DATA (buffer), pkt->data.frame.buf, pkt->data.frame.sz);
if (hook->image)
g_slice_free (vpx_image_t, hook->image);
hook->image = NULL;
if (invisible) {
hook->invisible = g_list_append (hook->invisible, buffer);
} else {
frame->src_buffer = buffer;
ret = gst_base_video_encoder_finish_frame (base_video_encoder, frame);
}
pkt = vpx_codec_get_cx_data (&encoder->encoder, &iter);
}
return ret;
}
static void
recurse_ent_cb(QofInstance *ent, gpointer user_data)
{
GList *ref_list, *i, *j, *ent_list, *child_list;
QofParam *ref_param;
QofInstance *ref_ent, *child_ent;
QofSession *session;
struct recurse_s *store;
gboolean success;
if (user_data == NULL)
{
return;
}
store = (struct recurse_s*)user_data;
session = store->session;
success = store->success;
ref_list = NULL;
child_ent = NULL;
ref_list = g_list_copy(store->ref_list);
if ((!session) || (!ent))
{
return;
}
ent_list = NULL;
child_list = NULL;
i = NULL;
j = NULL;
for (i = ref_list; i != NULL; i = i->next)
{
if (i->data == NULL)
{
continue;
}
ref_param = (QofParam*)i->data;
if (ref_param->param_name == NULL)
{
continue;
}
if (0 == safe_strcmp(ref_param->param_type, QOF_TYPE_COLLECT))
{
QofCollection *col;
col = ref_param->param_getfcn(ent, ref_param);
if (col)
{
qof_collection_foreach(col, recurse_collection_cb, store);
}
continue;
}
ref_ent = QOF_INSTANCE(ref_param->param_getfcn(ent, ref_param));
if ((ref_ent) && (ref_ent->e_type))
{
store->success = qof_instance_copy_to_session(session, ref_ent);
if (store->success)
{
ent_list = g_list_append(ent_list, ref_ent);
}
}
}
for (i = ent_list; i != NULL; i = i->next)
{
if (i->data == NULL)
{
continue;
}
child_ent = QOF_INSTANCE(i->data);
if (child_ent == NULL)
{
continue;
}
ref_list = qof_class_get_referenceList(child_ent->e_type);
for (j = ref_list; j != NULL; j = j->next)
{
if (j->data == NULL)
{
continue;
}
ref_param = (QofParam*)j->data;
ref_ent = ref_param->param_getfcn(child_ent, ref_param);
if (ref_ent != NULL)
{
success = qof_instance_copy_to_session(session, ref_ent);
if (success)
{
child_list = g_list_append(child_list, ref_ent);
}
}
}
}
for (i = child_list; i != NULL; i = i->next)
{
if (i->data == NULL)
{
continue;
}
ref_ent = QOF_INSTANCE(i->data);
if (ref_ent == NULL)
{
continue;
}
ref_list = qof_class_get_referenceList(ref_ent->e_type);
for (j = ref_list; j != NULL; j = j->next)
{
if (j->data == NULL)
{
continue;
}
ref_param = (QofParam*)j->data;
child_ent = ref_param->param_getfcn(ref_ent, ref_param);
if (child_ent != NULL)
{
qof_instance_copy_to_session(session, child_ent);
}
}
}
}
static gboolean
vorbis_dec_sink_event (GstPad * pad, GstEvent * event)
{
gboolean ret = FALSE;
GstVorbisDec *dec;
dec = GST_VORBIS_DEC (gst_pad_get_parent (pad));
GST_LOG_OBJECT (dec, "handling event");
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_EOS:
ret = gst_pad_push_event (dec->srcpad, event);
break;
case GST_EVENT_FLUSH_START:
ret = gst_pad_push_event (dec->srcpad, event);
break;
case GST_EVENT_FLUSH_STOP:
/* here we must clean any state in the decoder */
#ifdef HAVE_VORBIS_SYNTHESIS_RESTART
vorbis_synthesis_restart (&dec->vd);
#endif
gst_vorbis_dec_reset (dec);
ret = gst_pad_push_event (dec->srcpad, event);
break;
case GST_EVENT_NEWSEGMENT:
{
GstFormat format;
gdouble rate, arate;
gint64 start, stop, time;
gboolean update;
gst_event_parse_new_segment_full (event, &update, &rate, &arate, &format,
&start, &stop, &time);
/* we need time for now */
if (format != GST_FORMAT_TIME)
goto newseg_wrong_format;
GST_DEBUG_OBJECT (dec,
"newsegment: update %d, rate %g, arate %g, start %" GST_TIME_FORMAT
", stop %" GST_TIME_FORMAT ", time %" GST_TIME_FORMAT,
update, rate, arate, GST_TIME_ARGS (start), GST_TIME_ARGS (stop),
GST_TIME_ARGS (time));
/* now configure the values */
gst_segment_set_newsegment_full (&dec->segment, update,
rate, arate, format, start, stop, time);
dec->seqnum = gst_event_get_seqnum (event);
if (dec->initialized)
/* and forward */
ret = gst_pad_push_event (dec->srcpad, event);
else {
/* store it to send once we're initialized */
dec->pendingevents = g_list_append (dec->pendingevents, event);
ret = TRUE;
}
break;
}
case GST_EVENT_TAG:
{
if (dec->initialized)
/* and forward */
ret = gst_pad_push_event (dec->srcpad, event);
else {
/* store it to send once we're initialized */
dec->pendingevents = g_list_append (dec->pendingevents, event);
ret = TRUE;
}
break;
}
default:
ret = gst_pad_push_event (dec->srcpad, event);
break;
}
done:
gst_object_unref (dec);
return ret;
/* ERRORS */
newseg_wrong_format:
{
GST_DEBUG_OBJECT (dec, "received non TIME newsegment");
goto done;
}
}
/* launch following the commandline prepared by play_game, playback_game and record_game
then test if the game is launched, detect error and update game status */
void
launch_emulation (MameRomEntry *rom,
const gchar *options)
{
FILE *xmame_pipe;
gchar line [BUFFER_SIZE];
gchar *p, *p2;
gfloat done = 0;
gint nb_loaded = 0;
gint num_roms;
GList *extra_output = NULL;
gboolean error_rom, error_mame; /* Error with the load */
gboolean warning_rom; /* Warning with the load */
ProgressWindow *progress_window;
#ifdef ENABLE_JOYSTICK
gboolean usejoyingui;
joystick_close (joydata);
joydata = NULL;
#endif
g_object_get (rom, "num-roms", &num_roms, NULL);
/* FIXME Progress of loading ROMs is not reported in newer versions of MAME
(e.g. SDLMame), so there is no way of updating a progress window */
progress_window = progress_window_new (TRUE);
progress_window_set_title (progress_window, _("Loading %s:"), mame_rom_entry_get_list_name (rom));
progress_window_show (progress_window);
gtk_widget_hide (MainWindow);
/* need to use printf otherwise, with GMAMEUI_DEBUG, we dont see the complete command line */
GMAMEUI_DEBUG ("Message: running command %s\n", options);
xmame_pipe = popen (options, "r");
GMAMEUI_DEBUG (_("Loading %s:"), mame_rom_entry_get_gamename (rom));
/* Loading */
/* XMAME loads the ROM first and then prepares the display. We watch the
pipe during the ROM loading until we reach "done.", which is XMAME's way
of indicating the ROM has loaded. Errors with particular ROMs are not
displayed until after "done.", which is why we have two clauses looking
for NOT FOUND below */
/* The following are examples of output lines from MAME:
sv02.bin NOT FOUND (SDLMAME)
WARNING: the game might not run correctly. (SDLMAME)
mcu.bin NOT FOUND (NO GOOD DUMP KNOWN) (XMAME)
s92-23c NOT FOUND (XMAME)
ERROR: required files are missing, the game cannot be run.
SDL found mode:720x450x32 (XMAME - SDL)
XMAME generates the following output which can be parsed:
loading rom 0: epr11282.a4
loading rom 1: epr11280.a1
info: sysdep_mixer: using oss plugin
OSD: Info: Ideal mode for this game = 384x225
SVGAlib: Info: Found videomode 640x400x32
svgalib: Failed to initialize mouse
*/
error_rom = error_mame = warning_rom = FALSE;
while (fgets (line, BUFFER_SIZE, xmame_pipe)) {
/* remove the last \n */
for (p = line; (*p && (*p != '\n')); p++);
*p = '\0';
GMAMEUI_DEBUG ("xmame: %s", line);
if (!strncmp (line,"loading", 7)) {
/* Only works with XMAME */
/* xmame: loading rom 16: s92_18.bin */
nb_loaded++;
/*search for the : */
for (p = line; (*p && (*p != ':')); p++);
p = p + 2;
for (p2 = p; (*p2 && (*p2 != '\n')); p2++);
p2 = '\0';
done = (gfloat) (nb_loaded / num_roms);
progress_window_set_value (progress_window, done);
progress_window_set_text (progress_window, p);
} else if (!g_ascii_strncasecmp (line, "Ignoring", 8)) {
/* Ignore any errors starting with 'Ignoring' */
continue;
} else if (g_str_has_suffix (line, "NOT FOUND")) {
/* Catch errors relating to missing ROMs (SDLMAME catches them here) */
error_rom = TRUE;
extra_output = g_list_append (extra_output, g_strdup (line));
} else if (g_str_has_suffix (line, "(NO GOOD DUMP KNOWN)")) {
/* Catch errors relating to best available ROMs (SDLMAME catches them here) */
warning_rom = TRUE;
}
/* XMAME writes "done." to the command line once the ROMs have been
loaded, but before they are checked and before the display is
prepared. SDLMAME doesn't do this */
if (!strncmp (line, "done", 4))
break;
while (gtk_events_pending ()) gtk_main_iteration ();
}
progress_window_destroy (progress_window);
while (gtk_events_pending ()) gtk_main_iteration ();
/* Parse the output and check for errors */
while (fgets (line, BUFFER_SIZE, xmame_pipe)) {
for (p = line; (*p && (*p != '\n')); p++);
*p = '\0';
GMAMEUI_DEBUG ("xmame: %s", line);
if (!strncmp (line, "X Error", 7) || /* X11 mode not found*/
!strncmp (line, "GLERROR", 7) || /* OpenGL initialization errors */
!strncmp (line, "SDL: Unsupported", 16) ||
!strncmp (line, "Unable to start", 15) ||
!strncmp (line, "svgalib: ", 9)) /* XMAME SVGA */
{
GMAMEUI_DEBUG (_("Error with MAME graphics creation: %s"), line);
error_mame = TRUE;
extra_output = g_list_append (extra_output, g_strdup (line));
} else if (g_str_has_suffix (line, "NOT FOUND")) {
/* Catch errors relating to missing ROMs (XMAME catches them here) */
error_rom = TRUE;
extra_output = g_list_append (extra_output, g_strdup (line));
} else if (g_str_has_suffix (line, "(NO GOOD DUMP KNOWN)")) {
/* Catch errors relating to best available ROMs (XMAME catches them here) */
warning_rom = TRUE;
}
}
extra_output = glist_remove_duplicates (extra_output);
pclose (xmame_pipe);
if (error_rom || error_mame) {
/* There was an error during the load. Create a dialog to present the errors */
GtkWidget *dialog;
gchar *title = NULL;
gchar *secmessage = NULL;
if (error_rom) {
title = g_strdup (_("GMAMEUI could not load the ROM"));
secmessage = g_strdup (_("The following ROMs were not found:\n"));
} else if (error_mame) {
title = g_strdup (_("MAME did not start successfully"));
secmessage = g_strdup (_("The following errors were reported:\n"));
}
GMAMEUI_DEBUG ("error during load");
GList *node;
for (node = g_list_first (extra_output); node; node = node->next) {
secmessage = g_strconcat (secmessage, node->data, "\n", NULL);
}
dialog = gmameui_dialog_create (ERROR, NULL, title);
gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
secmessage);
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
g_free (title);
g_free (secmessage);
}
/* Update game information */
mame_rom_entry_rom_played (rom, warning_rom, error_rom);
g_list_foreach (extra_output, (GFunc)g_free, NULL);
g_list_free (extra_output);
gtk_widget_show (MainWindow);
/* Update the ROM with the times played or status if there was any error */
mame_gamelist_view_update_game_in_list (main_gui.displayed_list, rom);
#ifdef ENABLE_JOYSTICK
gchar *joystick_device;
g_object_get (main_gui.gui_prefs,
"usejoyingui", &usejoyingui,
"joystick-name", &joystick_device,
NULL);
if (usejoyingui)
joydata = joystick_new (joystick_device);
g_free (joystick_device);
#endif
}
static void push_to_deferred_queue(problem_info_t *pi)
{
g_deferred_crash_queue = g_list_append(g_deferred_crash_queue, pi);
}
// modified this to have 3 columns so we can display variable type
void FreeVarsWindowInitGtk( )
{
GtkWidget * hboxfreevars[ NBR_FREE_VAR_SPY ], *vboxMain;
char * VarName= NULL;
long ColumnVar;
int NumVarSpy,NumEntry,i=NBR_FREE_VAR_SPY;
GList *DisplayFormatItems = NULL;
SpyFreeVarsWindow = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title ((GtkWindow *)SpyFreeVarsWindow, "Watch Window");
vboxMain = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (SpyFreeVarsWindow), vboxMain);
gtk_widget_show (vboxMain);
DisplayFormatItems = g_list_append(DisplayFormatItems,"Dec");
DisplayFormatItems = g_list_append(DisplayFormatItems,"Hex");
DisplayFormatItems = g_list_append(DisplayFormatItems,"Bin");
if ( NBR_WORDS < NBR_FREE_VAR_SPY) { i=NBR_WORDS ;}
for(NumVarSpy=0; NumVarSpy<i; NumVarSpy++)
{
hboxfreevars[ NumVarSpy ] = gtk_hbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (vboxMain), hboxfreevars[ NumVarSpy ]);
gtk_widget_show (hboxfreevars[ NumVarSpy ]);
for(ColumnVar=0; ColumnVar<3; ColumnVar++)
{
NumEntry = NumVarSpy+ColumnVar*NBR_FREE_VAR_SPY;
if ( ColumnVar==0)
{
LabelFreeVars[NumEntry] = gtk_label_new(NULL);
gtk_widget_set_usize((GtkWidget *)LabelFreeVars[NumEntry],100,0);
gtk_box_pack_start (GTK_BOX (hboxfreevars[ NumVarSpy ]), LabelFreeVars[NumEntry], FALSE, FALSE, 0);
gtk_widget_show (LabelFreeVars[NumEntry]);
}
if ( ColumnVar==1)
{
EntryVarSpy[ NumEntry ] = gtk_entry_new();
gtk_widget_show(EntryVarSpy[NumEntry]);
gtk_box_pack_start (GTK_BOX( hboxfreevars[ NumVarSpy ] ), EntryVarSpy[ NumEntry ], TRUE, TRUE, 0);
gtk_widget_set_usize((GtkWidget *)EntryVarSpy[ NumEntry ],(ColumnVar==1)?80:110,0);
VarName = CreateVarName(VarSpy[NumVarSpy][0],VarSpy[NumVarSpy][1]);
TooltipsEntryVarSpy[ NumVarSpy ] = gtk_tooltips_new();
gtk_entry_set_text((GtkEntry *)EntryVarSpy[ NumEntry ],VarName);
gtk_signal_connect(GTK_OBJECT (EntryVarSpy[ NumEntry ]), "activate",
(GtkSignalFunc) EntryVarSpy_activate_event, (void *)(intptr_t)NumVarSpy);
}
if ( ColumnVar==2)
{
EntryVarSpy[ NumEntry ] = gtk_entry_new();
gtk_widget_show(EntryVarSpy[NumEntry]);
gtk_box_pack_start (GTK_BOX( hboxfreevars[ NumVarSpy ] ), EntryVarSpy[ NumEntry ], TRUE, TRUE, 0);
gtk_widget_set_usize((GtkWidget *)EntryVarSpy[ NumEntry ],(ColumnVar==2)?80:110,0);
}
}
DisplayFormatVarSpy[NumVarSpy] = gtk_combo_new();
gtk_combo_set_value_in_list(GTK_COMBO(DisplayFormatVarSpy[NumVarSpy]), TRUE /*val*/, FALSE /*ok_if_empty*/);
gtk_combo_set_popdown_strings(GTK_COMBO(DisplayFormatVarSpy[NumVarSpy]), DisplayFormatItems);
gtk_widget_set_usize((GtkWidget *)DisplayFormatVarSpy[NumVarSpy],65,0);
gtk_box_pack_start (GTK_BOX(hboxfreevars[ NumVarSpy ]), DisplayFormatVarSpy[NumVarSpy], FALSE, FALSE, 0);
gtk_widget_show(DisplayFormatVarSpy[NumVarSpy]);
}
gtk_signal_connect( GTK_OBJECT(SpyFreeVarsWindow), "delete_event",
(GtkSignalFunc)FreeVarsWindowDeleteEvent, 0 );
}
static gboolean
bus_cb (GstBus *bus, GstMessage *message, RBPlayerGst *mp)
{
const GstStructure *structure;
g_return_val_if_fail (mp != NULL, FALSE);
switch (GST_MESSAGE_TYPE (message)) {
case GST_MESSAGE_ERROR: {
char *debug;
GError *error = NULL;
GError *sig_error = NULL;
int code;
gboolean emit = TRUE;
gst_message_parse_error (message, &error, &debug);
/* If we've already got an error, ignore 'internal data flow error'
* type messages, as they're too generic to be helpful.
*/
if (mp->priv->emitted_error &&
error->domain == GST_STREAM_ERROR &&
error->code == GST_STREAM_ERROR_FAILED) {
rb_debug ("Ignoring generic error \"%s\"", error->message);
emit = FALSE;
}
code = rb_gst_error_get_error_code (error);
if (emit) {
if (message_from_sink (mp->priv->audio_sink, message)) {
rb_debug ("got error from sink: %s (%s)", error->message, debug);
/* Translators: the parameter here is an error message */
g_set_error (&sig_error,
RB_PLAYER_ERROR,
code,
_("Failed to open output device: %s"),
error->message);
} else {
rb_debug ("got error from stream: %s (%s)", error->message, debug);
g_set_error (&sig_error,
RB_PLAYER_ERROR,
code,
"%s",
error->message);
}
state_change_finished (mp, sig_error);
mp->priv->emitted_error = TRUE;
_rb_player_emit_error (RB_PLAYER (mp), mp->priv->stream_data, sig_error);
}
/* close if not already closing */
if (mp->priv->uri != NULL)
rb_player_close (RB_PLAYER (mp), NULL, NULL);
g_error_free (error);
g_free (debug);
break;
}
case GST_MESSAGE_EOS:
_rb_player_emit_eos (RB_PLAYER (mp), mp->priv->stream_data, FALSE);
break;
case GST_MESSAGE_STATE_CHANGED:
{
GstState oldstate;
GstState newstate;
GstState pending;
gst_message_parse_state_changed (message, &oldstate, &newstate, &pending);
if (GST_MESSAGE_SRC (message) == GST_OBJECT (mp->priv->playbin)) {
rb_debug ("playbin reached state %s", gst_element_state_get_name (newstate));
if (pending == GST_STATE_VOID_PENDING) {
state_change_finished (mp, NULL);
}
}
break;
}
case GST_MESSAGE_TAG: {
GstTagList *tags;
gst_message_parse_tag (message, &tags);
if (mp->priv->stream_change_pending || mp->priv->playbin_stream_changing) {
mp->priv->stream_tags = g_list_append (mp->priv->stream_tags, tags);
} else {
gst_tag_list_foreach (tags, (GstTagForeachFunc) process_tag, mp);
gst_tag_list_free (tags);
}
break;
}
case GST_MESSAGE_BUFFERING: {
gint progress;
structure = gst_message_get_structure (message);
if (!gst_structure_get_int (structure, "buffer-percent", &progress)) {
g_warning ("Could not get value from BUFFERING message");
break;
}
if (progress >= 100) {
mp->priv->buffering = FALSE;
if (mp->priv->playing) {
rb_debug ("buffering done, setting pipeline back to PLAYING");
gst_element_set_state (mp->priv->playbin, GST_STATE_PLAYING);
} else {
rb_debug ("buffering done, leaving pipeline PAUSED");
}
} else if (mp->priv->buffering == FALSE && mp->priv->playing) {
GstState cur_state;
gst_element_get_state (mp->priv->playbin, &cur_state, NULL, 0);
if (cur_state == GST_STATE_PLAYING) {
rb_debug ("buffering - temporarily pausing playback");
gst_element_set_state (mp->priv->playbin, GST_STATE_PAUSED);
} else {
rb_debug ("buffering - during preroll; doing nothing");
}
mp->priv->buffering = TRUE;
}
_rb_player_emit_buffering (RB_PLAYER (mp), mp->priv->stream_data, progress);
break;
}
case GST_MESSAGE_APPLICATION:
structure = gst_message_get_structure (message);
_rb_player_emit_event (RB_PLAYER (mp), mp->priv->stream_data, gst_structure_get_name (structure), NULL);
break;
case GST_MESSAGE_ELEMENT:
structure = gst_message_get_structure (message);
if (gst_is_missing_plugin_message (message)) {
handle_missing_plugin_message (mp, message);
} else if (mp->priv->playbin_stream_changing &&
gst_structure_has_name (structure, "playbin2-stream-changed")) {
rb_debug ("got playbin2-stream-changed message");
mp->priv->playbin_stream_changing = FALSE;
emit_playing_stream_and_tags (mp, TRUE);
} else if (gst_structure_has_name (structure, "redirect")) {
const char *uri = gst_structure_get_string (structure, "new-location");
_rb_player_emit_redirect (RB_PLAYER (mp), mp->priv->stream_data, uri);
}
break;
default:
break;
}
/* emit message signals too, so plugins can process messages */
gst_bus_async_signal_func (bus, message, NULL);
return TRUE;
}
/* reads a Atom feed URL and returns a new channel structure (even if
the feed could not be read) */
static void
atom10_parse_feed (feedParserCtxtPtr ctxt, xmlNodePtr cur)
{
NsHandler *nsh;
parseChannelTagFunc pf;
atom10ElementParserFunc func;
static GHashTable *feedElementHash = NULL;
if(!feedElementHash) {
feedElementHash = g_hash_table_new (g_str_hash, g_str_equal);
g_hash_table_insert (feedElementHash, "author", &atom10_parse_feed_author);
g_hash_table_insert (feedElementHash, "category", &atom10_parse_feed_category);
g_hash_table_insert (feedElementHash, "contributor", &atom10_parse_feed_contributor);
g_hash_table_insert (feedElementHash, "generator", &atom10_parse_feed_generator);
g_hash_table_insert (feedElementHash, "icon", &atom10_parse_feed_icon);
g_hash_table_insert (feedElementHash, "id", &atom10_parse_feed_id);
g_hash_table_insert (feedElementHash, "link", &atom10_parse_feed_link);
g_hash_table_insert (feedElementHash, "logo", &atom10_parse_feed_logo);
g_hash_table_insert (feedElementHash, "rights", &atom10_parse_feed_rights);
g_hash_table_insert (feedElementHash, "subtitle", &atom10_parse_feed_subtitle);
g_hash_table_insert (feedElementHash, "title", &atom10_parse_feed_title);
g_hash_table_insert (feedElementHash, "updated", &atom10_parse_feed_updated);
}
while (TRUE) {
if (xmlStrcmp (cur->name, BAD_CAST"feed")) {
g_string_append (ctxt->feed->parseErrors, "<p>Could not find Atom 1.0 header!</p>");
break;
}
/* parse feed contents */
cur = cur->xmlChildrenNode;
while (cur) {
if (!cur->name || cur->type != XML_ELEMENT_NODE || !cur->ns) {
cur = cur->next;
continue;
}
/* check if supported namespace should handle the current tag
by trying to determine a namespace handler */
nsh = NULL;
if (cur->ns->href)
nsh = (NsHandler *)g_hash_table_lookup (ns_atom10_ns_uri_table, (gpointer)cur->ns->href);
if (cur->ns->prefix && !nsh)
nsh = (NsHandler *)g_hash_table_lookup (atom10_nstable, (gpointer)cur->ns->prefix);
if(nsh) {
pf = nsh->parseChannelTag;
if(pf)
(*pf)(ctxt, cur);
cur = cur->next;
continue;
}
/* check namespace of this tag */
if (!cur->ns->href) {
/* This is an invalid feed... no idea what to do with the current element */
debug1 (DEBUG_PARSING, "element with no namespace found in atom feed (%s)!", cur->name);
cur = cur->next;
continue;
}
if (xmlStrcmp (cur->ns->href, ATOM10_NS)) {
debug1 (DEBUG_PARSING, "unknown namespace %s found in atom feed!", cur->ns->href);
cur = cur->next;
continue;
}
/* At this point, the namespace must be the Atom 1.0 namespace */
func = g_hash_table_lookup (feedElementHash, cur->name);
if (func) {
(*func) (cur, ctxt, NULL);
} else if (xmlStrEqual (cur->name, BAD_CAST"entry")) {
ctxt->item = atom10_parse_entry (ctxt, cur);
if (ctxt->item)
ctxt->items = g_list_append (ctxt->items, ctxt->item);
}
cur = cur->next;
}
/* FIXME: Maybe check to see that the required information was actually provided (persuant to the RFC). */
/* after parsing we fill in the infos into the feedPtr structure */
break;
}
}
static AlbumDetails *
make_album_from_release (MbRelease *release)
{
AlbumDetails *album;
char buffer[512];
MbArtist artist;
char *new_title;
int i;
g_assert (release);
album = g_new0 (AlbumDetails, 1);
GET_ID (album->album_id, mb_release_get_id, release);
GET (album->title, mb_release_get_title, release);
new_title = sj_metadata_helper_scan_disc_number (album->title, &album->disc_number);
if (new_title) {
g_free (album->title);
album->title = new_title;
}
artist = mb_release_get_artist (release);
GET_ID (album->artist_id, mb_artist_get_id, artist);
GET (album->artist, mb_artist_get_name, artist);
GET (album->artist_sortname, mb_artist_get_sortname, artist);
if (mb_release_get_num_release_events (release) >= 1) {
MbReleaseEvent event;
char *date = NULL;
event = mb_release_get_release_event (release, 0);
GET (date, mb_release_event_get_date, event);
album->release_date = sj_metadata_helper_scan_date (date);
g_free (date);
}
album->number = mb_release_get_num_tracks (release);
GET (album->asin, mb_release_get_asin, release);
for (i = 0; i < mb_release_get_num_relations (release); i++) {
MbRelation relation;
char *type = NULL;
relation = mb_release_get_relation (release, i);
GET(type, mb_relation_get_type, relation);
if (type && g_str_equal (type, "http://musicbrainz.org/ns/rel-1.0#Wikipedia")) {
GET (album->wikipedia, mb_relation_get_target_id, relation);
} else if (type && g_str_equal (type, "http://musicbrainz.org/ns/rel-1.0#Discogs")) {
GET (album->discogs, mb_relation_get_target_id, relation);
continue;
}
g_free (type);
}
for (i = 0; i < mb_release_get_num_types (release); i++) {
mb_release_get_type (release, i, buffer, sizeof(buffer));
if (g_str_has_suffix (buffer, "#Spokenword")
|| g_str_has_suffix (buffer, "#Interview")
|| g_str_has_suffix (buffer, "#Audiobook")) {
album->is_spoken_word = TRUE;
break;
}
}
for (i = 0; i < album->number; i++) {
MbTrack mbt;
TrackDetails *track;
mbt = mb_release_get_track (release, i);
track = g_new0 (TrackDetails, 1);
track->album = album;
track->number = i + 1;
GET_ID (track->track_id, mb_track_get_id, mbt);
GET (track->title, mb_track_get_title, mbt);
track->duration = mb_track_get_duration (mbt) / 1000;
artist = mb_track_get_artist (mbt);
if (artist == NULL)
artist = mb_release_get_artist (release);
GET_ID (track->artist_id, mb_artist_get_id, artist);
GET (track->artist, mb_artist_get_name, artist);
GET (track->artist_sortname, mb_artist_get_sortname, artist);
album->tracks = g_list_append (album->tracks, track);
}
return album;
}
static gboolean
gimp_session_info_deserialize (GimpConfig *config,
GScanner *scanner,
gint nest_level,
gpointer data)
{
GimpSessionInfo *info = GIMP_SESSION_INFO (config);
GTokenType token;
guint scope_id;
guint old_scope_id;
scope_id = g_type_qname (G_TYPE_FROM_INSTANCE (config));
old_scope_id = g_scanner_set_scope (scanner, scope_id);
g_scanner_scope_add_symbol (scanner, scope_id, "factory-entry",
GINT_TO_POINTER (SESSION_INFO_FACTORY_ENTRY));
g_scanner_scope_add_symbol (scanner, scope_id, "position",
GINT_TO_POINTER (SESSION_INFO_POSITION));
g_scanner_scope_add_symbol (scanner, scope_id, "size",
GINT_TO_POINTER (SESSION_INFO_SIZE));
g_scanner_scope_add_symbol (scanner, scope_id, "monitor",
GINT_TO_POINTER (SESSION_INFO_MONITOR));
g_scanner_scope_add_symbol (scanner, scope_id, "open-on-exit",
GINT_TO_POINTER (SESSION_INFO_OPEN));
g_scanner_scope_add_symbol (scanner, scope_id, "aux-info",
GINT_TO_POINTER (SESSION_INFO_AUX));
g_scanner_scope_add_symbol (scanner, scope_id, "gimp-dock",
GINT_TO_POINTER (SESSION_INFO_GIMP_DOCK));
g_scanner_scope_add_symbol (scanner, scope_id, "gimp-toolbox",
GINT_TO_POINTER (SESSION_INFO_GIMP_TOOLBOX));
/* For sessionrc files from version <= GIMP 2.6 */
g_scanner_scope_add_symbol (scanner, scope_id, "dock",
GINT_TO_POINTER (SESSION_INFO_DOCK));
token = G_TOKEN_LEFT_PAREN;
while (g_scanner_peek_next_token (scanner) == token)
{
token = g_scanner_get_next_token (scanner);
switch (token)
{
case G_TOKEN_LEFT_PAREN:
token = G_TOKEN_SYMBOL;
break;
case G_TOKEN_SYMBOL:
switch (GPOINTER_TO_INT (scanner->value.v_symbol))
{
case SESSION_INFO_FACTORY_ENTRY:
{
gchar *identifier = NULL;
GimpDialogFactoryEntry *entry = NULL;
token = G_TOKEN_STRING;
if (! gimp_scanner_parse_string (scanner, &identifier))
goto error;
entry = gimp_dialog_factory_find_entry (gimp_dialog_factory_get_singleton (),
identifier);
if (! entry)
goto error;
gimp_session_info_set_factory_entry (info, entry);
g_free (identifier);
}
break;
case SESSION_INFO_POSITION:
token = G_TOKEN_INT;
if (! gimp_session_info_parse_offset (scanner,
&info->p->x,
&info->p->right_align))
goto error;
if (! gimp_session_info_parse_offset (scanner,
&info->p->y,
&info->p->bottom_align))
goto error;
break;
case SESSION_INFO_SIZE:
token = G_TOKEN_INT;
if (! gimp_scanner_parse_int (scanner, &info->p->width))
goto error;
if (! gimp_scanner_parse_int (scanner, &info->p->height))
goto error;
break;
case SESSION_INFO_MONITOR:
token = G_TOKEN_INT;
if (! gimp_scanner_parse_int (scanner, &info->p->monitor))
goto error;
break;
case SESSION_INFO_OPEN:
info->p->open = TRUE;
/* the screen number is optional */
if (g_scanner_peek_next_token (scanner) == G_TOKEN_RIGHT_PAREN)
break;
token = G_TOKEN_INT;
if (! gimp_scanner_parse_int (scanner, &info->p->screen))
goto error;
break;
case SESSION_INFO_AUX:
token = gimp_session_info_aux_deserialize (scanner,
&info->p->aux_info);
if (token != G_TOKEN_LEFT_PAREN)
goto error;
break;
case SESSION_INFO_GIMP_TOOLBOX:
case SESSION_INFO_GIMP_DOCK:
case SESSION_INFO_DOCK:
{
GimpSessionInfoDock *dock_info = NULL;
const gchar *dock_type = NULL;
/* Handle old sessionrc:s from versions <= GIMP 2.6 */
if (GPOINTER_TO_INT (scanner->value.v_symbol) == SESSION_INFO_DOCK &&
info->p->factory_entry &&
info->p->factory_entry->identifier &&
strcmp ("gimp-toolbox-window",
info->p->factory_entry->identifier) == 0)
{
dock_type = "gimp-toolbox";
}
else
{
dock_type = ((GPOINTER_TO_INT (scanner->value.v_symbol) ==
SESSION_INFO_GIMP_TOOLBOX) ?
"gimp-toolbox" :
"gimp-dock");
}
g_scanner_set_scope (scanner, scope_id + 1);
token = gimp_session_info_dock_deserialize (scanner, scope_id + 1,
&dock_info,
dock_type);
if (token == G_TOKEN_LEFT_PAREN)
{
g_scanner_set_scope (scanner, scope_id);
info->p->docks = g_list_append (info->p->docks, dock_info);
}
else
goto error;
}
break;
default:
break;
}
token = G_TOKEN_RIGHT_PAREN;
break;
case G_TOKEN_RIGHT_PAREN:
token = G_TOKEN_LEFT_PAREN;
break;
default:
break;
}
}
error:
/* If we don't have docks, assume it is a toolbox dock window from a
* sessionrc file from GIMP <= 2.6 and add a toolbox dock manually
*/
if (! info->p->docks &&
info->p->factory_entry &&
strcmp ("gimp-toolbox-window",
info->p->factory_entry->identifier) == 0)
{
info->p->docks =
g_list_append (info->p->docks,
gimp_session_info_dock_new ("gimp-toolbox"));
}
g_scanner_scope_remove_symbol (scanner, scope_id, "factory-entry");
g_scanner_scope_remove_symbol (scanner, scope_id, "position");
g_scanner_scope_remove_symbol (scanner, scope_id, "size");
g_scanner_scope_remove_symbol (scanner, scope_id, "open-on-exit");
g_scanner_scope_remove_symbol (scanner, scope_id, "aux-info");
g_scanner_scope_remove_symbol (scanner, scope_id, "gimp-dock");
g_scanner_scope_remove_symbol (scanner, scope_id, "gimp-toolbox");
g_scanner_scope_remove_symbol (scanner, scope_id, "dock");
g_scanner_set_scope (scanner, old_scope_id);
return gimp_config_deserialize_return (scanner, token, nest_level);
}
/*
this is reverse process of pack_string_list
*/
GList*
string_list_unpack(const char* packed_str_list, size_t length)
{
GList* list = NULL;
const char* psl = packed_str_list;
const char * maxp= packed_str_list + length;
int len = 0;
while(TRUE){
char* buf;
if (*psl == '\0' || psl >= maxp){
break;
}
if (sscanf( psl, "%d:", &len) <= 0 ){
break;
}
if (len <=0){
cl_log(LOG_ERR, "unpack_string_list:"
"reading len of string error");
if (list){
list_cleanup(list);
}
return NULL;
}
while (*psl != ':' && *psl != '\0' ){
psl++;
}
if (*psl == '\0'){
break;
}
psl++;
buf = cl_malloc(len + 1);
if (buf == NULL){
cl_log(LOG_ERR, "unpack_string_list:"
"unable to allocate buf");
if(list){
list_cleanup(list);
}
return NULL;
}
memcpy(buf, psl, len);
buf[len] = '\0';
list = g_list_append(list, buf);
psl +=len;
if (*psl != ','){
cl_log(LOG_ERR, "unpack_string_list:"
"wrong format, s=%s",packed_str_list);
}
psl++;
}
return list;
}
/*! \brief Delete objects from the selection.
* \par Function Description
* This function deletes the objects selected on the current page of
* toplevel \a w_current.
*
* \param [in] w_current The GschemToplevel object.
*/
void o_delete_selected (GschemToplevel *w_current)
{
TOPLEVEL *toplevel = gschem_toplevel_get_toplevel (w_current);
SELECTION *selection = toplevel->page_current->selection_list;
GList *to_remove;
GList *iter;
OBJECT *obj;
unsigned int locked_num = 0;
g_return_if_fail (o_select_selected (w_current));
to_remove = g_list_copy (geda_list_get_glist (selection));
for (iter = to_remove; iter != NULL; iter = g_list_next (iter)) {
obj = (OBJECT *) iter->data;
if (obj->selectable == FALSE)
locked_num++;
}
if (locked_num > 0) {
GList *non_locked = NULL;
gint resp;
GtkWidget *dialog = gtk_message_dialog_new (NULL,
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_QUESTION, GTK_BUTTONS_NONE,
ngettext ("Delete locked object?", "Delete %u locked objects?",
locked_num), locked_num);
gtk_dialog_add_buttons (GTK_DIALOG (dialog),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_YES, GTK_RESPONSE_YES,
GTK_STOCK_NO, GTK_RESPONSE_NO, NULL);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_NO);
resp = gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
switch (resp) {
case GTK_RESPONSE_YES: /* Remove all */
break;
case GTK_RESPONSE_NO: /* Remove non locked */
for (iter = to_remove; iter != NULL; iter = g_list_next (iter)) {
obj = (OBJECT *) iter->data;
if (obj->selectable == TRUE)
non_locked = g_list_append (non_locked, iter->data);
}
g_list_free (to_remove);
to_remove = non_locked;
break;
default: /* Cancel */
g_list_free (to_remove);
return;
}
}
for (iter = to_remove; iter != NULL; iter = g_list_next (iter)) {
obj = (OBJECT *) iter->data;
o_selection_remove (toplevel, selection, obj);
s_page_remove (toplevel, toplevel->page_current, obj);
}
g_run_hook_object_list (w_current, "%remove-objects-hook", to_remove);
for (iter = to_remove; iter != NULL; iter = g_list_next (iter)) {
obj = (OBJECT *) iter->data;
s_delete_object (toplevel, obj);
}
g_list_free (to_remove);
gschem_toplevel_page_content_changed (w_current, toplevel->page_current);
w_current->inside_action = 0;
o_undo_savestate_old (w_current, UNDO_ALL);
i_update_menus (w_current);
}
int dt_control_key_pressed_override(guint key, guint state)
{
dt_control_accels_t *accels = &darktable.control->accels;
// TODO: if darkroom mode
// did a : vim-style command start?
static GList *autocomplete = NULL;
static char vimkey_input[256];
if(darktable.control->vimkey_cnt)
{
guchar unichar = gdk_keyval_to_unicode(key);
if(key == GDK_KEY_Return)
{
if(!strcmp(darktable.control->vimkey, ":q"))
{
dt_control_quit();
}
else
{
dt_bauhaus_vimkey_exec(darktable.control->vimkey);
}
darktable.control->vimkey[0] = 0;
darktable.control->vimkey_cnt = 0;
dt_control_log_ack_all();
g_list_free(autocomplete);
autocomplete = NULL;
}
else if(key == GDK_KEY_Escape)
{
darktable.control->vimkey[0] = 0;
darktable.control->vimkey_cnt = 0;
dt_control_log_ack_all();
g_list_free(autocomplete);
autocomplete = NULL;
}
else if(key == GDK_KEY_BackSpace)
{
darktable.control->vimkey_cnt
-= (darktable.control->vimkey + darktable.control->vimkey_cnt)
- g_utf8_prev_char(darktable.control->vimkey + darktable.control->vimkey_cnt);
darktable.control->vimkey[darktable.control->vimkey_cnt] = 0;
if(darktable.control->vimkey_cnt == 0)
dt_control_log_ack_all();
else
dt_control_log(darktable.control->vimkey);
g_list_free(autocomplete);
autocomplete = NULL;
}
else if(key == GDK_KEY_Tab)
{
// TODO: also support :preset and :get?
// auto complete:
if(darktable.control->vimkey_cnt < 5)
{
snprintf(darktable.control->vimkey, sizeof(darktable.control->vimkey), ":set ");
darktable.control->vimkey_cnt = 5;
}
else if(!autocomplete)
{
// TODO: handle '.'-separated things separately
// this is a static list, and tab cycles through the list
g_strlcpy(vimkey_input, darktable.control->vimkey + 5, sizeof(vimkey_input));
autocomplete = dt_bauhaus_vimkey_complete(darktable.control->vimkey + 5);
autocomplete = g_list_append(autocomplete, vimkey_input); // remember input to cycle back
}
if(autocomplete)
{
// pop first.
// the paths themselves are owned by bauhaus,
// no free required.
snprintf(darktable.control->vimkey, sizeof(darktable.control->vimkey), ":set %s",
(char *)autocomplete->data);
autocomplete = g_list_remove(autocomplete, autocomplete->data);
darktable.control->vimkey_cnt = strlen(darktable.control->vimkey);
}
dt_control_log(darktable.control->vimkey);
}
else if(g_unichar_isprint(unichar)) // printable unicode character
{
gchar utf8[6];
gint char_width = g_unichar_to_utf8(unichar, utf8);
if(darktable.control->vimkey_cnt + 1 + char_width < 256)
{
g_utf8_strncpy(darktable.control->vimkey + darktable.control->vimkey_cnt, utf8, 1);
darktable.control->vimkey_cnt += char_width;
darktable.control->vimkey[darktable.control->vimkey_cnt] = 0;
dt_control_log(darktable.control->vimkey);
g_list_free(autocomplete);
autocomplete = NULL;
}
}
else if(key == GDK_KEY_Up)
{
// TODO: step history up and copy to vimkey
}
else if(key == GDK_KEY_Down)
{
// TODO: step history down and copy to vimkey
}
return 1;
}
else if(key == ':' && darktable.control->key_accelerators_on)
{
darktable.control->vimkey[0] = ':';
darktable.control->vimkey[1] = 0;
darktable.control->vimkey_cnt = 1;
dt_control_log(darktable.control->vimkey);
return 1;
}
/* check if key accelerators are enabled*/
if(darktable.control->key_accelerators_on != 1) return 0;
if(key == accels->global_sideborders.accel_key && state == accels->global_sideborders.accel_mods)
{
/* toggle panel viewstate */
dt_ui_toggle_panels_visibility(darktable.gui->ui);
/* trigger invalidation of centerview to reprocess pipe */
dt_dev_invalidate(darktable.develop);
gtk_widget_queue_draw(dt_ui_center(darktable.gui->ui));
return 1;
}
else if(key == accels->global_header.accel_key && state == accels->global_header.accel_mods)
{
char key[512];
const dt_view_t *cv = dt_view_manager_get_current_view(darktable.view_manager);
/* do nothing if in collapse panel state
TODO: reconsider adding this check to ui api */
g_snprintf(key, sizeof(key), "%s/ui/panel_collaps_state", cv->module_name);
if(dt_conf_get_int(key)) return 0;
/* toggle the header visibility state */
g_snprintf(key, sizeof(key), "%s/ui/show_header", cv->module_name);
gboolean header = !dt_conf_get_bool(key);
dt_conf_set_bool(key, header);
/* show/hide the actual header panel */
dt_ui_panel_show(darktable.gui->ui, DT_UI_PANEL_TOP, header, TRUE);
gtk_widget_queue_draw(dt_ui_center(darktable.gui->ui));
return 1;
}
return 0;
}
/******************************************************
* gst_v4l2_empty_lists() and gst_v4l2_fill_lists():
* fill/empty the lists of enumerations
* return value: TRUE on success, FALSE on error
******************************************************/
static gboolean
gst_v4l2_fill_lists (GstV4l2Object * v4l2object)
{
gint n;
GstElement *e;
e = v4l2object->element;
GST_DEBUG_OBJECT (e, "getting enumerations");
GST_V4L2_CHECK_OPEN (v4l2object);
GST_DEBUG_OBJECT (e, " channels");
/* and now, the channels */
for (n = 0;; n++) {
struct v4l2_input input;
GstV4l2TunerChannel *v4l2channel;
GstTunerChannel *channel;
memset (&input, 0, sizeof (input));
input.index = n;
if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_ENUMINPUT, &input) < 0) {
if (errno == EINVAL || errno == ENOTTY)
break; /* end of enumeration */
else {
GST_ELEMENT_ERROR (e, RESOURCE, SETTINGS,
(_("Failed to query attributes of input %d in device %s"),
n, v4l2object->videodev),
("Failed to get %d in input enumeration for %s. (%d - %s)",
n, v4l2object->videodev, errno, strerror (errno)));
return FALSE;
}
}
GST_LOG_OBJECT (e, " index: %d", input.index);
GST_LOG_OBJECT (e, " name: '%s'", input.name);
GST_LOG_OBJECT (e, " type: %08x", input.type);
GST_LOG_OBJECT (e, " audioset: %08x", input.audioset);
GST_LOG_OBJECT (e, " std: %016" G_GINT64_MODIFIER "x", input.std);
GST_LOG_OBJECT (e, " status: %08x", input.status);
v4l2channel = g_object_new (GST_TYPE_V4L2_TUNER_CHANNEL, NULL);
channel = GST_TUNER_CHANNEL (v4l2channel);
channel->label = g_strdup ((const gchar *) input.name);
channel->flags = GST_TUNER_CHANNEL_INPUT;
v4l2channel->index = n;
if (input.type == V4L2_INPUT_TYPE_TUNER) {
struct v4l2_tuner vtun;
v4l2channel->tuner = input.tuner;
channel->flags |= GST_TUNER_CHANNEL_FREQUENCY;
vtun.index = input.tuner;
if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_G_TUNER, &vtun) < 0) {
GST_ELEMENT_ERROR (e, RESOURCE, SETTINGS,
(_("Failed to get setting of tuner %d on device '%s'."),
input.tuner, v4l2object->videodev), GST_ERROR_SYSTEM);
g_object_unref (G_OBJECT (channel));
return FALSE;
}
channel->freq_multiplicator =
62.5 * ((vtun.capability & V4L2_TUNER_CAP_LOW) ? 1 : 1000);
channel->min_frequency = vtun.rangelow * channel->freq_multiplicator;
channel->max_frequency = vtun.rangehigh * channel->freq_multiplicator;
channel->min_signal = 0;
channel->max_signal = 0xffff;
}
if (input.audioset) {
/* we take the first. We don't care for
* the others for now */
while (!(input.audioset & (1 << v4l2channel->audio)))
v4l2channel->audio++;
channel->flags |= GST_TUNER_CHANNEL_AUDIO;
}
v4l2object->channels =
g_list_prepend (v4l2object->channels, (gpointer) channel);
}
v4l2object->channels = g_list_reverse (v4l2object->channels);
GST_DEBUG_OBJECT (e, " norms");
/* norms... */
for (n = 0;; n++) {
struct v4l2_standard standard = { 0, };
GstV4l2TunerNorm *v4l2norm;
GstTunerNorm *norm;
/* fill in defaults */
standard.frameperiod.numerator = 1;
standard.frameperiod.denominator = 0;
standard.index = n;
if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_ENUMSTD, &standard) < 0) {
if (errno == EINVAL || errno == ENOTTY)
break; /* end of enumeration */
else {
GST_ELEMENT_ERROR (e, RESOURCE, SETTINGS,
(_("Failed to query norm on device '%s'."),
v4l2object->videodev),
("Failed to get attributes for norm %d on devide '%s'. (%d - %s)",
n, v4l2object->videodev, errno, strerror (errno)));
return FALSE;
}
}
GST_DEBUG_OBJECT (e, " '%s', fps: %d / %d",
standard.name, standard.frameperiod.denominator,
standard.frameperiod.numerator);
v4l2norm = g_object_new (GST_TYPE_V4L2_TUNER_NORM, NULL);
norm = GST_TUNER_NORM (v4l2norm);
norm->label = g_strdup ((const gchar *) standard.name);
gst_value_set_fraction (&norm->framerate,
standard.frameperiod.denominator, standard.frameperiod.numerator);
v4l2norm->index = standard.id;
GST_DEBUG_OBJECT (v4l2object->element, "index=%08x, label=%s",
(unsigned int) v4l2norm->index, norm->label);
v4l2object->norms = g_list_prepend (v4l2object->norms, (gpointer) norm);
}
v4l2object->norms = g_list_reverse (v4l2object->norms);
GST_DEBUG_OBJECT (e, " controls+menus");
/* and lastly, controls+menus (if appropriate) */
for (n = V4L2_CID_BASE;; n++) {
struct v4l2_queryctrl control = { 0, };
GstV4l2ColorBalanceChannel *v4l2channel;
GstColorBalanceChannel *channel;
/* when we reached the last official CID, continue with private CIDs */
if (n == V4L2_CID_LASTP1) {
GST_DEBUG_OBJECT (e, "checking private CIDs");
n = V4L2_CID_PRIVATE_BASE;
}
GST_DEBUG_OBJECT (e, "checking control %08x", n);
control.id = n;
if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_QUERYCTRL, &control) < 0) {
if (errno == EINVAL || errno == ENOTTY || errno == EIO || errno == ENOENT) {
if (n < V4L2_CID_PRIVATE_BASE) {
GST_DEBUG_OBJECT (e, "skipping control %08x", n);
/* continue so that we also check private controls */
continue;
} else {
GST_DEBUG_OBJECT (e, "controls finished");
break;
}
} else {
GST_WARNING_OBJECT (e, "Failed querying control %d on device '%s'. "
"(%d - %s)", n, v4l2object->videodev, errno, strerror (errno));
continue;
}
}
if (control.flags & V4L2_CTRL_FLAG_DISABLED) {
GST_DEBUG_OBJECT (e, "skipping disabled control");
continue;
}
switch (n) {
case V4L2_CID_BRIGHTNESS:
case V4L2_CID_CONTRAST:
case V4L2_CID_SATURATION:
case V4L2_CID_HUE:
case V4L2_CID_BLACK_LEVEL:
case V4L2_CID_AUTO_WHITE_BALANCE:
case V4L2_CID_DO_WHITE_BALANCE:
case V4L2_CID_RED_BALANCE:
case V4L2_CID_BLUE_BALANCE:
case V4L2_CID_GAMMA:
case V4L2_CID_EXPOSURE:
case V4L2_CID_AUTOGAIN:
case V4L2_CID_GAIN:
#ifdef V4L2_CID_SHARPNESS
case V4L2_CID_SHARPNESS:
#endif
/* we only handle these for now (why?) */
break;
case V4L2_CID_HFLIP:
case V4L2_CID_VFLIP:
#ifndef V4L2_CID_PAN_RESET
case V4L2_CID_HCENTER:
#endif
#ifndef V4L2_CID_TILT_RESET
case V4L2_CID_VCENTER:
#endif
#ifdef V4L2_CID_PAN_RESET
case V4L2_CID_PAN_RESET:
#endif
#ifdef V4L2_CID_TILT_RESET
case V4L2_CID_TILT_RESET:
#endif
/* not handled here, handled by VideoOrientation interface */
control.id++;
break;
case V4L2_CID_AUDIO_VOLUME:
case V4L2_CID_AUDIO_BALANCE:
case V4L2_CID_AUDIO_BASS:
case V4L2_CID_AUDIO_TREBLE:
case V4L2_CID_AUDIO_MUTE:
case V4L2_CID_AUDIO_LOUDNESS:
/* FIXME: We should implement GstMixer interface */
/* fall through */
default:
GST_DEBUG_OBJECT (e,
"ControlID %s (%x) unhandled, FIXME", control.name, n);
control.id++;
break;
}
if (n != control.id)
continue;
GST_DEBUG_OBJECT (e, "Adding ControlID %s (%x)", control.name, n);
v4l2channel = g_object_new (GST_TYPE_V4L2_COLOR_BALANCE_CHANNEL, NULL);
channel = GST_COLOR_BALANCE_CHANNEL (v4l2channel);
channel->label = g_strdup ((const gchar *) control.name);
v4l2channel->id = n;
#if 0
/* FIXME: it will be need just when handling private controls
*(currently none of base controls are of this type) */
if (control.type == V4L2_CTRL_TYPE_MENU) {
struct v4l2_querymenu menu, *mptr;
int i;
menu.id = n;
for (i = 0;; i++) {
menu.index = i;
if (v4l2_ioctl (v4l2object->video_fd, VIDIOC_QUERYMENU, &menu) < 0) {
if (errno == EINVAL)
break; /* end of enumeration */
else {
GST_ELEMENT_ERROR (e, RESOURCE, SETTINGS,
(_("Failed getting controls attributes on device '%s'."),
v4l2object->videodev),
("Failed to get %d in menu enumeration for %s. (%d - %s)",
n, v4l2object->videodev, errno, strerror (errno)));
return FALSE;
}
}
mptr = g_malloc (sizeof (menu));
memcpy (mptr, &menu, sizeof (menu));
menus = g_list_append (menus, mptr);
}
}
v4l2object->menus = g_list_append (v4l2object->menus, menus);
#endif
switch (control.type) {
case V4L2_CTRL_TYPE_INTEGER:
channel->min_value = control.minimum;
channel->max_value = control.maximum;
break;
case V4L2_CTRL_TYPE_BOOLEAN:
channel->min_value = FALSE;
channel->max_value = TRUE;
break;
default:
/* FIXME we should find out how to handle V4L2_CTRL_TYPE_BUTTON.
BUTTON controls like V4L2_CID_DO_WHITE_BALANCE can just be set (1) or
unset (0), but can't be queried */
GST_DEBUG_OBJECT (e,
"Control with non supported type %s (%x), type=%d",
control.name, n, control.type);
channel->min_value = channel->max_value = 0;
break;
}
v4l2object->colors =
g_list_prepend (v4l2object->colors, (gpointer) channel);
}
v4l2object->colors = g_list_reverse (v4l2object->colors);
GST_DEBUG_OBJECT (e, "done");
return TRUE;
}
GList *silcpurple_buddy_menu(PurpleBuddy *buddy)
{
PurpleConnection *gc = purple_account_get_connection(buddy->account);
SilcPurple sg = gc->proto_data;
SilcClientConnection conn = sg->conn;
const char *pkfile = NULL;
SilcClientEntry client_entry = NULL;
PurpleMenuAction *act;
GList *m = NULL;
SilcPurpleBuddyWb wb;
pkfile = purple_blist_node_get_string((PurpleBlistNode *) buddy, "public-key");
client_entry = silc_client_get_client_by_id(sg->client,
sg->conn,
buddy->proto_data);
if (client_entry && client_entry->send_key) {
act = purple_menu_action_new(_("Reset IM Key"),
PURPLE_CALLBACK(silcpurple_buddy_resetkey),
NULL, NULL);
m = g_list_append(m, act);
} else {
act = purple_menu_action_new(_("IM with Key Exchange"),
PURPLE_CALLBACK(silcpurple_buddy_keyagr),
NULL, NULL);
m = g_list_append(m, act);
act = purple_menu_action_new(_("IM with Password"),
PURPLE_CALLBACK(silcpurple_buddy_privkey_menu),
NULL, NULL);
m = g_list_append(m, act);
}
if (pkfile) {
act = purple_menu_action_new(_("Show Public Key"),
PURPLE_CALLBACK(silcpurple_buddy_showkey),
NULL, NULL);
m = g_list_append(m, act);
} else {
act = purple_menu_action_new(_("Get Public Key..."),
PURPLE_CALLBACK(silcpurple_buddy_getkey_menu),
NULL, NULL);
m = g_list_append(m, act);
}
if (conn && conn->local_entry->mode & SILC_UMODE_ROUTER_OPERATOR) {
act = purple_menu_action_new(_("Kill User"),
PURPLE_CALLBACK(silcpurple_buddy_kill),
NULL, NULL);
m = g_list_append(m, act);
}
if (client_entry) {
wb = silc_calloc(1, sizeof(*wb));
wb->sg = sg;
wb->client_entry = client_entry;
act = purple_menu_action_new(_("Draw On Whiteboard"),
PURPLE_CALLBACK(silcpurple_buddy_wb),
(void *)wb, NULL);
m = g_list_append(m, act);
}
return m;
}
static void
value_filename_edited (GtkCellRendererText * cell,
const gchar * path,
const gchar * new_text, GladeEditorProperty * eprop)
{
GladeEPropIconSources *eprop_sources = GLADE_EPROP_ICON_SOURCES (eprop);
GladeProperty *property = glade_editor_property_get_property (eprop);
GtkTreeIter iter;
GladeIconSources *icon_sources = NULL;
GtkIconSource *source;
gchar *icon_name;
gint index = -1;
GValue *value;
GdkPixbuf *pixbuf;
GList *source_list;
if (!new_text || !new_text[0])
{
g_idle_add ((GSourceFunc) reload_icon_sources_idle, eprop);
return;
}
if (!gtk_tree_model_get_iter_from_string
(GTK_TREE_MODEL (eprop_sources->store), &iter, path))
return;
gtk_tree_model_get (GTK_TREE_MODEL (eprop_sources->store), &iter,
COLUMN_ICON_NAME, &icon_name,
COLUMN_LIST_INDEX, &index, -1);
/* get new pixbuf value... */
value = glade_utils_value_from_string (GDK_TYPE_PIXBUF, new_text,
glade_widget_get_project (glade_property_get_widget (property)));
pixbuf = g_value_get_object (value);
glade_property_get (property, &icon_sources);
if (icon_sources)
{
icon_sources = glade_icon_sources_copy (icon_sources);
if (index >= 0 &&
(source = get_icon_source (icon_sources, icon_name, index)) != NULL)
gtk_icon_source_set_pixbuf (source, pixbuf);
else
{
source = gtk_icon_source_new ();
gtk_icon_source_set_pixbuf (source, pixbuf);
if ((source_list = g_hash_table_lookup (icon_sources->sources,
icon_name)) != NULL)
{
source_list = g_list_append (source_list, source);
}
else
{
source_list = g_list_prepend (NULL, source);
g_hash_table_insert (icon_sources->sources, g_strdup (icon_name),
source_list);
}
}
}
else
{
icon_sources = glade_icon_sources_new ();
source = gtk_icon_source_new ();
gtk_icon_source_set_pixbuf (source, pixbuf);
source_list = g_list_prepend (NULL, source);
g_hash_table_insert (icon_sources->sources, g_strdup (icon_name),
source_list);
}
g_value_unset (value);
g_free (value);
update_icon_sources (eprop, icon_sources);
}
