1 /* MInterfaceBasis.c */
2 /**********************************************************************************************************
3 Copyright (c) 2002-2013 Abdul-Rahman Allouche. All rights reserved
4
5 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
6 documentation files (the Gabedit), to deal in the Software without restriction, including without limitation
7 the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
8 and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
9
10 The above copyright notice and this permission notice shall be included in all copies or substantial portions
11 of the Software.
12
13 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
14 TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
15 THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
16 CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
17 DEALINGS IN THE SOFTWARE.
18 ************************************************************************************************************/
19
20
21 #include "../../Config.h"
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <unistd.h>
26 #include <gtk/gtk.h>
27
28 #include "../Common/Global.h"
29 #include "../Utils/UtilsInterface.h"
30 #include "../Utils/AtomsProp.h"
31 #include "../Utils/Constants.h"
32 #include "../Gaussian/GaussGlobal.h"
33 #include "../Geometry/GeomGlobal.h"
34 #include "../Utils/Utils.h"
35 #include "../Molpro/MInterfaceGeom.h"
36 #include "../Molpro/MInterfaceBasis.h"
37 #include "../Molpro/MolproLib.h"
38 #include "../Molpro/MolproBasisLibrary.h"
39
40 #define NHBOX 5
41 /********************************************************************************/
42 static GtkWidget *listOfAtoms;
43 static GtkWidget* BoiteVP;
44 static GtkWidget* BoiteHP[NHBOX];
45 static GtkWidget *BoiteListeBaseAll[NORB+1] ;
46 static GtkWidget *Wins = NULL;
47 static gchar pathSelectedAtom[100] = "-1";
48 static gint NListeBase;
49 static gchar *OrbSel;
50
51 #ifdef G_OS_WIN32
52 static gint originbasis = 1; /* 1 -> from file */
53 #else
54 static gint originbasis = 0; /* 0 -> libmol */
55 #endif
56
57 gpointer d=NULL;
58 GtkWidget *LabelInfo;
59
60 typedef struct _ProgressData {
61 GtkWidget *window;
62 GtkWidget *pbar;
63 GtkWidget *pbox;
64 } ProgressData;
65 ProgressData *pdata;
66 /********************************************************************************/
get_base_total_from_path()67 static Cbasetot* get_base_total_from_path()
68 {
69 GtkTreeModel *model;
70 GtkTreeIter iter;
71 Cbasetot *base;
72
73 if(atoi(pathSelectedAtom)<0) return NULL;
74 model = gtk_tree_view_get_model(GTK_TREE_VIEW(listOfAtoms));
75 if(!gtk_tree_model_get_iter_from_string (model, &iter, pathSelectedAtom)) return NULL;
76 gtk_tree_model_get (model, &iter, ATOMLIST_DATA, &base, -1);
77
78 return base;
79 }
80 /********************************************************************************/
set_base_total_from_path(Cbasetot * basetot)81 static void set_base_total_from_path(Cbasetot *basetot)
82 {
83 GtkTreeModel *model;
84 GtkTreeIter iter;
85 GtkListStore *store;
86
87 if(atoi(pathSelectedAtom)<0) return;
88 model = gtk_tree_view_get_model(GTK_TREE_VIEW(listOfAtoms));
89 if(!gtk_tree_model_get_iter_from_string (model, &iter, pathSelectedAtom)) return;
90 store = GTK_LIST_STORE (model);
91 gtk_list_store_set (store, &iter, ATOMLIST_DATA, (gpointer) basetot, -1);
92 }
93 /********************************************************************************/
removeSeletedAtom()94 static void removeSeletedAtom()
95 {
96 GtkTreeModel *model;
97 GtkListStore *store;
98 GtkTreeIter iter;
99
100 if(atoi(pathSelectedAtom)<0) return;
101
102 model = gtk_tree_view_get_model(GTK_TREE_VIEW(listOfAtoms));
103 if(!gtk_tree_model_get_iter_from_string (model, &iter, pathSelectedAtom)) return;
104 store = GTK_LIST_STORE (model);
105 gtk_list_store_remove(store, &iter);
106 }
107 /************************************************************************************************************/
selectRow(GtkWidget * list,gint row)108 static void selectRow(GtkWidget* list, gint row)
109 {
110 GtkTreePath *path;
111 gchar* tmp = g_strdup_printf("%d",row);
112
113 path = gtk_tree_path_new_from_string (tmp);
114 g_free(tmp);
115 gtk_tree_selection_select_path (gtk_tree_view_get_selection (GTK_TREE_VIEW (list)), path);
116 gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW (list), path, NULL, FALSE,0.5,0.5);
117 gtk_tree_path_free(path);
118 }
119 /********************************************************************************/
120 /* Update the value of the progress bar so that we get some movement */
progress(gpointer d)121 gint progress( gpointer d )
122 {
123 gpointer data = pdata->pbar;
124 gdouble new_val;
125 gchar *t = NULL;
126
127 if(d) new_val = 0;
128 else
129 new_val = gtk_progress_bar_get_fraction( GTK_PROGRESS_BAR(data) ) + 0.1;
130
131 if (new_val > 1) new_val = 1.0;
132 gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (data), new_val);
133
134 if(originbasis == 0)
135 t = g_strdup_printf(_(" Get Basis using libmol : %.0f%%"),new_val*100);
136 else
137 t = g_strdup_printf(_(" Get Basis from gabedit basis file : %.0f%%"),new_val*100);
138
139 gtk_label_set_text( GTK_LABEL(LabelInfo),t);
140 g_free(t);
141
142 while( gtk_events_pending() ) gtk_main_iteration();
143
144 return TRUE;
145 }
146 /********************************************************************************/
destroy_progress(GtkWidget * widget,gpointer data)147 void destroy_progress( GtkWidget *widget, gpointer data)
148 {
149 gtk_widget_destroy(pdata->pbox);
150 g_free(pdata);
151 pdata = NULL;
152 }
153 /********************************************************************************/
create_progress_bar(GtkWidget * hbox)154 void create_progress_bar(GtkWidget *hbox)
155 {
156 GtkWidget *align;
157 GtkWidget *separator;
158 GtkWidget *vbox;
159
160 pdata = g_malloc( sizeof(ProgressData) );
161
162 pdata->window = Wins;
163 gtk_widget_show(hbox);
164
165
166 pdata->pbox = vbox = gtk_vbox_new (FALSE, 5);
167 gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
168 gtk_container_add (GTK_CONTAINER (hbox), vbox);
169 gtk_widget_show(vbox);
170
171 align = gtk_alignment_new (0.5, 0.5, 0, 0);
172 gtk_box_pack_start (GTK_BOX (vbox), align, FALSE, FALSE, 5);
173 gtk_widget_show(align);
174
175 pdata->pbar = gtk_progress_bar_new ();
176
177 gtk_container_add (GTK_CONTAINER (align), pdata->pbar);
178 gtk_widget_show_all(pdata->pbar);
179
180 separator = gtk_hseparator_new ();
181 gtk_box_pack_start (GTK_BOX (vbox), separator, FALSE, FALSE, 0);
182 gtk_widget_show(separator);
183
184 }
185 /********************************************************************************/
get_one_base(gchar ** AtomTypeBase,gchar * cont)186 gchar *get_one_base(gchar **AtomTypeBase,gchar* cont)
187 {
188 gchar *t;
189 if(AtomTypeBase[2][strlen(AtomTypeBase[2])-1] =='\n')
190 AtomTypeBase[2][strlen(AtomTypeBase[2])-1] = ' ';
191 if(cont)
192 t=g_strdup_printf("%s,%s,%s%s\n",AtomTypeBase[0],AtomTypeBase[1],AtomTypeBase[2],cont);
193 else
194 t=g_strdup_printf("%s,%s,%s\n",AtomTypeBase[0],AtomTypeBase[1],AtomTypeBase[2]);
195
196 return t;
197 }
198 /********************************************************************************/
get_num_orb(gchar * nameorb)199 gint get_num_orb(gchar *nameorb)
200 {
201 gchar *orb = g_strdup(nameorb);
202 gint k=-1;
203 uppercase(orb);
204 if(strcmp(orb,"ECP")==0)
205 return -1;
206 switch(orb[0])
207 {
208 case 'S' : k=0;break;
209 case 'P' : k=1;break;
210 case 'D' : k=2;break;
211 default : if(orb[0]<='I')
212 k=(gint)orb[0]-(gint)'F'+3;
213 }
214
215 g_free(orb);
216 return k;
217 }
218 /********************************************************************************/
DefineTypeAll(Cbasetot * basetot,gchar ** AtomTypeBase,gchar * cont)219 void DefineTypeAll(Cbasetot *basetot,gchar **AtomTypeBase,gchar* cont)
220 {
221 gint k = -1;
222 gchar *t = NULL;
223 gint i;
224 gint j;
225 if(!strcmp(AtomTypeBase[0],"ECP") )
226 {
227 if(basetot->ECP) g_free(basetot->ECP);
228 basetot->ECP = get_one_base(AtomTypeBase,cont);
229 k=-1;
230 }
231 else
232 {
233 k = get_num_orb(AtomTypeBase[0]);
234 if(k==-1)
235 return;
236 if(basetot->Orb[k]) g_free(basetot->Orb[k]);
237 basetot->Orb[k] = get_one_base(AtomTypeBase,cont);
238 }
239 /* BoiteListeBaseAll[1] <=> s and BoiteListeBaseAll[2] <=> p ...*/
240 if(k+2 >NORB)
241 return;
242
243 for(j=k+2;j<=NORB;j++)
244 if(BoiteListeBaseAll[j]) gtk_tree_selection_unselect_all (gtk_tree_view_get_selection (GTK_TREE_VIEW (BoiteListeBaseAll[j])));
245
246 j=k+2;
247 if(BoiteListeBaseAll[j])
248 {
249 GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(BoiteListeBaseAll[j]));
250 gchar* pathString;
251 GtkTreeIter iter;
252
253 i=0;
254 pathString = g_strdup_printf("%d", i);
255 while (gtk_tree_model_get_iter_from_string (model, &iter, pathString) == TRUE)
256 {
257 gtk_tree_model_get (model, &iter, BASISLIST_NAME, &t, -1);
258 i++;
259 g_free(pathString);
260 pathString = g_strdup_printf("%d", i);
261 if(!strcmp(t,AtomTypeBase[2]))
262 {
263 selectRow(BoiteListeBaseAll[j],i-1);
264 break;
265 }
266 }
267 g_free(pathString);
268 }
269 }
270 /********************************************************************************/
UnDefineTypeAll(Cbasetot * basetot,gchar ** AtomTypeBase)271 void UnDefineTypeAll(Cbasetot *basetot,gchar **AtomTypeBase)
272 {
273 gint k;
274 if(!strcmp(AtomTypeBase[0],"ECP") )
275 {
276 if(basetot->ECP)
277 g_free(basetot->ECP);
278 basetot->ECP = NULL;
279 return;
280 }
281
282 k = get_num_orb(AtomTypeBase[0]);
283 if(k==-1)
284 return;
285 if(basetot->Orb[k])
286 g_free(basetot->Orb[k]);
287 basetot->Orb[k] = NULL;
288 }
289 /********************************************************************************/
AfficheTypeAll(Cbasetot * basetot)290 void AfficheTypeAll(Cbasetot *basetot)
291 {
292 if(basetot->ECP != NULL )
293 printf("%s",basetot->ECP);
294 if(basetot->Orb[0] != NULL )
295 printf("%s",basetot->Orb[0]);
296 if(basetot->Orb[1] != NULL )
297 printf("%s",basetot->Orb[1]);
298 if(basetot->Orb[1] != NULL )
299 printf("%s",basetot->Orb[1]);
300 if(basetot->Orb[2] != NULL )
301 printf("%s",basetot->Orb[2]);
302 if(basetot->Orb[3] != NULL )
303 printf("%s",basetot->Orb[3]);
304 if(basetot->Orb[4] != NULL )
305 printf("%s",basetot->Orb[4]);
306 if(basetot->Orb[5] != NULL )
307 printf("%s",basetot->Orb[5]);
308 if(basetot->Orb[6] != NULL )
309 printf("%s",basetot->Orb[6]);
310 }
311 /********************************************************************************/
DeselectionBase(Cbase * base)312 static void DeselectionBase(Cbase *base)
313 {
314 gchar **AtomTypeBase;
315 gchar *temp;
316 Cbasetot *basetot;
317
318 AtomTypeBase =g_strsplit (base->TypeBase," ",3);
319
320 temp=AtomTypeBase[0];
321 AtomTypeBase[0]=AtomTypeBase[1];
322 AtomTypeBase[1]=temp;
323 basetot = get_base_total_from_path();
324 UnDefineTypeAll(basetot,AtomTypeBase);
325
326 set_base_total_from_path(basetot);
327
328 g_strfreev(AtomTypeBase);
329 }
330 /********************************************************************************/
resetSelectedBasis(Cbase * base,gboolean cont)331 static void resetSelectedBasis(Cbase *base, gboolean cont)
332 {
333 gchar *AtomTypeBase[3];
334 gchar *temp;
335 Cbasetot *basetot;
336 gint i;
337
338 for(i=0;i<3;i++) AtomTypeBase[i] = g_malloc(40*sizeof(gchar));
339
340 sscanf(base->TypeBase,"%s %s %s",AtomTypeBase[0],AtomTypeBase[1],AtomTypeBase[2]);
341
342 temp=AtomTypeBase[0];
343 AtomTypeBase[0]=AtomTypeBase[1];
344 AtomTypeBase[1]=temp;
345
346 basetot = get_base_total_from_path();
347 if(!strstr(AtomTypeBase[0],"ECP"))
348 {
349 if(cont) DefineTypeAll(basetot,AtomTypeBase,";c");
350 else DefineTypeAll(basetot,AtomTypeBase,NULL);
351 }
352 else DefineTypeAll(basetot,AtomTypeBase,NULL);
353
354
355 set_base_total_from_path(basetot);
356
357 for(i=0;i<3;i++) g_free(AtomTypeBase[i]);
358 }
359
360 /********************************************************************************/
selectionABasis(GtkTreeSelection * selection,gpointer data)361 static void selectionABasis(GtkTreeSelection *selection, gpointer data)
362 {
363 Cbase *base;
364 gboolean cont;
365
366 GtkTreeIter iter;
367 GtkTreeModel *model;
368 if (!gtk_tree_selection_get_selected (selection, &model, &iter)) return;
369
370 gtk_tree_model_get (model, &iter, BASISLIST_CONTRACTION, &cont, BASISLIST_DATA, &base, -1);
371 DeselectionBase(base);
372 resetSelectedBasis(base, cont);
373 }
374 /********************************************************************************/
ListeBasis(GtkWidget * listOfBasis,char * NomFichier)375 gboolean ListeBasis(GtkWidget *listOfBasis,char *NomFichier)
376 {
377 gchar basisName[40];
378 FILE *fd;
379 Cbase *base;
380 gboolean OK = FALSE;
381 gchar temp[40];
382 gchar t[40];
383
384 GtkTreeModel *model;
385 GtkListStore *store;
386 GtkTreeIter iter;
387
388 model = gtk_tree_view_get_model(GTK_TREE_VIEW(listOfBasis));
389 store = GTK_LIST_STORE (model);
390
391 fd = fopen(NomFichier, "r");
392 if(fd!=NULL)
393 {
394 while(!feof(fd))
395 {
396 if(!fgets(t,40,fd))break;
397 sscanf(t,"%s %s %s", temp,temp, basisName);
398 base = g_malloc(sizeof(Cbase));
399 base->TypeBase = g_strdup(t);
400 gtk_list_store_append(store, &iter);
401 gtk_list_store_set (store, &iter, BASISLIST_NAME, basisName, BASISLIST_CONTRACTION, TRUE, BASISLIST_DATA, (gpointer) base, -1);
402 }
403 fclose(fd);
404 OK = TRUE;
405 }
406 return OK;
407 }
408 /********************************************************************************/
select_one_list(gint norb)409 void select_one_list(gint norb)
410 {
411 gchar *basename = NULL;
412 Cbasetot *basetot = get_base_total_from_path();
413 gchar **AtomTypeBase;
414 gint j = norb;
415 gint i = 0;
416 gchar *t;
417
418 if(basename)
419 g_free(basename);
420 basename = NULL;
421 if(norb==0 && basetot->ECP)
422 {
423 AtomTypeBase =g_strsplit (basetot->ECP,",",3);
424 basename= g_strdup(AtomTypeBase[2]);
425 g_strfreev(AtomTypeBase);
426 if(basename)
427 {
428 AtomTypeBase =g_strsplit (basename,";",1);
429 g_free(basename);
430 basename = NULL;
431 basename= g_strdup(AtomTypeBase[0]);
432 g_strfreev(AtomTypeBase);
433 }
434 }
435 else
436 if(basetot->Orb[norb-1])
437 {
438 AtomTypeBase =g_strsplit (basetot->Orb[norb-1],",",3);
439 basename= g_strdup(AtomTypeBase[2]);
440 g_strfreev(AtomTypeBase);
441 if(basename)
442 {
443 AtomTypeBase =g_strsplit (basename,";",1);
444 g_free(basename);
445 basename = NULL;
446 basename= g_strdup(AtomTypeBase[0]);
447 g_strfreev(AtomTypeBase);
448 }
449 }
450
451 if(basename == NULL)
452 return;
453
454 g_strchug(basename);
455 g_strchomp(basename);
456 if(j >NORB)
457 return;
458
459
460 if(BoiteListeBaseAll[j])
461 {
462 gtk_tree_selection_unselect_all (gtk_tree_view_get_selection (GTK_TREE_VIEW (BoiteListeBaseAll[j])));
463 }
464
465 if(BoiteListeBaseAll[j])
466 {
467 GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(BoiteListeBaseAll[j]));
468 gchar* pathString;
469 GtkTreeIter iter;
470
471 i=0;
472 pathString = g_strdup_printf("%d", i);
473 while (gtk_tree_model_get_iter_from_string (model, &iter, pathString) == TRUE)
474 {
475 gtk_tree_model_get (model, &iter, BASISLIST_NAME, &t, -1);
476 i++;
477 g_free(pathString);
478 pathString = g_strdup_printf("%d", i);
479 if(strcmp(t,basename) == 0)
480 {
481 selectRow(BoiteListeBaseAll[j],i-1);
482 break;
483 }
484 }
485 g_free(pathString);
486 }
487 if(basename) g_free(basename);
488
489 }
490 /********************************************************************************/
toggledContraction(GtkCellRendererToggle * cell,gchar * path_string,gpointer data)491 static void toggledContraction (GtkCellRendererToggle *cell, gchar *path_string, gpointer data)
492 {
493 GtkTreeModel *model = GTK_TREE_MODEL (data);
494 GtkTreeIter iter;
495 GtkTreePath *path = gtk_tree_path_new_from_string (path_string);
496 gboolean cont;
497 Cbase *base;
498
499 gtk_tree_model_get_iter (model, &iter, path);
500 gtk_tree_model_get (model, &iter, BASISLIST_CONTRACTION, &cont, BASISLIST_DATA, &base, -1);
501
502 cont = !cont;
503 gtk_list_store_set (GTK_LIST_STORE (model), &iter, BASISLIST_CONTRACTION, cont, -1);
504
505 gtk_tree_path_free (path);
506 DeselectionBase(base);
507 resetSelectedBasis(base, cont);
508 }
509 /********************************************************************************/
CreateListeBase(char * NomFichier)510 GtkWidget *CreateListeBase(char * NomFichier)
511 {
512 GtkWidget *Scr;
513 GtkWidget *window;
514 gchar *Titre[2];
515 gchar *temp;
516 gint nhbox = 1;
517 gboolean CreaHbox = FALSE;
518 GtkWidget *CListeBase = NULL;
519
520
521 if (!strcmp(OrbSel,"ECP") )
522 {
523 temp =g_strdup("ECP");
524 nhbox = 1;
525 }
526 else
527 {
528 temp = g_strdup_printf(_(" Basis for %s "),OrbSel);
529 if(strstr(OrbSel,"s") || strstr(OrbSel,"p")|| strstr(OrbSel,"d"))
530 nhbox = 2;
531 else
532 if(strstr(OrbSel,"f") || strstr(OrbSel,"g")|| strstr(OrbSel,"h"))
533 nhbox = 3;
534 else
535 nhbox = 4;
536 }
537 if(!BoiteHP[nhbox])
538 {
539 CreaHbox = TRUE;
540 BoiteHP[nhbox] = gtk_hbox_new(TRUE, 0);
541 gtk_box_pack_start (GTK_BOX (BoiteVP), BoiteHP[nhbox], TRUE, TRUE, 2);
542 }
543 Titre[0]=g_strdup(temp);
544 Titre[1]=g_strdup(" Cont. ");
545 g_free(temp);
546
547
548 window = gtk_vbox_new(FALSE, 0);
549 gtk_box_pack_start (GTK_BOX (BoiteHP[nhbox]), window, TRUE, TRUE, 2);
550 gtk_widget_show(window);
551
552 Scr = gtk_scrolled_window_new(NULL, NULL);
553 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(Scr),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
554 gtk_container_add(GTK_CONTAINER(window), Scr);
555
556 if (!strcmp(OrbSel,"ECP") )
557 {
558 GtkListStore *store;
559 GtkTreeModel *model;
560 GtkCellRenderer *renderer;
561 GtkTreeViewColumn *column;
562
563 store = gtk_list_store_new (3, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_POINTER); /* the third column is not visible, used for data */
564 model = GTK_TREE_MODEL (store);
565
566 CListeBase = gtk_tree_view_new_with_model (model);
567 gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (CListeBase), TRUE);
568 gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (CListeBase), TRUE);
569 gtk_tree_view_set_reorderable(GTK_TREE_VIEW (CListeBase), FALSE);
570
571 column = gtk_tree_view_column_new ();
572 gtk_tree_view_column_set_title (column, Titre[0]);
573 renderer = gtk_cell_renderer_text_new ();
574 gtk_tree_view_column_pack_start (column, renderer, TRUE);
575 gtk_tree_view_column_set_attributes (column, renderer, "text", BASISLIST_NAME, NULL);
576 gtk_tree_view_append_column (GTK_TREE_VIEW (CListeBase), column);
577 }
578 else
579 {
580 GtkListStore *store;
581 GtkTreeModel *model;
582 GtkCellRenderer *renderer;
583 GtkTreeViewColumn *column;
584
585 store = gtk_list_store_new (3, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_POINTER); /* the third column is not visible, used for data */
586 model = GTK_TREE_MODEL (store);
587
588 CListeBase = gtk_tree_view_new_with_model (model);
589 gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (CListeBase), TRUE);
590 gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (CListeBase), TRUE);
591 gtk_tree_view_set_reorderable(GTK_TREE_VIEW (CListeBase), FALSE);
592
593 column = gtk_tree_view_column_new ();
594 gtk_tree_view_column_set_title (column, Titre[0]);
595 renderer = gtk_cell_renderer_text_new ();
596 gtk_tree_view_column_pack_start (column, renderer, TRUE);
597 gtk_tree_view_column_set_attributes (column, renderer, "text", BASISLIST_NAME, NULL);
598 gtk_tree_view_column_set_min_width(column, (gint)(ScreenHeight*0.012));
599 gtk_tree_view_append_column (GTK_TREE_VIEW (CListeBase), column);
600
601 column = gtk_tree_view_column_new ();
602 gtk_tree_view_column_set_title (column, Titre[1]);
603 renderer = gtk_cell_renderer_toggle_new ();
604 gtk_tree_view_column_pack_start (column, renderer, TRUE);
605 gtk_tree_view_column_set_attributes (column, renderer, "active", BASISLIST_CONTRACTION, NULL);
606 gtk_tree_view_column_set_min_width(column, (gint)(ScreenHeight*0.09));
607 gtk_tree_view_append_column (GTK_TREE_VIEW (CListeBase), column);
608 g_signal_connect (renderer, "toggled", G_CALLBACK (toggledContraction), model);
609
610 }
611 gtk_widget_set_size_request(listOfAtoms, (gint)(ScreenHeight*0.136),(gint)(ScreenHeight*0.06));
612 gtk_container_add(GTK_CONTAINER(Scr), CListeBase);
613
614 if(!ListeBasis(CListeBase,NomFichier) && CreaHbox ) gtk_widget_destroy(BoiteHP[nhbox]);
615 return (CListeBase);
616 }
617 /********************************************************************************/
get_error_message()618 gchar* get_error_message()
619 {
620 gchar *errfile= g_strdup_printf("%s%stmp%serrfile",gabedit_directory(), G_DIR_SEPARATOR_S, G_DIR_SEPARATOR_S);
621 gchar *terr = NULL;
622 gchar *dump = NULL;
623 gint taille = BSIZE;
624 gchar t[BSIZE];
625 FILE *fd;
626 fd = fopen(errfile, "r");
627 if(fd)
628 {
629 while(!feof(fd))
630 {
631 if(!fgets(t,taille, fd))
632 break;
633 dump = terr;
634 if(!terr)
635 terr = g_strdup_printf("%s",t);
636 else
637 {
638 terr = g_strdup_printf("%s%s",terr,t);
639 g_free(dump);
640 }
641 }
642 fclose(fd);
643 #ifdef G_OS_WIN32
644 unlink (errfile);
645 #else
646 dump = g_strdup_printf("rm %s&",errfile);
647 {int ierr = system(dump);}
648 g_free(dump);
649 #endif
650
651
652 }
653 g_free(errfile);
654 return terr;
655 }
656 /********************************************************************************/
create_one_liste(GtkWidget * widget,gpointer data,gboolean fromfile)657 gint create_one_liste (GtkWidget *widget, gpointer data,gboolean fromfile)
658 {
659 gint OK = 1;
660 gchar *t;
661 gchar *terr;
662 FILE *fd;
663 Cbasetot *basetot;
664 gchar *temp=NULL;
665 gchar *outfile= g_strdup_printf("%s%stmp%soutfile",gabedit_directory(), G_DIR_SEPARATOR_S, G_DIR_SEPARATOR_S);
666 gchar *errfile= g_strdup_printf("%s%stmp%serrfile",gabedit_directory(), G_DIR_SEPARATOR_S, G_DIR_SEPARATOR_S);
667 gint k;
668
669 OrbSel = (gchar *) data;
670 basetot = get_base_total_from_path();
671
672 if(!fromfile)
673 {
674 temp = g_strdup_printf("sh -c 'libmol -e %s -t %s>%s 2>%s'",basetot->Name,(gchar*)data,outfile,errfile);
675 {int ierr = system(temp);}
676 }
677 else
678 {
679 temp=g_strdup(" ");
680 get_molpro_basis_list(basetot->Name,(gchar*)data,outfile,errfile);
681 }
682
683 t=g_malloc(40);
684 terr = NULL;
685 fd = fopen(outfile, "r");
686 if(fd)
687 {
688 terr=fgets(t,40,fd);
689 fclose(fd);
690 }
691 if(terr!=NULL)
692 {
693 NListeBase++;
694 k = get_num_orb(OrbSel);
695
696 if(k<0)
697 BoiteListeBaseAll[0] = CreateListeBase(outfile);
698 else
699 BoiteListeBaseAll[k+1] = CreateListeBase(outfile);
700 }
701 else
702 OK = 0;
703
704 fd = fopen(outfile, "r");
705 if(fd)
706 {
707 fclose(fd);
708 #ifdef G_OS_WIN32
709 unlink (outfile);
710 #else
711 if(temp)
712 g_free(temp);
713 temp = g_strdup_printf("rm %s",outfile);
714 {int ierr = system(temp);}
715 #endif
716 }
717
718 g_free(t);
719 g_free(temp);
720 g_free(errfile);
721 g_free(outfile);
722 return OK;
723 }
724 /********************************************************************************/
CreateOrbitalTypeAll(gboolean fromfile)725 gchar *CreateOrbitalTypeAll(gboolean fromfile)
726 {
727 gint n=0;
728 gchar *terr = NULL;
729 gchar *dump = NULL;
730
731 progress(&n);
732 gtk_widget_show (BoiteHP[0]);
733 n += create_one_liste(NULL,(gpointer)"ECP",fromfile);
734 progress( NULL);
735 n += create_one_liste(NULL,(gpointer)"s",fromfile);
736 progress( NULL);
737 n += create_one_liste(NULL,(gpointer)"p",fromfile );
738 progress( NULL);
739 n += create_one_liste(NULL,(gpointer)"d",fromfile );
740 progress( NULL);
741 n += create_one_liste(NULL,(gpointer)"f",fromfile );
742 progress( NULL);
743 n += create_one_liste(NULL,(gpointer)"g",fromfile );
744 progress( NULL);
745 n += create_one_liste(NULL,(gpointer)"h",fromfile );
746 progress( NULL);
747 n += create_one_liste(NULL,(gpointer)"i",fromfile );
748 progress( NULL);
749 if( n == 0)
750 {
751 terr = get_error_message();
752 if(!terr)
753 {
754 if(originbasis == 0)
755 terr = g_strdup(_(" Sorry,\nNo basis available for this atom,\nOr libmol is not installed in your system."));
756 else
757 terr = g_strdup(_(" Sorry,\nNo basis available for this atom,\nOr gabedit molpro basis file is corrupted."));
758 }
759 else
760 {
761 dump = terr;
762 terr = g_strdup_printf(_("Error : %s"),dump);
763 g_free(dump);
764 }
765 }
766 progress( NULL);
767
768 Waiting(0.2);
769 gtk_widget_hide (BoiteHP[0]);
770 return terr;
771 }
772 /********************************************************************************/
RedefineListeBasis()773 void RedefineListeBasis()
774 {
775 guint Ncenters;
776 gboolean OK;
777 guint i,j;
778 Cbasetot *basetot;
779 gchar *texts[1]={NULL};
780 GtkTreeModel *model;
781 GtkListStore *store;
782 GtkTreeIter iter;
783
784 model = gtk_tree_view_get_model(GTK_TREE_VIEW(listOfAtoms));
785 store = GTK_LIST_STORE (model);
786
787
788 if(MethodeGeom == GEOM_IS_XYZ) Ncenters = NcentersXYZ;
789 else Ncenters = NcentersZmat;
790
791 for (i=0;i<Ncenters;i++)
792 {
793 OK=TRUE;
794 if(MethodeGeom == GEOM_IS_XYZ)
795 {
796 texts[0]=g_strdup(GeomXYZ[i].Symb);
797 for (j=0;j<i;j++)
798 if( !strcmp(GeomXYZ[i].Symb,GeomXYZ[j].Symb) )
799 {
800 OK=FALSE;
801 break;
802 }
803 }
804 else
805 if(MethodeGeom == GEOM_IS_ZMAT)
806 {
807 texts[0]=g_strdup(Geom[i].Symb);
808 for (j=0;j<i;j++)
809 if( !strcmp(Geom[i].Symb,Geom[j].Symb) )
810 {
811 OK=FALSE;
812 break;
813 }
814 }
815 if(!OK)continue;
816
817 if(*texts[0] != 'X' )
818 {
819 NRatoms++;
820 basetot = g_malloc(sizeof(Cbasetot));
821 basetot->Name = g_strdup(texts[0]);
822 basetot->ECP = NULL;
823 for(j=0;j<NORB;j++) basetot->Orb[j] = NULL;
824 gtk_list_store_append(store, &iter);
825 gtk_list_store_set (store, &iter, ATOMLIST_SYMBOL, texts[0], ATOMLIST_DATA, (gpointer) basetot, -1);
826 }
827 }
828 }
829 /********************************************************************************/
DeselectionAnAtom()830 static void DeselectionAnAtom()
831 {
832 guint i;
833 if(NListeBase != -1 )
834 {
835 for (i=0;(gint)i<=NORB;i++)
836 {
837 if(BoiteListeBaseAll[i]!=NULL)
838 gtk_widget_hide_on_delete (BoiteListeBaseAll[i]);
839 BoiteListeBaseAll[i] = NULL;
840 }
841 NListeBase=-1;
842 }
843 for(i=1;i<NHBOX;i++)
844 {
845 if(BoiteHP[i])
846 gtk_widget_destroy(BoiteHP[i]);
847 BoiteHP[i] = NULL;
848 }
849
850 gtk_label_set_text( GTK_LABEL(LabelInfo),_("Please select a atom"));
851
852 }
853 /********************************************************************************/
selectionAnAtom(GtkTreeSelection * selection,gpointer data)854 static void selectionAnAtom(GtkTreeSelection *selection, gpointer data)
855 {
856 gchar *terr = NULL;
857 gint i;
858
859 GtkTreeIter iter;
860 GtkTreeModel *model;
861 gchar* pathString;
862 GtkTreeSelection *select;
863
864 if (!gtk_tree_selection_get_selected (selection, &model, &iter)) return;
865 pathString =gtk_tree_model_get_string_from_iter(model, &iter);
866
867 sprintf(pathSelectedAtom,"%s", pathString);
868
869 DeselectionAnAtom();
870
871 if(!BoiteHP[0])
872 {
873 BoiteHP[0] = gtk_hbox_new(FALSE, 0);
874 gtk_box_pack_start (GTK_BOX (BoiteVP), BoiteHP[0], FALSE, FALSE, 2);
875 create_progress_bar(BoiteHP[0]);
876 }
877
878 if(originbasis == 0)
879 {
880 terr = CreateOrbitalTypeAll(FALSE);
881 if(terr)
882 {
883 originbasis = 1;
884 gtk_label_set_text( GTK_LABEL(LabelInfo),terr);
885 while( gtk_events_pending() )
886 gtk_main_iteration();
887 Waiting(1.0);
888 g_free(terr);
889 terr = CreateOrbitalTypeAll(TRUE);
890 }
891 }
892 else
893 terr = CreateOrbitalTypeAll(TRUE);
894
895 for(i=1;i<NHBOX;i++)
896 if(BoiteHP[i])
897 gtk_widget_show_all(BoiteHP[i]);
898
899 for (i=0;i<=NORB;i++)
900 {
901 if(BoiteListeBaseAll[i]!=NULL)
902 {
903 select_one_list(i);
904 select = gtk_tree_view_get_selection (GTK_TREE_VIEW (BoiteListeBaseAll[i]));
905 gtk_tree_selection_set_mode (select, GTK_SELECTION_SINGLE);
906 g_signal_connect (G_OBJECT (select), "changed", G_CALLBACK (selectionABasis), NULL);
907 }
908 }
909
910 if(terr) gtk_label_set_text( GTK_LABEL(LabelInfo),terr);
911 else gtk_label_set_text( GTK_LABEL(LabelInfo),_("Please select your basis"));
912
913 }
914 /********************************************************************************/
DelAtomList(GtkWidget * w,gpointer data)915 static void DelAtomList(GtkWidget *w,gpointer data)
916 {
917 NRatoms--;
918 removeSeletedAtom();
919 sprintf(pathSelectedAtom,"-1");
920 if(NRatoms>0) selectRow(listOfAtoms, 0);
921 else DeselectionAnAtom();
922 }
923 /********************************************************************************/
DialogueDelete(GtkWidget * w)924 static void DialogueDelete(GtkWidget *w)
925 {
926 GtkWidget *Dialogue;
927 GtkWidget *Label;
928 GtkWidget *Bouton;
929 GtkWidget *frame, *vboxframe;
930
931
932 if (NRatoms <1)
933 {
934 Message(_(" No Atom to delete !"),_("Warning"),TRUE);
935 return ;
936 }
937 if (atoi(pathSelectedAtom) <0)
938 {
939 Message(_(" Please Select Your Atom to delete!"),_("Warning"),TRUE);
940 return ;
941 }
942
943
944 Dialogue = gtk_dialog_new();
945 gtk_window_set_title(GTK_WINDOW(Dialogue),_("Delete Atom"));
946 gtk_window_set_modal (GTK_WINDOW (Dialogue), TRUE);
947 gtk_window_set_position(GTK_WINDOW(Dialogue),GTK_WIN_POS_CENTER);
948
949 Label = gtk_label_new(_("Are you sure to delete \nthe selected atom? \n"));
950 frame = gtk_frame_new (NULL);
951 gtk_frame_set_shadow_type( GTK_FRAME(frame),GTK_SHADOW_ETCHED_OUT);
952
953 gtk_container_set_border_width (GTK_CONTAINER (frame), 10);
954 gtk_box_pack_start( GTK_BOX(GTK_DIALOG(Dialogue)->vbox), frame,TRUE,TRUE,0);
955
956 gtk_widget_show (frame);
957
958 vboxframe = create_vbox(frame);
959
960 gtk_box_pack_start(GTK_BOX(vboxframe), Label,TRUE,TRUE,0);
961
962 gtk_widget_realize(Dialogue);
963
964 Bouton = create_button(Dialogue,"No");
965 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(Dialogue)->action_area), Bouton,TRUE,TRUE,0);
966 g_signal_connect_swapped(G_OBJECT(Bouton), "clicked", (GCallback)gtk_widget_destroy, GTK_OBJECT(Dialogue));
967 GTK_WIDGET_SET_FLAGS(Bouton, GTK_CAN_DEFAULT);
968 gtk_widget_grab_default(Bouton);
969
970 Bouton = create_button(Dialogue,"Yes");
971 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(Dialogue)->action_area), Bouton,TRUE,TRUE,0);
972 g_signal_connect(G_OBJECT(Bouton), "clicked",(GCallback)DelAtomList, NULL);
973 g_signal_connect_swapped(G_OBJECT(Bouton), "clicked",(GCallback)gtk_widget_destroy, GTK_OBJECT(Dialogue));
974 GTK_WIDGET_SET_FLAGS(Bouton, GTK_CAN_DEFAULT);
975
976 gtk_widget_show_all(Dialogue);
977 }
978 /********************************************************************************/
SetAtom(GtkWidget * w,gpointer data)979 static void SetAtom(GtkWidget *w,gpointer data)
980 {
981 gchar *texts[1];
982 Cbasetot *basetot;
983 GtkTreeModel *model;
984 GtkListStore *store;
985 GtkTreeIter iter;
986
987 model = gtk_tree_view_get_model(GTK_TREE_VIEW(listOfAtoms));
988 store = GTK_LIST_STORE (model);
989
990 texts[0]=g_strdup((gchar*)data);
991 NRatoms++;
992
993 basetot = g_malloc(sizeof(Cbasetot));
994 basetot->Name = g_strdup(texts[0]);
995 basetot->ECP = NULL;
996 basetot->Orb[0] = NULL;
997 basetot->Orb[1] = NULL;
998 basetot->Orb[2] = NULL;
999 basetot->Orb[3] = NULL;
1000 basetot->Orb[4] = NULL;
1001 basetot->Orb[5] = NULL;
1002 basetot->Orb[6] = NULL;
1003 gtk_list_store_append(store, &iter);
1004 gtk_list_store_set (store, &iter, ATOMLIST_SYMBOL, texts[0], ATOMLIST_DATA, (gpointer) basetot, -1);
1005 selectRow(listOfAtoms, NRatoms-1);
1006
1007 }
1008 /********************************************************************************/
DialogueAdd(GtkWidget * w,gpointer data)1009 static void DialogueAdd(GtkWidget *w,gpointer data)
1010 {
1011 GtkWidget* Table;
1012 GtkWidget* button;
1013 GtkWidget* FenetreTable;
1014 GtkWidget* frame;
1015 GtkWidget* vbox;
1016 GtkWidget* hbox;
1017 guint i;
1018 guint j;
1019 GtkStyle *button_style;
1020 GtkStyle *style;
1021
1022
1023 gchar*** Symb = get_periodic_table();
1024
1025 FenetreTable = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1026 gtk_window_set_modal(GTK_WINDOW(FenetreTable),TRUE);
1027 gtk_window_set_title(GTK_WINDOW(FenetreTable),_("Select your atom"));
1028 gtk_window_set_position(GTK_WINDOW(FenetreTable),GTK_WIN_POS_CENTER);
1029 gtk_window_set_transient_for(GTK_WINDOW(FenetreTable),GTK_WINDOW(Wins));
1030 gtk_window_set_modal (GTK_WINDOW (FenetreTable), TRUE);
1031 gtk_window_set_default_size (GTK_WINDOW(FenetreTable),(gint)(ScreenWidth*0.5),(gint)(ScreenHeight*0.4));
1032
1033 add_child(Wins,FenetreTable,gtk_widget_destroy,_(" Selec. atom "));
1034 g_signal_connect(G_OBJECT(FenetreTable),"delete_event",(GCallback)delete_child,NULL);
1035
1036 button_style = gtk_widget_get_style(FenetreTable);
1037
1038 vbox = gtk_vbox_new (FALSE, 5);
1039 gtk_container_add(GTK_CONTAINER(FenetreTable),vbox);
1040
1041 hbox = gtk_hbox_new (FALSE, 0);
1042 gtk_widget_show (hbox);
1043 gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
1044
1045
1046 frame = gtk_frame_new (NULL);
1047 gtk_frame_set_shadow_type( GTK_FRAME(frame),GTK_SHADOW_ETCHED_OUT);
1048
1049 gtk_container_set_border_width (GTK_CONTAINER (frame), 10);
1050 gtk_container_add(GTK_CONTAINER(hbox),frame);
1051 gtk_widget_show (frame);
1052
1053
1054 Table = gtk_table_new(PERIODIC_TABLE_N_ROWS-1,PERIODIC_TABLE_N_COLUMNS,TRUE);
1055 gtk_container_add(GTK_CONTAINER(frame),Table);
1056
1057 for ( i = 0;i<PERIODIC_TABLE_N_ROWS-1;i++)
1058 for ( j = 0;j<PERIODIC_TABLE_N_COLUMNS;j++)
1059 {
1060 if(strcmp(Symb[j][i],"00"))
1061 {
1062 button = gtk_button_new_with_label(Symb[j][i]);
1063 style=set_button_style(button_style,button,Symb[j][i]);
1064 g_signal_connect(G_OBJECT(button), "clicked",(GCallback)SetAtom,(gpointer )Symb[j][i]);
1065 g_signal_connect_swapped(G_OBJECT(button), "clicked",(GCallback)delete_child,GTK_OBJECT(FenetreTable));
1066
1067 gtk_table_attach(GTK_TABLE(Table),button,j,j+1,i,i+1,
1068 (GtkAttachOptions)(GTK_FILL | GTK_EXPAND) ,
1069 (GtkAttachOptions)(GTK_FILL | GTK_EXPAND),
1070 1,1);
1071 }
1072
1073 }
1074
1075 hbox = create_hbox(vbox);
1076 gtk_widget_realize(FenetreTable);
1077 button = create_button(FenetreTable,_("Cancel"));
1078 gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
1079 g_signal_connect_swapped(G_OBJECT(button), "clicked",(GCallback)delete_child,GTK_OBJECT(FenetreTable));
1080 GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
1081 gtk_widget_grab_default(button);
1082 gtk_widget_show(button);
1083
1084 gtk_widget_show_all(FenetreTable);
1085
1086 }
1087 /********************************************************************************/
ButtonBar(GtkWidget * BoiteV)1088 void ButtonBar(GtkWidget *BoiteV)
1089 {
1090 GtkWidget *hbox;
1091 GtkWidget *button;
1092
1093 hbox = gtk_hbox_new (FALSE, 0);
1094 gtk_widget_show (hbox);
1095 gtk_box_pack_start (GTK_BOX (BoiteV), hbox, FALSE, FALSE, 5);
1096
1097 button = gtk_button_new_with_label (_(" New Atom "));
1098
1099 g_signal_connect(G_OBJECT(button), "clicked",(GCallback)DialogueAdd,Wins);
1100
1101 gtk_box_pack_start (GTK_BOX(hbox), button, FALSE, FALSE, 5);
1102 gtk_widget_show (button);
1103
1104
1105 button = gtk_button_new_with_label (_(" Delete Atom "));
1106
1107 g_signal_connect(G_OBJECT(button), "clicked", (GCallback)DialogueDelete,NULL);
1108
1109 gtk_box_pack_start (GTK_BOX(hbox), button, FALSE, FALSE, 5);
1110
1111
1112 }
1113 /********************************************************************************/
AjoutePageBasis(GtkWidget * Win,GtkWidget * NoteBook,BaseS * base)1114 void AjoutePageBasis(GtkWidget *Win,GtkWidget *NoteBook,BaseS *base)
1115 {
1116 GtkWidget *Frame;
1117 GtkWidget *LabelOnglet;
1118 GtkWidget *LabelMenu;
1119 GtkWidget *BoiteV;
1120 GtkWidget *HPaned;
1121 GtkWidget *Scr;
1122 GtkWidget *window1;
1123 GtkWidget *hbox3;
1124 gchar *titleForAtoms[] = {_("Atoms")};
1125 gint i;
1126
1127 GtkListStore *store;
1128 GtkTreeModel *model;
1129 GtkCellRenderer *renderer;
1130 GtkTreeViewColumn *column;
1131 GtkTreeSelection *select;
1132
1133 Wins = Win;
1134 NRatoms=0;
1135 NListeBase=-1;
1136 Frame = gtk_frame_new(NULL);
1137 gtk_widget_set_size_request(GTK_WIDGET(Frame), (gint)(ScreenHeight*0.6),(gint)(ScreenHeight*0.4));
1138 gtk_frame_set_shadow_type( GTK_FRAME(Frame),GTK_SHADOW_ETCHED_OUT);
1139 gtk_container_set_border_width(GTK_CONTAINER(Frame), 10);
1140
1141 LabelOnglet = gtk_label_new(_("Basis"));
1142 LabelMenu = gtk_label_new(_("Basis"));
1143 gtk_notebook_append_page_menu(GTK_NOTEBOOK(NoteBook),Frame,LabelOnglet, LabelMenu);
1144
1145 BoiteV = gtk_vbox_new(FALSE, 0);
1146 gtk_container_add(GTK_CONTAINER(Frame), BoiteV);
1147
1148 hbox3 = gtk_hbox_new (FALSE, 0);
1149 gtk_widget_show (hbox3);
1150 gtk_box_pack_start (GTK_BOX (BoiteV), hbox3, FALSE, FALSE, 0);
1151
1152 HPaned = gtk_hpaned_new();
1153 gtk_box_pack_start (GTK_BOX (BoiteV), HPaned,TRUE,TRUE, 0);
1154
1155 BoiteVP = gtk_vbox_new(FALSE, 0);
1156 gtk_paned_add2(GTK_PANED(HPaned), BoiteVP);
1157
1158 window1 = BoiteVP;
1159 hbox3 = gtk_hbox_new (FALSE, 0);
1160 gtk_widget_show (hbox3);
1161 gtk_box_pack_start (GTK_BOX (BoiteVP), hbox3, FALSE, FALSE, 0);
1162
1163 LabelInfo = gtk_label_new (_("Please select a atom "));
1164 gtk_widget_show (LabelInfo);
1165 gtk_box_pack_start (GTK_BOX (BoiteVP), LabelInfo, FALSE, FALSE, 0);
1166
1167 Scr = gtk_scrolled_window_new(NULL, NULL);
1168 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(Scr),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
1169
1170 gtk_paned_add1(GTK_PANED(HPaned), Scr);
1171
1172 store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_POINTER); /* the second column is not visible, used for data */
1173 model = GTK_TREE_MODEL (store);
1174
1175 listOfAtoms = gtk_tree_view_new_with_model (model);
1176 gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (listOfAtoms), TRUE);
1177 gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (listOfAtoms), TRUE);
1178 gtk_tree_view_set_reorderable(GTK_TREE_VIEW (listOfAtoms), FALSE);
1179
1180 column = gtk_tree_view_column_new ();
1181 gtk_tree_view_column_set_title (column, titleForAtoms[0]);
1182 renderer = gtk_cell_renderer_text_new ();
1183 gtk_tree_view_column_pack_start (column, renderer, TRUE);
1184 gtk_tree_view_column_set_attributes (column, renderer, "text", ATOMLIST_SYMBOL, NULL);
1185 gtk_tree_view_append_column (GTK_TREE_VIEW (listOfAtoms), column);
1186
1187
1188 RedefineListeBasis();
1189
1190
1191 gtk_widget_set_size_request(listOfAtoms,(gint)(ScreenHeight*0.136),(gint)(ScreenHeight*0.05));
1192 gtk_container_add(GTK_CONTAINER(Scr), listOfAtoms);
1193
1194 select = gtk_tree_view_get_selection (GTK_TREE_VIEW (listOfAtoms));
1195 gtk_tree_selection_set_mode (select, GTK_SELECTION_SINGLE);
1196 g_signal_connect (G_OBJECT (select), "changed", G_CALLBACK (selectionAnAtom), NULL);
1197
1198 base->listOfAtoms = listOfAtoms;
1199 base->NRatoms = NRatoms;
1200
1201 ButtonBar(BoiteV);
1202 for(i=0;i<NHBOX;i++) BoiteHP[i] = NULL;
1203 for(i=0;i<NORB+1;i++) BoiteListeBaseAll[i] = NULL ;
1204 }
1205 /********************************************************************************/
1206
1207