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;
}
