1 /* EXTRAITS DE LA LICENCE
2 Copyright CEA, contributeurs : Luc BILLARD, Damien
3 CALISTE, Olivier D'Astier, laboratoire L_Sim, (2001-2005)
4
5 Adresses mèl :
6 BILLARD, non joignable par mèl ;
7 CALISTE, damien P caliste AT cea P fr.
8 D'ASTIER, dastier AT iie P cnam P fr.
9
10 Ce logiciel est un programme informatique servant à visualiser des
11 structures atomiques dans un rendu pseudo-3D.
12
13 Ce logiciel est régi par la licence CeCILL soumise au droit français et
14 respectant les principes de diffusion des logiciels libres. Vous pouvez
15 utiliser, modifier et/ou redistribuer ce programme sous les conditions
16 de la licence CeCILL telle que diffusée par le CEA, le CNRS et l'INRIA
17 sur le site "http://www.cecill.info".
18
19 Le fait que vous puissiez accéder à cet en-tête signifie que vous avez
20 pris connaissance de la licence CeCILL, et que vous en avez accepté les
21 termes (cf. le fichier Documentation/licence.fr.txt fourni avec ce logiciel).
22 */
23
24 /* LICENCE SUM UP
25 Copyright CEA, contributors : Luc BILLARD and Damien
26 CALISTE and Olivier D'Astier, laboratoire L_Sim, (2001-2005)
27
28 E-mail addresses :
29 BILLARD, not reachable any more ;
30 CALISTE, damien P caliste AT cea P fr.
31 D'ASTIER, dastier AT iie P cnam P fr.
32
33 This software is a computer program whose purpose is to visualize atomic
34 configurations in 3D.
35
36 This software is governed by the CeCILL license under French law and
37 abiding by the rules of distribution of free software. You can use,
38 modify and/ or redistribute the software under the terms of the CeCILL
39 license as circulated by CEA, CNRS and INRIA at the following URL
40 "http://www.cecill.info".
41
42 The fact that you are presently reading this means that you have had
43 knowledge of the CeCILL license and that you accept its terms. You can
44 find a copy of this licence shipped with this software at Documentation/licence.en.txt.
45 */
46 #include "panelSurfacesTools.h"
47 #include "panelSurfaces.h"
48
49 #include <math.h>
50 #include <stdlib.h>
51 #include <stdio.h>
52 #include <string.h>
53 #include <support.h>
54 #include <visu_gtk.h>
55 #include <visu_basic.h>
56 #include <extraFunctions/pot2surf.h>
57 #include <extraFunctions/surfaces.h>
58 #include <gtk_renderingWindowWidget.h>
59
60 /**
61 * SECTION:panelSurfacesTools
62 * @short_description: Gtk interface to manage isosurfaces.
63 *
64 * <para>This module contains the panel used to manage your .surf
65 * files. At the moment, only two tools are availiable for you to
66 * use. <link linkend="v-sim-pot2surf">pot2surf</link> will allow you
67 * to create .surf files from .pot files. There is also a .surf file
68 * merger which is so short that we beliedved it didn't need it's own
69 * module.</para>
70 */
71
72 static GtkWidget *convert_window;
73 static gboolean convert_w_opened = FALSE;
74
75 static GtkListStore* list_store = NULL;
76 static GtkListStore* list_store_target = NULL;
77
78 static GtkWidget* tree_view_source = NULL;
79 static GtkWidget* tree_view_target = NULL;
80
81 enum {
82 MERGE_SURF_NAME,
83 MERGE_NB_POINTS,
84 MERGE_NB_VERTEX,
85 MERGE_FILENAME,
86 MERGE_NEW_SURF_NAME,
87 MERGE_SHORT_FILENAME,
88 MERGE_N_COLUMNS
89 };
90
91 static GtkWidget *surfmerge_source_ddd[6];
92 static GtkWidget *surfmerge_target_ddd[6];
93
94 static GtkWidget *entry_current_file;
95 static GtkWidget *entry_target_file;
96
97 void surf_add_surf_to_target();
98
99 #if GTK_MAJOR_VERSION < 3
gtk_tree_model_iter_previous(GtkTreeModel * tree_model,GtkTreeIter * iter)100 gboolean gtk_tree_model_iter_previous(GtkTreeModel *tree_model, GtkTreeIter *iter)
101 {
102 GtkTreePath *temp_to_free = gtk_tree_model_get_path(tree_model, iter);
103
104 if (!temp_to_free)
105 return FALSE;
106
107 if(!gtk_tree_path_prev(temp_to_free))
108 {
109 /* DBG_fprintf(stderr, "WARNING : custom gtk_tree_model_iter_previous couldn't retrieve previous element\n"); */
110 gtk_tree_path_free(temp_to_free);
111 return FALSE;
112 }
113
114 if(!gtk_tree_model_get_iter(tree_model, iter, temp_to_free))
115 {
116 /* DBG_fprintf(stderr, "WARNING : custom gtk_tree_model_iter_previous couldn't retrieve a valid iter\n"); */
117 gtk_tree_path_free(temp_to_free);
118 return FALSE;
119 }
120
121 gtk_tree_path_free(temp_to_free);
122 return TRUE;
123 }
124 #endif
125
126 /* Parses target surf file to retrieve dxx, ..., dzz,
127 as well as each surface name, nb of vertex and nb of points. */
surf_simply_parse_file(char * file_name)128 gboolean surf_simply_parse_file(char *file_name)
129 {
130 GString *line = g_string_new("");
131 gchar **surf_names = NULL;
132 gsize terminator_pos;
133 int last_op_status;
134 int number_of_surfaces;
135 int i;
136 int *nb_vertex, *nb_points;
137 float ddd[6];
138 char float_to_string[128];
139 gboolean ddd_are_null = TRUE;
140 gboolean ddd_are_equal = TRUE;
141
142 GIOChannel* file_to_parse = g_io_channel_new_file(file_name, "r", NULL);
143
144 if(file_to_parse == NULL)
145 return FALSE;
146
147 /* First line is arbitrary */
148 last_op_status =
149 g_io_channel_read_line_string (file_to_parse, line, &terminator_pos, NULL);
150 if(last_op_status != G_IO_STATUS_NORMAL)
151 return FALSE;
152
153 /* Second line contains dxx, dyx and dyy values */
154 last_op_status =
155 g_io_channel_read_line_string (file_to_parse, line, &terminator_pos, NULL);
156 if(last_op_status != G_IO_STATUS_NORMAL ||
157 sscanf(line->str, "%f %f %f", &ddd[0], &ddd[1], &ddd[2]) != 3)
158 return FALSE;
159
160 /* Third line contains dzx, dzy and dzz values */
161 last_op_status =
162 g_io_channel_read_line_string (file_to_parse, line, &terminator_pos, NULL);
163 if(last_op_status != G_IO_STATUS_NORMAL ||
164 sscanf(line->str, "%f %f %f", &ddd[3], &ddd[4], &ddd[5]) != 3)
165 return FALSE;
166
167 /* Fourth line contains nsurf values (as well as two other values) */
168 last_op_status =
169 g_io_channel_read_line_string (file_to_parse, line, &terminator_pos, NULL);
170 if(last_op_status != G_IO_STATUS_NORMAL ||
171 sscanf(line->str, "%d", &number_of_surfaces) != 1)
172 return FALSE;
173
174 if(number_of_surfaces <= 0)
175 return FALSE;
176
177 surf_names = g_malloc(number_of_surfaces * sizeof(gchar *));
178 nb_vertex = g_malloc(number_of_surfaces * sizeof(int));
179 nb_points = g_malloc(number_of_surfaces * sizeof(int));
180
181 for(i=0; i<number_of_surfaces; i++)
182 {
183 int j;
184
185 do
186 {
187 last_op_status =
188 g_io_channel_read_line_string (file_to_parse, line, &terminator_pos, NULL);
189 if(last_op_status != G_IO_STATUS_NORMAL)
190 return FALSE;
191 }
192 while (line->str[0] == '#');
193
194 surf_names[i] = g_strdup(line->str);
195 g_strdelimit(surf_names[i], "\n", ' ');
196 g_strstrip(surf_names[i]);
197
198 last_op_status =
199 g_io_channel_read_line_string (file_to_parse, line, &terminator_pos, NULL);
200 if(last_op_status != G_IO_STATUS_NORMAL ||
201 sscanf(line->str, "%d %d", &nb_vertex[i], &nb_points[i]) != 2)
202 return FALSE;
203
204 for(j=0; j<(nb_vertex[i]+nb_points[i]); j++)
205 {
206 last_op_status =
207 g_io_channel_read_line_string (file_to_parse, line, &terminator_pos, NULL);
208 if(last_op_status != G_IO_STATUS_NORMAL)
209 return FALSE;
210 }
211 }
212
213 gtk_list_store_clear(list_store);
214
215 for(i=0; i<6; i++)
216 {
217 sprintf(float_to_string, "%f", ddd[i]);
218 gtk_entry_set_text(GTK_ENTRY(surfmerge_source_ddd[i]), float_to_string);
219
220 ddd_are_null = ddd_are_null
221 && (atof(gtk_entry_get_text(GTK_ENTRY(surfmerge_target_ddd[i]))) == 0.);
222 ddd_are_equal = ddd_are_equal
223 && (atof(gtk_entry_get_text(GTK_ENTRY(surfmerge_target_ddd[i]))) == ddd[i]);
224 }
225 if(ddd_are_null)
226 for(i=0; i<6; i++)
227 gtk_entry_set_text(GTK_ENTRY(surfmerge_target_ddd[i]),
228 gtk_entry_get_text(GTK_ENTRY(surfmerge_source_ddd[i])));
229 else if(!ddd_are_equal)
230 {
231 GtkWidget* choice =
232 gtk_dialog_new_with_buttons(_("Found different dxx, ..., dzz"),
233 GTK_WINDOW(convert_window), GTK_DIALOG_MODAL,
234 TOOL_ICON_CANCEL, GTK_RESPONSE_CANCEL,
235 _("Keep current values"), GTK_RESPONSE_YES,
236 _("Change values to new ones"), GTK_RESPONSE_NO, NULL);
237
238 gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(choice))),
239 gtk_label_new(_("Current dxx, ..., dzz, doesn't match the ones used in the "
240 "file you are trying to load. Do you want to keep old "
241 "dxx, ..., dzz ? (if you don't know exactly what you're doing, "
242 "just cancel and load another file)")),
243 TRUE, TRUE, 0);
244 gtk_widget_show_all(choice);
245 switch(gtk_dialog_run (GTK_DIALOG (choice)))
246 {
247 case GTK_RESPONSE_CANCEL:
248 gtk_widget_destroy(choice);
249 return FALSE;
250 break;
251 case GTK_RESPONSE_NO:
252 for(i=0; i<6; i++)
253 gtk_entry_set_text(GTK_ENTRY(surfmerge_target_ddd[i]),
254 gtk_entry_get_text(GTK_ENTRY(surfmerge_source_ddd[i])));
255 gtk_widget_destroy(choice);
256 break;
257 case GTK_RESPONSE_YES:
258 default:
259 gtk_widget_destroy(choice);
260 break;
261 }
262 }
263
264 for(i=0; i<number_of_surfaces; i++)
265 {
266 GtkTreeIter iter;
267 gtk_list_store_insert(list_store, &iter, i);
268 gtk_list_store_set(list_store, &iter,
269 MERGE_SURF_NAME, surf_names[i],
270 MERGE_NB_VERTEX, nb_vertex[i],
271 MERGE_NB_POINTS, nb_points[i], -1);
272 g_free(surf_names[i]);
273 }
274
275 g_io_channel_unref(file_to_parse);
276 return TRUE;
277 }
278
279 /* Opens a file chooser asking the user to select a surf file and then parses
280 this file using surf_simply_parse_file(). If info can be retrieved from the selected
281 file, set the correspondig entry to selected file. */
surf_open_file_chooser()282 void surf_open_file_chooser()
283 {
284 GtkFileFilter *filter_surf = gtk_file_filter_new();
285 GtkFileFilter *filter_none = gtk_file_filter_new();
286 GtkWidget* file_chooser =
287 gtk_file_chooser_dialog_new("Open .surf file", GTK_WINDOW(convert_window),
288 GTK_FILE_CHOOSER_ACTION_OPEN,
289 TOOL_ICON_CANCEL, GTK_RESPONSE_CANCEL,
290 TOOL_ICON_OPEN, GTK_RESPONSE_ACCEPT,
291 NULL);
292 const gchar *directory = visu_ui_main_getLastOpenDirectory(visu_ui_main_class_getCurrentPanel());
293
294 if (directory)
295 gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(file_chooser), directory);
296
297 gtk_file_filter_add_pattern(filter_surf, "*.surf");
298 gtk_file_filter_set_name(filter_surf, "Isosurfaces files (*.surf)");
299 gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(file_chooser), filter_surf);
300
301 gtk_file_filter_add_pattern(filter_none, "*");
302 gtk_file_filter_set_name(filter_none, "All files");
303 gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(file_chooser), filter_none);
304
305 while(1)
306 {
307 gchar *current_file;
308 switch(gtk_dialog_run (GTK_DIALOG (file_chooser)))
309 {
310 case GTK_RESPONSE_ACCEPT:
311 current_file = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (file_chooser));
312 if(surf_simply_parse_file(current_file))
313 {
314 gtk_entry_set_text(GTK_ENTRY(entry_current_file), current_file);
315 gtk_widget_destroy (file_chooser);
316 return;
317 }
318 else
319 {
320 gtk_entry_set_text(GTK_ENTRY(entry_current_file), "");
321 gtk_list_store_clear(list_store);
322 visu_ui_raiseWarning(_("Loading a file"),
323 _("Unable to parse the selected file."),
324 (GtkWindow*)0);
325 }
326 break;
327 case GTK_RESPONSE_CANCEL:
328 default:
329 gtk_widget_destroy (file_chooser);
330 return;
331 }
332 }
333 }
334
335 /* Opens a file chooser asking the user to select a surf file and
336 set the correspondig entry to selected file. */
surfmerge_target_file_chooser(GtkWidget * widget _U_,gpointer data _U_)337 void surfmerge_target_file_chooser(GtkWidget *widget _U_, gpointer data _U_)
338 {
339 GtkFileFilter *filter_surf = gtk_file_filter_new();
340 GtkFileFilter *filter_none = gtk_file_filter_new();
341 GtkWidget* file_chooser =
342 gtk_file_chooser_dialog_new("Save as .surf file", GTK_WINDOW(convert_window),
343 GTK_FILE_CHOOSER_ACTION_SAVE,
344 TOOL_ICON_CANCEL, GTK_RESPONSE_CANCEL,
345 TOOL_ICON_SAVE, GTK_RESPONSE_ACCEPT,
346 NULL);
347 const gchar *directory = visu_ui_main_getLastOpenDirectory(visu_ui_main_class_getCurrentPanel());
348
349 if (directory)
350 gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(file_chooser), directory);
351
352
353 gtk_file_filter_add_pattern(filter_surf, "*.surf");
354 gtk_file_filter_set_name(filter_surf, "Isosurfaces files (*.surf)");
355 gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(file_chooser), filter_surf);
356
357 gtk_file_filter_add_pattern(filter_none, "*");
358 gtk_file_filter_set_name(filter_none, "All files");
359 gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(file_chooser), filter_none);
360
361 while(1)
362 {
363 gchar *target_file;
364 switch(gtk_dialog_run (GTK_DIALOG (file_chooser)))
365 {
366 case GTK_RESPONSE_ACCEPT:
367 target_file = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (file_chooser));
368 gtk_entry_set_text(GTK_ENTRY(entry_target_file), target_file);
369 gtk_widget_destroy (file_chooser);
370 return;
371 break;
372 case GTK_RESPONSE_CANCEL:
373 default:
374 gtk_widget_destroy (file_chooser);
375 return;
376 }
377 }
378 }
379
380 /* Callback for when a user specifies a custom name for a surface.
381 Register the given name as the new name of the surface. */
surfmerge_update_surf_name(GtkCellRendererText * cellrenderertext _U_,gchar * path,gchar * text,gpointer user_data _U_)382 void surfmerge_update_surf_name(GtkCellRendererText *cellrenderertext _U_,
383 gchar *path, gchar *text, gpointer user_data _U_)
384 {
385 GtkTreeIter iter;
386 if(gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(list_store_target),
387 &iter, path))
388 gtk_list_store_set(list_store_target, &iter,
389 MERGE_NEW_SURF_NAME, g_strdelimit(g_strstrip(text), " ", '_'), -1);
390 }
391
392 /* Callback for when a user removes a surface from the list */
surfmerge_remove_surf(GtkWidget * button _U_,gpointer data _U_)393 void surfmerge_remove_surf(GtkWidget *button _U_, gpointer data _U_)
394 {
395 GtkTreeIter iter, iter2;
396 GtkTreeModel *model;
397 GtkTreeSelection* tree_selection =
398 gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view_target));
399 gboolean list_empty = TRUE;
400
401 if (gtk_tree_selection_get_selected (tree_selection, &model, &iter))
402 {
403 iter2 = iter;
404 if(gtk_tree_model_iter_previous(model, &iter2))
405 list_empty = FALSE;
406 if(gtk_list_store_remove(list_store_target, &iter))
407 gtk_tree_selection_select_iter(tree_selection, &iter);
408 else if(list_empty == FALSE)
409 gtk_tree_selection_select_iter(tree_selection, &iter2);
410 }
411 }
412
413
414 /* Callback for when a user decides to move up or down a surface.
415 data == GINT_TO_POINTER(1) : move up
416 data == GINT_TO_POINTER(-1) : move down
417 */
surfmerge_move_surf(GtkWidget * button _U_,gpointer data)418 void surfmerge_move_surf(GtkWidget *button _U_, gpointer data)
419 {
420 GtkTreeIter iter, iter2;
421 GtkTreeModel *model;
422 int direction;
423
424 GtkTreeSelection* tree_selection =
425 gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view_target));
426
427 if(data == NULL)
428 return;
429
430 direction = GPOINTER_TO_INT(data);
431 if(direction != -1 && direction != 1)
432 return;
433
434 if(!gtk_tree_selection_get_selected(tree_selection, &model, &iter))
435 return;
436
437 iter2 = iter;
438 if(direction == 1)
439 {
440 if(gtk_tree_model_iter_next(model, &iter2))
441 gtk_list_store_move_after(list_store_target, &iter, &iter2);
442 }
443 else if(direction == -1)
444 {
445 if(gtk_tree_model_iter_previous(model, &iter2))
446 gtk_list_store_move_before(list_store_target, &iter, &iter2);
447 }
448 }
449
450 /* Sets up the model/view used to represent the surfaces present in a file,
451 as well as the surfaces the user wants to put in the files he builds. */
surf_create_tree_views()452 void surf_create_tree_views()
453 {
454 GtkCellRenderer* surf_name = gtk_cell_renderer_text_new ();
455 GtkTreeViewColumn* column = NULL;
456 GtkTreeSelection *tree_selection;
457
458 list_store_target =
459 gtk_list_store_new (MERGE_N_COLUMNS, G_TYPE_STRING, G_TYPE_INT,
460 G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
461 list_store =
462 gtk_list_store_new (MERGE_N_COLUMNS -3, G_TYPE_STRING, G_TYPE_INT,
463 G_TYPE_INT/*, G_TYPE_STRING*/);
464 g_object_set(G_OBJECT(surf_name), "editable", TRUE, NULL);
465
466 tree_view_source = gtk_tree_view_new_with_model(GTK_TREE_MODEL(list_store));
467 tree_selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view_source));
468 gtk_tree_selection_set_mode(tree_selection, GTK_SELECTION_MULTIPLE);
469
470 column =
471 gtk_tree_view_column_new_with_attributes(_("Surface name"), gtk_cell_renderer_text_new(),
472 "text", MERGE_SURF_NAME, NULL);
473 gtk_tree_view_column_set_expand(column, TRUE);
474 gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view_source), column);
475
476 /* column = */
477 /* gtk_tree_view_column_new_with_attributes(_("n points"), gtk_cell_renderer_text_new(), */
478 /* "text", MERGE_NB_POINTS, NULL); */
479 /* gtk_tree_view_column_set_expand(column, FALSE); */
480 /* gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view_source), column); */
481
482 /* column = */
483 /* gtk_tree_view_column_new_with_attributes(_("n vertex"), gtk_cell_renderer_text_new(), */
484 /* "text", MERGE_NB_VERTEX, NULL); */
485 /* gtk_tree_view_column_set_expand(column, FALSE); */
486 /* gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view_source), column); */
487
488 g_signal_connect(G_OBJECT(tree_view_source), "row_activated", surf_add_surf_to_target, NULL);
489
490 tree_view_target = gtk_tree_view_new_with_model(GTK_TREE_MODEL(list_store_target));
491
492 column =
493 gtk_tree_view_column_new_with_attributes(_("New name"), surf_name,
494 "text", MERGE_NEW_SURF_NAME, NULL);
495 gtk_tree_view_column_set_expand(column, TRUE);
496 gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view_target), column);
497
498 g_signal_connect(G_OBJECT(surf_name), "edited",
499 G_CALLBACK(surfmerge_update_surf_name), NULL);
500 column =
501 gtk_tree_view_column_new_with_attributes(_("old name"), gtk_cell_renderer_text_new(),
502 "text", MERGE_SURF_NAME, NULL);
503 gtk_tree_view_column_set_expand(column, TRUE);
504 gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view_target), column);
505
506 column =
507 gtk_tree_view_column_new_with_attributes(_("from file"), gtk_cell_renderer_text_new(),
508 "text", MERGE_SHORT_FILENAME, NULL);
509 gtk_tree_view_column_set_expand(column, TRUE);
510 gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view_target), column);
511
512 /* column = */
513 /* gtk_tree_view_column_new_with_attributes(_("n points"), gtk_cell_renderer_text_new(), */
514 /* "text", MERGE_NB_POINTS, NULL); */
515 /* gtk_tree_view_column_set_expand(column, FALSE); */
516 /* gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view_target), column); */
517
518 /* column= */
519 /* gtk_tree_view_column_new_with_attributes(_("n vertex"), gtk_cell_renderer_text_new(), */
520 /* "text", MERGE_NB_VERTEX, NULL); */
521 /* gtk_tree_view_column_set_expand(column, FALSE); */
522 /* gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view_target), column); */
523
524
525
526 }
527
528 /* Adds selected source isosurface to the list of isosurfaces to put in the file to create. */
surf_add_surf_to_target()529 void surf_add_surf_to_target()
530 {
531 GtkTreeIter iter_source, iter_target, iter_target_new;
532 GtkTreeModel *model_source, *model_target;
533 GtkTreeSelection* tree_selection_source =
534 gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view_source));
535 GtkTreeSelection* tree_selection_target =
536 gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view_target));
537 char *surf_name;
538 char *short_filename;
539 int nb_points, nb_vertex;
540 GList *rows_start, *rows_browse;
541
542 rows_browse = rows_start = gtk_tree_selection_get_selected_rows(tree_selection_source,
543 &model_source);
544
545 while(rows_browse != NULL)
546 {
547 if(!gtk_tree_model_get_iter(model_source, &iter_source, rows_browse->data))
548 break;
549 if(gtk_tree_selection_get_selected(tree_selection_target, &model_target, &iter_target))
550 {
551 gtk_list_store_insert_after(list_store_target, &iter_target_new, &iter_target);
552 gtk_tree_selection_select_iter(tree_selection_target, &iter_target_new);
553 }
554 else
555 {
556 iter_target_new = iter_target;
557 gtk_list_store_append(list_store_target, &iter_target_new);
558 }
559
560 gtk_tree_model_get(GTK_TREE_MODEL(list_store), &iter_source,
561 MERGE_SURF_NAME, &surf_name,
562 MERGE_NB_POINTS, &nb_points,
563 MERGE_NB_VERTEX, &nb_vertex, -1);
564 short_filename = g_path_get_basename(gtk_entry_get_text(GTK_ENTRY(entry_current_file)));
565 g_strdelimit(surf_name, " ", '_');
566 gtk_list_store_set(list_store_target, &iter_target_new,
567 MERGE_SURF_NAME, surf_name,
568 MERGE_NB_POINTS, nb_points,
569 MERGE_NB_VERTEX, nb_vertex,
570 MERGE_FILENAME, gtk_entry_get_text(GTK_ENTRY(entry_current_file)),
571 MERGE_NEW_SURF_NAME, surf_name,
572 MERGE_SHORT_FILENAME, short_filename, -1);
573 g_free(surf_name);
574 g_free(short_filename);
575 gtk_tree_path_free(rows_browse->data);
576 rows_browse = rows_browse->next;
577 }
578
579 g_list_free(rows_start);
580 }
581
582 /* Only used with a gtk_tree_model_foreach()
583 Used to count the total of surfaces, nb_vertex, and nb_points to build a correct .surf file. */
surfmerge_init_export(GtkTreeModel * model,GtkTreePath * path _U_,GtkTreeIter * iter,gpointer data)584 gboolean surfmerge_init_export(GtkTreeModel *model, GtkTreePath *path _U_,
585 GtkTreeIter *iter, gpointer data)
586 {
587 int *total = data;
588 int nb_points;
589 int nb_vertex;
590
591 gtk_tree_model_get(GTK_TREE_MODEL(model), iter,
592 MERGE_NB_POINTS, &nb_points,
593 MERGE_NB_VERTEX, &nb_vertex, -1);
594
595 total[0]++;
596 total[1] += nb_vertex;
597 total[2] += nb_points;
598
599 return FALSE;
600 }
601
602 /* Only used with a gtk_tree_model_foreach()
603 Used to write a surface in the file the user wants to write. */
surf_export_surf(GtkTreeModel * model,GtkTreePath * path _U_,GtkTreeIter * iter,gpointer data)604 gboolean surf_export_surf(GtkTreeModel *model, GtkTreePath *path _U_,
605 GtkTreeIter *iter, gpointer data)
606 {
607 FILE *file_to_write = data;
608 gchar *old_surf_name;
609 gchar * file_name;
610 gchar * surf_name;
611 int nb_vertex, nb_points, i, j;
612 GIOChannel* file_to_read;
613 gsize terminator_pos;
614 GString *line = g_string_new("");
615 int last_op_status;
616
617 gtk_tree_model_get(GTK_TREE_MODEL(model), iter,
618 MERGE_SURF_NAME, &old_surf_name,
619 MERGE_FILENAME, &file_name,
620 MERGE_NEW_SURF_NAME, &surf_name,
621 MERGE_NB_VERTEX, &nb_vertex,
622 MERGE_NB_POINTS, &nb_points, -1);
623
624 file_to_read = g_io_channel_new_file(file_name, "r", NULL);
625
626 DBG_fprintf(stderr, "Surface Merger : writing surface '%s' info \n", surf_name);
627
628 for(i=0; i<4; i++)
629 {
630 last_op_status =
631 g_io_channel_read_line_string (file_to_read, line, &terminator_pos, NULL);
632 if(last_op_status != G_IO_STATUS_NORMAL)
633 {
634 g_free(file_name);
635 g_free(surf_name);
636 g_free(old_surf_name);
637 g_string_free(line, TRUE);
638 g_io_channel_unref(file_to_read);
639 visu_ui_raiseWarning(_("Loading a file"),
640 _("An unknown error occured. Your surf"
641 " file is corrupted.\n"), (GtkWindow*)0);
642 return TRUE;
643 }
644 }
645
646 for(i=0; i>-1; i++)
647 {
648 gchar *cur_surf_name;
649 int surf_nb_vertex, surf_nb_points;
650 last_op_status =
651 g_io_channel_read_line_string (file_to_read, line, &terminator_pos, NULL);
652 if(last_op_status != G_IO_STATUS_NORMAL)
653 {
654 g_free(file_name);
655 g_free(surf_name);
656 g_free(old_surf_name);
657 g_string_free(line, TRUE);
658 g_io_channel_unref(file_to_read);
659 visu_ui_raiseWarning(_("Loading a file"),
660 _("An unknown error occured. Your surf"
661 " file is corrupted.\n"), (GtkWindow*)0);
662 return TRUE;
663 }
664 cur_surf_name = g_strdup(line->str);
665 g_strdelimit(cur_surf_name, "\n", ' ');
666 g_strstrip(cur_surf_name);
667
668 DBG_fprintf(stderr, "%s, old:%s\n", cur_surf_name, old_surf_name);
669 if(strcmp(cur_surf_name, old_surf_name) == 0)
670 fprintf(file_to_write, "%s\n", surf_name);
671
672 last_op_status =
673 g_io_channel_read_line_string (file_to_read, line, &terminator_pos, NULL);
674 if(last_op_status != G_IO_STATUS_NORMAL ||
675 sscanf(line->str, "%d %d", &surf_nb_vertex, &surf_nb_points) != 2)
676 {
677 g_free(file_name);
678 g_free(surf_name);
679 g_free(old_surf_name);
680 g_string_free(line, TRUE);
681 g_io_channel_unref(file_to_read);
682 visu_ui_raiseWarning(_("Loading a file"),
683 _("An unknown error occured. Your surf"
684 " file is corrupted.\n"), (GtkWindow*)0);
685 return TRUE;
686 }
687 DBG_fprintf(stderr, "%s, old:%s\n", cur_surf_name, old_surf_name);
688 if(strcmp(cur_surf_name, old_surf_name) == 0)
689 fprintf(file_to_write, "%s", line->str);
690
691 for(j=0; j<(surf_nb_vertex+surf_nb_points); j++)
692 {
693 last_op_status =
694 g_io_channel_read_line_string (file_to_read, line, &terminator_pos, NULL);
695 if(last_op_status != G_IO_STATUS_NORMAL)
696 {
697 g_free(file_name);
698 g_free(surf_name);
699 g_free(old_surf_name);
700 g_string_free(line, TRUE);
701 g_io_channel_unref(file_to_read);
702 visu_ui_raiseWarning(_("Loading a file"),
703 _("An unknown error occured. Your surf"
704 " file is corrupted.\n"), (GtkWindow*)0);
705 return TRUE;
706 }
707 if(strcmp(cur_surf_name, old_surf_name) == 0)
708 fprintf(file_to_write, "%s", line->str);
709 }
710 DBG_fprintf(stderr, "%s, old:%s\n", cur_surf_name, old_surf_name);
711 if(strcmp(cur_surf_name, old_surf_name) == 0)
712 {
713 g_free(cur_surf_name);
714 break;
715 }
716 g_free(cur_surf_name);
717 DBG_fprintf(stderr, "%s, old:%s\n", cur_surf_name, old_surf_name);
718 }
719 g_free(file_name);
720 g_free(old_surf_name);
721 g_free(surf_name);
722 g_string_free(line, TRUE);
723 g_io_channel_unref(file_to_read);
724 return FALSE;
725 }
726
727 /* If all parameters are correctly set, tries to write a valid .surf file
728 from the surfaces selected by the user. */
surf_gogogo()729 void surf_gogogo()
730 {
731 FILE* file_to_write = fopen(gtk_entry_get_text(GTK_ENTRY(entry_target_file)), "wb");
732 int i;
733 int total[3];
734
735 if(file_to_write == NULL)
736 {
737 visu_ui_raiseWarning(_("Saving a file"),
738 _("Please choose a surf file to write\n"), (GtkWindow*)0);
739 return;
740 }
741
742 for(i=0; i<3; i++)
743 total[i] = 0;
744
745 gtk_tree_model_foreach(GTK_TREE_MODEL(list_store_target),
746 surfmerge_init_export, total);
747
748 if(total[0] == 0)
749 {
750 visu_ui_raiseWarning(_("Saving a file"),
751 _("No surface to write\n"), (GtkWindow*)0);
752 return;
753 }
754
755
756 if(fprintf(file_to_write, "surf file generated by v_sim's merger\n") < 0)
757 return;
758
759 for(i=0; i<6; i++)
760 {
761 if(fprintf(file_to_write, "%s ",
762 gtk_entry_get_text(GTK_ENTRY(surfmerge_target_ddd[i]))) < 0)
763 return;
764 if((i+1)%3==0)
765 if(fprintf(file_to_write, "\n") < 0)
766 return;
767 }
768
769
770 if(fprintf(file_to_write, "%d %d %d\n", total[0], total[1], total[2]) < 0)
771 return;
772
773 gtk_tree_model_foreach(GTK_TREE_MODEL(list_store_target),
774 surf_export_surf, file_to_write);
775
776 fclose(file_to_write);
777
778 DBG_fprintf(stderr, "Surface Merger : wrote file %s\n",
779 gtk_entry_get_text(GTK_ENTRY(entry_target_file)));
780 }
781
782 /* See header file for more info */
visu_ui_panel_surfaces_tools_fileWidget()783 GtkWidget *visu_ui_panel_surfaces_tools_fileWidget()
784 {
785 enum { DXX, DYX, DYY, DZX, DZY, DZZ };
786 #if GTK_MAJOR_VERSION == 2 && GTK_MINOR_VERSION < 12
787 GtkTooltips *tooltips = gtk_tooltips_new ();
788 #endif
789 GtkWidget* scrolled_window_top = gtk_scrolled_window_new(NULL, NULL);
790 GtkWidget* scrolled_window_bot = gtk_scrolled_window_new(NULL, NULL);
791 GtkWidget *global_vbox = gtk_vbox_new(FALSE, 0);
792 GtkWidget *hbox1 = gtk_hbox_new(FALSE, 0);
793 GtkWidget *hbox_top_ddd = gtk_hbox_new(FALSE, 2);
794 GtkWidget *hbox_top_ddd2 = gtk_hbox_new(FALSE, 2);
795 GtkWidget *hbox_bot_ddd = gtk_hbox_new(FALSE, 2);
796 GtkWidget *hbox_bot_ddd2 = gtk_hbox_new(FALSE, 2);
797 GtkWidget *hbox_go = gtk_hbox_new(FALSE, 0);
798 GtkWidget *bottom_frame = gtk_frame_new(_("Target info : "));
799 GtkWidget *top_frame = gtk_frame_new(_("Source info : "));
800 GtkWidget *vbox = gtk_vbox_new(FALSE, 2);
801 GtkWidget *vbox_r = gtk_vbox_new(FALSE, 2);
802 GtkWidget *add_surf_button = gtk_button_new();
803 GtkWidget *go_button = gtk_button_new_with_label("Build");
804 GtkWidget *save_file = gtk_button_new();
805 GtkWidget *hbox_target_file = gtk_hbox_new(FALSE, 0);
806 char *ddd[] = {"dxx :", "dyx :", "dyy :",
807 "dzx :", "dzy :", "dzz :"};
808 GtkWidget *label;
809 GtkWidget *remove_surf_button = gtk_button_new();
810 GtkWidget *move_down_surf_button = gtk_button_new();
811 GtkWidget *move_up_surf_button = gtk_button_new();
812 int i;
813 GtkWidget *open_file = gtk_button_new();
814 GtkWidget *manage_top_tview_vbox = gtk_vbox_new(FALSE, 0);
815 GtkWidget *manage_bot_tview_vbox = gtk_vbox_new(FALSE, 0);
816 GtkWidget *top_tview_hbox = gtk_hbox_new(FALSE, 0);
817 GtkWidget *bot_tview_hbox = gtk_hbox_new(FALSE, 0);
818 GtkWidget *image_add = gtk_image_new_from_icon_name("list-add", GTK_ICON_SIZE_BUTTON);
819 GtkWidget *image_remove = gtk_image_new_from_icon_name("list-remove", GTK_ICON_SIZE_BUTTON);
820 GtkWidget *image_go_down = gtk_image_new_from_icon_name("go-down", GTK_ICON_SIZE_BUTTON);
821 GtkWidget *image_go_up = gtk_image_new_from_icon_name("go-up", GTK_ICON_SIZE_BUTTON);
822 GtkWidget *image_open = gtk_image_new_from_icon_name("document-open", GTK_ICON_SIZE_BUTTON);
823
824 entry_current_file = gtk_entry_new();
825 entry_target_file = gtk_entry_new();
826
827 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window_top),
828 GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
829 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window_bot),
830 GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
831
832 gtk_container_add (GTK_CONTAINER (add_surf_button), image_add);
833 gtk_container_add (GTK_CONTAINER (remove_surf_button), image_remove);
834 gtk_container_add (GTK_CONTAINER (move_down_surf_button), image_go_down);
835 gtk_container_add (GTK_CONTAINER (move_up_surf_button), image_go_up);
836 gtk_container_add (GTK_CONTAINER (open_file), image_open);
837 image_open = gtk_image_new_from_icon_name("document-open", GTK_ICON_SIZE_BUTTON);
838 gtk_container_add (GTK_CONTAINER (save_file), image_open);
839
840 gtk_widget_set_tooltip_text(go_button,
841 _("Build specified new .surf file"));
842 gtk_widget_set_tooltip_text(entry_current_file,
843 _("Contains the full path to the currently .surf selected file"));
844 gtk_widget_set_tooltip_text(entry_target_file,
845 _("Contains the full path to the .surf file you want to build"));
846 gtk_widget_set_tooltip_text(open_file,
847 _("Allows you to select a .surf file"));
848 gtk_widget_set_tooltip_text(save_file,
849 _("Selects the .surf file to write"));
850 gtk_widget_set_tooltip_text(add_surf_button,
851 _("Moves selected surface to the list of surfaces to build"));
852 gtk_widget_set_tooltip_text(move_down_surf_button,
853 _("Moves down selected surface in the list of surfaces to build"));
854 gtk_widget_set_tooltip_text(move_up_surf_button,
855 _("Moves up selected surface in the list of surfaces to build"));
856 gtk_widget_set_tooltip_text(remove_surf_button,
857 _("Removes selected surface from the list of surfaces to build"));
858
859 for(i=0; i<6; i++)
860 {
861 surfmerge_source_ddd[i] = gtk_entry_new();
862 gtk_entry_set_text(GTK_ENTRY(surfmerge_source_ddd[i]), "0.0000000");
863 g_object_set(G_OBJECT(surfmerge_source_ddd[i]), "width-chars", 9, NULL);
864 gtk_editable_set_editable(GTK_EDITABLE(surfmerge_source_ddd[i]), FALSE);
865 gtk_widget_set_tooltip_text(surfmerge_source_ddd[i],
866 _("The d__ of the current selected file"));
867 }
868
869 for(i=0; i<6; i++)
870 {
871 surfmerge_target_ddd[i] = gtk_entry_new();
872 gtk_entry_set_text(GTK_ENTRY(surfmerge_target_ddd[i]), "0.0000000");
873 g_object_set(G_OBJECT(surfmerge_target_ddd[i]), "width-chars", 9, NULL);
874 gtk_widget_set_tooltip_text(surfmerge_target_ddd[i],
875 _("The d__ of the file to build"));
876 }
877
878 surf_create_tree_views();
879
880 gtk_box_pack_start(GTK_BOX(global_vbox), top_frame, TRUE, TRUE, 0);
881 gtk_box_pack_start(GTK_BOX(global_vbox), bottom_frame, TRUE, TRUE, 0);
882
883 gtk_container_add(GTK_CONTAINER(top_frame), vbox);
884 gtk_container_add(GTK_CONTAINER(scrolled_window_top), tree_view_source);
885
886 gtk_box_pack_start(GTK_BOX(vbox), hbox1, FALSE, FALSE, 0);
887 gtk_box_pack_start(GTK_BOX(vbox), hbox_top_ddd, FALSE, FALSE, 0);
888 gtk_box_pack_start(GTK_BOX(vbox), hbox_top_ddd2, FALSE, FALSE, 0);
889
890 gtk_box_pack_start(GTK_BOX(vbox), top_tview_hbox, TRUE, TRUE, 0);
891
892 gtk_box_pack_start(GTK_BOX(hbox1), gtk_label_new(_("Current file : ")), FALSE, FALSE, 0);
893 gtk_box_pack_start(GTK_BOX(hbox1), entry_current_file, TRUE, TRUE, 0);
894 gtk_box_pack_start(GTK_BOX(hbox1), open_file, FALSE, FALSE, 0);
895
896 for(i=0; i<3; i++)
897 {
898 label = gtk_label_new(ddd[i]);
899 gtk_label_set_xalign(GTK_LABEL(label), 1.);
900 gtk_box_pack_start(GTK_BOX(hbox_top_ddd), label, i==0 ? FALSE : TRUE, TRUE, 0);
901 gtk_box_pack_start(GTK_BOX(hbox_top_ddd), surfmerge_source_ddd[i], FALSE, FALSE, 0);
902 }
903
904 for(i=3; i<6; i++)
905 {
906 label = gtk_label_new(ddd[i]);
907 gtk_label_set_xalign(GTK_LABEL(label), 1.);
908 gtk_box_pack_start(GTK_BOX(hbox_top_ddd2), label, i==3 ? FALSE : TRUE, TRUE, 0);
909 gtk_box_pack_start(GTK_BOX(hbox_top_ddd2), surfmerge_source_ddd[i], FALSE, FALSE, 0);
910 }
911
912 gtk_box_pack_start(GTK_BOX(top_tview_hbox), scrolled_window_top, TRUE, TRUE, 0);
913 gtk_box_pack_start(GTK_BOX(top_tview_hbox), manage_top_tview_vbox, FALSE, FALSE, 0);
914
915 gtk_box_pack_start(GTK_BOX(manage_top_tview_vbox), add_surf_button, TRUE, FALSE, 0);
916
917 gtk_container_add(GTK_CONTAINER(bottom_frame), vbox_r);
918 gtk_container_add(GTK_CONTAINER(scrolled_window_bot), tree_view_target);
919
920 gtk_box_pack_start(GTK_BOX(vbox_r), hbox_bot_ddd, FALSE, FALSE, 0);
921 gtk_box_pack_start(GTK_BOX(vbox_r), hbox_bot_ddd2, FALSE, FALSE, 0);
922 gtk_box_pack_start(GTK_BOX(vbox_r), bot_tview_hbox, TRUE, TRUE, 0);
923 gtk_box_pack_start(GTK_BOX(vbox_r), hbox_target_file, FALSE, FALSE, 0);
924 gtk_box_pack_start(GTK_BOX(vbox_r), hbox_go, FALSE, FALSE, 0);
925
926 for(i=0; i<3; i++)
927 {
928 label = gtk_label_new(ddd[i]);
929 gtk_label_set_xalign(GTK_LABEL(label), 1.);
930 gtk_box_pack_start(GTK_BOX(hbox_bot_ddd), label, i==0 ? FALSE : TRUE, TRUE, 0);
931 gtk_box_pack_start(GTK_BOX(hbox_bot_ddd), surfmerge_target_ddd[i], FALSE, FALSE, 0);
932 }
933
934 for(i=3; i<6; i++)
935 {
936 label = gtk_label_new(ddd[i]);
937 gtk_label_set_xalign(GTK_LABEL(label), 1.);
938 gtk_box_pack_start(GTK_BOX(hbox_bot_ddd2), label, i==3 ? FALSE : TRUE, TRUE, 0);
939 gtk_box_pack_start(GTK_BOX(hbox_bot_ddd2), surfmerge_target_ddd[i], FALSE, FALSE, 0);
940 }
941
942 gtk_box_pack_start(GTK_BOX(bot_tview_hbox), scrolled_window_bot, TRUE, TRUE, 0);
943 gtk_box_pack_start(GTK_BOX(bot_tview_hbox), manage_bot_tview_vbox, FALSE, FALSE, 0);
944
945 gtk_box_pack_start(GTK_BOX(manage_bot_tview_vbox), remove_surf_button, FALSE, FALSE, 0);
946 gtk_box_pack_end(GTK_BOX(manage_bot_tview_vbox), move_down_surf_button, FALSE, FALSE, 0);
947 gtk_box_pack_end(GTK_BOX(manage_bot_tview_vbox), move_up_surf_button, FALSE, FALSE, 0);
948
949 gtk_box_pack_start(GTK_BOX(hbox_target_file), gtk_label_new(_("Target file : ")), FALSE, FALSE, 0);
950 gtk_box_pack_start(GTK_BOX(hbox_target_file), entry_target_file, TRUE, TRUE, 0);
951 gtk_box_pack_start(GTK_BOX(hbox_target_file), save_file, FALSE, FALSE, 0);
952
953 gtk_box_pack_end(GTK_BOX(hbox_go), go_button, FALSE, FALSE, 0);
954
955 /* Signal connexion */
956 g_signal_connect(G_OBJECT(open_file), "clicked",
957 G_CALLBACK(surf_open_file_chooser), entry_current_file);
958 g_signal_connect(G_OBJECT(add_surf_button), "clicked",
959 G_CALLBACK(surf_add_surf_to_target), NULL);
960 g_signal_connect(G_OBJECT(go_button), "clicked",
961 G_CALLBACK(surf_gogogo), NULL);
962 g_signal_connect(G_OBJECT(remove_surf_button), "clicked",
963 G_CALLBACK(surfmerge_remove_surf), NULL);
964 g_signal_connect(G_OBJECT(move_up_surf_button), "clicked",
965 G_CALLBACK(surfmerge_move_surf), GINT_TO_POINTER(-1));
966 g_signal_connect(G_OBJECT(move_down_surf_button), "clicked",
967 G_CALLBACK(surfmerge_move_surf), GINT_TO_POINTER(1));
968 g_signal_connect(G_OBJECT(save_file), "clicked",
969 G_CALLBACK(surfmerge_target_file_chooser), NULL);
970
971 return global_vbox;
972 }
973
974 /*****************************************************************************/
975 /* */
976 /* POT2SURF */
977 /* */
978 /*****************************************************************************/
979
980 static GtkListStore *pot2surf_list_store = NULL;
981 static GtkWidget *pot2surf_tree_view = NULL;
982
983 static GtkWidget *pot2surf_entry_source_pot_file = NULL;
984 static GtkWidget *pot2surf_entry_target_surf_file = NULL;
985
986 static GtkWidget *pot2surf_potmax = NULL;
987 static GtkWidget *pot2surf_potmin = NULL;
988
989 enum {
990 POT2SURF_NAME,
991 POT2SURF_VALUE,
992 POT2SURF_N_COLUMNS
993 };
994
995 /* Pops up a window containing info about the pot2surf routine
996 Currently unused. */
pot2surf_popup_help()997 void pot2surf_popup_help()
998 {
999 GtkWidget *window;
1000 gsize length;
1001 gchar *text = NULL;
1002 GtkTextBuffer *text_buf;
1003 GtkWidget *text_view;
1004 GtkWidget *scrolled_window;
1005 gchar *chemin = g_build_filename(V_SIM_LEGAL_DIR, "pot2surf_help", NULL);
1006
1007 if(!g_file_get_contents(chemin, &text, &length, (GError**)0))
1008 {
1009 g_free(chemin);
1010 return;
1011 }
1012 g_free(chemin);
1013
1014 text_buf = gtk_text_buffer_new(NULL);
1015 text_view = gtk_text_view_new_with_buffer(text_buf);
1016 scrolled_window = gtk_scrolled_window_new(NULL, NULL);
1017
1018 gtk_text_buffer_insert_at_cursor(text_buf, text, -1);
1019 g_free(text);
1020
1021 /* Create a new dialog window for the scrolled window to be
1022 * packed into. */
1023 window = gtk_dialog_new_with_buttons(_("pot2surf_help"), NULL, 0,
1024 TOOL_ICON_OPEN, GTK_RESPONSE_ACCEPT, NULL);
1025 gtk_container_set_border_width (GTK_CONTAINER (window), 0);
1026 gtk_widget_set_size_request (window, 600, 300);
1027
1028 /* create a new scrolled window. */
1029 scrolled_window = gtk_scrolled_window_new (NULL, NULL);
1030 gtk_container_set_border_width (GTK_CONTAINER (scrolled_window), 10);
1031 gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
1032 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1033
1034 /* The dialog window is created with a vbox packed into it. */
1035 gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(window))),
1036 scrolled_window, TRUE, TRUE, 0);
1037
1038 #if GTK_MAJOR_VERSION < 3 || (GTK_MAJOR_VERSION == 3 && GTK_MINOR_VERSION < 8)
1039 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW (scrolled_window),
1040 text_view);
1041 #else
1042 gtk_container_add(GTK_CONTAINER(scrolled_window), text_view);
1043 #endif
1044
1045 gtk_widget_show_all (window);
1046
1047 switch(gtk_dialog_run(GTK_DIALOG(window)))
1048 {
1049 default:
1050 gtk_widget_destroy(window);
1051 }
1052 }
1053
1054 /* Parses target to file to retrieve pot_min and pot_max
1055 Returns TRUE in case of success, FALSE otherwise. */
pot2surf_quick_parse(char * file_name,float * pot_min,float * pot_max)1056 gboolean pot2surf_quick_parse(char *file_name, float *pot_min, float *pot_max)
1057 {
1058 GString *line = g_string_new("");
1059 int last_op_status;
1060 int na, nb, nc;
1061 int i, j;
1062 float current_value;
1063 gsize terminator_pos;
1064 gchar **float_tab;
1065 GIOChannel* file_to_parse = g_io_channel_new_file(file_name, "r", NULL);
1066
1067 if(file_to_parse == NULL)
1068 {
1069 visu_ui_raiseWarning(_("Loading a file"),
1070 _("Can't open given file for reading"), (GtkWindow*)0);
1071 g_io_channel_unref(file_to_parse);
1072 return FALSE;
1073 }
1074
1075 /* Read the first five lines */
1076 for(i=0; i<5; i++)
1077 {
1078 last_op_status =
1079 g_io_channel_read_line_string (file_to_parse, line, &terminator_pos, NULL);
1080 if(last_op_status != G_IO_STATUS_NORMAL)
1081 {
1082 visu_ui_raiseWarning(_("Loading a file"),
1083 _("This file doesn't seem to be a correct pot file"),
1084 (GtkWindow*)0);
1085 g_io_channel_unref(file_to_parse);
1086 return FALSE;
1087 }
1088 if(i==1)
1089 {
1090 sscanf(line->str, "%d %d %d", &na, &nb, &nc);
1091 if(na <= 0 || nb <= 0 || nc <= 0)
1092 {
1093 visu_ui_raiseWarning(_("Loading a file"),
1094 _("Second line seem to contain incorrect values"),
1095 (GtkWindow*)0);
1096 g_io_channel_unref(file_to_parse);
1097 return FALSE;
1098 }
1099 }
1100 }
1101
1102 /* Retrieve pot values to find min & max in the following lines.
1103 According to .pot files specifications, the following lines are in free format */
1104 for(i=0; i<na*nb*nc; )
1105 {
1106 last_op_status =
1107 g_io_channel_read_line_string (file_to_parse, line, &terminator_pos, NULL);
1108 if(last_op_status != G_IO_STATUS_NORMAL)
1109 {
1110 visu_ui_raiseWarning(_("Loading a file"),
1111 _("This file doesn't seem to be a correct pot file"),
1112 (GtkWindow*)0);
1113 g_io_channel_unref(file_to_parse);
1114 return FALSE;
1115 }
1116
1117 float_tab = g_strsplit(line->str, " ", -1);
1118 for(j=0; float_tab[j] != NULL; j++)
1119 {
1120 if(sscanf(float_tab[j], "%f", ¤t_value) == 1)
1121 {
1122 if(i==0) *pot_max = *pot_min = current_value;
1123 else
1124 if(current_value < *pot_min) *pot_min = current_value;
1125 else if(current_value > *pot_max) *pot_max = current_value;
1126 i++;
1127 }
1128 }
1129 g_strfreev(float_tab);
1130
1131 }
1132 g_io_channel_unref(file_to_parse);
1133
1134 return TRUE;
1135 }
1136
1137 /* Opens a file chooser for the user to select a pot file.
1138 This file is parsed using pot2surf_quick_parse() to try to retrieve pot_in and pot_max.
1139 If parsing is successful, set entries to default values (ie : file_selected.surf and
1140 file_selected.instruc) */
pot2surf_select_pot_file(GtkWidget * widget _U_,gpointer data _U_)1141 void pot2surf_select_pot_file(GtkWidget *widget _U_, gpointer data _U_)
1142 {
1143 GtkFileFilter *filter_pot = gtk_file_filter_new();
1144 GtkFileFilter *filter_none = gtk_file_filter_new();
1145 GtkWidget* file_chooser =
1146 gtk_file_chooser_dialog_new("Select a .pot file", GTK_WINDOW(convert_window),
1147 GTK_FILE_CHOOSER_ACTION_OPEN,
1148 TOOL_ICON_CANCEL, GTK_RESPONSE_CANCEL,
1149 /* GTK_STOCK_HELP, GTK_RESPONSE_HELP, */
1150 TOOL_ICON_OPEN, GTK_RESPONSE_ACCEPT, NULL);
1151 const gchar *directory = visu_ui_main_getLastOpenDirectory(visu_ui_main_class_getCurrentPanel());
1152 gchar *dir;
1153
1154 if (directory)
1155 gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(file_chooser), directory);
1156
1157 gtk_file_filter_add_pattern(filter_pot, "*.pot");
1158 gtk_file_filter_add_pattern(filter_pot, "*.dat");
1159 gtk_file_filter_set_name(filter_pot, "Potential files (*.pot, *.dat)");
1160 gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(file_chooser), filter_pot);
1161
1162 gtk_file_filter_add_pattern(filter_none, "*");
1163 gtk_file_filter_set_name(filter_none, "All files");
1164 gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(file_chooser), filter_none);
1165
1166 while(1)
1167 {
1168 switch(gtk_dialog_run(GTK_DIALOG(file_chooser)))
1169 {
1170 float pot_min, pot_max;
1171 char float_to_string[128];
1172 gchar *selected_file;
1173 GString *other_files;
1174 case GTK_RESPONSE_ACCEPT:
1175 selected_file =
1176 gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(file_chooser));
1177
1178 if(pot2surf_quick_parse(selected_file, &pot_min, &pot_max))
1179 {
1180 sprintf(float_to_string, "%f", pot_min);
1181 gtk_entry_set_text(GTK_ENTRY(pot2surf_potmin), float_to_string);
1182 sprintf(float_to_string, "%f", pot_max);
1183 gtk_entry_set_text(GTK_ENTRY(pot2surf_potmax), float_to_string);
1184 gtk_entry_set_text(GTK_ENTRY(pot2surf_entry_source_pot_file), selected_file);
1185
1186 other_files = g_string_new(selected_file);
1187 if(g_str_has_suffix(other_files->str, ".pot"))
1188 g_string_erase(other_files, other_files->len-4, -1);
1189 g_string_append(other_files, ".surf");
1190 gtk_entry_set_text(GTK_ENTRY(pot2surf_entry_target_surf_file), other_files->str);
1191 g_string_free(other_files, TRUE);
1192
1193 dir = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER (file_chooser));
1194 visu_ui_main_setLastOpenDirectory(visu_ui_main_class_getCurrentPanel(),
1195 dir, VISU_UI_DIR_SURFACE);
1196 g_free(dir);
1197 gtk_list_store_clear(pot2surf_list_store);
1198 gtk_widget_destroy(file_chooser);
1199 return;
1200 }
1201 else break;
1202 case GTK_RESPONSE_HELP:
1203 break;
1204 case GTK_RESPONSE_CANCEL:
1205 default:
1206 dir = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER (file_chooser));
1207 visu_ui_main_setLastOpenDirectory(visu_ui_main_class_getCurrentPanel(),
1208 dir, VISU_UI_DIR_SURFACE);
1209 g_free(dir);
1210 gtk_widget_destroy (file_chooser);
1211 return;
1212 }
1213 }
1214 }
1215
1216 /* Opens a file chooser to select an instruc file. */
1217 /* void pot2surf_source_instruc_open(GtkWidget *widget, gpointer data) */
1218 /* { */
1219 /* GtkFileFilter *filter_pot = gtk_file_filter_new (); */
1220 /* GtkFileFilter *filter_none = gtk_file_filter_new(); */
1221 /* GtkWidget* file_chooser = */
1222 /* gtk_file_chooser_dialog_new("Select an instruction file", GTK_WINDOW(convert_window), */
1223 /* GTK_FILE_CHOOSER_ACTION_OPEN, */
1224 /* GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, */
1225 /* /\* GTK_STOCK_HELP, GTK_RESPONSE_HELP, *\/ */
1226 /* GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL); */
1227 /* gchar *directory = visu_ui_getLastOpenDirectory(); */
1228
1229 /* if (directory) */
1230 /* gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(file_chooser), directory); */
1231 /* gtk_file_filter_add_pattern(filter_pot, "*.instruc"); */
1232 /* gtk_file_filter_set_name(filter_pot, "Instruction files (*.instruc)"); */
1233 /* gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(file_chooser), filter_pot); */
1234
1235 /* gtk_file_filter_add_pattern(filter_none, "*"); */
1236 /* gtk_file_filter_set_name(filter_none, "All files"); */
1237 /* gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(file_chooser), filter_none); */
1238
1239 /* while(1) */
1240 /* { */
1241 /* switch(gtk_dialog_run(GTK_DIALOG(file_chooser))) */
1242 /* { */
1243 /* gchar *selected_file; */
1244 /* case GTK_RESPONSE_ACCEPT: */
1245 /* selected_file = */
1246 /* gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(file_chooser)); */
1247 /* gtk_entry_set_text(GTK_ENTRY(pot2surf_entry_source_instruc_file), selected_file); */
1248 /* directory = (char*)gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER (file_chooser)); */
1249 /* visu_ui_setLastOpenDirectory(directory); */
1250 /* g_free(directory); */
1251 /* gtk_widget_destroy(file_chooser); */
1252 /* return; */
1253 /* case GTK_RESPONSE_HELP: */
1254 /* break; */
1255 /* case GTK_RESPONSE_CANCEL: */
1256 /* default: */
1257 /* directory = (char*)gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER (file_chooser)); */
1258 /* visu_ui_setLastOpenDirectory(directory); */
1259 /* g_free(directory); */
1260 /* gtk_widget_destroy (file_chooser); */
1261 /* return; */
1262 /* } */
1263 /* } */
1264 /* } */
1265
1266 /* Opens a file chooser to select a surf file. */
pot2surf_select_surf_file(GtkWidget * widget _U_,gpointer data _U_)1267 void pot2surf_select_surf_file(GtkWidget *widget _U_, gpointer data _U_)
1268 {
1269 GtkFileFilter *filter_pot = gtk_file_filter_new ();
1270 GtkFileFilter *filter_none = gtk_file_filter_new();
1271 GtkWidget* file_chooser =
1272 gtk_file_chooser_dialog_new("Select a .surf file", GTK_WINDOW(convert_window),
1273 GTK_FILE_CHOOSER_ACTION_SAVE,
1274 TOOL_ICON_CANCEL, GTK_RESPONSE_CANCEL,
1275 /* GTK_STOCK_HELP, GTK_RESPONSE_HELP, */
1276 TOOL_ICON_OPEN, GTK_RESPONSE_ACCEPT, NULL);
1277 const gchar *directory = visu_ui_main_getLastOpenDirectory(visu_ui_main_class_getCurrentPanel());
1278 gchar *dir;
1279
1280 if (directory)
1281 gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(file_chooser), directory);
1282
1283 gtk_file_filter_add_pattern(filter_pot, "*.surf");
1284 gtk_file_filter_set_name(filter_pot, "Isosurfaces files (*.surf)");
1285 gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(file_chooser), filter_pot);
1286
1287 gtk_file_filter_add_pattern(filter_none, "*");
1288 gtk_file_filter_set_name(filter_none, "All files");
1289 gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(file_chooser), filter_none);
1290
1291 while(1)
1292 {
1293 switch(gtk_dialog_run(GTK_DIALOG(file_chooser)))
1294 {
1295 gchar *selected_file;
1296
1297 case GTK_RESPONSE_ACCEPT:
1298 selected_file =
1299 gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(file_chooser));
1300 gtk_entry_set_text(GTK_ENTRY(pot2surf_entry_target_surf_file), selected_file);
1301 dir = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER (file_chooser));
1302 visu_ui_main_setLastOpenDirectory(visu_ui_main_class_getCurrentPanel(),
1303 dir, VISU_UI_DIR_SURFACE);
1304 g_free(dir);
1305 gtk_widget_destroy(file_chooser);
1306 return;
1307 case GTK_RESPONSE_HELP:
1308 break;
1309 case GTK_RESPONSE_CANCEL:
1310 default:
1311 dir = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER (file_chooser));
1312 visu_ui_main_setLastOpenDirectory(visu_ui_main_class_getCurrentPanel(),
1313 dir, VISU_UI_DIR_SURFACE);
1314 g_free(dir);
1315 gtk_widget_destroy (file_chooser);
1316 return;
1317 }
1318 }
1319 }
1320
1321 /* Callback for when a surf name is changed in the gtk_tree_view */
pot2surf_update_surf_name(GtkCellRendererText * cellrenderertext _U_,gchar * path,gchar * text,gpointer user_data _U_)1322 void pot2surf_update_surf_name(GtkCellRendererText *cellrenderertext _U_,
1323 gchar *path, gchar *text, gpointer user_data _U_)
1324 {
1325 GtkTreeIter iter;
1326
1327 g_return_if_fail(gtk_tree_model_get_iter_from_string
1328 (GTK_TREE_MODEL(pot2surf_list_store), &iter, path));
1329
1330 DBG_fprintf(stderr, "Panel VisuSurfaceTools: entered text '%s'.\n", text);
1331 if (!strcmp(text, VISU_UI_SURFACE_NAME_STR))
1332 gtk_list_store_set(pot2surf_list_store, &iter,
1333 POT2SURF_NAME, VISU_UI_SURFACE_NAME_CHOOSE, -1);
1334 else if (text && text[0])
1335 gtk_list_store_set(pot2surf_list_store, &iter,
1336 POT2SURF_NAME, g_strdelimit(text, " ", '_'), -1);
1337 else
1338 gtk_list_store_set(pot2surf_list_store, &iter,
1339 POT2SURF_NAME, VISU_UI_SURFACE_NAME_CHOOSE, -1);
1340 }
1341
1342 /* Callback for when the pot of a surf to build is changed in the gtk_tree_view */
pot2surf_update_surf_value(GtkCellRendererText * cellrenderertext _U_,gchar * path,gchar * text,gpointer user_data _U_)1343 void pot2surf_update_surf_value(GtkCellRendererText *cellrenderertext _U_,
1344 gchar *path, gchar *text, gpointer user_data _U_)
1345 {
1346 GtkTreeIter iter;
1347 float value;
1348 float pot_min = atof(gtk_entry_get_text(GTK_ENTRY(pot2surf_potmin)));
1349 float pot_max = atof(gtk_entry_get_text(GTK_ENTRY(pot2surf_potmax)));
1350
1351 if(sscanf(text, "%f", &value) != 1)
1352 return;
1353
1354 if(value <= pot_min || value >= pot_max)
1355 return;
1356
1357 if(gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(pot2surf_list_store),
1358 &iter, path))
1359 gtk_list_store_set(pot2surf_list_store, &iter,
1360 POT2SURF_VALUE, value, -1);
1361 }
1362
1363 /* Sets up the model/view used to represent the surfaces to build from
1364 a .pot file. */
pot2surf_create_tree_view()1365 void pot2surf_create_tree_view()
1366 {
1367 GtkCellRenderer* surf_name = gtk_cell_renderer_text_new ();
1368 GtkCellRenderer* surf_value = gtk_cell_renderer_text_new ();
1369 GtkTreeViewColumn* column1
1370 = gtk_tree_view_column_new_with_attributes(_("Surface name"), surf_name,
1371 "markup", POT2SURF_NAME, NULL);
1372 GtkTreeViewColumn* column2
1373 = gtk_tree_view_column_new_with_attributes(_("Pot value"), surf_value,
1374 "text", POT2SURF_VALUE, NULL);
1375
1376 pot2surf_list_store = gtk_list_store_new (POT2SURF_N_COLUMNS, G_TYPE_STRING, G_TYPE_FLOAT);
1377 pot2surf_tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(pot2surf_list_store));
1378
1379 g_object_set(G_OBJECT(surf_name), "editable", TRUE, "foreground", "blue", NULL);
1380 g_object_set(G_OBJECT(surf_value), "editable", TRUE, "foreground", "blue", NULL);
1381
1382 gtk_tree_view_column_set_expand (column1, TRUE);
1383 gtk_tree_view_column_set_expand(column2, FALSE);
1384 gtk_tree_view_insert_column(GTK_TREE_VIEW(pot2surf_tree_view), column1, -1);
1385 gtk_tree_view_insert_column(GTK_TREE_VIEW(pot2surf_tree_view), column2, -1);
1386
1387 g_signal_connect(G_OBJECT(surf_name), "edited",
1388 G_CALLBACK(pot2surf_update_surf_name), NULL);
1389 g_signal_connect(G_OBJECT(surf_value), "edited",
1390 G_CALLBACK(pot2surf_update_surf_value), NULL);
1391 }
1392
1393 /* Adds a new surface to the list of surfaces to build from a .pot file. */
pot2surf_add_surf(GtkWidget * button _U_,gpointer data _U_)1394 void pot2surf_add_surf(GtkWidget *button _U_, gpointer data _U_)
1395 {
1396 GtkTreeIter iter, new_row;
1397 GtkTreeModel *model;
1398 GtkTreeSelection* tree_selection =
1399 gtk_tree_view_get_selection(GTK_TREE_VIEW(pot2surf_tree_view));
1400
1401 if(strcmp("", gtk_entry_get_text(GTK_ENTRY(pot2surf_entry_source_pot_file))) == 0)
1402 return;
1403
1404 tree_selection =
1405 gtk_tree_view_get_selection(GTK_TREE_VIEW(pot2surf_tree_view));
1406
1407 if (gtk_tree_selection_get_selected (tree_selection, &model, &iter))
1408 gtk_list_store_insert_after(pot2surf_list_store, &new_row, &iter);
1409 else
1410 gtk_list_store_append(pot2surf_list_store, &new_row);
1411
1412 gtk_tree_selection_select_iter(tree_selection, &new_row);
1413 gtk_list_store_set(pot2surf_list_store, &new_row,
1414 POT2SURF_NAME, VISU_UI_SURFACE_NAME_CHOOSE,
1415 POT2SURF_VALUE,
1416 (atof(gtk_entry_get_text(GTK_ENTRY(pot2surf_potmin)))
1417 + atof(gtk_entry_get_text(GTK_ENTRY(pot2surf_potmax)))) / 2, -1);
1418 }
1419
onSpecialModeToggled(GtkToggleButton * button,gpointer data)1420 void onSpecialModeToggled(GtkToggleButton *button, gpointer data)
1421 {
1422 gtk_widget_set_sensitive(GTK_WIDGET(data), gtk_toggle_button_get_active(button));
1423 }
1424
pot2surf_special_add_surf(GtkWidget * button _U_,gpointer data _U_)1425 void pot2surf_special_add_surf(GtkWidget *button _U_, gpointer data _U_)
1426 {
1427 float *values, pot_min, pot_max;
1428 int nbValues, i;
1429 gchar *name;
1430 GtkTreeIter new_row;
1431 GtkTreeSelection* tree_selection =
1432 gtk_tree_view_get_selection(GTK_TREE_VIEW(pot2surf_tree_view));
1433 GtkWidget *dialog;
1434
1435 if(strcmp("", gtk_entry_get_text(GTK_ENTRY(pot2surf_entry_source_pot_file))) == 0)
1436 return;
1437
1438 pot_min = g_ascii_strtod(gtk_entry_get_text(GTK_ENTRY(pot2surf_potmin)), NULL);
1439 pot_max = g_ascii_strtod(gtk_entry_get_text(GTK_ENTRY(pot2surf_potmax)), NULL);
1440
1441 values = (float*)0;
1442 name = (gchar*)0;
1443 dialog = visu_ui_panel_surfaces_generateValues(&nbValues, &values, &name,
1444 pot_min, pot_max);
1445
1446 if (!dialog)
1447 return;
1448
1449 gtk_widget_destroy(dialog);
1450 for (i = 0; i < nbValues; i++)
1451 {
1452 gtk_list_store_append(pot2surf_list_store, &new_row);
1453 gtk_list_store_set(pot2surf_list_store, &new_row,
1454 POT2SURF_NAME, (name && name[0])?name:VISU_UI_SURFACE_NAME_CHOOSE,
1455 POT2SURF_VALUE, values[i], -1);
1456 }
1457 if (nbValues)
1458 gtk_tree_selection_select_iter(tree_selection, &new_row);
1459
1460 if (values)
1461 g_free(values);
1462 if (name)
1463 g_free(name);
1464 }
1465
1466
1467 /* Removes selected surface from the list of surfaces to build from a .pot file. */
pot2surf_remove_surf(GtkWidget * button _U_,gpointer data _U_)1468 void pot2surf_remove_surf(GtkWidget *button _U_, gpointer data _U_)
1469 {
1470 GtkTreeIter iter, iter2;
1471 GtkTreeModel *model;
1472 GtkTreeSelection* tree_selection =
1473 gtk_tree_view_get_selection(GTK_TREE_VIEW(pot2surf_tree_view));
1474 gboolean list_empty = TRUE;
1475
1476 if (gtk_tree_selection_get_selected (tree_selection, &model, &iter))
1477 {
1478 iter2 = iter;
1479 if(gtk_tree_model_iter_previous(model, &iter2))
1480 list_empty = FALSE;
1481 if(gtk_list_store_remove(pot2surf_list_store, &iter))
1482 gtk_tree_selection_select_iter(tree_selection, &iter);
1483 else if(list_empty == FALSE)
1484 gtk_tree_selection_select_iter(tree_selection, &iter2);
1485 }
1486 }
1487
1488
1489 /* Callback for when a user decides to move up or down a surface.
1490 data == GINT_TO_POINTER(1) : move up
1491 data == GINT_TO_POINTER(-1) : move down
1492 */
pot2surf_move_surf(GtkWidget * button _U_,gpointer data)1493 void pot2surf_move_surf(GtkWidget *button _U_, gpointer data)
1494 {
1495 GtkTreeIter iter, iter2;
1496 GtkTreeModel *model;
1497 int direction;
1498
1499 GtkTreeSelection* tree_selection =
1500 gtk_tree_view_get_selection(GTK_TREE_VIEW(pot2surf_tree_view));
1501
1502 if(data == NULL)
1503 return;
1504
1505 direction = GPOINTER_TO_INT(data);
1506 if(direction != -1 && direction != 1)
1507 return;
1508
1509 if(!gtk_tree_selection_get_selected(tree_selection, &model, &iter))
1510 return;
1511
1512 iter2 = iter;
1513 if(direction == 1)
1514 {
1515 if(gtk_tree_model_iter_next(model, &iter2))
1516 gtk_list_store_move_after(pot2surf_list_store, &iter, &iter2);
1517 }
1518 else if(direction == -1)
1519 {
1520 if(gtk_tree_model_iter_previous(model, &iter2))
1521 gtk_list_store_move_before(pot2surf_list_store, &iter, &iter2);
1522 }
1523 }
1524
1525 /* Only used through a gtk_tree_model_foreach()
1526 count the number of element present in a GtkTreeModel */
pot2surf_count_surf(GtkTreeModel * model _U_,GtkTreePath * path _U_,GtkTreeIter * iter _U_,gpointer data)1527 gboolean pot2surf_count_surf(GtkTreeModel *model _U_, GtkTreePath *path _U_,
1528 GtkTreeIter *iter _U_, gpointer data)
1529 {
1530 int *n = data;
1531 (*n)++;
1532 return FALSE;
1533 }
1534
1535 /* Only used through a gtk_tree_model_foreach()
1536 Writes a surface name and value in an instruc file. */
pot2surf_write_surf(GtkTreeModel * model,GtkTreePath * path _U_,GtkTreeIter * iter,gpointer data)1537 gboolean pot2surf_write_surf(GtkTreeModel *model, GtkTreePath *path _U_,
1538 GtkTreeIter *iter, gpointer data)
1539 {
1540 FILE *instruc = data;
1541 char *surf_name=NULL;
1542 float surf_value;
1543
1544 gtk_tree_model_get(GTK_TREE_MODEL(model), iter,
1545 POT2SURF_NAME, &surf_name,
1546 POT2SURF_VALUE, &surf_value, -1);
1547 fprintf(instruc, "%f %s\n", surf_value, surf_name);
1548
1549 g_free(surf_name);
1550
1551 return FALSE;
1552 }
1553
1554
1555
1556 /* Tries to build a valid .instruc file. */
1557 /* Returns : 0 in case of success
1558 n != 0 otherwise */
pot2surf_build_instruc_file(const gchar * pot_file,const gchar * surf_file,const gchar * instruc_file,int n)1559 gboolean pot2surf_build_instruc_file(const gchar *pot_file, const gchar *surf_file, const gchar *instruc_file, int n)
1560 {
1561 FILE *instruc = NULL;
1562 if(instruc_file == NULL || strcmp(instruc_file, "") == 0)
1563 {
1564 visu_ui_raiseWarning(_("Loading a file"),
1565 _("Please select an instruc file to write"),
1566 (GtkWindow*)0);
1567 return FALSE;
1568 }
1569 if((instruc = fopen(instruc_file, "w")) == NULL)
1570 {
1571 visu_ui_raiseWarning(_("Loading a file"),
1572 _("Can't open selected instruc file for writing"),
1573 (GtkWindow*)0);
1574 return FALSE;
1575 }
1576
1577 DBG_fprintf(stderr, "pot2surf : writing/overwriting %s file...\n", instruc_file);
1578
1579 fprintf(instruc, "%s\n", pot_file);
1580 fprintf(instruc, "%s\n", surf_file);
1581 fprintf(instruc, "%d\n", n);
1582
1583 gtk_tree_model_foreach(GTK_TREE_MODEL(pot2surf_list_store), pot2surf_write_surf, instruc);
1584
1585 DBG_fprintf(stderr, "pot2surf : ...finished to write file\n");
1586
1587 fclose(instruc);
1588
1589 return TRUE;
1590 }
1591
pot2surf_select_instruc_file_to_save()1592 void pot2surf_select_instruc_file_to_save()
1593 {
1594 GtkFileFilter *filter_instruc;
1595 GtkFileFilter *filter_none;
1596 GtkWidget* file_chooser;
1597 const char *directory = visu_ui_main_getLastOpenDirectory(visu_ui_main_class_getCurrentPanel());
1598 int n=0;
1599 const gchar *pot_file = gtk_entry_get_text(GTK_ENTRY(pot2surf_entry_source_pot_file));
1600 const gchar *surf_file = gtk_entry_get_text(GTK_ENTRY(pot2surf_entry_target_surf_file));
1601 GString *default_file = NULL;
1602
1603 gtk_tree_model_foreach(GTK_TREE_MODEL(pot2surf_list_store), pot2surf_count_surf, &n);
1604 if(n == 0)
1605 {
1606 visu_ui_raiseWarning(_("Saving a file"),
1607 _("Please specify surfaces to draw"), (GtkWindow*)0);
1608 return;
1609 }
1610 if(strcmp(pot_file, "") == 0)
1611 {
1612 visu_ui_raiseWarning(_("Saving a file"),
1613 _("Please select a source pot file"), (GtkWindow*)0);
1614 return;
1615 }
1616 if(surf_file == NULL || strcmp(surf_file, "") == 0)
1617 {
1618 visu_ui_raiseWarning(_("Saving a file"),
1619 _("Please select a target surf file"), (GtkWindow*)0);
1620 return;
1621 }
1622
1623 default_file = g_string_new("");
1624 g_string_append(default_file, pot_file);
1625 g_string_append(default_file, ".instruc");
1626
1627 filter_instruc = gtk_file_filter_new ();
1628 filter_none = gtk_file_filter_new();
1629 file_chooser = gtk_file_chooser_dialog_new("Save as a .instruc file", GTK_WINDOW(convert_window),
1630 GTK_FILE_CHOOSER_ACTION_SAVE,
1631 TOOL_ICON_CANCEL, GTK_RESPONSE_CANCEL,
1632 TOOL_ICON_SAVE, GTK_RESPONSE_ACCEPT, NULL);
1633 if(directory)
1634 gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(file_chooser), directory);
1635
1636 gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(file_chooser),default_file->str);
1637
1638 gtk_file_filter_add_pattern(filter_instruc, "*.instruc");
1639 gtk_file_filter_set_name(filter_instruc, "Instruction files (*.instruc)");
1640 gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(file_chooser), filter_instruc);
1641
1642 gtk_file_filter_add_pattern(filter_none, "*");
1643 gtk_file_filter_set_name(filter_none, "All files");
1644 gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(file_chooser), filter_none);
1645
1646 while(1)
1647 switch(gtk_dialog_run(GTK_DIALOG(file_chooser)))
1648 {
1649 case GTK_RESPONSE_ACCEPT:
1650 if(!pot2surf_build_instruc_file(pot_file, surf_file,
1651 gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(file_chooser)), n))
1652
1653 break;
1654 visu_ui_main_setLastOpenDirectory(visu_ui_main_class_getCurrentPanel(),
1655 gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER (file_chooser)), VISU_UI_DIR_SURFACE);
1656 g_string_free(default_file, TRUE);
1657 gtk_widget_destroy(file_chooser);
1658 return;
1659 case GTK_RESPONSE_CANCEL:
1660 default:
1661 g_string_free(default_file, TRUE);
1662 gtk_widget_destroy (file_chooser);
1663 return;
1664 }
1665 }
1666
1667 /* Only used through a gtk_tree_model_foreach()
1668 Writes a surface name and value in a struct surf array */
pot2surf_get_surfs(GtkTreeModel * model,GtkTreePath * path _U_,GtkTreeIter * iter,gpointer data)1669 gboolean pot2surf_get_surfs(GtkTreeModel *model, GtkTreePath *path _U_,
1670 GtkTreeIter *iter, gpointer data)
1671 {
1672 struct surf {
1673 char *name;
1674 float value;
1675 };
1676 struct surf *surfaces = data;
1677 int i;
1678
1679 for(i=0; surfaces[i].name != NULL; i++);
1680
1681 gtk_tree_model_get(GTK_TREE_MODEL(model), iter,
1682 POT2SURF_NAME, &surfaces[i].name,
1683 POT2SURF_VALUE, &surfaces[i].value, -1);
1684
1685 return FALSE;
1686 }
1687
1688 /* Tries to build a valid .instruc file and then to executes this file. */
pot2surf_build_surf_file(GtkWidget * button _U_,gpointer data)1689 gboolean pot2surf_build_surf_file(GtkWidget *button _U_, gpointer data)
1690 {
1691 struct surf {
1692 char *name;
1693 float value;
1694 };
1695 float *values = NULL;
1696 gchar **names = NULL;
1697 struct surf *surfaces = NULL;
1698 int n=0, i;
1699 GtkTreeIter iter;
1700 const gchar *pot_file = gtk_entry_get_text(GTK_ENTRY(pot2surf_entry_source_pot_file));
1701 const gchar *surf_file = gtk_entry_get_text(GTK_ENTRY(pot2surf_entry_target_surf_file));
1702
1703 gtk_tree_model_foreach(GTK_TREE_MODEL(pot2surf_list_store), pot2surf_count_surf, &n);
1704 if(n == 0)
1705 {
1706 visu_ui_raiseWarning(_("Saving a file"),
1707 _("Please specify surfaces to draw"), (GtkWindow*)0);
1708 return FALSE;
1709 }
1710 if(pot_file == NULL || strcmp(pot_file, "") == 0)
1711 {
1712 visu_ui_raiseWarning(_("Saving a file"),
1713 _("Please select a source pot file"), (GtkWindow*)0);
1714 return FALSE;
1715 }
1716 if(surf_file == NULL || strcmp(surf_file, "") == 0)
1717 {
1718 visu_ui_raiseWarning(_("Saving a file"),
1719 _("Please select a target surf file"), (GtkWindow*)0);
1720 return FALSE;
1721 }
1722
1723 surfaces = g_malloc(n*sizeof(struct surf));
1724 values = g_malloc(n*sizeof(float));
1725 names = g_malloc(n*sizeof(gchar *));
1726
1727 for(i=0; i<n; i++)
1728 surfaces[i].name = NULL;
1729
1730 gtk_tree_model_foreach(GTK_TREE_MODEL(pot2surf_list_store), pot2surf_get_surfs, surfaces);
1731
1732 for(i=0; i<n; i++)
1733 {
1734 /* fprintf(stderr, "%s %f\n", surfaces[i].name, surfaces[i].value); */
1735 values[i] = surfaces[i].value;
1736 if (strcmp(surfaces[i].name, VISU_UI_SURFACE_NAME_CHOOSE))
1737 names[i] = surfaces[i].name;
1738 else
1739 names[i] = (gchar*)0;
1740 }
1741
1742 if(visu_surface_createFromPotentialFile(surf_file, pot_file, n, values, (const gchar **)names) != 0)
1743 {
1744 visu_ui_raiseWarning(_("Saving a file"),
1745 _("Error"), (GtkWindow*)0);
1746 for(i=0; i<n; i++)
1747 g_free(names[i]);
1748 g_free(names);
1749 g_free(values);
1750 g_free(surfaces);
1751 return FALSE;
1752 }
1753
1754 if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data)))
1755 {
1756 if(visu_ui_panel_surfaces_loadFile(surf_file, &iter,
1757 (GHashTable*)0, (VisuScalarFieldMethod*)0) == 0)
1758 {
1759 for(i=0; i<n; i++)
1760 g_free(names[i]);
1761 g_free(names);
1762 g_free(values);
1763 g_free(surfaces);
1764 return FALSE;
1765 }
1766 }
1767
1768 for(i=0; i<n; i++)
1769 g_free(names[i]);
1770 g_free(names);
1771 g_free(values);
1772 g_free(surfaces);
1773 return TRUE;
1774 }
1775
1776 /* Tries to execute a .instruc file
1777 ie : given a list of potenetials, tries to build a .surf file from a .pot file */
1778 /* gboolean pot2surf_execute_instruc(GtkWidget *button, gpointer data) */
1779 /* { */
1780 /* const gchar *instruc_file = gtk_entry_get_text(GTK_ENTRY(pot2surf_entry_source_instruc_file)); */
1781 /* GString *surf_file_wrote = g_string_new(""); */
1782
1783 /* if(instruc_file == NULL || strcmp(instruc_file, "") == 0) */
1784 /* { */
1785 /* raiseAlertDialog(_("Please select an instruction file")); */
1786 /* g_string_free(surf_file_wrote, TRUE); */
1787 /* return FALSE; */
1788 /* } */
1789
1790 /* if(pot2surf(instruc_file, surf_file_wrote) != 0) */
1791 /* { */
1792 /* g_string_free(surf_file_wrote, TRUE); */
1793 /* return FALSE; */
1794 /* } */
1795
1796 /* if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data))) */
1797 /* if(isosurfaces_try_file(surf_file_wrote->str, 0) == 0) */
1798 /* { */
1799 /* g_string_free(surf_file_wrote, TRUE); */
1800 /* return FALSE; */
1801 /* } */
1802
1803 /* return TRUE; */
1804 /* } */
1805
1806
1807 /* void pot2surf_select_build_surf(GtkWidget *radio_button, GtkWidget *hbox) */
1808 /* { */
1809 /* gtk_widget_set_sensitive(hbox, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(radio_button))); */
1810 /* } */
1811
1812 /* void pot2surf_select_build_instruc(GtkWidget *radio_button, GtkWidget *hbox) */
1813 /* { */
1814 /* gtk_widget_set_sensitive(hbox, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(radio_button))); */
1815 /* } */
1816
pot2surf_load_instruc_file(const gchar * instruc_filename)1817 gboolean pot2surf_load_instruc_file(const gchar *instruc_filename)
1818 {
1819 GIOChannel* instruc_file=NULL;
1820 GString *line=NULL;
1821 gchar *surf_file=NULL;
1822 gchar *pot_file=NULL;
1823 int n=0, i, j;
1824 gchar **surf_names;
1825 float *surf_values;
1826 GtkTreeIter iter;
1827 float pot_min, pot_max;
1828 char float_to_string[128];
1829
1830 instruc_file = g_io_channel_new_file(instruc_filename, "r", NULL);
1831 line = g_string_new("");
1832 if(instruc_file == NULL)
1833 {
1834 visu_ui_raiseWarning(_("Loading a file"),
1835 _("Can't open selected file"), (GtkWindow*)0);
1836 return FALSE;
1837 }
1838
1839 if(g_io_channel_read_line_string(instruc_file, line, NULL, NULL)
1840 != G_IO_STATUS_NORMAL)
1841 {
1842 visu_ui_raiseWarning(_("Loading a file"),
1843 _("Line 1 must contain the full path to the .pot"
1844 " file to read\n"), (GtkWindow*)0);
1845 g_string_free(line, TRUE);
1846 return FALSE;
1847 }
1848
1849 pot_file = g_strstrip(g_strdup(line->str));
1850
1851 if(g_io_channel_read_line_string(instruc_file, line, NULL, NULL)
1852 != G_IO_STATUS_NORMAL)
1853 {
1854 visu_ui_raiseWarning(_("Loading a file"),
1855 _("Line 2 must contain the full path to the"
1856 " .surf file to read\n"), (GtkWindow*)0);
1857 g_string_free(line, TRUE);
1858 g_free(instruc_file);
1859 return FALSE;
1860 }
1861
1862 surf_file = g_strstrip(g_strdup(line->str));
1863
1864 if((g_io_channel_read_line_string(instruc_file, line, NULL, NULL) != G_IO_STATUS_NORMAL)
1865 || (sscanf(line->str, "%d", &n) != 1))
1866 {
1867 visu_ui_raiseWarning(_("Loading a file"),
1868 _("Line 3 must contain the number of"
1869 " surfaces to build\n"), (GtkWindow*)0);
1870 g_string_free(line, TRUE);
1871 g_free(instruc_file);
1872 g_free(surf_file);
1873 return FALSE;
1874 }
1875
1876 surf_names = g_malloc(n*sizeof(gchar *));
1877 surf_values = g_malloc(n*sizeof(gchar *));
1878 for(i=0; i<n; i++)
1879 {
1880 surf_names[i] = g_malloc(TOOL_MAX_LINE_LENGTH*sizeof(gchar));
1881 if((g_io_channel_read_line_string(instruc_file, line, NULL, NULL) != G_IO_STATUS_NORMAL)
1882 || (sscanf(line->str, "%f %s", &surf_values[i], surf_names[i]) != 2))
1883 {
1884 visu_ui_raiseWarning(_("Loading a file"),
1885 _("Lines must contain the value of the"
1886 " surface to build and its name\n"), (GtkWindow*)0);
1887 g_string_free(line, TRUE);
1888 g_free(instruc_file);
1889 g_free(surf_file);
1890 for(j=0; j<i; j++)
1891 g_free(surf_names[j]);
1892 g_free(surf_names);
1893 return FALSE;
1894 }
1895 }
1896
1897 gtk_list_store_clear(pot2surf_list_store);
1898 for(i=0; i<n; i++)
1899 {
1900 gtk_list_store_insert(pot2surf_list_store, &iter, i);
1901 gtk_list_store_set(pot2surf_list_store, &iter,
1902 POT2SURF_NAME, surf_names[i],
1903 POT2SURF_VALUE, surf_values[i], -1);
1904 }
1905
1906 if(pot2surf_quick_parse(pot_file, &pot_min, &pot_max))
1907 {
1908 sprintf(float_to_string, "%f", pot_min);
1909 gtk_entry_set_text(GTK_ENTRY(pot2surf_potmin), float_to_string);
1910 sprintf(float_to_string, "%f", pot_max);
1911 gtk_entry_set_text(GTK_ENTRY(pot2surf_potmax), float_to_string);
1912 }
1913 gtk_entry_set_text(GTK_ENTRY(pot2surf_entry_source_pot_file), pot_file);
1914 gtk_entry_set_text(GTK_ENTRY(pot2surf_entry_target_surf_file), surf_file);
1915
1916 g_string_free(line, TRUE);
1917 g_free(pot_file);
1918 g_free(surf_file);
1919 for(j=0; j<i; j++)
1920 g_free(surf_names[j]);
1921 g_free(surf_names);
1922 g_io_channel_unref(instruc_file);
1923 return TRUE;
1924 }
1925
pot2surf_select_instruc_file_to_load()1926 void pot2surf_select_instruc_file_to_load()
1927 {
1928 GtkFileFilter *filter_instruc = gtk_file_filter_new ();
1929 GtkFileFilter *filter_none = gtk_file_filter_new();
1930 GtkWidget* file_chooser =
1931 gtk_file_chooser_dialog_new("Opens a .instruc file", GTK_WINDOW(convert_window),
1932 GTK_FILE_CHOOSER_ACTION_OPEN,
1933 TOOL_ICON_CANCEL, GTK_RESPONSE_CANCEL,
1934 TOOL_ICON_OPEN, GTK_RESPONSE_ACCEPT, NULL);
1935 const char *directory = visu_ui_main_getLastOpenDirectory(visu_ui_main_class_getCurrentPanel());
1936
1937 if(directory)
1938 gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(file_chooser), directory);
1939
1940 gtk_file_filter_add_pattern(filter_instruc, "*.instruc");
1941 gtk_file_filter_set_name(filter_instruc, "Instruction files (*.instruc)");
1942 gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(file_chooser), filter_instruc);
1943
1944 gtk_file_filter_add_pattern(filter_none, "*");
1945 gtk_file_filter_set_name(filter_none, "All files");
1946 gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(file_chooser), filter_none);
1947
1948 while(1)
1949 switch(gtk_dialog_run(GTK_DIALOG(file_chooser)))
1950 {
1951 case GTK_RESPONSE_ACCEPT:
1952 if(!pot2surf_load_instruc_file(gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(file_chooser))))
1953 break;
1954 visu_ui_main_setLastOpenDirectory(visu_ui_main_class_getCurrentPanel(),
1955 gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER (file_chooser)), VISU_UI_DIR_SURFACE);
1956 gtk_widget_destroy(file_chooser);
1957 return;
1958 case GTK_RESPONSE_CANCEL:
1959 default:
1960 gtk_widget_destroy (file_chooser);
1961 return;
1962 }
1963 }
1964
1965 /* See header file for more info */
visu_ui_panel_surfaces_tools_convertWidget()1966 GtkWidget* visu_ui_panel_surfaces_tools_convertWidget()
1967 {
1968 #if GTK_MAJOR_VERSION == 2 && GTK_MINOR_VERSION < 12
1969 GtkTooltips *tooltips = gtk_tooltips_new ();
1970 #endif
1971
1972 GtkToolItem *instruc_open = gtk_tool_button_new(NULL, NULL);
1973 GtkToolItem *instruc_save = gtk_tool_button_new(NULL, NULL);
1974 GtkToolItem *instruc_help = gtk_tool_button_new(NULL, NULL);
1975 GtkToolItem* separator = gtk_separator_tool_item_new();
1976 GtkWidget *main_vbox = gtk_vbox_new(FALSE, 0);
1977
1978 GtkWidget* scrolled_window = gtk_scrolled_window_new(NULL, NULL);
1979
1980 GtkWidget *pot_hbox = gtk_hbox_new(FALSE, 0);
1981 GtkWidget *pot_open_button = gtk_button_new();
1982
1983 GtkWidget *tview_hbox = gtk_hbox_new(FALSE, 0);
1984
1985 GtkWidget *manage_tview_vbox = gtk_vbox_new(FALSE, 0);
1986 GtkWidget *add_surf_button = gtk_button_new();
1987 GtkWidget *special_add_button = gtk_button_new();
1988 GtkWidget *remove_surf_button = gtk_button_new();
1989 GtkWidget *move_down_button = gtk_button_new();
1990 GtkWidget *move_up_button = gtk_button_new();
1991
1992 GtkWidget *surf_hbox = gtk_hbox_new(FALSE, 0);
1993 GtkWidget *surf_open_button = gtk_button_new();
1994
1995 GtkWidget *min_max_hbox = gtk_hbox_new(FALSE, 0);
1996
1997 GtkWidget *build_hbox = gtk_hbox_new(FALSE, 0);
1998 GtkWidget *build_surf_button = gtk_button_new_with_label(_("Build"));
1999 GtkWidget *autoload_checkbox = gtk_check_button_new_with_label (_("Autoload in V_Sim"));
2000
2001 GtkWidget *image_execute = gtk_image_new_from_icon_name("system-execute", GTK_ICON_SIZE_BUTTON);
2002 GtkWidget *image_add = gtk_image_new_from_icon_name("list-add", GTK_ICON_SIZE_BUTTON);
2003 GtkWidget *image_remove = gtk_image_new_from_icon_name("list-remove", GTK_ICON_SIZE_BUTTON);
2004 GtkWidget *image_go_up = gtk_image_new_from_icon_name("go-up", GTK_ICON_SIZE_BUTTON);
2005 GtkWidget *image_go_down = gtk_image_new_from_icon_name("go-down", GTK_ICON_SIZE_BUTTON);
2006 GtkWidget *image_open = gtk_image_new_from_icon_name("document-open", GTK_ICON_SIZE_BUTTON);
2007
2008 GtkWidget *toolbar = gtk_toolbar_new();
2009
2010 gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(instruc_open), "document-open");
2011 gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(instruc_save), "document-save-as");
2012 gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(instruc_help), "help-browser");
2013
2014 gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_BOTH_HORIZ);
2015 gtk_widget_set_name(toolbar, "message_toolbar");
2016 gtk_widget_set_name(autoload_checkbox, "message_tog");
2017
2018 pot2surf_create_tree_view();
2019
2020 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(autoload_checkbox), TRUE);
2021
2022 pot2surf_potmin = gtk_entry_new ();
2023 pot2surf_potmax = gtk_entry_new ();
2024 gtk_editable_set_editable(GTK_EDITABLE(pot2surf_potmin), FALSE);
2025 gtk_editable_set_editable(GTK_EDITABLE(pot2surf_potmax), FALSE);
2026 /* gtk_widget_set_sensitive(pot2surf_potmin, FALSE); */
2027 /* gtk_widget_set_sensitive(pot2surf_potmax, FALSE); */
2028 gtk_entry_set_text(GTK_ENTRY(pot2surf_potmin), "0.0000000");
2029 gtk_entry_set_text(GTK_ENTRY(pot2surf_potmax), "0.0000000");
2030 g_object_set(G_OBJECT(pot2surf_potmin), "width-chars", 9, NULL);
2031 g_object_set(G_OBJECT(pot2surf_potmax), "width-chars", 9, NULL);
2032
2033 pot2surf_entry_source_pot_file = gtk_entry_new();
2034 gtk_editable_set_editable(GTK_EDITABLE(pot2surf_entry_source_pot_file), FALSE);
2035 pot2surf_entry_target_surf_file = gtk_entry_new();
2036 gtk_editable_set_editable(GTK_EDITABLE(pot2surf_entry_target_surf_file), FALSE);
2037
2038 /* Widget properties edition */
2039 gtk_widget_set_tooltip_text(autoload_checkbox,
2040 _("If checked, autoloads newly built file in V_Sim"));
2041 gtk_widget_set_tooltip_text(pot2surf_entry_source_pot_file,
2042 _("Contains the full path to the currently .pot selected file"));
2043 gtk_widget_set_tooltip_text(pot2surf_entry_target_surf_file,
2044 _("Contains the full path to the .surf file you want to build"));
2045 gtk_widget_set_tooltip_text(pot2surf_potmin,
2046 _("Contains the minimal value found in the selected .pot file"));
2047 gtk_widget_set_tooltip_text(pot2surf_potmax,
2048 _("Contains the maximal value found in the selected .pot file"));
2049 gtk_widget_set_tooltip_text(build_surf_button,
2050 _("Tries to build specified .surf file using specified parameters"));
2051 gtk_widget_set_tooltip_text(add_surf_button,
2052 _("Adds a new surface to the list of surfaces to build"));
2053 gtk_widget_set_tooltip_text(special_add_button,
2054 _("Adds many surfaces to the list of surfaces to build"));
2055 gtk_widget_set_tooltip_text(remove_surf_button,
2056 _("Removes selected surface from the list of surfaces to build"));
2057 gtk_widget_set_tooltip_text(move_down_button,
2058 _("Moves down selected surface in the list of surfaces to build"));
2059 gtk_widget_set_tooltip_text(move_up_button,
2060 _("Moves up selected surface in the list of surfaces to build"));
2061 gtk_widget_set_tooltip_text(pot_open_button,
2062 _("Selects the .pot file to use"));
2063 gtk_widget_set_tooltip_text(surf_open_button,
2064 _("Selects the .surf file to write"));
2065 gtk_tool_item_set_tooltip_text(instruc_open,
2066 _("Opens a .instruc file"));
2067 gtk_tool_item_set_tooltip_text(instruc_save,
2068 _("Saves current settings as .instruc file"));
2069 gtk_tool_item_set_tooltip_text(instruc_help,
2070 _("Show help"));
2071
2072 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
2073 GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
2074 gtk_container_add (GTK_CONTAINER (add_surf_button), image_add);
2075 gtk_container_add (GTK_CONTAINER (special_add_button), image_execute);
2076 gtk_container_add (GTK_CONTAINER (remove_surf_button), image_remove);
2077 gtk_container_add (GTK_CONTAINER (move_down_button), image_go_down);
2078 gtk_container_add (GTK_CONTAINER (move_up_button), image_go_up);
2079 gtk_container_add (GTK_CONTAINER (pot_open_button), image_open);
2080 image_open = gtk_image_new_from_icon_name("document-open", GTK_ICON_SIZE_BUTTON);
2081 gtk_container_add (GTK_CONTAINER (surf_open_button), image_open);
2082
2083 gtk_toolbar_insert(GTK_TOOLBAR(toolbar), instruc_open, 0);
2084 gtk_toolbar_insert(GTK_TOOLBAR(toolbar), instruc_save, 1);
2085 gtk_tool_item_set_expand(separator, TRUE);
2086 gtk_separator_tool_item_set_draw(GTK_SEPARATOR_TOOL_ITEM(separator), FALSE);
2087 gtk_toolbar_insert(GTK_TOOLBAR(toolbar), separator, 2);
2088 gtk_toolbar_insert(GTK_TOOLBAR(toolbar), instruc_help, 3);
2089
2090 /* Widget packing */
2091 gtk_container_add(GTK_CONTAINER(scrolled_window), pot2surf_tree_view);
2092
2093 gtk_box_pack_start(GTK_BOX(main_vbox), toolbar, FALSE, FALSE, 1);
2094 gtk_box_pack_start(GTK_BOX(main_vbox), pot_hbox, FALSE, FALSE, 1);
2095 gtk_box_pack_start(GTK_BOX(main_vbox), min_max_hbox, FALSE, FALSE, 1);
2096 gtk_box_pack_start(GTK_BOX(main_vbox), tview_hbox, TRUE, TRUE, 0);
2097 gtk_box_pack_start(GTK_BOX(main_vbox), surf_hbox, FALSE, FALSE, 1);
2098 gtk_box_pack_start(GTK_BOX(main_vbox), build_hbox, FALSE, FALSE, 1);
2099
2100 gtk_box_pack_start(GTK_BOX(tview_hbox), scrolled_window, TRUE, TRUE, 0);
2101 gtk_box_pack_start(GTK_BOX(tview_hbox), manage_tview_vbox, FALSE, FALSE, 0);
2102
2103 gtk_box_pack_start(GTK_BOX(pot_hbox), gtk_label_new(_("Source .pot file :")), FALSE, FALSE, 1);
2104 gtk_box_pack_start(GTK_BOX(pot_hbox), pot2surf_entry_source_pot_file, TRUE, TRUE, 1);
2105 gtk_box_pack_start(GTK_BOX(pot_hbox), pot_open_button, FALSE, FALSE, 1);
2106
2107 gtk_box_pack_start(GTK_BOX(surf_hbox), gtk_label_new(_("Target .surf file :")), FALSE, FALSE, 1);
2108 gtk_box_pack_start(GTK_BOX(surf_hbox), pot2surf_entry_target_surf_file, TRUE, TRUE, 1);
2109 gtk_box_pack_start(GTK_BOX(surf_hbox), surf_open_button, FALSE, FALSE, 1);
2110
2111 gtk_box_pack_start(GTK_BOX(manage_tview_vbox), add_surf_button, FALSE, FALSE, 1);
2112 gtk_box_pack_start(GTK_BOX(manage_tview_vbox), special_add_button, FALSE, FALSE, 1);
2113 gtk_box_pack_start(GTK_BOX(manage_tview_vbox), remove_surf_button, FALSE, FALSE, 1);
2114 gtk_box_pack_end(GTK_BOX(manage_tview_vbox), move_down_button, FALSE, FALSE, 1);
2115 gtk_box_pack_end(GTK_BOX(manage_tview_vbox), move_up_button, FALSE, FALSE, 1);
2116
2117 gtk_box_pack_start(GTK_BOX(min_max_hbox), gtk_label_new(_("Pot min : ")), FALSE, FALSE, 1);
2118 gtk_box_pack_start(GTK_BOX(min_max_hbox), pot2surf_potmin, FALSE, FALSE, 1);
2119 gtk_box_pack_end(GTK_BOX(min_max_hbox), pot2surf_potmax, FALSE, FALSE, 1);
2120 gtk_box_pack_end(GTK_BOX(min_max_hbox), gtk_label_new(_("Pot max : ")), FALSE, FALSE, 1);
2121
2122 gtk_box_pack_end(GTK_BOX(build_hbox), build_surf_button, FALSE, FALSE, 1);
2123 gtk_box_pack_end(GTK_BOX(build_hbox), autoload_checkbox, FALSE, FALSE, 1);
2124
2125 /* Signal connexion */
2126 g_signal_connect(instruc_open, "clicked",
2127 G_CALLBACK(pot2surf_select_instruc_file_to_load), NULL);
2128 g_signal_connect(instruc_save, "clicked",
2129 G_CALLBACK(pot2surf_select_instruc_file_to_save), NULL);
2130 g_signal_connect(instruc_help, "clicked",
2131 G_CALLBACK(pot2surf_popup_help), NULL);
2132 g_signal_connect(build_surf_button, "clicked",
2133 G_CALLBACK(pot2surf_build_surf_file), autoload_checkbox);
2134 g_signal_connect(pot_open_button, "clicked",
2135 G_CALLBACK(pot2surf_select_pot_file), NULL);
2136 g_signal_connect(surf_open_button, "clicked",
2137 G_CALLBACK(pot2surf_select_surf_file), NULL);
2138 g_signal_connect(add_surf_button, "clicked",
2139 G_CALLBACK(pot2surf_add_surf), NULL);
2140 g_signal_connect(special_add_button, "clicked",
2141 G_CALLBACK(pot2surf_special_add_surf), NULL);
2142 g_signal_connect(remove_surf_button, "clicked",
2143 G_CALLBACK(pot2surf_remove_surf), NULL);
2144 g_signal_connect(move_down_button, "clicked",
2145 G_CALLBACK(pot2surf_move_surf), GINT_TO_POINTER(1));
2146 g_signal_connect(move_up_button, "clicked",
2147 G_CALLBACK(pot2surf_move_surf), GINT_TO_POINTER(-1));
2148
2149 return main_vbox;
2150 }
2151
visu_ui_panel_surfaces_tools_init_destroy()2152 void visu_ui_panel_surfaces_tools_init_destroy()
2153 {
2154 convert_w_opened = FALSE;
2155 gtk_widget_destroy(convert_window);
2156 }
2157
2158 /* See header file for more info */
visu_ui_panel_surfaces_tools_init()2159 void visu_ui_panel_surfaces_tools_init()
2160 {
2161 GtkWidget *main_vbox;
2162 GtkWidget *convert_notebook;
2163 GtkWidget *close_button;
2164 GtkWidget *merge_label;
2165 GtkWidget *pot2surf_label;
2166
2167 if(convert_w_opened)
2168 return;
2169 convert_w_opened = TRUE;
2170
2171 main_vbox = gtk_vbox_new(FALSE, 0);
2172 convert_notebook = gtk_notebook_new();
2173 close_button = gtk_button_new_from_icon_name("window-close", GTK_ICON_SIZE_BUTTON);
2174 merge_label = gtk_label_new(_("Merge"));
2175 pot2surf_label = gtk_label_new(_("pot2surf"));
2176
2177 convert_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
2178 gtk_window_set_title(GTK_WINDOW(convert_window), "File conversion utilities");
2179 /* gtk_window_set_modal(GTK_WINDOW(convert_window), TRUE); */
2180 /* gtk_window_set_transient_for(GTK_WINDOW(convert_window), GTK_WINDOW(mainWindow)); */
2181
2182 gtk_notebook_append_page(GTK_NOTEBOOK(convert_notebook), visu_ui_panel_surfaces_tools_convertWidget(),
2183 pot2surf_label);
2184 gtk_notebook_append_page(GTK_NOTEBOOK(convert_notebook), visu_ui_panel_surfaces_tools_fileWidget(),
2185 merge_label);
2186
2187 gtk_container_add(GTK_CONTAINER(convert_window), main_vbox);
2188 gtk_widget_set_name(convert_window, "message");
2189 gtk_widget_set_name(convert_notebook, "message_notebook");
2190
2191
2192 gtk_box_pack_start(GTK_BOX(main_vbox), convert_notebook, TRUE, TRUE, 0);
2193 gtk_box_pack_start(GTK_BOX(main_vbox), close_button, FALSE, FALSE, 1);
2194
2195 g_signal_connect(convert_window, "destroy",
2196 G_CALLBACK(visu_ui_panel_surfaces_tools_init_destroy), NULL);
2197 g_signal_connect(close_button, "clicked",
2198 G_CALLBACK(visu_ui_panel_surfaces_tools_init_destroy), NULL);
2199
2200 gtk_widget_show_all(convert_window);
2201 }
2202
2203
2204 /* void open_pot2surf(GtkWidget *widget, gpointer data) */
2205 /* { */
2206 /* char *file_to_convert = NULL; */
2207 /* GtkFileFilter *filter = gtk_file_filter_new (); */
2208 /* GtkWidget* file_chooser = */
2209 /* gtk_file_chooser_dialog_new("Select a .instruc file", GTK_WINDOW(convert_window), */
2210 /* GTK_FILE_CHOOSER_ACTION_OPEN, */
2211 /* GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, */
2212 /* GTK_STOCK_HELP, GTK_RESPONSE_HELP, */
2213 /* "Convert", GTK_RESPONSE_ACCEPT, */
2214 /* NULL); */
2215 /* gint r_value; */
2216
2217 /* gtk_file_filter_add_pattern(filter, "*.instruc"); */
2218 /* gtk_file_filter_set_name(filter, "Instructions files (*.instruc)"); */
2219 /* gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(file_chooser), filter); */
2220
2221 /* while((r_value = gtk_dialog_run(GTK_DIALOG(file_chooser)))) */
2222 /* switch(r_value) */
2223 /* { */
2224 /* case GTK_RESPONSE_ACCEPT: */
2225 /* file_to_convert = */
2226 /* gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(file_chooser)); */
2227 /* DBG_fprintf(stderr, "\n\n%s\n\n", file_to_convert); */
2228 /* pot2surf(file_to_convert, NULL); */
2229 /* gtk_widget_destroy(file_chooser); */
2230 /* return; */
2231 /* case GTK_RESPONSE_HELP: */
2232 /* pot2surf_popup_help(); */
2233 /* break; */
2234 /* case GTK_RESPONSE_CANCEL: */
2235 /* default: */
2236 /* gtk_widget_destroy (file_chooser); */
2237 /* return; */
2238 /* } */
2239 /* } */
2240
2241