gint write_gms(gchar *filename, struct model_pak *model) { gdouble x[3]; GSList *list; struct core_pak *core; FILE *fp; /* checks */ g_return_val_if_fail(model != NULL, 1); g_return_val_if_fail(filename != NULL, 2); /* open the file */ fp = fopen(filename,"wb"); if (!fp) return(3); /* TODO - enforce lines < 80 chars? */ /* print control keywords */ fprintf(fp, " $contrl coord=unique"); write_keyword(fp, GMS_EXETYPE_TXT, model->gamess.exe_type, exe_types); write_keyword(fp, GMS_SCFTYPE_TXT, model->gamess.scf_type, scf_types); write_keyword(fp, GMS_RUNTYPE_TXT, model->gamess.run_type, run_types); /* FIXME - put in to try & keep the lines below 80 chars */ fprintf(fp, "\n "); write_keyword(fp, GMS_UNITS_TXT, model->gamess.units, units); fprintf(fp, " %s%d", GMS_MAXIT_TXT, (gint) model->gamess.maxit); if (model->gamess.total_charge != 0.0) fprintf(fp, " %s%d", GMS_TOTAL_Q_TXT, (gint) model->gamess.total_charge); if (model->gamess.multiplicity > 1) fprintf(fp, " %s%d", GMS_MULT_TXT, (gint) model->gamess.multiplicity); if (model->gamess.wide_output) fprintf(fp, " %s6", GMS_WIDE_OUTPUT_TXT); fprintf(fp, " $end\n"); /* NEW - dft calc */ if (model->gamess.dft) { fprintf(fp, " $dft"); switch (model->gamess.dft_functional) { case SVWN: fprintf(fp, " dfttyp=SVWN"); break; case BLYP: fprintf(fp, " dfttyp=BLYP"); break; case B3LYP: fprintf(fp, " dfttyp=B3LYP"); break; } fprintf(fp, " $end\n"); } /* TODO: electron correlation stuff */ /* print size and memory */ fprintf(fp, " $system %s%d %s%d $end\x0a", GMS_TIMLIM_TXT, (gint) model->gamess.time_limit, GMS_MWORDS_TXT, (gint) model->gamess.mwords); /* print optimiser data */ if (model->gamess.run_type >= GMS_OPTIMIZE) { fprintf(fp, " $statpt %s%d ", GMS_NSTEP_TXT, (gint) model->gamess.nstep); write_keyword(fp, GMS_METHOD_TXT, model->gamess.opt_type, method_types); fprintf(fp, "$end\n"); } /* print basis set if one of the standard ones */ if (model->gamess.basis != GMS_USER) { fprintf(fp, " $basis "); write_keyword(fp, GMS_BASIS_TXT, model->gamess.basis, basis_types); if (model->gamess.ngauss) fprintf(fp, " %s%d", GMS_NGAUSS_TXT, model->gamess.ngauss); if (model->gamess.num_p) fprintf(fp, " %s%d", GMS_NUM_P_TXT, (gint) model->gamess.num_p); if (model->gamess.num_d) fprintf(fp, " %s%d", GMS_NUM_D_TXT, (gint) model->gamess.num_d); if (model->gamess.num_f) fprintf(fp, " %s%d", GMS_NUM_F_TXT, (gint) model->gamess.num_f); if (model->gamess.have_heavy_diffuse) fprintf(fp, " %s", GMS_DIFFSP_TXT); if (model->gamess.have_hydrogen_diffuse) fprintf(fp, " %s", GMS_DIFFS_TXT); fprintf(fp, " $end\n"); } /* print data */ fprintf(fp, " $DATA\n"); /* print data header */ fprintf(fp, "%s\n", model->gamess.title); /* print symmetry */ fprintf(fp, "c1\n"); for (list=model->cores ; list ; list=g_slist_next(list)) { core = list->data; if (core->status & DELETED) continue; /* everything is cartesian after latmat mult */ ARR3SET(x, core->x); vecmat(model->latmat, x); if (model->gamess.units == GMS_ANGS) fprintf(fp,"%-7s %d %14.9f %14.9f %14.9f\n", elements[core->atom_code].symbol, elements[core->atom_code].number, x[0], x[1], x[2]); else fprintf(fp,"%-7s %d %14.9f %14.9f %14.9f\n", elements[core->atom_code].symbol, elements[core->atom_code].number, x[0]/BOHR_TO_ANGS, x[1]/BOHR_TO_ANGS, x[2]/BOHR_TO_ANGS); } fprintf(fp, " $END\n"); fclose(fp); return(0); }
static void write_network_to_xml (const gchar *id, EmpathyIrcNetwork *network, xmlNodePtr root) { xmlNodePtr network_node, servers_node; GSList *servers, *l; gchar *name, *charset; if (!network->user_defined) /* no need to write this network to the XML */ return; network_node = xmlNewChild (root, NULL, "network", NULL); xmlNewProp (network_node, "id", id); if (network->dropped) { xmlNewProp (network_node, "dropped", "1"); return; } g_object_get (network, "name", &name, "charset", &charset, NULL); xmlNewProp (network_node, "name", name); xmlNewProp (network_node, "network_charset", charset); g_free (name); g_free (charset); servers = empathy_irc_network_get_servers (network); servers_node = xmlNewChild (network_node, NULL, "servers", NULL); for (l = servers; l != NULL; l = g_slist_next (l)) { EmpathyIrcServer *server; xmlNodePtr server_node; gchar *address, *tmp; guint port; gboolean ssl; server = l->data; server_node = xmlNewChild (servers_node, NULL, "server", NULL); g_object_get (server, "address", &address, "port", &port, "ssl", &ssl, NULL); xmlNewProp (server_node, "address", address); tmp = g_strdup_printf ("%u", port); xmlNewProp (server_node, "port", tmp); g_free (tmp); xmlNewProp (server_node, "ssl", ssl ? "TRUE": "FALSE"); g_free (address); } /* free the list */ g_slist_foreach (servers, (GFunc) g_object_unref, NULL); g_slist_free (servers); }
void write_xmms_config() { /*char tempname[100];*/ char *tempname = (char *)malloc(sizeof(char)*100); int count; GSList *position = cdcover_config.cover_searchpaths; GSList *positionext = cdcover_config.cover_extensions; mcs_handle_t *config; DPRINT (__DEBUG_GENERAL__,"Writing config"); config = aud_cfg_db_open (); if (config) { // Window position aud_cfg_db_set_bool (config,PLUGIN_NAME,"savewindowpos",cdcover_config.save_window_pos); aud_cfg_db_set_int (config,PLUGIN_NAME,"windowposx",cdcover_config.winpos_x); aud_cfg_db_set_int (config,PLUGIN_NAME,"windowposy",cdcover_config.winpos_y); // Aspect ratio aud_cfg_db_set_bool (config,PLUGIN_NAME,"aspectratio",cdcover_config.preserve_aspectratio); // Iterate through the search list and save the paths count=0; while (position!=NULL) { count++; sprintf (tempname,"path%d",count); aud_cfg_db_set_string (config,PLUGIN_NAME,tempname,position->data); //printf("Wrote path %s (%d, %s)\n", (char *)position->data, count, tempname); position = g_slist_next (position); } //printf("Done writing paths\n"); // Delete the next key, so there's a hole and read_xmms_config can stop here // Not too nice, as we probably leave garbage in the xmms config file sprintf (tempname,"path%d",count+1); aud_cfg_db_unset_key (config,PLUGIN_NAME,tempname); // Iterate through the search list and save the extensions count=0; //printf("About to write extensions\n"); while (positionext!=NULL) { count++; sprintf (tempname,"ext%d",count); aud_cfg_db_set_string (config,PLUGIN_NAME,tempname,positionext->data); //printf("Wrote extension %s (%d, %s)\n", (char *)positionext->data, count, tempname); positionext = g_slist_next (positionext); } //printf("Done with the extensions too\n"); // Delete the next key, so there's a hole and read_xmms_config can stop here // Not too nice, as we probably leave garbage in the xmms config file sprintf (tempname,"ext%d",count+1); aud_cfg_db_unset_key (config,PLUGIN_NAME,tempname); // Save the skin if (cdcover_config.skin_path!=NULL) { // Save the user selected skin aud_cfg_db_set_string (config,PLUGIN_NAME,"skinpath",cdcover_config.skin_path); } else { // Built in default skin, delete the key aud_cfg_db_unset_key (config,PLUGIN_NAME,"skinpath"); } // Write and then free the config //printf("About to close config file\n"); aud_cfg_db_close (config); //printf("Closed config file\n"); } else { DPRINT (__DEBUG_GENERAL__,"cannot open config file for writing"); } }
static void deserialize_exif_gps_speed (GstTagList * taglist, const gchar * gst_tag, const gchar * xmp_tag, const gchar * str, GSList ** pending_tags) { const gchar *speed_str = NULL; const gchar *speedref_str = NULL; gint frac_n; gint frac_d; gdouble value; GSList *entry; PendingXmpTag *ptag = NULL; /* find the other missing part */ if (strcmp (xmp_tag, "exif:GPSSpeed") == 0) { speed_str = str; for (entry = *pending_tags; entry; entry = g_slist_next (entry)) { ptag = (PendingXmpTag *) entry->data; if (strcmp (ptag->xmp_tag->tag_name, "exif:GPSSpeedRef") == 0) { speedref_str = ptag->str; break; } } } else if (strcmp (xmp_tag, "exif:GPSSpeedRef") == 0) { speedref_str = str; for (entry = *pending_tags; entry; entry = g_slist_next (entry)) { ptag = (PendingXmpTag *) entry->data; if (strcmp (ptag->xmp_tag->tag_name, "exif:GPSSpeed") == 0) { speed_str = ptag->str; break; } } } else { GST_WARNING ("Unexpected xmp tag %s", xmp_tag); return; } if (!speed_str) { GST_WARNING ("Missing exif:GPSSpeed tag"); return; } if (!speedref_str) { GST_WARNING ("Missing exif:GPSSpeedRef tag"); return; } if (sscanf (speed_str, "%d/%d", &frac_n, &frac_d) != 2) { GST_WARNING ("Failed to parse fraction: %s", speed_str); return; } gst_util_fraction_to_double (frac_n, frac_d, &value); if (speedref_str[0] == 'K') { value *= KILOMETERS_PER_HOUR_TO_METERS_PER_SECOND; } else if (speedref_str[0] == 'M') { value *= MILES_PER_HOUR_TO_METERS_PER_SECOND; } else if (speedref_str[0] == 'N') { value *= KNOTS_TO_METERS_PER_SECOND; } else { GST_WARNING ("Unexpected exif:SpeedRef value: %s", speedref_str); return; } /* add to the taglist */ gst_tag_list_add (taglist, GST_TAG_MERGE_REPLACE, GST_TAG_GEO_LOCATION_MOVEMENT_SPEED, value, NULL); /* clean up entry */ g_free (ptag->str); g_slice_free (PendingXmpTag, ptag); *pending_tags = g_slist_delete_link (*pending_tags, entry); }
static void file_open_dialog_response (GtkWidget *open_dialog, gint response_id, Gimp *gimp) { GimpFileDialog *dialog = GIMP_FILE_DIALOG (open_dialog); GSList *uris; GSList *list; gboolean success = FALSE; g_object_set_data_full (G_OBJECT (gimp), "gimp-file-open-dialog-state", gimp_file_dialog_get_state (dialog), (GDestroyNotify) gimp_file_dialog_state_destroy); if (response_id != GTK_RESPONSE_OK) { if (! dialog->busy) gtk_widget_destroy (open_dialog); return; } uris = gtk_file_chooser_get_uris (GTK_FILE_CHOOSER (open_dialog)); if (uris) g_object_set_data_full (G_OBJECT (gimp), GIMP_FILE_OPEN_LAST_URI_KEY, g_strdup (uris->data), (GDestroyNotify) g_free); gimp_file_dialog_set_sensitive (dialog, FALSE); /* When we are going to open new image windows, unset the transient * window. We don't need it since we will use gdk_window_raise() to * keep the dialog on top. And if we don't do it, then the dialog * will pull the image window it was invoked from on top of all the * new opened image windows, and we don't want that to happen. */ if (! dialog->open_as_layers) gtk_window_set_transient_for (GTK_WINDOW (open_dialog), NULL); for (list = uris; list; list = g_slist_next (list)) { gchar *filename = file_utils_filename_from_uri (list->data); if (filename) { gboolean regular = g_file_test (filename, G_FILE_TEST_IS_REGULAR); g_free (filename); if (! regular) continue; } if (dialog->open_as_layers) { if (! dialog->image) { dialog->image = file_open_dialog_open_image (open_dialog, gimp, list->data, list->data, dialog->file_proc); if (dialog->image) success = TRUE; } else if (file_open_dialog_open_layers (open_dialog, dialog->image, list->data, list->data, dialog->file_proc)) { success = TRUE; } } else { if (file_open_dialog_open_image (open_dialog, gimp, list->data, list->data, dialog->file_proc)) { success = TRUE; /* Make the dialog stay on top of all images we open if * we open say 10 at once */ gdk_window_raise (gtk_widget_get_window (open_dialog)); } } if (dialog->canceled) break; } if (success) { if (dialog->open_as_layers && dialog->image) gimp_image_flush (dialog->image); gtk_widget_destroy (open_dialog); } else { gimp_file_dialog_set_sensitive (dialog, TRUE); } g_slist_free_full (uris, (GDestroyNotify) g_free); }
static GtkWidget * create_sheet_page(GtkWidget *parent, Sheet *sheet) { GSList *list; SheetObject *sheet_obj; GtkWidget *table; GtkWidget *button; GtkWidget *pixmapwidget; GdkPixmap *pixmap; GdkBitmap *mask; ToolButtonData *data; GtkStyle *style; GtkWidget *scrolled_window; int i; int rows; scrolled_window = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); rows = (g_slist_length(sheet->objects) - 1) / COLUMNS + 1; if (rows<1) rows = 1; table = gtk_table_new (rows, COLUMNS, TRUE); style = gtk_widget_get_style(parent); i = 0; list = sheet->objects; while (list != NULL) { sheet_obj = (SheetObject *) list->data; if (sheet_obj->pixmap != NULL) { pixmap = gdk_pixmap_create_from_xpm_d(parent->window, &mask, &style->bg[GTK_STATE_NORMAL], sheet_obj->pixmap); } else if (sheet_obj->pixmap_file != NULL) { pixmap = gdk_pixmap_create_from_xpm(parent->window, &mask, &style->bg[GTK_STATE_NORMAL], sheet_obj->pixmap_file); } else { ObjectType *type; type = object_get_type(sheet_obj->object_type); pixmap = gdk_pixmap_create_from_xpm_d(parent->window, &mask, &style->bg[GTK_STATE_NORMAL], type->pixmap); } pixmapwidget = gtk_pixmap_new(pixmap, mask); button = gtk_radio_button_new (tool_group); gtk_container_set_border_width (GTK_CONTAINER (button), 0); tool_group = gtk_radio_button_group (GTK_RADIO_BUTTON (button)); gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (button), FALSE); gtk_container_add (GTK_CONTAINER (button), pixmapwidget); gtk_table_attach (GTK_TABLE (table), button, (i % COLUMNS), (i % COLUMNS) + 1, (i / COLUMNS), (i / COLUMNS) + 1, GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_FILL, 0, 0); /* This is a Memory leak, these can't be freed. Doesn't matter much anyway... */ data = g_new(ToolButtonData, 1); data->type = CREATE_OBJECT_TOOL; data->extra_data = sheet_obj->object_type; data->user_data = sheet_obj->user_data; gtk_signal_connect (GTK_OBJECT (button), "toggled", GTK_SIGNAL_FUNC (tool_select_update), data); gtk_signal_connect (GTK_OBJECT (button), "button_press_event", GTK_SIGNAL_FUNC (tool_button_press), data); gtk_tooltips_set_tip (tool_tips, button, gettext(sheet_obj->description), NULL); list = g_slist_next(list); i++; } gtk_widget_show(table); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled_window), table); return scrolled_window; }
/* If the LHS of a relation test is a FIELD, run some checks * and possibly some modifications of syntax tree nodes. */ static void check_relation_LHS_FIELD(dfwork_t *dfw, const char *relation_string, FtypeCanFunc can_func, gboolean allow_partial_value, stnode_t *st_node, stnode_t *st_arg1, stnode_t *st_arg2) { stnode_t *new_st; sttype_id_t type2; header_field_info *hfinfo1, *hfinfo2; df_func_def_t *funcdef; ftenum_t ftype1, ftype2; fvalue_t *fvalue; char *s; type2 = stnode_type_id(st_arg2); hfinfo1 = (header_field_info*)stnode_data(st_arg1); ftype1 = hfinfo1->type; if (stnode_type_id(st_node) == STTYPE_TEST) { DebugLog((" 5 check_relation_LHS_FIELD(%s)\n", relation_string)); } else { DebugLog((" 6 check_relation_LHS_FIELD(%s)\n", relation_string)); } if (!can_func(ftype1)) { dfilter_fail(dfw, "%s (type=%s) cannot participate in '%s' comparison.", hfinfo1->abbrev, ftype_pretty_name(ftype1), relation_string); THROW(TypeError); } if (type2 == STTYPE_FIELD) { hfinfo2 = (header_field_info*)stnode_data(st_arg2); ftype2 = hfinfo2->type; if (!compatible_ftypes(ftype1, ftype2)) { dfilter_fail(dfw, "%s and %s are not of compatible types.", hfinfo1->abbrev, hfinfo2->abbrev); THROW(TypeError); } /* Do this check even though you'd think that if * they're compatible, then can_func() would pass. */ if (!can_func(ftype2)) { dfilter_fail(dfw, "%s (type=%s) cannot participate in specified comparison.", hfinfo2->abbrev, ftype_pretty_name(ftype2)); THROW(TypeError); } } else if (type2 == STTYPE_STRING || type2 == STTYPE_UNPARSED) { s = (char *)stnode_data(st_arg2); if (strcmp(relation_string, "matches") == 0) { /* Convert to a FT_PCRE */ if (type2 == STTYPE_STRING) fvalue = dfilter_fvalue_from_string(dfw, FT_PCRE, s); else fvalue = dfilter_fvalue_from_unparsed(dfw, FT_PCRE, s, FALSE); } else { /* Skip incompatible fields */ while (hfinfo1->same_name_prev_id != -1 && ((type2 == STTYPE_STRING && ftype1 != FT_STRING && ftype1!= FT_STRINGZ) || (type2 != STTYPE_STRING && (ftype1 == FT_STRING || ftype1== FT_STRINGZ)))) { hfinfo1 = proto_registrar_get_nth(hfinfo1->same_name_prev_id); ftype1 = hfinfo1->type; } if (type2 == STTYPE_STRING) fvalue = dfilter_fvalue_from_string(dfw, ftype1, s); else fvalue = dfilter_fvalue_from_unparsed(dfw, ftype1, s, allow_partial_value); if (!fvalue) { /* check value_string */ fvalue = mk_fvalue_from_val_string(dfw, hfinfo1, s); } } if (!fvalue) { THROW(TypeError); } new_st = stnode_new(STTYPE_FVALUE, fvalue); if (stnode_type_id(st_node) == STTYPE_TEST) { sttype_test_set2_args(st_node, st_arg1, new_st); } else { sttype_set_replace_element(st_node, st_arg2, new_st); } stnode_free(st_arg2); } else if (type2 == STTYPE_RANGE) { check_drange_sanity(dfw, st_arg2); if (!is_bytes_type(ftype1)) { if (!ftype_can_slice(ftype1)) { dfilter_fail(dfw, "\"%s\" is a %s and cannot be converted into a sequence of bytes.", hfinfo1->abbrev, ftype_pretty_name(ftype1)); THROW(TypeError); } /* Convert entire field to bytes */ new_st = convert_to_bytes(st_arg1); sttype_test_set2_args(st_node, new_st, st_arg2); } } else if (type2 == STTYPE_FUNCTION) { funcdef = sttype_function_funcdef(st_arg2); ftype2 = funcdef->retval_ftype; if (!compatible_ftypes(ftype1, ftype2)) { dfilter_fail(dfw, "%s (type=%s) and return value of %s() (type=%s) are not of compatible types.", hfinfo1->abbrev, ftype_pretty_name(ftype1), funcdef->name, ftype_pretty_name(ftype2)); THROW(TypeError); } if (!can_func(ftype2)) { dfilter_fail(dfw, "return value of %s() (type=%s) cannot participate in specified comparison.", funcdef->name, ftype_pretty_name(ftype2)); THROW(TypeError); } check_function(dfw, st_arg2); } else if (type2 == STTYPE_SET) { GSList *nodelist; /* A set should only ever appear on RHS of 'in' operation */ if (strcmp(relation_string, "in") != 0) { g_assert_not_reached(); } /* Attempt to interpret one element of the set at a time */ nodelist = (GSList*)stnode_data(st_arg2); while (nodelist) { stnode_t *node = (stnode_t*)nodelist->data; /* Don't let a range on the RHS affect the LHS field. */ if (stnode_type_id(node) == STTYPE_RANGE) { dfilter_fail(dfw, "A range may not appear inside a set."); THROW(TypeError); break; } check_relation_LHS_FIELD(dfw, "==", can_func, allow_partial_value, st_arg2, st_arg1, node); nodelist = g_slist_next(nodelist); } } else { g_assert_not_reached(); } }
void zmat_build(void) { gint i, j, k, n, type; gdouble r, a, d, x[4][3], v[3]; gdouble zaxis[3] = {0.0, 0.0, 1.0}; gchar *line; GSList *list, *species; struct zmat_pak *zmat; struct core_pak *core[4] = {NULL, NULL, NULL, NULL}; struct model_pak *model; model = sysenv.active_model; if (!model) return; /* CURRENT - using selection as our list of cores to generate a zmatrix from */ if (!model->selection) { gui_text_show(WARNING, "ZMATRIX: please select a molecule.\n"); return; } /* destroy old zmatrix */ /* TODO - prompt if non null */ zmat_free(model->zmatrix); zmat = model->zmatrix = zmat_new(); zmat_angle_units_set(model->zmatrix, DEGREES); /* setup SIESTA species type */ species = fdf_species_build(model); /* sort the list so it follows molecular connectivity */ model->selection = zmat_connect_sort(model->selection); n=0; for (list=model->selection ; list ; list=g_slist_next(list)) { /* current atom/zmatrix line init */ core[0] = list->data; type = fdf_species_index(core[0]->atom_label, species); line = NULL; zmat->zcores = g_slist_append(zmat->zcores, core[0]); /* build a ZMATRIX line for processing */ switch (n) { case 0: if (core[0]) { ARR3SET(x[0], core[0]->x); vecmat(model->latmat, x[0]); } line = g_strdup_printf("%d 0 0 0 %f %f %f 0 0 0\n", type, x[0][0], x[0][1], x[0][2]); break; case 1: if (core[0]) { ARR3SET(x[0], core[0]->x); vecmat(model->latmat, x[0]); } if (core[1]) { ARR3SET(x[1], core[1]->x); vecmat(model->latmat, x[1]); } r = measure_distance(x[0], x[1]); /* angle with z axis */ ARR3SET(v, x[0]); ARR3SUB(v, x[1]); a = R2D * via(v, zaxis, 3); /* angle between xy projection and x axis */ d = R2D * angle_x_compute(v[0], v[1]); line = g_strdup_printf("%d 1 0 0 %f %f %f 0 0 0\n", type, r, a, d); break; case 2: /* coords init */ for (i=3 ; i-- ; ) { if (core[i]) { ARR3SET(x[i], core[i]->x); vecmat(model->latmat, x[i]); } else g_assert_not_reached(); } r = measure_distance(x[0], x[1]); a = measure_angle(x[0], x[1], x[2]); /* create a fake core -> 1 unit displaced in the z direction */ g_assert(core[3] == NULL); core[3] = core_new("x", NULL, model); ARR3SET(core[3]->rx, core[2]->rx); ARR3ADD(core[3]->rx, zaxis); d = measure_torsion(core); core_free(core[3]); line = g_strdup_printf("%d 2 1 0 %f %f %f 0 0 0\n", type,r,a,d); break; default: /* connectivity test */ if (!zmat_bond_check(core[0], core[1])) { #if DEBUG_ZMAT_BUILD printf("[%d] non-connected atoms [%f]\n", n, measure_distance(x[0], x[1])); #endif /* need to build a new connectivity chain starting from core[0] */ core[1] = core[2] = core[3] = NULL; if (!zmat_connect_find(n, core, zmat)) { gui_text_show(WARNING, "ZMATRIX: bad connectivity (molecule will be incomplete)\n"); goto zmat_build_done; } } /* coords init */ for (i=3 ; i-- ; ) { if (core[i]) { ARR3SET(x[i], core[i]->x); vecmat(model->latmat, x[i]); } else g_assert_not_reached(); } r = measure_distance(x[0], x[1]); a = measure_angle(x[0], x[1], x[2]); d = measure_torsion(core); /* NB: indexing starts from 0, siesta starts from 1 (naturally) */ i = 1+g_slist_index(zmat->zcores, core[1]); j = 1+g_slist_index(zmat->zcores, core[2]); k = 1+g_slist_index(zmat->zcores, core[3]); line = g_strdup_printf("%d %d %d %d %f %f %f 0 0 0\n", type,i,j,k,r,a,d); } /* process a successfully constructed ZMATRIX line */ if (line) { zmat_core_add(line, model->zmatrix); g_free(line); } /* shuffle */ core[3] = core[2]; core[2] = core[1]; core[1] = core[0]; n++; } zmat_build_done: /* do the species typing */ zmat_type(model->zmatrix, species); free_slist(species); }
void plug_in_menus_setup (GimpUIManager *manager, const gchar *ui_path) { GimpPlugInManager *plug_in_manager; GTree *menu_entries; GSList *list; guint merge_id; gint i; g_return_if_fail (GIMP_IS_UI_MANAGER (manager)); g_return_if_fail (ui_path != NULL); plug_in_manager = manager->gimp->plug_in_manager; merge_id = gtk_ui_manager_new_merge_id (GTK_UI_MANAGER (manager)); for (i = 0; i < manager->gimp->config->plug_in_history_size; i++) { gchar *action_name; gchar *action_path; action_name = g_strdup_printf ("plug-in-recent-%02d", i + 1); action_path = g_strdup_printf ("%s/Filters/Recently Used/Plug-Ins", ui_path); gtk_ui_manager_add_ui (GTK_UI_MANAGER (manager), merge_id, action_path, action_name, action_name, GTK_UI_MANAGER_MENUITEM, FALSE); g_free (action_name); g_free (action_path); } menu_entries = g_tree_new_full ((GCompareDataFunc) strcmp, NULL, g_free, (GDestroyNotify) plug_in_menu_entry_free); for (list = plug_in_manager->plug_in_procedures; list; list = g_slist_next (list)) { GimpPlugInProcedure *plug_in_proc = list->data; if (! plug_in_proc->file) continue; g_signal_connect_object (plug_in_proc, "menu-path-added", G_CALLBACK (plug_in_menus_menu_path_added), manager, 0); if (plug_in_proc->menu_paths && ! plug_in_proc->file_proc) { GList *path; for (path = plug_in_proc->menu_paths; path; path = g_list_next (path)) { if (g_str_has_prefix (path->data, manager->name)) { PlugInMenuEntry *entry = g_slice_new0 (PlugInMenuEntry); GFile *file; const gchar *locale_domain; entry->proc = plug_in_proc; entry->menu_path = path->data; file = gimp_plug_in_procedure_get_file (plug_in_proc); locale_domain = gimp_plug_in_manager_get_locale_domain (plug_in_manager, file, NULL); if (plug_in_proc->menu_label) { gchar *menu; menu = g_strconcat (dgettext (locale_domain, path->data), "/", dgettext (locale_domain, plug_in_proc->menu_label), NULL); plug_in_menus_tree_insert (menu_entries, menu, entry); g_free (menu); } else { plug_in_menus_tree_insert (menu_entries, dgettext (locale_domain, path->data), entry); } } } } } g_object_set_data (G_OBJECT (manager), "ui-path", (gpointer) ui_path); g_tree_foreach (menu_entries, (GTraverseFunc) plug_in_menus_tree_traverse, manager); g_object_set_data (G_OBJECT (manager), "ui-path", NULL); g_tree_destroy (menu_entries); g_signal_connect_object (manager->gimp->pdb, "register-procedure", G_CALLBACK (plug_in_menus_register_procedure), manager, 0); g_signal_connect_object (manager->gimp->pdb, "unregister-procedure", G_CALLBACK (plug_in_menus_unregister_procedure), manager, 0); }
gint zmat_connect_find(gint n, struct core_pak **core, struct zmat_pak *zmatrix) { gint m; GSList *list1, *list2; struct zval_pak *zval; struct core_pak *seek; struct bond_pak *bond; g_assert(core != NULL); g_assert(zmatrix != NULL); for (list1=core[0]->bonds ; list1 ; list1=g_slist_next(list1)) { bond = list1->data; if (bond->type == BOND_HBOND) continue; if (bond->atom1 == core[0]) seek = bond->atom2; else seek = bond->atom1; /* TODO - if atom has been PRUNED - should be gtg (faster than index check) */ m = g_slist_index(zmatrix->zcores, seek); #if DEBUG_ZMAT_CONNECT_FIND printf("atom: %d, seeking chain with head: [%d] %p\n", n, m, seek); #endif if (m < 0) { #if DEBUG_ZMAT_CONNECT_FIND printf("Ignoring atom that is not yet defined.\n"); #endif continue; } /* trivial case - use the head atom's zmatrix line (IF it's not one */ /* of the first 2 special case atoms */ if (m < n && m > 3) { zval = g_slist_nth_data(zmatrix->zlines, m); g_assert(zval != NULL); core[1] = g_slist_nth_data(zmatrix->zcores, m); core[2] = g_slist_nth_data(zmatrix->zcores, zval->connect[0]-1); core[3] = g_slist_nth_data(zmatrix->zcores, zval->connect[1]-1); #if DEBUG_ZMAT_CONNECT_FIND printf("Using trivial case: [%d][%d][%d]\n", g_slist_index(zmatrix->zcores, core[1]), g_slist_index(zmatrix->zcores, core[2]), g_slist_index(zmatrix->zcores, core[3])); #endif return(TRUE); } list2 = zmatrix->zlines; list2 = g_slist_next(list2); list2 = g_slist_next(list2); while (list2) { zval = list2->data; if (m == zval->connect[0]) { #if DEBUG_ZMAT_CONNECT_FIND printf("found: [%d][%d][%d]\n", zval->connect[0], zval->connect[1], zval->connect[2]); #endif core[1] = g_slist_nth_data(zmatrix->zcores, zval->connect[0]); core[2] = g_slist_nth_data(zmatrix->zcores, zval->connect[1]); core[3] = g_slist_nth_data(zmatrix->zcores, zval->connect[2]); return(TRUE); } if (m == zval->connect[2]) { #if DEBUG_ZMAT_CONNECT_FIND printf("found: [%d][%d][%d]\n", zval->connect[0], zval->connect[1], zval->connect[2]); #endif core[1] = g_slist_nth_data(zmatrix->zcores, zval->connect[2]); core[2] = g_slist_nth_data(zmatrix->zcores, zval->connect[1]); core[3] = g_slist_nth_data(zmatrix->zcores, zval->connect[0]); return(TRUE); } list2 = g_slist_next(list2); } } return(FALSE); }
GSList *zmat_connect_sort(GSList *molecule) { GSList *list, *path, *sorted; struct core_pak *core, *next; /* flag all atoms as unpruned */ for (list=molecule ; list ; list=g_slist_next(list)) { core = list->data; core->status &= ~PRUNED; } /* CURRENT - try to start connectivity chain with an atom with 1 bond */ next = NULL; path = NULL; for (list=molecule ; list ; list=g_slist_next(list)) { core = list->data; if (g_slist_length(core->bonds) == 1) { next = core; break; } } /* if we can't find single bonded atom - start with 1st in selection & hope */ if (next) path = g_slist_append(path, core); else path = g_slist_append(path, molecule->data); /* trace connectivity - store atoms with more than two bonds */ sorted = NULL; while (path) { core = path->data; if (!(core->status & PRUNED)) { core->status |= PRUNED; sorted = g_slist_append(sorted, core); } while (core) { next = zmat_connect_next(core); if (next) { if (g_slist_length(next->bonds) > 2) path = g_slist_append(path, next); next->status |= PRUNED; sorted = g_slist_append(sorted, next); } core = next; } /* current chain exhausted - check current node (path) for another to */ /* expore, if nothing - try to get next node */ while (path) { core = zmat_connect_next(path->data); if (core) break; path = g_slist_next(path); } } return(sorted); }
void zmat_process(gpointer data, struct model_pak *model) { gint i, n; gdouble r, a, d; gdouble v1[3], v2[3], v3[3], m1[9], m2[9]; gpointer tmp; GSList *list; struct zmat_pak *zmat = data; struct zval_pak *zval; struct core_pak *core[4] = {NULL, NULL, NULL, NULL}; /* checks */ if (!zmat) return; matrix_lattice_init(model); #if ZMAT_PROCESS_DEBUG printf("distance scale = %f\n", zmat->distance_scale); printf("angle scale = %f\n", zmat->angle_scale); #endif /* track the core # - 1st 3 items in zmatrix are exceptions */ n = 0; for (list=zmat->zlines ; list ; list=g_slist_next(list)) { zval = list->data; /* check for variable names */ for (i=3 ; i-- ; ) { if (zval->name[i]) { /* hash table lookup for variable value */ zval->value[i] = zmat_table_lookup(zval->name[i], zmat); } } /* create the core */ #if ZMAT_PROCESS_DEBUG printf("[%d = %s] [%d %d %d]", zval->type, zval->elem, zval->connect[0], zval->connect[1], zval->connect[2]); P3VEC(" x: ", zval->value); #endif /* TODO - need to mark zmatrix generated cores as special */ /* probably have another list in the zmat struct that contains */ /* all the cores created below */ switch (n) { case 0: /* TODO - convert to cartesian if fractional and enforce cart model */ core[0] = new_core(zval->elem, model); model->cores = g_slist_prepend(model->cores, core[0]); zmat->zcores = g_slist_prepend(zmat->zcores, core[0]); ARR3SET(core[0]->x, zval->value); if (zmat->fractional) vecmat(model->latmat, core[0]->x); else { VEC3MUL(core[0]->x, zmat->distance_scale); } break; case 1: core[1] = new_core(zval->elem, model); model->cores = g_slist_prepend(model->cores, core[1]); zmat->zcores = g_slist_prepend(zmat->zcores, core[1]); r = zmat->distance_scale * zval->value[0]; /* a = zmat->angle_scale * zval->value[1]; d = zmat->angle_scale * zval->value[2]; */ /* SIESTA hack : z-axis angle is 2nd, and theta is 3rd (last) */ a = zmat->angle_scale * zval->value[2]; d = zmat->angle_scale * zval->value[1]; v1[0] = v1[1] = r * sin(d); v1[0] *= cos(a); v1[1] *= sin(a); v1[2] = r * cos(d); ARR3SET(core[1]->x, core[0]->x); ARR3ADD(core[1]->x, v1); break; case 2: /* check the connection order */ if (zval->connect[0] == 2) { tmp = core[0]; core[0] = core[1]; core[1] = tmp; } r = zmat->distance_scale * zval->value[0]; a = zmat->angle_scale * zval->value[1]; d = zmat->angle_scale * zval->value[2]; ARR3SET(v2, core[1]->x); ARR3SUB(v2, core[0]->x); /* get rotation axis for bond angle */ VEC3SET(v3, 0.0, 0.0, 1.0); crossprod(v1, v3, v2); /* rotate bondlength scaled vector into position */ matrix_v_rotation(m2, v1, a); ARR3SET(v3, v2); normalize(v3, 3); VEC3MUL(v3, r); vecmat(m2, v3); /* rotate to give required dihedral */ matrix_v_rotation(m1, v2, d); vecmat(m1, v3); /* generate the atom position */ core[2] = new_core(zval->elem, model); model->cores = g_slist_prepend(model->cores, core[2]); zmat->zcores = g_slist_prepend(zmat->zcores, core[2]); ARR3SET(core[2]->x, core[0]->x); ARR3ADD(core[2]->x, v3); break; default: /* get core connectivity (NB: prepending cores - hence n - number) */ core[0] = g_slist_nth_data(zmat->zcores, n-zval->connect[0]); core[1] = g_slist_nth_data(zmat->zcores, n-zval->connect[1]); core[2] = g_slist_nth_data(zmat->zcores, n-zval->connect[2]); g_assert(core[0] != NULL); g_assert(core[1] != NULL); g_assert(core[2] != NULL); r = zmat->distance_scale * zval->value[0]; a = zmat->angle_scale * zval->value[1]; d = zmat->angle_scale * zval->value[2]; /* setup vectors */ ARR3SET(v2, core[1]->x); ARR3SUB(v2, core[0]->x); ARR3SET(v3, core[2]->x); ARR3SUB(v3, core[1]->x); /* rotate v3 about v2 to give dihedral */ matrix_v_rotation(m1, v2, d); vecmat(m1, v3); /* get rotation axis and matrix for bond angle */ crossprod(v1, v3, v2); matrix_v_rotation(m2, v1, a); normalize(v2, 3); VEC3MUL(v2, r); vecmat(m2, v2); /* generate the atom position */ core[3] = new_core(zval->elem, model); model->cores = g_slist_prepend(model->cores, core[3]); zmat->zcores = g_slist_prepend(zmat->zcores, core[3]); ARR3SET(core[3]->x, core[0]->x); ARR3ADD(core[3]->x, v2); /* TODO (maybe) - some zmatrix constructions implicitly assume */ /* some checking for duplicate atoms & reversing the torsional */ /* angle sense to accomodate this. */ break; } n++; } /* zmatrix cores are created in cartesians - revert to fractional if required */ if (model->fractional) { for (list=zmat->zcores ; list ; list=g_slist_next(list)) { core[0] = list->data; vecmat(model->ilatmat, core[0]->x); } } }
gint read_gms_out_block(FILE *fp, struct model_pak *model, gint num_skip, gint bohr) { gint i, num_tokens; gchar **buff, line[LINELEN]; GString *title, *energy_string, *grad_string; GSList *clist; struct core_pak *core; clist = model->cores; /* ignore first num_skip lines */ for (i=0 ; i<num_skip; i++) if (fgetline(fp, line)) { gui_text_show(ERROR, "unexpected end of file reading coordinates\n"); return(11); } model->construct_pbc = FALSE; model->fractional = FALSE; /* get 1st line of coords */ if (fgetline(fp, line)) { gui_text_show(ERROR, "unexpected end of file reading coordinates\n"); return(11); } buff = tokenize(line, &num_tokens); while (num_tokens > 4) { if (clist) { core = clist->data; clist = g_slist_next(clist); } else { core = new_core(elements[(int) str_to_float(*(buff+1))].symbol, model); model->cores = g_slist_append(model->cores, core); } if (bohr) { core->x[0] = BOHR_TO_ANGS*str_to_float(*(buff+2)); core->x[1] = BOHR_TO_ANGS*str_to_float(*(buff+3)); core->x[2] = BOHR_TO_ANGS*str_to_float(*(buff+4)); } else { core->x[0] = str_to_float(*(buff+2)); core->x[1] = str_to_float(*(buff+3)); core->x[2] = str_to_float(*(buff+4)); } /* get next line */ g_strfreev(buff); if (fgetline(fp, line)) { gui_text_show(ERROR, "unexpected end of file reading coordinates\n"); return(11); } buff = tokenize(line, &num_tokens); } g_strfreev(buff); /* search for energy */ while (!fgetline(fp, line)) { if (g_ascii_strncasecmp(line, " FINAL", 6) == 0) { buff = tokenize(line, &num_tokens); if (g_ascii_strncasecmp(*(buff+1), "ENERGY", 6) == 0) model->gamess.energy = str_to_float(*(buff+3)); else model->gamess.energy = str_to_float(*(buff+4)); model->gamess.have_energy = TRUE; g_strfreev(buff); break; } } /* update for MP? */ if (model->gamess.MP_level > 0) { while (!fgetline(fp, line)) { if (g_strrstr(line ,"E(MP2)") != NULL) { buff = tokenize(line, &num_tokens); model->gamess.energy = str_to_float(*(buff+1)); model->gamess.have_energy = TRUE; g_strfreev(buff); break; } } } /* search for gradient and read any properties */ while (!fgetline(fp, line)) { if (g_ascii_strncasecmp(line, " NET CHARGES:", 13) == 0) { clist = model->cores; /* skip forward four lines */ for (i=0 ; i<4; i++) if (fgetline(fp, line)) { gui_text_show(ERROR, "unexpected end of file reading fitted charges\n"); return(11); } while (clist != NULL) { buff = tokenize(line, &num_tokens); core = clist->data; core->lookup_charge = FALSE; core->charge = str_to_float(*(buff+1)); g_strfreev(buff); clist = g_slist_next(clist); if (fgetline(fp, line)) { gui_text_show(ERROR, "unexpected end of file reading fitted charges\n"); return(11); } } } if (g_ascii_strncasecmp(line, " MAXIMUM GRADIENT", 26) == 0) { buff = tokenize(line, &num_tokens); model->gamess.max_grad = str_to_float(*(buff+3)); model->gamess.have_max_grad = TRUE; model->gamess.rms_grad = str_to_float(*(buff+7)); model->gamess.have_rms_grad = TRUE; g_strfreev(buff); /* check next line to see if converged */ if (fgetline(fp, line)) { gui_text_show(ERROR, "unexpected end of file reading equilibrium status\n"); return(11); } if (g_ascii_strncasecmp(line, "1 ***** EQUILIBRIUM GEOMETRY LOCATED *****", 46) == 0) model->gamess.converged = TRUE; break; } } g_free(model->title); title = g_string_new(""); if (model->gamess.have_energy) { energy_string = g_string_new(""); g_string_append_printf(energy_string, "%.5f H", model->gamess.energy); property_add_ranked(3, "Energy", energy_string->str, model); g_string_free(energy_string, TRUE); g_string_append_printf(title, "E"); if (model->gamess.MP_level > 0) g_string_append_printf(title, "(MP%d)", model->gamess.MP_level); g_string_append_printf(title, " = %.5f H", model->gamess.energy); } if (model->gamess.have_rms_grad) { grad_string = g_string_new(""); g_string_append_printf(grad_string, "%.4f H/B", model->gamess.rms_grad); property_add_ranked(4, "RMS Gradient", grad_string->str, model); g_string_free(grad_string, TRUE); g_string_append_printf(title, ", grad = %.5f", model->gamess.rms_grad); } if (model->gamess.have_max_grad) { grad_string = g_string_new(""); g_string_append_printf(grad_string, "%.4f H/B", model->gamess.max_grad); property_add_ranked(4, "Maximum Gradient", grad_string->str, model); g_string_free(grad_string, TRUE); } model->title = g_strdup(title->str); g_string_free(title, TRUE); return(0); }
gint get_next_group(FILE *fp, struct model_pak *model, gint *have_basis) { gchar *line, *keyword; gint ret; GSList *keywords = NULL, *list; line = file_read_line(fp); if (!line) return(FALSE); /* TODO not a valid keyword so for the moment skip but could store */ if (g_ascii_strncasecmp(line, " $", 2) != 0) return(TRUE); if (g_ascii_strncasecmp(line, " $data", 6) == 0) { ret = get_data(fp, model, *have_basis); } else if (g_ascii_strncasecmp(line, " $basis", 7) == 0) { *have_basis = TRUE; keywords = get_gamess_keywords(fp, line+7, &ret); for (list=keywords ; list ; list=g_slist_next(list)) { keyword = (gchar *) list->data; ret = get_basis(keyword, model); } } else if (g_ascii_strncasecmp(line, " $contrl", 8) == 0) { keywords = get_gamess_keywords(fp, line+8, &ret); for (list=keywords; list ; list=g_slist_next(list)) { keyword = (gchar *) list->data; ret = get_control(keyword, model); } } else if (g_ascii_strncasecmp(line, " $system", 8) == 0) { keywords = get_gamess_keywords(fp, line+8, &ret); for (list=keywords; list ; list=g_slist_next(list)) { keyword = (gchar *) list->data; ret = get_system(keyword, model); } } else if (g_ascii_strncasecmp(line, " $statpt", 8) == 0) { keywords = get_gamess_keywords(fp, line+8, &ret); for (list=keywords; list ; list=g_slist_next(list)) { keyword = (gchar *) list->data; ret = get_statpt(keyword, model); } } else if (g_ascii_strncasecmp(line, " $dft", 5) == 0) { model->gamess.dft = TRUE; /* TODO - process functional */ } else { /* TODO - Unknown keyword, just pass through */ } free_slist(keywords); g_free(line); return(TRUE); }
static struct fp_driver *find_supporting_driver(libusb_device *udev, const struct usb_id **usb_id, uint32_t *devtype) { int ret; GSList *elem = registered_drivers; struct libusb_device_descriptor dsc; const struct usb_id *best_usb_id; struct fp_driver *best_drv; uint32_t best_devtype; int drv_score = 0; ret = libusb_get_device_descriptor(udev, &dsc); if (ret < 0) { fp_err("Failed to get device descriptor"); return NULL; } best_drv = NULL; best_devtype = 0; do { struct fp_driver *drv = elem->data; uint32_t type = 0; const struct usb_id *id; for (id = drv->id_table; id->vendor; id++) { if (dsc.idVendor == id->vendor && dsc.idProduct == id->product) { if (drv->discover) { int r = drv->discover(&dsc, &type); if (r < 0) fp_err("%s discover failed, code %d", drv->name, r); if (r <= 0) continue; /* Has a discover function, and matched our device */ drv_score = 100; } else { /* Already got a driver as good */ if (drv_score >= 50) continue; drv_score = 50; } fp_dbg("driver %s supports USB device %04x:%04x", drv->name, id->vendor, id->product); best_usb_id = id; best_drv = drv; best_devtype = type; /* We found the best possible driver */ if (drv_score == 100) break; } } } while ((elem = g_slist_next(elem))); if (best_drv != NULL) { fp_dbg("selected driver %s supports USB device %04x:%04x", best_drv->name, dsc.idVendor, dsc.idProduct); *devtype = best_devtype; *usb_id = best_usb_id; } return best_drv; }
static GtkWidget * build_suggestion_menu (PlumaAutomaticSpellChecker *spell, const gchar *word) { GtkWidget *topmenu, *menu; GtkWidget *mi; GSList *suggestions; GSList *list; gchar *label_text; topmenu = menu = gtk_menu_new(); suggestions = pluma_spell_checker_get_suggestions (spell->spell_checker, word, -1); list = suggestions; if (suggestions == NULL) { /* no suggestions. put something in the menu anyway... */ GtkWidget *label; /* Translators: Displayed in the "Check Spelling" dialog if there are no suggestions for the current misspelled word */ label = gtk_label_new (_("(no suggested words)")); mi = gtk_menu_item_new (); gtk_widget_set_sensitive (mi, FALSE); gtk_container_add (GTK_CONTAINER(mi), label); gtk_widget_show_all (mi); gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), mi); } else { gint count = 0; /* build a set of menus with suggestions. */ while (suggestions != NULL) { GtkWidget *label; if (count == 10) { /* Separator */ mi = gtk_menu_item_new (); gtk_widget_show (mi); gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi); mi = gtk_menu_item_new_with_mnemonic (_("_More...")); gtk_widget_show (mi); gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi); menu = gtk_menu_new (); gtk_menu_item_set_submenu (GTK_MENU_ITEM (mi), menu); count = 0; } label_text = g_strdup_printf ("<b>%s</b>", (gchar*) suggestions->data); label = gtk_label_new (label_text); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); gtk_label_set_xalign (GTK_LABEL (label), 0.0); mi = gtk_menu_item_new (); gtk_container_add (GTK_CONTAINER(mi), label); gtk_widget_show_all (mi); gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi); g_object_set_qdata_full (G_OBJECT (mi), suggestion_id, g_strdup (suggestions->data), (GDestroyNotify)g_free); g_free (label_text); g_signal_connect (mi, "activate", G_CALLBACK (replace_word), spell); count++; suggestions = g_slist_next (suggestions); } } /* free the suggestion list */ suggestions = list; while (list) { g_free (list->data); list = g_slist_next (list); } g_slist_free (suggestions); /* Separator */ mi = gtk_menu_item_new (); gtk_widget_show (mi); gtk_menu_shell_append (GTK_MENU_SHELL (topmenu), mi); /* Ignore all */ mi = gtk_image_menu_item_new_with_mnemonic (_("_Ignore All")); gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (mi), gtk_image_new_from_icon_name ("go-bottom", GTK_ICON_SIZE_MENU)); g_signal_connect (mi, "activate", G_CALLBACK(ignore_all), spell); gtk_widget_show_all (mi); gtk_menu_shell_append (GTK_MENU_SHELL (topmenu), mi); /* + Add to Dictionary */ mi = gtk_image_menu_item_new_with_mnemonic (_("_Add")); gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (mi), gtk_image_new_from_icon_name ("list-add", GTK_ICON_SIZE_MENU)); g_signal_connect (mi, "activate", G_CALLBACK (add_to_dictionary), spell); gtk_widget_show_all (mi); gtk_menu_shell_append (GTK_MENU_SHELL (topmenu), mi); return topmenu; }
void view_enter(struct dt_lib_module_t *self,struct dt_view_t *old_view,struct dt_view_t *new_view) { dt_lib_camera_t *lib = self->data; /* add all camera properties to the widget */ dt_lib_camera_property_t *prop; if((prop = _lib_property_add_new(lib, _("program"), "expprogram")) != NULL) _lib_property_add_to_gui(prop, lib); if((prop = _lib_property_add_new(lib, _("focus mode"), "focusmode")) != NULL) _lib_property_add_to_gui(prop, lib); else if((prop = _lib_property_add_new(lib, _("focus mode"), "drivemode")) != NULL) _lib_property_add_to_gui(prop, lib); if((prop = _lib_property_add_new(lib, _("aperture"), "f-number")) != NULL) _lib_property_add_to_gui(prop, lib); else if((prop = _lib_property_add_new(lib, _("aperture"), "aperture")) != NULL) // for Canon cameras _lib_property_add_to_gui(prop, lib); if((prop = _lib_property_add_new(lib, _("focal length"), "focallength")) != NULL) _lib_property_add_to_gui(prop, lib); if((prop = _lib_property_add_new(lib, _("shutterspeed2"), "shutterspeed2")) != NULL) _lib_property_add_to_gui(prop, lib); else if((prop = _lib_property_add_new(lib, _("shutterspeed"), "shutterspeed")) != NULL) // Canon, again _lib_property_add_to_gui(prop, lib); if((prop = _lib_property_add_new(lib, _("ISO"), "iso")) != NULL) _lib_property_add_to_gui(prop, lib); if((prop = _lib_property_add_new(lib, _("WB"), "whitebalance")) != NULL) _lib_property_add_to_gui(prop, lib); if((prop = _lib_property_add_new(lib, _("quality"), "imagequality")) != NULL) _lib_property_add_to_gui(prop, lib); if((prop = _lib_property_add_new(lib, _("size"), "imagesize")) != NULL) _lib_property_add_to_gui(prop, lib); /* add user widgets */ GSList *options = dt_conf_all_string_entries("plugins/capture/tethering/properties"); if(options) { GSList *item = options; if(item) { do { dt_conf_string_entry_t *entry = (dt_conf_string_entry_t *)item->data; /* get the label from key */ char *p = entry->key; const char *end = entry->key + strlen(entry->key); while(p++ < end) if(*p == '_') *p = ' '; if((prop = _lib_property_add_new(lib, entry->key, entry->value)) != NULL) _lib_property_add_to_gui(prop, lib); } while((item = g_slist_next(item)) != NULL); } g_slist_free_full(options, dt_conf_string_entry_free); } /* build the propertymenu we do it now because it needs an actual camera */ dt_camctl_camera_build_property_menu(darktable.camctl, NULL, &lib->gui.properties_menu, G_CALLBACK(_property_choice_callback), lib); // Register listener dt_camctl_register_listener(darktable.camctl, lib->data.listener); dt_camctl_tether_mode(darktable.camctl, NULL, TRUE); // Get camera model name lib->data.camera_model = dt_camctl_camera_get_model(darktable.camctl, NULL); }
static void pluma_automatic_spell_checker_free_internal (PlumaAutomaticSpellChecker *spell) { GtkTextTagTable *table; GtkTextIter start, end; GSList *list; g_return_if_fail (spell != NULL); table = gtk_text_buffer_get_tag_table (GTK_TEXT_BUFFER (spell->doc)); if (table != NULL && spell->tag_highlight != NULL) { gtk_text_buffer_get_bounds (GTK_TEXT_BUFFER (spell->doc), &start, &end); gtk_text_buffer_remove_tag (GTK_TEXT_BUFFER (spell->doc), spell->tag_highlight, &start, &end); g_signal_handlers_disconnect_matched (G_OBJECT (table), G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, spell); gtk_text_tag_table_remove (table, spell->tag_highlight); } g_signal_handlers_disconnect_matched (G_OBJECT (spell->doc), G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, spell); g_signal_handlers_disconnect_matched (G_OBJECT (spell->spell_checker), G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, spell); g_object_unref (spell->spell_checker); list = spell->views; while (list != NULL) { PlumaView *view = PLUMA_VIEW (list->data); g_signal_handlers_disconnect_matched (G_OBJECT (view), G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, spell); g_signal_handlers_disconnect_matched (G_OBJECT (view), G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, spell); list = g_slist_next (list); } g_slist_free (spell->views); g_free (spell); }
int main (int argc, char *argv[]) { int err, i; GNOME_Pilot_Survival survive; GError *error; GList *pilots = NULL; GOptionContext *option_context; bindtextdomain (PACKAGE, GNOMELOCALEDIR); textdomain (PACKAGE); bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); if (argc<2) { g_message ("usage : %s [--now|--later] [--pilot PDA] [FILE ...]", argv[0]); exit (1); } option_context = g_option_context_new (PACKAGE); g_option_context_add_main_entries (option_context, options, NULL); if (!g_option_context_parse(option_context, &argc, &argv, &error)) { g_error (_("Error parsing commandline arguments: %s"), error->message); exit (1); } gtk_init (&argc, &argv); gpc = GNOME_PILOT_CLIENT (gnome_pilot_client_new ()); g_object_ref_sink (G_OBJECT (gpc)); g_signal_connect (G_OBJECT (gpc),"completed_request", G_CALLBACK(gpilotd_request_completed), NULL); gnome_pilot_client_connect_to_daemon (gpc); if (pilot_arg!=NULL) { pilots = g_list_append (pilots, g_strdup (pilot_arg)); } else { err = gnome_pilot_client_get_pilots (gpc, &pilots); if (err !=GPILOTD_OK || pilots == NULL) { g_warning (_("Unable to get PDA names")); show_warning_dialog (_("Unable to get PDA names")); exit (1); } } notfailed = failed = handles = NULL; survive = GNOME_Pilot_IMMEDIATE; if (later) survive = GNOME_Pilot_PERSISTENT; i=0; while (filenames && filenames[i]!=NULL) { gint err; err = gnome_pilot_client_install_file (gpc, pilots->data, /* get first pilot */ filenames[i], survive, 0, &handle); if (err == GPILOTD_OK) { handles = g_slist_prepend (handles,GINT_TO_POINTER(handle)); notfailed = g_slist_prepend (notfailed, (void *) filenames[i]); } else { failed = g_slist_prepend (failed, (void *) filenames[i]); } i++; } if (!later) { gchar *message; message = NULL; if (failed != NULL) { GSList *e; message = g_strdup (_("Following files failed :\n")); for (e=failed;e;e = g_slist_next (e)) { gchar *tmp; tmp = g_strconcat (message,"\t- ", e->data,"\n", NULL); g_free (message); message = tmp; } g_slist_free (failed); } { GSList *e; if (message == NULL) message = g_strdup_printf (_("Installing to %s:\n"), (char*)pilots->data); else { gchar *tmp; tmp = g_strconcat (message,"\nInstalling to ", (char*)pilots->data, ":\n", NULL); g_free (message); message = tmp; } for (e=notfailed;e;e = g_slist_next (e)) { gchar *tmp; tmp = g_strconcat (message,"\t- ", e->data,"\n", NULL); g_free (message); message = tmp; } g_slist_free (notfailed); } { gchar *tmp; gchar *info; if (handles == NULL) info = g_strdup (_("No files to install")); else { info = g_strdup (_("Press synchronize on the cradle to install\n" " or cancel the operation.")); err = gnome_pilot_client_conduit (gpc, pilots->data, "File", GNOME_Pilot_CONDUIT_DEFAULT, survive, 0, &handle); } tmp = g_strconcat (message==NULL?"":message, "\n", info, NULL); g_free (message); g_free (info); message = tmp; } dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_OTHER, GTK_BUTTONS_CANCEL, "%s", message); gint response = gtk_dialog_run(GTK_DIALOG(dialog)); if (dialog != NULL) /* if not destroyed by callback */ gtk_widget_destroy(dialog); if (response == GTK_RESPONSE_CANCEL) { GSList *e; for (e=handles;e;e = g_slist_next (e)) { gnome_pilot_client_remove_request (gpc,GPOINTER_TO_INT(e->data)); } g_slist_free (handles); } g_free (message); } g_object_unref (G_OBJECT (gpc)); return 0; }
void gimp_plug_in_procedure_set_file_proc (GimpPlugInProcedure *proc, const gchar *extensions, const gchar *prefixes, const gchar *magics) { GSList *list; g_return_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc)); proc->file_proc = TRUE; /* extensions */ if (proc->extensions != extensions) { if (proc->extensions) g_free (proc->extensions); proc->extensions = g_strdup (extensions); } if (proc->extensions_list) g_slist_free_full (proc->extensions_list, (GDestroyNotify) g_free); proc->extensions_list = extensions_parse (proc->extensions); /* prefixes */ if (proc->prefixes != prefixes) { if (proc->prefixes) g_free (proc->prefixes); proc->prefixes = g_strdup (prefixes); } if (proc->prefixes_list) g_slist_free_full (proc->prefixes_list, (GDestroyNotify) g_free); proc->prefixes_list = extensions_parse (proc->prefixes); /* don't allow "file:" to be registered as prefix */ for (list = proc->prefixes_list; list; list = g_slist_next (list)) { const gchar *prefix = list->data; if (prefix && strcmp (prefix, "file:") == 0) { g_free (list->data); proc->prefixes_list = g_slist_delete_link (proc->prefixes_list, list); break; } } /* magics */ if (proc->magics != magics) { if (proc->magics) g_free (proc->magics); proc->magics = g_strdup (magics); } if (proc->magics_list) g_slist_free_full (proc->magics_list, (GDestroyNotify) g_free); proc->magics_list = extensions_parse (proc->magics); }
static void deserialize_exif_altitude (GstTagList * taglist, const gchar * gst_tag, const gchar * xmp_tag, const gchar * str, GSList ** pending_tags) { const gchar *altitude_str = NULL; const gchar *altituderef_str = NULL; gint frac_n; gint frac_d; gdouble value; GSList *entry; PendingXmpTag *ptag = NULL; /* find the other missing part */ if (strcmp (xmp_tag, "exif:GPSAltitude") == 0) { altitude_str = str; for (entry = *pending_tags; entry; entry = g_slist_next (entry)) { ptag = (PendingXmpTag *) entry->data; if (strcmp (ptag->xmp_tag->tag_name, "exif:GPSAltitudeRef") == 0) { altituderef_str = ptag->str; break; } } } else if (strcmp (xmp_tag, "exif:GPSAltitudeRef") == 0) { altituderef_str = str; for (entry = *pending_tags; entry; entry = g_slist_next (entry)) { ptag = (PendingXmpTag *) entry->data; if (strcmp (ptag->xmp_tag->tag_name, "exif:GPSAltitude") == 0) { altitude_str = ptag->str; break; } } } else { GST_WARNING ("Unexpected xmp tag %s", xmp_tag); return; } if (!altitude_str) { GST_WARNING ("Missing exif:GPSAltitude tag"); return; } if (!altituderef_str) { GST_WARNING ("Missing exif:GPSAltitudeRef tag"); return; } if (sscanf (altitude_str, "%d/%d", &frac_n, &frac_d) != 2) { GST_WARNING ("Failed to parse fraction: %s", altitude_str); return; } gst_util_fraction_to_double (frac_n, frac_d, &value); if (altituderef_str[0] == '0') { /* nop */ } else if (altituderef_str[0] == '1') { value *= -1; } else { GST_WARNING ("Unexpected exif:AltitudeRef value: %s", altituderef_str); return; } /* add to the taglist */ gst_tag_list_add (taglist, GST_TAG_MERGE_REPLACE, GST_TAG_GEO_LOCATION_ELEVATION, value, NULL); /* clean up entry */ g_free (ptag->str); g_slice_free (PendingXmpTag, ptag); *pending_tags = g_slist_delete_link (*pending_tags, entry); }
void uim_cand_win_gtk_set_candidates(UIMCandWinGtk *cwin, guint display_limit, GSList *candidates) { gint i, nr_stores = 1; g_return_if_fail(UIM_IS_CAND_WIN_GTK(cwin)); if (cwin->stores == NULL) cwin->stores = g_ptr_array_new(); /* remove old data */ if (cwin->page_index >= 0 && cwin->page_index < (int) cwin->stores->len) { /* Remove data from current page to shrink the window */ if (cwin->stores->pdata[cwin->page_index]) gtk_list_store_clear(cwin->stores->pdata[cwin->page_index]); } for (i = cwin->stores->len - 1; i >= 0; i--) { GtkListStore *store = g_ptr_array_remove_index(cwin->stores, i); if (store) g_object_unref(G_OBJECT(store)); } cwin->candidate_index = -1; cwin->nr_candidates = g_slist_length(candidates); cwin->display_limit = display_limit; cwin->sub_window.active = FALSE; if (candidates == NULL) return; /* calculate number of GtkListStores to create */ if (display_limit) { nr_stores = cwin->nr_candidates / display_limit; if (cwin->nr_candidates > display_limit * nr_stores) nr_stores++; } /* create GtkListStores, and set candidates */ for (i = 0; i < nr_stores; i++) { GtkListStore *store = gtk_list_store_new(NR_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); GSList *node; guint j; g_ptr_array_add(cwin->stores, store); /* set candidates */ for (j = i * display_limit, node = g_slist_nth(candidates, j); display_limit ? j < display_limit * (i + 1) : j < cwin->nr_candidates; j++, node = g_slist_next(node)) { GtkTreeIter ti; if (node) { uim_candidate cand = node->data; gtk_list_store_append(store, &ti); gtk_list_store_set(store, &ti, COLUMN_HEADING, uim_candidate_get_heading_label(cand), COLUMN_CANDIDATE, uim_candidate_get_cand_str(cand), COLUMN_ANNOTATION, uim_candidate_get_annotation_str(cand), TERMINATOR); } else { #if 0 /* * 2004-07-22 Takuro Ashie <*****@*****.**> * * FIXME!: * I think we shoudn't set any data for empty row. * It may cause incorrect action. */ gtk_list_store_append(store, &ti); gtk_list_store_set(store, &ti, COLUMN_HEADING, "", COLUMN_CANDIDATE, "", COLUMN_ANNOTATION, NULL, TERMINATOR); #endif } } } if (cwin->nr_candidates <= cwin->display_limit) { gtk_widget_set_sensitive(GTK_WIDGET(cwin->prev_page_button), FALSE); gtk_widget_set_sensitive(GTK_WIDGET(cwin->next_page_button), FALSE); } else { gtk_widget_set_sensitive(GTK_WIDGET(cwin->prev_page_button), TRUE); gtk_widget_set_sensitive(GTK_WIDGET(cwin->next_page_button), TRUE); } uim_cand_win_gtk_set_page(cwin, 0); uim_cand_win_gtk_update_label(cwin); }
static void deserialize_exif_gps_direction (GstTagList * taglist, const gchar * gst_tag, const gchar * xmp_tag, const gchar * str, GSList ** pending_tags, const gchar * direction_tag, const gchar * directionref_tag) { const gchar *dir_str = NULL; const gchar *dirref_str = NULL; gint frac_n; gint frac_d; gdouble value; GSList *entry; PendingXmpTag *ptag = NULL; /* find the other missing part */ if (strcmp (xmp_tag, direction_tag) == 0) { dir_str = str; for (entry = *pending_tags; entry; entry = g_slist_next (entry)) { ptag = (PendingXmpTag *) entry->data; if (strcmp (ptag->xmp_tag->tag_name, directionref_tag) == 0) { dirref_str = ptag->str; break; } } } else if (strcmp (xmp_tag, directionref_tag) == 0) { dirref_str = str; for (entry = *pending_tags; entry; entry = g_slist_next (entry)) { ptag = (PendingXmpTag *) entry->data; if (strcmp (ptag->xmp_tag->tag_name, direction_tag) == 0) { dir_str = ptag->str; break; } } } else { GST_WARNING ("Unexpected xmp tag %s", xmp_tag); return; } if (!dir_str) { GST_WARNING ("Missing %s tag", dir_str); return; } if (!dirref_str) { GST_WARNING ("Missing %s tag", dirref_str); return; } if (sscanf (dir_str, "%d/%d", &frac_n, &frac_d) != 2) { GST_WARNING ("Failed to parse fraction: %s", dir_str); return; } gst_util_fraction_to_double (frac_n, frac_d, &value); if (dirref_str[0] == 'T') { /* nop */ } else if (dirref_str[0] == 'M') { GST_WARNING ("Magnetic direction tags aren't supported yet"); return; } else { GST_WARNING ("Unexpected %s value: %s", directionref_tag, dirref_str); return; } /* add to the taglist */ gst_tag_list_add (taglist, GST_TAG_MERGE_REPLACE, gst_tag, value, NULL); /* clean up entry */ g_free (ptag->str); g_slice_free (PendingXmpTag, ptag); *pending_tags = g_slist_delete_link (*pending_tags, entry); }
gint write_diffax(gchar *filename, struct model_pak *data) { gint i, j, n, tot_layer; gdouble pr, x[3]; GSList *list1, *list2; struct layer_pak *layer; struct core_pak *core; struct elem_pak elem; FILE *fp; printf("write_diffax()\n"); /* checks */ g_return_val_if_fail(data != NULL, 1); g_return_val_if_fail(filename != NULL, 2); /* open the file */ fp = fopen(filename,"wt"); if (!fp) return(3); /* setup the layers */ #ifdef WITH_GUI diffract_layer_setup(data); #endif tot_layer = g_slist_length(data->layer_list); if (!tot_layer) { printf("No layers to write.\n"); return(0); } /* output */ fprintf(fp, "\n"); fprintf(fp, "INSTRUMENTAL\nX-RAY\n1.5418\n"); fprintf(fp, "GAUSSIAN 0.4\n\n"); fprintf(fp, "STRUCTURAL\n%11.6f %11.6f %11.6f %11.6f\nUNKNOWN\n%d\ninfinite\n\n", data->pbc[0], data->pbc[1], data->pbc[2]/tot_layer, R2D*data->pbc[5], tot_layer); /* write out the layers */ i=1; for (list1=data->layer_list ; list1 ; list1=g_slist_next(list1)) { fprintf(fp, "\nLAYER %d\nnone\n", i); /* write out the atoms within the layer */ n=1; layer = (struct layer_pak *) list1->data; for (list2=layer->cores ; list2 ; list2=g_slist_next(list2)) { core = (struct core_pak *) list2->data; if (core->status & DELETED) continue; ARR3SET(x, core->x); /* center layer on origin */ x[2] -= layer->centroid[2]; /* scale up to 0.0-1.0 range */ x[2] *= tot_layer; /* move centroid to middle of the layer */ x[2] += 0.5; get_elem_data(core->atom_code, &elem, NULL); fprintf(fp, "%4s %4d %11.6f %11.6f %11.6f 1.0 %8.6f\n", elem.symbol, n, x[0], x[1], x[2], core->sof); n++; } i++; } fprintf(fp, "\nSTACKING\nrecursive\ninfinite\n\n"); fprintf(fp, "TRANSITIONS\n"); /* omit region 0 - temporary impl for the later method where */ /* the desired layers will be in a linked list, rather than */ /* all 1..max regions included */ for (i=1 ; i<=tot_layer ; i++) { fprintf(fp, "\n"); /* uniform probability & no xlat */ pr = 1.0 / (gdouble) tot_layer; for (j=1 ; j<=tot_layer ; j++) fprintf(fp, "%8.6f 0.0 0.0 1.0 {layer %d-%d}\n",pr,i,j); } fclose(fp); return(0); }
void pixmap_save_cb(GtkWidget *w, gpointer pixmap_ptr _U_) { GtkWidget *save_as_w; #if GTK_CHECK_VERSION(2,22,0) surface_info_t *surface_info = (surface_info_t *)g_object_get_data(G_OBJECT(w), "surface-info"); #else GdkPixmap *pixmap = (GdkPixmap *)g_object_get_data(G_OBJECT(w), "pixmap"); #endif GdkPixbuf *pixbuf; GdkPixbufFormat *pixbuf_format; GtkWidget *main_vb, *save_as_type_hb, *type_lb, *type_cm; GSList *file_formats,*ffp; GdkWindow *parent; gchar *format_name; guint format_index = 0; guint default_index = 0; gchar *filename, *file_type; GError *error = NULL; gboolean ret; GtkWidget *msg_dialog; #if GTK_CHECK_VERSION(2,22,0) pixbuf = gdk_pixbuf_get_from_surface (surface_info->surface, 0, 0, surface_info->width, surface_info->height); #else pixbuf = gdk_pixbuf_get_from_drawable(NULL, pixmap, NULL, 0, 0, 0, 0, -1, -1); #endif if(!pixbuf) { simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%sCould not get image from graph%s", simple_dialog_primary_start(), simple_dialog_primary_end()); return; } save_as_w = file_selection_new("Wireshark: Save Graph As ...", FILE_SELECTION_SAVE); gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(save_as_w), TRUE); /* Container for each row of widgets */ main_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 0, FALSE); file_selection_set_extra_widget(save_as_w, main_vb); gtk_widget_show(main_vb); save_as_type_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0, FALSE); gtk_box_pack_start(GTK_BOX(main_vb), save_as_type_hb, FALSE, FALSE, 0); gtk_widget_show(save_as_type_hb); type_lb = gtk_label_new("File type: "); gtk_box_pack_start(GTK_BOX(save_as_type_hb), type_lb, FALSE, FALSE, 0); gtk_widget_show(type_lb); type_cm = gtk_combo_box_text_new(); gtk_box_pack_start(GTK_BOX(save_as_type_hb), type_cm, FALSE, FALSE, 0); /* List all of the file formats the gdk-pixbuf library supports */ file_formats = gdk_pixbuf_get_formats(); ffp = file_formats; while(ffp) { pixbuf_format = (GdkPixbufFormat *)ffp->data; if (gdk_pixbuf_format_is_writable(pixbuf_format)) { format_name = gdk_pixbuf_format_get_name(pixbuf_format); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(type_cm), format_name); if (!(g_ascii_strcasecmp(format_name, "png"))) default_index = format_index; format_index++; } ffp = g_slist_next(ffp); } g_slist_free(file_formats); gtk_combo_box_set_active(GTK_COMBO_BOX(type_cm), default_index); gtk_widget_show(type_cm); gtk_widget_show(save_as_w); window_present(save_as_w); parent = gtk_widget_get_parent_window(w); gdk_window_set_transient_for(gtk_widget_get_window(save_as_w), parent); /* * Loop until the user either selects a file or gives up. */ for (;;) { if (gtk_dialog_run(GTK_DIALOG(save_as_w)) != GTK_RESPONSE_ACCEPT) { /* They clicked "Cancel" or closed the dialog or.... */ window_destroy(save_as_w); return; } filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(save_as_w)); /* Perhaps the user specified a directory instead of a file. Check whether they did. */ if (test_for_directory(filename) == EISDIR) { /* It's a directory - set the file selection box to display that directory, and leave the selection box displayed. */ set_last_open_dir(filename); g_free(filename); file_selection_set_current_folder(save_as_w, get_last_open_dir()); gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(save_as_w), ""); continue; } file_type = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(type_cm)); ret = gdk_pixbuf_save(pixbuf, filename, file_type, &error, NULL); g_free(filename); g_free(file_type); if (!ret) { msg_dialog = gtk_message_dialog_new(GTK_WINDOW(save_as_w), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "%s", error->message); gtk_dialog_run(GTK_DIALOG(msg_dialog)); gtk_widget_destroy(msg_dialog); continue; } window_destroy(save_as_w); return; } }
gint read_diffax(gchar *filename, struct model_pak *model) { gint num_tokens, num_layer, tot_layer; gdouble offset; gchar **buff; GSList *list1, *list2; struct core_pak *core; struct layer_pak *layer; FILE *fp; /* checks */ g_return_val_if_fail(model != NULL, 1); g_return_val_if_fail(filename != NULL, 2); fp = fopen(filename, "rt"); if (!fp) return(3); /* setup */ model->id = DIFFAX_INP; model->fractional = TRUE; model->periodic = 3; model->colour_scheme = REGION; strcpy(model->filename, filename); g_free(model->basename); model->basename = parse_strip(filename); /* scan the file */ while ((buff = get_tokenized_line(fp, &num_tokens))) { diffax_keyword_search:; /* restricted unit cell */ if (g_ascii_strncasecmp("structural", *buff, 10) == 0) { g_strfreev(buff); buff = get_tokenized_line(fp, &num_tokens); if (num_tokens > 3) { model->pbc[0] = str_to_float(*(buff+0)); model->pbc[1] = str_to_float(*(buff+1)); model->pbc[2] = str_to_float(*(buff+2)); model->pbc[3] = PI/2.0; model->pbc[4] = PI/2.0; model->pbc[5] = D2R*str_to_float(*(buff+3)); } } /* layer testing */ if (g_ascii_strncasecmp("layer", *buff, 5) == 0) { layer = g_malloc(sizeof(struct model_pak)); layer->width = 1.0; VEC3SET(layer->centroid, 0.5, 0.5, 0.5); layer->cores = NULL; model->layer_list = g_slist_prepend(model->layer_list, layer); g_strfreev(buff); buff = get_tokenized_line(fp, &num_tokens); if (buff) { /* TODO - if centrosymmetric : add a -1 operation */ } /* get layer data */ g_strfreev(buff); buff = get_tokenized_line(fp, &num_tokens); while (buff) { if (elem_symbol_test(*buff)) { if (num_tokens > 6) { /* printf("[%s] [%s %s %s]\n", *buff, *(buff+2), *(buff+3), *(buff+4)); */ core = new_core(*buff, model); model->cores = g_slist_prepend(model->cores, core); layer->cores = g_slist_prepend(layer->cores, core); core->x[0] = str_to_float(*(buff+2)); core->x[1] = str_to_float(*(buff+3)); core->x[2] = str_to_float(*(buff+4)); core->sof = str_to_float(*(buff+5)); } } else goto diffax_keyword_search; /* get next line of tokens */ g_strfreev(buff); buff = get_tokenized_line(fp, &num_tokens); } } g_strfreev(buff); } /* TODO - enumerate layers and scale, so they are stacked 1..n in a single cell */ /* also label the layers as different region types */ model->layer_list = g_slist_reverse(model->layer_list); num_layer = 0; tot_layer = g_slist_length(model->layer_list); model->pbc[2] *= tot_layer; #if DEBUG_READ_DIFFAX printf("Read in %d layers.\n", tot_layer); #endif for (list1=model->layer_list ; list1 ; list1=g_slist_next(list1)) { layer = (struct layer_pak *) list1->data; layer->width = 1.0 / (gdouble) tot_layer; offset = (gdouble) num_layer * layer->width; VEC3SET(layer->centroid, 0.0, 0.0, offset); for (list2=layer->cores ; list2 ; list2=g_slist_next(list2)) { core = (struct core_pak *) list2->data; /* scale to within the big cell (encloses all DIFFAX layers) */ core->x[2] *= layer->width; /* offset each particular layer */ core->x[2] += offset; core->region = num_layer; } num_layer++; } /* end of read */ fclose(fp); /* post read setup */ model->cores = g_slist_reverse(model->cores); model_prep(model); return(0); }
xmpp_stanza_t* form_create_submission(DataForm *form) { xmpp_ctx_t *ctx = connection_get_ctx(); xmpp_stanza_t *x = xmpp_stanza_new(ctx); xmpp_stanza_set_name(x, STANZA_NAME_X); xmpp_stanza_set_ns(x, STANZA_NS_DATA); xmpp_stanza_set_type(x, "submit"); GSList *curr_field = form->fields; while (curr_field) { FormField *field = curr_field->data; if (field->type_t != FIELD_FIXED) { xmpp_stanza_t *field_stanza = xmpp_stanza_new(ctx); xmpp_stanza_set_name(field_stanza, "field"); xmpp_stanza_set_attribute(field_stanza, "var", field->var); xmpp_stanza_t *value_stanza = NULL; GSList *curr_value = NULL; switch (field->type_t) { case FIELD_HIDDEN: case FIELD_TEXT_SINGLE: case FIELD_TEXT_PRIVATE: case FIELD_BOOLEAN: case FIELD_LIST_SINGLE: case FIELD_JID_SINGLE: value_stanza = xmpp_stanza_new(ctx); xmpp_stanza_set_name(value_stanza, "value"); if (field->values) { if (field->values->data) { xmpp_stanza_t *text_stanza = xmpp_stanza_new(ctx); xmpp_stanza_set_text(text_stanza, field->values->data); xmpp_stanza_add_child(value_stanza, text_stanza); xmpp_stanza_release(text_stanza); } } xmpp_stanza_add_child(field_stanza, value_stanza); xmpp_stanza_release(value_stanza); break; case FIELD_TEXT_MULTI: case FIELD_LIST_MULTI: case FIELD_JID_MULTI: curr_value = field->values; while (curr_value) { char *value = curr_value->data; value_stanza = xmpp_stanza_new(ctx); xmpp_stanza_set_name(value_stanza, "value"); if (value) { xmpp_stanza_t *text_stanza = xmpp_stanza_new(ctx); xmpp_stanza_set_text(text_stanza, value); xmpp_stanza_add_child(value_stanza, text_stanza); xmpp_stanza_release(text_stanza); } xmpp_stanza_add_child(field_stanza, value_stanza); xmpp_stanza_release(value_stanza); curr_value = g_slist_next(curr_value); } break; case FIELD_FIXED: default: break; } xmpp_stanza_add_child(x, field_stanza); xmpp_stanza_release(field_stanza); } curr_field = g_slist_next(curr_field); } return x; }
static void a2dp_discovery_complete(struct avdtp *session, GSList *seps, struct avdtp_error *err, void *user_data) { struct unix_client *client = user_data; char buf[BT_SUGGESTED_BUFFER_SIZE]; struct bt_get_capabilities_rsp *rsp = (void *) buf; struct a2dp_data *a2dp = &client->d.a2dp; GSList *l; if (!g_slist_find(clients, client)) { debug("Client disconnected during discovery"); return; } if (err) goto failed; memset(buf, 0, sizeof(buf)); client->req_id = 0; rsp->h.type = BT_RESPONSE; rsp->h.name = BT_GET_CAPABILITIES; rsp->h.length = sizeof(*rsp); ba2str(&client->dev->src, rsp->source); ba2str(&client->dev->dst, rsp->destination); strncpy(rsp->object, client->dev->path, sizeof(rsp->object)); for (l = seps; l; l = g_slist_next(l)) { struct avdtp_remote_sep *rsep = l->data; struct a2dp_sep *sep; struct avdtp_service_capability *cap; struct avdtp_stream *stream; uint8_t type, seid, configured = 0, lock = 0; GSList *cl; type = avdtp_get_type(rsep); if (type != AVDTP_SEP_TYPE_SINK) continue; cap = avdtp_get_codec(rsep); if (cap->category != AVDTP_MEDIA_CODEC) continue; seid = avdtp_get_seid(rsep); if (client->seid != 0 && client->seid != seid) continue; stream = avdtp_get_stream(rsep); if (stream) { configured = 1; if (client->seid == seid) cap = avdtp_stream_get_codec(stream); } for (cl = clients; cl; cl = cl->next) { struct unix_client *c = cl->data; struct a2dp_data *ca2dp = &c->d.a2dp; if (ca2dp && ca2dp->session == session && c->seid == seid) { lock = c->lock; break; } } sep = a2dp_get_sep(session, stream); if (sep && a2dp_sep_get_lock(sep)) lock = BT_WRITE_LOCK; a2dp_append_codec(rsp, cap, seid, configured, lock); } unix_ipc_sendmsg(client, &rsp->h); return; failed: error("discovery failed"); unix_ipc_error(client, BT_GET_CAPABILITIES, EIO); if (a2dp->sep) { a2dp_sep_unlock(a2dp->sep, a2dp->session); a2dp->sep = NULL; } avdtp_unref(a2dp->session); a2dp->session = NULL; a2dp->stream = NULL; }
void gimp_text_buffer_insert (GimpTextBuffer *buffer, const gchar *text) { GtkTextIter iter, start; gint start_offset; gboolean insert_tags_set; GList *insert_tags; GList *remove_tags; GSList *tags_off = NULL; g_return_if_fail (GIMP_IS_TEXT_BUFFER (buffer)); gtk_text_buffer_get_iter_at_mark (GTK_TEXT_BUFFER (buffer), &iter, gtk_text_buffer_get_insert (GTK_TEXT_BUFFER (buffer))); start_offset = gtk_text_iter_get_offset (&iter); insert_tags_set = buffer->insert_tags_set; insert_tags = buffer->insert_tags; remove_tags = buffer->remove_tags; buffer->insert_tags_set = FALSE; buffer->insert_tags = NULL; buffer->remove_tags = NULL; tags_off = gtk_text_iter_get_toggled_tags (&iter, FALSE); gtk_text_buffer_begin_user_action (GTK_TEXT_BUFFER (buffer)); gtk_text_buffer_insert (GTK_TEXT_BUFFER (buffer), &iter, text, -1); gtk_text_buffer_get_iter_at_offset (GTK_TEXT_BUFFER (buffer), &start, start_offset); if (insert_tags_set) { GList *list; for (list = remove_tags; list; list = g_list_next (list)) { GtkTextTag *tag = list->data; gtk_text_buffer_remove_tag (GTK_TEXT_BUFFER (buffer), tag, &start, &iter); } for (list = insert_tags; list; list = g_list_next (list)) { GtkTextTag *tag = list->data; gtk_text_buffer_apply_tag (GTK_TEXT_BUFFER (buffer), tag, &start, &iter); } } if (tags_off) { GSList *slist; for (slist = tags_off; slist; slist = g_slist_next (slist)) { GtkTextTag *tag = slist->data; if (! g_list_find (remove_tags, tag) && ! g_list_find (buffer->kerning_tags, tag)) { gtk_text_buffer_apply_tag (GTK_TEXT_BUFFER (buffer), tag, &start, &iter); } } g_slist_free (tags_off); } g_list_free (remove_tags); g_list_free (insert_tags); gtk_text_buffer_end_user_action (GTK_TEXT_BUFFER (buffer)); }
// NOTE: when loading a file, you have to allocate one extra byte and set it to \0 int vfsLoadFile( const char *filename, void **bufferptr, int index ){ int i, count = 0; char tmp[NAME_MAX], fixed[NAME_MAX]; GSList *lst; *bufferptr = NULL; strcpy( fixed, filename ); vfsFixDOSName( fixed ); g_strdown( fixed ); for ( i = 0; i < g_numDirs; i++ ) { strcpy( tmp, g_strDirs[i] ); strcat( tmp, filename ); if ( access( tmp, R_OK ) == 0 ) { if ( count == index ) { return vfsLoadFullPathFile( tmp,bufferptr ); /* long len; FILE *f; f = fopen (tmp, "rb"); if (f == NULL) return -1; fseek (f, 0, SEEK_END); len = ftell (f); rewind (f); *bufferptr = g_malloc (len+1); if (*bufferptr == NULL) return -1; fread (*bufferptr, 1, len, f); fclose (f); // we need to end the buffer with a 0 ((char*) (*bufferptr))[len] = 0; return len; */ } count++; } } // Textures in HalfLife wads don't have paths, but in the list of files // we store the actual full paths of the files and what WAD they're in. // so what we have to do is strip the paths and just compare filenames. // Hydra: well, we did do this, but now we don't, as the map loader now // fills in the correct paths for each texture. /* char *searchname; char *fixedptr; fixedptr = fixed; for (i = strlen(fixed)-1 ; i >= 0 && fixed[i] != '\\' && fixed[i] != '/' ; i --) fixedptr = (char *)fixed + i; */ for ( lst = g_pakFiles; lst != NULL; lst = g_slist_next( lst ) ) { VFS_PAKFILE* file = (VFS_PAKFILE*)lst->data; /* searchname = file->name; for (i = strlen(file->name)-1 ; i >= 0 && file->name[i] != '\\' && file->name[i] != '/' ; i --) searchname = (char *)file->name + i; if (strcmp (searchname, fixedptr) != 0) continue; */ if ( strcmp( file->name, fixed ) != 0 ) { continue; } if ( count == index ) { // Useful for debugging //Sys_Printf("VFSWAD: reading from %s\n",file->wadfile->wadfilename); if ( wadOpenCurrentFileByNum( file->wadfile, file->filenumber ) != 1 ) { return -1; } *bufferptr = g_malloc( file->size + 1 ); // we need to end the buffer with a 0 ( (char*) ( *bufferptr ) )[file->size] = 0; i = wadReadCurrentFile( file->wadfile, (char *)*bufferptr, file->size ); wadCloseCurrentFile( file->wadfile ); if ( i > 0 ) { return file->size; } else{ return -1; } } count++; } return -1; }