char *do_message(SPDMessageType msgtype) { int ret; char *cur_line; GString *msg; size_t n; int nlines = 0; msg = g_string_new(""); printf("202 OK RECEIVING MESSAGE\n"); fflush(stdout); while (1) { cur_line = NULL; n = 0; ret = spd_getline(&cur_line, &n, stdin); nlines++; if (ret == -1) return g_strdup("401 ERROR INTERNAL"); if (!strcmp(cur_line, "..\n")) { g_free(cur_line); cur_line = g_strdup(".\n"); } else if (!strcmp(cur_line, ".\n")) { /* Strip the trailing \n */ msg->str[strlen(msg->str) - 1] = 0; g_free(cur_line); break; } g_string_append(msg, cur_line); g_free(cur_line); } if ((msgtype != SPD_MSGTYPE_TEXT) && (nlines > 2)) { return g_strdup("305 DATA MORE THAN ONE LINE"); } if ((msgtype == SPD_MSGTYPE_CHAR) && (!strcmp(msg->str, "space"))) { g_string_free(msg, 1); msg = g_string_new(" "); } /* no sure we need this check here at all */ if (msg->str == NULL || msg->str[0] == 0) { DBG("requested data NULL or empty\n"); g_string_free(msg, TRUE); return g_strdup("301 ERROR CANT SPEAK"); } /* check voice and synthesis_voice settings for consistency */ if (msg_settings.voice.name == NULL && msg_settings_old.voice.name != NULL && msg_settings.voice_type == msg_settings_old.voice_type) { /* force to set voice again, since synthesis_voice changed to NULL */ msg_settings_old.voice_type = -1; } /* Volume is controlled by the synthesizer. Always play at normal on audio device. */ if (spd_audio_set_volume(module_audio_id, 85) < 0) { DBG("Can't set volume. audio not initialized?"); } ret = module_speak(msg->str, strlen(msg->str), msgtype); g_string_free(msg, 1); if (ret <= 0) return g_strdup("301 ERROR CANT SPEAK"); return g_strdup("200 OK SPEAKING"); }
/** * 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);; }
/** * gom_command_builder_build_update: * @builder: A #GomCommandBuilder. * @resource: a #GomResource * * Builds a new #GomCommand that will update the contents stored for @resource * in the underlying database. * * Returns: (transfer full): A #GomCommand. */ GomCommand * gom_command_builder_build_update (GomCommandBuilder *builder, GomResource *resource) { GomCommandBuilderPrivate *priv; GomResourceClass *klass; GomCommand *command = NULL; GParamSpec **pspecs = NULL; gboolean did_pspec = FALSE; GString *str = NULL; guint n_pspecs = 0; guint i = 0; guint idx = 0; g_return_val_if_fail(GOM_IS_COMMAND_BUILDER(builder), NULL); priv = builder->priv; klass = g_type_class_ref(priv->resource_type); pspecs = g_object_class_list_properties(G_OBJECT_CLASS(klass), &n_pspecs); str = g_string_new("UPDATE "); g_string_append_printf(str, "%s SET ", klass->table); for (i = 0; i < n_pspecs; i++) { if (do_prop_on_insert(pspecs[i], klass, priv->resource_type)) { if (did_pspec) { g_string_append(str, ", "); } g_string_append_printf(str, "'%s' = ?", pspecs[i]->name); did_pspec = TRUE; } } g_string_append_printf(str, " WHERE '%s'.'%s' = ?;", klass->table, klass->primary_key); command = g_object_new(GOM_TYPE_COMMAND, "adapter", priv->adapter, "sql", str->str, NULL); for (i = 0; i < n_pspecs; i++) { if (do_prop_on_insert(pspecs[i], klass, priv->resource_type)) { GValue value = { 0 }; resource_get_property(G_OBJECT(resource), pspecs[i]->name, &value); gom_command_set_param(command, idx++, &value); g_value_unset(&value); } } { GParamSpec *pspec; GValue value = { 0 }; pspec = g_object_class_find_property(G_OBJECT_GET_CLASS(resource), klass->primary_key); g_assert(pspec); g_value_init(&value, pspec->value_type); g_object_get_property(G_OBJECT(resource), pspec->name, &value); gom_command_set_param(command, idx++, &value); g_value_unset(&value); } g_type_class_unref(klass); if (str) { g_string_free(str, TRUE); } g_free(pspecs); return command; }
char* p_gpg_decrypt(const char *const cipher) { gpgme_ctx_t ctx; gpgme_error_t error = gpgme_new(&ctx); if (error) { log_error("GPG: Failed to create gpgme context. %s %s", gpgme_strsource(error), gpgme_strerror(error)); return NULL; } gpgme_set_passphrase_cb(ctx, (gpgme_passphrase_cb_t)_p_gpg_passphrase_cb, NULL); char *cipher_with_headers = _add_header_footer(cipher, PGP_MESSAGE_HEADER, PGP_MESSAGE_FOOTER); gpgme_data_t cipher_data; gpgme_data_new_from_mem(&cipher_data, cipher_with_headers, strlen(cipher_with_headers), 1); free(cipher_with_headers); gpgme_data_t plain_data; gpgme_data_new(&plain_data); error = gpgme_op_decrypt(ctx, cipher_data, plain_data); gpgme_data_release(cipher_data); if (error) { log_error("GPG: Failed to encrypt message. %s %s", gpgme_strsource(error), gpgme_strerror(error)); gpgme_data_release(plain_data); gpgme_release(ctx); return NULL; } gpgme_decrypt_result_t res = gpgme_op_decrypt_result(ctx); if (res) { GString *recipients_str = g_string_new(""); gpgme_recipient_t recipient = res->recipients; while (recipient) { gpgme_key_t key; error = gpgme_get_key(ctx, recipient->keyid, &key, 1); if (!error && key) { const char *addr = gpgme_key_get_string_attr(key, GPGME_ATTR_EMAIL, NULL, 0); if (addr) { g_string_append(recipients_str, addr); } gpgme_key_unref(key); } if (recipient->next) { g_string_append(recipients_str, ", "); } recipient = recipient->next; } log_debug("GPG: Decrypted message for recipients: %s", recipients_str->str); g_string_free(recipients_str, TRUE); } gpgme_release(ctx); size_t len = 0; char *plain_str = gpgme_data_release_and_get_mem(plain_data, &len); char *result = NULL; if (plain_str) { plain_str[len] = 0; result = g_strdup(plain_str); } gpgme_free(plain_str); if (passphrase_attempt) { passphrase = strdup(passphrase_attempt); } return result; }
gchar * wtap_get_debug_if_descr(const wtapng_if_descr_t *if_descr, const int indent, const char* line_end) { GString *info = g_string_new(""); g_assert(if_descr); g_string_printf(info, "%*cName = %s%s", indent, ' ', if_descr->if_name ? if_descr->if_name : "UNKNOWN", line_end); g_string_append_printf(info, "%*cDescription = %s%s", indent, ' ', if_descr->if_description ? if_descr->if_description : "NONE", line_end); g_string_append_printf(info, "%*cEncapsulation = %s (%d/%u - %s)%s", indent, ' ', wtap_encap_string(if_descr->wtap_encap), if_descr->wtap_encap, if_descr->link_type, wtap_encap_short_string(if_descr->wtap_encap), line_end); g_string_append_printf(info, "%*cSpeed = %" G_GINT64_MODIFIER "u%s", indent, ' ', if_descr->if_speed, line_end); g_string_append_printf(info, "%*cCapture length = %u%s", indent, ' ', if_descr->snap_len, line_end); g_string_append_printf(info, "%*cFCS length = %d%s", indent, ' ', if_descr->if_fcslen, line_end); g_string_append_printf(info, "%*cTime precision = %s (%d)%s", indent, ' ', wtap_tsprec_string(if_descr->tsprecision), if_descr->tsprecision, line_end); g_string_append_printf(info, "%*cTime ticks per second = %" G_GINT64_MODIFIER "u%s", indent, ' ', if_descr->time_units_per_second, line_end); g_string_append_printf(info, "%*cTime resolution = 0x%.2x%s", indent, ' ', if_descr->if_tsresol, line_end); g_string_append_printf(info, "%*cFilter string = %s%s", indent, ' ', if_descr->if_filter_str ? if_descr->if_filter_str : "NONE", line_end); g_string_append_printf(info, "%*cOperating system = %s%s", indent, ' ', if_descr->if_os ? if_descr->if_os : "UNKNOWN", line_end); g_string_append_printf(info, "%*cComment = %s%s", indent, ' ', if_descr->opt_comment ? if_descr->opt_comment : "NONE", line_end); g_string_append_printf(info, "%*cBPF filter length = %u%s", indent, ' ', if_descr->bpf_filter_len, line_end); g_string_append_printf(info, "%*cNumber of stat entries = %u%s", indent, ' ', if_descr->num_stat_entries, line_end); return g_string_free(info, FALSE); }
// Parse NCBI GI to taxon_id mapping from tab-delimited text file. If output_map_file is specified // then the function will also write out the subset of the mapping that pertains to the reference // sequence GIs in refseq_gi_ht. // // input_map_file Tab-delimited NCBI GI to NCBI taxon_id mapping file to read. // output_map_file Optional output file. If not NULL the subset of input_map_file that // corresponds to refseq_gi_ht will be written to this file. // bam_header Pointer to the header for one of the alignment BAM files. // refseq_gi_ht The refseq GI to target index mapping hashtable generated by build_refseq_hash // target_gids NCBI GI parsed for each refseq referenced in the bam_header. // // Returns a GHashTable that maps reference sequence NCBI GI to NCBI taxon_id, as per input_map_file. // GHashTable *read_gi_to_taxon_map(char *input_map_file, char *output_map_file, bam_header_t *bam_header, GHashTable *refseq_gi_ht, int *target_gids, gboolean verbose) { // mapping from GI to taxon_id parsed from the mapping file GHashTable *gi_to_tid_ht = g_hash_table_new(g_int_hash, g_int_equal); // --------------------------------------------------------------------------------- // step 1: parse GI to taxon_id mapping from input_map_file // --------------------------------------------------------------------------------- GIOChannel *ofh = NULL; // in this mode we write out the subset of the mapping that corresponds to the input refseqs, but do nothing else if (output_map_file != NULL) { ofh = g_io_channel_new_file(output_map_file, "w", NULL); if (ofh == NULL) { fprintf(stderr, "ERROR - failed to open %s to write subset of NCBI GI -> taxon_id mapping", output_map_file); return NULL; } } // read NCBI mapping file fprintf(stderr, "reading %s\n", input_map_file); GIOChannel *fh = g_io_channel_new_file(input_map_file, "r", NULL); if (fh == NULL) { fprintf(stderr, "ERROR - failed to read from NCBI GI -> taxon_id mapping file %s\n", input_map_file); return NULL; } // parse NCBI GI and NCBI taxon_id from mapping file GRegex *ncbi_gi_re = g_regex_new("^(\\d+)\\t(\\d+)$", 0, 0, NULL); gchar *line; int linenum = 0; int gid; int tid; int *gids = NULL; int *tids = NULL; int tidnum = 0; GIOStatus rs; gsize bytecount; GMatchInfo *match_info = NULL; // only store GI -> taxon_id mapping when not running on the full mapping file (which is very large) if (output_map_file == NULL) { // HACK: these arrays aren't currently freed anywhere gids = g_malloc(sizeof(int) * bam_header->n_targets); tids = g_malloc(sizeof(int) * bam_header->n_targets); } while (rs = g_io_channel_read_line(fh, &line, NULL, NULL, NULL)) { if ((line == NULL) || (rs != G_IO_STATUS_NORMAL)) break; ++linenum; // apply regex to parse GI and taxon_id, check whether GI is needed, and store the mapping if so if (g_regex_match(ncbi_gi_re, line, 0, &match_info)) { while (g_match_info_matches(match_info)) { gchar *gi_str = g_match_info_fetch(match_info, 1); gchar *tid_str = g_match_info_fetch(match_info, 2); sscanf(gi_str, "%d", &gid); g_free(gi_str); sscanf(tid_str, "%d", &tid); g_free(tid_str); // check gi against hashtable of all refseq gis, store mapping if it matches if (g_hash_table_lookup(refseq_gi_ht, &gid) != NULL) { // sanity check if (tidnum > bam_header->n_targets) { fprintf(stderr, "ERROR - read more than %d distinct taxon_ids", bam_header->n_targets); return NULL; } // either store the mapping from GI to taxon_id for later use if (output_map_file == NULL) { gids[tidnum] = gid; tids[tidnum] = tid; g_hash_table_insert(gi_to_tid_ht, &gids[tidnum], &tids[tidnum]); } // OR echo the relevant line to the output file if (ofh != NULL) { GIOStatus ws = g_io_channel_write_chars(ofh, line, -1, &bytecount, NULL); if (ws != G_IO_STATUS_NORMAL) { fprintf(stderr, "ERROR - GLib error writing to %s\n", output_map_file); return NULL; } } ++tidnum; } g_match_info_next(match_info, NULL); } } else { fprintf(stderr, "ERROR - couldn't parse line %d of %s\n", linenum, input_map_file); return NULL; } g_match_info_free(match_info); if (line != NULL) g_free(line); // print progress updates if ((linenum % PROGRESS_INTERVAL_ROWS) == 0) { if (verbose) fprintf(stderr, "INFO - read progress: %d line(s), %d recorded taxon id(s)\n", linenum, tidnum); } } if ((rs != G_IO_STATUS_NORMAL) && (rs != G_IO_STATUS_EOF)) { fprintf(stderr, "ERROR - GLib error reading from %s\n", input_map_file); return NULL; } fprintf(stderr, "read %d line(s) from %s and recorded %d GI -> taxon_id mapping(s) for %d distinct refseqs\n", linenum, input_map_file, tidnum, bam_header->n_targets); g_regex_unref(ncbi_gi_re); g_io_channel_shutdown(fh, TRUE, NULL); if (ofh != NULL) g_io_channel_shutdown(ofh, TRUE, NULL); // --------------------------------------------------------------------------------- // step 2: generate dummy GI and taxon_ids for any reference seqs that lack either // --------------------------------------------------------------------------------- // count affected refseqs int refseqs_no_gi = 0; int refseqs_no_ti = 0; // hashtable of newly-generated taxon_ids, indexed by organism name GHashTable *new_taxon_id_ht = g_hash_table_new(g_str_hash, g_str_equal); // HACK: this array isn't currently freed anywhere int *target_tids = g_malloc(sizeof(int) * bam_header->n_targets); int i; for (i = 0;i < bam_header->n_targets; ++i) { if (target_gids[i] <= FIRST_UNKNOWN_GI) { if (verbose) fprintf(stderr, "WARN - no GI found for target %d: %s\n", i, bam_header->target_name[i]); ++refseqs_no_gi; } int *taxon_id = (int *)g_hash_table_lookup(gi_to_tid_ht, &target_gids[i]); if (taxon_id == NULL) { // only count those that have a GI but no taxon id if (target_gids[i] > FIRST_UNKNOWN_GI) { if (verbose) fprintf(stderr, "WARN - no taxon_id found for target %d: %s\n", i, bam_header->target_name[i]); ++refseqs_no_ti; } // parse organism name from target name // HACK - this is specific to the HMP query sequence set GString *org_name = NULL; GRegex *org_name_re = g_regex_new("\\|([a-zA-Z\\_\\.\\d\\-]+)\\_Cont\\d+\\.\\d+\\|", 0, 0, NULL); GMatchInfo *org_match_info = NULL; if (g_regex_match(org_name_re, bam_header->target_name[i], 0, &org_match_info)) { while (g_match_info_matches(org_match_info)) { gchar *m1 = g_match_info_fetch(org_match_info, 1); org_name = g_string_new(m1); // NOTE - not freeing org_name since it will be used as a hashtable key g_match_info_next(org_match_info, NULL); } } else { fprintf(stderr, "ERROR - unable to parse organism name from the following refseq name: %s\n", bam_header->target_name[i]); return NULL; } g_match_info_free(org_match_info); g_regex_unref(org_name_re); // generate a new taxon_id, if necessary, and assign this gi to it taxon_id = (int *)g_hash_table_lookup(new_taxon_id_ht, org_name->str); if (taxon_id == NULL) { target_tids[i] = new_taxon_id--; if (verbose) fprintf(stderr, "INFO - assigning new taxon_id=%d to '%s'\n", target_tids[i], org_name->str); g_hash_table_insert(new_taxon_id_ht, org_name->str, &target_tids[i]); taxon_id = &target_tids[i]; } else { target_tids[i] = *taxon_id; } g_hash_table_insert(gi_to_tid_ht, &target_gids[i], &target_tids[i]); } target_tids[i] = *taxon_id; } fprintf(stderr, "found %d/%d refseqs with no GI\n", refseqs_no_gi, bam_header->n_targets); fprintf(stderr, "found %d/%d refseqs with a GI but no taxon_id\n", refseqs_no_ti, bam_header->n_targets); return gi_to_tid_ht; }
char* p_gpg_sign(const char *const str, const char *const fp) { gpgme_ctx_t ctx; gpgme_error_t error = gpgme_new(&ctx); if (error) { log_error("GPG: Failed to create gpgme context. %s %s", gpgme_strsource(error), gpgme_strerror(error)); return NULL; } gpgme_set_passphrase_cb(ctx, (gpgme_passphrase_cb_t)_p_gpg_passphrase_cb, NULL); gpgme_key_t key = NULL; error = gpgme_get_key(ctx, fp, &key, 1); if (error || key == NULL) { log_error("GPG: Failed to get key. %s %s", gpgme_strsource(error), gpgme_strerror(error)); gpgme_release(ctx); return NULL; } gpgme_signers_clear(ctx); error = gpgme_signers_add(ctx, key); gpgme_key_unref(key); if (error) { log_error("GPG: Failed to load signer. %s %s", gpgme_strsource(error), gpgme_strerror(error)); gpgme_release(ctx); return NULL; } char *str_or_empty = NULL; if (str) { str_or_empty = strdup(str); } else { str_or_empty = strdup(""); } gpgme_data_t str_data; gpgme_data_new_from_mem(&str_data, str_or_empty, strlen(str_or_empty), 1); free(str_or_empty); gpgme_data_t signed_data; gpgme_data_new(&signed_data); gpgme_set_armor(ctx,1); error = gpgme_op_sign(ctx, str_data, signed_data, GPGME_SIG_MODE_DETACH); gpgme_data_release(str_data); gpgme_release(ctx); if (error) { log_error("GPG: Failed to sign string. %s %s", gpgme_strsource(error), gpgme_strerror(error)); gpgme_data_release(signed_data); return NULL; } char *result = NULL; size_t len = 0; char *signed_str = gpgme_data_release_and_get_mem(signed_data, &len); if (signed_str) { GString *signed_gstr = g_string_new(""); g_string_append_len(signed_gstr, signed_str, len); result = _remove_header_footer(signed_gstr->str, PGP_SIGNATURE_FOOTER); g_string_free(signed_gstr, TRUE); gpgme_free(signed_str); } if (passphrase_attempt) { passphrase = strdup(passphrase_attempt); } return result; }
/* * Parse Exec command line of app desktop file, and translate * it into a real command which can be passed to g_spawn_command_line_async(). * file_list is a null-terminated file list containing full * paths of the files passed to app. * returned char* should be freed when no longer needed. */ static char* translate_app_exec_to_command_line( VFSAppDesktop* app, GList* file_list ) { const char* pexec = vfs_app_desktop_get_exec( app ); char* file; GList* l; gchar *tmp; GString* cmd = g_string_new(""); gboolean add_files = FALSE; for( ; *pexec; ++pexec ) { if( *pexec == '%' ) { ++pexec; switch( *pexec ) { case 'U': for( l = file_list; l; l = l->next ) { tmp = g_filename_to_uri( (char*)l->data, NULL, NULL ); file = g_shell_quote( tmp ); g_free( tmp ); g_string_append( cmd, file ); g_string_append_c( cmd, ' ' ); g_free( file ); } add_files = TRUE; break; case 'u': if( file_list && file_list->data ) { file = (char*)file_list->data; tmp = g_filename_to_uri( file, NULL, NULL ); file = g_shell_quote( tmp ); g_free( tmp ); g_string_append( cmd, file ); g_free( file ); add_files = TRUE; } break; case 'F': case 'N': for( l = file_list; l; l = l->next ) { file = (char*)l->data; tmp = g_shell_quote( file ); g_string_append( cmd, tmp ); g_string_append_c( cmd, ' ' ); g_free( tmp ); } add_files = TRUE; break; case 'f': case 'n': if( file_list && file_list->data ) { file = (char*)file_list->data; tmp = g_shell_quote( file ); g_string_append( cmd, tmp ); g_free( tmp ); add_files = TRUE; } break; case 'D': for( l = file_list; l; l = l->next ) { tmp = g_path_get_dirname( (char*)l->data ); file = g_shell_quote( tmp ); g_free( tmp ); g_string_append( cmd, file ); g_string_append_c( cmd, ' ' ); g_free( file ); } add_files = TRUE; break; case 'd': if( file_list && file_list->data ) { tmp = g_path_get_dirname( (char*)file_list->data ); file = g_shell_quote( tmp ); g_free( tmp ); g_string_append( cmd, file ); g_free( tmp ); add_files = TRUE; } break; case 'c': g_string_append( cmd, vfs_app_desktop_get_disp_name( app ) ); break; case 'i': /* Add icon name */ if( vfs_app_desktop_get_icon_name( app ) ) { g_string_append( cmd, "--icon " ); g_string_append( cmd, vfs_app_desktop_get_icon_name( app ) ); } break; case 'k': /* Location of the desktop file */ break; case 'v': /* Device name */ break; case '%': g_string_append_c ( cmd, '%' ); break; case '\0': goto _finish; break; } } else /* not % escaped part */ { g_string_append_c ( cmd, *pexec ); } } _finish: if( ! add_files ) { g_string_append_c ( cmd, ' ' ); for( l = file_list; l; l = l->next ) { file = (char*)l->data; tmp = g_shell_quote( file ); g_string_append( cmd, tmp ); g_string_append_c( cmd, ' ' ); g_free( tmp ); } } return g_string_free( cmd, FALSE ); }
char * get_random_hint (int force) { char *data, *result = NULL, *eop; int len; int start; static int last_sec; static struct timeval tv; GIConv conv; /* Do not change hints more often than one minute */ gettimeofday (&tv, NULL); if (!force && !(tv.tv_sec > last_sec + 60)) return g_strdup (""); last_sec = tv.tv_sec; data = load_mc_home_file (mc_global.share_data_dir, MC_HINT, NULL); if (data == NULL) return NULL; /* get a random entry */ srand (tv.tv_sec); len = strlen (data); start = rand () % (len - 1); /* Search the start of paragraph */ for (; start != 0; start--) if (data[start] == '\n' && data[start + 1] == '\n') { start += 2; break; } /* Search the end of paragraph */ for (eop = data + start; *eop != '\0'; eop++) { if (*eop == '\n' && *(eop + 1) == '\n') { *eop = '\0'; break; } if (*eop == '\n') *eop = ' '; } /* hint files are stored in utf-8 */ /* try convert hint file from utf-8 to terminal encoding */ conv = str_crt_conv_from ("UTF-8"); if (conv != INVALID_CONV) { GString *buffer; buffer = g_string_new (""); if (str_convert (conv, &data[start], buffer) != ESTR_FAILURE) result = g_string_free (buffer, FALSE); else g_string_free (buffer, TRUE); str_close_conv (conv); } else result = g_strdup (&data[start]); g_free (data); return result; }
/** * gst_rtsp_sdp_from_media: * @sdp: a #GstSDPMessage * @info: info * @media: a #GstRTSPMedia * * Add @media specific info to @sdp. @info is used to configure the connection * information in the SDP. * * Returns: TRUE on success. */ gboolean gst_rtsp_sdp_from_media (GstSDPMessage * sdp, GstSDPInfo * info, GstRTSPMedia * media) { guint i, n_streams; gchar *rangestr; n_streams = gst_rtsp_media_n_streams (media); rangestr = gst_rtsp_media_get_range_string (media, FALSE, GST_RTSP_RANGE_NPT); if (rangestr == NULL) goto not_prepared; gst_sdp_message_add_attribute (sdp, "range", rangestr); g_free (rangestr); for (i = 0; i < n_streams; i++) { GstRTSPStream *stream; GstSDPMedia *smedia; GstStructure *s; const gchar *caps_str, *caps_enc, *caps_params; gchar *tmp; gint caps_pt, caps_rate; guint n_fields, j; gboolean first; GString *fmtp; GstCaps *caps; stream = gst_rtsp_media_get_stream (media, i); caps = gst_rtsp_stream_get_caps (stream); if (caps == NULL) { g_warning ("ignoring stream %d without media type", i); continue; } s = gst_caps_get_structure (caps, 0); if (s == NULL) { gst_caps_unref (caps); g_warning ("ignoring stream %d without media type", i); continue; } gst_sdp_media_new (&smedia); /* get media type and payload for the m= line */ caps_str = gst_structure_get_string (s, "media"); gst_sdp_media_set_media (smedia, caps_str); gst_structure_get_int (s, "payload", &caps_pt); tmp = g_strdup_printf ("%d", caps_pt); gst_sdp_media_add_format (smedia, tmp); g_free (tmp); gst_sdp_media_set_port_info (smedia, 0, 1); gst_sdp_media_set_proto (smedia, "RTP/AVP"); /* for the c= line */ if (info->is_ipv6) { gst_sdp_media_add_connection (smedia, "IN", "IP6", "::", 16, 0); } else { gst_sdp_media_add_connection (smedia, "IN", "IP4", "0.0.0.0", 16, 0); } /* get clock-rate, media type and params for the rtpmap attribute */ gst_structure_get_int (s, "clock-rate", &caps_rate); caps_enc = gst_structure_get_string (s, "encoding-name"); caps_params = gst_structure_get_string (s, "encoding-params"); if (caps_enc) { if (caps_params) tmp = g_strdup_printf ("%d %s/%d/%s", caps_pt, caps_enc, caps_rate, caps_params); else tmp = g_strdup_printf ("%d %s/%d", caps_pt, caps_enc, caps_rate); gst_sdp_media_add_attribute (smedia, "rtpmap", tmp); g_free (tmp); } /* the config uri */ tmp = gst_rtsp_stream_get_control (stream); gst_sdp_media_add_attribute (smedia, "control", tmp); g_free (tmp); /* collect all other properties and add them to fmtp or attributes */ fmtp = g_string_new (""); g_string_append_printf (fmtp, "%d ", caps_pt); first = TRUE; n_fields = gst_structure_n_fields (s); for (j = 0; j < n_fields; j++) { const gchar *fname, *fval; fname = gst_structure_nth_field_name (s, j); /* filter out standard properties */ if (!strcmp (fname, "media")) continue; if (!strcmp (fname, "payload")) continue; if (!strcmp (fname, "clock-rate")) continue; if (!strcmp (fname, "encoding-name")) continue; if (!strcmp (fname, "encoding-params")) continue; if (!strcmp (fname, "ssrc")) continue; if (!strcmp (fname, "clock-base")) continue; if (!strcmp (fname, "seqnum-base")) continue; if (g_str_has_prefix (fname, "a-")) { /* attribute */ if ((fval = gst_structure_get_string (s, fname))) gst_sdp_media_add_attribute (smedia, fname + 2, fval); continue; } if (g_str_has_prefix (fname, "x-")) { /* attribute */ if ((fval = gst_structure_get_string (s, fname))) gst_sdp_media_add_attribute (smedia, fname, fval); continue; } if ((fval = gst_structure_get_string (s, fname))) { g_string_append_printf (fmtp, "%s%s=%s", first ? "" : ";", fname, fval); first = FALSE; } } if (!first) { tmp = g_string_free (fmtp, FALSE); gst_sdp_media_add_attribute (smedia, "fmtp", tmp); g_free (tmp); } else { g_string_free (fmtp, TRUE); } update_sdp_from_tags (stream, smedia); gst_sdp_message_add_media (sdp, smedia); gst_sdp_media_free (smedia); gst_caps_unref (caps); } { GstNetTimeProvider *provider; if ((provider = gst_rtsp_media_get_time_provider (media, info->server_ip, 0))) { GstClock *clock; gchar *address, *str; gint port; g_object_get (provider, "clock", &clock, "address", &address, "port", &port, NULL); str = g_strdup_printf ("GstNetTimeProvider %s %s:%d %" G_GUINT64_FORMAT, g_type_name (G_TYPE_FROM_INSTANCE (clock)), address, port, gst_clock_get_time (clock)); gst_sdp_message_add_attribute (sdp, "x-gst-clock", str); g_free (str); gst_object_unref (clock); g_free (address); gst_object_unref (provider); } } return TRUE; /* ERRORS */ not_prepared: { GST_ERROR ("media %p is not prepared", media); return FALSE; } }
static NMCmdLine * create_dm_cmd_line (const char *iface, NMIP4Config *ip4_config, const char *pidfile, GError **error) { NMCmdLine *cmd; GString *s; const NMPlatformIP4Address *tmp; char first[INET_ADDRSTRLEN]; char last[INET_ADDRSTRLEN]; char localaddr[INET_ADDRSTRLEN]; char *error_desc = NULL; const char *dm_binary; dm_binary = nm_utils_find_helper ("dnsmasq", DNSMASQ_PATH, error); if (!dm_binary) return NULL; /* Create dnsmasq command line */ cmd = nm_cmd_line_new (); nm_cmd_line_add_string (cmd, dm_binary); if (getenv ("NM_DNSMASQ_DEBUG")) { nm_cmd_line_add_string (cmd, "--log-dhcp"); nm_cmd_line_add_string (cmd, "--log-queries"); } /* dnsmasq may read from it's default config file location, which if that * location is a valid config file, it will combine with the options here * and cause undesirable side-effects. Like sending bogus IP addresses * as the gateway or whatever. So tell dnsmasq not to use any config file * at all. */ nm_cmd_line_add_string (cmd, "--conf-file"); nm_cmd_line_add_string (cmd, "--no-hosts"); nm_cmd_line_add_string (cmd, "--keep-in-foreground"); nm_cmd_line_add_string (cmd, "--bind-interfaces"); nm_cmd_line_add_string (cmd, "--except-interface=lo"); nm_cmd_line_add_string (cmd, "--clear-on-reload"); /* Use strict order since in the case of VPN connections, the VPN's * nameservers will be first in resolv.conf, and those need to be tried * first by dnsmasq to successfully resolve names from the VPN. */ nm_cmd_line_add_string (cmd, "--strict-order"); /* Find the IP4 address to use */ tmp = nm_ip4_config_get_address (ip4_config, 0); s = g_string_new ("--listen-address="); nm_utils_inet4_ntop (tmp->address, localaddr); g_string_append (s, localaddr); nm_cmd_line_add_string (cmd, s->str); g_string_free (s, TRUE); if (!nm_dnsmasq_utils_get_range (tmp, first, last, &error_desc)) { g_set_error_literal (error, NM_MANAGER_ERROR, NM_MANAGER_ERROR_FAILED, error_desc); nm_log_warn (LOGD_SHARING, "Failed to find DHCP address ranges: %s", error_desc); g_free (error_desc); nm_cmd_line_destroy (cmd); return NULL; } s = g_string_new ("--dhcp-range="); g_string_append_printf (s, "%s,%s,60m", first, last); nm_cmd_line_add_string (cmd, s->str); g_string_free (s, TRUE); s = g_string_new ("--dhcp-option=option:router,"); g_string_append (s, localaddr); nm_cmd_line_add_string (cmd, s->str); g_string_free (s, TRUE); nm_cmd_line_add_string (cmd, "--dhcp-lease-max=50"); s = g_string_new ("--pid-file="); g_string_append (s, pidfile); nm_cmd_line_add_string (cmd, s->str); g_string_free (s, TRUE); return cmd; }
static GtkTreeModel *create_settings_model(gpointer data) { struct dirent *dent; GtkListStore *list; GtkTreeIter iter; struct stat st; GString *str; DIR *dir; int ret; list = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING); gtk_list_store_append(list, &iter); gtk_list_store_set(list, &iter, 0, "Current", 1, "", -1); /* Search for user settings first */ str = get_home_settings_new(); ret = stat(str->str, &st); if (ret < 0 || !S_ISDIR(st.st_mode)) goto read_system; dir = opendir(str->str); if (!dir) goto read_system; while ((dent = readdir(dir))) { const char *name = dent->d_name; GString *file; gchar *item; if (strcmp(name, ".") == 0 || strcmp(name, "..") == 0) continue; if (strcmp(name + strlen(name) - 4, ".kss") != 0) continue; file = g_string_new(str->str); g_string_append_printf(file, "/%s", name); /* Save the file name but remove the .kss extention */ item = g_strdup(name); item[strlen(name) - 4] = 0; gtk_list_store_append(list, &iter); gtk_list_store_set(list, &iter, 0, item, 1, file->str, -1); g_free(item); g_string_free(file, TRUE); } read_system: g_string_free(str, TRUE); return GTK_TREE_MODEL(list); }
/* * Trace Capture Dialog Window * * +--------------------------------------------------------------------+ * | Dialog Window | * | +-------------------------------+-------------------------------+ | * | | Paned Window | +---------------------------+ | | * | | +---------------------------+ | | Scroll window | | | * | | | Hbox | | | +-----------------------+ | | | * | | | Label Plugin Combo | | | | Event Tree | | | | * | | +---------------------------+ | | | | | | | * | | | | | | | | | * | | | | +-----------------------+ | | | * | | | +---------------------------+ | | * | +-------------------------------+-------------------------------+ | * +--------------------------------------------------------------------+ */ static void tracing_dialog(struct shark_info *info, const char *tracing) { struct pevent *pevent; GtkWidget *dialog; GtkWidget *button; GtkWidget *combo; GtkWidget *label; GtkWidget *entry; GtkWidget *frame; GtkWidget *vbox; GtkWidget *scrollwin; GtkWidget *table; GtkWidget *table2; GtkWidget *event_tree; GtkWidget *viewport; GtkWidget *textview; GtkWidget *hbox; GtkTextBuffer *buffer; GtkTextIter start_iter; GtkTextIter end_iter; char **plugins; int nr_plugins; struct trace_capture cap; const gchar *file; const char *command; const char *val; GString *str; gint result; memset(&cap, 0, sizeof(cap)); cap.info = info; plugins = tracecmd_local_plugins(tracing); /* Skip latency plugins */ nr_plugins = trim_plugins(plugins); if (!nr_plugins && plugins) { tracecmd_free_list(plugins); plugins = NULL; } /* Send parse warnings to status display */ trace_dialog_register_alt_warning(vpr_stat); pevent = tracecmd_local_events(tracing); trace_dialog_register_alt_warning(NULL); cap.pevent = pevent; if (!pevent && !nr_plugins) { warning("No events or plugins found"); return; } dialog = gtk_dialog_new(); gtk_window_set_title(GTK_WINDOW(dialog), "Capture"); button = gtk_button_new_with_label("Run"); gtk_dialog_add_action_widget(GTK_DIALOG(dialog), button, GTK_RESPONSE_ACCEPT); gtk_widget_show(button); cap.run_button = button; gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_CLOSE, GTK_RESPONSE_REJECT); cap.main_dialog = dialog; /* --- Top Level Hpaned --- */ table = gtk_table_new(4, 2, FALSE); /* It is possible that no pevents exist. */ if (pevent) { scrollwin = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_table_attach(GTK_TABLE(table), scrollwin, 0, 1, 1, 2, GTK_FILL, GTK_FILL|GTK_EXPAND, 0, 0); gtk_widget_show(scrollwin); event_tree = trace_create_event_list_view(pevent, NULL, cap.info->cap_all_events, cap.info->cap_systems, cap.info->cap_events); gtk_container_add(GTK_CONTAINER(scrollwin), event_tree); gtk_widget_show(event_tree); cap.event_view = event_tree; } else { /* No events */ label = gtk_label_new("No events enabled on system"); gtk_table_attach(GTK_TABLE(table), label, 0, 1, 1, 2, GTK_FILL, GTK_EXPAND|GTK_FILL, 0, 10); gtk_widget_show(label); cap.event_view = NULL; } gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), table, TRUE, TRUE, 0); gtk_widget_show(table); /*------------------ Frame Settings --------------------------- */ frame = gtk_frame_new("Settings"); gtk_table_attach(GTK_TABLE(table), frame, 0, 1, 0, 1, GTK_FILL, 0, 0, 10); gtk_widget_show(frame); table2 = gtk_table_new(2, 3, FALSE); gtk_container_add(GTK_CONTAINER(frame), table2); gtk_widget_show(table2); gtk_table_set_col_spacings(GTK_TABLE(table2), 5); button = gtk_button_new_with_label("Save Settings"); gtk_table_attach_defaults(GTK_TABLE(table2), button, 0, 1, 0, 1); gtk_widget_show(button); g_signal_connect (button, "clicked", G_CALLBACK (save_settings_clicked), (gpointer)&cap); button = gtk_button_new_with_label("Import Settings"); gtk_table_attach_defaults(GTK_TABLE(table2), button, 1, 2, 0, 1); gtk_widget_show(button); g_signal_connect (button, "clicked", G_CALLBACK (import_settings_clicked), (gpointer)&cap); button = gtk_button_new_with_label("Export Settings"); gtk_table_attach_defaults(GTK_TABLE(table2), button, 2, 3, 0, 1); gtk_widget_show(button); g_signal_connect (button, "clicked", G_CALLBACK (export_settings_clicked), (gpointer)&cap); if (cap.info->cap_settings_name) set_settings(&cap); label = gtk_label_new("Available Settings: "); gtk_table_attach_defaults(GTK_TABLE(table2), label, 0, 1, 1, 2); gtk_widget_show(label); combo = trace_create_combo_box(NULL, NULL, create_settings_model, NULL); gtk_table_attach_defaults(GTK_TABLE(table2), combo, 1, 3, 1, 2); cap.settings_combo = combo; g_signal_connect (combo, "changed", G_CALLBACK (settings_changed), (gpointer)&cap); /*------------------ Frame Settings --------------------------- */ frame = gtk_frame_new("Execute"); gtk_table_attach(GTK_TABLE(table), frame, 0, 1, 3, 4, GTK_FILL, 0, 0, 10); gtk_widget_show(frame); table2 = gtk_table_new(3, 3, FALSE); gtk_container_add(GTK_CONTAINER(frame), table2); gtk_widget_show(table2); label = gtk_label_new("Plugin: "); gtk_table_attach_defaults(GTK_TABLE(table2), label, 0, 1, 0, 1); gtk_widget_show(label); combo = trace_create_combo_box(NULL, NULL, create_plugin_combo_model, plugins); cap.plugin_combo = combo; gtk_table_attach_defaults(GTK_TABLE(table2), combo, 1, 3, 0, 1); if (cap.info->cap_plugin) set_plugin(&cap); label = gtk_label_new("Command:"); gtk_table_attach_defaults(GTK_TABLE(table2), label, 0, 1, 1, 2); gtk_widget_show(label); entry = gtk_entry_new(); gtk_table_attach_defaults(GTK_TABLE(table2), entry, 1, 3, 1, 2); gtk_widget_show(entry); cap.command_entry = entry; if (cap.info->cap_command) gtk_entry_set_text(GTK_ENTRY(entry), cap.info->cap_command); label = gtk_label_new("Output file: "); gtk_table_attach_defaults(GTK_TABLE(table2), label, 0, 1, 2, 3); gtk_widget_show(label); entry = gtk_entry_new(); gtk_table_attach_defaults(GTK_TABLE(table2), entry, 1, 2, 2, 3); gtk_widget_show(entry); if (cap.info->cap_file) file = cap.info->cap_file; else file = default_output_file; gtk_entry_set_text(GTK_ENTRY(entry), file); cap.file_entry = entry; button = gtk_button_new_with_label("Browse"); gtk_table_attach_defaults(GTK_TABLE(table2), button, 2, 3, 2, 3); gtk_widget_show(button); g_signal_connect (button, "clicked", G_CALLBACK (file_clicked), (gpointer)&cap); /*------------------ Command Output ------------------ */ vbox = gtk_vbox_new(FALSE, 0); gtk_table_attach_defaults(GTK_TABLE(table), vbox, 1, 2, 0, 4); gtk_widget_show(vbox); gtk_widget_set_size_request(GTK_WIDGET(vbox), 500, 0); label = gtk_label_new("Output Display:"); gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0); gtk_widget_show(label); scrollwin = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start(GTK_BOX(vbox), scrollwin, TRUE, TRUE, 0); gtk_widget_show(scrollwin); viewport = gtk_viewport_new(NULL, NULL); gtk_widget_show(viewport); gtk_container_add(GTK_CONTAINER(scrollwin), viewport); textview = gtk_text_view_new(); buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview)); gtk_container_add(GTK_CONTAINER(viewport), textview); gtk_widget_show(textview); cap.output_text = textview; cap.output_buffer = buffer; /* set the buffer from its previous setting */ if (info->cap_buffer_output) gtk_text_buffer_set_text(buffer, info->cap_buffer_output, strlen(info->cap_buffer_output)); hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); gtk_widget_show(hbox); label = gtk_label_new("Max # of characters in output display: "); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); gtk_widget_show(label); entry = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(hbox), entry, FALSE, FALSE, 0); gtk_widget_show(entry); cap.max_num_entry = entry; if (!info->cap_max_buf_size) info->cap_max_buf_size = DEFAULT_MAX_BUF_SIZE; str = g_string_new(""); g_string_append_printf(str, "%d", info->cap_max_buf_size); gtk_entry_set_text(GTK_ENTRY(entry), str->str); g_string_free(str, TRUE); g_signal_connect (entry, "insert-text", G_CALLBACK (insert_text), (gpointer)&cap); gtk_widget_set_size_request(GTK_WIDGET(dialog), DIALOG_WIDTH, DIALOG_HEIGHT); gtk_widget_show(dialog); cont: result = gtk_dialog_run(GTK_DIALOG(dialog)); if (result == GTK_RESPONSE_ACCEPT) { execute_button_clicked(&cap); goto cont; } /* Make sure no capture is running */ end_capture(&cap); /* Get the max buffer size */ val = gtk_entry_get_text(GTK_ENTRY(entry)); info->cap_max_buf_size = atoi(val); gtk_text_buffer_get_start_iter(cap.output_buffer, &start_iter); gtk_text_buffer_get_end_iter(cap.output_buffer, &end_iter); g_free(info->cap_buffer_output); info->cap_buffer_output = gtk_text_buffer_get_text(cap.output_buffer, &start_iter, &end_iter, FALSE); /* save the plugin and file to reuse if we come back */ update_plugin(&cap); free(info->cap_file); cap.info->cap_file = strdup(gtk_entry_get_text(GTK_ENTRY(cap.file_entry))); free(info->cap_command); command = gtk_entry_get_text(GTK_ENTRY(cap.command_entry)); if (command && strlen(command) && !is_just_ws(command)) cap.info->cap_command = strdup(command); else cap.info->cap_command = NULL; update_events(&cap); gtk_widget_destroy(dialog); if (pevent) pevent_free(pevent); if (plugins) tracecmd_free_list(plugins); }
JSBool gjs_console_interact(JSContext *context, unsigned argc, jsval *vp) { JSObject *object = JS_THIS_OBJECT(context, vp); gboolean eof = FALSE; jsval result; JSString *str; GString *buffer = NULL; char *temp_buf = NULL; int lineno; int startline; FILE *file = stdin; JS_SetErrorReporter(context, gjs_console_error_reporter); /* It's an interactive filehandle; drop into read-eval-print loop. */ lineno = 1; do { /* * Accumulate lines until we get a 'compilable unit' - one that either * generates an error (before running out of source) or that compiles * cleanly. This should be whenever we get a complete statement that * coincides with the end of a line. */ startline = lineno; buffer = g_string_new(""); do { if (!gjs_console_readline(context, &temp_buf, file, startline == lineno ? "gjs> " : ".... ")) { eof = JS_TRUE; break; } g_string_append(buffer, temp_buf); g_free(temp_buf); lineno++; } while (!JS_BufferIsCompilableUnit(context, JS_TRUE, object, buffer->str, buffer->len)); JS_EvaluateScript(context, object, buffer->str, buffer->len, "typein", startline, &result); if (JS_GetPendingException(context, &result)) { str = JS_ValueToString(context, result); JS_ClearPendingException(context); } else if (JSVAL_IS_VOID(result)) { goto next; } else { str = JS_ValueToString(context, result); } if (str) { char *display_str; display_str = gjs_value_debug_string(context, result); if (display_str != NULL) { g_fprintf(stdout, "%s\n", display_str); g_free(display_str); } } next: g_string_free(buffer, TRUE); } while (!eof); g_fprintf(stdout, "\n"); if (file != stdin) fclose(file); return JS_TRUE; }
static void impl_show_properties (RBMediaPlayerSource *source, GtkWidget *info_box, GtkWidget *notebook) { RBGenericPlayerSourcePrivate *priv = GET_PRIVATE (source); RhythmDBQueryModel *model; GtkBuilder *builder; GtkWidget *widget; GString *str; char *device_name; char *builder_file; char *vendor_name; char *model_name; char *serial_id; GObject *plugin; char *text; GList *output_formats; GList *t; g_object_get (source, "plugin", &plugin, NULL); builder_file = rb_find_plugin_data_file (plugin, "generic-player-info.ui"); g_object_unref (plugin); if (builder_file == NULL) { g_warning ("Couldn't find generic-player-info.ui"); return; } builder = rb_builder_load (builder_file, NULL); g_free (builder_file); if (builder == NULL) { rb_debug ("Couldn't load generic-player-info.ui"); return; } /* 'basic' tab stuff */ widget = GTK_WIDGET (gtk_builder_get_object (builder, "generic-player-basic-info")); gtk_box_pack_start (GTK_BOX (info_box), widget, TRUE, TRUE, 0); widget = GTK_WIDGET (gtk_builder_get_object (builder, "entry-device-name")); g_object_get (source, "name", &device_name, NULL); gtk_entry_set_text (GTK_ENTRY (widget), device_name); g_free (device_name); /* don't think we can support this.. g_signal_connect (widget, "focus-out-event", (GCallback)rb_mtp_source_name_changed_cb, source); */ g_object_get (source, "base-query-model", &model, NULL); widget = GTK_WIDGET (gtk_builder_get_object (builder, "num-tracks")); text = g_strdup_printf ("%d", gtk_tree_model_iter_n_children (GTK_TREE_MODEL (model), NULL)); gtk_label_set_text (GTK_LABEL (widget), text); g_free (text); g_object_unref (model); widget = GTK_WIDGET (gtk_builder_get_object (builder, "num-playlists")); text = g_strdup_printf ("%d", g_list_length (priv->playlists)); gtk_label_set_text (GTK_LABEL (widget), text); g_free (text); /* 'advanced' tab stuff */ widget = GTK_WIDGET (gtk_builder_get_object (builder, "generic-player-advanced-tab")); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), widget, gtk_label_new (_("Advanced"))); g_object_get (priv->device_info, "model", &model_name, "vendor", &vendor_name, "serial", &serial_id, NULL); widget = GTK_WIDGET (gtk_builder_get_object (builder, "label-model-value")); gtk_label_set_text (GTK_LABEL (widget), model_name); widget = GTK_WIDGET (gtk_builder_get_object (builder, "label-manufacturer-value")); gtk_label_set_text (GTK_LABEL (widget), vendor_name); widget = GTK_WIDGET (gtk_builder_get_object (builder, "label-serial-number-value")); gtk_label_set_text (GTK_LABEL (widget), serial_id); g_free (model_name); g_free (vendor_name); g_free (serial_id); str = g_string_new (""); output_formats = rb_transfer_target_get_format_descriptions (RB_TRANSFER_TARGET (source)); for (t = output_formats; t != NULL; t = t->next) { if (t != output_formats) { g_string_append (str, "\n"); } g_string_append (str, t->data); } rb_list_deep_free (output_formats); widget = GTK_WIDGET (gtk_builder_get_object (builder, "audio-format-list")); gtk_label_set_text (GTK_LABEL (widget), str->str); g_string_free (str, TRUE); g_object_unref (builder); }
/* Common XML format for both Bijiben / Tomboy */ static void processNode (BijiLazyDeserializer *self) { xmlTextReaderPtr r = self->priv->r; BijiNoteObj * n = self->priv->note; xmlChar *name; GdkRGBA color; gchar *tag, *color_str; GString *norm; name = xmlTextReaderName (r); if ( g_strcmp0((gchar*)name,"title") == 0 ) biji_process_string (r, (BijiReaderFunc*) biji_note_obj_set_title, n); if ( g_strcmp0((gchar*)name,"text") == 0 ) { if (self->priv->type == BIJIBEN_1) { process_bijiben_html_content (self, r); } else if (self->priv->type == TOMBOY_1 || self->priv->type == TOMBOY_2 || self->priv->type == TOMBOY_3 ) { self->priv->content = (gchar*) xmlTextReaderReadInnerXml (r); process_tomboy_xml_content (self); } } if (g_strcmp0 ((gchar*) name, "last-change-date") == 0) { xmlChar *result = xmlTextReaderReadString (r); biji_note_obj_set_mtime (n, str_to_gint64 (result)); free (result); } if (g_strcmp0 ((gchar*) name, "last-metadata-change-date") == 0) { xmlChar *result = xmlTextReaderReadString (r); biji_note_obj_set_last_metadata_change_date (n, str_to_gint64 (result)); free (result); } if (g_strcmp0 ((gchar*) name, "create-date") == 0) { xmlChar *result = xmlTextReaderReadString (r); biji_note_obj_set_create_date (n, str_to_gint64 (result)); free (result); } if (g_strcmp0 ((gchar*) name, "color") == 0 ) { color_str = (gchar*) xmlTextReaderReadString (r); if (gdk_rgba_parse (&color, color_str)) biji_note_obj_set_rgba (n, &color); else g_warning ("color invalid:%s", color_str); free (color_str); } if ( g_strcmp0((gchar*)name,"tag") == 0 ) { tag = (gchar*) xmlTextReaderReadString(r); if (g_str_has_prefix (tag,"system:template")) { note_obj_set_is_template(n,TRUE); } else if (g_str_has_prefix (tag,"system:notebook:")) { norm = g_string_new (tag); g_string_erase (norm,0,16); biji_item_add_collection (BIJI_ITEM (n), NULL, norm->str); g_string_free (norm, TRUE); } free (tag); } xmlFree(name); }
G_MODULE_EXPORT gboolean tracker_extract_get_metadata (TrackerExtractInfo *info) { TrackerSparqlBuilder *preupdate, *metadata; goffset size; GifFileType *gifFile = NULL; GString *where; const gchar *graph; gchar *filename, *uri; GFile *file; int fd; #if GIFLIB_MAJOR >= 5 int err; #endif preupdate = tracker_extract_info_get_preupdate_builder (info); metadata = tracker_extract_info_get_metadata_builder (info); graph = tracker_extract_info_get_graph (info); file = tracker_extract_info_get_file (info); filename = g_file_get_path (file); size = tracker_file_get_size (filename); if (size < 64) { g_free (filename); return FALSE; } fd = tracker_file_open_fd (filename); if (fd == -1) { g_warning ("Could not open GIF file '%s': %s\n", filename, g_strerror (errno)); g_free (filename); return FALSE; } #if GIFLIB_MAJOR < 5 if ((gifFile = DGifOpenFileHandle (fd)) == NULL) { print_gif_error (); #else /* GIFLIB_MAJOR < 5 */ if ((gifFile = DGifOpenFileHandle (fd, &err)) == NULL) { gif_error ("Could not open GIF file with handle", err); #endif /* GIFLIB_MAJOR < 5 */ g_free (filename); close (fd); return FALSE; } g_free (filename); tracker_sparql_builder_predicate (metadata, "a"); tracker_sparql_builder_object (metadata, "nfo:Image"); tracker_sparql_builder_object (metadata, "nmm:Photo"); where = g_string_new (""); uri = g_file_get_uri (file); read_metadata (preupdate, metadata, where, gifFile, uri, graph); tracker_extract_info_set_where_clause (info, where->str); g_string_free (where, TRUE); g_free (uri); if (DGifCloseFile (gifFile) != GIF_OK) { #if GIFLIB_MAJOR < 5 print_gif_error (); #else /* GIFLIB_MAJOR < 5 */ gif_error ("Could not close GIF file", gifFile->Error); #endif /* GIFLIB_MAJOR < 5 */ } return TRUE; }
/** * seahorse_util_uris_package: * @package: Package uri * @uris: null-terminated array of uris to package * * Package uris into an archive. The uris must be local. * * Returns: TRUE on success or FALSE on failure */ gboolean seahorse_util_uris_package (const gchar* package, const char** uris) { GError* err = NULL; gchar *out = NULL; gint status; gboolean r; GString *str; gchar *cmd; gchar *t; gchar *x; GFile *file, *fpackage; fpackage = g_file_new_for_uri (package); t = g_file_get_path (fpackage); x = g_shell_quote (t); g_free (t); /* create execution */ str = g_string_new (""); g_string_printf (str, "file-roller --add-to=%s", x); g_free (x); while(*uris) { /* We should never be passed any remote uris at this point */ x = g_uri_parse_scheme (*uris); if (x) file = g_file_new_for_uri (*uris); else file = g_file_new_for_path (*uris); g_free (x); t = g_file_get_path (file); g_object_unref (file); g_return_val_if_fail (t != NULL, FALSE); x = g_shell_quote (t); g_free (t); g_string_append_printf (str, " %s", x); g_free (x); uris++; } /* Execute the command */ cmd = g_string_free (str, FALSE); r = g_spawn_command_line_sync (cmd, &out, NULL, &status, &err); g_free (cmd); /* TODO: This won't work for remote packages if we support them in the future */ t = g_file_get_path (fpackage); g_chmod (t, S_IRUSR | S_IWUSR); g_free (t); g_object_unref (fpackage); if (out) { g_print ("%s", out); g_free (out); } if (!r) { seahorse_util_handle_error (err, _("Couldn’t run file-roller")); g_clear_error (&err); return FALSE; } if(!(WIFEXITED(status) && WEXITSTATUS(status) == 0)) { seahorse_util_show_error(NULL, _("Couldn’t package files"), _("The file-roller process did not complete successfully")); return FALSE; } return TRUE; }
void p_gpg_on_connect(const char *const barejid) { gchar *data_home = xdg_get_data_home(); GString *pubsfile = g_string_new(data_home); free(data_home); gchar *account_dir = str_replace(barejid, "@", "_at_"); g_string_append(pubsfile, "/profanity/pgp/"); g_string_append(pubsfile, account_dir); free(account_dir); // mkdir if doesn't exist for account errno = 0; int res = g_mkdir_with_parents(pubsfile->str, S_IRWXU); if (res == -1) { char *errmsg = strerror(errno); if (errmsg) { log_error("Error creating directory: %s, %s", pubsfile->str, errmsg); } else { log_error("Error creating directory: %s", pubsfile->str); } } // create or read publickeys g_string_append(pubsfile, "/pubkeys"); pubsloc = pubsfile->str; g_string_free(pubsfile, FALSE); if (g_file_test(pubsloc, G_FILE_TEST_EXISTS)) { g_chmod(pubsloc, S_IRUSR | S_IWUSR); } pubkeyfile = g_key_file_new(); g_key_file_load_from_file(pubkeyfile, pubsloc, G_KEY_FILE_KEEP_COMMENTS, NULL); // load each keyid gsize len = 0; gchar **jids = g_key_file_get_groups(pubkeyfile, &len); gpgme_ctx_t ctx; gpgme_error_t error = gpgme_new(&ctx); if (error) { log_error("GPG: Failed to create gpgme context. %s %s", gpgme_strsource(error), gpgme_strerror(error)); g_strfreev(jids); return; } int i = 0; for (i = 0; i < len; i++) { GError *gerr = NULL; gchar *jid = jids[i]; gchar *keyid = g_key_file_get_string(pubkeyfile, jid, "keyid", &gerr); if (gerr) { log_error("Error loading PGP key id for %s", jid); g_error_free(gerr); g_free(keyid); } else { gpgme_key_t key = NULL; error = gpgme_get_key(ctx, keyid, &key, 0); if (error || key == NULL) { log_warning("GPG: Failed to get key for %s: %s %s", jid, gpgme_strsource(error), gpgme_strerror(error)); continue; } ProfPGPPubKeyId *pubkeyid = malloc(sizeof(ProfPGPPubKeyId)); pubkeyid->id = strdup(keyid); pubkeyid->received = FALSE; g_hash_table_replace(pubkeys, strdup(jid), pubkeyid); g_free(keyid); gpgme_key_unref(key); } } gpgme_release(ctx); g_strfreev(jids); _save_pubkeys(); }
static char* getStatusString( const tr_torrent * tor, const tr_stat * torStat, const double uploadSpeed, const double downloadSpeed ) { const int isActive = torStat->activity != TR_STATUS_STOPPED; const int isChecking = torStat->activity == TR_STATUS_CHECK || torStat->activity == TR_STATUS_CHECK_WAIT; GString * gstr = g_string_new( NULL ); if( torStat->error ) { const char * fmt[] = { NULL, N_( "Tracker gave a warning: \"%s\"" ), N_( "Tracker gave an error: \"%s\"" ), N_( "Error: %s" ) }; g_string_append_printf( gstr, _( fmt[torStat->error] ), torStat->errorString ); } else switch( torStat->activity ) { case TR_STATUS_STOPPED: case TR_STATUS_CHECK_WAIT: case TR_STATUS_CHECK: { char * pch = getShortStatusString( tor, torStat, uploadSpeed, downloadSpeed ); g_string_assign( gstr, pch ); g_free( pch ); break; } case TR_STATUS_DOWNLOAD: { if( tr_torrentHasMetadata( tor ) ) { g_string_append_printf( gstr, ngettext( "Downloading from %1$'d of %2$'d connected peer", "Downloading from %1$'d of %2$'d connected peers", torStat->peersConnected ), torStat->peersSendingToUs + torStat->webseedsSendingToUs, torStat->peersConnected + torStat->webseedsSendingToUs ); } else { g_string_append_printf( gstr, ngettext( "Downloading metadata from %1$'d peer (%2$d%% done)", "Downloading metadata from %1$'d peers (%2$d%% done)", torStat->peersConnected ), torStat->peersConnected + torStat->webseedsSendingToUs, (int)(100.0*torStat->metadataPercentComplete) ); } break; } case TR_STATUS_SEED: g_string_append_printf( gstr, ngettext( "Seeding to %1$'d of %2$'d connected peer", "Seeding to %1$'d of %2$'d connected peers", torStat->peersConnected ), torStat->peersGettingFromUs, torStat->peersConnected ); break; } if( isActive && !isChecking ) { char buf[256]; getShortTransferString( tor, torStat, uploadSpeed, downloadSpeed, buf, sizeof( buf ) ); if( *buf ) g_string_append_printf( gstr, " - %s", buf ); } return g_string_free( gstr, FALSE ); }
char* p_gpg_encrypt(const char *const barejid, const char *const message, const char *const fp) { ProfPGPPubKeyId *pubkeyid = g_hash_table_lookup(pubkeys, barejid); if (!pubkeyid) { return NULL; } if (!pubkeyid->id) { return NULL; } gpgme_key_t keys[3]; keys[0] = NULL; keys[1] = NULL; keys[2] = NULL; gpgme_ctx_t ctx; gpgme_error_t error = gpgme_new(&ctx); if (error) { log_error("GPG: Failed to create gpgme context. %s %s", gpgme_strsource(error), gpgme_strerror(error)); return NULL; } gpgme_key_t receiver_key; error = gpgme_get_key(ctx, pubkeyid->id, &receiver_key, 0); if (error || receiver_key == NULL) { log_error("GPG: Failed to get receiver_key. %s %s", gpgme_strsource(error), gpgme_strerror(error)); gpgme_release(ctx); return NULL; } keys[0] = receiver_key; gpgme_key_t sender_key = NULL; error = gpgme_get_key(ctx, fp, &sender_key, 0); if (error || sender_key == NULL) { log_error("GPG: Failed to get sender_key. %s %s", gpgme_strsource(error), gpgme_strerror(error)); gpgme_release(ctx); return NULL; } keys[1] = sender_key; gpgme_data_t plain; gpgme_data_new_from_mem(&plain, message, strlen(message), 1); gpgme_data_t cipher; gpgme_data_new(&cipher); gpgme_set_armor(ctx, 1); error = gpgme_op_encrypt(ctx, keys, GPGME_ENCRYPT_ALWAYS_TRUST, plain, cipher); gpgme_data_release(plain); gpgme_release(ctx); gpgme_key_unref(receiver_key); gpgme_key_unref(sender_key); if (error) { log_error("GPG: Failed to encrypt message. %s %s", gpgme_strsource(error), gpgme_strerror(error)); return NULL; } size_t len; char *cipher_str = gpgme_data_release_and_get_mem(cipher, &len); char *result = NULL; if (cipher_str) { GString *cipher_gstr = g_string_new(""); g_string_append_len(cipher_gstr, cipher_str, len); result = _remove_header_footer(cipher_gstr->str, PGP_MESSAGE_FOOTER); g_string_free(cipher_gstr, TRUE); gpgme_free(cipher_str); } return result; }
static char* getProgressString( const tr_torrent * tor, const tr_info * info, const tr_stat * torStat ) { const int isDone = torStat->leftUntilDone == 0; const uint64_t haveTotal = torStat->haveUnchecked + torStat->haveValid; const int isSeed = torStat->haveValid >= info->totalSize; char buf1[32], buf2[32], buf3[32], buf4[32], buf5[32], buf6[32]; char * str; double seedRatio; const gboolean hasSeedRatio = tr_torrentGetSeedRatio( tor, &seedRatio ); if( !isDone ) /* downloading */ { str = g_strdup_printf( /* %1$s is how much we've got, %2$s is how much we'll have when done, %3$s%% is a percentage of the two */ _( "%1$s of %2$s (%3$s%%)" ), tr_strlsize( buf1, haveTotal, sizeof( buf1 ) ), tr_strlsize( buf2, torStat->sizeWhenDone, sizeof( buf2 ) ), tr_strlpercent( buf3, torStat->percentDone * 100.0, sizeof( buf3 ) ) ); } else if( !isSeed ) /* partial seeds */ { if( hasSeedRatio ) { str = g_strdup_printf( /* %1$s is how much we've got, %2$s is the torrent's total size, %3$s%% is a percentage of the two, %4$s is how much we've uploaded, %5$s is our upload-to-download ratio, %6$s is the ratio we want to reach before we stop uploading */ _( "%1$s of %2$s (%3$s%%), uploaded %4$s (Ratio: %5$s Goal: %6$s)" ), tr_strlsize( buf1, haveTotal, sizeof( buf1 ) ), tr_strlsize( buf2, info->totalSize, sizeof( buf2 ) ), tr_strlpercent( buf3, torStat->percentComplete * 100.0, sizeof( buf3 ) ), tr_strlsize( buf4, torStat->uploadedEver, sizeof( buf4 ) ), tr_strlratio( buf5, torStat->ratio, sizeof( buf5 ) ), tr_strlratio( buf6, seedRatio, sizeof( buf6 ) ) ); } else { str = g_strdup_printf( /* %1$s is how much we've got, %2$s is the torrent's total size, %3$s%% is a percentage of the two, %4$s is how much we've uploaded, %5$s is our upload-to-download ratio */ _( "%1$s of %2$s (%3$s%%), uploaded %4$s (Ratio: %5$s)" ), tr_strlsize( buf1, haveTotal, sizeof( buf1 ) ), tr_strlsize( buf2, info->totalSize, sizeof( buf2 ) ), tr_strlpercent( buf3, torStat->percentComplete * 100.0, sizeof( buf3 ) ), tr_strlsize( buf4, torStat->uploadedEver, sizeof( buf4 ) ), tr_strlratio( buf5, torStat->ratio, sizeof( buf5 ) ) ); } } else /* seeding */ { if( hasSeedRatio ) { str = g_strdup_printf( /* %1$s is the torrent's total size, %2$s is how much we've uploaded, %3$s is our upload-to-download ratio, %4$s is the ratio we want to reach before we stop uploading */ _( "%1$s, uploaded %2$s (Ratio: %3$s Goal: %4$s)" ), tr_strlsize( buf1, info->totalSize, sizeof( buf1 ) ), tr_strlsize( buf2, torStat->uploadedEver, sizeof( buf2 ) ), tr_strlratio( buf3, torStat->ratio, sizeof( buf3 ) ), tr_strlratio( buf4, seedRatio, sizeof( buf4 ) ) ); } else /* seeding w/o a ratio */ { str = g_strdup_printf( /* %1$s is the torrent's total size, %2$s is how much we've uploaded, %3$s is our upload-to-download ratio */ _( "%1$s, uploaded %2$s (Ratio: %3$s)" ), tr_strlsize( buf1, info->totalSize, sizeof( buf1 ) ), tr_strlsize( buf2, torStat->uploadedEver, sizeof( buf2 ) ), tr_strlratio( buf3, torStat->ratio, sizeof( buf3 ) ) ); } } /* add time when downloading */ if( ( torStat->activity == TR_STATUS_DOWNLOAD ) || ( hasSeedRatio && ( torStat->activity == TR_STATUS_SEED ) ) ) { const int eta = torStat->eta; GString * gstr = g_string_new( str ); g_string_append( gstr, " - " ); if( eta < 0 ) g_string_append( gstr, _( "Remaining time unknown" ) ); else { char timestr[128]; tr_strltime( timestr, eta, sizeof( timestr ) ); /* time remaining */ g_string_append_printf( gstr, _( "%s remaining" ), timestr ); } g_free( str ); str = g_string_free( gstr, FALSE ); } return str; }
static void grain_stat(G_GNUC_UNUSED GwyContainer *data, GwyRunType run) { GtkWidget *dialog, *table; GwyDataField *dfield, *mfield; GwySIUnit *siunit, *siunit2; GwySIValueFormat *vf; gint xres, yres, ngrains; gdouble total_area, area, size, vol_0, vol_min, vol_laplace, v; gdouble *values = NULL; gint *grains; GString *str; gint row; g_return_if_fail(run & STAT_RUN_MODES); gwy_app_data_browser_get_current(GWY_APP_DATA_FIELD, &dfield, GWY_APP_MASK_FIELD, &mfield, 0); g_return_if_fail(dfield); g_return_if_fail(mfield); xres = gwy_data_field_get_xres(mfield); yres = gwy_data_field_get_yres(mfield); total_area = gwy_data_field_get_xreal(dfield) *gwy_data_field_get_yreal(dfield); grains = g_new0(gint, xres*yres); ngrains = gwy_data_field_number_grains(mfield, grains); area = grains_get_total_value(dfield, ngrains, grains, &values, GWY_GRAIN_VALUE_PROJECTED_AREA); size = grains_get_total_value(dfield, ngrains, grains, &values, GWY_GRAIN_VALUE_EQUIV_SQUARE_SIDE); vol_0 = grains_get_total_value(dfield, ngrains, grains, &values, GWY_GRAIN_VALUE_VOLUME_0); vol_min = grains_get_total_value(dfield, ngrains, grains, &values, GWY_GRAIN_VALUE_VOLUME_MIN); vol_laplace = grains_get_total_value(dfield, ngrains, grains, &values, GWY_GRAIN_VALUE_VOLUME_LAPLACE); g_free(values); g_free(grains); dialog = gtk_dialog_new_with_buttons(_("Grain Statistics"), NULL, 0, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL); gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE); table = gtk_table_new(7, 2, FALSE); gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), table); gtk_container_set_border_width(GTK_CONTAINER(table), 4); row = 0; str = g_string_new(NULL); g_string_printf(str, "%d", ngrains); add_report_row(GTK_TABLE(table), &row, _("Number of grains:"), str->str); siunit = gwy_data_field_get_si_unit_xy(dfield); siunit2 = gwy_si_unit_power(siunit, 2, NULL); v = area; vf = gwy_si_unit_get_format(siunit2, GWY_SI_UNIT_FORMAT_VFMARKUP, v, NULL); g_string_printf(str, "%.*f %s", vf->precision, v/vf->magnitude, vf->units); add_report_row(GTK_TABLE(table), &row, _("Total projected area (abs.):"), str->str); g_string_printf(str, "%.2f %%", 100.0*area/total_area); add_report_row(GTK_TABLE(table), &row, _("Total projected area (rel.):"), str->str); v = area/ngrains; gwy_si_unit_get_format(siunit2, GWY_SI_UNIT_FORMAT_VFMARKUP, v, vf); g_string_printf(str, "%.*f %s", vf->precision, v/vf->magnitude, vf->units); add_report_row(GTK_TABLE(table), &row, _("Mean grain area:"), str->str); v = size/ngrains; gwy_si_unit_get_format(siunit, GWY_SI_UNIT_FORMAT_VFMARKUP, v, vf); g_string_printf(str, "%.*f %s", vf->precision, v/vf->magnitude, vf->units); add_report_row(GTK_TABLE(table), &row, _("Mean grain size:"), str->str); siunit = gwy_data_field_get_si_unit_z(dfield); gwy_si_unit_multiply(siunit2, siunit, siunit2); v = vol_0; gwy_si_unit_get_format(siunit2, GWY_SI_UNIT_FORMAT_VFMARKUP, v, vf); g_string_printf(str, "%.*f %s", vf->precision, v/vf->magnitude, vf->units); add_report_row(GTK_TABLE(table), &row, _("Total grain volume (zero):"), str->str); v = vol_min; gwy_si_unit_get_format(siunit2, GWY_SI_UNIT_FORMAT_VFMARKUP, v, vf); g_string_printf(str, "%.*f %s", vf->precision, v/vf->magnitude, vf->units); add_report_row(GTK_TABLE(table), &row, _("Total grain volume (minimum):"), str->str); v = vol_laplace; gwy_si_unit_get_format(siunit2, GWY_SI_UNIT_FORMAT_VFMARKUP, v, vf); g_string_printf(str, "%.*f %s", vf->precision, v/vf->magnitude, vf->units); add_report_row(GTK_TABLE(table), &row, _("Total grain volume (laplacian):"), str->str); gwy_si_unit_value_format_free(vf); g_string_free(str, TRUE); g_object_unref(siunit2); gtk_widget_show_all(dialog); gtk_dialog_run(GTK_DIALOG(dialog)); gtk_widget_destroy(dialog); }
static gchar * extract_content_text (PopplerDocument *document, gsize n_bytes) { GString *string; GTimer *timer; gsize remaining_bytes; gint n_pages, i; gdouble elapsed; n_pages = poppler_document_get_n_pages (document); string = g_string_new (""); timer = g_timer_new (); for (i = 0, remaining_bytes = n_bytes, elapsed = g_timer_elapsed (timer, NULL); i < n_pages && remaining_bytes > 0 && elapsed < EXTRACTION_PROCESS_TIMEOUT; i++, elapsed = g_timer_elapsed (timer, NULL)) { PopplerPage *page; gsize written_bytes = 0; gchar *text; page = poppler_document_get_page (document, i); text = poppler_page_get_text (page); if (!text) { g_object_unref (page); continue; } if (tracker_text_validate_utf8 (text, MIN (strlen (text), remaining_bytes), &string, &written_bytes)) { g_string_append_c (string, ' '); } remaining_bytes -= written_bytes; g_debug ("Extracted %" G_GSIZE_FORMAT " bytes from page %d, " "%" G_GSIZE_FORMAT " bytes remaining", written_bytes, i, remaining_bytes); g_free (text); g_object_unref (page); } if (elapsed >= EXTRACTION_PROCESS_TIMEOUT) { g_debug ("Extraction timed out, %d seconds reached", EXTRACTION_PROCESS_TIMEOUT); } g_debug ("Content extraction finished: %d/%d pages indexed in %2.2f seconds, " "%" G_GSIZE_FORMAT " bytes extracted", i, n_pages, g_timer_elapsed (timer, NULL), (n_bytes - remaining_bytes)); g_timer_destroy (timer); return g_string_free (string, FALSE); }
static char * xmlnode_to_pretty_str(xmlnode *node, int *len, int depth) { GString *text = g_string_new(""); xmlnode *c; char *node_name, *esc, *esc2, *tab = NULL; gboolean need_end = FALSE, pretty = TRUE; g_return_val_if_fail(node != NULL, NULL); if (pretty && depth) { tab = g_strnfill(depth, '\t'); text = g_string_append(text, tab); } node_name = g_markup_escape_text(node->name, -1); g_string_append_printf(text, "<font color='" BRACKET_COLOR "'><</font>" "<font color='" TAG_COLOR "'><b>%s</b></font>", node_name); if (node->xmlns) { if ((!node->parent || !node->parent->xmlns || !purple_strequal(node->xmlns, node->parent->xmlns)) && !purple_strequal(node->xmlns, "jabber:client")) { char *xmlns = g_markup_escape_text(node->xmlns, -1); g_string_append_printf(text, " <font color='" ATTR_NAME_COLOR "'><b>xmlns</b></font>=" "'<font color='" XMLNS_COLOR "'><b>%s</b></font>'", xmlns); g_free(xmlns); } } for (c = node->child; c; c = c->next) { if (c->type == XMLNODE_TYPE_ATTRIB) { esc = g_markup_escape_text(c->name, -1); esc2 = g_markup_escape_text(c->data, -1); g_string_append_printf(text, " <font color='" ATTR_NAME_COLOR "'><b>%s</b></font>=" "'<font color='" ATTR_VALUE_COLOR "'>%s</font>'", esc, esc2); g_free(esc); g_free(esc2); } else if (c->type == XMLNODE_TYPE_TAG || c->type == XMLNODE_TYPE_DATA) { if (c->type == XMLNODE_TYPE_DATA) pretty = FALSE; need_end = TRUE; } } if (need_end) { g_string_append_printf(text, "<font color='"BRACKET_COLOR"'>></font>%s", pretty ? "<br>" : ""); for (c = node->child; c; c = c->next) { if (c->type == XMLNODE_TYPE_TAG) { int esc_len; esc = xmlnode_to_pretty_str(c, &esc_len, depth+1); text = g_string_append_len(text, esc, esc_len); g_free(esc); } else if (c->type == XMLNODE_TYPE_DATA && c->data_sz > 0) { esc = g_markup_escape_text(c->data, c->data_sz); text = g_string_append(text, esc); g_free(esc); } } if(tab && pretty) text = g_string_append(text, tab); g_string_append_printf(text, "<font color='" BRACKET_COLOR "'><</font>/" "<font color='" TAG_COLOR "'><b>%s</b></font>" "<font color='" BRACKET_COLOR "'>></font><br>", node_name); } else { g_string_append_printf(text, "/<font color='" BRACKET_COLOR "'>></font><br>"); } g_free(node_name); g_free(tab); if(len) *len = text->len; return g_string_free(text, FALSE); }
G_MODULE_EXPORT gboolean tracker_extract_get_metadata (TrackerExtractInfo *info) { TrackerConfig *config; GTime creation_date; GError *error = NULL; TrackerSparqlBuilder *metadata, *preupdate; const gchar *graph; TrackerXmpData *xd = NULL; PDFData pd = { 0 }; /* actual data */ PDFData md = { 0 }; /* for merging */ PopplerDocument *document; gchar *xml = NULL; gchar *content, *uri; guint n_bytes; GPtrArray *keywords; GString *where; guint i; GFile *file; gchar *filename; int fd; gchar *contents = NULL; gsize len; struct stat st; metadata = tracker_extract_info_get_metadata_builder (info); preupdate = tracker_extract_info_get_preupdate_builder (info); graph = tracker_extract_info_get_graph (info); file = tracker_extract_info_get_file (info); filename = g_file_get_path (file); fd = tracker_file_open_fd (filename); if (fd == -1) { g_warning ("Could not open pdf file '%s': %s\n", filename, g_strerror (errno)); g_free (filename); return FALSE; } if (fstat (fd, &st) == -1) { g_warning ("Could not fstat pdf file '%s': %s\n", filename, g_strerror (errno)); close (fd); g_free (filename); return FALSE; } if (st.st_size == 0) { contents = NULL; len = 0; } else { contents = (gchar *) mmap (NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0); if (contents == NULL || contents == MAP_FAILED) { g_warning ("Could not mmap pdf file '%s': %s\n", filename, g_strerror (errno)); close (fd); g_free (filename); return FALSE; } len = st.st_size; } g_free (filename); uri = g_file_get_uri (file); document = poppler_document_new_from_data (contents, len, NULL, &error); if (error) { if (error->code == POPPLER_ERROR_ENCRYPTED) { tracker_sparql_builder_predicate (metadata, "a"); tracker_sparql_builder_object (metadata, "nfo:PaginatedTextDocument"); tracker_sparql_builder_predicate (metadata, "nfo:isContentEncrypted"); tracker_sparql_builder_object_boolean (metadata, TRUE); g_error_free (error); g_free (uri); close (fd); return TRUE; } else { g_warning ("Couldn't create PopplerDocument from uri:'%s', %s", uri, error->message ? error->message : "no error given"); g_error_free (error); g_free (uri); close (fd); return FALSE; } } if (!document) { g_warning ("Could not create PopplerDocument from uri:'%s', " "NULL returned without an error", uri); g_free (uri); close (fd); return FALSE; } tracker_sparql_builder_predicate (metadata, "a"); tracker_sparql_builder_object (metadata, "nfo:PaginatedTextDocument"); g_object_get (document, "title", &pd.title, "author", &pd.author, "subject", &pd.subject, "keywords", &pd.keywords, "creation-date", &creation_date, "metadata", &xml, NULL); if (creation_date > 0) { pd.creation_date = tracker_date_to_string ((time_t) creation_date); } keywords = g_ptr_array_new (); if (xml && (xd = tracker_xmp_new (xml, strlen (xml), uri)) != NULL) { /* The casts here are well understood and known */ md.title = (gchar *) tracker_coalesce_strip (4, pd.title, xd->title, xd->title2, xd->pdf_title); md.subject = (gchar *) tracker_coalesce_strip (2, pd.subject, xd->subject); md.date = (gchar *) tracker_coalesce_strip (3, pd.creation_date, xd->date, xd->time_original); md.author = (gchar *) tracker_coalesce_strip (2, pd.author, xd->creator); write_pdf_data (md, metadata, keywords); if (xd->keywords) { tracker_keywords_parse (keywords, xd->keywords); } if (xd->pdf_keywords) { tracker_keywords_parse (keywords, xd->pdf_keywords); } if (xd->publisher) { tracker_sparql_builder_predicate (metadata, "nco:publisher"); tracker_sparql_builder_object_blank_open (metadata); tracker_sparql_builder_predicate (metadata, "a"); tracker_sparql_builder_object (metadata, "nco:Contact"); tracker_sparql_builder_predicate (metadata, "nco:fullname"); tracker_sparql_builder_object_unvalidated (metadata, xd->publisher); tracker_sparql_builder_object_blank_close (metadata); } if (xd->type) { tracker_sparql_builder_predicate (metadata, "dc:type"); tracker_sparql_builder_object_unvalidated (metadata, xd->type); } if (xd->format) { tracker_sparql_builder_predicate (metadata, "dc:format"); tracker_sparql_builder_object_unvalidated (metadata, xd->format); } if (xd->identifier) { tracker_sparql_builder_predicate (metadata, "dc:identifier"); tracker_sparql_builder_object_unvalidated (metadata, xd->identifier); } if (xd->source) { tracker_sparql_builder_predicate (metadata, "dc:source"); tracker_sparql_builder_object_unvalidated (metadata, xd->source); } if (xd->language) { tracker_sparql_builder_predicate (metadata, "dc:language"); tracker_sparql_builder_object_unvalidated (metadata, xd->language); } if (xd->relation) { tracker_sparql_builder_predicate (metadata, "dc:relation"); tracker_sparql_builder_object_unvalidated (metadata, xd->relation); } if (xd->coverage) { tracker_sparql_builder_predicate (metadata, "dc:coverage"); tracker_sparql_builder_object_unvalidated (metadata, xd->coverage); } if (xd->license) { tracker_sparql_builder_predicate (metadata, "nie:license"); tracker_sparql_builder_object_unvalidated (metadata, xd->license); } if (xd->make || xd->model) { gchar *equip_uri; equip_uri = tracker_sparql_escape_uri_printf ("urn:equipment:%s:%s:", xd->make ? xd->make : "", xd->model ? xd->model : ""); tracker_sparql_builder_insert_open (preupdate, NULL); if (graph) { tracker_sparql_builder_graph_open (preupdate, graph); } tracker_sparql_builder_subject_iri (preupdate, equip_uri); tracker_sparql_builder_predicate (preupdate, "a"); tracker_sparql_builder_object (preupdate, "nfo:Equipment"); if (xd->make) { tracker_sparql_builder_predicate (preupdate, "nfo:manufacturer"); tracker_sparql_builder_object_unvalidated (preupdate, xd->make); } if (xd->model) { tracker_sparql_builder_predicate (preupdate, "nfo:model"); tracker_sparql_builder_object_unvalidated (preupdate, xd->model); } if (graph) { tracker_sparql_builder_graph_close (preupdate); } tracker_sparql_builder_insert_close (preupdate); tracker_sparql_builder_predicate (metadata, "nfo:equipment"); tracker_sparql_builder_object_iri (metadata, equip_uri); g_free (equip_uri); } if (xd->orientation) { tracker_sparql_builder_predicate (metadata, "nfo:orientation"); tracker_sparql_builder_object (metadata, xd->orientation); } if (xd->rights) { tracker_sparql_builder_predicate (metadata, "nie:copyright"); tracker_sparql_builder_object_unvalidated (metadata, xd->rights); } if (xd->white_balance) { tracker_sparql_builder_predicate (metadata, "nmm:whiteBalance"); tracker_sparql_builder_object (metadata, xd->white_balance); } if (xd->fnumber) { gdouble value; value = g_strtod (xd->fnumber, NULL); tracker_sparql_builder_predicate (metadata, "nmm:fnumber"); tracker_sparql_builder_object_double (metadata, value); } if (xd->flash) { tracker_sparql_builder_predicate (metadata, "nmm:flash"); tracker_sparql_builder_object (metadata, xd->flash); } if (xd->focal_length) { gdouble value; value = g_strtod (xd->focal_length, NULL); tracker_sparql_builder_predicate (metadata, "nmm:focalLength"); tracker_sparql_builder_object_double (metadata, value); } /* Question: Shouldn't xd->Artist be merged with md.author instead? */ if (xd->artist || xd->contributor) { const gchar *artist; artist = tracker_coalesce_strip (2, xd->artist, xd->contributor); tracker_sparql_builder_predicate (metadata, "nco:contributor"); tracker_sparql_builder_object_blank_open (metadata); tracker_sparql_builder_predicate (metadata, "a"); tracker_sparql_builder_object (metadata, "nco:Contact"); tracker_sparql_builder_predicate (metadata, "nco:fullname"); tracker_sparql_builder_object_unvalidated (metadata, artist); tracker_sparql_builder_object_blank_close (metadata); } if (xd->exposure_time) { gdouble value; value = g_strtod (xd->exposure_time, NULL); tracker_sparql_builder_predicate (metadata, "nmm:exposureTime"); tracker_sparql_builder_object_double (metadata, value); } if (xd->iso_speed_ratings) { gdouble value; value = g_strtod (xd->iso_speed_ratings, NULL); tracker_sparql_builder_predicate (metadata, "nmm:isoSpeed"); tracker_sparql_builder_object_double (metadata, value); } if (xd->description) { tracker_sparql_builder_predicate (metadata, "nie:description"); tracker_sparql_builder_object_unvalidated (metadata, xd->description); } if (xd->metering_mode) { tracker_sparql_builder_predicate (metadata, "nmm:meteringMode"); tracker_sparql_builder_object (metadata, xd->metering_mode); } if (xd->address || xd->state || xd->country || xd->city || xd->gps_altitude || xd->gps_latitude || xd-> gps_longitude) { tracker_sparql_builder_predicate (metadata, "slo:location"); tracker_sparql_builder_object_blank_open (metadata); /* GeoLocation */ tracker_sparql_builder_predicate (metadata, "a"); tracker_sparql_builder_object (metadata, "slo:GeoLocation"); if (xd->address || xd->state || xd->country || xd->city) { gchar *addruri; addruri = tracker_sparql_get_uuid_urn (); tracker_sparql_builder_predicate (metadata, "slo:postalAddress"); tracker_sparql_builder_object_iri (metadata, addruri); tracker_sparql_builder_insert_open (preupdate, NULL); if (graph) { tracker_sparql_builder_graph_open (preupdate, graph); } tracker_sparql_builder_subject_iri (preupdate, addruri); g_free (addruri); tracker_sparql_builder_predicate (preupdate, "a"); tracker_sparql_builder_object (preupdate, "nco:PostalAddress"); if (xd->address) { tracker_sparql_builder_predicate (preupdate, "nco:streetAddress"); tracker_sparql_builder_object_unvalidated (preupdate, xd->address); } if (xd->state) { tracker_sparql_builder_predicate (preupdate, "nco:region"); tracker_sparql_builder_object_unvalidated (preupdate, xd->state); } if (xd->city) { tracker_sparql_builder_predicate (preupdate, "nco:locality"); tracker_sparql_builder_object_unvalidated (preupdate, xd->city); } if (xd->country) { tracker_sparql_builder_predicate (preupdate, "nco:country"); tracker_sparql_builder_object_unvalidated (preupdate, xd->country); } if (graph) { tracker_sparql_builder_graph_close (preupdate); } tracker_sparql_builder_insert_close (preupdate); } if (xd->gps_altitude) { tracker_sparql_builder_predicate (metadata, "slo:altitude"); tracker_sparql_builder_object_unvalidated (metadata, xd->gps_altitude); } if (xd->gps_latitude) { tracker_sparql_builder_predicate (metadata, "slo:latitude"); tracker_sparql_builder_object_unvalidated (metadata, xd->gps_latitude); } if (xd->gps_longitude) { tracker_sparql_builder_predicate (metadata, "slo:longitude"); tracker_sparql_builder_object_unvalidated (metadata, xd->gps_longitude); } tracker_sparql_builder_object_blank_close (metadata); /* GeoLocation */ } if (xd->regions) { tracker_xmp_apply_regions (preupdate, metadata, graph, xd); } tracker_xmp_free (xd); } else { /* So if we are here we have NO XMP data and we just * write what we know from Poppler. */ write_pdf_data (pd, metadata, keywords); } where = g_string_new (""); for (i = 0; i < keywords->len; i++) { gchar *p, *escaped, *var; p = g_ptr_array_index (keywords, i); escaped = tracker_sparql_escape_string (p); var = g_strdup_printf ("tag%d", i + 1); /* ensure tag with specified label exists */ tracker_sparql_builder_append (preupdate, "INSERT { "); if (graph) { tracker_sparql_builder_append (preupdate, "GRAPH <"); tracker_sparql_builder_append (preupdate, graph); tracker_sparql_builder_append (preupdate, "> { "); } tracker_sparql_builder_append (preupdate, "_:tag a nao:Tag ; nao:prefLabel \""); tracker_sparql_builder_append (preupdate, escaped); tracker_sparql_builder_append (preupdate, "\""); if (graph) { tracker_sparql_builder_append (preupdate, " } "); } tracker_sparql_builder_append (preupdate, " }\n"); tracker_sparql_builder_append (preupdate, "WHERE { FILTER (NOT EXISTS { " "?tag a nao:Tag ; nao:prefLabel \""); tracker_sparql_builder_append (preupdate, escaped); tracker_sparql_builder_append (preupdate, "\" }) }\n"); /* associate file with tag */ tracker_sparql_builder_predicate (metadata, "nao:hasTag"); tracker_sparql_builder_object_variable (metadata, var); g_string_append_printf (where, "?%s a nao:Tag ; nao:prefLabel \"%s\" .\n", var, escaped); g_free (var); g_free (escaped); g_free (p); } g_ptr_array_free (keywords, TRUE); tracker_extract_info_set_where_clause (info, where->str); g_string_free (where, TRUE); tracker_sparql_builder_predicate (metadata, "nfo:pageCount"); tracker_sparql_builder_object_int64 (metadata, poppler_document_get_n_pages (document)); config = tracker_main_get_config (); n_bytes = tracker_config_get_max_bytes (config); content = extract_content_text (document, n_bytes); if (content) { tracker_sparql_builder_predicate (metadata, "nie:plainTextContent"); tracker_sparql_builder_object_unvalidated (metadata, content); g_free (content); } read_outline (document, metadata); g_free (xml); g_free (pd.keywords); g_free (pd.title); g_free (pd.subject); g_free (pd.creation_date); g_free (pd.author); g_free (pd.date); g_free (uri); g_object_unref (document); if (contents) { munmap (contents, len); } close (fd); return TRUE; }
/** * gom_command_builder_build_insert: * @builder: A #GomCommandBuilder. * @resource: a #GomResource * * Builds a new #GomCommand that will insert the parameters of the resource * into the underlying database. * * Returns: (transfer full): A #GomCommand. */ GomCommand * gom_command_builder_build_insert (GomCommandBuilder *builder, GomResource *resource) { GomCommandBuilderPrivate *priv; GomResourceClass *klass; GomCommand *command = NULL; GParamSpec **pspecs = NULL; gboolean did_pspec = FALSE; gboolean has_dynamic_pkey; GString *str = NULL; guint n_pspecs = 0; guint i = 0; guint idx = 0; g_return_val_if_fail(GOM_IS_COMMAND_BUILDER(builder), NULL); priv = builder->priv; klass = g_type_class_ref(priv->resource_type); pspecs = g_object_class_list_properties(G_OBJECT_CLASS(klass), &n_pspecs); str = g_string_new("INSERT INTO "); g_string_append_printf(str, "%s (", klass->table); has_dynamic_pkey = gom_resource_has_dynamic_pkey (priv->resource_type); if (!has_dynamic_pkey) { g_string_append_printf(str, "'%s'", klass->primary_key); did_pspec = TRUE; } for (i = 0; i < n_pspecs; i++) { if (do_prop_on_insert(pspecs[i], klass, priv->resource_type)) { if (did_pspec) { g_string_append(str, ", "); } g_string_append_printf(str, "'%s'", pspecs[i]->name); did_pspec = TRUE; } } g_string_append(str, ") VALUES ("); did_pspec = FALSE; if (!has_dynamic_pkey) { g_string_append(str, "?"); did_pspec = TRUE; } for (i = 0; i < n_pspecs; i++) { if (do_prop_on_insert(pspecs[i], klass, priv->resource_type)) { if (did_pspec) { g_string_append(str, ", "); } g_string_append(str, "?"); did_pspec = TRUE; } } g_string_append(str, ");"); command = g_object_new(GOM_TYPE_COMMAND, "adapter", priv->adapter, "sql", str->str, NULL); if (!has_dynamic_pkey) { GValue value = { 0 }; resource_get_property(G_OBJECT(resource), klass->primary_key, &value); gom_command_set_param(command, idx++, &value); g_value_unset(&value); did_pspec = TRUE; } for (i = 0; i < n_pspecs; i++) { if (do_prop_on_insert(pspecs[i], klass, priv->resource_type)) { GValue value = { 0 }; resource_get_property(G_OBJECT(resource), pspecs[i]->name, &value); gom_command_set_param(command, idx++, &value); g_value_unset(&value); } } g_type_class_unref(klass); if (str) { g_string_free(str, TRUE); } g_free(pspecs); return command; }
static void read_toc (PopplerIndexIter *index, GString **toc) { if (!index) { return; } if (!*toc) { *toc = g_string_new (""); } do { PopplerAction *action; PopplerIndexIter *iter; action = poppler_index_iter_get_action (index); if (!action) { continue; } switch (action->type) { case POPPLER_ACTION_GOTO_DEST: { PopplerActionGotoDest *ag = (PopplerActionGotoDest *)action; PopplerDest *agd = ag->dest; if (!tracker_is_empty_string (ag->title)) { g_string_append_printf (*toc, "%s ", ag->title); } if (!tracker_is_empty_string (agd->named_dest)) { g_string_append_printf (*toc, "%s ", agd->named_dest); } break; } case POPPLER_ACTION_LAUNCH: { PopplerActionLaunch *al = (PopplerActionLaunch *)action; if (!tracker_is_empty_string (al->title)) { g_string_append_printf (*toc, "%s ", al->title); } if (!tracker_is_empty_string (al->file_name)) { g_string_append_printf (*toc, "%s ", al->file_name); } if (!tracker_is_empty_string (al->params)) { g_string_append_printf (*toc, "%s ", al->params); } break; } case POPPLER_ACTION_URI: { PopplerActionUri *au = (PopplerActionUri *)action; if (!tracker_is_empty_string (au->uri)) { g_string_append_printf (*toc, "%s ", au->uri); } break; } case POPPLER_ACTION_NAMED: { PopplerActionNamed *an = (PopplerActionNamed *)action; if (!tracker_is_empty_string (an->title)) { g_string_append_printf (*toc, "%s, ", an->title); } if (!tracker_is_empty_string (an->named_dest)) { g_string_append_printf (*toc, "%s ", an->named_dest); } break; } case POPPLER_ACTION_MOVIE: { PopplerActionMovie *am = (PopplerActionMovie *)action; if (!tracker_is_empty_string (am->title)) { g_string_append_printf (*toc, "%s ", am->title); } break; } case POPPLER_ACTION_NONE: case POPPLER_ACTION_UNKNOWN: case POPPLER_ACTION_GOTO_REMOTE: case POPPLER_ACTION_RENDITION: case POPPLER_ACTION_OCG_STATE: case POPPLER_ACTION_JAVASCRIPT: /* Do nothing */ break; } poppler_action_free (action); iter = poppler_index_iter_get_child (index); read_toc (iter, toc); } while (poppler_index_iter_next (index)); poppler_index_iter_free (index); }
static void gimp_tag_popup_toggle_tag (GimpTagPopup *popup, PopupTagData *tag_data) { gchar **current_tags; GString *tag_str; gint length; gint i; gboolean tag_toggled_off = FALSE; if (tag_data->state == GTK_STATE_NORMAL) { tag_data->state = GTK_STATE_SELECTED; } else if (tag_data->state == GTK_STATE_SELECTED) { tag_data->state = GTK_STATE_NORMAL; } else { return; } current_tags = gimp_tag_entry_parse_tags (GIMP_TAG_ENTRY (popup->combo_entry)); tag_str = g_string_new (""); length = g_strv_length (current_tags); for (i = 0; i < length; i++) { if (! gimp_tag_compare_with_string (tag_data->tag, current_tags[i])) { tag_toggled_off = TRUE; } else { if (tag_str->len) { g_string_append (tag_str, gimp_tag_entry_get_separator ()); g_string_append_c (tag_str, ' '); } g_string_append (tag_str, current_tags[i]); } } if (! tag_toggled_off) { /* this tag was not selected yet, so it needs to be toggled on */ if (tag_str->len) { g_string_append (tag_str, gimp_tag_entry_get_separator ()); g_string_append_c (tag_str, ' '); } g_string_append (tag_str, gimp_tag_get_name (tag_data->tag)); } gimp_tag_entry_set_tag_string (GIMP_TAG_ENTRY (popup->combo_entry), tag_str->str); g_string_free (tag_str, TRUE); g_strfreev (current_tags); if (GIMP_TAG_ENTRY (popup->combo_entry)->mode == GIMP_TAG_ENTRY_MODE_QUERY) { GimpTaggedContainer *container; container = GIMP_TAG_ENTRY (popup->combo_entry)->container; for (i = 0; i < popup->tag_count; i++) { if (popup->tag_data[i].state != GTK_STATE_SELECTED) { popup->tag_data[i].state = GTK_STATE_INSENSITIVE; } } gimp_container_foreach (GIMP_CONTAINER (container), (GFunc) gimp_tag_popup_check_can_toggle, popup); } }
static GwyContainer* ols_load_tiff(const GwyTIFF *tiff, const gchar *filename, GError **error) { const gchar *colour_channels[] = { "Red", "Green", "Blue" }; const gchar *colour_channel_gradients[] = { "RGB-Red", "RGB-Green", "RGB-Blue" }; GwyContainer *container = NULL; GwyDataField *dfield; GwySIUnit *siunit; GwyTIFFImageReader *reader = NULL; GwyTextHeaderParser parser; GHashTable *hash; gint i, power10; gchar *comment = NULL; const gchar *s1; GError *err = NULL; guint spp, ch, id = 0, dir_num = 0; gdouble *data; gdouble z_axis = 1.0, xy_axis, factor; GQuark quark; GString *key; /* Comment with parameters is common for all data fields */ if (!gwy_tiff_get_string0(tiff, GWY_TIFFTAG_IMAGE_DESCRIPTION, &comment) || !strstr(comment, MAGIC_COMMENT)) { g_free(comment); err_FILE_TYPE(error, "OLS"); return NULL; } /* Read the comment header. */ gwy_clear(&parser, 1); parser.key_value_separator = "="; parser.section_template = "[\x1a]"; parser.endsection_template = "[\x1a End]"; parser.section_accessor = "::"; hash = gwy_text_header_parse(comment, &parser, NULL, NULL); key = g_string_new(NULL); for (dir_num = 0; dir_num < gwy_tiff_get_n_dirs(tiff); dir_num++) { reader = gwy_tiff_image_reader_free(reader); /* Request a reader, this ensures dimensions and stuff are defined. */ reader = gwy_tiff_get_image_reader(tiff, dir_num, 3, &err); if (!reader) { g_warning("Ignoring directory %u: %s", dir_num, err->message); g_clear_error(&err); continue; } spp = reader->samples_per_pixel; g_string_printf(key, "Data %u Info::XY Convert Value", dir_num+1); if (!(s1 = g_hash_table_lookup(hash, key->str))) { g_warning("Cannot find 'XY Convert Value' for data %u.", dir_num+1); continue; } xy_axis = g_ascii_strtod(s1, NULL); if (!((xy_axis = fabs(xy_axis)) > 0)) { g_warning("Real size step is 0.0, fixing to 1.0"); xy_axis = 1.0; } g_string_printf(key, "Data %u Info::Z Convert Value", dir_num+1); if (!(s1 = g_hash_table_lookup(hash, key->str))) { g_warning("Cannot find 'Z Convert Value' for data %u.", dir_num+1); continue; } z_axis = g_ascii_strtod(s1, NULL); for (ch = 0; ch < spp; ch++) { siunit = gwy_si_unit_new_parse("nm", &power10); factor = pow10(power10); dfield = gwy_data_field_new(reader->width, reader->height, reader->width * xy_axis * factor, reader->height * xy_axis * factor, FALSE); // units gwy_data_field_set_si_unit_xy(dfield, siunit); g_object_unref(siunit); if (spp == 1) { if (dir_num == 1) siunit = gwy_si_unit_new_parse("nm", &power10); else siunit = gwy_si_unit_new_parse("1e-6", &power10); } else { siunit = gwy_si_unit_new(NULL); power10 = 0; } gwy_data_field_set_si_unit_z(dfield, siunit); g_object_unref(siunit); factor = z_axis * pow10(power10); data = gwy_data_field_get_data(dfield); for (i = 0; i < reader->height; i++) gwy_tiff_read_image_row(tiff, reader, ch, i, factor, 0.0, data + i*reader->width); /* add read datafield to container */ if (!container) container = gwy_container_new(); quark = gwy_app_get_data_key_for_id(id); gwy_container_set_object(container, quark, dfield); g_object_unref(dfield); g_string_printf(key, "%s/title", g_quark_to_string(quark)); if (spp == 1) { /* Channel 0 is texture */ if (dir_num == 0) { gwy_container_set_string_by_name(container, key->str, g_strdup("Texture")); } /* Channel 1 is topography */ else if (dir_num == 1) { g_string_printf(key, "%s/title", g_quark_to_string(quark)); gwy_container_set_string_by_name(container, key->str, g_strdup("Height")); } } else { gwy_container_set_string_by_name(container, key->str, g_strdup(colour_channels[ch])); g_string_printf(key, "/%d/base/palette", id); gwy_container_set_string_by_name (container, key->str, g_strdup(colour_channel_gradients[ch])); } gwy_file_channel_import_log_add(container, id, NULL, filename); id++; } } g_hash_table_destroy(hash); g_string_free(key, TRUE); g_free(comment); if (reader) { gwy_tiff_image_reader_free(reader); reader = NULL; } if (!container) err_NO_DATA(error); return container; }