/**
* ags_port_selection_load_ports:
* @selection:
*
*
*/
void
ags_port_selection_load_ports(AgsPortSelection *selection)
{
AgsAutomationEditor *automation_editor;
AgsMachine *machine;
AgsAudio *audio;
GtkMenu *menu;
GtkMenuItem *item;
AgsChannel *channel;
GList *port;
auto GList* ags_port_selection_list_ports(GType type);
GList* ags_port_selection_list_ports(GType type){
GList *pad, *pad_start;
GList *line, *line_start;
GList *line_member, *line_member_start;
GList *port;
pad_start =
pad = gtk_container_get_children(((type == AGS_TYPE_OUTPUT) ? machine->output: machine->input));
port = NULL;
while(pad != NULL){
line_start =
line = gtk_container_get_children(AGS_PAD(pad->data)->expander_set);
while(line != NULL){
channel = AGS_LINE(line->data)->channel;
line_member_start =
line_member = gtk_container_get_children(AGS_LINE(line->data)->expander->table);
while(line_member != NULL){
if(AGS_IS_LINE_MEMBER(line_member->data)){
/* fill list */
port = g_list_prepend(port,
AGS_LINE_MEMBER(line_member->data)->port);
/* add menu item */
item = gtk_check_menu_item_new_with_label(g_strdup_printf("[%d] %s: %s\0",
channel->line,
AGS_PORT(port->data)->plugin_name,
AGS_PORT(port->data)->specifier));
g_object_set_data(G_OBJECT(item),
AGS_PORT_SELECTION_DATA_CHANNEL,
channel);
g_object_set_data(G_OBJECT(item),
AGS_PORT_SELECTION_DATA_PORT,
port->data);
gtk_menu_shell_append(GTK_MENU_SHELL(menu),
GTK_WIDGET(item));
g_signal_connect(item, "toggled\0",
G_CALLBACK(ags_port_selection_ports_toggled_callback), selection);
}
line_member = line_member->next;
}
g_list_free(line_member_start);
line = line->next;
}
g_list_free(line_start);
pad = pad->next;
}
g_list_free(pad_start);
port = g_list_reverse(port);
return(port);
}
static void
glade_gtk_table_set_n_common (GObject *object,
const GValue *value,
gboolean for_rows)
{
GladeWidget *widget;
GtkTable *table;
guint new_size, old_size, n_columns, n_rows;
table = GTK_TABLE (object);
g_object_get (table, "n-columns", &n_columns, "n-rows", &n_rows, NULL);
new_size = g_value_get_uint (value);
old_size = for_rows ? n_rows : n_columns;
if (new_size < 1)
return;
if (glade_gtk_table_widget_exceeds_bounds
(table, for_rows ? new_size : n_rows, for_rows ? n_columns : new_size))
/* Refuse to shrink if it means orphaning widgets */
return;
widget = glade_widget_get_from_gobject (GTK_WIDGET (table));
g_return_if_fail (widget != NULL);
G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
if (for_rows)
gtk_table_resize (table, new_size, n_columns);
else
gtk_table_resize (table, n_rows, new_size);
G_GNUC_END_IGNORE_DEPRECATIONS;
/* Fill table with placeholders */
glade_gtk_table_refresh_placeholders (table);
if (new_size < old_size)
{
/* Remove from the bottom up */
GList *list, *children;
GList *list_to_free = NULL;
children = gtk_container_get_children (GTK_CONTAINER (table));
for (list = children; list && list->data; list = list->next)
{
GtkTableChild child;
guint start, end;
glade_gtk_table_get_child_attachments (GTK_WIDGET (table),
GTK_WIDGET (list->data),
&child);
start = for_rows ? child.top_attach : child.left_attach;
end = for_rows ? child.bottom_attach : child.right_attach;
/* We need to completely remove it */
if (start >= new_size)
{
list_to_free = g_list_prepend (list_to_free, child.widget);
continue;
}
/* If the widget spans beyond the new border,
* we should resize it to fit on the new table */
if (end > new_size)
gtk_container_child_set
(GTK_CONTAINER (table), GTK_WIDGET (child.widget),
for_rows ? "bottom_attach" : "right_attach", new_size, NULL);
}
g_list_free (children);
if (list_to_free)
{
for (list = g_list_first (list_to_free);
list && list->data; list = list->next)
{
g_object_ref (G_OBJECT (list->data));
gtk_container_remove (GTK_CONTAINER (table),
GTK_WIDGET (list->data));
/* This placeholder is no longer valid, force destroy */
gtk_widget_destroy (GTK_WIDGET (list->data));
}
g_list_free (list_to_free);
}
G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
gtk_table_resize (table,
for_rows ? new_size : n_rows,
for_rows ? n_columns : new_size);
G_GNUC_END_IGNORE_DEPRECATIONS;
}
}
gchar * ggp_message_format_to_gg(PurpleConversation *conv, const gchar *text)
{
gchar *text_new, *tmp;
GList *rt = NULL; /* reformatted text */
GMatchInfo *match;
guint pos = 0;
GList *pending_objects = NULL;
GList *font_stack = NULL;
static int html_sizes_pt[7] = { 7, 8, 9, 10, 12, 14, 16 };
ggp_font *font_new, *font_current, *font_base;
gboolean font_changed = FALSE;
gboolean in_any_tag = FALSE;
/* TODO: verbose
* purple_debug_info("gg", "ggp formatting text: [%s]\n", text);
*/
/* default font */
font_base = ggp_font_new();
font_current = ggp_font_new();
font_new = ggp_font_new();
/* GG11 doesn't use nbsp, it just print spaces */
text_new = purple_strreplace(text, " ", " ");
/* add end-of-message tag */
if (strstr(text_new, "<eom>") != NULL) {
tmp = text_new;
text_new = purple_strreplace(text_new, "<eom>", "");
g_free(tmp);
purple_debug_warning("gg", "ggp_message_format_to_gg: "
"unexpected <eom> tag\n");
}
tmp = text_new;
text_new = g_strdup_printf("%s<eom></eom>", text_new);
g_free(tmp);
g_regex_match(global_data.re_html_tag, text_new, 0, &match);
while (g_match_info_matches(match)) {
int m_start, m_end, m_pos;
gboolean tag_close;
gchar *tag_str, *attribs_str;
ggp_html_tag tag;
gboolean text_before;
/* reading tag and its contents */
g_match_info_fetch_pos(match, 0, &m_start, &m_end);
g_assert(m_start >= 0 && m_end >= 0);
text_before = ((guint)m_start > pos);
g_match_info_fetch_pos(match, 1, &m_pos, NULL);
tag_close = (m_pos >= 0);
tag_str = g_match_info_fetch(match, 2);
tag = ggp_html_parse_tag(tag_str);
attribs_str = g_match_info_fetch(match, 3);
g_match_info_next(match, NULL);
if (tag == GGP_HTML_TAG_UNKNOWN) {
purple_debug_warning("gg", "ggp_message_format_to_gg: "
"uknown tag %s\n", tag_str);
}
/* closing *all* formatting-related tags (GG11 weirness)
* and adding pending objects */
if ((text_before && (font_changed || pending_objects)) ||
(tag == GGP_HTML_TAG_EOM && tag_close))
{
font_changed = FALSE;
if (in_any_tag) {
in_any_tag = FALSE;
if (font_current->s && !GGP_GG11_FORCE_COMPAT)
rt = g_list_prepend(rt,
g_strdup("</s>"));
if (font_current->u)
rt = g_list_prepend(rt,
g_strdup("</u>"));
if (font_current->i)
rt = g_list_prepend(rt,
g_strdup("</i>"));
if (font_current->b)
rt = g_list_prepend(rt,
g_strdup("</b>"));
rt = g_list_prepend(rt, g_strdup("</span>"));
}
if (pending_objects) {
rt = g_list_concat(pending_objects, rt);
pending_objects = NULL;
}
}
/* opening formatting-related tags again */
if (text_before && !in_any_tag) {
gchar *style;
GList *styles = NULL;
gboolean has_size = (font_new->size > 0 &&
font_new->size <= 7 && font_new->size != 3);
if (has_size)
styles = g_list_append(styles, g_strdup_printf(
"font-size:%dpt;",
html_sizes_pt[font_new->size - 1]));
if (font_new->face)
styles = g_list_append(styles, g_strdup_printf(
"font-family:%s;", font_new->face));
if (font_new->bgcolor >= 0 && !GGP_GG11_FORCE_COMPAT)
styles = g_list_append(styles, g_strdup_printf(
"background-color:#%06x;",
font_new->bgcolor));
if (font_new->color >= 0)
styles = g_list_append(styles, g_strdup_printf(
"color:#%06x;", font_new->color));
if (styles) {
gchar *combined = ggp_strjoin_list(" ", styles);
g_list_free_full(styles, g_free);
style = g_strdup_printf(" style=\"%s\"",
combined);
g_free(combined);
} else
style = g_strdup("");
rt = g_list_prepend(rt, g_strdup_printf("<span%s>",
style));
g_free(style);
if (font_new->b)
rt = g_list_prepend(rt, g_strdup("<b>"));
if (font_new->i)
rt = g_list_prepend(rt, g_strdup("<i>"));
if (font_new->u)
rt = g_list_prepend(rt, g_strdup("<u>"));
if (font_new->s && !GGP_GG11_FORCE_COMPAT)
rt = g_list_prepend(rt, g_strdup("<s>"));
ggp_font_free(font_current);
font_current = font_new;
font_new = ggp_font_clone(font_current);
in_any_tag = TRUE;
}
if (text_before) {
rt = g_list_prepend(rt,
g_strndup(text_new + pos, m_start - pos));
}
/* set formatting of a following text */
if (tag == GGP_HTML_TAG_B) {
font_changed |= (font_new->b != !tag_close);
font_new->b = !tag_close;
} else if (tag == GGP_HTML_TAG_I) {
font_changed |= (font_new->i != !tag_close);
font_new->i = !tag_close;
} else if (tag == GGP_HTML_TAG_U) {
font_changed |= (font_new->u != !tag_close);
font_new->u = !tag_close;
} else if (tag == GGP_HTML_TAG_S) {
font_changed |= (font_new->s != !tag_close);
font_new->s = !tag_close;
} else if (tag == GGP_HTML_TAG_IMG && !tag_close) {
GHashTable *attribs = ggp_html_tag_attribs(attribs_str);
gchar *val = NULL;
uint64_t id;
int stored_id = -1;
ggp_image_prepare_result res = -1;
if ((val = g_hash_table_lookup(attribs, "src")) != NULL
&& g_str_has_prefix(val,
PURPLE_STORED_IMAGE_PROTOCOL))
{
val += strlen(PURPLE_STORED_IMAGE_PROTOCOL);
if (sscanf(val, "%u", &stored_id) != 1)
stored_id = -1;
}
if (stored_id >= 0)
res = ggp_image_prepare(conv, stored_id, &id);
if (res == GGP_IMAGE_PREPARE_OK) {
pending_objects = g_list_prepend(
pending_objects, g_strdup_printf(
"<img name=\"" GGP_IMAGE_ID_FORMAT
"\">", id));
} else if (res == GGP_IMAGE_PREPARE_TOO_BIG) {
purple_conversation_write(conv, "",
_("Image is too large, please try "
"smaller one."), PURPLE_MESSAGE_ERROR,
time(NULL));
} else {
purple_conversation_write(conv, "",
_("Image cannot be sent."),
PURPLE_MESSAGE_ERROR, time(NULL));
}
g_hash_table_destroy(attribs);
} else if (tag == GGP_HTML_TAG_FONT && !tag_close) {
GHashTable *attribs = ggp_html_tag_attribs(attribs_str);
gchar *val = NULL;
font_stack = g_list_prepend(font_stack,
ggp_font_clone(font_new));
if ((val = g_hash_table_lookup(attribs, "size")) != NULL
&& val[0] >= '1' && val[0] <= '7' &&
val[1] == '\0')
{
int size = val[0] - '0';
font_changed |= (font_new->size != size);
font_new->size = size;
}
if ((val = g_hash_table_lookup(attribs, "face"))
!= NULL)
{
font_changed |=
(g_strcmp0(font_new->face, val) != 0);
g_free(font_new->face);
font_new->face = g_strdup(val);
}
if ((val = g_hash_table_lookup(attribs, "color"))
!= NULL && val[0] == '#' && strlen(val) == 7)
{
int color = ggp_html_decode_color(val);
font_changed |= (font_new->color != color);
font_new->color = color;
}
g_hash_table_destroy(attribs);
}
else if ((tag == GGP_HTML_TAG_SPAN || tag == GGP_HTML_TAG_DIV)
&& !tag_close)
{
GHashTable *attribs, *styles = NULL;
gchar *style = NULL;
gchar *val = NULL;
attribs = ggp_html_tag_attribs(attribs_str);
font_stack = g_list_prepend(font_stack,
ggp_font_clone(font_new));
if (tag == GGP_HTML_TAG_DIV)
pending_objects = g_list_prepend(
pending_objects, g_strdup("<br>"));
style = g_hash_table_lookup(attribs, "style");
if (style)
styles = ggp_html_css_attribs(style);
if ((val = g_hash_table_lookup(styles,
"background-color")) != NULL)
{
int color = ggp_html_decode_color(val);
font_changed |= (font_new->bgcolor != color);
font_new->bgcolor = color;
}
if ((val = g_hash_table_lookup(styles,
"color")) != NULL)
{
int color = ggp_html_decode_color(val);
font_changed |= (font_new->color != color);
font_new->color = color;
}
if (styles)
g_hash_table_destroy(styles);
g_hash_table_destroy(attribs);
}
else if ((tag == GGP_HTML_TAG_FONT || tag == GGP_HTML_TAG_SPAN
|| tag == GGP_HTML_TAG_DIV) && tag_close)
{
font_changed = TRUE;
ggp_font_free(font_new);
if (font_stack) {
font_new = (ggp_font*)font_stack->data;
font_stack = g_list_delete_link(
font_stack, font_stack);
}
else
font_new = ggp_font_clone(font_base);
} else if (tag == GGP_HTML_TAG_BR) {
pending_objects = g_list_prepend(pending_objects,
g_strdup("<br>"));
} else if (tag == GGP_HTML_TAG_HR) {
pending_objects = g_list_prepend(pending_objects,
g_strdup("<br><span>---</span><br>"));
} else if (tag == GGP_HTML_TAG_A || tag == GGP_HTML_TAG_EOM) {
/* do nothing */
} else if (tag == GGP_HTML_TAG_UNKNOWN) {
purple_debug_warning("gg", "ggp_message_format_to_gg: "
"uknown tag %s\n", tag_str);
} else {
purple_debug_error("gg", "ggp_message_format_to_gg: "
"not handled tag %s\n", tag_str);
}
pos = m_end;
g_free(tag_str);
g_free(attribs_str);
}
g_match_info_free(match);
if (pos < strlen(text_new) || in_any_tag) {
purple_debug_fatal("gg", "ggp_message_format_to_gg: "
"end of message not reached\n");
}
/* releasing fonts recources */
ggp_font_free(font_new);
ggp_font_free(font_current);
ggp_font_free(font_base);
g_list_free_full(font_stack, ggp_font_free);
/* combining reformatted text info one string */
rt = g_list_reverse(rt);
g_free(text_new);
text_new = ggp_strjoin_list("", rt);
g_list_free_full(rt, g_free);
/* TODO: verbose
* purple_debug_info("gg", "reformatted text: [%s]\n", text_new);
*/
return text_new;
}
static void
_prepend_missing_element (gchar * element, GList ** list)
{
*list = g_list_prepend (*list, g_strdup (element));
}
int process_remote_stonith_query(xmlNode *msg)
{
int devices = 0;
const char *id = NULL;
const char *host = NULL;
remote_fencing_op_t *op = NULL;
st_query_result_t *result = NULL;
xmlNode *dev = get_xpath_object("//@"F_STONITH_REMOTE, msg, LOG_ERR);
xmlNode *child = NULL;
CRM_CHECK(dev != NULL, return -EPROTO);
id = crm_element_value(dev, F_STONITH_REMOTE);
CRM_CHECK(id != NULL, return -EPROTO);
dev = get_xpath_object("//@st-available-devices", msg, LOG_ERR);
CRM_CHECK(dev != NULL, return -EPROTO);
crm_element_value_int(dev, "st-available-devices", &devices);
op = g_hash_table_lookup(remote_op_list, id);
if(op == NULL) {
crm_debug("Unknown or expired remote op: %s", id);
return -EOPNOTSUPP;
}
op->replies++;
host = crm_element_value(msg, F_ORIG);
if(devices <= 0) {
/* If we're doing 'known' then we might need to fire anyway */
crm_trace("Query result from %s (%d devices)", host, devices);
return pcmk_ok;
} else if(op->call_options & st_opt_allow_suicide) {
crm_trace("Allowing %s to potentialy fence itself", op->target);
} else if(safe_str_eq(host, op->target)) {
crm_info("Ignoring reply from %s, hosts are not permitted to commit suicide", op->target);
return pcmk_ok;
}
crm_debug("Query result from %s (%d devices)", host, devices);
result = calloc(1, sizeof(st_query_result_t));
result->host = strdup(host);
result->devices = devices;
for (child = __xml_first_child(dev); child != NULL; child = __xml_next(child)) {
const char *device = ID(child);
if(device) {
result->device_list = g_list_prepend(result->device_list, strdup(device));
}
}
CRM_CHECK(devices == g_list_length(result->device_list),
crm_err("Mis-match: Query claimed to have %d devices but %d found", devices, g_list_length(result->device_list)));
op->query_results = g_list_insert_sorted(op->query_results, result, sort_peers);
if(op->state == st_query && is_set(op->call_options, st_opt_all_replies) == FALSE) {
call_remote_stonith(op, result);
} else if(op->state == st_done) {
crm_info("Discarding query result from %s (%d devices): Operation is in state %d",
result->host, result->devices, op->state);
}
return pcmk_ok;
}
static void
gtk_app_chooser_widget_real_add_items (GtkAppChooserWidget *self)
{
GList *all_applications = NULL;
GList *recommended_apps = NULL;
GList *fallback_apps = NULL;
GList *exclude_apps = NULL;
GAppInfo *default_app = NULL;
gboolean show_headings;
gboolean apps_added;
show_headings = TRUE;
apps_added = FALSE;
if (self->priv->show_all)
show_headings = FALSE;
if (self->priv->show_default && self->priv->content_type)
{
default_app = g_app_info_get_default_for_type (self->priv->content_type, FALSE);
if (default_app != NULL)
{
gtk_app_chooser_add_default (self, default_app);
apps_added = TRUE;
exclude_apps = g_list_prepend (exclude_apps, default_app);
}
}
#ifndef G_OS_WIN32
if ((self->priv->content_type && self->priv->show_recommended) || self->priv->show_all)
{
if (self->priv->content_type)
recommended_apps = g_app_info_get_recommended_for_type (self->priv->content_type);
apps_added |= gtk_app_chooser_widget_add_section (self, _("Recommended Applications"),
show_headings,
!self->priv->show_all, /* mark as recommended */
FALSE, /* mark as fallback */
recommended_apps, exclude_apps);
exclude_apps = g_list_concat (exclude_apps,
g_list_copy (recommended_apps));
}
if ((self->priv->content_type && self->priv->show_fallback) || self->priv->show_all)
{
if (self->priv->content_type)
fallback_apps = g_app_info_get_fallback_for_type (self->priv->content_type);
apps_added |= gtk_app_chooser_widget_add_section (self, _("Related Applications"),
show_headings,
FALSE, /* mark as recommended */
!self->priv->show_all, /* mark as fallback */
fallback_apps, exclude_apps);
exclude_apps = g_list_concat (exclude_apps,
g_list_copy (fallback_apps));
}
#endif
if (self->priv->show_other || self->priv->show_all)
{
all_applications = g_app_info_get_all ();
apps_added |= gtk_app_chooser_widget_add_section (self, _("Other Applications"),
show_headings,
FALSE,
FALSE,
all_applications, exclude_apps);
}
if (!apps_added)
add_no_applications_label (self);
gtk_app_chooser_widget_select_first (self);
if (default_app != NULL)
g_object_unref (default_app);
if (all_applications != NULL)
g_list_free_full (all_applications, g_object_unref);
if (recommended_apps != NULL)
g_list_free_full (recommended_apps, g_object_unref);
if (fallback_apps != NULL)
g_list_free_full (fallback_apps, g_object_unref);
if (exclude_apps != NULL)
g_list_free (exclude_apps);
}
void ShowFileSelect( int type,int modal )
{
int i, k, fsMedium;
char * tmp = NULL, * dir = NULL;
struct stat f;
if ( fsFileSelect ) gtkActive( fsFileSelect );
else fsFileSelect=create_FileSelect();
fsType=type;
switch ( type )
{
case fsVideoSelector:
gtk_window_set_title( GTK_WINDOW( fsFileSelect ),MSGTR_FileSelect );
fsList_items=NULL;
for( i=0;fsVideoFilterNames[i][0];i++ )
fsList_items=g_list_append( fsList_items,fsVideoFilterNames[i][0] );
k = fsLastVideoFilterSelected;
gtk_combo_set_popdown_strings( GTK_COMBO( List ),fsList_items );
g_list_free( fsList_items );
gtk_entry_set_text( GTK_ENTRY( fsFilterCombo ),fsVideoFilterNames[k >= 0 ? k : i-2][0] );
tmp=guiInfo.Filename;
break;
case fsSubtitleSelector:
gtk_window_set_title( GTK_WINDOW( fsFileSelect ),MSGTR_SubtitleSelect );
fsList_items=NULL;
for( i=0;fsSubtitleFilterNames[i][0];i++ )
fsList_items=g_list_append( fsList_items,fsSubtitleFilterNames[i][0] );
k = fsLastSubtitleFilterSelected;
gtk_combo_set_popdown_strings( GTK_COMBO( List ),fsList_items );
g_list_free( fsList_items );
gtk_entry_set_text( GTK_ENTRY( fsFilterCombo ),fsSubtitleFilterNames[k >= 0 ? k : i-2][0] );
tmp=guiInfo.SubtitleFilename;
break;
/* case fsOtherSelector:
gtk_window_set_title( GTK_WINDOW( fsFileSelect ),MSGTR_OtherSelect );
fsList_items=NULL;
for( i=0;fsOtherFilterNames[i][0];i++ )
fsList_items=g_list_append( fsList_items,fsOtherFilterNames[i][0] );
gtk_combo_set_popdown_strings( GTK_COMBO( List ),fsList_items );
g_list_free( fsList_items );
gtk_entry_set_text( GTK_ENTRY( fsFilterCombo ),fsOtherFilterNames[0][0] );
tmp=guiInfo.Othername;
break;*/
case fsAudioSelector:
gtk_window_set_title( GTK_WINDOW( fsFileSelect ),MSGTR_AudioFileSelect );
fsList_items=NULL;
for( i=0;fsAudioFileNames[i][0];i++ )
fsList_items=g_list_append( fsList_items,fsAudioFileNames[i][0] );
k = fsLastAudioFilterSelected;
gtk_combo_set_popdown_strings( GTK_COMBO( List ),fsList_items );
g_list_free( fsList_items );
gtk_entry_set_text( GTK_ENTRY( fsFilterCombo ),fsAudioFileNames[k >= 0 ? k : i-2][0] );
tmp=guiInfo.AudioFilename;
break;
case fsFontSelector:
gtk_window_set_title( GTK_WINDOW( fsFileSelect ),MSGTR_FontSelect );
fsList_items=NULL;
for( i=0;fsFontFileNames[i][0];i++ )
fsList_items=g_list_append( fsList_items,fsFontFileNames[i][0] );
k = fsLastFontFilterSelected;
gtk_combo_set_popdown_strings( GTK_COMBO( List ),fsList_items );
g_list_free( fsList_items );
gtk_entry_set_text( GTK_ENTRY( fsFilterCombo ),fsFontFileNames[k >= 0 ? k : i-2][0] );
tmp=font_name;
break;
}
fsMedium=(fsType == fsVideoSelector || fsType == fsSubtitleSelector || fsType == fsAudioSelector);
if ( !tmp && fsMedium ) tmp=guiInfo.Filename;
if ( tmp && tmp[0] && !strstr( tmp,"://" ) )
{
dir = strdup( tmp );
do
{
char * c = strrchr( dir,'/' );
if ( ( stat( dir,&f ) != 0 ) || S_ISDIR( f.st_mode ) ) break;
if ( c ) *c=0;
} while ( strrchr( dir,'/' ) );
if ( !dir[0] ) nfree( dir );
}
if ( fsTopList_items ) g_list_free( fsTopList_items ); fsTopList_items=NULL;
{
unsigned int i, c = 1;
if ( fsMedium )
{
for ( i=0;i < FF_ARRAY_ELEMS(fsHistory);i++ )
if ( fsHistory[i] ) { fsTopList_items=g_list_append( fsTopList_items,fsHistory[i] ); if ( c ) c=gstrcmp( dir,fsHistory[i] ); }
}
if ( c && dir )
{
g_free( fsSelectedDirectoryUtf8 );
fsSelectedDirectoryUtf8=g_filename_to_utf8( dir, -1, NULL, NULL, NULL );
fsTopList_items=g_list_prepend( fsTopList_items,fsSelectedDirectoryUtf8 );
}
}
free( dir );
if ( getenv( "HOME" ) ) fsTopList_items=g_list_append( fsTopList_items,getenv( "HOME" ) );
else fsTopList_items=g_list_append( fsTopList_items,"/home" );
if (stat( "/media",&f ) == 0) fsTopList_items=g_list_append( fsTopList_items,"/media" );
if (stat( "/mnt",&f ) == 0) fsTopList_items=g_list_append( fsTopList_items,"/mnt" );
fsTopList_items=g_list_append( fsTopList_items,"/" );
gtk_combo_set_popdown_strings( GTK_COMBO( fsCombo4 ),fsTopList_items );
gtk_widget_grab_focus( fsFNameList );
if (fsLastFNameListSelected + 1 > ((GtkCList *)fsFNameList)->rows) fsLastFNameListSelected = 0;
((GtkCList *)fsFNameList)->focus_row = fsLastFNameListSelected;
gtk_clist_select_row( GTK_CLIST( fsFNameList ),fsLastFNameListSelected,1 );
fsLastFNameListSelected = 0;
gtk_window_set_modal( GTK_WINDOW( fsFileSelect ),modal );
gtk_widget_show( fsFileSelect );
}
AgsScriptObject*
ags_script_object_real_valueof(AgsScriptObject *script_object,
GError **error)
{
AgsScriptObject *first_match, *last_match, *current;
GList *node_list;
guint retval_count;
gchar *xpath;
gchar **name;
guint *index;
guint index_length;
guint name_length;
xmlNode *node;
guint i, j, k;
guint z_index;
guint current_node_count;
gboolean is_node_after_first_match, is_node_after_last_match;
/* entry */
xpath = xmlGetProp(script_object->node, "retval\0");
if((first_match = ags_script_object_find_flags_descending_first_match(script_object,
AGS_SCRIPT_OBJECT_LAUNCHED,
strtoul(xmlGetProp(script_object->node, "z_index\0"), NULL, 10))) == NULL){
return(NULL);
}
last_match = ags_script_object_find_flags_descending_last_match(script_object,
AGS_SCRIPT_OBJECT_LAUNCHED,
strtoul(xmlGetProp(script_object->node, "z_index\0"), NULL, 10));
retval_count = ags_script_object_count_retval(script_object);
name = ags_script_object_split_xpath(xpath, &name_length);
index = ags_script_object_read_index(xpath,
&index_length);
if(index_length > retval_count){
guint prefix_length;
current = script_object;
node_list = NULL;
is_node_after_first_match = FALSE;
is_node_after_last_match = TRUE;
for(i = 0, j = 0; i < index_length; i++){
if(current == first_match){
is_node_after_first_match = TRUE;
}
if(current == NULL){
/* set error */
g_set_error(error,
AGS_SCRIPT_OBJECT_ERROR,
AGS_SCRIPT_OBJECT_INDEX_EXCEEDED,
"can't access index because it doesn't exist: %d of %d\0",
retval_count, retval_count);
return(NULL);
}
/* find first - start */
if(name[i][1] == '/'){
prefix_length = 2;
if(name[i][2] != '\0' && name[i][2] != '[' && name[i][2] != '@'){
while(current != NULL){
node = current->node;
//FIXME:JK: strlen() not very safe
if(!xmlStrncmp(node->name, &(name[i][prefix_length]), strlen(node->name))){
break;
}else{
current = current->retval;
j++;
}
}
}
if(current == NULL){
/* set error */
g_set_error(error,
AGS_SCRIPT_OBJECT_ERROR,
AGS_SCRIPT_OBJECT_INDEX_EXCEEDED,
"named child doesn't exist\0");
return(NULL);
}
}else{
prefix_length = 1;
if(!xmlStrcmp(node->name, &(name[i][prefix_length]))){
current = current->retval;
node = current->node;
j++;
}else{
/* set error */
g_set_error(error,
AGS_SCRIPT_OBJECT_ERROR,
AGS_SCRIPT_OBJECT_INDEX_EXCEEDED,
"named child doesn't exist\0");
}
}
/* position */
z_index = strtoul(xmlGetProp(node, "z_index\0"), NULL, 10);
if(index[i] != AGS_SCRIPT_OBJECT_XPATH_NaN){
for(k = 0; k < index[i] && current != NULL; j++){
node = current->node;
current = current->retval;
//FIXME:JK: strlen() not very safe
if(!xmlStrncmp(node->name, &(name[i][prefix_length]), strlen(node->name)) &&
z_index == strtoul(xmlGetProp(node, "z_index\0"), NULL, 10)){
k++;
}
}
}else{
current = last_match;
}
node_list = g_list_prepend(node_list,
node);
if(index[i] != AGS_SCRIPT_OBJECT_XPATH_NaN &&
k != index[i]){
/* set error */
g_set_error(error,
AGS_SCRIPT_OBJECT_ERROR,
AGS_SCRIPT_OBJECT_INDEX_EXCEEDED,
"can't access index because it doesn't exist: %d of %d\0",
retval_count, retval_count);
return(NULL);
}
}
if(!is_node_after_first_match){
/* set error */
g_set_error(error,
AGS_SCRIPT_OBJECT_ERROR,
AGS_SCRIPT_OBJECT_INDEX_EXCEEDED,
"can't access index because it doesn't exist: %d of %d\0",
-1, index_length);
return(NULL);
}
}else{
/* set error */
g_set_error(error,
AGS_SCRIPT_OBJECT_ERROR,
AGS_SCRIPT_OBJECT_INDEX_EXCEEDED,
"can't access index because it doesn't exist: %d of %d\0",
-1, index_length);
return(NULL);
}
if(j > 0){
return(current);
}else{
return(first_match);
}
}
/**
* gupnp_service_info_get_introspection_async_full:
* @info: A #GUPnPServiceInfo
* @callback: (scope async) : callback to be called when introspection object is ready.
* @cancellable: GCancellable that can be used to cancel the call, or %NULL.
* @user_data: user_data to be passed to the callback.
*
* Note that introspection object is created from the information in service
* description document (SCPD) provided by the service so it can not be created
* if the service does not provide an SCPD.
*
* If @cancellable is used to cancel the call, @callback will be called with
* error code %G_IO_ERROR_CANCELLED.
*
* Since: 0.20.9
**/
void
gupnp_service_info_get_introspection_async_full
(GUPnPServiceInfo *info,
GUPnPServiceIntrospectionCallback callback,
GCancellable *cancellable,
gpointer user_data)
{
GetSCPDURLData *data;
char *scpd_url;
SoupSession *session;
GUPnPServiceInfoPrivate *priv;
g_return_if_fail (GUPNP_IS_SERVICE_INFO (info));
g_return_if_fail (callback != NULL);
data = g_slice_new (GetSCPDURLData);
scpd_url = gupnp_service_info_get_scpd_url (info);
data->message = NULL;
if (scpd_url != NULL) {
GUPnPContext *context = NULL;
char *local_scpd_url = NULL;
context = gupnp_service_info_get_context (info);
local_scpd_url = gupnp_context_rewrite_uri (context, scpd_url);
g_free (scpd_url);
data->message = soup_message_new (SOUP_METHOD_GET,
local_scpd_url);
g_free (local_scpd_url);
}
if (data->message == NULL) {
GError *error;
error = g_error_new
(GUPNP_SERVER_ERROR,
GUPNP_SERVER_ERROR_INVALID_URL,
"No valid SCPD URL defined");
callback (info, NULL, error, user_data);
g_error_free (error);
g_slice_free (GetSCPDURLData, data);
return;
}
data->info = info;
data->callback = callback;
data->user_data = user_data;
/* Send off the message */
priv = gupnp_service_info_get_instance_private (info);
priv->pending_gets = g_list_prepend (priv->pending_gets, data);
session = gupnp_context_get_session (priv->context);
soup_session_queue_message (session,
data->message,
(SoupSessionCallback) got_scpd_url,
data);
data->cancellable = cancellable;
if (data->cancellable) {
g_object_ref (cancellable);
data->cancelled_id = g_cancellable_connect
(data->cancellable,
G_CALLBACK (cancellable_cancelled_cb),
data,
NULL);
}
}
static void
process_kill (CockpitRouter *self,
JsonObject *options)
{
GHashTableIter iter;
const gchar *group = NULL;
const gchar *host = NULL;
GList *list, *l;
if (!cockpit_json_get_string (options, "group", NULL, &group))
{
g_warning ("received invalid \"group\" field in kill command");
return;
}
else if (!cockpit_json_get_string (options, "host", NULL, &host))
{
g_warning ("received invalid \"host\" field in kill command");
return;
}
/* Killing on other hosts is handled elsewhere */
if (host && g_strcmp0 (host, self->init_host) != 0)
return;
list = NULL;
if (group)
{
gpointer id, channel_group;
g_hash_table_iter_init (&iter, self->groups);
while (g_hash_table_iter_next (&iter, &id, &channel_group))
{
CockpitChannel *channel;
if (!g_str_equal (group, channel_group))
continue;
channel = g_hash_table_lookup (self->channels, id);
if (channel)
list = g_list_prepend (list, g_object_ref (channel));
}
}
else
{
gpointer id, channel;
g_hash_table_iter_init (&iter, self->channels);
while (g_hash_table_iter_next (&iter, &id, &channel))
list = g_list_prepend (list, g_object_ref (channel));
}
for (l = list; l != NULL; l = g_list_next (l))
{
CockpitChannel *channel = l->data;
g_debug ("killing channel: %s", cockpit_channel_get_id (channel));
cockpit_channel_close (channel, "terminated");
g_object_unref (channel);
}
g_list_free (list);
}
static gboolean
process_package_args (const char *cmdline, GList **packages, FILE *log)
{
gboolean success = TRUE;
GList *reqs;
reqs = parse_module_list (NULL, cmdline, "(command line arguments)");
if (reqs == NULL)
{
fprintf (stderr, "Must specify package names on the command line\n");
fflush (stderr);
return FALSE;
}
for (; reqs != NULL; reqs = g_list_next (reqs))
{
Package *req;
RequiredVersion *ver = reqs->data;
/* override requested versions with cmdline options */
if (required_exact_version)
{
g_free (ver->version);
ver->comparison = EQUAL;
ver->version = g_strdup (required_exact_version);
}
else if (required_atleast_version)
{
g_free (ver->version);
ver->comparison = GREATER_THAN_EQUAL;
ver->version = g_strdup (required_atleast_version);
}
else if (required_max_version)
{
g_free (ver->version);
ver->comparison = LESS_THAN_EQUAL;
ver->version = g_strdup (required_max_version);
}
if (want_short_errors)
req = get_package_quiet (ver->name);
else
req = get_package (ver->name);
if (log != NULL)
{
if (req == NULL)
fprintf (log, "%s NOT-FOUND\n", ver->name);
else
fprintf (log, "%s %s %s\n", ver->name,
comparison_to_str (ver->comparison),
(ver->version == NULL) ? "(null)" : ver->version);
}
if (req == NULL)
{
success = FALSE;
verbose_error ("No package '%s' found\n", ver->name);
continue;
}
if (!version_test (ver->comparison, req->version, ver->version))
{
success = FALSE;
verbose_error ("Requested '%s %s %s' but version of %s is %s\n",
ver->name,
comparison_to_str (ver->comparison),
ver->version,
req->name,
req->version);
if (req->url)
verbose_error ("You may find new versions of %s at %s\n",
req->name, req->url);
continue;
}
*packages = g_list_prepend (*packages, req);
}
*packages = g_list_reverse (*packages);
return success;
}
static GList *
parse_mcedit_arguments (int argc, char **argv)
{
GList *flist = NULL;
int i;
long first_line_number = -1;
for (i = 0; i < argc; i++)
{
char *tmp;
char *end, *p;
mcedit_arg_t *arg;
tmp = argv[i];
/*
* First, try to get line number as +lineno.
*/
if (*tmp == '+')
{
long lineno;
char *error;
lineno = strtol (tmp + 1, &error, 10);
if (*error == '\0')
{
/* this is line number */
first_line_number = lineno;
continue;
}
/* this is file name */
}
/*
* Check for filename:lineno, followed by an optional colon.
* This format is used by many programs (especially compilers)
* in error messages and warnings. It is supported so that
* users can quickly copy and paste file locations.
*/
end = tmp + strlen (tmp);
p = end;
if (p > tmp && p[-1] == ':')
p--;
while (p > tmp && g_ascii_isdigit ((gchar) p[-1]))
p--;
if (tmp < p && p < end && p[-1] == ':')
{
char *fname;
vfs_path_t *tmp_vpath, *fname_vpath;
struct stat st;
fname = g_strndup (tmp, p - 1 - tmp);
tmp_vpath = vfs_path_from_str (tmp);
fname_vpath = vfs_path_from_str (fname);
/*
* Check that the file before the colon actually exists.
* If it doesn't exist, create new file.
*/
if (mc_stat (tmp_vpath, &st) == -1 && mc_stat (fname_vpath, &st) != -1)
{
arg = mcedit_arg_vpath_new (fname_vpath, atoi (p));
vfs_path_free (tmp_vpath);
}
else
{
arg = mcedit_arg_vpath_new (tmp_vpath, 0);
vfs_path_free (fname_vpath);
}
g_free (fname);
}
else
arg = mcedit_arg_new (tmp, 0);
flist = g_list_prepend (flist, arg);
}
if (flist == NULL)
flist = g_list_prepend (flist, mcedit_arg_new (NULL, 0));
else if (first_line_number != -1)
{
/* overwrite line number for first file */
GList *l;
l = g_list_last (flist);
((mcedit_arg_t *) l->data)->line_number = first_line_number;
}
return flist;
}
/**************************************************************************
Creates a new dialog. It will be a tab or a window depending on the
current user setting of 'gui_gtk2_enable_tabs'.
Sets pdlg to point to the dialog once it is create, Zeroes pdlg on
dialog destruction.
user_data will be passed through response function
check_top indicates if the layout deision should depend on the parent.
**************************************************************************/
void gui_dialog_new(struct gui_dialog **pdlg, GtkNotebook *notebook,
gpointer user_data, bool check_top)
{
struct gui_dialog *dlg;
GtkWidget *vbox, *action_area;
static int dialog_id_counter;
dlg = fc_malloc(sizeof(*dlg));
dialog_list = g_list_prepend(dialog_list, dlg);
dlg->source = pdlg;
*pdlg = dlg;
dlg->user_data = user_data;
dlg->title = NULL;
dlg->default_width = 200;
dlg->default_height = 300;
if (gui_gtk2_enable_tabs) {
dlg->type = GUI_DIALOG_TAB;
} else {
dlg->type = GUI_DIALOG_WINDOW;
}
if (!gui_action) {
gui_action = gtk_size_group_new(GTK_SIZE_GROUP_VERTICAL);
}
dlg->gui_button = gtk_size_group_new(GTK_SIZE_GROUP_BOTH);
if (gui_gtk2_enable_tabs
&& (check_top && notebook != GTK_NOTEBOOK(top_notebook))
&& !gui_gtk2_small_display_layout) {
/* We expect this to be short (as opposed to tall); maximise usable
* height by putting buttons down the right hand side */
vbox = gtk_hbox_new(FALSE, 0);
action_area = gtk_vbox_new(FALSE, 2);
} else {
/* We expect this to be reasonably tall; maximise usable width by
* putting buttons along the bottom */
vbox = gtk_vbox_new(FALSE, 0);
action_area = gtk_hbox_new(FALSE, 2);
}
gtk_widget_show(vbox);
gtk_box_pack_end(GTK_BOX(vbox), action_area, FALSE, TRUE, 0);
gtk_widget_show(action_area);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 2);
gtk_box_set_spacing(GTK_BOX(action_area), 4);
gtk_container_set_border_width(GTK_CONTAINER(action_area), 2);
switch (dlg->type) {
case GUI_DIALOG_WINDOW:
{
GtkWidget *window;
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_set_name(window, "Freeciv");
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_MOUSE);
setup_dialog(window, toplevel);
gtk_container_add(GTK_CONTAINER(window), vbox);
dlg->v.window = window;
g_signal_connect(window, "delete_event",
G_CALLBACK(gui_dialog_delete_handler), dlg);
}
break;
case GUI_DIALOG_TAB:
{
GtkWidget *hbox, *label, *image, *button, *event_box;
gint w, h;
char buf[256];
gtk_icon_size_lookup(GTK_ICON_SIZE_MENU, &w, &h);
hbox = gtk_hbox_new(FALSE, 0);
label = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_misc_set_padding(GTK_MISC(label), 4, 0);
gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 0);
button = gtk_button_new();
gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);
g_signal_connect_swapped(button, "clicked",
G_CALLBACK(gui_dialog_delete_tab_handler), dlg);
fc_snprintf(buf, sizeof(buf), _("Close Tab:\n%s"), _("Ctrl+W"));
gtk_tooltips_set_tip(main_tips, button, buf, "");
image = gtk_image_new_from_stock(GTK_STOCK_CLOSE, GTK_ICON_SIZE_MENU);
gtk_widget_set_size_request(button, w, h);
gtk_container_add(GTK_CONTAINER(button), image);
gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show_all(hbox);
event_box = gtk_event_box_new();
gtk_container_add(GTK_CONTAINER(event_box), hbox);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox, event_box);
dlg->v.tab.handler_id =
g_signal_connect(notebook, "switch_page",
G_CALLBACK(gui_dialog_switch_page_handler), dlg);
dlg->v.tab.child = vbox;
dlg->v.tab.label = label;
dlg->v.tab.notebook = GTK_WIDGET(notebook);
gtk_widget_add_events(event_box, GDK_BUTTON2_MOTION_MASK);
g_signal_connect(event_box, "button-press-event",
G_CALLBACK(click_on_tab_callback), dlg);
}
break;
}
dlg->vbox = vbox;
dlg->action_area = action_area;
dlg->response_callback = gui_dialog_destroyed;
dlg->id = dialog_id_counter;
dialog_id_counter++;
dlg->return_dialog_id = -1;
g_signal_connect(vbox, "destroy",
G_CALLBACK(gui_dialog_destroy_handler), dlg);
g_signal_connect(vbox, "key_press_event",
G_CALLBACK(gui_dialog_key_press_handler), dlg);
g_object_set_data(G_OBJECT(vbox), "gui-dialog-data", dlg);
}
void
gimp_dialog_factory_add_dialog (GimpDialogFactory *factory,
GtkWidget *dialog)
{
GimpDialogFactory *dialog_factory;
GimpDialogFactoryEntry *entry;
GimpSessionInfo *info;
GList *list;
gboolean toplevel;
g_return_if_fail (GIMP_IS_DIALOG_FACTORY (factory));
g_return_if_fail (GTK_IS_WIDGET (dialog));
if (g_list_find (factory->open_dialogs, dialog))
{
g_warning ("%s: dialog already registered", G_STRFUNC);
return;
}
dialog_factory = gimp_dialog_factory_from_widget (dialog, &entry);
if (! (dialog_factory && (entry || GIMP_IS_DOCK (dialog))))
{
g_warning ("%s: dialog was not created by a GimpDialogFactory",
G_STRFUNC);
return;
}
if (dialog_factory != factory)
{
g_warning ("%s: dialog was created by a different GimpDialogFactory",
G_STRFUNC);
return;
}
toplevel = GTK_WIDGET_TOPLEVEL (dialog);
if (entry) /* dialog is a toplevel (but not a GimpDock) or a GimpDockable */
{
D (g_print ("%s: adding %s \"%s\"\n",
G_STRFUNC,
toplevel ? "toplevel" : "dockable",
entry->identifier));
for (list = factory->session_infos; list; list = g_list_next (list))
{
info = list->data;
if ((info->toplevel_entry == entry) ||
(info->dockable_entry == entry))
{
if (info->widget)
{
if (entry->singleton)
{
g_warning ("%s: singleton dialog \"%s\" created twice",
G_STRFUNC, entry->identifier);
D (g_print ("%s: corrupt session info: %p (widget %p)\n",
G_STRFUNC,
info, info->widget));
return;
}
continue;
}
info->widget = dialog;
D (g_print ("%s: updating session info %p (widget %p) for %s \"%s\"\n",
G_STRFUNC,
info, info->widget,
toplevel ? "toplevel" : "dockable",
entry->identifier));
if (toplevel && entry->session_managed)
gimp_session_info_set_geometry (info);
break;
}
}
if (! list) /* didn't find a session info */
{
info = gimp_session_info_new ();
info->widget = dialog;
D (g_print ("%s: creating session info %p (widget %p) for %s \"%s\"\n",
G_STRFUNC,
info, info->widget,
toplevel ? "toplevel" : "dockable",
entry->identifier));
if (toplevel)
{
info->toplevel_entry = entry;
/* if we create a new session info, we never call
* gimp_session_info_set_geometry(), but still the
* dialog needs GDK_HINT_USER_POS so it keeps its
* position when hidden/shown within this(!) session.
*/
if (entry->session_managed)
g_signal_connect (dialog, "configure-event",
G_CALLBACK (gimp_dialog_factory_set_user_pos),
NULL);
}
else
{
info->dockable_entry = entry;
}
factory->session_infos = g_list_append (factory->session_infos, info);
}
}
else /* dialog is a GimpDock */
{
D (g_print ("%s: adding dock\n", G_STRFUNC));
for (list = factory->session_infos; list; list = g_list_next (list))
{
info = list->data;
/* take the first empty slot */
if (! info->toplevel_entry &&
! info->dockable_entry &&
! info->widget)
{
info->widget = dialog;
D (g_print ("%s: updating session info %p (widget %p) for dock\n",
G_STRFUNC,
info, info->widget));
gimp_session_info_set_geometry (info);
break;
}
}
if (! list) /* didn't find a session info */
{
info = gimp_session_info_new ();
info->widget = dialog;
D (g_print ("%s: creating session info %p (widget %p) for dock\n",
G_STRFUNC,
info, info->widget));
/* if we create a new session info, we never call
* gimp_session_info_set_geometry(), but still the
* dialog needs GDK_HINT_USER_POS so it keeps its
* position when hidden/shown within this(!) session.
*/
g_signal_connect (dialog, "configure-event",
G_CALLBACK (gimp_dialog_factory_set_user_pos),
NULL);
factory->session_infos = g_list_append (factory->session_infos, info);
}
}
factory->open_dialogs = g_list_prepend (factory->open_dialogs, dialog);
g_signal_connect_object (dialog, "destroy",
G_CALLBACK (gimp_dialog_factory_remove_dialog),
factory,
G_CONNECT_SWAPPED);
if (entry && entry->session_managed && toplevel)
g_signal_connect_object (dialog, "configure-event",
G_CALLBACK (gimp_dialog_factory_dialog_configure),
factory,
0);
}
GList *
ephy_history_service_find_visit_rows (EphyHistoryService *self, EphyHistoryQuery *query)
{
EphySQLiteStatement *statement = NULL;
GList *substring;
GString *statement_str;
GList *visits = NULL;
GError *error = NULL;
const char *base_statement = ""
"SELECT "
"visits.url, "
"visits.visit_time, "
"visits.visit_type ";
const char *from_join_statement = ""
"FROM "
"visits JOIN urls ON visits.url = urls.id ";
const char *from_visits_statement = ""
"FROM "
"visits ";
int i = 0;
g_assert (self->history_thread == g_thread_self ());
g_assert (self->history_database != NULL);
statement_str = g_string_new (base_statement);
if (query->substring_list)
statement_str = g_string_append (statement_str, from_join_statement);
else
statement_str = g_string_append (statement_str, from_visits_statement);
statement_str = g_string_append (statement_str, "WHERE ");
if (query->from >= 0)
statement_str = g_string_append (statement_str, "visits.visit_time >= ? AND ");
if (query->to >= 0)
statement_str = g_string_append (statement_str, "visits.visit_time <= ? AND ");
if (query->host > 0)
statement_str = g_string_append (statement_str, "urls.host = ? AND ");
for (substring = query->substring_list; substring != NULL; substring = substring->next) {
statement_str = g_string_append (statement_str, "(urls.url LIKE ? OR urls.title LIKE ?) AND ");
}
statement_str = g_string_append (statement_str, "1");
statement = ephy_sqlite_connection_create_statement (self->history_database,
statement_str->str, &error);
g_string_free (statement_str, TRUE);
if (error) {
g_warning ("Could not build visits table query statement: %s", error->message);
g_error_free (error);
return NULL;
}
if (query->from >= 0) {
if (ephy_sqlite_statement_bind_int64 (statement, i++, query->from, &error) == FALSE) {
g_warning ("Could not build urls table query statement: %s", error->message);
g_error_free (error);
g_object_unref (statement);
return NULL;
}
}
if (query->to >= 0) {
if (ephy_sqlite_statement_bind_int64 (statement, i++, query->to, &error) == FALSE) {
g_warning ("Could not build urls table query statement: %s", error->message);
g_error_free (error);
g_object_unref (statement);
return NULL;
}
}
if (query->host > 0) {
if (ephy_sqlite_statement_bind_int (statement, i++, (int)query->host, &error) == FALSE) {
g_warning ("Could not build urls table query statement: %s", error->message);
g_error_free (error);
g_object_unref (statement);
return NULL;
}
}
for (substring = query->substring_list; substring != NULL; substring = substring->next) {
char *string = ephy_sqlite_create_match_pattern (substring->data);
if (ephy_sqlite_statement_bind_string (statement, i++, string, &error) == FALSE) {
g_warning ("Could not build urls table query statement: %s", error->message);
g_error_free (error);
g_object_unref (statement);
g_free (string);
return NULL;
}
if (ephy_sqlite_statement_bind_string (statement, i++, string + 2, &error) == FALSE) {
g_warning ("Could not build urls table query statement: %s", error->message);
g_error_free (error);
g_object_unref (statement);
g_free (string);
return NULL;
}
g_free (string);
}
while (ephy_sqlite_statement_step (statement, &error))
visits = g_list_prepend (visits, create_page_visit_from_statement (statement));
visits = g_list_reverse (visits);
if (error) {
g_warning ("Could not execute visits table query statement: %s", error->message);
g_error_free (error);
g_object_unref (statement);
ephy_history_page_visit_list_free (visits);
return NULL;
}
g_object_unref (statement);
return visits;
}
static void
anjuta_window_instance_init (AnjutaWindow *win)
{
GtkWidget *menubar, *about_menu;
GtkWidget *view_menu, *hbox;
GtkWidget *main_box;
GtkWidget *dockbar;
GtkAction* action;
GList *plugins_dirs = NULL;
GdkGeometry size_hints = {
100, 100, 0, 0, 100, 100, 1, 1, 0.0, 0.0, GDK_GRAVITY_NORTH_WEST
};
DEBUG_PRINT ("%s", "Initializing Anjuta...");
gtk_window_set_geometry_hints (GTK_WINDOW (win), GTK_WIDGET (win),
&size_hints, GDK_HINT_RESIZE_INC);
gtk_window_set_resizable (GTK_WINDOW (win), TRUE);
/*
* Main box
*/
main_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (win), main_box);
gtk_widget_show (main_box);
win->values = NULL;
win->widgets = NULL;
win->maximized = FALSE;
/* Settings */
win->settings = g_settings_new (PREF_SCHEMA);
/* Status bar */
win->status = ANJUTA_STATUS (anjuta_status_new ());
anjuta_status_set_title_window (win->status, GTK_WIDGET (win));
gtk_widget_show (GTK_WIDGET (win->status));
gtk_box_pack_end (GTK_BOX (main_box),
GTK_WIDGET (win->status), FALSE, TRUE, 0);
g_object_ref (G_OBJECT (win->status));
g_object_add_weak_pointer (G_OBJECT (win->status), (gpointer)&win->status);
/* configure dock */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_widget_show (hbox);
win->dock = gdl_dock_new ();
gtk_widget_show (win->dock);
gtk_box_pack_end(GTK_BOX (hbox), win->dock, TRUE, TRUE, 0);
dockbar = gdl_dock_bar_new (G_OBJECT (win->dock));
gtk_widget_show (dockbar);
gtk_box_pack_start(GTK_BOX (hbox), dockbar, FALSE, FALSE, 0);
win->layout_manager = gdl_dock_layout_new (G_OBJECT (win->dock));
g_signal_connect (win->layout_manager, "notify::dirty",
G_CALLBACK (on_layout_dirty_notify), win);
g_signal_connect (gdl_dock_layout_get_master (win->layout_manager), "notify::locked",
G_CALLBACK (on_layout_locked_notify), win);
/* UI engine */
win->ui = anjuta_ui_new ();
g_object_add_weak_pointer (G_OBJECT (win->ui), (gpointer)&win->ui);
/* show tooltips in the statusbar */
g_signal_connect (win->ui,
"connect_proxy",
G_CALLBACK (connect_proxy_cb),
win);
g_signal_connect (win->ui,
"disconnect_proxy",
G_CALLBACK (disconnect_proxy_cb),
win);
/* Plugin Manager */
plugins_dirs = g_list_prepend (plugins_dirs, PACKAGE_PLUGIN_DIR);
win->plugin_manager = anjuta_plugin_manager_new (G_OBJECT (win),
win->status,
plugins_dirs);
win->profile_manager = anjuta_profile_manager_new (win->plugin_manager);
g_list_free (plugins_dirs);
/* Preferences */
win->preferences = anjuta_preferences_new (win->plugin_manager, PREF_SCHEMA);
g_object_add_weak_pointer (G_OBJECT (win->preferences),
(gpointer)&win->preferences);
g_signal_connect (win->settings, "changed::" GDL_STYLE,
G_CALLBACK (on_gdl_style_changed), win);
on_gdl_style_changed (win->settings, GDL_STYLE, win);
/* Register actions */
anjuta_ui_add_action_group_entries (win->ui, "ActionGroupFile", _("File"),
menu_entries_file,
G_N_ELEMENTS (menu_entries_file),
GETTEXT_PACKAGE, TRUE, win);
anjuta_ui_add_action_group_entries (win->ui, "ActionGroupEdit", _("Edit"),
menu_entries_edit,
G_N_ELEMENTS (menu_entries_edit),
GETTEXT_PACKAGE, TRUE, win);
anjuta_ui_add_action_group_entries (win->ui, "ActionGroupView", _("View"),
menu_entries_view,
G_N_ELEMENTS (menu_entries_view),
GETTEXT_PACKAGE, TRUE, win);
anjuta_ui_add_toggle_action_group_entries (win->ui, "ActionGroupToggleView",
_("View"),
menu_entries_toggle_view,
G_N_ELEMENTS (menu_entries_toggle_view),
GETTEXT_PACKAGE, TRUE, win);
anjuta_ui_add_action_group_entries (win->ui, "ActionGroupHelp", _("Help"),
menu_entries_help,
G_N_ELEMENTS (menu_entries_help),
GETTEXT_PACKAGE, TRUE, win);
/* Merge UI */
anjuta_ui_merge (win->ui, UI_FILE);
/* Adding accels group */
gtk_window_add_accel_group (GTK_WINDOW (win),
gtk_ui_manager_get_accel_group (GTK_UI_MANAGER (win->ui)));
/* create main menu */
menubar = gtk_ui_manager_get_widget (GTK_UI_MANAGER (win->ui),
"/MenuMain");
gtk_box_pack_start (GTK_BOX (main_box), menubar, FALSE, FALSE, 0);
gtk_widget_show (menubar);
/* create toolbar */
win->toolbar = gtk_ui_manager_get_widget (GTK_UI_MANAGER (win->ui),
"/ToolbarMain");
if (!g_settings_get_boolean (win->settings, TOOLBAR_VISIBLE))
gtk_widget_hide (win->toolbar);
gtk_style_context_add_class (gtk_widget_get_style_context (win->toolbar),
GTK_STYLE_CLASS_PRIMARY_TOOLBAR);
gtk_toolbar_set_icon_size (GTK_TOOLBAR (win->toolbar),
GTK_ICON_SIZE_MENU);
gtk_box_pack_start (GTK_BOX (main_box), win->toolbar, FALSE, FALSE, 0);
action = gtk_ui_manager_get_action (GTK_UI_MANAGER (win->ui),
"/MenuMain/MenuView/Toolbar");
gtk_toggle_action_set_active (GTK_TOGGLE_ACTION(action),
g_settings_get_boolean (win->settings,
TOOLBAR_VISIBLE));
g_signal_connect (win->settings, "changed::" TOOLBAR_STYLE,
G_CALLBACK (on_toolbar_style_changed), win);
on_toolbar_style_changed (win->settings, TOOLBAR_STYLE, win);
/* Create widgets menu */
view_menu =
gtk_ui_manager_get_widget (GTK_UI_MANAGER(win->ui),
"/MenuMain/MenuView");
win->view_menu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (view_menu));
/* Create about plugins menu */
about_menu =
gtk_ui_manager_get_widget (GTK_UI_MANAGER(win->ui),
"/MenuMain/PlaceHolderHelpMenus/MenuHelp/"
"PlaceHolderHelpAbout/AboutPlugins");
about_create_plugins_submenu (ANJUTA_SHELL (win), about_menu);
/* Add main view */
gtk_box_pack_start (GTK_BOX (main_box), hbox, TRUE, TRUE, 0);
/* Connect to session */
g_signal_connect (G_OBJECT (win), "save_session",
G_CALLBACK (on_session_save), win);
g_signal_connect (G_OBJECT (win), "load_session",
G_CALLBACK (on_session_load), win);
/* Loading accels */
anjuta_ui_load_accels (NULL);
win->save_count = 0;
}
GList *
gimp_brush_pipe_load (GimpContext *context,
const gchar *filename,
GError **error)
{
GimpBrushPipe *pipe = NULL;
GimpPixPipeParams params;
gint i;
gint num_of_brushes = 0;
gint totalcells;
gchar *paramstring;
GString *buffer;
gchar c;
gint fd;
g_return_val_if_fail (filename != NULL, NULL);
g_return_val_if_fail (g_path_is_absolute (filename), NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
fd = g_open (filename, O_RDONLY | _O_BINARY, 0);
if (fd == -1)
{
g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_OPEN,
_("Could not open '%s' for reading: %s"),
gimp_filename_to_utf8 (filename), g_strerror (errno));
return NULL;
}
/* The file format starts with a painfully simple text header */
/* get the name */
buffer = g_string_new (NULL);
while (read (fd, &c, 1) == 1 && c != '\n' && buffer->len < 1024)
g_string_append_c (buffer, c);
if (buffer->len > 0 && buffer->len < 1024)
{
gchar *utf8 =
gimp_any_to_utf8 (buffer->str, buffer->len,
_("Invalid UTF-8 string in brush file '%s'."),
gimp_filename_to_utf8 (filename));
pipe = g_object_new (GIMP_TYPE_BRUSH_PIPE,
"name", utf8,
"mime-type", "image/x-gimp-gih",
NULL);
g_free (utf8);
}
g_string_free (buffer, TRUE);
if (! pipe)
{
g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_READ,
_("Fatal parse error in brush file '%s': "
"File is corrupt."),
gimp_filename_to_utf8 (filename));
close (fd);
return NULL;
}
/* get the number of brushes */
buffer = g_string_new (NULL);
while (read (fd, &c, 1) == 1 && c != '\n' && buffer->len < 1024)
g_string_append_c (buffer, c);
if (buffer->len > 0 && buffer->len < 1024)
{
num_of_brushes = strtol (buffer->str, ¶mstring, 10);
}
if (num_of_brushes < 1)
{
g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_READ,
_("Fatal parse error in brush file '%s': "
"File is corrupt."),
gimp_filename_to_utf8 (filename));
close (fd);
g_object_unref (pipe);
g_string_free (buffer, TRUE);
return NULL;
}
while (*paramstring && g_ascii_isspace (*paramstring))
paramstring++;
if (*paramstring)
{
gimp_pixpipe_params_init (¶ms);
gimp_pixpipe_params_parse (paramstring, ¶ms);
pipe->dimension = params.dim;
pipe->rank = g_new0 (gint, pipe->dimension);
pipe->select = g_new0 (PipeSelectModes, pipe->dimension);
pipe->index = g_new0 (gint, pipe->dimension);
/* placement is not used at all ?? */
if (params.free_placement_string)
g_free (params.placement);
for (i = 0; i < pipe->dimension; i++)
{
pipe->rank[i] = MAX (1, params.rank[i]);
if (strcmp (params.selection[i], "incremental") == 0)
pipe->select[i] = PIPE_SELECT_INCREMENTAL;
else if (strcmp (params.selection[i], "angular") == 0)
pipe->select[i] = PIPE_SELECT_ANGULAR;
else if (strcmp (params.selection[i], "velocity") == 0)
pipe->select[i] = PIPE_SELECT_VELOCITY;
else if (strcmp (params.selection[i], "random") == 0)
pipe->select[i] = PIPE_SELECT_RANDOM;
else if (strcmp (params.selection[i], "pressure") == 0)
pipe->select[i] = PIPE_SELECT_PRESSURE;
else if (strcmp (params.selection[i], "xtilt") == 0)
pipe->select[i] = PIPE_SELECT_TILT_X;
else if (strcmp (params.selection[i], "ytilt") == 0)
pipe->select[i] = PIPE_SELECT_TILT_Y;
else
pipe->select[i] = PIPE_SELECT_CONSTANT;
if (params.free_selection_string)
g_free (params.selection[i]);
pipe->index[i] = 0;
}
}
else
{
pipe->dimension = 1;
pipe->rank = g_new (gint, 1);
pipe->rank[0] = num_of_brushes;
pipe->select = g_new (PipeSelectModes, 1);
pipe->select[0] = PIPE_SELECT_INCREMENTAL;
pipe->index = g_new (gint, 1);
pipe->index[0] = 0;
}
g_string_free (buffer, TRUE);
totalcells = 1; /* Not all necessarily present, maybe */
for (i = 0; i < pipe->dimension; i++)
totalcells *= pipe->rank[i];
pipe->stride = g_new0 (gint, pipe->dimension);
for (i = 0; i < pipe->dimension; i++)
{
if (i == 0)
pipe->stride[i] = totalcells / pipe->rank[i];
else
pipe->stride[i] = pipe->stride[i-1] / pipe->rank[i];
}
g_assert (pipe->stride[pipe->dimension-1] == 1);
pipe->brushes = g_new0 (GimpBrush *, num_of_brushes);
while (pipe->n_brushes < num_of_brushes)
{
GError *my_error = NULL;
pipe->brushes[pipe->n_brushes] = gimp_brush_load_brush (context,
fd, filename,
&my_error);
if (pipe->brushes[pipe->n_brushes])
{
gimp_object_set_name (GIMP_OBJECT (pipe->brushes[pipe->n_brushes]),
NULL);
}
else
{
g_propagate_error (error, my_error);
close (fd);
g_object_unref (pipe);
return NULL;
}
pipe->n_brushes++;
}
close (fd);
/* Current brush is the first one. */
pipe->current = pipe->brushes[0];
/* just to satisfy the code that relies on this crap */
GIMP_BRUSH (pipe)->spacing = pipe->current->spacing;
GIMP_BRUSH (pipe)->x_axis = pipe->current->x_axis;
GIMP_BRUSH (pipe)->y_axis = pipe->current->y_axis;
GIMP_BRUSH (pipe)->mask = pipe->current->mask;
GIMP_BRUSH (pipe)->pixmap = pipe->current->pixmap;
return g_list_prepend (NULL, pipe);
}
void
update_process_info (void)
{
static guint64 old_total_jiffies = 0;
if (!awn_proc_users)
{
g_debug ("%s: no users",__func__);
return;
}
pid_t * p;
gint y ;
glibtop_proclist proclist;
GList * old_awn_proc_info=awn_proc_info;
guint64 total_jiffies;
glibtop_cpu cpu;
gdouble percent;
gdouble total_per = 0;
glibtop_get_cpu (&cpu);
total_jiffies = cpu.total;
awn_proc_info = NULL;
/* p = glibtop_get_proclist(&proclist, GLIBTOP_KERN_PROC_RUID, getuid());*/
p = glibtop_get_proclist(&proclist, GLIBTOP_KERN_PROC_ALL, -1);
// g_debug ("number of entries = %d",proclist.number);
for (y = 0;y < proclist.number;y++)
{
AwnProcInfo * data = g_malloc (sizeof(AwnProcInfo));
GList * search;
data->pid = p[y];
glibtop_get_proc_state(&data->proc_state, p[y]);
glibtop_get_proc_time(&data->proc_time, p[y]);
search = g_list_find_custom (old_awn_proc_info,GINT_TO_POINTER(p[y]),
(GCompareFunc)_cmp_find_pid);
if (search)
{
AwnProcInfo * search_data = search->data;
long time_diff;
double jiffies;
jiffies = total_jiffies - old_total_jiffies;
// g_debug ("%d jiffies = %lf",p[y],jiffies);
time_diff = (data->proc_time.utime + data->proc_time.stime) - (search_data->proc_time.utime+search_data->proc_time.stime);
// g_debug ("%d time diff = %ld",p[y],time_diff);
percent = time_diff / (jiffies / cpu.frequency) ;
// g_debug ("percent for %d = %lf",p[y],percent);
}
else
{
percent = 0;
}
data->percent_cpu = percent;
total_per = total_per + percent;
awn_proc_info = g_list_prepend (awn_proc_info,data);
}
g_list_foreach (old_awn_proc_info,(GFunc)g_free,NULL);
g_list_free (old_awn_proc_info);
g_free (p);
old_total_jiffies = total_jiffies;
}
static void
gnc_autoclear_window_ok_cb (GtkWidget *widget,
AutoClearWindow *data)
{
GList *node, *nc_list = 0, *toclear_list = 0;
gnc_numeric toclear_value;
GHashTable *sack;
gtk_label_set_text(data->status_label, "Searching for splits to clear ...");
/* Value we have to reach */
toclear_value = gnc_amount_edit_get_amount(data->end_value);
toclear_value = gnc_numeric_convert(toclear_value, xaccAccountGetCommoditySCU(data->account), GNC_HOW_RND_NEVER);
/* Extract which splits are not cleared and compute the amount we have to clear */
for (node = xaccAccountGetSplitList(data->account); node; node = node->next)
{
Split *split = (Split *)node->data;
char recn;
gnc_numeric value;
recn = xaccSplitGetReconcile (split);
value = xaccSplitGetAmount (split);
if (recn == NREC)
nc_list = g_list_append(nc_list, split);
else
toclear_value = gnc_numeric_sub_fixed(toclear_value, value);
}
/* Pretty print information */
printf("Amount to clear: %s\n", gnc_numeric_to_string(toclear_value));
printf("Available splits:\n");
for (node = nc_list; node; node = node->next)
{
Split *split = (Split *)node->data;
gnc_numeric value = xaccSplitGetAmount (split);
printf(" %s\n", gnc_numeric_to_string(value));
}
/* Run knapsack */
/* Entries in the hash table are:
* - key = amount to which we know how to clear (freed by GHashTable)
* - value = last split we used to clear this amount (not managed by GHashTable)
*/
printf("Knapsacking ...\n");
sack = g_hash_table_new_full (ght_gnc_numeric_hash, ght_gnc_numeric_equal, g_free, NULL);
for (node = nc_list; node; node = node->next)
{
Split *split = (Split *)node->data;
gnc_numeric split_value = xaccSplitGetAmount(split);
GList *node;
struct _sack_foreach_data_t data[1];
data->split_value = split_value;
data->reachable_list = 0;
printf(" Split value: %s\n", gnc_numeric_to_string(split_value));
/* For each value in the sack, compute a new reachable value */
g_hash_table_foreach (sack, sack_foreach_func, data);
/* Add the value of the split itself to the reachable_list */
data->reachable_list = g_list_append(data->reachable_list, g_memdup(&split_value, sizeof(gnc_numeric)));
/* Add everything to the sack, looking out for duplicates */
for (node = data->reachable_list; node; node = node->next)
{
gnc_numeric *reachable_value = node->data;
Split *toinsert_split = split;
printf(" Reachable value: %s ", gnc_numeric_to_string(*reachable_value));
/* Check if it already exists */
if (g_hash_table_lookup_extended(sack, reachable_value, NULL, NULL))
{
/* If yes, we are in trouble, we reached an amount using two solutions */
toinsert_split = NULL;
printf("dup");
}
g_hash_table_insert (sack, reachable_value, toinsert_split);
printf("\n");
}
g_list_free(data->reachable_list);
}
/* Check solution */
printf("Rebuilding solution ...\n");
while (!gnc_numeric_zero_p(toclear_value))
{
gpointer psplit = NULL;
printf(" Left to clear: %s\n", gnc_numeric_to_string(toclear_value));
if (g_hash_table_lookup_extended(sack, &toclear_value, NULL, &psplit))
{
if (psplit != NULL)
{
/* Cast the gpointer to the kind of pointer we actually need */
Split *split = (Split *)psplit;
toclear_list = g_list_prepend(toclear_list, split);
toclear_value = gnc_numeric_sub_fixed(toclear_value,
xaccSplitGetAmount(split));
printf(" Cleared: %s -> %s\n",
gnc_numeric_to_string(xaccSplitGetAmount(split)),
gnc_numeric_to_string(toclear_value));
}
else
{
/* We couldn't reconstruct the solution */
printf(" Solution not unique.\n");
gtk_label_set_text(data->status_label, "Cannot uniquely clear splits. Found multiple possibilities.");
return;
}
}
else
{
printf(" No solution found.\n");
gtk_label_set_text(data->status_label, "The selected amount cannot be cleared.");
return;
}
}
g_hash_table_destroy (sack);
/* Show solution */
printf("Clearing splits:\n");
for (node = toclear_list; node; node = node->next)
{
Split *split = node->data;
char recn;
gnc_numeric value;
recn = xaccSplitGetReconcile (split);
value = xaccSplitGetAmount (split);
printf(" %c %s\n", recn, gnc_numeric_to_string(value));
xaccSplitSetReconcile (split, CREC);
}
if (toclear_list == 0)
printf(" None\n");
/* Free lists */
g_list_free(nc_list);
g_list_free(toclear_list);
/* Close window */
gtk_widget_destroy(data->window);
g_free(data);
}
/*
* @uid: user's uid, list all users if * is passed in.
*/
static GList *ldap_list_users (CcnetUserManager *manager, const char *uid,
int start, int limit)
{
LDAP *ld = NULL;
GList *ret = NULL;
int res;
GString *filter;
char *filter_str;
char *attrs[2];
LDAPMessage *msg = NULL, *entry;
ld = ldap_init_and_bind (manager->ldap_host,
#ifdef WIN32
manager->use_ssl,
#endif
manager->user_dn,
manager->password);
if (!ld)
return NULL;
filter = g_string_new (NULL);
g_string_printf (filter, "(%s=%s)", manager->login_attr, uid);
filter_str = g_string_free (filter, FALSE);
attrs[0] = manager->login_attr;
attrs[1] = NULL;
res = ldap_search_s (ld, manager->base, LDAP_SCOPE_SUBTREE,
filter_str, attrs, 0, &msg);
if (res != LDAP_SUCCESS) {
ccnet_warning ("ldap_search failed: %s.\n", ldap_err2string(res));
ret = NULL;
goto out;
}
int i = 0;
if (start == -1)
start = 0;
for (entry = ldap_first_entry (ld, msg);
entry != NULL;
entry = ldap_next_entry (ld, entry), ++i)
{
char *attr;
char **vals;
BerElement *ber;
CcnetEmailUser *user;
if (i < start)
continue;
if (limit >= 0 && i >= start + limit)
break;
attr = ldap_first_attribute (ld, entry, &ber);
vals = ldap_get_values (ld, entry, attr);
user = g_object_new (CCNET_TYPE_EMAIL_USER,
"id", 0,
"email", vals[0],
"is_staff", FALSE,
"is_active", TRUE,
"ctime", (gint64)0,
NULL);
ret = g_list_prepend (ret, user);
ldap_memfree (attr);
ldap_value_free (vals);
ber_free (ber, 0);
}
out:
ldap_msgfree (msg);
g_free (filter_str);
if (ld) ldap_unbind_s (ld);
return ret;
}
static void fs_Ok_released( GtkButton * button, gpointer user_data )
{
GList * item;
int i = 1, l;
struct stat fs;
gchar * selected;
if( ( stat( fsSelectedFile,&fs ) == 0 ) && S_ISDIR( fs.st_mode ) )
{
if ( chdir( fsSelectedFile ) != 0 ) return;
fsSelectedFile=fsThatDir;
CheckDir( fsFNameList );
gtk_entry_set_text( GTK_ENTRY( fsPathCombo ),(unsigned char *)get_current_dir_name_utf8() );
gtk_widget_grab_focus( fsFNameList );
return;
}
fsSelectedDirectory=(unsigned char *)get_current_dir_name();
switch ( fsType )
{
case fsVideoSelector:
for (l = 0; fsVideoFilterNames[l][0]; l++)
if (strcmp(fsVideoFilterNames[l][0], MSGTR_Filter_Playlists) == 0) break;
uiSetFile( fsSelectedDirectory,fsSelectedFile, fsLastVideoFilterSelected == l ? STREAMTYPE_PLAYLIST : STREAMTYPE_FILE );
selected = g_strconcat(fsSelectedDirectory, "/", fsSelectedFile, NULL);
if (selected)
{
listMgr(PLAYLIST_DELETE, 0);
add_to_gui_playlist(selected, PLAYLIST_ITEM_APPEND);
g_free(selected);
}
guiInfo.NewPlay=GUI_FILE_NEW; sub_fps=0;
fs_PersistantHistory( get_current_dir_name_utf8() ); //totem, write into history
break;
case fsSubtitleSelector:
setddup( &guiInfo.SubtitleFilename,fsSelectedDirectory,fsSelectedFile );
mplayerLoadSubtitle( guiInfo.SubtitleFilename );
break;
/* case fsOtherSelector:
setddup( &guiInfo.Othername,fsSelectedDirectory,fsSelectedFile );
break;*/
case fsAudioSelector:
setddup( &guiInfo.AudioFilename,fsSelectedDirectory,fsSelectedFile );
break;
case fsFontSelector:
setddup( &font_name,fsSelectedDirectory,fsSelectedFile );
mplayerLoadFont();
if ( Preferences ) gtk_entry_set_text( GTK_ENTRY( prEFontName ),font_name );
break;
}
HideFileSelect();
item=fsTopList_items;
while( item )
{
if ( !strcmp( item->data,fsSelectedDirectory ) ) i=0;
item=item->next;
}
if ( i ) fsTopList_items=g_list_prepend( fsTopList_items,(gchar *)get_current_dir_name_utf8() );
if ( uiLoadPlay ) { uiLoadPlay=False; uiEvent( evPlay,0 ); }
else gui( GUI_SET_STATE,(void *) GUI_STOP );
}
/*
* Parse one address from the input stream; if an output stream is
* given, create an item on it for the output address.
*/
static LibBalsaABErr
libbalsa_address_book_ldif_parse_address(FILE * stream,
LibBalsaAddress * address,
FILE * stream_out,
LibBalsaAddress * address_out)
{
gchar *line;
gchar *surname = NULL, *givenname = NULL, *nickname = NULL,
*fullname = NULL, *organization = NULL;
gint in_ldif = FALSE;
GList *address_list = NULL;
guint wrote = 0;
for (; (line=read_line(stream)) != NULL || in_ldif; g_free(line) ) {
if (line) {
/*
* Check if it is a card.
*/
if (g_ascii_strncasecmp(line, "dn:", 3) == 0) {
in_ldif = TRUE;
if (stream_out)
lbab_ldif_write_dn(stream_out, address_out);
continue;
}
if (!in_ldif) {
if (stream_out && *line)
fprintf(stream_out, "%s\n", line);
continue;
}
g_strchomp(line);
}
if (!line || line[0] == '\0') {
LibBalsaABErr res = LBABERR_CANNOT_READ;
/*
* We are done loading a card.
*/
if (address_list) {
if (stream_out) {
if (!(wrote & (1 << LAST_NAME)))
lbab_ldif_write_surname(stream_out, address_out);
if (!(wrote & (1 << FIRST_NAME)))
lbab_ldif_write_givenname(stream_out, address_out);
if (!(wrote & (1 << NICK_NAME)))
lbab_ldif_write_nickname(stream_out, address_out);
if (!(wrote & (1 << ORGANIZATION)))
lbab_ldif_write_organization(stream_out, address_out);
lbab_ldif_write_addresses(stream_out, address_out);
res = fprintf(stream_out, "\n") < 0 ?
LBABERR_CANNOT_WRITE : LBABERR_OK;
}
if (address) {
address_new_prefill(address,
g_list_reverse(address_list),
nickname, givenname, surname,
fullname, organization);
g_free(line);
return LBABERR_OK;
}
g_list_foreach(address_list, (GFunc) g_free, NULL);
g_list_free(address_list);
}
/* Record without e-mail address, or we're not creating
* addresses: free memory. */
g_free(fullname);
g_free(nickname);
g_free(givenname);
g_free(surname);
g_free(organization);
g_free(line);
return res;
}
if (g_ascii_strncasecmp(line, "cn:", 3) == 0) {
fullname = value_spec_to_string(g_strchug(line + 3));
continue;
}
if (g_ascii_strncasecmp(line, "sn:", 3) == 0) {
surname = value_spec_to_string(g_strchug(line + 3));
if (stream_out) {
lbab_ldif_write_surname(stream_out, address_out);
wrote |= 1 << LAST_NAME;
}
continue;
}
if (g_ascii_strncasecmp(line, "givenname:", 10) == 0) {
givenname = value_spec_to_string(g_strchug(line + 10));
if (stream_out) {
lbab_ldif_write_givenname(stream_out, address_out);
wrote |= 1 << FIRST_NAME;
}
continue;
}
if (g_ascii_strncasecmp(line, "xmozillanickname:", 17) == 0) {
nickname = value_spec_to_string(g_strchug(line + 17));
if (stream_out) {
lbab_ldif_write_nickname(stream_out, address_out);
wrote |= 1 << NICK_NAME;
}
continue;
}
if (g_ascii_strncasecmp(line, "o:", 2) == 0) {
organization = value_spec_to_string(g_strchug(line + 2));
if (stream_out) {
lbab_ldif_write_organization(stream_out, address_out);
wrote |= 1 << ORGANIZATION;
}
continue;
}
if (g_ascii_strncasecmp(line, "member:", 7) == 0) {
address_list =
g_list_prepend(address_list,
member_value_to_mail(g_strchug(line + 7)));
continue;
}
/*
* fetch all e-mail fields
*/
if (g_ascii_strncasecmp(line, "mail:", 5) == 0) {
address_list =
g_list_prepend(address_list,
value_spec_to_string(g_strchug(line + 5)));
continue;
}
/*
* unknown line
*/
if (stream_out && *line)
fprintf(stream_out, "%s\n", line);
}
return LBABERR_CANNOT_READ;
}
static guint
fill_contact_info_grid (TpawUserInfo *self)
{
TpConnection *connection;
TpContact *contact;
GList *specs, *l;
guint n_rows = 0;
GList *info;
const char **field_names = tpaw_contact_info_get_field_names (NULL);
guint i;
g_assert (self->priv->details_to_set == NULL);
connection = tp_account_get_connection (self->priv->account);
contact = tp_connection_get_self_contact (connection);
specs = tp_connection_dup_contact_info_supported_fields (connection);
info = tp_contact_dup_contact_info (contact);
/* Look at the fields set in our vCard */
for (l = info; l != NULL; l = l->next)
{
TpContactInfoField *field = l->data;
/* For some reason it can happen that the vCard contains fields the CM
* claims to be not supported. This is a workaround for gabble bug
* https://bugs.freedesktop.org/show_bug.cgi?id=64319. But we shouldn't
* crash on buggy CM anyway. */
if (get_spec_from_list (specs, field->field_name) == NULL)
{
DEBUG ("Buggy CM: self's vCard contains %s field but it is not in "
"Connection' supported fields", field->field_name);
continue;
}
/* make a copy for the details_to_set list */
field = tp_contact_info_field_copy (field);
DEBUG ("Field %s is in our vCard", field->field_name);
self->priv->details_to_set = g_list_prepend (self->priv->details_to_set,
field);
}
/* Add fields which are supported but not in the vCard */
for (i = 0; field_names[i] != NULL; i++)
{
TpContactInfoFieldSpec *spec;
TpContactInfoField *field;
/* Check if the field was in the vCard */
if (field_name_in_field_list (self->priv->details_to_set,
field_names[i]))
continue;
/* Check if the CM supports the field */
spec = get_spec_from_list (specs, field_names[i]);
if (spec == NULL)
continue;
/* add an empty field so user can set a value */
field = tp_contact_info_field_new (spec->name, spec->parameters, NULL);
self->priv->details_to_set = g_list_prepend (self->priv->details_to_set,
field);
}
/* Add widgets for supported fields */
self->priv->details_to_set = g_list_sort (self->priv->details_to_set,
(GCompareFunc) tpaw_contact_info_field_spec_cmp);
for (l = self->priv->details_to_set; l != NULL; l= g_list_next (l))
{
TpContactInfoField *field = l->data;
GtkWidget *label, *w;
TpContactInfoFieldSpec *spec;
gboolean has_field;
char *title;
has_field = tpaw_contact_info_lookup_field (field->field_name,
NULL, NULL);
if (!has_field)
{
/* We don't display this field so we can't change it.
* But we put it in the details_to_set list so it won't be erased
* when calling SetContactInfo (bgo #630427) */
DEBUG ("Unhandled ContactInfo field spec: %s", field->field_name);
continue;
}
spec = get_spec_from_list (specs, field->field_name);
/* We shouldn't have added the field to details_to_set if it's not
* supported by the CM */
g_assert (spec != NULL);
if (spec->flags & TP_CONTACT_INFO_FIELD_FLAG_OVERWRITTEN_BY_NICKNAME)
{
DEBUG ("Ignoring field '%s' due it to having the "
"Overwritten_By_Nickname flag", field->field_name);
continue;
}
/* Add Title */
title = tpaw_contact_info_field_label (field->field_name,
field->parameters,
(spec->flags & TP_CONTACT_INFO_FIELD_FLAG_PARAMETERS_EXACT));
label = gtk_label_new (title);
g_free (title);
/* TODO: if TP_CONTACT_INFO_FIELD_FLAG_PARAMETERS_EXACT is not set we
* should allow user to tag the vCard fields (bgo#672034) */
/* Add Value */
if (!tp_strdiff (field->field_name, "bday"))
{
w = tpaw_calendar_button_new ();
if (field->field_value[0])
{
GDate date;
g_date_set_parse (&date, field->field_value[0]);
if (g_date_valid (&date))
{
tpaw_calendar_button_set_date (TPAW_CALENDAR_BUTTON (w),
&date);
}
}
g_signal_connect (w, "date-changed",
G_CALLBACK (bday_changed_cb), self);
}
else
{
w = gtk_entry_new ();
gtk_entry_set_text (GTK_ENTRY (w),
field->field_value[0] ? field->field_value[0] : "");
g_signal_connect (w, "changed",
G_CALLBACK (contact_info_changed_cb), self);
}
add_row (GTK_GRID (self), label, w, TRUE);
g_object_set_data ((GObject *) w, DATA_FIELD, field);
n_rows++;
}
tp_contact_info_spec_list_free (specs);
tp_contact_info_list_free (info);
return n_rows;
}
/**
* gom_command_builder_build_create:
* @builder: (in): A #GomCommandBuilder.
* @version: the version of the database.
*
* Builds a list of #GomCommand to update the table for the
* resource_type associated with @builder up to @version.
*
* Returns: (element-type GomCommand) (transfer full): A #GList of #GomCommand.
*/
GList *
gom_command_builder_build_create (GomCommandBuilder *builder,
guint version)
{
GomCommandBuilderPrivate *priv;
GomResourceClass *klass;
GomCommand *command;
GList *ret = NULL;
GString *str;
GParamSpec *primary_pspec, **pspecs;
guint n_pspecs;
guint i;
g_return_val_if_fail(GOM_IS_COMMAND_BUILDER(builder), NULL);
g_return_val_if_fail(version >= 1, NULL);
priv = builder->priv;
klass = g_type_class_ref(priv->resource_type);
primary_pspec = g_object_class_find_property(G_OBJECT_CLASS(klass),
klass->primary_key);
g_assert(primary_pspec);
pspecs = g_object_class_list_properties(G_OBJECT_CLASS(klass), &n_pspecs);
/* Create the table if it doesn't already exist*/
if (version == 1) {
str = g_string_new("CREATE TABLE IF NOT EXISTS ");
add_table_name(str, klass);
g_string_append(str, "(");
add_pkey_column(str, klass);
for (i = 0; i < n_pspecs; i++) {
if (pspecs[i] != primary_pspec &&
is_mapped(pspecs[i]) &&
is_new_in_version(pspecs[i], version)) {
g_string_append(str, ",");
g_string_append_printf(str, "'%s' %s",
pspecs[i]->name,
sql_type_for_column (pspecs[i]));
add_reference(str, pspecs[i]);
add_unique(str, pspecs[i]);
add_notnull(str, pspecs[i]);
}
}
g_string_append(str, ")");
command = g_object_new(GOM_TYPE_COMMAND,
"adapter", priv->adapter,
"sql", str->str,
NULL);
ret = g_list_prepend(NULL, command);
g_string_free(str, TRUE);
goto out;
}
/* And now each of the columns for versions > 1 */
for (i = 0; i < n_pspecs; i++) {
if (pspecs[i] != primary_pspec &&
is_mapped(pspecs[i]) &&
is_new_in_version(pspecs[i], version)) {
str = g_string_new("ALTER TABLE ");
add_table_name(str, klass);
g_string_append(str, " ADD COLUMN ");
g_string_append_printf(str, "'%s' %s",
pspecs[i]->name,
sql_type_for_column (pspecs[i]));
add_unique(str, pspecs[i]);
add_notnull(str, pspecs[i]);
add_reference(str, pspecs[i]);
command = g_object_new(GOM_TYPE_COMMAND,
"adapter", priv->adapter,
"sql", str->str,
NULL);
ret = g_list_prepend(ret, command);
g_string_free(str, TRUE);
}
}
out:
g_free(pspecs);
g_type_class_unref(klass);
return g_list_reverse(ret);;
}
static gboolean
ldsm_check_all_mounts (gpointer data)
{
GList *mounts;
GList *l;
GList *check_mounts = NULL;
GList *full_mounts = NULL;
guint number_of_mounts;
guint number_of_full_mounts;
gboolean multiple_volumes = FALSE;
gboolean other_usable_volumes = FALSE;
/* We iterate through the static mounts in /etc/fstab first, seeing if
* they're mounted by checking if the GUnixMountPoint has a corresponding GUnixMountEntry.
* Iterating through the static mounts means we automatically ignore dynamically mounted media.
*/
mounts = g_unix_mount_points_get (time_read);
for (l = mounts; l != NULL; l = l->next) {
GUnixMountPoint *mount_point = l->data;
GUnixMountEntry *mount;
LdsmMountInfo *mount_info;
const gchar *path;
path = g_unix_mount_point_get_mount_path (mount_point);
mount = g_unix_mount_at (path, time_read);
g_unix_mount_point_free (mount_point);
if (mount == NULL) {
/* The GUnixMountPoint is not mounted */
continue;
}
mount_info = g_new0 (LdsmMountInfo, 1);
mount_info->mount = mount;
path = g_unix_mount_get_mount_path (mount);
if (g_unix_mount_is_readonly (mount)) {
ldsm_free_mount_info (mount_info);
continue;
}
if (ldsm_mount_is_user_ignore (g_unix_mount_get_mount_path (mount))) {
ldsm_free_mount_info (mount_info);
continue;
}
if (csd_should_ignore_unix_mount (mount)) {
ldsm_free_mount_info (mount_info);
continue;
}
if (statvfs (path, &mount_info->buf) != 0) {
ldsm_free_mount_info (mount_info);
continue;
}
if (ldsm_mount_is_virtual (mount_info)) {
ldsm_free_mount_info (mount_info);
continue;
}
check_mounts = g_list_prepend (check_mounts, mount_info);
}
g_list_free (mounts);
number_of_mounts = g_list_length (check_mounts);
if (number_of_mounts > 1)
multiple_volumes = TRUE;
for (l = check_mounts; l != NULL; l = l->next) {
LdsmMountInfo *mount_info = l->data;
if (!ldsm_mount_has_space (mount_info)) {
full_mounts = g_list_prepend (full_mounts, mount_info);
} else {
g_hash_table_remove (ldsm_notified_hash, g_unix_mount_get_mount_path (mount_info->mount));
ldsm_free_mount_info (mount_info);
}
}
number_of_full_mounts = g_list_length (full_mounts);
if (number_of_mounts > number_of_full_mounts)
other_usable_volumes = TRUE;
ldsm_maybe_warn_mounts (full_mounts, multiple_volumes,
other_usable_volumes);
g_list_free (check_mounts);
g_list_free (full_mounts);
return TRUE;
}
static void
create_animation (AboutState *state)
{
AboutRenderer *r;
GList *tail;
unsigned ui;
unsigned N = G_N_ELEMENTS (contributors);
unsigned *permutation;
state->now += 500;
r = make_text_item (state, _("Gnumeric is the result of"), 3000);
set_text_motion (r, 0.5, 0.9, 0.5, 0.1);
tail = state->waiting = g_list_prepend (NULL, r);
state->now -= 2000; /* Overlap. */
r = make_text_item (state, _("the efforts of many people."), 3000);
set_text_motion (r, 0.5, 0.9, 0.5, 0.1);
APPENDR (r);
state->now -= 2000; /* Overlap. */
r = make_text_item (state, _("Your help is much appreciated!"), 3000);
set_text_motion (r, 0.5, 0.9, 0.5, 0.1);
APPENDR (r);
permutation = g_new (unsigned, N);
for (ui = 0; ui < N; ui++)
permutation[ui] = ui;
for (ui = 0; ui < N; ui++) {
unsigned pui = (int)(random_01 () * N);
unsigned A = permutation[ui];
permutation[ui] = permutation[pui];
permutation[pui] = A;
}
for (ui = 0; ui < N; ui++) {
unsigned pui = permutation[ui];
const char *name = contributors[pui].name;
int style = ui % 2;
if (ui != 0)
state->now -= 1900; /* Overlap. */
r = make_text_item (state, name, 3000);
switch (style) {
case 0:
set_text_motion (r, 0.5, 0.1, 0.1, 0.9);
if (0) set_text_expansion (r, 1);
break;
case 1:
set_text_motion (r, 0.5, 0.1, 0.9, 0.9);
if (0) set_text_expansion (r, 1);
break;
#if 0
case 2:
set_text_motion (r, 0.5, 0.1, 0.5, 0.9);
set_text_expansion (r, 3);
break;
#endif
}
APPENDR (r);
}
g_free (permutation);
state->now += 1000;
r = make_text_item (state, _("We apologize if anyone was left out."),
3000);
set_text_motion (r, 0.5, 0.9, 0.5, 0.1);
APPENDR (r);
state->now -= 2000; /* Overlap. */
r = make_text_item (state, _("Please contact us to correct mistakes."),
3000);
set_text_motion (r, 0.5, 0.9, 0.5, 0.1);
APPENDR (r);
state->now -= 2000; /* Overlap. */
r = make_text_item (state, _("Report problems at http://bugzilla.gnome.org"), 3000);
set_text_motion (r, 0.5, 0.9, 0.5, 0.1);
APPENDR (r);
r = make_text_item (state, _("We aim to please!"), 3000);
r->fade_out = FALSE;
APPENDR (r);
state->now -= 100; /* Overlap. */
r = make_text_item (state, _("We aim to please!"), 1000);
r->fade_in = FALSE;
set_text_expansion (r, 4);
APPENDR (r);
state->now = 0;
}
static void
glade_gtk_table_child_insert_remove_action (GladeWidgetAdaptor *adaptor,
GObject *container,
GObject *object,
GroupAction group_action,
const gchar *n_row_col,
const gchar *attach1, /* should be smaller (top/left) attachment */
const gchar *attach2, /* should be larger (bot/right) attachment */
gboolean remove,
gboolean after)
{
GladeWidget *parent;
GList *children, *l;
gint child_pos, size, offset;
gtk_container_child_get (GTK_CONTAINER (container),
GTK_WIDGET (object),
after ? attach2 : attach1, &child_pos, NULL);
parent = glade_widget_get_from_gobject (container);
switch (group_action)
{
case GROUP_ACTION_INSERT_ROW:
glade_command_push_group (_("Insert Row on %s"), glade_widget_get_name (parent));
break;
case GROUP_ACTION_INSERT_COLUMN:
glade_command_push_group (_("Insert Column on %s"), glade_widget_get_name (parent));
break;
case GROUP_ACTION_REMOVE_COLUMN:
glade_command_push_group (_("Remove Column on %s"), glade_widget_get_name (parent));
break;
case GROUP_ACTION_REMOVE_ROW:
glade_command_push_group (_("Remove Row on %s"), glade_widget_get_name (parent));
break;
default:
g_assert_not_reached ();
}
children = glade_widget_adaptor_get_children (adaptor, container);
/* Make sure widgets does not get destroyed */
g_list_foreach (children, (GFunc) g_object_ref, NULL);
glade_widget_property_get (parent, n_row_col, &size);
if (remove)
{
GList *del = NULL;
/* Remove children first */
for (l = children; l; l = g_list_next (l))
{
GladeWidget *gchild = glade_widget_get_from_gobject (l->data);
gint pos1, pos2;
/* Skip placeholders */
if (gchild == NULL)
continue;
glade_widget_pack_property_get (gchild, attach1, &pos1);
glade_widget_pack_property_get (gchild, attach2, &pos2);
if ((pos1 + 1 == pos2) && ((after ? pos2 : pos1) == child_pos))
{
del = g_list_prepend (del, gchild);
}
}
if (del)
{
glade_command_delete (del);
g_list_free (del);
}
offset = -1;
}
else
{
/* Expand the table */
glade_command_set_property (glade_widget_get_property (parent, n_row_col),
size + 1);
offset = 1;
}
/* Reorder children */
for (l = children; l; l = g_list_next (l))
{
GladeWidget *gchild = glade_widget_get_from_gobject (l->data);
gint pos;
/* Skip placeholders */
if (gchild == NULL)
continue;
/* if removing, do top/left before bot/right */
if (remove)
{
/* adjust top-left attachment */
glade_widget_pack_property_get (gchild, attach1, &pos);
if (pos > child_pos || (after && pos == child_pos))
{
glade_command_set_property (glade_widget_get_pack_property
(gchild, attach1), pos + offset);
}
/* adjust bottom-right attachment */
glade_widget_pack_property_get (gchild, attach2, &pos);
if (pos > child_pos || (after && pos == child_pos))
{
glade_command_set_property (glade_widget_get_pack_property
(gchild, attach2), pos + offset);
}
}
/* if inserting, do bot/right before top/left */
else
{
/* adjust bottom-right attachment */
glade_widget_pack_property_get (gchild, attach2, &pos);
if (pos > child_pos)
{
glade_command_set_property (glade_widget_get_pack_property
(gchild, attach2), pos + offset);
}
/* adjust top-left attachment */
glade_widget_pack_property_get (gchild, attach1, &pos);
if (pos >= child_pos)
{
glade_command_set_property (glade_widget_get_pack_property
(gchild, attach1), pos + offset);
}
}
}
if (remove)
{
/* Shrink the table */
glade_command_set_property (glade_widget_get_property (parent, n_row_col),
size - 1);
}
g_list_foreach (children, (GFunc) g_object_unref, NULL);
g_list_free (children);
glade_command_pop_group ();
}
static void flush_pending_metadata_to_save (ItemHandler *item, ...)
{
gboolean to_free;
gchar *stats;
gchar *query;
gchar *useless;
gchar *uri;
va_list params;
gpointer key;
gpointer value;
GList *statements;
GHashTable *table;
GHashTableIter iter;
GVariant *results;
GVariant *rows;
GVariant *sub_value;
GVariant *sub_sub_value;
GVariantIter r_iter;
GVariantIter sub_iter;
GVariantIter sub_sub_iter;
GError *error;
Property *prop;
statements = NULL;
va_start (params, item);
while ((table = va_arg (params, GHashTable*)) != NULL) {
to_free = va_arg (params, gboolean);
g_hash_table_iter_init (&iter, table);
while (g_hash_table_iter_next (&iter, &key, &value)) {
prop = properties_pool_get_by_name ((gchar*) key);
switch (property_get_datatype (prop)) {
case PROPERTY_TYPE_STRING:
stats = g_strdup_printf ("%s \"%s\"", (gchar*) key, (gchar*) value);
statements = g_list_prepend (statements, stats);
break;
case PROPERTY_TYPE_RESOURCE:
stats = g_strdup_printf ("%s <%s>", (gchar*) key, (gchar*) value);
statements = g_list_prepend (statements, stats);
break;
default:
stats = g_strdup_printf ("%s %s", (gchar*) key, (gchar*) value);
statements = g_list_prepend (statements, stats);
break;
}
}
if (to_free == TRUE)
g_hash_table_foreach_remove (table, destroy_value_in_hash, NULL);
}
va_end (params);
if (statements == NULL)
return;
stats = from_glist_to_string (statements, " ; ", TRUE);
query = g_strdup_printf ("INSERT { _:item a nfo:FileDataObject ; a nie:InformationElement ; %s }", stats);
g_free (stats);
error = NULL;
results = execute_update_blank (query, &error);
if (error != NULL) {
g_warning ("Error while saving metadata: %s", error->message);
g_error_free (error);
}
else {
/*
To know how to iter a SparqlUpdateBlank response, cfr.
http://mail.gnome.org/archives/commits-list/2011-February/msg05384.html
*/
g_variant_iter_init (&r_iter, results);
if ((rows = g_variant_iter_next_value (&r_iter))) {
g_variant_iter_init (&sub_iter, rows);
if ((sub_value = g_variant_iter_next_value (&sub_iter))) {
g_variant_iter_init (&sub_sub_iter, sub_value);
if ((sub_sub_value = g_variant_iter_next_value (&sub_sub_iter))) {
useless = NULL;
uri = NULL;
g_variant_get (sub_sub_value, "a{ss}", &useless, &uri);
item->priv->subject = g_strdup (uri);
g_variant_unref (sub_sub_value);
}
g_variant_unref (sub_value);
}
g_variant_unref (rows);
}
}
g_free (query);
}
/* Use this function to set the directory containing installed pixmaps. */
void
add_pixmap_directory (const gchar *directory)
{
pixmaps_directories = g_list_prepend (pixmaps_directories,
g_strdup (directory));
}
void interrupter_add(struct db *db)
{
sigstate.interrupter_dbs = g_list_prepend(sigstate.interrupter_dbs, db);
}
