1 /**********************************************************************************************************
2 Copyright (c) 2002-2013 Abdul-Rahman Allouche. All rights reserved
3
4 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
5 documentation files (the Gabedit), to deal in the Software without restriction, including without limitation
6 the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
7 and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
8
9 The above copyright notice and this permission notice shall be included in all copies or substantial portions
10 of the Software.
11
12 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
13 TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
14 THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
15 CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
16 DEALINGS IN THE SOFTWARE.
17 ************************************************************************************************************/
18 #include <stdlib.h>
19 #include "../../Config.h"
20 #include "../Utils/Constants.h"
21 #include "../Common/Global.h"
22 #include "../Molpro/MolproLib.h"
23 #include "../Utils/Utils.h"
24 #include "../Utils/UtilsInterface.h"
25 #include "../Utils/AtomsProp.h"
26 #include "../Molpro/MolproBasisLibrary.h"
27 #include "../Common/StockIcons.h"
28
29 static GtkWidget* Entry;
30
31
32 static gint Factor = 7;
33
34 #define lengthList 23
35
36 /************************************************************************************************************/
37 typedef enum
38 {
39 LIST_ATOM_SYMBOL = 0,
40 LIST_BASIS_NAME,
41 LIST_PSEUDO,
42 LIST_s,
43 LIST_p,
44 LIST_d,
45 LIST_f,
46 LIST_g,
47 LIST_h,
48 LIST_i,
49 LIST_j,
50 LIST_k,
51 LIST_l,
52 LIST_S,
53 LIST_P,
54 LIST_D,
55 LIST_F,
56 LIST_G,
57 LIST_H,
58 LIST_I,
59 LIST_J,
60 LIST_K,
61 LIST_L,
62 VISIBLE_COLUMN,
63 LIST_DATA /* column for data, this column is not visible */
64 }ListColumnsTypes;
65 /************************************************************************************************************/
66
67 static MolproBasis molproBasis={0,NULL};
68
69 static GtkWidget *SetWinDlg = NULL;
70 static GtkWidget *treeView = NULL;
71
72 typedef struct _DataMolproTree DataMolproTree;
73 struct _DataMolproTree
74 {
75 gint atomNumber;
76 gint basisNumber;
77 };
78 static gchar selectedRow[100] = "-1";
79 static void rafreshTreeView();
80 /********************************************************************************/
81 typedef enum
82 {
83 MENU_NEW_ATOM =0,
84 MENU_DELETE_ATOM,
85 MENU_NEW_BASIS,
86 MENU_DELETE_BASIS,
87 MENU_SAVE,
88 MENU_CLOSE
89 } EnumMenuType;
90
91 /********************************************************************************/
92 static void deleteBasisDlg(GtkWidget *win,gpointer d);
93 static void deleteAtomDlg(GtkWidget *win,gpointer d);
94 static void newBasisDlg();
95 static void newAtomDlg();
96 /********************************************************************************/
freeMolproBasis()97 static void freeMolproBasis()
98 {
99 if(molproBasis.numberOfAtoms<1)
100 {
101 molproBasis.numberOfAtoms = 0;
102 molproBasis.atoms = NULL;
103 return;
104 }
105 molproBasis.numberOfAtoms = 0;
106 molproBasis.atoms = NULL;
107 }
108 /********************************************************************************/
get_num_orb(gchar * orb)109 static gint get_num_orb(gchar *orb)
110 {
111 gchar allorb[21] = {'E', 's','p','d','f','g','h','i','j','k','l',
112 'S','P','D','F','G','H','I','J','K','L'};
113 gint i=0;
114
115 for(i=0;i<21;i++)
116 if(orb[0] == allorb[i])
117 return i;
118 return -1;
119 }
120 /********************************************************************************/
get_molpro_basis_list(gchar * Symb,gchar * orb,gchar * outfile,gchar * errfile)121 void get_molpro_basis_list(gchar* Symb,gchar* orb,gchar* outfile,gchar* errfile)
122 {
123 gchar *allorb[21] = {"ECP", "s","p","d","f","g","h","i","j","k","l",
124 "S","P","D","F","G","H","I","J","K","L"};
125 FILE* fout=fopen(outfile,"w");
126 FILE* ferr=fopen(errfile,"w");
127 gint numorb1=-1;
128 gint numorb2=-1;
129 gchar bas[BSIZE];
130 gchar* orbdown = g_strdup(orb);
131 gchar* orbup = g_strdup(orb);
132 gint atomNumber = -1;
133 gint i;
134
135 lowercase(orbdown);
136 uppercase(orbup);
137
138 if(molproBasis.numberOfAtoms<1)
139 {
140 loadMolproBasis();
141 if(molproBasis.numberOfAtoms<1)
142 return;
143 }
144
145 numorb1 = get_num_orb(orbup);
146 numorb2 = get_num_orb(orbdown);
147 atomNumber = -1;
148 for(i=0;i<molproBasis.numberOfAtoms;i++)
149 if(strcmp(molproBasis.atoms[i].symbol,Symb)==0)
150 {
151 atomNumber = i;
152 break;
153 }
154 if(atomNumber>=0)
155 for(i=0;i<molproBasis.atoms[atomNumber].numberOfBasis;i++)
156 {
157 sprintf(bas,"%s",molproBasis.atoms[atomNumber].basis[i].name);
158 if(numorb1>=0 && molproBasis.atoms[atomNumber].basis[i].orbitals[numorb1-1])
159 fprintf(fout,"%s %s %s\n",Symb,allorb[numorb1],bas);
160
161 if(numorb2>=0 && molproBasis.atoms[atomNumber].basis[i].orbitals[numorb2-1])
162 fprintf(fout,"%s %s %s\n",Symb,allorb[numorb2],bas);
163
164 if(numorb2==0 && molproBasis.atoms[atomNumber].basis[i].pseudo)
165 fprintf(fout,"%s %s %s\n",Symb,allorb[numorb2],bas);
166 }
167 g_free(orbdown);
168 g_free(orbup);
169 fclose(ferr);
170 fclose(fout);
171 }
172 /********************************************************************************/
destroyDlg(GtkWidget * win,gpointer data)173 static void destroyDlg(GtkWidget* win, gpointer data)
174 {
175 gtk_widget_destroy(win);
176 }
177 /********************************************************************************/
Traitement(guint Operation)178 static void Traitement(guint Operation)
179 {
180 switch(Operation)
181 {
182 case MENU_NEW_ATOM :
183 newAtomDlg();
184 break;
185 case MENU_DELETE_ATOM :
186 deleteAtomDlg(NULL,NULL);
187 break;
188 case MENU_NEW_BASIS :
189 newBasisDlg();
190 break;
191 case MENU_DELETE_BASIS :
192 deleteBasisDlg(NULL,NULL);
193 break;
194 case MENU_SAVE :
195 saveMolproBasis();
196 break;
197 case MENU_CLOSE :
198 destroyDlg(SetWinDlg, NULL);
199 SetWinDlg = NULL;
200 }
201 }
202 /********************************************************************************/
set_sensitive_option(GtkUIManager * manager,gchar * path,gboolean sensitive)203 static void set_sensitive_option(GtkUIManager *manager, gchar* path, gboolean sensitive)
204 {
205 GtkWidget *wid = gtk_ui_manager_get_widget (manager, path);
206 if(GTK_IS_WIDGET(wid)) gtk_widget_set_sensitive(wid, sensitive);
207 }
208 /**********************************************************************************/
set_sensitive_menu(GtkUIManager * manager,gint row,gint basisNumber)209 static void set_sensitive_menu(GtkUIManager *manager, gint row, gint basisNumber)
210 {
211 gint i;
212 GtkWidget *menu = gtk_ui_manager_get_widget (manager, "/MenuMolproBasis");
213 static gchar* paths[] = {
214 "/MenuMolproBasis/NewAtom", "/MenuMolproBasis/DeleteAtom",
215 "/MenuMolproBasis/NewBasis", "/MenuMolproBasis/DeleteBasis",
216 "/MenuMolproBasis/Save", "/MenuMolproBasis/Close" };
217 static gboolean sensitive[] = {TRUE, TRUE, TRUE, TRUE, TRUE, TRUE};
218 static gint o = MENU_NEW_ATOM;
219 static gint n = MENU_CLOSE-MENU_NEW_ATOM;
220 if (!GTK_IS_MENU (menu)) return;
221 if(row < 0)
222 {
223 sensitive[MENU_NEW_ATOM-o] = TRUE;
224 sensitive[MENU_DELETE_ATOM-o] = FALSE;
225 sensitive[MENU_NEW_BASIS-o] = FALSE;
226 sensitive[MENU_DELETE_BASIS-o] = FALSE;
227 sensitive[MENU_SAVE-o] = TRUE;
228 sensitive[MENU_CLOSE-o] = TRUE;
229 for(i=0;i<n;i++) set_sensitive_option(manager, paths[i], sensitive[i]);
230 }
231 else
232 {
233 if(basisNumber<0)
234 {
235 sensitive[MENU_NEW_ATOM-o] = TRUE;
236 sensitive[MENU_DELETE_ATOM-o] = TRUE;
237 sensitive[MENU_NEW_BASIS-o] = TRUE;
238 sensitive[MENU_DELETE_BASIS-o] = FALSE;
239 sensitive[MENU_SAVE-o] = TRUE;
240 sensitive[MENU_CLOSE-o] = TRUE;
241 for(i=0;i<n;i++) set_sensitive_option(manager, paths[i], sensitive[i]);
242 }
243 else
244 if(basisNumber>=0)
245 {
246 sensitive[MENU_NEW_ATOM-o] = FALSE;
247 sensitive[MENU_DELETE_ATOM-o] = FALSE;
248 sensitive[MENU_NEW_BASIS-o] = TRUE;
249 sensitive[MENU_DELETE_BASIS-o] = TRUE;
250 sensitive[MENU_SAVE-o] = TRUE;
251 sensitive[MENU_CLOSE-o] = TRUE;
252 for(i=0;i<n;i++) set_sensitive_option(manager, paths[i], sensitive[i]);
253 }
254 }
255 }
256 /**********************************************************************************/
show_menu_popup(GtkUIManager * manager,guint button,guint32 time)257 static gboolean show_menu_popup(GtkUIManager *manager, guint button, guint32 time)
258 {
259 GtkWidget *menu = gtk_ui_manager_get_widget (manager, "/MenuMolproBasis");
260 if (GTK_IS_MENU (menu))
261 {
262 gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, button, time);
263 return TRUE;
264 }
265 return FALSE;
266 }
267 /*********************************************************************************************************************/
activate_action(GtkAction * action)268 static void activate_action (GtkAction *action)
269 {
270 const gchar *name = gtk_action_get_name (action);
271 if(!strcmp(name, "NewAtom")) Traitement(MENU_NEW_ATOM);
272 else if(!strcmp(name, "DeleteAtom")) Traitement(MENU_DELETE_ATOM);
273 else if(!strcmp(name, "NewBasis")) Traitement(MENU_NEW_BASIS);
274 else if(!strcmp(name, "DeleteBasis")) Traitement(MENU_DELETE_BASIS);
275 else if(!strcmp(name, "Save")) Traitement(MENU_SAVE);
276 else if(!strcmp(name, "Close")) Traitement(MENU_CLOSE);
277 }
278 /*--------------------------------------------------------------------*/
279 static GtkActionEntry gtkActionEntries[] =
280 {
281 {"NewAtom", GABEDIT_STOCK_NEW, N_("New _atom"), NULL, "New atom", G_CALLBACK (activate_action) },
282 {"DeleteAtom", GABEDIT_STOCK_CUT, N_("_Delete selected atom"), NULL, "Delete selected atom", G_CALLBACK (activate_action) },
283 {"NewBasis", GABEDIT_STOCK_NEW, N_("New _basis"), NULL, "New _basis", G_CALLBACK (activate_action) },
284 {"DeleteBasis", GABEDIT_STOCK_CUT, N_("_Delete selected basis"), NULL, "Delete selected basis", G_CALLBACK (activate_action) },
285 {"Save", GABEDIT_STOCK_SAVE, N_("_Save"), NULL, "Save", G_CALLBACK (activate_action) },
286 {"Close", GABEDIT_STOCK_CLOSE, N_("_Close"), NULL, "Close", G_CALLBACK (activate_action) },
287 };
288 static guint numberOfGtkActionEntries = G_N_ELEMENTS (gtkActionEntries);
289 /********************************************************************************/
290 /* XML description of the menus for the test app. The parser understands
291 * a subset of the Bonobo UI XML format, and uses GMarkup for parsing */
292 static const gchar *uiMenuInfo =
293 " <popup name=\"MenuMolproBasis\">\n"
294 " <separator name=\"sepMenuPopAtom\" />\n"
295 " <menuitem name=\"NewAtom\" action=\"NewAtom\" />\n"
296 " <menuitem name=\"DeleteAtom\" action=\"DeleteAtom\" />\n"
297 " <separator name=\"sepMenuPopBasis\" />\n"
298 " <menuitem name=\"NewBasis\" action=\"NewBasis\" />\n"
299 " <menuitem name=\"DeleteBasis\" action=\"DeleteBasis\" />\n"
300 " <separator name=\"sepMenuPopSave\" />\n"
301 " <menuitem name=\"Save\" action=\"Save\" />\n"
302 " <separator name=\"sepMenuPopClose\" />\n"
303 " <menuitem name=\"Close\" action=\"Close\" />\n"
304 " </popup>\n"
305 ;
306 /*******************************************************************************************************************************/
newMenu(GtkWidget * win)307 static GtkUIManager *newMenu(GtkWidget* win)
308 {
309 GtkActionGroup *actionGroup = NULL;
310 GtkUIManager *manager = NULL;
311 GError *error = NULL;
312
313 manager = gtk_ui_manager_new ();
314 g_signal_connect_swapped (win, "destroy", G_CALLBACK (g_object_unref), manager);
315
316 actionGroup = gtk_action_group_new ("GabeditEditBasisMolproLibrary");
317 gtk_action_group_set_translation_domain(actionGroup,GETTEXT_PACKAGE);
318 gtk_action_group_add_actions (actionGroup, gtkActionEntries, numberOfGtkActionEntries, NULL);
319
320 gtk_ui_manager_insert_action_group (manager, actionGroup, 0);
321
322 gtk_window_add_accel_group (GTK_WINDOW (win), gtk_ui_manager_get_accel_group (manager));
323 if (!gtk_ui_manager_add_ui_from_string (manager, uiMenuInfo, -1, &error))
324 {
325 g_message (_("building menus failed: %s"), error->message);
326 g_error_free (error);
327 }
328 return manager;
329 }
330 /********************************************************************************/
eventDispatcher(GtkWidget * widget,GdkEventButton * event,gpointer user_data)331 static void eventDispatcher(GtkWidget *widget, GdkEventButton *event, gpointer user_data)
332 {
333
334 GtkTreePath *path;
335 GtkTreeIter iter;
336 GtkTreeModel *model;
337
338 if (!event) return;
339 if (event->window == gtk_tree_view_get_bin_window (GTK_TREE_VIEW (widget))
340 && !gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (widget), event->x, event->y, NULL, NULL, NULL, NULL)) {
341 gtk_tree_selection_unselect_all (gtk_tree_view_get_selection (GTK_TREE_VIEW (widget)));
342 }
343 if(gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (widget), event->x, event->y, &path, NULL, NULL, NULL))
344 {
345 if(path)
346 {
347 model = gtk_tree_view_get_model(GTK_TREE_VIEW(widget));
348 gtk_tree_selection_select_path (gtk_tree_view_get_selection (GTK_TREE_VIEW (widget)), path);
349 sprintf(selectedRow ,"%s",gtk_tree_path_to_string(path));
350 gtk_tree_model_get_iter (model, &iter, path);
351 gtk_tree_path_free(path);
352 if (event->type == GDK_BUTTON_PRESS && ((GdkEventButton *) event)->button == 3)
353 {
354 GdkEventButton *bevent = (GdkEventButton *) event;
355 GtkUIManager *manager = GTK_UI_MANAGER(user_data);
356 if(atoi(selectedRow) < 0) set_sensitive_menu(manager, TRUE, 0);
357 else
358 {
359 DataMolproTree* data = NULL;
360 gtk_tree_model_get (model, &iter, LIST_DATA, &data, -1);
361 if(data) set_sensitive_menu(manager, FALSE, data->basisNumber);
362 }
363 show_menu_popup(manager, bevent->button, bevent->time);
364 }
365 }
366 }
367 GTK_WIDGET_GET_CLASS(widget)->button_press_event(widget, event);
368 }
369 /********************************************************************************/
newDataMolproTree(gint atomNumber,gint basisNumber)370 static DataMolproTree* newDataMolproTree(gint atomNumber, gint basisNumber)
371 {
372 DataMolproTree* dataTree;
373 dataTree = g_malloc(sizeof(DataMolproTree));
374 dataTree->atomNumber = atomNumber;
375 dataTree->basisNumber = basisNumber;
376 return dataTree;
377 }
378 /********************************************************************************/
freeDataMolproTree()379 static void freeDataMolproTree()
380 {
381 DataMolproTree* data = NULL;
382 gint i = 0;
383 gchar* pathString = NULL;
384 GtkTreeIter iter;
385 GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(treeView));
386
387 pathString = g_strdup_printf("%d", i);
388 while (gtk_tree_model_get_iter_from_string (model, &iter, pathString) == TRUE)
389 {
390 gtk_tree_model_get (model, &iter, LIST_DATA, &data, -1);
391 if(data) g_free(data);
392 i++;
393 g_free(pathString);
394 pathString = g_strdup_printf("%d", i);
395 }
396 g_free(pathString);
397 }
398 /********************************************************************************/
getExpandInfo()399 static gboolean* getExpandInfo()
400 {
401 gint i;
402 gboolean* expandeds = NULL;
403 gint nNodes = 0;
404
405 gchar* pathString = NULL;
406 GtkTreeIter iter;
407 GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(treeView));
408
409 nNodes = 0;
410 pathString = g_strdup_printf("%d", nNodes);
411 while (gtk_tree_model_get_iter_from_string (model, &iter, pathString) == TRUE)
412 {
413 nNodes++;
414 g_free(pathString);
415 pathString = g_strdup_printf("%d", nNodes);
416 }
417 g_free(pathString);
418 if(nNodes<1) return NULL;
419 expandeds = g_malloc((nNodes+1)*sizeof(gboolean));
420 for(i=0;i<nNodes+1;i++) expandeds[i] = FALSE;
421
422 i = 0;
423 pathString = g_strdup_printf("%d", i);
424 while (gtk_tree_model_get_iter_from_string (model, &iter, pathString) == TRUE)
425 {
426 GtkTreePath *path = gtk_tree_path_new_from_string (pathString);
427 expandeds[i] = FALSE;
428 expandeds[i] = gtk_tree_view_row_expanded(GTK_TREE_VIEW(treeView), path);
429 gtk_tree_path_free(path);
430 i++;
431 g_free(pathString);
432 pathString = g_strdup_printf("%d", i);
433 }
434 g_free(pathString);
435 return expandeds;
436
437 }
438 /********************************************************************************/
setExpandeds(gboolean * expandeds,gchar * selected_row)439 static void setExpandeds(gboolean* expandeds, gchar* selected_row)
440 {
441 gint i;
442 gchar* pathString = NULL;
443 GtkTreeIter iter;
444 GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(treeView));
445
446 if(!expandeds) return;
447
448 i = 0;
449 pathString = g_strdup_printf("%d", i);
450 while (gtk_tree_model_get_iter_from_string (model, &iter, pathString) == TRUE)
451 {
452 if(expandeds[i])
453 {
454 GtkTreePath *path = gtk_tree_path_new_from_string (pathString);
455 gtk_tree_view_expand_to_path(GTK_TREE_VIEW(treeView), path);
456 gtk_tree_path_free(path);
457 }
458 i++;
459 g_free(pathString);
460 pathString = g_strdup_printf("%d", i);
461 }
462 g_free(pathString);
463 if(selected_row)
464 {
465 GtkTreePath *path = gtk_tree_path_new_from_string (selected_row);
466 gtk_tree_selection_select_path (gtk_tree_view_get_selection (GTK_TREE_VIEW (treeView)), path);
467 gtk_tree_path_free(path);
468 }
469 }
470 /********************************************************************************/
deleteOneBasis(GtkWidget * win,gpointer d)471 static void deleteOneBasis(GtkWidget *win, gpointer d)
472 {
473 gint atomNumber;
474 gint basisNumber;
475 gint numberOfBasis;
476 gint i;
477 gboolean* expandeds;
478
479 GtkTreeIter node;
480 GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(treeView));
481 DataMolproTree* data = NULL;
482
483 if(atoi(selectedRow)<0) return;
484 if(!gtk_tree_model_get_iter_from_string (model, &node, selectedRow)) return;
485 gtk_tree_model_get (model, &node, LIST_DATA, &data, -1);
486
487
488
489 if(!data) return;
490
491 expandeds = getExpandInfo();
492
493 atomNumber = data->atomNumber;
494 basisNumber = data->basisNumber;
495
496 if(atomNumber<0)
497 return;
498 if(basisNumber<0)
499 return;
500
501
502 if(molproBasis.atoms[atomNumber].basis[basisNumber].name)
503 g_free(molproBasis.atoms[atomNumber].basis[basisNumber].name);
504
505 numberOfBasis = molproBasis.atoms[atomNumber].numberOfBasis;
506
507 for(i=basisNumber;i<numberOfBasis-1;i++)
508 molproBasis.atoms[atomNumber].basis[i] = molproBasis.atoms[atomNumber].basis[i+1];
509
510 molproBasis.atoms[atomNumber].numberOfBasis--;
511
512 molproBasis.atoms[atomNumber].basis =
513 g_realloc(molproBasis.atoms[atomNumber].basis,
514 molproBasis.atoms[atomNumber].numberOfBasis*sizeof(MolproOneBasis));
515
516 freeDataMolproTree();
517 rafreshTreeView();
518 setExpandeds(expandeds,selectedRow);
519 if(expandeds)
520 g_free(expandeds);
521 }
522 /********************************************************************************/
deleteBasisDlg(GtkWidget * win,gpointer d)523 static void deleteBasisDlg(GtkWidget *win,gpointer d)
524 {
525
526 gchar *format =_("Do you want to really delete \"%s\" basis for \"%s\" atom ?");
527 gchar *t =NULL;
528 gint atomNumber;
529 gint basisNumber;
530 GtkWidget* w = NULL;
531
532 GtkTreeIter node;
533 GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(treeView));
534 DataMolproTree* data = NULL;
535
536 if(atoi(selectedRow)<0) return;
537 if(!gtk_tree_model_get_iter_from_string (model, &node, selectedRow)) return;
538 gtk_tree_model_get (model, &node, LIST_DATA, &data, -1);
539
540
541 if(!data) return;
542
543 atomNumber = data->atomNumber;
544 basisNumber = data->basisNumber;
545
546 if(atomNumber<0)
547 return;
548 if(basisNumber<0)
549 return;
550
551 t =g_strdup_printf(format,
552 molproBasis.atoms[atomNumber].basis[basisNumber].name,
553 molproBasis.atoms[atomNumber].symbol
554 );
555
556 w = Continue_YesNo(deleteOneBasis, NULL,t);
557 gtk_window_set_modal(GTK_WINDOW(w),TRUE);
558 gtk_window_set_transient_for(GTK_WINDOW(w),GTK_WINDOW(SetWinDlg));
559 }
560 /********************************************************************************/
deleteOneAtom(GtkWidget * win,gpointer d)561 static void deleteOneAtom(GtkWidget *win, gpointer d)
562 {
563 gint atomNumber;
564 gint basisNumber;
565 gint numberOfBasis;
566 gint numberOfAtoms;
567 gint i;
568 gboolean* expandeds;
569
570 GtkTreeIter node;
571 GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(treeView));
572 DataMolproTree* data = NULL;
573
574 if(atoi(selectedRow)<0) return;
575 if(!gtk_tree_model_get_iter_from_string (model, &node, selectedRow)) return;
576 gtk_tree_model_get (model, &node, LIST_DATA, &data, -1);
577
578 if(!data) return;
579
580 expandeds = getExpandInfo();
581
582 atomNumber = data->atomNumber;
583 basisNumber = data->basisNumber;
584
585 if(atomNumber<0)
586 return;
587 if(basisNumber>=0)
588 return;
589
590
591 numberOfBasis = molproBasis.atoms[atomNumber].numberOfBasis;
592 numberOfAtoms = molproBasis.numberOfAtoms;
593 for(i=0;i<numberOfBasis;i++)
594 if(molproBasis.atoms[atomNumber].basis[i].name)
595 g_free(molproBasis.atoms[atomNumber].basis[i].name);
596
597 if(molproBasis.atoms[atomNumber].symbol)
598 g_free(molproBasis.atoms[atomNumber].symbol);
599
600 for(i=atomNumber;i<numberOfAtoms-1;i++)
601 molproBasis.atoms[i] = molproBasis.atoms[i+1];
602
603 molproBasis.numberOfAtoms--;
604
605 molproBasis.atoms =
606 g_realloc(molproBasis.atoms,
607 molproBasis.numberOfAtoms*sizeof(MolproAtom));
608
609 freeDataMolproTree();
610 rafreshTreeView();
611 setExpandeds(expandeds,selectedRow);
612 if(expandeds)
613 g_free(expandeds);
614 }
615 /********************************************************************************/
deleteAtomDlg(GtkWidget * win,gpointer d)616 static void deleteAtomDlg(GtkWidget *win,gpointer d)
617 {
618
619 gchar *format =_("Do you want to really delete \"%s\" atom ?");
620 gchar *t =NULL;
621 gint atomNumber;
622 gint basisNumber;
623 GtkWidget* w = NULL;
624
625 GtkTreeIter node;
626 GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(treeView));
627 DataMolproTree* data = NULL;
628
629 if(atoi(selectedRow)<0) return;
630 if(!gtk_tree_model_get_iter_from_string (model, &node, selectedRow)) return;
631 gtk_tree_model_get (model, &node, LIST_DATA, &data, -1);
632
633 if(!data) return;
634
635 atomNumber = data->atomNumber;
636 basisNumber = data->basisNumber;
637
638 if(atomNumber<0)
639 return;
640 if(basisNumber>=0)
641 return;
642
643 t =g_strdup_printf(format,molproBasis.atoms[atomNumber].symbol);
644
645 w = Continue_YesNo(deleteOneAtom, NULL,t);
646 gtk_window_set_modal(GTK_WINDOW(w),TRUE);
647 gtk_window_set_transient_for(GTK_WINDOW(w),GTK_WINDOW(SetWinDlg));
648 }
649 /********************************************************************************/
newAtom()650 static void newAtom()
651 {
652 gint atomNumber;
653 gint basisNumber;
654 gint numberOfAtoms;
655 MolproAtom* atoms;
656 gchar* symbol = g_strdup(gtk_entry_get_text(GTK_ENTRY(Entry)));
657 gboolean* expandeds;
658 gint i;
659
660 GtkTreeIter node;
661 GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(treeView));
662 DataMolproTree* data = NULL;
663
664 if(!gtk_tree_model_get_iter_from_string (model, &node, selectedRow)) return;
665 gtk_tree_model_get (model, &node, LIST_DATA, &data, -1);
666
667
668 atomNumber = -1;
669 basisNumber = -1;
670 if(data)
671 {
672 atomNumber = data->atomNumber;
673 basisNumber = data->basisNumber;
674 }
675
676 if(strlen(symbol)<=0)
677 return;
678
679 numberOfAtoms = molproBasis.numberOfAtoms;
680 atoms = molproBasis.atoms;
681 for(i=0;i<numberOfAtoms;i++)
682 {
683 if(strcmp(symbol,atoms[i].symbol)==0)
684 {
685 GtkWidget* win = Message(_("Sorry this atom is available"),"Error",TRUE);
686 gtk_window_set_modal(GTK_WINDOW(win),TRUE);
687 gtk_window_set_transient_for(GTK_WINDOW(win),GTK_WINDOW(SetWinDlg));
688 return;
689 }
690 }
691 numberOfAtoms++;
692 atoms = g_realloc(atoms,numberOfAtoms*sizeof(MolproAtom));
693 atoms[numberOfAtoms-1].symbol = symbol;
694 atoms[numberOfAtoms-1].numberOfBasis = 0;
695 atoms[numberOfAtoms-1].basis = NULL;
696
697 molproBasis.atoms = atoms;
698 molproBasis.numberOfAtoms = numberOfAtoms;
699 if(atomNumber>=0)
700 {
701 MolproAtom t = molproBasis.atoms[numberOfAtoms-1];
702 for(i=numberOfAtoms-1;i>atomNumber;i--)
703 molproBasis.atoms[i] = molproBasis.atoms[i-1];
704 molproBasis.atoms[atomNumber] = t;
705 }
706
707 expandeds = getExpandInfo();
708 freeDataMolproTree();
709 rafreshTreeView();
710 setExpandeds(expandeds,selectedRow);
711 if(expandeds)
712 g_free(expandeds);
713
714 }
715 /********************************************************************************/
setAtom(GtkWidget * w,gpointer data)716 static void setAtom(GtkWidget *w,gpointer data)
717 {
718 gtk_entry_set_text(GTK_ENTRY(Entry),(char *)data);
719 }
720 /********************************************************************************/
selectAtom(GtkWidget * w,gpointer entry0)721 static void selectAtom(GtkWidget *w,gpointer entry0)
722 {
723 GtkWidget* Table;
724 GtkWidget* button;
725 GtkWidget* frame;
726 GtkWidget* FenetreTable;
727 guint i;
728 guint j;
729 GtkStyle *button_style;
730 GtkStyle *style;
731
732 gchar*** Symb = get_periodic_table();
733
734 FenetreTable = gtk_window_new(GTK_WINDOW_TOPLEVEL);
735 gtk_window_set_modal(GTK_WINDOW(FenetreTable),TRUE);
736 gtk_window_set_title(GTK_WINDOW(FenetreTable),_("Select your atom"));
737 gtk_window_set_default_size (GTK_WINDOW(FenetreTable),(gint)(ScreenWidth*0.5),(gint)(ScreenHeight*0.4));
738
739 frame = gtk_frame_new (NULL);
740 gtk_frame_set_shadow_type( GTK_FRAME(frame),GTK_SHADOW_ETCHED_OUT);
741 gtk_container_set_border_width (GTK_CONTAINER (frame), 10);
742
743 gtk_container_add(GTK_CONTAINER(FenetreTable),frame);
744 gtk_widget_show (frame);
745
746 Table = gtk_table_new(PERIODIC_TABLE_N_ROWS-1,PERIODIC_TABLE_N_COLUMNS,TRUE);
747 gtk_container_add(GTK_CONTAINER(frame),Table);
748 button_style = gtk_widget_get_style(FenetreTable);
749
750 for ( i = 0;i<PERIODIC_TABLE_N_ROWS-1;i++)
751 for ( j = 0;j<PERIODIC_TABLE_N_COLUMNS;j++)
752 {
753 if(strcmp(Symb[j][i],"00"))
754 {
755 button = gtk_button_new_with_label(Symb[j][i]);
756 style=set_button_style(button_style,button,Symb[j][i]);
757 g_signal_connect(G_OBJECT(button), "clicked",
758 (GCallback)setAtom,(gpointer )Symb[j][i]);
759 g_signal_connect_swapped(G_OBJECT(button), "clicked",
760 (GCallback)gtk_widget_destroy,GTK_OBJECT(FenetreTable));
761 gtk_table_attach(GTK_TABLE(Table),button,j,j+1,i,i+1,
762 (GtkAttachOptions)(GTK_FILL | GTK_EXPAND) ,
763 (GtkAttachOptions)(GTK_FILL | GTK_EXPAND),
764 1,1);
765 }
766
767 }
768
769 gtk_widget_show_all(FenetreTable);
770
771 }
772 /********************************************************************************/
newAtomDlg()773 static void newAtomDlg()
774 {
775 GtkWidget *WinDlg;
776 GtkWidget *Button;
777 GtkWidget *hbox;
778 GtkWidget *frame;
779 GtkWidget *vboxframe;
780 gint atomNumber;
781 gint basisNumber;
782 gchar title[BSIZE];
783
784 GtkTreeIter node;
785 GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(treeView));
786 DataMolproTree* data = NULL;
787
788 if(!gtk_tree_model_get_iter_from_string (model, &node, selectedRow)) return;
789 gtk_tree_model_get (model, &node, LIST_DATA, &data, -1);
790
791 if(!data) return;
792
793 atomNumber = data->atomNumber;
794 basisNumber = data->basisNumber;
795
796 sprintf(title,_("New Atom"));
797
798 WinDlg = gtk_dialog_new();
799 gtk_window_set_title(GTK_WINDOW(WinDlg),title);
800 gtk_window_set_position(GTK_WINDOW(WinDlg),GTK_WIN_POS_CENTER);
801 gtk_window_set_transient_for(GTK_WINDOW(WinDlg),GTK_WINDOW(SetWinDlg));
802 gtk_window_set_modal(GTK_WINDOW(WinDlg),TRUE);
803
804 g_signal_connect(G_OBJECT(WinDlg),"delete_event",(GCallback)gtk_widget_destroy,NULL);
805
806 frame = gtk_frame_new (NULL);
807 gtk_frame_set_shadow_type( GTK_FRAME(frame),GTK_SHADOW_ETCHED_OUT);
808 gtk_container_set_border_width (GTK_CONTAINER (frame), 10);
809 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(WinDlg)->vbox), frame,TRUE,TRUE,0);
810 gtk_widget_show (frame);
811
812 vboxframe = create_vbox(frame);
813 hbox=create_hbox_false(vboxframe);
814
815 Entry = create_label_entry(hbox,_(" Atom Symbol : "),-1,-1);
816 gtk_entry_set_text(GTK_ENTRY(Entry),"H");
817 gtk_editable_set_editable((GtkEditable*) Entry,FALSE);
818 Button = gtk_button_new_with_label(_(" Set "));
819 gtk_box_pack_start (GTK_BOX(hbox), Button, TRUE, TRUE, 5);
820 g_signal_connect(G_OBJECT(Button), "clicked", (GCallback)selectAtom,Entry);
821
822 gtk_widget_realize(WinDlg);
823
824 Button = create_button(WinDlg,_("Cancel"));
825 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(WinDlg)->action_area), Button,TRUE,TRUE,0);
826 g_signal_connect_swapped(G_OBJECT(Button), "clicked", (GCallback)gtk_widget_destroy,GTK_OBJECT(WinDlg));
827 GTK_WIDGET_SET_FLAGS(Button, GTK_CAN_DEFAULT);
828
829 Button = create_button(WinDlg,_("OK"));
830 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(WinDlg)->action_area), Button,TRUE,TRUE,0);
831 g_signal_connect_swapped(G_OBJECT(Button), "clicked", (GCallback)newAtom,GTK_OBJECT(WinDlg));
832 g_signal_connect_swapped(G_OBJECT(Button), "clicked", (GCallback)gtk_widget_destroy,GTK_OBJECT(WinDlg));
833 GTK_WIDGET_SET_FLAGS(Button, GTK_CAN_DEFAULT);
834 gtk_widget_grab_default(Button);
835
836
837 gtk_widget_show_all(WinDlg);
838 }
839 /********************************************************************************/
newBasis()840 static void newBasis()
841 {
842 gint atomNumber;
843 gint basisNumber;
844 gint numberOfBasis;
845 MolproOneBasis* basis;
846 gchar* basisName = g_strdup(gtk_entry_get_text(GTK_ENTRY(Entry)));
847 gboolean* expandeds;
848 gint i;
849
850 GtkTreeIter node;
851 GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(treeView));
852 DataMolproTree* data = NULL;
853
854 if(!gtk_tree_model_get_iter_from_string (model, &node, selectedRow)) return;
855 gtk_tree_model_get (model, &node, LIST_DATA, &data, -1);
856
857 if(!data) return;
858
859 atomNumber = data->atomNumber;
860 basisNumber = data->basisNumber;
861
862 if(atomNumber<0)
863 return;
864 delete_all_spaces(basisName);
865 if(strlen(basisName)<=0)
866 return;
867 numberOfBasis = molproBasis.atoms[atomNumber].numberOfBasis;
868 basis = molproBasis.atoms[atomNumber].basis;
869 for(i=0;i<numberOfBasis;i++)
870 {
871 if(strcmp(basisName,basis[i].name)==0)
872 {
873 Message(_("Sorry this basis is already available"),"Error",TRUE);
874 return;
875 }
876 }
877 numberOfBasis++;
878 basis = g_realloc(basis,numberOfBasis*sizeof(MolproOneBasis));
879 basis[numberOfBasis-1].name = basisName;
880 basis[numberOfBasis-1].pseudo = FALSE;
881 for(i=0;i<21;i++)
882 basis[numberOfBasis-1].orbitals[i] = FALSE;
883
884 molproBasis.atoms[atomNumber].basis = basis;
885 molproBasis.atoms[atomNumber].numberOfBasis = numberOfBasis;
886 if(basisNumber>=0)
887 {
888 MolproOneBasis t = molproBasis.atoms[atomNumber].basis[numberOfBasis-1];
889
890 for(i=numberOfBasis-1;i>basisNumber;i--)
891 molproBasis.atoms[atomNumber].basis[i] =
892 molproBasis.atoms[atomNumber].basis[i-1];
893
894 molproBasis.atoms[atomNumber].basis[basisNumber] = t;
895 }
896
897 expandeds = getExpandInfo();
898 freeDataMolproTree();
899 rafreshTreeView();
900 setExpandeds(expandeds,selectedRow);
901 if(expandeds)
902 g_free(expandeds);
903
904 }
905 /********************************************************************************/
newBasisDlg()906 static void newBasisDlg()
907 {
908 GtkWidget *WinDlg;
909 GtkWidget *Button;
910 GtkWidget *hbox;
911 GtkWidget *frame;
912 GtkWidget *vboxframe;
913 gint atomNumber;
914 gint basisNumber;
915 gchar title[BSIZE];
916
917 GtkTreeIter node;
918 GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(treeView));
919 DataMolproTree* data = NULL;
920
921 if(!gtk_tree_model_get_iter_from_string (model, &node, selectedRow)) return;
922 gtk_tree_model_get (model, &node, LIST_DATA, &data, -1);
923
924
925 if(!data) return;
926
927 atomNumber = data->atomNumber;
928 basisNumber = data->basisNumber;
929
930 if(atomNumber<0 )
931 return;
932
933 sprintf(title,_("New Basis for %s atom :"),molproBasis.atoms[atomNumber].symbol);
934
935 WinDlg = gtk_dialog_new();
936 gtk_window_set_title(GTK_WINDOW(WinDlg),title);
937 gtk_window_set_position(GTK_WINDOW(WinDlg),GTK_WIN_POS_CENTER);
938 gtk_window_set_transient_for(GTK_WINDOW(WinDlg),GTK_WINDOW(SetWinDlg));
939 gtk_window_set_modal(GTK_WINDOW(WinDlg),TRUE);
940
941 g_signal_connect(G_OBJECT(WinDlg),"delete_event",(GCallback)gtk_widget_destroy,NULL);
942
943 frame = gtk_frame_new (NULL);
944 gtk_frame_set_shadow_type( GTK_FRAME(frame),GTK_SHADOW_ETCHED_OUT);
945 gtk_container_set_border_width (GTK_CONTAINER (frame), 10);
946 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(WinDlg)->vbox), frame,TRUE,TRUE,0);
947 gtk_widget_show (frame);
948
949 vboxframe = create_vbox(frame);
950 hbox=create_hbox_false(vboxframe);
951
952 Entry = create_label_entry(hbox,_(" Basis Name : "),-1,-1);
953
954 gtk_editable_set_editable((GtkEditable*) Entry,TRUE);
955
956 gtk_widget_realize(WinDlg);
957
958 Button = create_button(WinDlg,"Cancel");
959 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(WinDlg)->action_area), Button,TRUE,TRUE,0);
960 g_signal_connect_swapped(G_OBJECT(Button), "clicked", (GCallback)gtk_widget_destroy,GTK_OBJECT(WinDlg));
961 GTK_WIDGET_SET_FLAGS(Button, GTK_CAN_DEFAULT);
962
963 Button = create_button(WinDlg,_("OK"));
964 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(WinDlg)->action_area), Button,TRUE,TRUE,0);
965 g_signal_connect_swapped(G_OBJECT(Button), "clicked", (GCallback)newBasis,GTK_OBJECT(WinDlg));
966 g_signal_connect_swapped(G_OBJECT(Button), "clicked", (GCallback)gtk_widget_destroy,GTK_OBJECT(WinDlg));
967 GTK_WIDGET_SET_FLAGS(Button, GTK_CAN_DEFAULT);
968 gtk_widget_grab_default(Button);
969
970
971 gtk_widget_show_all(WinDlg);
972 }
973 /********************************************************************************/
toggledAvailable(GtkCellRendererToggle * cell,gchar * path_string,gpointer data)974 static void toggledAvailable (GtkCellRendererToggle *cell, gchar *path_string, gpointer data)
975 {
976 gint column = GPOINTER_TO_INT(data);
977 GtkTreeIter iter;
978 GtkTreePath *path = gtk_tree_path_new_from_string (path_string);
979 gboolean value = FALSE;
980 DataMolproTree* dataTree = NULL;
981 GtkTreeModel *model;
982
983 if(column<2) return;
984
985 model = gtk_tree_view_get_model(GTK_TREE_VIEW(treeView));
986
987 gtk_tree_model_get_iter (model, &iter, path);
988 gtk_tree_model_get (model, &iter, column, &value, LIST_DATA, &dataTree, -1);
989
990 value = !value;
991 gtk_tree_store_set (GTK_TREE_STORE (model), &iter, column, value, -1);
992
993 gtk_tree_path_free (path);
994
995 if(data)
996 {
997 gint iorb = column-2;
998 gint ia = dataTree->atomNumber;
999 gint ib = dataTree->basisNumber;
1000 if(iorb==0) molproBasis.atoms[ia].basis[ib].pseudo = value;
1001 else
1002 {
1003 iorb = iorb -1;
1004 molproBasis.atoms[ia].basis[ib].orbitals[iorb] = value;
1005 }
1006 }
1007 }
1008 /********************************************************************************/
addFeuille(GtkTreeIter * parent,MolproOneBasis * molproOneBasis,gint atomNumber,gint basisNumber)1009 static void addFeuille(GtkTreeIter *parent, MolproOneBasis* molproOneBasis, gint atomNumber, gint basisNumber)
1010 {
1011 GtkTreeIter feuille;
1012 DataMolproTree* dataTree;
1013 gint i;
1014 GtkTreeModel *model;
1015 GtkTreeStore *store;
1016
1017 model = gtk_tree_view_get_model(GTK_TREE_VIEW(treeView));
1018 store = GTK_TREE_STORE (model);
1019
1020 dataTree = newDataMolproTree(atomNumber,basisNumber);
1021
1022 gtk_tree_store_append(store, &feuille, parent);
1023 gtk_tree_store_set (store, &feuille, LIST_ATOM_SYMBOL, " ", -1);
1024 gtk_tree_store_set (store, &feuille, LIST_BASIS_NAME, molproOneBasis->name, -1);
1025 gtk_tree_store_set (store, &feuille, LIST_PSEUDO, molproOneBasis->pseudo, -1);
1026 for(i=3;i<lengthList;i++) gtk_tree_store_set (store, &feuille, i, molproOneBasis->orbitals[i-3], -1);
1027
1028 gtk_tree_store_set (store, &feuille, LIST_DATA, dataTree, -1);
1029 gtk_tree_store_set (store, &feuille, VISIBLE_COLUMN, TRUE, -1);
1030 }
1031 /********************************************************************************/
addNode(gchar * text,gint atomNumber)1032 static GtkTreeIter addNode(gchar *text,gint atomNumber)
1033 {
1034 GtkTreeIter node;
1035 DataMolproTree* dataTree;
1036 GtkTreeModel *model;
1037 GtkTreeStore *store;
1038
1039 model = gtk_tree_view_get_model(GTK_TREE_VIEW(treeView));
1040 store = GTK_TREE_STORE (model);
1041
1042 gtk_tree_store_append(store, &node, NULL);
1043 dataTree = newDataMolproTree(atomNumber,-1);
1044 gtk_tree_store_set (store, &node, LIST_ATOM_SYMBOL, text, -1);
1045 gtk_tree_store_set (store, &node, LIST_BASIS_NAME, " ", -1);
1046 gtk_tree_store_set (store, &node, VISIBLE_COLUMN, FALSE, -1);
1047 gtk_tree_store_set (store, &node, LIST_DATA, dataTree, -1);
1048
1049 return node;
1050 }
1051 /***********************************************************************/
addBasisList()1052 static void addBasisList()
1053 {
1054 gint i;
1055 GtkTreeIter node;
1056 MolproOneBasis* molproOneBasis;
1057 gint numberOfBasis = 0;
1058 gint j;
1059
1060 for(i=0;i<molproBasis.numberOfAtoms;i++)
1061 {
1062 node = addNode(molproBasis.atoms[i].symbol,i);
1063 molproOneBasis = molproBasis.atoms[i].basis;
1064 numberOfBasis = molproBasis.atoms[i].numberOfBasis;
1065
1066 for(j=0;j<numberOfBasis;j++)
1067 {
1068 addFeuille(&node,&molproOneBasis[j],i,j);
1069 }
1070
1071 }
1072 }
1073 /********************************************************************************/
clearTreeView()1074 static void clearTreeView()
1075 {
1076 GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(treeView));
1077 GtkTreeStore *store = GTK_TREE_STORE (model);
1078 gtk_tree_store_clear(store);
1079 }
1080 /********************************************************************************/
rafreshTreeView()1081 static void rafreshTreeView()
1082 {
1083 if(treeView == NULL) return;
1084 clearTreeView();
1085 addBasisList();
1086 }
1087 /***********************************************************************/
addTreeView(GtkWidget * win,GtkWidget * vbox)1088 static void addTreeView(GtkWidget *win, GtkWidget *vbox)
1089 {
1090 GtkWidget *scr;
1091 gint i;
1092 GtkTreeStore *store;
1093 GtkTreeModel *model;
1094 GtkCellRenderer *renderer;
1095 GtkTreeViewColumn *column;
1096 gchar *listTitles[]={ N_("Atom"), N_("Basis"), N_("Pseudo"),
1097 "s","p","d","f","g","h","i","j","k","l",
1098 "S","P","D","F","G","H","I","J","K","L"
1099 };
1100 static gint listWidths[]={15,15,8,
1101 4,4,4,4,4,4,4,4,4,4,
1102 4,4,4,4,4,4,4,4,4,4
1103 };
1104
1105
1106 gint widall=0;
1107
1108 for(i=0;i<lengthList;i++) widall += listWidths[i];
1109
1110 widall = widall*Factor+200;
1111
1112 scr = gtk_scrolled_window_new(NULL, NULL);
1113 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scr), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1114 gtk_container_add(GTK_CONTAINER(vbox), scr);
1115 gtk_widget_set_size_request(scr,widall,(gint)(ScreenHeight*0.80));
1116
1117 store = gtk_tree_store_new (lengthList+2,
1118 G_TYPE_STRING, G_TYPE_STRING, /* atom symbol and basis name */
1119 G_TYPE_BOOLEAN, /* pseudo */
1120 /* s, p, .... l */
1121 G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN,
1122 G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN,
1123 /* S, P, .... L */
1124 G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN,
1125 G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN,
1126 G_TYPE_BOOLEAN, /* it is not visible, used for render others columns visible or not */
1127 G_TYPE_POINTER); /* it is not visible, = data row */
1128
1129 model = GTK_TREE_MODEL (store);
1130
1131 treeView = gtk_tree_view_new_with_model (model);
1132 gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeView), TRUE);
1133 gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeView), TRUE);
1134
1135 for (i=0;i<2;i++)
1136 {
1137 column = gtk_tree_view_column_new ();
1138 gtk_tree_view_column_set_title (column, listTitles[i]);
1139 gtk_tree_view_column_set_reorderable(column, TRUE);
1140 renderer = gtk_cell_renderer_text_new ();
1141 gtk_tree_view_column_pack_start (column, renderer, FALSE);
1142 gtk_tree_view_column_set_attributes (column, renderer, "text", i, NULL);
1143 gtk_tree_view_column_set_min_width(column, listWidths[i]*Factor);
1144 gtk_tree_view_append_column (GTK_TREE_VIEW (treeView), column);
1145 }
1146 for (i=2;i<lengthList;i++)
1147 {
1148 column = gtk_tree_view_column_new ();
1149 gtk_tree_view_column_set_title (column, listTitles[i]);
1150 gtk_tree_view_column_set_reorderable(column, TRUE);
1151 renderer = gtk_cell_renderer_toggle_new ();
1152 gtk_tree_view_column_pack_start (column, renderer, FALSE);
1153 gtk_tree_view_column_set_attributes (column, renderer, "active", i, "visible", VISIBLE_COLUMN,NULL);
1154 gtk_tree_view_column_set_min_width(column, listWidths[i]*Factor);
1155 gtk_tree_view_append_column (GTK_TREE_VIEW (treeView), column);
1156 g_signal_connect (renderer, "toggled", G_CALLBACK (toggledAvailable), GINT_TO_POINTER(i));
1157 }
1158 set_base_style(treeView,30000,50000,60000);
1159
1160 gtk_container_add(GTK_CONTAINER(scr), treeView);
1161 }
1162 /***********************************************************************/
saveMolproBasis()1163 void saveMolproBasis()
1164 {
1165 gchar *filename = g_strdup_printf("%s/molprobasis",gabedit_directory());
1166 FILE* file;
1167 gint i,j,k;
1168
1169 if(molproBasis.numberOfAtoms<0)
1170 return;
1171 file = fopen(filename,"w");
1172 fprintf(file,"Natoms = %d\n",molproBasis.numberOfAtoms);
1173 for(i=0;i<molproBasis.numberOfAtoms;i++)
1174 {
1175 fprintf(file,"Atom %s\n",molproBasis.atoms[i].symbol);
1176 fprintf(file,"%d\n",molproBasis.atoms[i].numberOfBasis);
1177 for(j=0;j<molproBasis.atoms[i].numberOfBasis;j++)
1178 {
1179 fprintf(file,"%s ",molproBasis.atoms[i].basis[j].name);
1180 fprintf(file,"%d ",molproBasis.atoms[i].basis[j].pseudo);
1181 for(k=0;k<20;k++)
1182 fprintf(file,"%d ",molproBasis.atoms[i].basis[j].orbitals[k]);
1183 fprintf(file,"\n");
1184 }
1185
1186 }
1187 fclose(file);
1188
1189 }
1190 /***********************************************************************/
loadMolproBasis()1191 void loadMolproBasis()
1192 {
1193 gchar *filename = g_strdup_printf("%s/molprobasis",gabedit_directory());
1194 FILE* file = fopen(filename,"r");
1195 gchar t[BSIZE];
1196 gchar symb[BSIZE];
1197 gchar bas[BSIZE];
1198 gchar dump[BSIZE];
1199 gint orbok[21];
1200 gint nbas = 0;
1201 gint natoms = 0;
1202 gchar* point = NULL;
1203 gint i,j, k, n;
1204
1205 if(!file)
1206 {
1207 create_molpro_basis_file();
1208 file = fopen(filename,"r");
1209 }
1210 if(!file)
1211 {
1212 printf(_("Sorry the molprobasis is corrupted.\nPlease reinstall gabedit\n"));
1213 return;
1214 }
1215 { char* e = fgets(t,BSIZE,file);} /* number of atoms */
1216 point = strstr(t,"=");
1217 if(!point)
1218 {
1219 freeMolproBasis();
1220 return;
1221 }
1222
1223 point = strstr(t,"=")+1;
1224
1225 sscanf(point,"%d",&natoms);
1226 if(natoms<1 || natoms>200)
1227 return;
1228
1229 molproBasis.numberOfAtoms = natoms;
1230 molproBasis.atoms = g_malloc(natoms*sizeof(MolproAtom));
1231
1232 for(i=0;i<natoms;i++)
1233 {
1234 if(!fgets(t,BSIZE,file))
1235 {
1236 printf(_("Sorry the molprobasis is corrupted.\nPlease reinstall gabedit\n"));
1237 freeMolproBasis();
1238 break;
1239 }
1240 n = sscanf(t,"%s %s",dump,symb);
1241 if(n!=2)
1242 {
1243 printf(_("Sorry the molprobasis is corrupted.\nPlease reinstall gabedit\n"));
1244 freeMolproBasis();
1245 return;
1246 }
1247 molproBasis.atoms[i].symbol = g_strdup(symb);
1248 if(!fgets(t,BSIZE,file))
1249 break;
1250 sscanf(t,"%d",&nbas);
1251 molproBasis.atoms[i].numberOfBasis = nbas;
1252 molproBasis.atoms[i].basis = g_malloc(nbas*sizeof(MolproOneBasis));
1253
1254 for(j=0;j<nbas;j++)
1255 {
1256 if(!fgets(t,BSIZE,file))
1257 {
1258 printf(_("Sorry the molprobasis is corrupted.\nPlease reinstall gabedit\n"));
1259 freeMolproBasis();
1260 break;
1261 }
1262 sscanf(t,"%s %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d",
1263 bas,
1264 &orbok[0],/*pseudo*/
1265 &orbok[1],&orbok[2],&orbok[3],&orbok[4],&orbok[5],
1266 &orbok[6],&orbok[7],&orbok[8],&orbok[9],&orbok[10],
1267 &orbok[11],&orbok[12],&orbok[13],&orbok[14],&orbok[15],
1268 &orbok[16],&orbok[17],&orbok[18],&orbok[19],&orbok[20]
1269 );
1270 molproBasis.atoms[i].basis[j].name = g_strdup(bas);
1271 molproBasis.atoms[i].basis[j].pseudo = orbok[0];
1272 for(k=1;k<=20;k++)
1273 molproBasis.atoms[i].basis[j].orbitals[k-1] = orbok[k];
1274 }
1275 }
1276
1277 fclose(file);
1278 }
1279 /***********************************************************************/
setMolproBasisDlg()1280 void setMolproBasisDlg()
1281 {
1282 GtkWidget *Win;
1283 GtkWidget *vbox;
1284 GtkWidget *frame;
1285 GtkWidget *parentWindow = Fenetre;
1286 GtkUIManager *manager = NULL;
1287
1288 Win= gtk_window_new(GTK_WINDOW_TOPLEVEL);
1289 gtk_window_set_position(GTK_WINDOW(Win),GTK_WIN_POS_CENTER);
1290 gtk_window_set_transient_for(GTK_WINDOW(Win),GTK_WINDOW(parentWindow));
1291 gtk_window_set_title(GTK_WINDOW(Win),_("Set Molpro Basis"));
1292 gtk_window_set_modal (GTK_WINDOW (Win), TRUE);
1293
1294 SetWinDlg = Win;
1295
1296 g_signal_connect(G_OBJECT(Win),"delete_event",(GCallback)destroyDlg, NULL);
1297
1298 vbox = gtk_vbox_new (FALSE, 0);
1299 gtk_widget_show (vbox);
1300 gtk_container_add (GTK_CONTAINER (Win), vbox);
1301
1302 frame = gtk_frame_new (NULL);
1303 gtk_frame_set_shadow_type( GTK_FRAME(frame),GTK_SHADOW_ETCHED_OUT);
1304 gtk_container_set_border_width (GTK_CONTAINER (frame), 5);
1305
1306 gtk_container_add(GTK_CONTAINER(vbox),frame);
1307 gtk_widget_show (frame);
1308
1309 vbox = create_vbox(frame);
1310 gtk_widget_realize(Win);
1311
1312 if(molproBasis.numberOfAtoms==0)
1313 loadMolproBasis();
1314
1315 treeView = NULL;
1316 addTreeView(Win, vbox);
1317 rafreshTreeView();
1318
1319 manager = newMenu(Win);
1320 g_signal_connect(treeView, "button_press_event", G_CALLBACK(eventDispatcher), manager);
1321
1322 gtk_widget_show_all(Win);
1323 }
1324