/** * 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); }