« back to all changes in this revision
Viewing changes to minimize.c
- browse files at revision 3
- compare with another revision
- download diff
- download tarball
- view history from revision 3
- Committer: Bazaar Package Importer
- Author(s): Noèl Köthe
- Date: 2004-09-13 23:44:50 UTC
- mfrom: (1.2.1 upstream) (2.1.1 warty)
- Revision ID: james.westby@ubuntu.com-20040913234450-wwdqtqfx9k38qhif
Tags: 0.86-1
new upstream release from 2004-08-26
- files added:
- analysis.c
- files removed:
- INSTALL
- files modified:
- CHANGELOG
added
removed
minimize.c
1
/*
2
Copyright (C) 2000 by Sean David Fleming
3
4
sean@power.curtin.edu.au
5
6
This program is free software; you can redistribute it and/or
7
modify it under the terms of the GNU General Public License
8
as published by the Free Software Foundation; either version 2
9
of the License, or (at your option) any later version.
10
11
This program is distributed in the hope that it will be useful,
12
but WITHOUT ANY WARRANTY; without even the implied warranty of
13
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14
GNU General Public License for more details.
15
16
You should have received a copy of the GNU General Public License
17
along with this program; if not, write to the Free Software
18
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19
20
The GNU GPL can also be found at http://www.gnu.org
21
*/
22
23
#include "config.h"
24
#include <fcntl.h>
25
#include <math.h>
26
#include <stdio.h>
27
#include <stdlib.h>
28
#include <string.h>
29
#include <unistd.h>
30
#include <sys/stat.h>
31
32
#include "gdis.h"
33
34
extern struct sysenv_pak sysenv;
35
extern struct elem_pak elements[];
36
37
/***************************************************/
38
/* get single point energy from a GULP output file */
39
/***************************************************/
40
#define DEBUG_READ_GULP 0
41
gint read_single_gulp(gchar *file, struct model_pak *data)
42
{
43
gchar line[LINELEN], **buff;
44
FILE *fp;
45
46
/* open & scan gulp output file */
47
fp = fopen(file,"rt");
48
if (!fp)
49
{
50
printf("No output file found!\n");
51
return(1);
52
}
53
54
/* look for last (eV) energy output */
55
while(!fgetline(fp,line))
56
{
57
buff = get_tokens(line, 10);
58
59
/* search for energy */
60
if (g_strncasecmp(" Total lattice energy",line,22) == 0)
61
{
62
/* if nothing on the rest of this line, then should be on the next */
63
if (!strlen(*(buff+5)))
64
{
65
while(!fgetline(fp,line))
66
if (g_strncasecmp(" Primitive unit cell",line,20) == 0)
67
break;
68
g_strfreev(buff);
69
buff = get_tokens(line, 6);
70
}
71
72
if (g_strncasecmp("eV",*(buff+5),2) == 0)
73
sscanf(*(buff+4),"%f",&data->gulp.energy);
74
}
75
76
/* search for free energy */
77
if (g_strncasecmp(" Total free energy",line,19) == 0)
78
{
79
if (g_strncasecmp("eV",*(buff+5),2) == 0)
80
sscanf(*(buff+4),"%f",&data->gulp.energy);
81
}
82
83
/* search for surface energy */
84
if (g_strncasecmp(" Surface energy ",line,17) == 0)
85
{
86
sscanf(*(buff+5),"%f",&data->gulp.esurf);
87
g_free(data->gulp.esurf_units);
88
data->gulp.esurf_units = g_strdup(*(buff+6));
89
}
90
91
/* search for attachment energy */
92
if (g_strncasecmp(" Attachment energy",line,19) == 0)
93
{
94
data->gulp.eatt = str_to_float(*(buff+3));
95
g_free(data->gulp.eatt_units);
96
data->gulp.eatt_units = g_strdup(*(buff+4));
97
}
98
99
if (g_strncasecmp(" Attachment energy/molecule",line,28) == 0)
100
{
101
data->gulp.eatt = str_to_float(*(buff+3));
102
g_free(data->gulp.eatt_units);
103
data->gulp.eatt_units = g_strdup("eV/mol");
104
}
105
106
/* dipole moment */
107
if (g_strncasecmp(" Initial surface dipole ",line,25) == 0)
108
sscanf(*(buff+4),"%f",&data->gulp.sdipole);
109
110
g_strfreev(buff);
111
}
112
/* done */
113
g_snprintf(line,35,"Single point Energy: %10.4f eV\n", data->gulp.energy);
114
show_text(line);
115
return(0);
116
}
117
118
/**********************************************/
119
/* get updated coords from a GULP output file */
120
/**********************************************/
121
gint read_minimize_gulp(gchar *file, struct model_pak *data)
122
{
123
gint code, model;
124
gchar *tmp;
125
FILE *fp;
126
127
/* open & scan gulp output file */
128
fp = fopen(file,"rt");
129
if (!fp)
130
{
131
printf("No output file found!\n");
132
return(-1);
133
}
134
135
/* create new file instead of overwriting */
136
model = sysenv.num_models;
137
tmp = g_strdup_printf("%s_opti", g_strstrip(data->basename));
138
if ((code = load_gulp_output(fp, model, tmp)))
139
printf("Output file load failed, error code %d.\n",code);
140
else
141
{
142
/* this will trigger a pick_model() call */
143
tree_select(model);
144
}
145
146
/* done */
147
g_free(tmp);
148
fclose(fp);
149
return(model);
150
}
151
152
/*******************/
153
/* run a gulp file */
154
/*******************/
155
#define DEBUG_EXEC_GULP 0
156
gint exec_gulp(gchar *input, gchar *output)
157
{
158
GString *cmd;
159
160
/* stop gulp's renaming (if it exists already) */
161
unlink(output);
162
163
/* TODO - scan output to print updates */
164
/* build & execute command line */
165
cmd = g_string_new(NULL);
166
167
/* The SG's don't like the ampersand after the '>' */
168
/*
169
g_string_sprintf(cmd,"%s < %s >& %s",sysenv.gulp_exe,input,output);
170
*/
171
g_string_sprintf(cmd,"%s < %s > %s",sysenv.gulp_exe,input,output);
172
173
#if DEBUG_EXEC_GULP
174
printf("executing: [%s]\n",cmd->str);
175
#endif
176
177
my_system(cmd->str);
178
179
/*
180
unlink(input);
181
*/
182
183
/* done */
184
g_string_free(cmd, TRUE);
185
return(0);
186
}
187
188
/*****************************/
189
/* execute a gulp run (task) */
190
/*****************************/
191
#define DEBUG_EXEC_GULP_TASK 0
192
void exec_gulp_task(gpointer *ptr)
193
{
194
gint fi, fo;
195
gchar *inpfile, *outfile, *argv[2];
196
gchar **buff;
197
struct model_pak *data;
198
199
g_return_if_fail(ptr != NULL);
200
data = (struct model_pak *) ptr;
201
202
/* get input and output filenames */
203
/* TODO - can we put =, instead of malloc'ing? */
204
inpfile = g_strdup(data->gulp.temp_file);
205
206
/* TODO - put this in a routine */
207
buff = g_strsplit(data->gulp.temp_file, ".gin", 0);
208
/* copy first token as the base name */
209
outfile = g_malloc((5+strlen(*buff))*sizeof(gchar));
210
strcpy(outfile, *buff);
211
strcat(outfile, ".got");
212
g_strfreev(buff);
213
214
#if DEBUG_EXEC_GULP_TASK
215
printf("output file: %s\n", outfile);
216
#endif
217
218
/* create the input file */
219
write_gulp(inpfile, data);
220
221
/* redirect stdin */
222
fi = open(inpfile, O_RDONLY);
223
if (fi < 0)
224
{
225
printf("failed to open: %s\n", inpfile);
226
_exit;
227
}
228
close(0);
229
dup2(fi, 0);
230
close(fi);
231
/* redirect stdout */
232
/* NB: output file must have correct permissions if created */
233
fo = open(outfile, O_RDWR | O_CREAT, S_IREAD | S_IWRITE);
234
if (fo < 0)
235
{
236
printf("failed to open: %s\n", outfile);
237
_exit;
238
}
239
close(1);
240
dup2(fo, 1);
241
close(fo);
242
/* NEW - some machines (mac's) don't like empty argument lists */
243
argv[0] = "";
244
argv[1] = NULL;
245
/* run */
246
execvp(sysenv.gulp_exe, argv);
247
_exit;
248
}
249
250
/*****************************/
251
/* process a gulp run (task) */
252
/*****************************/
253
#define DEBUG_PROC_GULP 0
254
void proc_gulp_task(gpointer *ptr)
255
{
256
gint model;
257
GString *line;
258
struct model_pak *dest, *data;
259
260
/* TODO - model locking (moldel_ptr RO/RW etc) to prevent screw ups */
261
g_return_if_fail(ptr != NULL);
262
data = (struct model_pak *) ptr;
263
264
/* TODO - make it possile to get dialog data by request */
265
/* so that we can check if a dialog exsits to be updated */
266
267
/* get new coords */
268
if (data->gulp.run == E_OPTIMIZE)
269
{
270
/* NEW - if minimize, we deal with the newly created model */
271
model = read_minimize_gulp(data->gulp.out_file, data);
272
dest = model_ptr(model, RECALL);
273
if (dest)
274
{
275
/* transfer data to new model */
276
copy_gulp_data(data, dest);
277
copy_gulp_extra(data, dest);
278
copy_elem_data(data, dest);
279
/* update coords etc - INIT's */
280
init_objs(REDO_COORDS, dest);
281
calc_bonds(dest);
282
calc_mols(dest);
283
redraw_canvas(ALL);
284
}
285
}
286
else
287
{
288
/* same model (ie with current energetics dialog) so update */
289
read_single_gulp(data->gulp.out_file, data);
290
/* update energy (TODO - only if successful) */
291
line = g_string_new(NULL);
292
if (data->gulp.free)
293
g_string_sprintf(line,"%f (free energy)",data->gulp.energy);
294
else
295
g_string_sprintf(line,"%f",data->gulp.energy);
296
297
/* is there a dialog entry to be updated? */
298
if (GTK_IS_ENTRY(data->gulp.energy_entry))
299
gtk_entry_set_text(GTK_ENTRY(data->gulp.energy_entry), line->str);
300
if (data->periodic == 2)
301
{
302
/* update surface energy dialog entry */
303
g_string_sprintf(line,"%f %s",data->gulp.esurf, data->gulp.esurf_units);
304
if (GTK_IS_ENTRY(data->gulp.esurf_entry))
305
gtk_entry_set_text(GTK_ENTRY(data->gulp.esurf_entry), line->str);
306
307
/* update attachment energy dialog entry */
308
g_string_sprintf(line,"%f %s",data->gulp.eatt, data->gulp.eatt_units);
309
if (GTK_IS_ENTRY(data->gulp.eatt_entry))
310
gtk_entry_set_text(GTK_ENTRY(data->gulp.eatt_entry), line->str);
311
}
312
g_string_free(line, TRUE);
313
}
314
315
/*
316
unlink(data->gulp.out_file);
317
*/
318
319
return;
320
}
321
322
/***********************************************/
323
/* controls the use of GULP to optimise coords */
324
/***********************************************/
325
#define DEBUG_RUN_GULP 0
326
void run_gulp(gint id)
327
{
328
gint model;
329
gchar **buff;
330
struct model_pak *data;
331
struct task_pak task;
332
333
if (!sysenv.have_gulp)
334
{
335
show_text("Sorry, gulp executable was not found.");
336
return;
337
}
338
339
/* get model attached to dialog id */
340
model = sysenv.dialog[id].model;
341
data = model_ptr(model, RECALL);
342
g_return_if_fail(data != NULL);
343
344
/* create input file to execute */
345
write_gulp(data->gulp.temp_file, data);
346
347
/* set up output file to use */
348
g_free(data->gulp.out_file);
349
350
/* TODO - put this in a routine */
351
buff = g_strsplit(data->gulp.temp_file, ".gin", 0);
352
/* copy first token as the base name */
353
data->gulp.out_file = g_malloc((5+strlen(*buff))*sizeof(gchar));
354
strcpy(data->gulp.out_file, *buff);
355
strcat(data->gulp.out_file, ".got");
356
g_strfreev(buff);
357
358
#if DEBUG_RUN_GULP
359
printf("output file: %s\n", data->gulp.out_file);
360
#endif
361
362
show_text("Running GULP in the background.");
363
364
/* run as a background process */
365
task.label = g_strdup("Gulp");
366
task.primary = &exec_gulp_task;
367
task.ptr1 = (gpointer *) data;
368
task.cleanup = &proc_gulp_task;
369
task.ptr2 = (gpointer *) data;
370
371
start_task(&task);
372
}
373
374
/***********************/
375
/* GULP keyword toggle */
376
/***********************/
377
gint gulp_keyword(GtkWidget *w, gpointer *obj)
378
{
379
gint keyword;
380
struct model_pak *data;
381
382
keyword = GPOINTER_TO_INT(gtk_object_get_data(GTK_OBJECT(obj), "key"));
383
384
data = (struct model_pak *) gtk_object_get_data(GTK_OBJECT(obj), "ptr");
385
g_return_val_if_fail(data != NULL, FALSE);
386
387
switch(keyword)
388
{
389
case E_SINGLE:
390
case E_OPTIMIZE:
391
case MD:
392
data->gulp.run = keyword;
393
break;
394
case NO_EATT:
395
data->gulp.no_eatt ^= 1;
396
break;
397
case NO_ESURF:
398
data->gulp.no_esurf ^= 1;
399
break;
400
case NVE:
401
case NVT:
402
case NPT:
403
if (data->gulp.run != MD)
404
{
405
show_text("I'm ignoring this as it's not a dynamics run type.");
406
return(TRUE);
407
}
408
else
409
show_text("");
410
data->gulp.ensemble = keyword;
411
break;
412
case CONP:
413
case CONV:
414
data->gulp.method = keyword;
415
break;
416
case BFGS_OPT:
417
case CONJ_OPT:
418
case RFO_OPT:
419
data->gulp.optimiser = keyword;
420
break;
421
case MOLE:
422
case MOLMEC:
423
case MOLQ:
424
case NOBUILD:
425
data->gulp.coulomb = keyword;
426
break;
427
case TEMPERATURE:
428
data->gulp.temp = (gfloat) GTK_ADJUSTMENT(obj)->value;
429
break;
430
case MAXCYC:
431
data->gulp.maxcyc = (gint) GTK_ADJUSTMENT(obj)->value;
432
break;
433
case TEMP_FILE:
434
g_free(data->gulp.temp_file);
435
data->gulp.temp_file = g_strdup(gtk_entry_get_text(GTK_ENTRY(obj)));
436
break;
437
case DUMP_FILE:
438
g_free(data->gulp.dump_file);
439
data->gulp.dump_file = g_strdup(gtk_entry_get_text(GTK_ENTRY(obj)));
440
break;
441
case LIB_FILE:
442
g_free(data->gulp.lib_file);
443
data->gulp.lib_file = g_strdup(gtk_entry_get_text(GTK_ENTRY(obj)));
444
break;
445
}
446
447
return(FALSE);
448
}
449
450
/***********************************/
451
/* register structure name changes */
452
/***********************************/
453
gint name_entry_changed(gpointer *entry)
454
{
455
struct model_pak *data;
456
457
/* retrieve the appropriate model */
458
data = (struct model_pak *) gtk_object_get_data(GTK_OBJECT(entry), "ptr");
459
g_return_val_if_fail(data != NULL, FALSE);
460
461
/* set the new basename */
462
g_free(data->basename);
463
data->basename = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry)));
464
465
/* update the model tree */
466
new_tree_item(data->number, REPLACE);
467
return(FALSE);
468
}
469
470
/*************************/
471
/* The GULP setup widget */
472
/*************************/
473
void gulp_widget(GtkWidget *w, struct model_pak *data)
474
{
475
gint id, model;
476
struct dialog_pak *gulp_dialog;
477
GtkWidget *main_hbox, *hbox, *vbox, *vbox1, *vbox2, *page;
478
GtkWidget *frame, *button, *label, *entry, *notebook;
479
GtkAdjustment *adj;
480
GSList *keyword[5];
481
GString *line;
482
483
/* do we have to do anything? */
484
g_return_if_fail(data != NULL);
485
486
/* NEW - default run setup is done by the template routine */
487
model = data->number;
488
if ((id = request_dialog(model, GULP)) < 0)
489
return;
490
gulp_dialog = &sysenv.dialog[id];
491
492
/* string manipulation scratchpad */
493
line = g_string_new(NULL);
494
495
/* NEW - setup some gulp file name defaults */
496
if (g_strncasecmp(data->gulp.temp_file, "none", 4) == 0)
497
{
498
/* FIXME - what if temp_file = filename? (may not want to overwrite) */
499
g_string_sprintf(line,"%s.gin",g_strstrip(data->basename));
500
g_free(data->gulp.temp_file);
501
data->gulp.temp_file = g_strdup(line->str);
502
}
503
if (g_strncasecmp(data->gulp.dump_file, "none", 4) == 0)
504
{
505
g_string_sprintf(line,"%s.res",g_strstrip(data->basename));
506
g_free(data->gulp.dump_file);
507
data->gulp.dump_file = g_strdup(line->str);
508
}
509
510
/* TODO - show model's name */
511
/* create a new dialogue */
512
gulp_dialog->win = gtk_dialog_new();
513
gtk_window_set_title (GTK_WINDOW(gulp_dialog->win), "GULP interface");
514
gtk_signal_connect(GTK_OBJECT(gulp_dialog->win), "destroy",
515
GTK_SIGNAL_FUNC(event_close_dialog), (gpointer) id);
516
517
main_hbox = gtk_hbox_new(TRUE,3);
518
gtk_container_add(GTK_CONTAINER(GTK_DIALOG(gulp_dialog->win)->vbox),main_hbox);
519
520
/* left vbox */
521
vbox1 = gtk_vbox_new(FALSE, 0);
522
gtk_box_pack_start (GTK_BOX(main_hbox), vbox1, TRUE, TRUE, 0);
523
524
/* frame 1 */
525
frame = gtk_frame_new("run type");
526
gtk_container_add(GTK_CONTAINER(GTK_BOX(vbox1)),frame);
527
gtk_container_set_border_width(GTK_CONTAINER(frame),3);
528
vbox = gtk_vbox_new(TRUE, 0);
529
gtk_container_add(GTK_CONTAINER(frame),vbox);
530
531
/* do the first (DEFAULT MODE) radio button */
532
button = gtk_radio_button_new_with_label(NULL, "single point");
533
gtk_box_pack_start(GTK_BOX (vbox), button, TRUE, TRUE, 0);
534
gtk_signal_connect_object(GTK_OBJECT (button), "clicked",
535
GTK_SIGNAL_FUNC (gulp_keyword),
536
(gpointer) button);
537
gtk_object_set_data(GTK_OBJECT(button), "key", (gpointer) E_SINGLE);
538
gtk_object_set_data(GTK_OBJECT(button), "ptr", (gpointer) data);
539
/* NEW */
540
if (data->gulp.run == E_SINGLE)
541
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);
542
543
/* make a radio group */
544
keyword[0] = gtk_radio_button_group(GTK_RADIO_BUTTON(button));
545
/* do the next button */
546
button = gtk_radio_button_new_with_label (keyword[0], "minimize");
547
gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
548
gtk_signal_connect_object(GTK_OBJECT (button), "clicked",
549
GTK_SIGNAL_FUNC (gulp_keyword),
550
(gpointer) button);
551
gtk_object_set_data(GTK_OBJECT(button), "key", (gpointer) E_OPTIMIZE);
552
gtk_object_set_data(GTK_OBJECT(button), "ptr", (gpointer) data);
553
/* NEW */
554
if (data->gulp.run == E_OPTIMIZE)
555
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);
556
557
/* subsequent button... */
558
button = gtk_radio_button_new_with_label(gtk_radio_button_group
559
(GTK_RADIO_BUTTON(button)), "dynamics");
560
gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
561
gtk_signal_connect_object(GTK_OBJECT (button), "clicked",
562
GTK_SIGNAL_FUNC (gulp_keyword),
563
(gpointer) button);
564
gtk_object_set_data(GTK_OBJECT(button), "key", (gpointer) MD);
565
gtk_object_set_data(GTK_OBJECT(button), "ptr", (gpointer) data);
566
/* NEW */
567
if (data->gulp.run == MD)
568
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);
569
570
571
572
573
574
575
/* NEW - notebook display for extended options */
576
frame = gtk_frame_new("Run options");
577
gtk_box_pack_start(GTK_BOX (vbox1), frame, FALSE, FALSE, 0);
578
gtk_container_set_border_width(GTK_CONTAINER(frame),3);
579
580
vbox = gtk_vbox_new(TRUE, 0);
581
gtk_container_add(GTK_CONTAINER(frame),vbox);
582
/*
583
gtk_container_set_border_width(GTK_CONTAINER(GTK_BOX(vbox)),1);
584
*/
585
586
/* create notebook */
587
notebook = gtk_notebook_new();
588
gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP);
589
/*
590
gtk_container_add(GTK_CONTAINER(frame),notebook);
591
*/
592
gtk_box_pack_start(GTK_BOX(vbox), notebook, TRUE, TRUE, 0);
593
594
gtk_notebook_set_show_border(GTK_NOTEBOOK(notebook), FALSE);
595
596
/* create minimize page */
597
page = gtk_vbox_new(FALSE,0);
598
gtk_container_set_border_width (GTK_CONTAINER(GTK_BOX(vbox)), 10);
599
600
/* minimize constraint */
601
frame = gtk_frame_new("method");
602
gtk_box_pack_start (GTK_BOX (page), frame, FALSE, FALSE, 0);
603
gtk_container_set_border_width(GTK_CONTAINER(frame),3);
604
vbox = gtk_vbox_new(TRUE, 0);
605
gtk_container_add(GTK_CONTAINER(frame),vbox);
606
607
/* do the first (DEFAULT MODE) radio button */
608
button = gtk_radio_button_new_with_label (NULL, "constant pressure");
609
gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
610
gtk_signal_connect_object(GTK_OBJECT (button), "clicked",
611
GTK_SIGNAL_FUNC (gulp_keyword),
612
(gpointer) button);
613
gtk_object_set_data(GTK_OBJECT(button), "key", (gpointer) CONP);
614
gtk_object_set_data(GTK_OBJECT(button), "ptr", (gpointer) data);
615
/* NEW */
616
if (data->gulp.method == CONP)
617
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);
618
619
/* make a radio group */
620
keyword[1] = gtk_radio_button_group (GTK_RADIO_BUTTON (button));
621
/* do the next button */
622
button = gtk_radio_button_new_with_label (keyword[1], "constant volume");
623
gtk_box_pack_start(GTK_BOX (vbox), button, TRUE, TRUE, 0);
624
gtk_signal_connect_object(GTK_OBJECT (button), "clicked",
625
GTK_SIGNAL_FUNC (gulp_keyword),
626
(gpointer) button);
627
gtk_object_set_data(GTK_OBJECT(button), "key", (gpointer) CONV);
628
gtk_object_set_data(GTK_OBJECT(button), "ptr", (gpointer) data);
629
/* NEW */
630
if (data->gulp.method == CONV)
631
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);
632
633
634
/* optimiser to use */
635
frame = gtk_frame_new("optimiser");
636
gtk_box_pack_start (GTK_BOX (page), frame, FALSE, FALSE, 0);
637
gtk_container_set_border_width(GTK_CONTAINER(frame),3);
638
vbox = gtk_vbox_new(TRUE, 0);
639
gtk_container_add(GTK_CONTAINER(frame),vbox);
640
641
/* do the first (DEFAULT MODE) radio button */
642
button = gtk_radio_button_new_with_label (NULL, "bfgs (default)");
643
gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
644
gtk_signal_connect_object(GTK_OBJECT (button), "clicked",
645
GTK_SIGNAL_FUNC (gulp_keyword),
646
(gpointer) button);
647
gtk_object_set_data(GTK_OBJECT(button), "key", (gpointer) BFGS_OPT);
648
gtk_object_set_data(GTK_OBJECT(button), "ptr", (gpointer) data);
649
/* NEW */
650
if (data->gulp.optimiser == BFGS_OPT || data->gulp.optimiser == -1)
651
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);
652
653
/* make a radio group */
654
keyword[1] = gtk_radio_button_group (GTK_RADIO_BUTTON (button));
655
/* do the next button */
656
button = gtk_radio_button_new_with_label (keyword[1], "conj");
657
gtk_box_pack_start(GTK_BOX (vbox), button, TRUE, TRUE, 0);
658
gtk_signal_connect_object(GTK_OBJECT (button), "clicked",
659
GTK_SIGNAL_FUNC (gulp_keyword),
660
(gpointer) button);
661
gtk_object_set_data(GTK_OBJECT(button), "key", (gpointer) CONJ_OPT);
662
gtk_object_set_data(GTK_OBJECT(button), "ptr", (gpointer) data);
663
/* NEW */
664
if (data->gulp.optimiser == CONJ_OPT)
665
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);
666
667
/* subsequent button... */
668
button = gtk_radio_button_new_with_label(gtk_radio_button_group
669
(GTK_RADIO_BUTTON (button)), "rfo");
670
gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
671
gtk_signal_connect_object(GTK_OBJECT (button), "clicked",
672
GTK_SIGNAL_FUNC (gulp_keyword),
673
(gpointer) button);
674
gtk_object_set_data(GTK_OBJECT(button), "key", (gpointer) RFO_OPT);
675
gtk_object_set_data(GTK_OBJECT(button), "ptr", (gpointer) data);
676
/* NEW */
677
if (data->gulp.optimiser == RFO_OPT)
678
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);
679
680
/* add the page & title */
681
label = gtk_label_new ("minimize");
682
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), page, label);
683
684
685
686
687
688
689
690
691
/* create dynamics page */
692
page = gtk_vbox_new(FALSE,0);
693
gtk_container_set_border_width (GTK_CONTAINER(GTK_BOX(vbox)), 10);
694
695
/* dynamics ensemble */
696
frame = gtk_frame_new("ensemble");
697
gtk_box_pack_start(GTK_BOX (page), frame, FALSE, FALSE, 0);
698
gtk_container_set_border_width(GTK_CONTAINER(frame),3);
699
vbox = gtk_vbox_new(TRUE, 0);
700
gtk_container_add(GTK_CONTAINER(frame),vbox);
701
702
/* do the first (DEFAULT MODE) radio button */
703
button = gtk_radio_button_new_with_label (NULL, "NVE");
704
gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
705
gtk_signal_connect_object(GTK_OBJECT (button), "clicked",
706
GTK_SIGNAL_FUNC (gulp_keyword),
707
(gpointer) button);
708
gtk_object_set_data(GTK_OBJECT(button), "key", (gpointer) NVE);
709
gtk_object_set_data(GTK_OBJECT(button), "ptr", (gpointer) data);
710
/* NEW */
711
if (data->gulp.ensemble == NVE)
712
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);
713
714
/* make a radio group */
715
keyword[1] = gtk_radio_button_group (GTK_RADIO_BUTTON (button));
716
/* do the next button */
717
button = gtk_radio_button_new_with_label (keyword[1], "NVT");
718
gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
719
gtk_signal_connect_object(GTK_OBJECT (button), "clicked",
720
GTK_SIGNAL_FUNC (gulp_keyword),
721
(gpointer) button);
722
gtk_object_set_data(GTK_OBJECT(button), "key", (gpointer) NVT);
723
gtk_object_set_data(GTK_OBJECT(button), "ptr", (gpointer) data);
724
/* NEW */
725
if (data->gulp.ensemble == NVT)
726
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);
727
728
/* subsequent button... */
729
button = gtk_radio_button_new_with_label(gtk_radio_button_group
730
(GTK_RADIO_BUTTON (button)), "NPT");
731
gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
732
gtk_signal_connect_object(GTK_OBJECT (button), "clicked",
733
GTK_SIGNAL_FUNC (gulp_keyword),
734
(gpointer) button);
735
gtk_object_set_data(GTK_OBJECT(button), "key", (gpointer) NPT);
736
gtk_object_set_data(GTK_OBJECT(button), "ptr", (gpointer) data);
737
/* NEW */
738
if (data->gulp.ensemble == NPT)
739
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);
740
741
/* TODO */
742
/* step size/run length, trajectory file etc. */
743
744
/* add the page & title */
745
label = gtk_label_new ("dynamics");
746
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), page, label);
747
748
749
/* create misc page */
750
page = gtk_vbox_new(FALSE,0);
751
gtk_container_set_border_width (GTK_CONTAINER(GTK_BOX(vbox)), 10);
752
753
/* dynamics ensemble */
754
frame = gtk_frame_new(NULL);
755
gtk_box_pack_start(GTK_BOX (page), frame, FALSE, FALSE, 0);
756
gtk_container_set_border_width(GTK_CONTAINER(frame),3);
757
vbox = gtk_vbox_new(TRUE, 0);
758
gtk_container_add(GTK_CONTAINER(frame),vbox);
759
760
if (data->periodic == 2)
761
{
762
button = gtk_check_button_new_with_label("No attachment energy calculation");
763
gtk_box_pack_start(GTK_BOX(vbox), button, TRUE, TRUE, 0);
764
gtk_signal_connect_object(GTK_OBJECT (button), "clicked",
765
GTK_SIGNAL_FUNC (gulp_keyword),
766
(gpointer) button);
767
gtk_object_set_data(GTK_OBJECT(button), "key", (gpointer) NO_EATT);
768
gtk_object_set_data(GTK_OBJECT(button), "ptr", (gpointer) data);
769
}
770
771
/* add the page & title */
772
label = gtk_label_new ("misc");
773
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), page, label);
774
775
776
/* starting page */
777
gtk_widget_show_all(notebook); /* needed in order to make this work */
778
if (data->gulp.run == MD)
779
gtk_notebook_set_page(GTK_NOTEBOOK(notebook), 1);
780
else
781
gtk_notebook_set_page(GTK_NOTEBOOK(notebook), 0);
782
783
784
/* right vbox */
785
vbox2 = gtk_vbox_new(FALSE, 0);
786
gtk_box_pack_start (GTK_BOX(main_hbox), vbox2, TRUE, TRUE, 0);
787
788
/* frame 3 */
789
frame = gtk_frame_new("Molecule options");
790
gtk_container_add(GTK_CONTAINER(GTK_BOX(vbox2)),frame);
791
gtk_container_set_border_width(GTK_CONTAINER(frame),3);
792
vbox = gtk_vbox_new(TRUE, 0);
793
gtk_container_add(GTK_CONTAINER(frame),vbox);
794
/* do the first radio button */
795
button = gtk_radio_button_new_with_label (NULL, "1-2 coulomb subtraction");
796
gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
797
gtk_signal_connect_object(GTK_OBJECT (button), "clicked",
798
GTK_SIGNAL_FUNC (gulp_keyword),
799
(gpointer) button);
800
gtk_object_set_data(GTK_OBJECT(button), "key", (gpointer) MOLE);
801
gtk_object_set_data(GTK_OBJECT(button), "ptr", (gpointer) data);
802
/* NEW */
803
if (data->gulp.coulomb == MOLE)
804
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);
805
806
/* make a radio group */
807
keyword[2] = gtk_radio_button_group (GTK_RADIO_BUTTON (button));
808
/* do the next button */
809
button = gtk_radio_button_new_with_label (keyword[2],
810
"1-2 and 1-3 coulomb subtraction");
811
gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
812
gtk_signal_connect_object(GTK_OBJECT (button), "clicked",
813
GTK_SIGNAL_FUNC (gulp_keyword),
814
(gpointer) button);
815
gtk_object_set_data(GTK_OBJECT(button), "key", (gpointer) MOLMEC);
816
gtk_object_set_data(GTK_OBJECT(button), "ptr", (gpointer) data);
817
/* NEW */
818
if (data->gulp.coulomb == MOLMEC)
819
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);
820
821
/* subsequent button... */
822
button = gtk_radio_button_new_with_label(gtk_radio_button_group
823
(GTK_RADIO_BUTTON (button)), "build, but retain coulomb interactions");
824
gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
825
gtk_signal_connect_object(GTK_OBJECT (button), "clicked",
826
GTK_SIGNAL_FUNC (gulp_keyword),
827
(gpointer) button);
828
gtk_object_set_data(GTK_OBJECT(button), "key", (gpointer) MOLQ);
829
gtk_object_set_data(GTK_OBJECT(button), "ptr", (gpointer) data);
830
/* NEW */
831
if (data->gulp.coulomb == MOLQ)
832
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);
833
834
/* subsequent button... */
835
button = gtk_radio_button_new_with_label(gtk_radio_button_group
836
(GTK_RADIO_BUTTON (button)), "molecule building off");
837
gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
838
gtk_signal_connect_object(GTK_OBJECT (button), "clicked",
839
GTK_SIGNAL_FUNC (gulp_keyword),
840
(gpointer) button);
841
gtk_object_set_data(GTK_OBJECT(button), "key", (gpointer) NOBUILD);
842
gtk_object_set_data(GTK_OBJECT(button), "ptr", (gpointer) data);
843
/* NEW */
844
if (data->gulp.coulomb == NOBUILD)
845
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);
846
847
848
849
/* frame */
850
frame = gtk_frame_new(NULL);
851
gtk_container_add(GTK_CONTAINER(GTK_BOX(vbox2)),frame);
852
gtk_container_set_border_width(GTK_CONTAINER(frame),3);
853
hbox = gtk_hbox_new(FALSE, 0);
854
gtk_container_add (GTK_CONTAINER(frame),hbox);
855
gtk_container_set_border_width(GTK_CONTAINER(hbox),3);
856
857
/* TODO - ability to edit (via another dialog) */
858
label = gtk_label_new(" Temperature ");
859
gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, FALSE, 0);
860
861
adj = (GtkAdjustment *) gtk_adjustment_new
862
(data->gulp.temp, 0, 500, 10, 10, 0);
863
button = gtk_spin_button_new(adj, 0, 0);
864
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(button), FALSE);
865
gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
866
gtk_signal_connect_object(GTK_OBJECT (adj), "value_changed",
867
GTK_SIGNAL_FUNC (gulp_keyword),
868
(gpointer) adj);
869
gtk_object_set_data(GTK_OBJECT(adj), "key", (gpointer) TEMPERATURE);
870
gtk_object_set_data(GTK_OBJECT(adj), "ptr", (gpointer) data);
871
872
873
/* frame */
874
frame = gtk_frame_new(NULL);
875
gtk_container_add(GTK_CONTAINER(GTK_BOX(vbox2)),frame);
876
gtk_container_set_border_width(GTK_CONTAINER(frame),3);
877
hbox = gtk_hbox_new(FALSE, 0);
878
gtk_container_add (GTK_CONTAINER(frame),hbox);
879
gtk_container_set_border_width(GTK_CONTAINER(hbox),3);
880
881
/* TODO - ability to edit (via another dialog) */
882
label = gtk_label_new(" Maximum cycles ");
883
gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, FALSE, 0);
884
885
adj = (GtkAdjustment *) gtk_adjustment_new
886
(data->gulp.maxcyc, 0, 500, 10, 10, 0);
887
button = gtk_spin_button_new(adj, 0, 0);
888
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(button), FALSE);
889
gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
890
gtk_signal_connect_object(GTK_OBJECT (adj), "value_changed",
891
GTK_SIGNAL_FUNC (gulp_keyword),
892
(gpointer) adj);
893
gtk_object_set_data(GTK_OBJECT(adj), "key", (gpointer) MAXCYC);
894
gtk_object_set_data(GTK_OBJECT(adj), "ptr", (gpointer) data);
895
896
/* setup the filename entry part */
897
frame = gtk_frame_new("Supplied data");
898
899
900
gtk_box_pack_start(GTK_BOX(vbox2),frame,FALSE,FALSE,0);
901
/*
902
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(gulp_dialog->win)->vbox),frame,FALSE,FALSE,0);
903
*/
904
gtk_container_set_border_width(GTK_CONTAINER(frame),3);
905
hbox = gtk_hbox_new(FALSE, 0);
906
gtk_container_add (GTK_CONTAINER(frame),hbox);
907
gtk_container_set_border_width(GTK_CONTAINER(hbox),3);
908
909
/* left vbox */
910
vbox = gtk_vbox_new(TRUE, 2);
911
gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);
912
913
/* GULP template data */
914
/* TODO - ability to edit (via another dialog) */
915
label = gtk_label_new("Potentials");
916
gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, FALSE, 0);
917
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.0f);
918
label = gtk_label_new("Species data");
919
gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, FALSE, 0);
920
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.0f);
921
label = gtk_label_new("Element data");
922
gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, FALSE, 0);
923
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.0f);
924
925
/* right vbox */
926
vbox = gtk_vbox_new(TRUE, 2);
927
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
928
929
g_string_sprintf(line,"%d",data->gulp.num_potentials);
930
label = gtk_label_new(line->str);
931
gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
932
g_string_sprintf(line,"%d",data->gulp.num_species);
933
label = gtk_label_new(line->str);
934
gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
935
g_string_sprintf(line,"%d",data->gulp.num_elem);
936
label = gtk_label_new(line->str);
937
gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
938
939
/* setup the filename entry */
940
frame = gtk_frame_new("Files");
941
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(gulp_dialog->win)->vbox),frame,FALSE,FALSE,0);
942
gtk_container_set_border_width(GTK_CONTAINER(frame),3);
943
hbox = gtk_hbox_new(FALSE, 0);
944
gtk_container_add (GTK_CONTAINER(frame),hbox);
945
gtk_container_set_border_width(GTK_CONTAINER(hbox),3);
946
947
/* left vbox */
948
vbox = gtk_vbox_new(TRUE, 2);
949
gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);
950
951
/* temporary GULP input filename */
952
label = gtk_label_new(" Job input file ");
953
gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
954
label = gtk_label_new(" Dump file ");
955
gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
956
label = gtk_label_new(" Potential library ");
957
gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
958
959
/* right vbox */
960
vbox = gtk_vbox_new(TRUE, 2);
961
gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);
962
963
/* temporary input */
964
entry = gtk_entry_new_with_max_length(LINELEN);
965
gtk_entry_set_text(GTK_ENTRY(entry), data->gulp.temp_file);
966
gtk_box_pack_start (GTK_BOX (vbox), entry, TRUE, TRUE, 0);
967
/* event */
968
gtk_signal_connect_object(GTK_OBJECT (entry), "changed",
969
GTK_SIGNAL_FUNC (gulp_keyword),
970
(gpointer) entry);
971
gtk_object_set_data(GTK_OBJECT(entry), "key", (gpointer) TEMP_FILE);
972
gtk_object_set_data(GTK_OBJECT(entry), "ptr", (gpointer) data);
973
974
/* dump file */
975
entry = gtk_entry_new_with_max_length(LINELEN);
976
gtk_entry_set_text(GTK_ENTRY(entry), data->gulp.dump_file);
977
gtk_box_pack_start (GTK_BOX (vbox), entry, TRUE, TRUE, 0);
978
/* event */
979
gtk_signal_connect_object(GTK_OBJECT (entry), "changed",
980
GTK_SIGNAL_FUNC (gulp_keyword),
981
(gpointer) entry);
982
gtk_object_set_data(GTK_OBJECT(entry), "key", (gpointer) DUMP_FILE);
983
gtk_object_set_data(GTK_OBJECT(entry), "ptr", (gpointer) data);
984
985
/* potential library */
986
entry = gtk_entry_new_with_max_length(LINELEN);
987
gtk_entry_set_text(GTK_ENTRY(entry),data->gulp.lib_file);
988
gtk_box_pack_start (GTK_BOX (vbox), entry, TRUE, TRUE, 0);
989
/* event */
990
gtk_signal_connect_object(GTK_OBJECT (entry), "changed",
991
GTK_SIGNAL_FUNC (gulp_keyword),
992
(gpointer) entry);
993
gtk_object_set_data(GTK_OBJECT(entry), "key", (gpointer) LIB_FILE);
994
gtk_object_set_data(GTK_OBJECT(entry), "ptr", (gpointer) data);
995
996
997
/* setup the filename entry */
998
frame = gtk_frame_new("Details");
999
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(gulp_dialog->win)->vbox),frame,FALSE,FALSE,0);
1000
gtk_container_set_border_width(GTK_CONTAINER(frame),3);
1001
hbox = gtk_hbox_new(FALSE, 0);
1002
gtk_container_add (GTK_CONTAINER(frame),hbox);
1003
1004
/* left vbox */
1005
vbox = gtk_vbox_new(TRUE, 2);
1006
gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);
1007
1008
/* temporary GULP input filename */
1009
label = gtk_label_new("Structure name");
1010
gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
1011
label = gtk_label_new("Lattice energy (eV)");
1012
gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
1013
if (data->periodic == 2)
1014
{
1015
label = gtk_label_new("Surface bulk energy (eV)");
1016
gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
1017
label = gtk_label_new("Surface energy");
1018
gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
1019
label = gtk_label_new("Attachment energy");
1020
gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 0);
1021
}
1022
1023
/* right vbox */
1024
vbox = gtk_vbox_new(TRUE, 2);
1025
gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);
1026
1027
entry = gtk_entry_new_with_max_length(LINELEN);
1028
gtk_entry_set_text(GTK_ENTRY(entry),data->basename);
1029
gtk_box_pack_start (GTK_BOX (vbox), entry, TRUE, TRUE, 0);
1030
/* CURRENT */
1031
gtk_signal_connect_object(GTK_OBJECT (entry), "changed",
1032
GTK_SIGNAL_FUNC (name_entry_changed),
1033
(gpointer) entry);
1034
gtk_object_set_data(GTK_OBJECT(entry), "ptr", (gpointer) data);
1035
1036
1037
data->gulp.energy_entry = gtk_entry_new_with_max_length(LINELEN);
1038
if (data->gulp.free)
1039
g_string_sprintf(line,"%f (free energy)",data->gulp.energy);
1040
else
1041
g_string_sprintf(line,"%f",data->gulp.energy);
1042
1043
gtk_entry_set_text(GTK_ENTRY(data->gulp.energy_entry),line->str);
1044
gtk_box_pack_start (GTK_BOX (vbox), data->gulp.energy_entry, TRUE, TRUE, 0);
1045
gtk_entry_set_editable(GTK_ENTRY(data->gulp.energy_entry), FALSE);
1046
1047
if (data->periodic == 2)
1048
{
1049
data->gulp.sbe_entry = gtk_entry_new_with_max_length(LINELEN);
1050
g_string_sprintf(line,"%f",data->gulp.sbulkenergy);
1051
gtk_entry_set_text(GTK_ENTRY(data->gulp.sbe_entry),line->str);
1052
gtk_box_pack_start (GTK_BOX (vbox), data->gulp.sbe_entry, TRUE, TRUE, 0);
1053
gtk_entry_set_editable(GTK_ENTRY(data->gulp.sbe_entry), FALSE);
1054
1055
data->gulp.esurf_entry = gtk_entry_new_with_max_length(LINELEN);
1056
g_string_sprintf(line,"%f %s",data->gulp.esurf, data->gulp.esurf_units);
1057
gtk_entry_set_text(GTK_ENTRY(data->gulp.esurf_entry),line->str);
1058
gtk_box_pack_start (GTK_BOX (vbox), data->gulp.esurf_entry, TRUE, TRUE, 0);
1059
gtk_entry_set_editable(GTK_ENTRY(data->gulp.esurf_entry), FALSE);
1060
1061
data->gulp.eatt_entry = gtk_entry_new_with_max_length(LINELEN);
1062
g_string_sprintf(line,"%f %s",data->gulp.eatt, data->gulp.eatt_units);
1063
gtk_entry_set_text(GTK_ENTRY(data->gulp.eatt_entry),line->str);
1064
gtk_box_pack_start (GTK_BOX (vbox), data->gulp.eatt_entry, TRUE, TRUE, 0);
1065
gtk_entry_set_editable(GTK_ENTRY(data->gulp.eatt_entry), FALSE);
1066
}
1067
1068
/* TODO - choose foreground or background run ?*/
1069
/* terminating buttons */
1070
button = gtk_button_new_with_label ("Run");
1071
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (gulp_dialog->win)->action_area),
1072
button, FALSE, TRUE, 0);
1073
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1074
GTK_SIGNAL_FUNC (run_gulp), (gpointer) id);
1075
1076
button = gtk_button_new_with_label ("Close");
1077
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (gulp_dialog->win)->action_area),
1078
button, FALSE, TRUE, 0);
1079
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
1080
GTK_SIGNAL_FUNC (close_dialog),
1081
(gpointer) id);
1082
/* done */
1083
gtk_widget_show_all(gulp_dialog->win);
1084
1085
g_string_free(line, TRUE);
1086
pick_model(data->number);
1087
}
1088
Loggerhead is a web-based interface for Breezy
Version: 2.0.1