?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
set up the treeview reflections
[hkl.git] / gui / hkl-gui.c
blob72144899c98dcc12b62cdb1f8b20a782d53622b5
1 /* This file is part of the hkl library.
2 *
3 * The hkl library is free software: you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License as published by
5 * the Free Software Foundation, either version 3 of the License, or
6 * (at your option) any later version.
7 *
8 * The hkl library is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with the hkl library. If not, see <http://www.gnu.org/licenses/>.
15 *
16 * Copyright (C) 2003-2010 Synchrotron SOLEIL
17 * L'Orme des Merisiers Saint-Aubin
18 * BP 48 91192 GIF-sur-YVETTE CEDEX
19 *
20 * Authors: Picca Frédéric-Emmanuel <picca@synchrotron-soleil.fr>
21 */
22
23 #include "hkl-gui.h"
24 #include <glib.h>
25 #include <glib-object.h>
26 #include <gtk/gtk.h>
27 #include "hkl.h"
28 #include "hkl-gui-pseudoaxes.h"
29 #include <gdk/gdk.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <float.h>
33 #include <math.h>
34 #include <stdio.h>
35
36 #define HKL_GUI_TYPE_WINDOW (hkl_gui_window_get_type ())
37 #define HKL_GUI_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), HKL_GUI_TYPE_WINDOW, HklGuiWindow))
38 #define HKL_GUI_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), HKL_GUI_TYPE_WINDOW, HklGuiWindowClass))
39 #define HKL_GUI_IS_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), HKL_GUI_TYPE_WINDOW))
40 #define HKL_GUI_IS_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), HKL_GUI_TYPE_WINDOW))
41 #define HKL_GUI_WINDOW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), HKL_GUI_TYPE_WINDOW, HklGuiWindowClass))
42
43 G_DEFINE_TYPE (HklGuiWindow, hkl_gui_window, G_TYPE_OBJECT);
44
45 typedef enum {
46 REFLECTION_COL_INDEX = 0,
47 REFLECTION_COL_H,
48 REFLECTION_COL_K,
49 REFLECTION_COL_L,
50 REFLECTION_COL_FLAG,
51 REFLECTION_COL_REFLECTION,
52 REFLECTION_COL_N_COLUMNS
53 } ReflectionCol;
54
55 typedef enum {
56 AXIS_COL_AXIS = 0,
57 AXIS_COL_NAME,
58 AXIS_COL_READ,
59 AXIS_COL_WRITE,
60 AXIS_COL_MIN,
61 AXIS_COL_MAX,
62 AXIS_COL_N_COLUMNS
63 } AxisCol;
64
65 typedef enum {
66 PSEUDO_AXIS_COL_PARAMETER = 0,
67 PSEUDO_AXIS_COL_ENGINE,
68 PSEUDO_AXIS_COL_NAME,
69 PSEUDO_AXIS_COL_READ,
70 PSEUDO_AXIS_COL_WRITE,
71 PSEUDO_AXIS_COL_N_COLUMNS
72 } PseudoAxisCol;
73
74 typedef enum {
75 PARAMETER_COL_PARAMETER = 0,
76 PARAMETER_COL_NAME,
77 PARAMETER_COL_VALUE,
78 PARAMETER_COL_N_COLUMNS
79 } ParameterCol;
80
81 typedef enum {
82 SAMPLE_COL_SAMPLE = 0,
83 SAMPLE_COL_REFLECTIONS,
84 SAMPLE_COL_NAME,
85 SAMPLE_COL_A,
86 SAMPLE_COL_B,
87 SAMPLE_COL_C,
88 SAMPLE_COL_ALPHA,
89 SAMPLE_COL_BETA,
90 SAMPLE_COL_GAMMA,
91 SAMPLE_COL_N_COLUMNS
92 } SampleCol;
93
94 typedef enum {
95 SOLUTION_COL_INDEX = 0,
96 SOLUTION_COL_N_COLUMNS
97 } SolutionCol;
98
99 typedef enum {
100 DIFFRACTOMETER_COL_NAME = 0,
101 DIFFRACTOMETER_COL_FACTORY,
102 DIFFRACTOMETER_COL_DIFFRACTOMETER,
103 DIFFRACTOMETER_COL_N_COLUMNS
104 } DiffractometerCol;
105
106 /******************/
107 /* Diffractometer */
108 /******************/
109
110 struct diffractometer_t {
111 HklGeometry *geometry;
112 HklDetector *detector;
113 HklEngineList *engines;
114 };
115
116
117 static struct diffractometer_t *
118 create_diffractometer(HklFactory *factory)
119 {
120 struct diffractometer_t *self;
121
122 self = malloc(sizeof(*self));
123
124 self->geometry = hkl_factory_create_new_geometry (factory);
125 self->engines = hkl_factory_create_new_engine_list (factory);
126 self->detector = hkl_detector_factory_new (HKL_DETECTOR_TYPE_0D);
127 hkl_detector_idx_set (self->detector, 1);
128
129 return self;
130 }
131
132 static void
133 delete_diffractometer(struct diffractometer_t *self)
134 {
135 hkl_geometry_free(self->geometry);
136 hkl_engine_list_free(self->engines);
137 hkl_detector_free(self->detector);
138 }
139
140
141 static void
142 dump_diffractometer(struct diffractometer_t *self)
143 {
144 /* hkl_geometry_fprintf(stderr, self->geometry); */
145 /* hkl_engine_list_fprintf(stderr, self->engines); */
146 /* hkl_detector_fprintf(stderr, self->detector); */
147 }
148
149 /****************/
150 /* HklGuiWindow */
151 /****************/
152
153 struct _HklGuiWindowPrivate {
154 GtkBuilder* builder;
155 GtkLabel* _label_UB11;
156 GtkLabel* _label_UB12;
157 GtkLabel* _label_UB13;
158 GtkLabel* _label_UB21;
159 GtkLabel* _label_UB22;
160 GtkLabel* _label_UB23;
161 GtkLabel* _label_UB31;
162 GtkLabel* _label_UB32;
163 GtkLabel* _label_UB33;
164 GtkButton* _button2;
165 GtkSpinButton* _spinbutton_a;
166 GtkSpinButton* _spinbutton_b;
167 GtkSpinButton* _spinbutton_c;
168 GtkSpinButton* _spinbutton_alpha;
169 GtkSpinButton* _spinbutton_beta;
170 GtkSpinButton* _spinbutton_gamma;
171 GtkSpinButton* _spinbutton_a_min;
172 GtkSpinButton* _spinbutton_b_min;
173 GtkSpinButton* _spinbutton_c_min;
174 GtkSpinButton* _spinbutton_alpha_min;
175 GtkSpinButton* _spinbutton_beta_min;
176 GtkSpinButton* _spinbutton_gamma_min;
177 GtkSpinButton* _spinbutton_a_max;
178 GtkSpinButton* _spinbutton_b_max;
179 GtkSpinButton* _spinbutton_c_max;
180 GtkSpinButton* _spinbutton_alpha_max;
181 GtkSpinButton* _spinbutton_beta_max;
182 GtkSpinButton* _spinbutton_gamma_max;
183 GtkSpinButton* _spinbutton_lambda;
184 GtkSpinButton* _spinbutton_a_star;
185 GtkSpinButton* _spinbutton_b_star;
186 GtkSpinButton* _spinbutton_c_star;
187 GtkSpinButton* _spinbutton_alpha_star;
188 GtkSpinButton* _spinbutton_beta_star;
189 GtkSpinButton* _spinbutton_gamma_star;
190 GtkSpinButton* _spinbutton_ux;
191 GtkSpinButton* _spinbutton_uy;
192 GtkSpinButton* _spinbutton_uz;
193 GtkSpinButton* _spinbutton_U11;
194 GtkSpinButton* _spinbutton_U12;
195 GtkSpinButton* _spinbutton_U13;
196 GtkSpinButton* _spinbutton_U21;
197 GtkSpinButton* _spinbutton_U22;
198 GtkSpinButton* _spinbutton_U23;
199 GtkSpinButton* _spinbutton_U31;
200 GtkSpinButton* _spinbutton_U32;
201 GtkSpinButton* _spinbutton_U33;
202 GtkCheckButton* _checkbutton_a;
203 GtkCheckButton* _checkbutton_b;
204 GtkCheckButton* _checkbutton_c;
205 GtkCheckButton* _checkbutton_alpha;
206 GtkCheckButton* _checkbutton_beta;
207 GtkCheckButton* _checkbutton_gamma;
208 GtkCheckButton* _checkbutton_Ux;
209 GtkCheckButton* _checkbutton_Uy;
210 GtkCheckButton* _checkbutton_Uz;
211 GtkTreeView* _treeview_reflections;
212 GtkTreeView* _treeview_crystals;
213 GtkTreeView* _treeview_axes;
214 GtkTreeView* _treeview_pseudo_axes;
215 GtkTreeView* _treeview_pseudo_axes_parameters;
216 GtkTreeView* _treeview_solutions;
217 GtkToolButton* _toolbutton_add_reflection;
218 GtkToolButton* _toolbutton_goto_reflection;
219 GtkToolButton* _toolbutton_del_reflection;
220 GtkToolButton* _toolbutton_setUB;
221 GtkToolButton* _toolbutton_computeUB;
222 GtkToolButton* _toolbutton_add_crystal;
223 GtkToolButton* _toolbutton_copy_crystal;
224 GtkToolButton* _toolbutton_del_crystal;
225 GtkToolButton* _toolbutton_affiner;
226 GtkStatusbar* _statusbar;
227 GtkImageMenuItem* _menuitem5;
228 GtkVBox* _box_info_bar; /* fake for the infor bar */
229 GtkVBox* _vbox7;
230 GtkVBox* _vbox2;
231 GtkDialog* _dialog1;
232 GtkButton* _button1;
233 GtkComboBox* _combobox1;
234 GtkListStore* _liststore_diffractometer;
235 GtkListStore* _liststore_axis;
236 GtkListStore* _liststore_pseudo_axes;
237 GtkListStore* _liststore_solutions;
238 GtkListStore* _liststore_reflections;
239
240 GtkListStore* store_samples;
241 GtkInfoBar *info_bar;
242 GtkLabel *info_message;
243
244 darray(HklGuiEngine *) pseudo_frames;
245
246 struct diffractometer_t *diffractometer; /* unowned */
247 HklSample *sample; /* unowned */
248 HklLattice *reciprocal;
249 };
250
251 #define HKL_GUI_WINDOW_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), HKL_GUI_TYPE_WINDOW, HklGuiWindowPrivate))
252
253 static gboolean
254 finalize_liststore_diffractometer(GtkTreeModel *model,
255 GtkTreePath *path,
256 GtkTreeIter *iter,
257 gpointer data)
258 {
259 struct diffractometer_t *diffractometer;
260
261 gtk_tree_model_get(model, iter,
262 DIFFRACTOMETER_COL_DIFFRACTOMETER, &diffractometer,
263 -1);
264 delete_diffractometer(diffractometer);
265
266 return FALSE;
267 }
268
269 static void
270 finalize (GObject* object)
271 {
272 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(object);
273
274 g_object_unref(priv->builder);
275
276 darray_free(priv->pseudo_frames);
277
278 gtk_tree_model_foreach(GTK_TREE_MODEL(priv->_liststore_diffractometer),
279 finalize_liststore_diffractometer,
280 NULL);
281
282 G_OBJECT_CLASS (hkl_gui_window_parent_class)->finalize (object);
283 }
284
285 HklGuiWindow* hkl_gui_window_new (void)
286 {
287 return g_object_new (HKL_GUI_TYPE_WINDOW, NULL);
288 }
289
290
291 #define get_object(builder, type, priv, name) priv->_ ## name = type(gtk_builder_get_object(builder, #name))
292
293 static void
294 hkl_gui_window_get_widgets_and_objects_from_ui (HklGuiWindow* self)
295 {
296 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
297 GtkBuilder* builder;
298
299 g_return_if_fail (self != NULL);
300
301 priv->builder = builder = gtk_builder_new ();
302 gtk_builder_add_from_file (builder, "ghkl.ui", NULL);
303
304 get_object(builder, GTK_LIST_STORE, priv, liststore_diffractometer);
305 get_object(builder, GTK_LIST_STORE, priv, liststore_axis);
306 get_object(builder, GTK_LIST_STORE, priv, liststore_pseudo_axes);
307 get_object(builder, GTK_LIST_STORE, priv, liststore_reflections);
308
309 get_object(builder, GTK_LABEL, priv, label_UB11);
310 get_object(builder, GTK_LABEL, priv, label_UB12);
311 get_object(builder, GTK_LABEL, priv, label_UB13);
312 get_object(builder, GTK_LABEL, priv, label_UB21);
313 get_object(builder, GTK_LABEL, priv, label_UB22);
314 get_object(builder, GTK_LABEL, priv, label_UB23);
315 get_object(builder, GTK_LABEL, priv, label_UB31);
316 get_object(builder, GTK_LABEL, priv, label_UB32);
317 get_object(builder, GTK_LABEL, priv, label_UB33);
318
319 get_object(builder, GTK_BUTTON, priv, button2);
320
321 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_a);
322 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_a_min);
323 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_a_max);
324 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_a_star);
325
326 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_b);
327 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_b_min);
328 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_b_max);
329 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_b_star);
330
331 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_c);
332 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_c_min);
333 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_c_max);
334 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_c_star);
335
336 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_alpha);
337 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_alpha_min);
338 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_alpha_max);
339 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_alpha_star);
340
341 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_beta);
342 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_beta_min);
343 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_beta_max);
344 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_beta_star);
345
346 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_gamma);
347 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_gamma_min);
348 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_gamma_max);
349 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_gamma_star);
350
351 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_lambda);
352
353 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_ux);
354 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_uy);
355 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_uz);
356
357 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_U11);
358 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_U12);
359 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_U13);
360 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_U21);
361 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_U22);
362 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_U23);
363 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_U31);
364 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_U32);
365 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_U33);
366
367
368 get_object(builder, GTK_CHECK_BUTTON, priv, checkbutton_a);
369 get_object(builder, GTK_CHECK_BUTTON, priv, checkbutton_b);
370 get_object(builder, GTK_CHECK_BUTTON, priv, checkbutton_c);
371 get_object(builder, GTK_CHECK_BUTTON, priv, checkbutton_alpha);
372 get_object(builder, GTK_CHECK_BUTTON, priv, checkbutton_beta);
373 get_object(builder, GTK_CHECK_BUTTON, priv, checkbutton_gamma);
374 get_object(builder, GTK_CHECK_BUTTON, priv, checkbutton_Ux);
375 get_object(builder, GTK_CHECK_BUTTON, priv, checkbutton_Uy);
376 get_object(builder, GTK_CHECK_BUTTON, priv, checkbutton_Uz);
377
378
379 get_object(builder, GTK_TREE_VIEW, priv, treeview_reflections);
380 get_object(builder, GTK_TREE_VIEW, priv, treeview_crystals);
381 get_object(builder, GTK_TREE_VIEW, priv, treeview_axes);
382 get_object(builder, GTK_TREE_VIEW, priv, treeview_pseudo_axes);
383 get_object(builder, GTK_TREE_VIEW, priv, treeview_solutions);
384 priv->_treeview_pseudo_axes_parameters = GTK_TREE_VIEW(gtk_builder_get_object (builder, "treeview_pseudoAxes_parameters"));
385
386
387 get_object(builder, GTK_TOOL_BUTTON, priv, toolbutton_add_reflection);
388 get_object(builder, GTK_TOOL_BUTTON, priv, toolbutton_goto_reflection);
389 get_object(builder, GTK_TOOL_BUTTON, priv, toolbutton_del_reflection);
390 get_object(builder, GTK_TOOL_BUTTON, priv, toolbutton_setUB);
391 get_object(builder, GTK_TOOL_BUTTON, priv, toolbutton_computeUB);
392 get_object(builder, GTK_TOOL_BUTTON, priv, toolbutton_add_crystal);
393 get_object(builder, GTK_TOOL_BUTTON, priv, toolbutton_copy_crystal);
394 get_object(builder, GTK_TOOL_BUTTON, priv, toolbutton_del_crystal);
395 get_object(builder, GTK_TOOL_BUTTON, priv, toolbutton_affiner);
396
397 get_object(builder, GTK_STATUSBAR, priv, statusbar);
398
399 get_object(builder, GTK_IMAGE_MENU_ITEM, priv, menuitem5);
400
401 get_object(builder, GTK_VBOX, priv, vbox7);
402 get_object(builder, GTK_VBOX, priv, vbox2);
403 get_object(builder, GTK_VBOX, priv, box_info_bar);
404
405 get_object(builder, GTK_DIALOG, priv, dialog1);
406
407 get_object(builder, GTK_COMBO_BOX, priv, combobox1);
408
409 gtk_builder_connect_signals (builder, self);
410 }
411
412 static void
413 update_pseudo_axes_frames (HklGuiWindow* self)
414 {
415 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
416 HklGuiEngine **engine;
417
418 g_return_if_fail (self != NULL);
419
420 darray_foreach(engine, priv->pseudo_frames){
421 hkl_gui_engine_update(*engine);
422 }
423 }
424
425 static void
426 raise_error(HklGuiWindow *self, HklError **error)
427 {
428 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
429
430 g_return_if_fail (self != NULL);
431 g_return_if_fail (error != NULL);
432
433 /* show an error message */
434 gtk_label_set_text (GTK_LABEL (priv->info_message),
435 hkl_error_message_get(*error));
436 gtk_info_bar_set_message_type (priv->info_bar,
437 GTK_MESSAGE_ERROR);
438 gtk_widget_show (GTK_WIDGET(priv->info_bar));
439
440 hkl_error_clear(error);
441 }
442
443 static void
444 clear_error(HklGuiWindow *self, HklError **error)
445 {
446 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
447
448 g_return_if_fail (self != NULL);
449
450 gtk_widget_hide(GTK_WIDGET(priv->info_bar));
451 }
452
453 static gboolean
454 _update_axis (GtkTreeModel *model, GtkTreePath *path,
455 GtkTreeIter *iter, gpointer data)
456 {
457 HklParameter *parameter;
458 gdouble value, min, max;
459
460 gtk_tree_model_get (model, iter,
461 AXIS_COL_AXIS, &parameter,
462 -1);
463
464 hkl_parameter_min_max_unit_get(parameter, &min, &max);
465 value = hkl_parameter_value_unit_get(parameter);
466
467 gtk_list_store_set(GTK_LIST_STORE(model), iter,
468 AXIS_COL_READ, value,
469 AXIS_COL_WRITE, value,
470 AXIS_COL_MIN, min,
471 AXIS_COL_MAX, max,
472 -1);
473 return FALSE;
474 }
475
476 static void
477 update_axes (HklGuiWindow* self)
478 {
479 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
480
481 g_return_if_fail (self != NULL);
482
483 gtk_tree_model_foreach(GTK_TREE_MODEL(priv->_liststore_axis),
484 _update_axis,
485 self);
486 }
487
488 static gboolean
489 _update_pseudo_axes (GtkTreeModel *model, GtkTreePath *path,
490 GtkTreeIter *iter, gpointer data)
491 {
492 HklParameter *parameter;
493 gdouble value, min, max;
494
495 gtk_tree_model_get (model, iter,
496 PSEUDO_AXIS_COL_PARAMETER, &parameter,
497 -1);
498
499 hkl_parameter_min_max_unit_get(parameter, &min, &max);
500 value = hkl_parameter_value_unit_get(parameter);
501
502 gtk_list_store_set(GTK_LIST_STORE(model), iter,
503 PSEUDO_AXIS_COL_READ, value,
504 PSEUDO_AXIS_COL_WRITE, value,
505 -1);
506 return FALSE;
507 }
508
509 static void
510 update_pseudo_axes (HklGuiWindow* self)
511 {
512 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
513
514 g_return_if_fail (self != NULL);
515
516 gtk_tree_model_foreach(GTK_TREE_MODEL(priv->_liststore_pseudo_axes),
517 _update_pseudo_axes,
518 self);
519 }
520
521 static void
522 update_solutions (HklGuiWindow* self)
523 {
524 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
525 const HklGeometryList *geometries;
526 const darray_item *items;
527 GtkTreeIter iter = {0};
528
529 g_return_if_fail (self != NULL);
530
531 geometries = hkl_engine_list_geometries(priv->diffractometer->engines);
532
533 gtk_list_store_clear(priv->_liststore_solutions);
534 items = hkl_geometry_list_items_get(geometries);
535 if (darray_size(*items)){
536 gint n_values = gtk_tree_model_get_n_columns (GTK_TREE_MODEL(priv->_liststore_solutions));
537 GValue *values = g_new0(GValue, n_values);
538 gint *columns = g_new0(gint, n_values);
539 gint i;
540
541 /* prepare the GValue before using them */
542 g_value_init(&values[0], G_TYPE_INT);
543 for(i=1; i<n_values; ++i)
544 g_value_init(&values[i], G_TYPE_DOUBLE);
545
546 for(i=0; i<darray_size(*items);++i){
547 gint column = 0;
548 const HklGeometry *geometry;
549 HklParameter **parameter;
550 const darray_parameter *parameters;
551
552 geometry = hkl_geometry_list_item_geometry_get(darray_item(*items, i));
553 parameters = hkl_geometry_axes_get(geometry);
554
555 g_value_set_int(&values[column], i);
556 columns[0] = column;
557
558 darray_foreach(parameter, *parameters){
559 double value = hkl_parameter_value_unit_get(*parameter);
560
561 column = column + 1;
562 g_value_set_double(&values[column], value);
563 columns[column] = column;
564 }
565 gtk_list_store_insert_with_valuesv(priv->_liststore_solutions,
566 &iter, i,
567 columns, values, n_values);
568 }
569 g_free(columns);
570 g_free(values);
571 }
572 }
573
574 static gboolean
575 hkl_engine_to_axes(HklGuiWindow *self, HklEngine *engine)
576 {
577 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
578 HklError *error = NULL;
579 gboolean res = TRUE;
580
581 g_return_val_if_fail (self != NULL, FALSE);
582 g_return_val_if_fail (engine != NULL, FALSE);
583
584 if(hkl_engine_set(engine, &error)){
585 clear_error(self, &error);
586 hkl_engine_list_select_solution(priv->diffractometer->engines, 0);
587 hkl_engine_list_get(priv->diffractometer->engines);
588
589 update_axes (self);
590 update_pseudo_axes (self);
591 update_pseudo_axes_frames (self);
592 }else{
593 raise_error(self, &error);
594 dump_diffractometer(priv->diffractometer);
595 res = FALSE;
596 }
597 update_solutions (self);
598 return res;
599 }
600
601 static void
602 pseudo_axes_frame_changed_cb (HklGuiEngine *gui_engine, HklGuiWindow *self)
603 {
604 HklEngine *engine;
605
606 g_return_if_fail (self != NULL);
607
608 g_object_get(G_OBJECT(gui_engine),
609 "engine", &engine,
610 NULL);
611
612 hkl_engine_to_axes(self, engine);
613 }
614
615 static void
616 set_up_pseudo_axes_frames (HklGuiWindow* self)
617 {
618 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
619 HklGuiEngine **pseudo;
620 GtkVBox* vbox2;
621 HklEngine **engine;
622 darray_engine *engines;
623
624 g_return_if_fail (self != NULL);
625
626 darray_foreach (pseudo, priv->pseudo_frames){
627 gtk_container_remove(GTK_CONTAINER(priv->_vbox2),
628 GTK_WIDGET (hkl_gui_engine_get_frame (*pseudo)));
629 g_object_unref(*pseudo);
630 }
631 darray_size (priv->pseudo_frames) = 0;
632
633 engines = hkl_engine_list_engines (priv->diffractometer->engines);
634 darray_foreach (engine, *engines){
635 HklGuiEngine *pseudo;
636
637 pseudo = hkl_gui_engine_new (*engine);
638 darray_append(priv->pseudo_frames, pseudo);
639 gtk_container_add (GTK_CONTAINER (priv->_vbox2),
640 GTK_WIDGET (hkl_gui_engine_get_frame(pseudo)));
641
642 g_signal_connect_object (pseudo,
643 "changed",
644 G_CALLBACK(pseudo_axes_frame_changed_cb),
645 self, 0);
646 }
647
648 gtk_widget_show_all (GTK_WIDGET (priv->_vbox2));
649 }
650
651
652 static void
653 set_up_diffractometer_model (HklGuiWindow* self)
654 {
655 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
656 unsigned int i, n;
657 HklFactory **factories;
658
659 g_return_if_fail (self != NULL);
660
661 factories = hkl_factory_get_all(&n);
662 for(i=0; i<n; ++i){
663 GtkTreeIter iter = {0};
664
665 gtk_list_store_append (priv->_liststore_diffractometer, &iter);
666 gtk_list_store_set (priv->_liststore_diffractometer,
667 &iter,
668 DIFFRACTOMETER_COL_NAME, hkl_factory_name(factories[i]),
669 DIFFRACTOMETER_COL_FACTORY, factories[i],
670 DIFFRACTOMETER_COL_DIFFRACTOMETER, NULL,
671 -1);
672 }
673 }
674
675 static void
676 set_up_tree_view_axes (HklGuiWindow* self)
677 {
678 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
679 HklParameter **parameter;
680 const darray_parameter *parameters;
681 GtkCellRenderer* renderer = NULL;
682 GtkTreeViewColumn* column = NULL;
683 GList* columns;
684
685 g_return_if_fail (self != NULL);
686
687 gtk_list_store_clear (priv->_liststore_axis);
688
689 parameters = hkl_geometry_axes_get(priv->diffractometer->geometry);
690 darray_foreach (parameter, *parameters){
691 GtkTreeIter iter = {0};
692
693 gtk_list_store_append (priv->_liststore_axis, &iter);
694 gtk_list_store_set (priv->_liststore_axis, &iter,
695 AXIS_COL_AXIS, *parameter,
696 AXIS_COL_NAME, hkl_parameter_name_get(*parameter),
697 -1);
698 }
699
700 update_axes (self);
701 }
702
703 static void
704 set_up_tree_view_pseudo_axes (HklGuiWindow* self)
705 {
706 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
707 HklParameter **parameter;
708 const darray_parameter *parameters;
709 HklEngine **engine;
710 const darray_engine *engines;
711
712 GtkCellRendererText* renderer = NULL;
713 GtkTreeViewColumn* column = NULL;
714 GList* columns;
715
716 g_return_if_fail (self != NULL);
717
718 gtk_list_store_clear(priv->_liststore_pseudo_axes);
719
720 engines = hkl_engine_list_engines(priv->diffractometer->engines);
721 darray_foreach(engine, *engines){
722 parameters = hkl_engine_pseudo_axes(*engine);
723 darray_foreach(parameter, *parameters){
724 GtkTreeIter iter = {0};
725
726 gtk_list_store_append (priv->_liststore_pseudo_axes, &iter);
727 gtk_list_store_set (priv->_liststore_pseudo_axes, &iter,
728 PSEUDO_AXIS_COL_PARAMETER, *parameter,
729 PSEUDO_AXIS_COL_ENGINE, *engine,
730 PSEUDO_AXIS_COL_NAME, hkl_parameter_name_get(*parameter),
731 -1);
732 }
733 }
734
735 update_pseudo_axes (self);
736 }
737
738 static void
739 _delete_column(gpointer data,
740 gpointer user_data)
741 {
742 gtk_tree_view_remove_column (GTK_TREE_VIEW(user_data),
743 GTK_TREE_VIEW_COLUMN(data));
744 }
745
746 static void
747 set_up_tree_view_solutions (HklGuiWindow* self)
748 {
749 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
750 const darray_parameter *parameters;
751 int i;
752 GtkCellRenderer* renderer = NULL;
753 GtkTreeViewColumn* column = NULL;
754 GList* columns;
755 GType* types;
756 gint n_columns;
757
758 g_return_if_fail (self != NULL);
759
760 parameters = hkl_geometry_axes_get(priv->diffractometer->geometry);
761
762 n_columns = SOLUTION_COL_N_COLUMNS + darray_size(*parameters);
763
764 /* prepare types for the liststore */
765 types = g_new0 (GType, n_columns);
766
767 /* first remove all the columns */
768 columns = gtk_tree_view_get_columns (priv->_treeview_solutions);
769 g_list_foreach(columns, _delete_column, priv->_treeview_solutions);
770 g_list_free(columns);
771
772 /* now add the index column */
773 renderer = gtk_cell_renderer_text_new ();
774 column = gtk_tree_view_column_new_with_attributes ("index",
775 renderer, "text",
776 SOLUTION_COL_INDEX, NULL);
777
778 gtk_tree_view_append_column (priv->_treeview_solutions, column);
779 types[0] = G_TYPE_INT;
780
781 /* add the axes column */
782 for(i=1; i<n_columns; ++i){
783 HklParameter *parameter;
784
785 parameter = darray_item(*parameters, i - SOLUTION_COL_N_COLUMNS);
786 renderer = gtk_cell_renderer_text_new ();
787 column = gtk_tree_view_column_new_with_attributes (hkl_parameter_name_get(parameter),
788 renderer, "text",
789 i, NULL);
790
791 gtk_tree_view_append_column (priv->_treeview_solutions, column);
792 types[i] = G_TYPE_DOUBLE;
793 }
794
795 if (priv->_liststore_solutions)
796 g_object_unref(priv->_liststore_solutions);
797 priv->_liststore_solutions = gtk_list_store_newv (n_columns, types);
798 g_free (types);
799
800 gtk_tree_view_set_model (priv->_treeview_solutions,
801 GTK_TREE_MODEL(priv->_liststore_solutions));
802
803 update_solutions (self);
804 }
805
806 void
807 set_up_info_bar(HklGuiWindow *self)
808 {
809 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
810 GtkWidget *content_area;
811
812 g_return_if_fail (self != NULL);
813
814 /* set up info bar until we can use glade for this purpose or
815 * switch to gtk3 */
816 if (priv->info_bar)
817 return;
818
819 priv->info_bar = GTK_INFO_BAR(gtk_info_bar_new ());
820 gtk_widget_set_no_show_all (GTK_WIDGET(priv->info_bar), TRUE);
821
822 priv->info_message = GTK_LABEL(gtk_label_new (""));
823 gtk_widget_show (GTK_WIDGET(priv->info_message));
824
825 content_area = gtk_info_bar_get_content_area (GTK_INFO_BAR (priv->info_bar));
826 gtk_container_add (GTK_CONTAINER (content_area),
827 GTK_WIDGET(priv->info_message));
828 gtk_info_bar_add_button (priv->info_bar,
829 GTK_STOCK_OK, GTK_RESPONSE_OK);
830 g_signal_connect (priv->info_bar, "response",
831 G_CALLBACK (gtk_widget_hide), NULL);
832
833 gtk_box_pack_start(GTK_BOX(priv->_box_info_bar),
834 GTK_WIDGET(priv->info_bar),
835 TRUE, TRUE, 0);
836 }
837
838 void
839 hkl_gui_window_combobox1_changed_cb(GtkComboBox *combobox, gpointer *user_data)
840 {
841 HklGuiWindow *self = HKL_GUI_WINDOW(user_data);
842 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(user_data);
843 HklFactory *factory;
844 struct diffractometer_t *dif = NULL;
845
846 GtkTreeIter iter = {0};
847
848 if(gtk_combo_box_get_active_iter (combobox, &iter)){
849 gtk_tree_model_get(GTK_TREE_MODEL(priv->_liststore_diffractometer),
850 &iter,
851 DIFFRACTOMETER_COL_FACTORY, &factory,
852 DIFFRACTOMETER_COL_DIFFRACTOMETER, &dif,
853 -1);
854
855 if (!dif){
856 dif = create_diffractometer(factory);
857 gtk_list_store_set(priv->_liststore_diffractometer,
858 &iter,
859 DIFFRACTOMETER_COL_DIFFRACTOMETER, dif,
860 -1);
861 }
862 printf("toto\n");
863 }
864 priv->diffractometer = dif;
865 /* TODO check if this is the right place for this */
866 hkl_engine_list_init(dif->engines, dif->geometry, dif->detector, priv->sample);
867
868 set_up_pseudo_axes_frames(self);
869 set_up_tree_view_axes(self);
870 //hkl_gui_window_set_up_tree_view_pseudo_axes_parameters(self);
871 set_up_tree_view_pseudo_axes(self);
872
873 /* FIXME create the right solution Model Column */
874 /* this._solutionModelColumns = 0; */
875 set_up_tree_view_solutions(self);
876 set_up_info_bar(self);
877 #if HKL3D
878 set_up_3D(self);
879 #endif
880 }
881
882
883 /* axis read cb */
884 void
885 hkl_gui_window_cellrendererspin1_edited_cb(GtkCellRendererText *renderer,
886 gchar *path,
887 gchar *new_text,
888 gpointer user_data)
889 {
890 HklGuiWindow *self = HKL_GUI_WINDOW(user_data);
891 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(user_data);
892 GtkTreeIter iter = {0};
893 gdouble value = 0.0;
894 HklParameter* parameter = NULL;
895
896 g_return_if_fail (renderer != NULL);
897 g_return_if_fail (path != NULL);
898 g_return_if_fail (new_text != NULL);
899 g_return_if_fail (user_data != NULL);
900
901 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL(priv->_liststore_axis),
902 &iter,
903 path);
904 gtk_tree_model_get (GTK_TREE_MODEL(priv->_liststore_axis), &iter,
905 AXIS_COL_AXIS, &parameter,
906 -1);
907
908 value = atof(new_text); /* TODO need to check for the right conversion */
909 hkl_parameter_value_unit_set (parameter, value, NULL);
910 hkl_geometry_axis_set(priv->diffractometer->geometry,
911 parameter);
912
913 hkl_engine_list_get(priv->diffractometer->engines);
914
915 /* ok so set the model with the new value */
916 gtk_list_store_set (priv->_liststore_axis, &iter,
917 AXIS_COL_READ, value,
918 AXIS_COL_WRITE, value,
919 -1);
920
921 update_pseudo_axes (self);
922 update_pseudo_axes_frames (self);
923 }
924
925
926 /* axis min cb */
927 void
928 hkl_gui_window_cellrendererspin3_edited_cb(GtkCellRendererText *renderer,
929 gchar *path,
930 gchar *new_text,
931 gpointer user_data)
932 {
933 HklGuiWindow *self = HKL_GUI_WINDOW(user_data);
934 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(user_data);
935 GtkTreeIter iter = {0};
936 gdouble value = 0.0;
937 HklParameter* parameter = NULL;
938 gdouble shit, max;
939
940 g_return_if_fail (renderer != NULL);
941 g_return_if_fail (path != NULL);
942 g_return_if_fail (new_text != NULL);
943 g_return_if_fail (user_data != NULL);
944
945 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL(priv->_liststore_axis),
946 &iter,
947 path);
948 gtk_tree_model_get (GTK_TREE_MODEL(priv->_liststore_axis), &iter,
949 AXIS_COL_AXIS, &parameter,
950 -1);
951
952 value = atof(new_text); /* TODO need to check for the right conversion */
953 hkl_parameter_min_max_unit_get (parameter, &shit, &max);
954 hkl_parameter_min_max_unit_set (parameter, value, max);
955
956 gtk_list_store_set (priv->_liststore_axis, &iter,
957 AXIS_COL_MIN, value,
958 -1);
959
960 update_pseudo_axes (self);
961 }
962
963
964 /* axis max cb */
965 void
966 hkl_gui_window_cellrendererspin4_edited_cb(GtkCellRendererText *renderer,
967 gchar *path,
968 gchar *new_text,
969 gpointer user_data)
970 {
971 HklGuiWindow *self = HKL_GUI_WINDOW(user_data);
972 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(user_data);
973 GtkTreeIter iter = {0};
974 gdouble value = 0.0;
975 HklParameter* parameter = NULL;
976 gdouble shit, min;
977
978 g_return_if_fail (renderer != NULL);
979 g_return_if_fail (path != NULL);
980 g_return_if_fail (new_text != NULL);
981 g_return_if_fail (user_data != NULL);
982
983 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL(priv->_liststore_axis),
984 &iter,
985 path);
986 gtk_tree_model_get (GTK_TREE_MODEL(priv->_liststore_axis), &iter,
987 AXIS_COL_AXIS, &parameter,
988 -1);
989
990 value = atof(new_text); /* TODO need to check for the right conversion */
991 hkl_parameter_min_max_unit_get (parameter, &min, &shit);
992 hkl_parameter_min_max_unit_set (parameter, min, value);
993
994 gtk_list_store_set (priv->_liststore_axis, &iter,
995 AXIS_COL_MAX, value,
996 -1);
997
998 update_pseudo_axes (self);
999 }
1000
1001
1002 /* pseudo axis write */
1003 void
1004 hkl_gui_window_cellrenderertext5_edited_cb(GtkCellRendererText *renderer,
1005 gchar *path,
1006 gchar *new_text,
1007 gpointer user_data)
1008 {
1009 HklGuiWindow *self = HKL_GUI_WINDOW(user_data);
1010 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(user_data);
1011 GtkTreeIter iter = {0};
1012 gdouble value = 0.0;
1013 gdouble old_value;
1014 HklParameter* parameter = NULL;
1015 HklEngine *engine = NULL;
1016 HklError *error = NULL;
1017
1018 g_return_if_fail (renderer != NULL);
1019 g_return_if_fail (path != NULL);
1020 g_return_if_fail (new_text != NULL);
1021 g_return_if_fail (user_data != NULL);
1022
1023 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL(priv->_liststore_pseudo_axes),
1024 &iter,
1025 path);
1026 gtk_tree_model_get (GTK_TREE_MODEL(priv->_liststore_pseudo_axes), &iter,
1027 PSEUDO_AXIS_COL_PARAMETER, &parameter,
1028 PSEUDO_AXIS_COL_ENGINE, &engine,
1029 -1);
1030
1031 value = atof(new_text); /* TODO need to check for the right conversion */
1032 old_value = hkl_parameter_value_unit_get(parameter);
1033
1034 g_assert(error != NULL || error == NULL);
1035 hkl_parameter_value_unit_set (parameter, value, &error);
1036 if(error != NULL){
1037 raise_error(self, &error);
1038 }
1039
1040 if (hkl_engine_to_axes(self, engine)){
1041 gtk_list_store_set (priv->_liststore_pseudo_axes,
1042 &iter,
1043 PSEUDO_AXIS_COL_WRITE, value,
1044 -1);
1045 }else{
1046 hkl_parameter_value_unit_set(parameter, old_value, NULL);
1047 }
1048 }
1049
1050
1051 void
1052 hkl_gui_window_treeview_solutions_cursor_changed_cb (GtkTreeView *tree_view,
1053 gpointer user_data)
1054 {
1055 HklGuiWindow* self = HKL_GUI_WINDOW(user_data);
1056 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(user_data);
1057
1058 GtkTreePath* path = NULL;
1059 GtkTreeViewColumn* focus_column = NULL;
1060 GtkTreeIter iter = {0};
1061 gsize index = 0UL;
1062
1063 g_return_if_fail (tree_view != NULL);
1064 g_return_if_fail (user_data != NULL);
1065
1066 gtk_tree_view_get_cursor (tree_view, &path, &focus_column);
1067 gtk_tree_model_get_iter (GTK_TREE_MODEL(priv->_liststore_solutions), &iter, path);
1068 gtk_tree_model_get (GTK_TREE_MODEL(priv->_liststore_solutions), &iter,
1069 SOLUTION_COL_INDEX, &index,
1070 -1);
1071
1072 hkl_engine_list_select_solution (priv->diffractometer->engines, index);
1073 hkl_engine_list_get (priv->diffractometer->engines);
1074
1075 update_axes (self);
1076 update_pseudo_axes (self);
1077 update_pseudo_axes_frames (self);
1078
1079 gtk_tree_path_free (path);
1080 }
1081
1082 /* reflection h */
1083 void
1084 hkl_gui_window_cellrenderertext7_edited_cb(GtkCellRendererText* _sender, const gchar* path,
1085 const gchar* new_text, gpointer self)
1086 {
1087 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
1088
1089 g_return_if_fail (self != NULL);
1090 g_return_if_fail (path != NULL);
1091 g_return_if_fail (new_text != NULL);
1092
1093 if (priv->sample){
1094 gdouble h = 0.0;
1095 gdouble k = 0.0;
1096 gdouble l = 0.0;
1097 HklSampleReflection* reflection = NULL;
1098 GtkTreeIter iter = {0};
1099
1100 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL(priv->_liststore_reflections),
1101 &iter, path);
1102 gtk_tree_model_get (GTK_TREE_MODEL(priv->_liststore_reflections),
1103 &iter,
1104 REFLECTION_COL_REFLECTION, &reflection,
1105 -1);
1106
1107 hkl_sample_reflection_hkl_get (reflection, &h, &k, &l);
1108 h = atof(new_text);
1109 hkl_sample_reflection_hkl_set (reflection, h, k, l);
1110 gtk_list_store_set (priv->_liststore_reflections,
1111 &iter,
1112 REFLECTION_COL_H, h,
1113 -1);
1114 }
1115 }
1116
1117 /* reflection k */
1118 void
1119 hkl_gui_window_cellrenderertext8_edited_cb (GtkCellRendererText* _sender, const gchar* path,
1120 const gchar* new_text, gpointer self)
1121 {
1122 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
1123
1124 g_return_if_fail (self != NULL);
1125 g_return_if_fail (path != NULL);
1126 g_return_if_fail (new_text != NULL);
1127
1128 if (priv->sample){
1129 gdouble h = 0.0;
1130 gdouble k = 0.0;
1131 gdouble l = 0.0;
1132 HklSampleReflection* reflection = NULL;
1133 GtkTreeIter iter = {0};
1134
1135 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL(priv->_liststore_reflections),
1136 &iter, path);
1137 gtk_tree_model_get (GTK_TREE_MODEL(priv->_liststore_reflections),
1138 &iter,
1139 REFLECTION_COL_REFLECTION, &reflection,
1140 -1);
1141
1142 hkl_sample_reflection_hkl_get (reflection, &h, &k, &l);
1143 k = atof(new_text);
1144 hkl_sample_reflection_hkl_set (reflection, h, k, l);
1145 gtk_list_store_set (priv->_liststore_reflections,
1146 &iter,
1147 REFLECTION_COL_K, k,
1148 -1);
1149 }
1150 }
1151
1152 /* reflection l */
1153 void
1154 hkl_gui_window_cellrenderertext9_edited_cb (GtkCellRendererText* _sender, const gchar* path,
1155 const gchar* new_text, gpointer self)
1156 {
1157 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
1158
1159 g_return_if_fail (self != NULL);
1160 g_return_if_fail (path != NULL);
1161 g_return_if_fail (new_text != NULL);
1162
1163 if (priv->sample){
1164 gdouble h = 0.0;
1165 gdouble k = 0.0;
1166 gdouble l = 0.0;
1167 HklSampleReflection* reflection = NULL;
1168 GtkTreeIter iter = {0};
1169
1170 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL(priv->_liststore_reflections),
1171 &iter, path);
1172 gtk_tree_model_get (GTK_TREE_MODEL(priv->_liststore_reflections),
1173 &iter,
1174 REFLECTION_COL_REFLECTION, &reflection,
1175 -1);
1176
1177 hkl_sample_reflection_hkl_get (reflection, &h, &k, &l);
1178 l = atof(new_text);
1179 hkl_sample_reflection_hkl_set (reflection, h, k, l);
1180 gtk_list_store_set (priv->_liststore_reflections,
1181 &iter,
1182 REFLECTION_COL_L, l,
1183 -1);
1184 }
1185 }
1186
1187 /* reflection flag */
1188 void
1189 hkl_gui_window_cellrenderertoggle1_toggled_cb (GtkCellRendererToggle* renderer, const gchar* path,
1190 gpointer self)
1191 {
1192 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
1193
1194 g_return_if_fail (self != NULL);
1195 g_return_if_fail (path != NULL);
1196
1197 if (priv->sample){
1198 gboolean flag;
1199 HklSampleReflection* reflection = NULL;
1200 GtkTreeIter iter = {0};
1201
1202 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL(priv->_liststore_reflections),
1203 &iter, path);
1204 gtk_tree_model_get (GTK_TREE_MODEL(priv->_liststore_reflections),
1205 &iter,
1206 REFLECTION_COL_REFLECTION, &reflection,
1207 -1);
1208
1209 flag = gtk_cell_renderer_toggle_get_active(renderer);
1210 hkl_sample_reflection_flag_set (reflection, flag);
1211 gtk_list_store_set (priv->_liststore_reflections,
1212 &iter,
1213 REFLECTION_COL_FLAG, flag,
1214 -1);
1215 }
1216 }
1217
1218 /*
1219
1220 static void _hkl_gui_window_on_spinbutton_lambda_value_changed_gtk_spin_button_value_changed (GtkSpinButton* _sender, gpointer self) {
1221
1222 hkl_gui_window_on_spinbutton_lambda_value_changed (self);
1223
1224 }
1225
1226
1227 static void _hkl_gui_window_on_spinbutton_uxuyuz_value_changed_gtk_spin_button_value_changed (GtkSpinButton* _sender, gpointer self) {
1228
1229 hkl_gui_window_on_spinbutton_uxuyuz_value_changed (self);
1230
1231 }
1232
1233
1234 static void _hkl_gui_window_on_button2_clicked_gtk_button_clicked (GtkButton* _sender, gpointer self) {
1235
1236 hkl_gui_window_on_button2_clicked (self);
1237
1238 }
1239
1240
1241 static void _hkl_gui_window_on_checkbutton_a_toggled_gtk_toggle_button_toggled (GtkToggleButton* _sender, gpointer self) {
1242
1243 hkl_gui_window_on_checkbutton_a_toggled (self);
1244
1245 }
1246
1247
1248 static void _hkl_gui_window_on_checkbutton_b_toggled_gtk_toggle_button_toggled (GtkToggleButton* _sender, gpointer self) {
1249
1250 hkl_gui_window_on_checkbutton_b_toggled (self);
1251
1252 }
1253
1254
1255 static void _hkl_gui_window_on_checkbutton_c_toggled_gtk_toggle_button_toggled (GtkToggleButton* _sender, gpointer self) {
1256
1257 hkl_gui_window_on_checkbutton_c_toggled (self);
1258
1259 }
1260
1261
1262 static void _hkl_gui_window_on_checkbutton_alpha_toggled_gtk_toggle_button_toggled (GtkToggleButton* _sender, gpointer self) {
1263
1264 hkl_gui_window_on_checkbutton_alpha_toggled (self);
1265
1266 }
1267
1268
1269 static void _hkl_gui_window_on_checkbutton_beta_toggled_gtk_toggle_button_toggled (GtkToggleButton* _sender, gpointer self) {
1270
1271 hkl_gui_window_on_checkbutton_beta_toggled (self);
1272
1273 }
1274
1275
1276 static void _hkl_gui_window_on_checkbutton_gamma_toggled_gtk_toggle_button_toggled (GtkToggleButton* _sender, gpointer self) {
1277
1278 hkl_gui_window_on_checkbutton_gamma_toggled (self);
1279
1280 }
1281
1282
1283 static void _hkl_gui_window_on_checkbutton_Ux_toggled_gtk_toggle_button_toggled (GtkToggleButton* _sender, gpointer self) {
1284
1285 hkl_gui_window_on_checkbutton_Ux_toggled (self);
1286
1287 }
1288
1289
1290 static void _hkl_gui_window_on_checkbutton_Uy_toggled_gtk_toggle_button_toggled (GtkToggleButton* _sender, gpointer self) {
1291
1292 hkl_gui_window_on_checkbutton_Uy_toggled (self);
1293
1294 }
1295
1296
1297 static void _hkl_gui_window_on_checkbutton_Uz_toggled_gtk_toggle_button_toggled (GtkToggleButton* _sender, gpointer self) {
1298
1299 hkl_gui_window_on_checkbutton_Uz_toggled (self);
1300
1301 }
1302
1303
1304 static gboolean _hkl_gui_window_on_tree_view_reflections_key_press_event_gtk_widget_key_press_event (GtkWidget* _sender, GdkEventKey* event, gpointer self) {
1305 gboolean result;
1306 result = hkl_gui_window_on_tree_view_reflections_key_press_event (event, self);
1307
1308 return result;
1309
1310 }
1311
1312
1313 static void _hkl_gui_window_on_tree_view_pseudo_axes_cursor_changed_gtk_tree_view_cursor_changed (GtkTreeView* _sender, gpointer self) {
1314
1315 hkl_gui_window_on_tree_view_pseudo_axes_cursor_changed (self);
1316
1317 }
1318
1319
1320 static void _hkl_gui_window_on_tree_view_crystals_cursor_changed_gtk_tree_view_cursor_changed (GtkTreeView* _sender, gpointer self) {
1321
1322 hkl_gui_window_on_tree_view_crystals_cursor_changed (self);
1323
1324 }
1325
1326
1327 static gboolean _hkl_gui_window_on_tree_view_crystals_key_press_event_gtk_widget_key_press_event (GtkWidget* _sender, GdkEventKey* event, gpointer self) {
1328 gboolean result;
1329 result = hkl_gui_window_on_tree_view_crystals_key_press_event (event, self);
1330
1331 return result;
1332
1333 }
1334
1335
1336 static void _hkl_gui_window_on_toolbutton_add_reflection_clicked_gtk_tool_button_clicked (GtkToolButton* _sender, gpointer self) {
1337
1338 hkl_gui_window_on_toolbutton_add_reflection_clicked (self);
1339
1340 }
1341
1342
1343 static void _hkl_gui_window_on_toolbutton_goto_reflection_clicked_gtk_tool_button_clicked (GtkToolButton* _sender, gpointer self) {
1344
1345 hkl_gui_window_on_toolbutton_goto_reflection_clicked (self);
1346
1347 }
1348
1349
1350 static void _hkl_gui_window_on_toolbutton_del_reflection_clicked_gtk_tool_button_clicked (GtkToolButton* _sender, gpointer self) {
1351
1352 hkl_gui_window_on_toolbutton_del_reflection_clicked (self);
1353
1354 }
1355
1356
1357 static void _hkl_gui_window_on_toolbutton_setUB_clicked_gtk_tool_button_clicked (GtkToolButton* _sender, gpointer self) {
1358
1359 hkl_gui_window_on_toolbutton_setUB_clicked (self);
1360
1361 }
1362
1363
1364 static void _hkl_gui_window_on_toolbutton_computeUB_clicked_gtk_tool_button_clicked (GtkToolButton* _sender, gpointer self) {
1365
1366 hkl_gui_window_on_toolbutton_computeUB_clicked (self);
1367
1368 }
1369
1370
1371 static void _hkl_gui_window_on_toolbutton_add_crystal_clicked_gtk_tool_button_clicked (GtkToolButton* _sender, gpointer self) {
1372
1373 hkl_gui_window_on_toolbutton_add_crystal_clicked (self);
1374
1375 }
1376
1377
1378 static void _hkl_gui_window_on_toolbutton_copy_crystal_clicked_gtk_tool_button_clicked (GtkToolButton* _sender, gpointer self) {
1379
1380 hkl_gui_window_on_toolbutton_copy_crystal_clicked (self);
1381
1382 }
1383
1384
1385 static void _hkl_gui_window_on_toolbutton_del_crystal_clicked_gtk_tool_button_clicked (GtkToolButton* _sender, gpointer self) {
1386
1387 hkl_gui_window_on_toolbutton_del_crystal_clicked (self);
1388
1389 }
1390
1391
1392 static void _hkl_gui_window_on_toolbutton_affiner_clicked_gtk_tool_button_clicked (GtkToolButton* _sender, gpointer self) {
1393
1394 hkl_gui_window_on_toolbutton_affiner_clicked (self);
1395
1396 }
1397
1398
1399 static void _hkl_gui_window_on_menuitem5_activate_gtk_menu_item_activate (GtkMenuItem* _sender, gpointer self) {
1400
1401 hkl_gui_window_on_menuitem5_activate (self);
1402
1403 }
1404
1405
1406 static void _hkl_gui_window_on_button1_clicked_gtk_button_clicked (GtkButton* _sender, gpointer self) {
1407
1408 hkl_gui_window_on_button1_clicked (self);
1409
1410 }
1411
1412
1413 static void _hkl_gui_window_on_combobox1_changed_gtk_combo_box_changed (GtkComboBox* _sender, gpointer self) {
1414
1415 hkl_gui_window_on_combobox1_changed (self);
1416 }
1417
1418 #define CONNECT_SPINBUTTON(name) \
1419 g_signal_connect_object (priv->_ ## name, \
1420 "value-changed", \
1421 (GCallback) SPINBUTTON_VALUE_CHANGED_CB(name), \
1422 self, 0);
1423
1424 #define CONNECT_UX_UY_UZ(name) \
1425 g_signal_connect_object (priv->_ ## name, \
1426 "value-changed", \
1427 (GCallback) _hkl_gui_window_on_spinbutton_uxuyuz_value_changed_gtk_spin_button_value_changed, \
1428 self, 0);
1429
1430 #define CONNECT_CHECKBUTTON(name) \
1431 g_signal_connect_object (priv->_ ## name, \
1432 "toggled", \
1433 (GCallback) CHECKBUTTON_TOGGLED_CB(name), \
1434 self, 0);
1435 static void
1436 hkl_gui_window_connect_all_signals (HklGuiWindow* self)
1437 {
1438 HklGuiWindowPrivate *priv = self->priv;
1439
1440 g_return_if_fail (self != NULL);
1441
1442 CONNECT_SPINBUTTON(spinbutton_a);
1443 CONNECT_SPINBUTTON(spinbutton_a_min);
1444 CONNECT_SPINBUTTON(spinbutton_a_max);
1445 CONNECT_SPINBUTTON(spinbutton_a_star);
1446
1447 CONNECT_SPINBUTTON(spinbutton_b);
1448 CONNECT_SPINBUTTON(spinbutton_b_min);
1449 CONNECT_SPINBUTTON(spinbutton_b_max);
1450 CONNECT_SPINBUTTON(spinbutton_b_star);
1451
1452 CONNECT_SPINBUTTON(spinbutton_c);
1453 CONNECT_SPINBUTTON(spinbutton_c_min);
1454 CONNECT_SPINBUTTON(spinbutton_c_max);
1455 CONNECT_SPINBUTTON(spinbutton_c_star);
1456
1457 CONNECT_SPINBUTTON(spinbutton_alpha);
1458 CONNECT_SPINBUTTON(spinbutton_alpha_min);
1459 CONNECT_SPINBUTTON(spinbutton_alpha_max);
1460 CONNECT_SPINBUTTON(spinbutton_alpha_star);
1461
1462 CONNECT_SPINBUTTON(spinbutton_beta);
1463 CONNECT_SPINBUTTON(spinbutton_beta_min);
1464 CONNECT_SPINBUTTON(spinbutton_beta_max);
1465 CONNECT_SPINBUTTON(spinbutton_beta_star);
1466
1467 CONNECT_SPINBUTTON(spinbutton_alpha);
1468 CONNECT_SPINBUTTON(spinbutton_alpha_min);
1469 CONNECT_SPINBUTTON(spinbutton_alpha_max);
1470 CONNECT_SPINBUTTON(spinbutton_alpha_star);
1471
1472 g_signal_connect_object (priv->_spinbutton_lambda,
1473 "value-changed",
1474 (GCallback) _hkl_gui_window_on_spinbutton_lambda_value_changed_gtk_spin_button_value_changed,
1475 self, 0);
1476
1477 CONNECT_UX_UY_UZ(spinbutton_ux);
1478 CONNECT_UX_UY_UZ(spinbutton_uy);
1479 CONNECT_UX_UY_UZ(spinbutton_uz);
1480
1481 g_signal_connect_object (priv->_button2,
1482 "clicked",
1483 (GCallback) _hkl_gui_window_on_button2_clicked_gtk_button_clicked,
1484 self, 0);
1485
1486 CONNECT_CHECKBUTTON(checkbutton_a);
1487 CONNECT_CHECKBUTTON(checkbutton_b);
1488 CONNECT_CHECKBUTTON(checkbutton_c);
1489 CONNECT_CHECKBUTTON(checkbutton_alpha);
1490 CONNECT_CHECKBUTTON(checkbutton_beta);
1491 CONNECT_CHECKBUTTON(checkbutton_gamma);
1492 CONNECT_CHECKBUTTON(checkbutton_Ux);
1493 CONNECT_CHECKBUTTON(checkbutton_Uy);
1494 CONNECT_CHECKBUTTON(checkbutton_Uz);
1495
1496 g_signal_connect_object (GTK_WIDGET(priv->_treeview_reflections),
1497 "key-press-event",
1498 (GCallback) _hkl_gui_window_on_tree_view_reflections_key_press_event_gtk_widget_key_press_event,
1499 self, 0);
1500
1501 g_signal_connect_object (priv->_treeview_pseudo_axes,
1502 "cursor-changed",
1503 (GCallback) _hkl_gui_window_on_tree_view_pseudo_axes_cursor_changed_gtk_tree_view_cursor_changed,
1504 self, 0);
1505
1506 g_signal_connect_object (priv->_treeview_crystals,
1507 "cursor-changed",
1508 (GCallback) _hkl_gui_window_on_tree_view_crystals_cursor_changed_gtk_tree_view_cursor_changed, self, 0);
1509
1510 g_signal_connect_object (GTK_WIDGET(priv->_treeview_crystals),
1511 "key-press-event",
1512 (GCallback) _hkl_gui_window_on_tree_view_crystals_key_press_event_gtk_widget_key_press_event,
1513 self, 0);
1514
1515 g_signal_connect_object (priv->_toolbutton_add_reflection,
1516 "clicked",
1517 (GCallback) _hkl_gui_window_on_toolbutton_add_reflection_clicked_gtk_tool_button_clicked,
1518 self, 0);
1519
1520 g_signal_connect_object (priv->_toolbutton_goto_reflection,
1521 "clicked",
1522 (GCallback) _hkl_gui_window_on_toolbutton_goto_reflection_clicked_gtk_tool_button_clicked,
1523 self, 0);
1524
1525 g_signal_connect_object (priv->_toolbutton_del_reflection,
1526 "clicked",
1527 (GCallback) _hkl_gui_window_on_toolbutton_del_reflection_clicked_gtk_tool_button_clicked,
1528 self, 0);
1529
1530 g_signal_connect_object (priv->_toolbutton_setUB,
1531 "clicked",
1532 (GCallback) _hkl_gui_window_on_toolbutton_setUB_clicked_gtk_tool_button_clicked,
1533 self, 0);
1534
1535 g_signal_connect_object (priv->_toolbutton_computeUB,
1536 "clicked",
1537 (GCallback) _hkl_gui_window_on_toolbutton_computeUB_clicked_gtk_tool_button_clicked,
1538 self, 0);
1539
1540 g_signal_connect_object (priv->_toolbutton_add_crystal,
1541 "clicked",
1542 (GCallback) _hkl_gui_window_on_toolbutton_add_crystal_clicked_gtk_tool_button_clicked,
1543 self, 0);
1544
1545 g_signal_connect_object (priv->_toolbutton_copy_crystal,
1546 "clicked",
1547 (GCallback) _hkl_gui_window_on_toolbutton_copy_crystal_clicked_gtk_tool_button_clicked,
1548 self, 0);
1549
1550 g_signal_connect_object (priv->_toolbutton_del_crystal,
1551 "clicked",
1552 (GCallback) _hkl_gui_window_on_toolbutton_del_crystal_clicked_gtk_tool_button_clicked,
1553 self, 0);
1554
1555 g_signal_connect_object (priv->_toolbutton_affiner,
1556 "clicked",
1557 (GCallback) _hkl_gui_window_on_toolbutton_affiner_clicked_gtk_tool_button_clicked,
1558 self, 0);
1559
1560 g_signal_connect_object (GTK_MENU_ITEM(priv->_menuitem5),
1561 "activate",
1562 (GCallback) _hkl_gui_window_on_menuitem5_activate_gtk_menu_item_activate,
1563 self, 0);
1564
1565 g_signal_connect_object (priv->_button1,
1566 "clicked",
1567 (GCallback) _hkl_gui_window_on_button1_clicked_gtk_button_clicked,
1568 self, 0);
1569
1570 g_signal_connect_object (priv->_combobox1,
1571 "changed",
1572 (GCallback) _hkl_gui_window_on_combobox1_changed_gtk_combo_box_changed,
1573 self, 0);
1574 }
1575
1576
1577
1578
1579
1580 static void _hkl_gui_window_on_cell_tree_view_axes_read_edited_gtk_cell_renderer_text_edited (GtkCellRendererText* _sender, const gchar* path, const gchar* new_text, gpointer self) {
1581
1582 hkl_gui_window_on_cell_tree_view_axes_read_edited (path, new_text, self);
1583
1584 }
1585
1586
1587 static void _hkl_gui_window_on_cell_tree_view_axes_write_edited_gtk_cell_renderer_text_edited (GtkCellRendererText* _sender, const gchar* path, const gchar* new_text, gpointer self) {
1588
1589 hkl_gui_window_on_cell_tree_view_axes_write_edited (path, new_text, self);
1590
1591 }
1592
1593
1594 static void _hkl_gui_window_on_cell_tree_view_axes_min_edited_gtk_cell_renderer_text_edited (GtkCellRendererText* _sender, const gchar* path, const gchar* new_text, gpointer self) {
1595
1596 hkl_gui_window_on_cell_tree_view_axes_min_edited (path, new_text, self);
1597
1598 }
1599
1600
1601 static void _hkl_gui_window_on_cell_tree_view_axes_max_edited_gtk_cell_renderer_text_edited (GtkCellRendererText* _sender, const gchar* path, const gchar* new_text, gpointer self) {
1602
1603 hkl_gui_window_on_cell_tree_view_axes_max_edited (path, new_text, self);
1604
1605 }
1606
1607
1608
1609 static void _hkl_gui_window_on_cell_tree_view_pseudo_axes_write_edited_gtk_cell_renderer_text_edited (GtkCellRendererText* _sender, const gchar* path, const gchar* new_text, gpointer self) {
1610
1611 hkl_gui_window_on_cell_tree_view_pseudo_axes_write_edited (path, new_text, self);
1612
1613 }
1614
1615
1616 static void _hkl_gui_window_on_cell_tree_view_pseudo_axes_is_initialized_toggled_gtk_cell_renderer_toggle_toggled (GtkCellRendererToggle* _sender, const gchar* path, gpointer self) {
1617
1618 hkl_gui_window_on_cell_tree_view_pseudo_axes_is_initialized_toggled (path, self);
1619
1620 }
1621
1622
1623 static void _hkl_gui_window_on_cell_tree_view_pseudo_axes_parameters_value_edited_gtk_cell_renderer_text_edited (GtkCellRendererText* _sender, const gchar* path, const gchar* new_text, gpointer self) {
1624
1625 hkl_gui_window_on_cell_tree_view_pseudo_axes_parameters_value_edited (path, new_text, self);
1626
1627 }
1628
1629
1630 static void hkl_gui_window_set_up_tree_view_pseudo_axes_parameters (HklGuiWindow* self) {
1631 GtkCellRendererText* renderer = NULL;
1632 GtkTreeViewColumn* column = NULL;
1633 GtkTreeView* _tmp0_;
1634 GList* _tmp1_ = NULL;
1635 GList* columns;
1636 GList* _tmp2_;
1637 GtkCellRendererText* _tmp5_;
1638 GtkCellRendererText* _tmp6_;
1639 GtkTreeViewColumn* _tmp7_;
1640 GtkTreeView* _tmp8_;
1641 GtkTreeViewColumn* _tmp9_;
1642 GtkCellRendererText* _tmp10_;
1643 GtkCellRendererText* _tmp11_;
1644 GtkCellRendererText* _tmp12_;
1645 GtkCellRendererText* _tmp13_;
1646 GtkTreeViewColumn* _tmp14_;
1647 GtkTreeView* _tmp15_;
1648 GtkTreeViewColumn* _tmp16_;
1649
1650 g_return_if_fail (self != NULL);
1651
1652 _tmp0_ = priv->_treeview_pseudo_axes_parameters;
1653
1654 _tmp1_ = gtk_tree_view_get_columns (_tmp0_);
1655
1656 columns = _tmp1_;
1657
1658 _tmp2_ = columns;
1659
1660 {
1661 GList* col_collection = NULL;
1662 GList* col_it = NULL;
1663
1664 col_collection = _tmp2_;
1665
1666 for (col_it = col_collection; col_it != NULL; col_it = col_it->next) {
1667
1668 GtkTreeViewColumn* col = NULL;
1669
1670 col = (GtkTreeViewColumn*) col_it->data;
1671
1672 {
1673 GtkTreeView* _tmp3_;
1674 GtkTreeViewColumn* _tmp4_;
1675
1676 _tmp3_ = priv->_treeview_pseudo_axes_parameters;
1677
1678 _tmp4_ = col;
1679
1680 gtk_tree_view_remove_column (_tmp3_, _tmp4_);
1681
1682 }
1683 }
1684 }
1685
1686 _tmp5_ = (GtkCellRendererText*) gtk_cell_renderer_text_new ();
1687
1688 g_object_ref_sink (_tmp5_);
1689
1690 _g_object_unref0 (renderer);
1691
1692 renderer = _tmp5_;
1693
1694 _tmp6_ = renderer;
1695
1696 _tmp7_ = gtk_tree_view_column_new_with_attributes ("name", (GtkCellRenderer*) _tmp6_, "text", PARAMETER_COL_NAME, NULL);
1697
1698 g_object_ref_sink (_tmp7_);
1699
1700 _g_object_unref0 (column);
1701
1702 column = _tmp7_;
1703
1704 _tmp8_ = priv->_treeview_pseudo_axes_parameters;
1705
1706 _tmp9_ = column;
1707
1708 gtk_tree_view_append_column (_tmp8_, _tmp9_);
1709
1710 _tmp10_ = (GtkCellRendererText*) gtk_cell_renderer_text_new ();
1711
1712 g_object_ref_sink (_tmp10_);
1713
1714 _g_object_unref0 (renderer);
1715
1716 renderer = _tmp10_;
1717
1718 _tmp11_ = renderer;
1719
1720 g_signal_connect_object (_tmp11_, "edited", (GCallback) _hkl_gui_window_on_cell_tree_view_pseudo_axes_parameters_value_edited_gtk_cell_renderer_text_edited, self, 0);
1721
1722 _tmp12_ = renderer;
1723
1724 g_object_set (_tmp12_, "editable", TRUE, NULL);
1725
1726 _tmp13_ = renderer;
1727
1728 _tmp14_ = gtk_tree_view_column_new_with_attributes ("read", (GtkCellRenderer*) _tmp13_, "text", PARAMETER_COL_VALUE, NULL);
1729
1730 g_object_ref_sink (_tmp14_);
1731
1732 _g_object_unref0 (column);
1733
1734 column = _tmp14_;
1735
1736 _tmp15_ = priv->_treeview_pseudo_axes_parameters;
1737
1738 _tmp16_ = column;
1739
1740 gtk_tree_view_append_column (_tmp15_, _tmp16_);
1741
1742 _g_list_free0 (columns);
1743
1744 _g_object_unref0 (column);
1745
1746 _g_object_unref0 (renderer);
1747
1748 }
1749
1750
1751 static void _hkl_gui_window_on_tree_view1_cursor_changed_gtk_tree_view_cursor_changed (GtkTreeView* _sender, gpointer self) {
1752
1753 hkl_gui_window_on_tree_view1_cursor_changed (self);
1754
1755 }
1756
1757
1758
1759
1760
1761
1762 static void _hkl_gui_window_on_cell_tree_view_crystals_name_edited_gtk_cell_renderer_text_edited (GtkCellRendererText* _sender, const gchar* path, const gchar* new_text, gpointer self) {
1763
1764 hkl_gui_window_on_cell_tree_view_crystals_name_edited (path, new_text, self);
1765
1766 }
1767
1768
1769 static void hkl_gui_window_set_up_tree_view_crystals (HklGuiWindow* self) {
1770 GtkTreeViewColumn* column = NULL;
1771 GtkCellRendererText* renderer = NULL;
1772 GtkTreeView* _tmp0_;
1773 GList* _tmp1_ = NULL;
1774 GList* columns;
1775 GList* _tmp2_;
1776 GtkCellRendererText* _tmp5_;
1777 GtkCellRendererText* _tmp6_;
1778 GtkCellRendererText* _tmp7_;
1779 GtkCellRendererText* _tmp8_;
1780 GtkTreeViewColumn* _tmp9_;
1781 GtkTreeView* _tmp10_;
1782 GtkTreeViewColumn* _tmp11_;
1783 GtkCellRendererText* _tmp12_;
1784 GtkCellRendererText* _tmp13_;
1785 GtkTreeViewColumn* _tmp14_;
1786 GtkTreeView* _tmp15_;
1787 GtkTreeViewColumn* _tmp16_;
1788 GtkCellRendererText* _tmp17_;
1789 GtkCellRendererText* _tmp18_;
1790 GtkTreeViewColumn* _tmp19_;
1791 GtkTreeView* _tmp20_;
1792 GtkTreeViewColumn* _tmp21_;
1793 GtkCellRendererText* _tmp22_;
1794 GtkCellRendererText* _tmp23_;
1795 GtkTreeViewColumn* _tmp24_;
1796 GtkTreeView* _tmp25_;
1797 GtkTreeViewColumn* _tmp26_;
1798 GtkCellRendererText* _tmp27_;
1799 GtkCellRendererText* _tmp28_;
1800 GtkTreeViewColumn* _tmp29_;
1801 GtkTreeView* _tmp30_;
1802 GtkTreeViewColumn* _tmp31_;
1803 GtkCellRendererText* _tmp32_;
1804 GtkCellRendererText* _tmp33_;
1805 GtkTreeViewColumn* _tmp34_;
1806 GtkTreeView* _tmp35_;
1807 GtkTreeViewColumn* _tmp36_;
1808 GtkCellRendererText* _tmp37_;
1809 GtkCellRendererText* _tmp38_;
1810 GtkTreeViewColumn* _tmp39_;
1811 GtkTreeView* _tmp40_;
1812 GtkTreeViewColumn* _tmp41_;
1813 GtkTreeView* _tmp42_;
1814 GtkTreeSelection* _tmp43_ = NULL;
1815
1816 g_return_if_fail (self != NULL);
1817
1818 _tmp0_ = priv->_treeview_crystals;
1819
1820 _tmp1_ = gtk_tree_view_get_columns (_tmp0_);
1821
1822 columns = _tmp1_;
1823
1824 _tmp2_ = columns;
1825
1826 {
1827 GList* col_collection = NULL;
1828 GList* col_it = NULL;
1829
1830 col_collection = _tmp2_;
1831
1832 for (col_it = col_collection; col_it != NULL; col_it = col_it->next) {
1833
1834 GtkTreeViewColumn* col = NULL;
1835
1836 col = (GtkTreeViewColumn*) col_it->data;
1837
1838 {
1839 GtkTreeView* _tmp3_;
1840 GtkTreeViewColumn* _tmp4_;
1841
1842 _tmp3_ = priv->_treeview_crystals;
1843
1844 _tmp4_ = col;
1845
1846 gtk_tree_view_remove_column (_tmp3_, _tmp4_);
1847
1848 }
1849 }
1850 }
1851
1852 _tmp5_ = (GtkCellRendererText*) gtk_cell_renderer_text_new ();
1853
1854 g_object_ref_sink (_tmp5_);
1855
1856 _g_object_unref0 (renderer);
1857
1858 renderer = _tmp5_;
1859
1860 _tmp6_ = renderer;
1861
1862 g_signal_connect_object (_tmp6_, "edited", (GCallback) _hkl_gui_window_on_cell_tree_view_crystals_name_edited_gtk_cell_renderer_text_edited, self, 0);
1863
1864 _tmp7_ = renderer;
1865
1866 g_object_set (_tmp7_, "editable", TRUE, NULL);
1867
1868 _tmp8_ = renderer;
1869
1870 _tmp9_ = gtk_tree_view_column_new_with_attributes ("name", (GtkCellRenderer*) _tmp8_, "text", SAMPLE_COL_NAME, NULL);
1871
1872 g_object_ref_sink (_tmp9_);
1873
1874 _g_object_unref0 (column);
1875
1876 column = _tmp9_;
1877
1878 _tmp10_ = priv->_treeview_crystals;
1879
1880 _tmp11_ = column;
1881
1882 gtk_tree_view_append_column (_tmp10_, _tmp11_);
1883
1884 _tmp12_ = (GtkCellRendererText*) gtk_cell_renderer_text_new ();
1885
1886 g_object_ref_sink (_tmp12_);
1887
1888 _g_object_unref0 (renderer);
1889
1890 renderer = _tmp12_;
1891
1892 _tmp13_ = renderer;
1893
1894 _tmp14_ = gtk_tree_view_column_new_with_attributes ("a", (GtkCellRenderer*) _tmp13_, "text", SAMPLE_COL_A, NULL);
1895
1896 g_object_ref_sink (_tmp14_);
1897
1898 _g_object_unref0 (column);
1899
1900 column = _tmp14_;
1901
1902 _tmp15_ = priv->_treeview_crystals;
1903
1904 _tmp16_ = column;
1905
1906 gtk_tree_view_append_column (_tmp15_, _tmp16_);
1907
1908 _tmp17_ = (GtkCellRendererText*) gtk_cell_renderer_text_new ();
1909
1910 g_object_ref_sink (_tmp17_);
1911
1912 _g_object_unref0 (renderer);
1913
1914 renderer = _tmp17_;
1915
1916 _tmp18_ = renderer;
1917
1918 _tmp19_ = gtk_tree_view_column_new_with_attributes ("b", (GtkCellRenderer*) _tmp18_, "text", SAMPLE_COL_B, NULL);
1919
1920 g_object_ref_sink (_tmp19_);
1921
1922 _g_object_unref0 (column);
1923
1924 column = _tmp19_;
1925
1926 _tmp20_ = priv->_treeview_crystals;
1927
1928 _tmp21_ = column;
1929
1930 gtk_tree_view_append_column (_tmp20_, _tmp21_);
1931
1932 _tmp22_ = (GtkCellRendererText*) gtk_cell_renderer_text_new ();
1933
1934 g_object_ref_sink (_tmp22_);
1935
1936 _g_object_unref0 (renderer);
1937
1938 renderer = _tmp22_;
1939
1940 _tmp23_ = renderer;
1941
1942 _tmp24_ = gtk_tree_view_column_new_with_attributes ("c", (GtkCellRenderer*) _tmp23_, "text", SAMPLE_COL_C, NULL);
1943
1944 g_object_ref_sink (_tmp24_);
1945
1946 _g_object_unref0 (column);
1947
1948 column = _tmp24_;
1949
1950 _tmp25_ = priv->_treeview_crystals;
1951
1952 _tmp26_ = column;
1953
1954 gtk_tree_view_append_column (_tmp25_, _tmp26_);
1955
1956 _tmp27_ = (GtkCellRendererText*) gtk_cell_renderer_text_new ();
1957
1958 g_object_ref_sink (_tmp27_);
1959
1960 _g_object_unref0 (renderer);
1961
1962 renderer = _tmp27_;
1963
1964 _tmp28_ = renderer;
1965
1966 _tmp29_ = gtk_tree_view_column_new_with_attributes ("alpha", (GtkCellRenderer*) _tmp28_, "text", SAMPLE_COL_ALPHA, NULL);
1967
1968 g_object_ref_sink (_tmp29_);
1969
1970 _g_object_unref0 (column);
1971
1972 column = _tmp29_;
1973
1974 _tmp30_ = priv->_treeview_crystals;
1975
1976 _tmp31_ = column;
1977
1978 gtk_tree_view_append_column (_tmp30_, _tmp31_);
1979
1980 _tmp32_ = (GtkCellRendererText*) gtk_cell_renderer_text_new ();
1981
1982 g_object_ref_sink (_tmp32_);
1983
1984 _g_object_unref0 (renderer);
1985
1986 renderer = _tmp32_;
1987
1988 _tmp33_ = renderer;
1989
1990 _tmp34_ = gtk_tree_view_column_new_with_attributes ("beta", (GtkCellRenderer*) _tmp33_, "text", SAMPLE_COL_BETA, NULL);
1991
1992 g_object_ref_sink (_tmp34_);
1993
1994 _g_object_unref0 (column);
1995
1996 column = _tmp34_;
1997
1998 _tmp35_ = priv->_treeview_crystals;
1999
2000 _tmp36_ = column;
2001
2002 gtk_tree_view_append_column (_tmp35_, _tmp36_);
2003
2004 _tmp37_ = (GtkCellRendererText*) gtk_cell_renderer_text_new ();
2005
2006 g_object_ref_sink (_tmp37_);
2007
2008 _g_object_unref0 (renderer);
2009
2010 renderer = _tmp37_;
2011
2012 _tmp38_ = renderer;
2013
2014 _tmp39_ = gtk_tree_view_column_new_with_attributes ("gamma", (GtkCellRenderer*) _tmp38_, "text", SAMPLE_COL_GAMMA, NULL);
2015
2016 g_object_ref_sink (_tmp39_);
2017
2018 _g_object_unref0 (column);
2019
2020 column = _tmp39_;
2021
2022 _tmp40_ = priv->_treeview_crystals;
2023
2024 _tmp41_ = column;
2025
2026 gtk_tree_view_append_column (_tmp40_, _tmp41_);
2027
2028 _tmp42_ = priv->_treeview_crystals;
2029
2030 _tmp43_ = gtk_tree_view_get_selection (_tmp42_);
2031
2032 gtk_tree_selection_set_mode (_tmp43_, GTK_SELECTION_MULTIPLE);
2033
2034 _g_list_free0 (columns);
2035
2036 _g_object_unref0 (renderer);
2037
2038 _g_object_unref0 (column);
2039
2040 }
2041
2042
2043 static void hkl_gui_window_set_up_3D (HklGuiWindow* self) {
2044 HklGeometry* _tmp0_;
2045 HklGeometryConfig* _tmp1_;
2046 HklGeometryType _tmp2_;
2047 GtkVBox* _tmp7_;
2048 HklGui3DFrame* _tmp8_;
2049 GtkFrame* _tmp9_ = NULL;
2050 GtkFrame* _tmp10_;
2051 GtkVBox* _tmp11_;
2052
2053 g_return_if_fail (self != NULL);
2054
2055 _tmp0_ = priv->geometry;
2056
2057 _tmp1_ = _tmp0_->config;
2058
2059 _tmp2_ = (*_tmp1_).type;
2060
2061 switch (_tmp2_) {
2062
2063 case HKL_GEOMETRY_TYPE_KAPPA6C:
2064
2065 {
2066 HklGeometry* _tmp3_;
2067 HklGui3DFrame* _tmp4_;
2068
2069 _tmp3_ = priv->geometry;
2070
2071 _tmp4_ = hkl_gui_3d_frame_new ("../data/diffabs.yaml", _tmp3_);
2072
2073 _g_object_unref0 (priv->Frame3D);
2074
2075 priv->Frame3D = _tmp4_;
2076
2077 break;
2078
2079 }
2080
2081 case HKL_GEOMETRY_TYPE_KAPPA4C_VERTICAL:
2082
2083 {
2084 HklGeometry* _tmp5_;
2085 HklGui3DFrame* _tmp6_;
2086
2087 _tmp5_ = priv->geometry;
2088
2089 _tmp6_ = hkl_gui_3d_frame_new ("../data/cristal4C.yaml", _tmp5_);
2090
2091 _g_object_unref0 (priv->Frame3D);
2092
2093 priv->Frame3D = _tmp6_;
2094
2095 break;
2096
2097 }
2098 default:
2099
2100 break;
2101
2102 }
2103
2104 _tmp7_ = priv->_vbox7;
2105
2106 _tmp8_ = priv->Frame3D;
2107
2108 _tmp9_ = hkl_gui_3d_frame_frame (_tmp8_);
2109
2110 _tmp10_ = _tmp9_;
2111
2112 gtk_box_pack_start ((GtkBox*) _tmp7_, (GtkWidget*) _tmp10_, TRUE, TRUE, (guint) 0);
2113
2114 _g_object_unref0 (_tmp10_);
2115
2116 _tmp11_ = priv->_vbox7;
2117
2118 gtk_widget_show_all ((GtkWidget*) _tmp11_);
2119
2120 }
2121
2122
2123 static void hkl_gui_window_update_source (HklGuiWindow* self) {
2124 HklGeometry* _tmp0_;
2125
2126 g_return_if_fail (self != NULL);
2127
2128 _tmp0_ = priv->geometry;
2129
2130 if (_tmp0_ != NULL) {
2131
2132 HklGeometry* _tmp1_;
2133 gdouble _tmp2_ = 0.0;
2134 gdouble lambda;
2135 GtkSpinButton* _tmp3_;
2136 gdouble _tmp4_;
2137
2138 _tmp1_ = priv->geometry;
2139
2140 _tmp2_ = hkl_source_get_wavelength (&_tmp1_->source);
2141
2142 lambda = _tmp2_;
2143
2144 _tmp3_ = priv->_spinbutton_lambda;
2145
2146 _tmp4_ = lambda;
2147
2148 gtk_spin_button_set_value (_tmp3_, _tmp4_);
2149
2150 }
2151 }
2152
2153
2154 static void hkl_gui_window_update_pseudo_axes_parameters (HklGuiWindow* self) {
2155 GeeHashMap* _tmp0_;
2156 GeeMapIterator* _tmp1_ = NULL;
2157 GeeMapIterator* iter;
2158
2159 g_return_if_fail (self != NULL);
2160
2161 _tmp0_ = priv->hash_store_pseudo_axis_parameter;
2162
2163 _tmp1_ = gee_abstract_map_map_iterator ((GeeAbstractMap*) _tmp0_);
2164
2165 iter = _tmp1_;
2166
2167 while (TRUE) {
2168
2169 GeeMapIterator* _tmp2_;
2170 gboolean _tmp3_ = FALSE;
2171 GtkListStore* model = NULL;
2172 GtkTreeIter iter2 = {0};
2173 gboolean valid = FALSE;
2174 GeeMapIterator* _tmp4_;
2175 gpointer _tmp5_ = NULL;
2176 GtkListStore* _tmp6_;
2177 GtkTreeIter _tmp7_ = {0};
2178 gboolean _tmp8_ = FALSE;
2179
2180 _tmp2_ = iter;
2181
2182 _tmp3_ = gee_map_iterator_next (_tmp2_);
2183
2184 if (!_tmp3_) {
2185
2186 break;
2187
2188 }
2189
2190 _tmp4_ = iter;
2191
2192 _tmp5_ = gee_map_iterator_get_value (_tmp4_);
2193
2194 _g_object_unref0 (model);
2195
2196 model = (GtkListStore*) _tmp5_;
2197
2198 _tmp6_ = model;
2199
2200 _tmp8_ = gtk_tree_model_get_iter_first ((GtkTreeModel*) _tmp6_, &_tmp7_);
2201
2202 iter2 = _tmp7_;
2203
2204 valid = _tmp8_;
2205
2206 while (TRUE) {
2207
2208 gboolean _tmp9_;
2209 HklParameter* parameter = NULL;
2210 GtkListStore* _tmp10_;
2211 GtkTreeIter _tmp11_;
2212 GtkListStore* _tmp12_;
2213 GtkTreeIter _tmp13_;
2214 HklParameter* _tmp14_;
2215 const gchar* _tmp15_;
2216 HklParameter* _tmp16_;
2217 HklParameter _tmp17_;
2218 gdouble _tmp18_ = 0.0;
2219 GtkListStore* _tmp19_;
2220 gboolean _tmp20_ = FALSE;
2221
2222 _tmp9_ = valid;
2223
2224 if (!_tmp9_) {
2225
2226 break;
2227
2228 }
2229
2230 _tmp10_ = model;
2231
2232 _tmp11_ = iter2;
2233
2234 gtk_tree_model_get ((GtkTreeModel*) _tmp10_, &_tmp11_, PARAMETER_COL_PARAMETER, &parameter, -1);
2235
2236 _tmp12_ = model;
2237
2238 _tmp13_ = iter2;
2239
2240 _tmp14_ = parameter;
2241
2242 _tmp15_ = (*_tmp14_).name;
2243
2244 _tmp16_ = parameter;
2245
2246 _tmp17_ = *_tmp16_;
2247
2248 _tmp18_ = hkl_parameter_get_value_unit (&_tmp17_);
2249
2250 gtk_list_store_set (_tmp12_, &_tmp13_, PARAMETER_COL_NAME, _tmp15_, PARAMETER_COL_VALUE, _tmp18_, -1);
2251
2252 _tmp19_ = model;
2253
2254 _tmp20_ = gtk_tree_model_iter_next ((GtkTreeModel*) _tmp19_, &iter2);
2255
2256 valid = _tmp20_;
2257
2258 }
2259
2260 _g_object_unref0 (model);
2261
2262 }
2263
2264 _g_object_unref0 (iter);
2265
2266 }
2267
2268
2269 static void hkl_gui_window_update_lattice (HklGuiWindow* self) {
2270 HklSampleList* _tmp0_;
2271 HklSample* _tmp1_;
2272 HklSample* sample;
2273 HklSample* _tmp2_;
2274
2275 g_return_if_fail (self != NULL);
2276
2277 _tmp0_ = priv->samples;
2278
2279 _tmp1_ = _tmp0_->current;
2280
2281 sample = _tmp1_;
2282
2283 _tmp2_ = sample;
2284
2285 if (_tmp2_ != NULL) {
2286
2287 GtkSpinButton* _tmp3_;
2288 HklSample* _tmp4_;
2289 HklLattice* _tmp5_;
2290 HklParameter* _tmp6_;
2291 HklParameter _tmp7_;
2292 gdouble _tmp8_ = 0.0;
2293 GtkSpinButton* _tmp9_;
2294 HklSample* _tmp10_;
2295 HklLattice* _tmp11_;
2296 HklParameter* _tmp12_;
2297 HklParameter _tmp13_;
2298 gdouble _tmp14_ = 0.0;
2299 GtkSpinButton* _tmp15_;
2300 HklSample* _tmp16_;
2301 HklLattice* _tmp17_;
2302 HklParameter* _tmp18_;
2303 HklParameter _tmp19_;
2304 gdouble _tmp20_ = 0.0;
2305 GtkSpinButton* _tmp21_;
2306 HklSample* _tmp22_;
2307 HklLattice* _tmp23_;
2308 HklParameter* _tmp24_;
2309 HklParameter _tmp25_;
2310 gdouble _tmp26_ = 0.0;
2311 GtkSpinButton* _tmp27_;
2312 HklSample* _tmp28_;
2313 HklLattice* _tmp29_;
2314 HklParameter* _tmp30_;
2315 HklParameter _tmp31_;
2316 gdouble _tmp32_ = 0.0;
2317 GtkSpinButton* _tmp33_;
2318 HklSample* _tmp34_;
2319 HklLattice* _tmp35_;
2320 HklParameter* _tmp36_;
2321 HklParameter _tmp37_;
2322 gdouble _tmp38_ = 0.0;
2323
2324 _tmp3_ = priv->_spinbutton_a;
2325
2326 _tmp4_ = sample;
2327
2328 _tmp5_ = _tmp4_->lattice;
2329
2330 _tmp6_ = _tmp5_->a;
2331
2332 _tmp7_ = *_tmp6_;
2333
2334 _tmp8_ = hkl_parameter_get_value_unit (&_tmp7_);
2335
2336 gtk_spin_button_set_value (_tmp3_, _tmp8_);
2337
2338 _tmp9_ = priv->_spinbutton_b;
2339
2340 _tmp10_ = sample;
2341
2342 _tmp11_ = _tmp10_->lattice;
2343
2344 _tmp12_ = _tmp11_->b;
2345
2346 _tmp13_ = *_tmp12_;
2347
2348 _tmp14_ = hkl_parameter_get_value_unit (&_tmp13_);
2349
2350 gtk_spin_button_set_value (_tmp9_, _tmp14_);
2351
2352 _tmp15_ = priv->_spinbutton_c;
2353
2354 _tmp16_ = sample;
2355
2356 _tmp17_ = _tmp16_->lattice;
2357
2358 _tmp18_ = _tmp17_->c;
2359
2360 _tmp19_ = *_tmp18_;
2361
2362 _tmp20_ = hkl_parameter_get_value_unit (&_tmp19_);
2363
2364 gtk_spin_button_set_value (_tmp15_, _tmp20_);
2365
2366 _tmp21_ = priv->_spinbutton_alpha;
2367
2368 _tmp22_ = sample;
2369
2370 _tmp23_ = _tmp22_->lattice;
2371
2372 _tmp24_ = _tmp23_->alpha;
2373
2374 _tmp25_ = *_tmp24_;
2375
2376 _tmp26_ = hkl_parameter_get_value_unit (&_tmp25_);
2377
2378 gtk_spin_button_set_value (_tmp21_, _tmp26_);
2379
2380 _tmp27_ = priv->_spinbutton_beta;
2381
2382 _tmp28_ = sample;
2383
2384 _tmp29_ = _tmp28_->lattice;
2385
2386 _tmp30_ = _tmp29_->beta;
2387
2388 _tmp31_ = *_tmp30_;
2389
2390 _tmp32_ = hkl_parameter_get_value_unit (&_tmp31_);
2391
2392 gtk_spin_button_set_value (_tmp27_, _tmp32_);
2393
2394 _tmp33_ = priv->_spinbutton_gamma;
2395
2396 _tmp34_ = sample;
2397
2398 _tmp35_ = _tmp34_->lattice;
2399
2400 _tmp36_ = _tmp35_->gamma;
2401
2402 _tmp37_ = *_tmp36_;
2403
2404 _tmp38_ = hkl_parameter_get_value_unit (&_tmp37_);
2405
2406 gtk_spin_button_set_value (_tmp33_, _tmp38_);
2407
2408 }
2409 }
2410
2411
2412 static void hkl_gui_window_update_lattice_parameters (HklGuiWindow* self) {
2413 HklSampleList* _tmp0_;
2414 HklSample* _tmp1_;
2415 HklSample* sample;
2416 HklSample* _tmp2_;
2417
2418 g_return_if_fail (self != NULL);
2419
2420 _tmp0_ = priv->samples;
2421
2422 _tmp1_ = _tmp0_->current;
2423
2424 sample = _tmp1_;
2425
2426 _tmp2_ = sample;
2427
2428 if (_tmp2_ != NULL) {
2429
2430 gdouble min = 0.0;
2431 gdouble max = 0.0;
2432 HklParameter* parameter = NULL;
2433 HklSample* _tmp3_;
2434 HklLattice* _tmp4_;
2435 HklParameter* _tmp5_;
2436 HklParameter* _tmp6_;
2437 HklParameter _tmp7_;
2438 gdouble _tmp8_ = 0.0;
2439 gdouble _tmp9_ = 0.0;
2440 GtkSpinButton* _tmp10_;
2441 gdouble _tmp11_;
2442 GtkSpinButton* _tmp12_;
2443 gdouble _tmp13_;
2444 GtkCheckButton* _tmp14_;
2445 HklParameter* _tmp15_;
2446 gboolean _tmp16_;
2447 HklSample* _tmp17_;
2448 HklLattice* _tmp18_;
2449 HklParameter* _tmp19_;
2450 HklParameter* _tmp20_;
2451 HklParameter _tmp21_;
2452 gdouble _tmp22_ = 0.0;
2453 gdouble _tmp23_ = 0.0;
2454 GtkSpinButton* _tmp24_;
2455 gdouble _tmp25_;
2456 GtkSpinButton* _tmp26_;
2457 gdouble _tmp27_;
2458 GtkCheckButton* _tmp28_;
2459 HklParameter* _tmp29_;
2460 gboolean _tmp30_;
2461 HklSample* _tmp31_;
2462 HklLattice* _tmp32_;
2463 HklParameter* _tmp33_;
2464 HklParameter* _tmp34_;
2465 HklParameter _tmp35_;
2466 gdouble _tmp36_ = 0.0;
2467 gdouble _tmp37_ = 0.0;
2468 GtkSpinButton* _tmp38_;
2469 gdouble _tmp39_;
2470 GtkSpinButton* _tmp40_;
2471 gdouble _tmp41_;
2472 GtkCheckButton* _tmp42_;
2473 HklParameter* _tmp43_;
2474 gboolean _tmp44_;
2475 HklSample* _tmp45_;
2476 HklLattice* _tmp46_;
2477 HklParameter* _tmp47_;
2478 HklParameter* _tmp48_;
2479 HklParameter _tmp49_;
2480 gdouble _tmp50_ = 0.0;
2481 gdouble _tmp51_ = 0.0;
2482 GtkSpinButton* _tmp52_;
2483 gdouble _tmp53_;
2484 GtkSpinButton* _tmp54_;
2485 gdouble _tmp55_;
2486 GtkCheckButton* _tmp56_;
2487 HklParameter* _tmp57_;
2488 gboolean _tmp58_;
2489 HklSample* _tmp59_;
2490 HklLattice* _tmp60_;
2491 HklParameter* _tmp61_;
2492 HklParameter* _tmp62_;
2493 HklParameter _tmp63_;
2494 gdouble _tmp64_ = 0.0;
2495 gdouble _tmp65_ = 0.0;
2496 GtkSpinButton* _tmp66_;
2497 gdouble _tmp67_;
2498 GtkSpinButton* _tmp68_;
2499 gdouble _tmp69_;
2500 GtkCheckButton* _tmp70_;
2501 HklParameter* _tmp71_;
2502 gboolean _tmp72_;
2503 HklSample* _tmp73_;
2504 HklLattice* _tmp74_;
2505 HklParameter* _tmp75_;
2506 HklParameter* _tmp76_;
2507 HklParameter _tmp77_;
2508 gdouble _tmp78_ = 0.0;
2509 gdouble _tmp79_ = 0.0;
2510 GtkSpinButton* _tmp80_;
2511 gdouble _tmp81_;
2512 GtkSpinButton* _tmp82_;
2513 gdouble _tmp83_;
2514 GtkCheckButton* _tmp84_;
2515 HklParameter* _tmp85_;
2516 gboolean _tmp86_;
2517
2518 _tmp3_ = sample;
2519
2520 _tmp4_ = _tmp3_->lattice;
2521
2522 _tmp5_ = _tmp4_->a;
2523
2524 parameter = _tmp5_;
2525
2526 _tmp6_ = parameter;
2527
2528 _tmp7_ = *_tmp6_;
2529
2530 hkl_parameter_get_range_unit (&_tmp7_, &_tmp8_, &_tmp9_);
2531
2532 min = _tmp8_;
2533
2534 max = _tmp9_;
2535
2536 _tmp10_ = priv->_spinbutton_a_min;
2537
2538 _tmp11_ = min;
2539
2540 gtk_spin_button_set_value (_tmp10_, _tmp11_);
2541
2542 _tmp12_ = priv->_spinbutton_a_max;
2543
2544 _tmp13_ = max;
2545
2546 gtk_spin_button_set_value (_tmp12_, _tmp13_);
2547
2548 _tmp14_ = priv->_checkbutton_a;
2549
2550 _tmp15_ = parameter;
2551
2552 _tmp16_ = (*_tmp15_).fit;
2553
2554 gtk_toggle_button_set_active ((GtkToggleButton*) _tmp14_, _tmp16_);
2555
2556 _tmp17_ = sample;
2557
2558 _tmp18_ = _tmp17_->lattice;
2559
2560 _tmp19_ = _tmp18_->b;
2561
2562 parameter = _tmp19_;
2563
2564 _tmp20_ = parameter;
2565
2566 _tmp21_ = *_tmp20_;
2567
2568 hkl_parameter_get_range_unit (&_tmp21_, &_tmp22_, &_tmp23_);
2569
2570 min = _tmp22_;
2571
2572 max = _tmp23_;
2573
2574 _tmp24_ = priv->_spinbutton_b_min;
2575
2576 _tmp25_ = min;
2577
2578 gtk_spin_button_set_value (_tmp24_, _tmp25_);
2579
2580 _tmp26_ = priv->_spinbutton_b_max;
2581
2582 _tmp27_ = max;
2583
2584 gtk_spin_button_set_value (_tmp26_, _tmp27_);
2585
2586 _tmp28_ = priv->_checkbutton_b;
2587
2588 _tmp29_ = parameter;
2589
2590 _tmp30_ = (*_tmp29_).fit;
2591
2592 gtk_toggle_button_set_active ((GtkToggleButton*) _tmp28_, _tmp30_);
2593
2594 _tmp31_ = sample;
2595
2596 _tmp32_ = _tmp31_->lattice;
2597
2598 _tmp33_ = _tmp32_->c;
2599
2600 parameter = _tmp33_;
2601
2602 _tmp34_ = parameter;
2603
2604 _tmp35_ = *_tmp34_;
2605
2606 hkl_parameter_get_range_unit (&_tmp35_, &_tmp36_, &_tmp37_);
2607
2608 min = _tmp36_;
2609
2610 max = _tmp37_;
2611
2612 _tmp38_ = priv->_spinbutton_c_min;
2613
2614 _tmp39_ = min;
2615
2616 gtk_spin_button_set_value (_tmp38_, _tmp39_);
2617
2618 _tmp40_ = priv->_spinbutton_c_max;
2619
2620 _tmp41_ = max;
2621
2622 gtk_spin_button_set_value (_tmp40_, _tmp41_);
2623
2624 _tmp42_ = priv->_checkbutton_c;
2625
2626 _tmp43_ = parameter;
2627
2628 _tmp44_ = (*_tmp43_).fit;
2629
2630 gtk_toggle_button_set_active ((GtkToggleButton*) _tmp42_, _tmp44_);
2631
2632 _tmp45_ = sample;
2633
2634 _tmp46_ = _tmp45_->lattice;
2635
2636 _tmp47_ = _tmp46_->alpha;
2637
2638 parameter = _tmp47_;
2639
2640 _tmp48_ = parameter;
2641
2642 _tmp49_ = *_tmp48_;
2643
2644 hkl_parameter_get_range_unit (&_tmp49_, &_tmp50_, &_tmp51_);
2645
2646 min = _tmp50_;
2647
2648 max = _tmp51_;
2649
2650 _tmp52_ = priv->_spinbutton_alpha_min;
2651
2652 _tmp53_ = min;
2653
2654 gtk_spin_button_set_value (_tmp52_, _tmp53_);
2655
2656 _tmp54_ = priv->_spinbutton_alpha_max;
2657
2658 _tmp55_ = max;
2659
2660 gtk_spin_button_set_value (_tmp54_, _tmp55_);
2661
2662 _tmp56_ = priv->_checkbutton_alpha;
2663
2664 _tmp57_ = parameter;
2665
2666 _tmp58_ = (*_tmp57_).fit;
2667
2668 gtk_toggle_button_set_active ((GtkToggleButton*) _tmp56_, _tmp58_);
2669
2670 _tmp59_ = sample;
2671
2672 _tmp60_ = _tmp59_->lattice;
2673
2674 _tmp61_ = _tmp60_->beta;
2675
2676 parameter = _tmp61_;
2677
2678 _tmp62_ = parameter;
2679
2680 _tmp63_ = *_tmp62_;
2681
2682 hkl_parameter_get_range_unit (&_tmp63_, &_tmp64_, &_tmp65_);
2683
2684 min = _tmp64_;
2685
2686 max = _tmp65_;
2687
2688 _tmp66_ = priv->_spinbutton_beta_min;
2689
2690 _tmp67_ = min;
2691
2692 gtk_spin_button_set_value (_tmp66_, _tmp67_);
2693
2694 _tmp68_ = priv->_spinbutton_beta_max;
2695
2696 _tmp69_ = max;
2697
2698 gtk_spin_button_set_value (_tmp68_, _tmp69_);
2699
2700 _tmp70_ = priv->_checkbutton_beta;
2701
2702 _tmp71_ = parameter;
2703
2704 _tmp72_ = (*_tmp71_).fit;
2705
2706 gtk_toggle_button_set_active ((GtkToggleButton*) _tmp70_, _tmp72_);
2707
2708 _tmp73_ = sample;
2709
2710 _tmp74_ = _tmp73_->lattice;
2711
2712 _tmp75_ = _tmp74_->gamma;
2713
2714 parameter = _tmp75_;
2715
2716 _tmp76_ = parameter;
2717
2718 _tmp77_ = *_tmp76_;
2719
2720 hkl_parameter_get_range_unit (&_tmp77_, &_tmp78_, &_tmp79_);
2721
2722 min = _tmp78_;
2723
2724 max = _tmp79_;
2725
2726 _tmp80_ = priv->_spinbutton_gamma_min;
2727
2728 _tmp81_ = min;
2729
2730 gtk_spin_button_set_value (_tmp80_, _tmp81_);
2731
2732 _tmp82_ = priv->_spinbutton_gamma_max;
2733
2734 _tmp83_ = max;
2735
2736 gtk_spin_button_set_value (_tmp82_, _tmp83_);
2737
2738 _tmp84_ = priv->_checkbutton_gamma;
2739
2740 _tmp85_ = parameter;
2741
2742 _tmp86_ = (*_tmp85_).fit;
2743
2744 gtk_toggle_button_set_active ((GtkToggleButton*) _tmp84_, _tmp86_);
2745
2746 }
2747 }
2748
2749
2750 static void hkl_gui_window_update_reciprocal_lattice (HklGuiWindow* self) {
2751 HklSampleList* _tmp0_;
2752 HklSample* _tmp1_;
2753 HklSample* sample;
2754 HklSample* _tmp2_;
2755
2756 g_return_if_fail (self != NULL);
2757
2758 _tmp0_ = priv->samples;
2759
2760 _tmp1_ = _tmp0_->current;
2761
2762 sample = _tmp1_;
2763
2764 _tmp2_ = sample;
2765
2766 if (_tmp2_ != NULL) {
2767
2768 HklSample* _tmp3_;
2769 HklLattice* _tmp4_;
2770 HklLattice* _tmp5_;
2771 GtkSpinButton* _tmp6_;
2772 HklLattice* _tmp7_;
2773 HklParameter* _tmp8_;
2774 HklParameter _tmp9_;
2775 gdouble _tmp10_ = 0.0;
2776 GtkSpinButton* _tmp11_;
2777 HklLattice* _tmp12_;
2778 HklParameter* _tmp13_;
2779 HklParameter _tmp14_;
2780 gdouble _tmp15_ = 0.0;
2781 GtkSpinButton* _tmp16_;
2782 HklLattice* _tmp17_;
2783 HklParameter* _tmp18_;
2784 HklParameter _tmp19_;
2785 gdouble _tmp20_ = 0.0;
2786 GtkSpinButton* _tmp21_;
2787 HklLattice* _tmp22_;
2788 HklParameter* _tmp23_;
2789 HklParameter _tmp24_;
2790 gdouble _tmp25_ = 0.0;
2791 GtkSpinButton* _tmp26_;
2792 HklLattice* _tmp27_;
2793 HklParameter* _tmp28_;
2794 HklParameter _tmp29_;
2795 gdouble _tmp30_ = 0.0;
2796 GtkSpinButton* _tmp31_;
2797 HklLattice* _tmp32_;
2798 HklParameter* _tmp33_;
2799 HklParameter _tmp34_;
2800 gdouble _tmp35_ = 0.0;
2801
2802 _tmp3_ = sample;
2803
2804 _tmp4_ = _tmp3_->lattice;
2805
2806 _tmp5_ = priv->reciprocal;
2807
2808 hkl_lattice_reciprocal (_tmp4_, _tmp5_);
2809
2810 _tmp6_ = priv->_spinbutton_a_star;
2811
2812 _tmp7_ = priv->reciprocal;
2813
2814 _tmp8_ = _tmp7_->a;
2815
2816 _tmp9_ = *_tmp8_;
2817
2818 _tmp10_ = hkl_parameter_get_value_unit (&_tmp9_);
2819
2820 gtk_spin_button_set_value (_tmp6_, _tmp10_);
2821
2822 _tmp11_ = priv->_spinbutton_b_star;
2823
2824 _tmp12_ = priv->reciprocal;
2825
2826 _tmp13_ = _tmp12_->b;
2827
2828 _tmp14_ = *_tmp13_;
2829
2830 _tmp15_ = hkl_parameter_get_value_unit (&_tmp14_);
2831
2832 gtk_spin_button_set_value (_tmp11_, _tmp15_);
2833
2834 _tmp16_ = priv->_spinbutton_c_star;
2835
2836 _tmp17_ = priv->reciprocal;
2837
2838 _tmp18_ = _tmp17_->c;
2839
2840 _tmp19_ = *_tmp18_;
2841
2842 _tmp20_ = hkl_parameter_get_value_unit (&_tmp19_);
2843
2844 gtk_spin_button_set_value (_tmp16_, _tmp20_);
2845
2846 _tmp21_ = priv->_spinbutton_alpha_star;
2847
2848 _tmp22_ = priv->reciprocal;
2849
2850 _tmp23_ = _tmp22_->alpha;
2851
2852 _tmp24_ = *_tmp23_;
2853
2854 _tmp25_ = hkl_parameter_get_value_unit (&_tmp24_);
2855
2856 gtk_spin_button_set_value (_tmp21_, _tmp25_);
2857
2858 _tmp26_ = priv->_spinbutton_beta_star;
2859
2860 _tmp27_ = priv->reciprocal;
2861
2862 _tmp28_ = _tmp27_->beta;
2863
2864 _tmp29_ = *_tmp28_;
2865
2866 _tmp30_ = hkl_parameter_get_value_unit (&_tmp29_);
2867
2868 gtk_spin_button_set_value (_tmp26_, _tmp30_);
2869
2870 _tmp31_ = priv->_spinbutton_gamma_star;
2871
2872 _tmp32_ = priv->reciprocal;
2873
2874 _tmp33_ = _tmp32_->gamma;
2875
2876 _tmp34_ = *_tmp33_;
2877
2878 _tmp35_ = hkl_parameter_get_value_unit (&_tmp34_);
2879
2880 gtk_spin_button_set_value (_tmp31_, _tmp35_);
2881
2882 }
2883 }
2884
2885
2886 static gchar* double_to_string (gdouble self) {
2887 gchar* result = NULL;
2888 gchar* _tmp0_ = NULL;
2889 gchar* _tmp1_;
2890 gint _tmp1__length1;
2891 const gchar* _tmp2_ = NULL;
2892 gchar* _tmp3_;
2893 gchar* _tmp4_;
2894
2895 _tmp0_ = g_new0 (gchar, G_ASCII_DTOSTR_BUF_SIZE);
2896
2897 _tmp1_ = _tmp0_;
2898
2899 _tmp1__length1 = G_ASCII_DTOSTR_BUF_SIZE;
2900
2901 _tmp2_ = g_ascii_dtostr (_tmp1_, G_ASCII_DTOSTR_BUF_SIZE, self);
2902
2903 _tmp3_ = g_strdup (_tmp2_);
2904
2905 _tmp4_ = _tmp3_;
2906
2907 _tmp1_ = (g_free (_tmp1_), NULL);
2908
2909 result = _tmp4_;
2910
2911 return result;
2912
2913 }
2914
2915
2916 static void hkl_gui_window_update_UB (HklGuiWindow* self) {
2917 HklSampleList* _tmp0_;
2918 HklSample* _tmp1_;
2919 HklSample* sample;
2920 HklSample* _tmp2_;
2921
2922 g_return_if_fail (self != NULL);
2923
2924 _tmp0_ = priv->samples;
2925
2926 _tmp1_ = _tmp0_->current;
2927
2928 sample = _tmp1_;
2929
2930 _tmp2_ = sample;
2931
2932 if (_tmp2_ != NULL) {
2933
2934 HklMatrix UB = {0};
2935 HklSample* _tmp3_;
2936 HklMatrix _tmp4_ = {0};
2937 GtkLabel* _tmp5_;
2938 HklMatrix _tmp6_;
2939 gdouble** _tmp7_;
2940 gint _tmp7__length1;
2941 gdouble* _tmp8_;
2942 gint _tmp8__length1;
2943 gdouble _tmp9_;
2944 gchar* _tmp10_ = NULL;
2945 gchar* _tmp11_;
2946 GtkLabel* _tmp12_;
2947 HklMatrix _tmp13_;
2948 gdouble** _tmp14_;
2949 gint _tmp14__length1;
2950 gdouble* _tmp15_;
2951 gint _tmp15__length1;
2952 gdouble _tmp16_;
2953 gchar* _tmp17_ = NULL;
2954 gchar* _tmp18_;
2955 GtkLabel* _tmp19_;
2956 HklMatrix _tmp20_;
2957 gdouble** _tmp21_;
2958 gint _tmp21__length1;
2959 gdouble* _tmp22_;
2960 gint _tmp22__length1;
2961 gdouble _tmp23_;
2962 gchar* _tmp24_ = NULL;
2963 gchar* _tmp25_;
2964 GtkLabel* _tmp26_;
2965 HklMatrix _tmp27_;
2966 gdouble** _tmp28_;
2967 gint _tmp28__length1;
2968 gdouble* _tmp29_;
2969 gint _tmp29__length1;
2970 gdouble _tmp30_;
2971 gchar* _tmp31_ = NULL;
2972 gchar* _tmp32_;
2973 GtkLabel* _tmp33_;
2974 HklMatrix _tmp34_;
2975 gdouble** _tmp35_;
2976 gint _tmp35__length1;
2977 gdouble* _tmp36_;
2978 gint _tmp36__length1;
2979 gdouble _tmp37_;
2980 gchar* _tmp38_ = NULL;
2981 gchar* _tmp39_;
2982 GtkLabel* _tmp40_;
2983 HklMatrix _tmp41_;
2984 gdouble** _tmp42_;
2985 gint _tmp42__length1;
2986 gdouble* _tmp43_;
2987 gint _tmp43__length1;
2988 gdouble _tmp44_;
2989 gchar* _tmp45_ = NULL;
2990 gchar* _tmp46_;
2991 GtkLabel* _tmp47_;
2992 HklMatrix _tmp48_;
2993 gdouble** _tmp49_;
2994 gint _tmp49__length1;
2995 gdouble* _tmp50_;
2996 gint _tmp50__length1;
2997 gdouble _tmp51_;
2998 gchar* _tmp52_ = NULL;
2999 gchar* _tmp53_;
3000 GtkLabel* _tmp54_;
3001 HklMatrix _tmp55_;
3002 gdouble** _tmp56_;
3003 gint _tmp56__length1;
3004 gdouble* _tmp57_;
3005 gint _tmp57__length1;
3006 gdouble _tmp58_;
3007 gchar* _tmp59_ = NULL;
3008 gchar* _tmp60_;
3009 GtkLabel* _tmp61_;
3010 HklMatrix _tmp62_;
3011 gdouble** _tmp63_;
3012 gint _tmp63__length1;
3013 gdouble* _tmp64_;
3014 gint _tmp64__length1;
3015 gdouble _tmp65_;
3016 gchar* _tmp66_ = NULL;
3017 gchar* _tmp67_;
3018
3019 _tmp3_ = sample;
3020
3021 hkl_sample_get_UB (_tmp3_, &_tmp4_);
3022
3023 (&UB);
3024
3025 UB = _tmp4_;
3026
3027 _tmp5_ = priv->_label_UB11;
3028
3029 _tmp6_ = UB;
3030
3031 _tmp7_ = _tmp6_.data;
3032
3033 _tmp7__length1 = -1;
3034
3035 _tmp8_ = _tmp7_[0];
3036
3037 _tmp8__length1 = -1;
3038
3039 _tmp9_ = _tmp8_[0];
3040
3041 _tmp10_ = double_to_string (_tmp9_);
3042
3043 _tmp11_ = _tmp10_;
3044
3045 gtk_label_set_text (_tmp5_, _tmp11_);
3046
3047 _g_free0 (_tmp11_);
3048
3049 _tmp12_ = priv->_label_UB12;
3050
3051 _tmp13_ = UB;
3052
3053 _tmp14_ = _tmp13_.data;
3054
3055 _tmp14__length1 = -1;
3056
3057 _tmp15_ = _tmp14_[0];
3058
3059 _tmp15__length1 = -1;
3060
3061 _tmp16_ = _tmp15_[1];
3062
3063 _tmp17_ = double_to_string (_tmp16_);
3064
3065 _tmp18_ = _tmp17_;
3066
3067 gtk_label_set_text (_tmp12_, _tmp18_);
3068
3069 _g_free0 (_tmp18_);
3070
3071 _tmp19_ = priv->_label_UB13;
3072
3073 _tmp20_ = UB;
3074
3075 _tmp21_ = _tmp20_.data;
3076
3077 _tmp21__length1 = -1;
3078
3079 _tmp22_ = _tmp21_[0];
3080
3081 _tmp22__length1 = -1;
3082
3083 _tmp23_ = _tmp22_[2];
3084
3085 _tmp24_ = double_to_string (_tmp23_);
3086
3087 _tmp25_ = _tmp24_;
3088
3089 gtk_label_set_text (_tmp19_, _tmp25_);
3090
3091 _g_free0 (_tmp25_);
3092
3093 _tmp26_ = priv->_label_UB21;
3094
3095 _tmp27_ = UB;
3096
3097 _tmp28_ = _tmp27_.data;
3098
3099 _tmp28__length1 = -1;
3100
3101 _tmp29_ = _tmp28_[1];
3102
3103 _tmp29__length1 = -1;
3104
3105 _tmp30_ = _tmp29_[0];
3106
3107 _tmp31_ = double_to_string (_tmp30_);
3108
3109 _tmp32_ = _tmp31_;
3110
3111 gtk_label_set_text (_tmp26_, _tmp32_);
3112
3113 _g_free0 (_tmp32_);
3114
3115 _tmp33_ = priv->_label_UB22;
3116
3117 _tmp34_ = UB;
3118
3119 _tmp35_ = _tmp34_.data;
3120
3121 _tmp35__length1 = -1;
3122
3123 _tmp36_ = _tmp35_[1];
3124
3125 _tmp36__length1 = -1;
3126
3127 _tmp37_ = _tmp36_[1];
3128
3129 _tmp38_ = double_to_string (_tmp37_);
3130
3131 _tmp39_ = _tmp38_;
3132
3133 gtk_label_set_text (_tmp33_, _tmp39_);
3134
3135 _g_free0 (_tmp39_);
3136
3137 _tmp40_ = priv->_label_UB23;
3138
3139 _tmp41_ = UB;
3140
3141 _tmp42_ = _tmp41_.data;
3142
3143 _tmp42__length1 = -1;
3144
3145 _tmp43_ = _tmp42_[1];
3146
3147 _tmp43__length1 = -1;
3148
3149 _tmp44_ = _tmp43_[2];
3150
3151 _tmp45_ = double_to_string (_tmp44_);
3152
3153 _tmp46_ = _tmp45_;
3154
3155 gtk_label_set_text (_tmp40_, _tmp46_);
3156
3157 _g_free0 (_tmp46_);
3158
3159 _tmp47_ = priv->_label_UB31;
3160
3161 _tmp48_ = UB;
3162
3163 _tmp49_ = _tmp48_.data;
3164
3165 _tmp49__length1 = -1;
3166
3167 _tmp50_ = _tmp49_[2];
3168
3169 _tmp50__length1 = -1;
3170
3171 _tmp51_ = _tmp50_[0];
3172
3173 _tmp52_ = double_to_string (_tmp51_);
3174
3175 _tmp53_ = _tmp52_;
3176
3177 gtk_label_set_text (_tmp47_, _tmp53_);
3178
3179 _g_free0 (_tmp53_);
3180
3181 _tmp54_ = priv->_label_UB32;
3182
3183 _tmp55_ = UB;
3184
3185 _tmp56_ = _tmp55_.data;
3186
3187 _tmp56__length1 = -1;
3188
3189 _tmp57_ = _tmp56_[2];
3190
3191 _tmp57__length1 = -1;
3192
3193 _tmp58_ = _tmp57_[1];
3194
3195 _tmp59_ = double_to_string (_tmp58_);
3196
3197 _tmp60_ = _tmp59_;
3198
3199 gtk_label_set_text (_tmp54_, _tmp60_);
3200
3201 _g_free0 (_tmp60_);
3202
3203 _tmp61_ = priv->_label_UB33;
3204
3205 _tmp62_ = UB;
3206
3207 _tmp63_ = _tmp62_.data;
3208
3209 _tmp63__length1 = -1;
3210
3211 _tmp64_ = _tmp63_[2];
3212
3213 _tmp64__length1 = -1;
3214
3215 _tmp65_ = _tmp64_[2];
3216
3217 _tmp66_ = double_to_string (_tmp65_);
3218
3219 _tmp67_ = _tmp66_;
3220
3221 gtk_label_set_text (_tmp61_, _tmp67_);
3222
3223 _g_free0 (_tmp67_);
3224
3225 (&UB);
3226
3227 }
3228 }
3229
3230
3231 static void hkl_gui_window_update_UxUyUz (HklGuiWindow* self) {
3232 HklSampleList* _tmp0_;
3233 HklSample* _tmp1_;
3234 HklSample* sample;
3235 HklSample* _tmp2_;
3236
3237 g_return_if_fail (self != NULL);
3238
3239 _tmp0_ = priv->samples;
3240
3241 _tmp1_ = _tmp0_->current;
3242
3243 sample = _tmp1_;
3244
3245 _tmp2_ = sample;
3246
3247 if (_tmp2_ != NULL) {
3248
3249 GtkSpinButton* _tmp3_;
3250 HklSample* _tmp4_;
3251 HklParameter* _tmp5_;
3252 gdouble _tmp6_ = 0.0;
3253 GtkSpinButton* _tmp7_;
3254 HklSample* _tmp8_;
3255 HklParameter* _tmp9_;
3256 gdouble _tmp10_ = 0.0;
3257 GtkSpinButton* _tmp11_;
3258 HklSample* _tmp12_;
3259 HklParameter* _tmp13_;
3260 gdouble _tmp14_ = 0.0;
3261 GtkCheckButton* _tmp15_;
3262 HklSample* _tmp16_;
3263 HklParameter* _tmp17_;
3264 gboolean _tmp18_;
3265 GtkCheckButton* _tmp19_;
3266 HklSample* _tmp20_;
3267 HklParameter* _tmp21_;
3268 gboolean _tmp22_;
3269 GtkCheckButton* _tmp23_;
3270 HklSample* _tmp24_;
3271 HklParameter* _tmp25_;
3272 gboolean _tmp26_;
3273
3274 _tmp3_ = priv->_spinbutton_ux;
3275
3276 _tmp4_ = sample;
3277
3278 _tmp5_ = _tmp4_->ux;
3279
3280 _tmp6_ = hkl_parameter_get_value_unit (_tmp5_);
3281
3282 gtk_spin_button_set_value (_tmp3_, _tmp6_);
3283
3284 _tmp7_ = priv->_spinbutton_uy;
3285
3286 _tmp8_ = sample;
3287
3288 _tmp9_ = _tmp8_->uy;
3289
3290 _tmp10_ = hkl_parameter_get_value_unit (_tmp9_);
3291
3292 gtk_spin_button_set_value (_tmp7_, _tmp10_);
3293
3294 _tmp11_ = priv->_spinbutton_uz;
3295
3296 _tmp12_ = sample;
3297
3298 _tmp13_ = _tmp12_->uz;
3299
3300 _tmp14_ = hkl_parameter_get_value_unit (_tmp13_);
3301
3302 gtk_spin_button_set_value (_tmp11_, _tmp14_);
3303
3304 _tmp15_ = priv->_checkbutton_Ux;
3305
3306 _tmp16_ = sample;
3307
3308 _tmp17_ = _tmp16_->ux;
3309
3310 _tmp18_ = (*_tmp17_).fit;
3311
3312 gtk_toggle_button_set_active ((GtkToggleButton*) _tmp15_, _tmp18_);
3313
3314 _tmp19_ = priv->_checkbutton_Uy;
3315
3316 _tmp20_ = sample;
3317
3318 _tmp21_ = _tmp20_->uy;
3319
3320 _tmp22_ = (*_tmp21_).fit;
3321
3322 gtk_toggle_button_set_active ((GtkToggleButton*) _tmp19_, _tmp22_);
3323
3324 _tmp23_ = priv->_checkbutton_Uz;
3325
3326 _tmp24_ = sample;
3327
3328 _tmp25_ = _tmp24_->uz;
3329
3330 _tmp26_ = (*_tmp25_).fit;
3331
3332 gtk_toggle_button_set_active ((GtkToggleButton*) _tmp23_, _tmp26_);
3333
3334 }
3335 }
3336
3337
3338 static void _hkl_gui_window_update_reflections (HklSample* sample, GtkListStore* model) {
3339 gsize i = 0UL;
3340 GtkListStore* _tmp0_;
3341 HklSample* _tmp1_;
3342 HklSampleReflection** _tmp2_;
3343 gint _tmp2__length1;
3344
3345 g_return_if_fail (sample != NULL);
3346
3347 g_return_if_fail (model != NULL);
3348
3349 _tmp0_ = model;
3350
3351 gtk_list_store_clear (_tmp0_);
3352
3353 i = (gsize) 0;
3354
3355 _tmp1_ = sample;
3356
3357 _tmp2_ = _tmp1_->reflections;
3358
3359 _tmp2__length1 = _tmp1_->reflections_len;
3360
3361 {
3362 HklSampleReflection** reflection_collection = NULL;
3363 gint reflection_collection_length1 = 0;
3364 gint _reflection_collection_size_ = 0;
3365 gint reflection_it = 0;
3366
3367 reflection_collection = _tmp2_;
3368
3369 reflection_collection_length1 = _tmp2__length1;
3370
3371 for (reflection_it = 0; reflection_it < _tmp2__length1; reflection_it = reflection_it + 1) {
3372
3373 HklSampleReflection* reflection = NULL;
3374
3375 reflection = reflection_collection[reflection_it];
3376
3377 {
3378 GtkTreeIter iter = {0};
3379 GtkListStore* _tmp3_;
3380 GtkTreeIter _tmp4_ = {0};
3381 GtkListStore* _tmp5_;
3382 GtkTreeIter _tmp6_;
3383 gsize _tmp7_;
3384 HklSampleReflection* _tmp8_;
3385 HklVector _tmp9_;
3386 gdouble* _tmp10_;
3387 gint _tmp10__length1;
3388 gdouble _tmp11_;
3389 HklSampleReflection* _tmp12_;
3390 HklVector _tmp13_;
3391 gdouble* _tmp14_;
3392 gint _tmp14__length1;
3393 gdouble _tmp15_;
3394 HklSampleReflection* _tmp16_;
3395 HklVector _tmp17_;
3396 gdouble* _tmp18_;
3397 gint _tmp18__length1;
3398 gdouble _tmp19_;
3399 HklSampleReflection* _tmp20_;
3400 gint _tmp21_;
3401
3402 _tmp3_ = model;
3403
3404 gtk_list_store_append (_tmp3_, &_tmp4_);
3405
3406 iter = _tmp4_;
3407
3408 _tmp5_ = model;
3409
3410 _tmp6_ = iter;
3411
3412 _tmp7_ = i;
3413
3414 i = _tmp7_ + 1;
3415
3416 _tmp8_ = reflection;
3417
3418 _tmp9_ = _tmp8_->hkl;
3419
3420 _tmp10_ = _tmp9_.data;
3421
3422 _tmp10__length1 = _tmp9_.data_length1;
3423
3424 _tmp11_ = _tmp10_[0];
3425
3426 _tmp12_ = reflection;
3427
3428 _tmp13_ = _tmp12_->hkl;
3429
3430 _tmp14_ = _tmp13_.data;
3431
3432 _tmp14__length1 = _tmp13_.data_length1;
3433
3434 _tmp15_ = _tmp14_[1];
3435
3436 _tmp16_ = reflection;
3437
3438 _tmp17_ = _tmp16_->hkl;
3439
3440 _tmp18_ = _tmp17_.data;
3441
3442 _tmp18__length1 = _tmp17_.data_length1;
3443
3444 _tmp19_ = _tmp18_[2];
3445
3446 _tmp20_ = reflection;
3447
3448 _tmp21_ = _tmp20_->flag;
3449
3450 gtk_list_store_set (_tmp5_, &_tmp6_, REFLECTION_COL_INDEX, _tmp7_, REFLECTION_COL_H, _tmp11_, REFLECTION_COL_K, _tmp15_, REFLECTION_COL_L, _tmp19_, REFLECTION_COL_FLAG, _tmp21_, -1);
3451
3452 }
3453 }
3454 }
3455 }
3456
3457
3458 static void hkl_gui_window_update_tree_view_crystals (HklGuiWindow* self) {
3459 GtkListStore* reflections = NULL;
3460 GtkTreeIter iter = {0};
3461 GtkListStore* _tmp0_;
3462 GtkTreeView* _tmp1_;
3463 GtkListStore* _tmp2_;
3464 HklSampleList* _tmp3_;
3465 HklSample** _tmp4_;
3466 gint _tmp4__length1;
3467
3468 g_return_if_fail (self != NULL);
3469
3470 _tmp0_ = gtk_list_store_new ((gint) SAMPLE_COL_N_COLUMNS, G_TYPE_POINTER, GTK_TYPE_LIST_STORE, G_TYPE_STRING, G_TYPE_DOUBLE, G_TYPE_DOUBLE, G_TYPE_DOUBLE, G_TYPE_DOUBLE, G_TYPE_DOUBLE, G_TYPE_DOUBLE);
3471
3472 _g_object_unref0 (priv->store_samples);
3473
3474 priv->store_samples = _tmp0_;
3475
3476 _tmp1_ = priv->_treeview_crystals;
3477
3478 _tmp2_ = priv->store_samples;
3479
3480 gtk_tree_view_set_model (_tmp1_, (GtkTreeModel*) _tmp2_);
3481
3482 _tmp3_ = priv->samples;
3483
3484 _tmp4_ = _tmp3_->samples;
3485
3486 _tmp4__length1 = _tmp3_->len;
3487
3488 {
3489 HklSample** sample_collection = NULL;
3490 gint sample_collection_length1 = 0;
3491 gint _sample_collection_size_ = 0;
3492 gint sample_it = 0;
3493
3494 sample_collection = _tmp4_;
3495
3496 sample_collection_length1 = _tmp4__length1;
3497
3498 for (sample_it = 0; sample_it < _tmp4__length1; sample_it = sample_it + 1) {
3499
3500 HklSample* sample = NULL;
3501
3502 sample = sample_collection[sample_it];
3503
3504 {
3505 HklSample* _tmp5_;
3506 HklLattice* _tmp6_;
3507 HklLattice* lattice;
3508 GtkListStore* _tmp7_;
3509 HklSample* _tmp8_;
3510 GtkListStore* _tmp9_;
3511 GtkListStore* _tmp10_;
3512 GtkTreeIter _tmp11_ = {0};
3513 GtkListStore* _tmp12_;
3514 GtkTreeIter _tmp13_;
3515 HklSample* _tmp14_;
3516 GtkListStore* _tmp15_;
3517 HklSample* _tmp16_;
3518 const gchar* _tmp17_;
3519 HklLattice* _tmp18_;
3520 HklParameter* _tmp19_;
3521 HklParameter _tmp20_;
3522 gdouble _tmp21_ = 0.0;
3523 HklLattice* _tmp22_;
3524 HklParameter* _tmp23_;
3525 HklParameter _tmp24_;
3526 gdouble _tmp25_ = 0.0;
3527 HklLattice* _tmp26_;
3528 HklParameter* _tmp27_;
3529 HklParameter _tmp28_;
3530 gdouble _tmp29_ = 0.0;
3531 HklLattice* _tmp30_;
3532 HklParameter* _tmp31_;
3533 HklParameter _tmp32_;
3534 gdouble _tmp33_ = 0.0;
3535 HklLattice* _tmp34_;
3536 HklParameter* _tmp35_;
3537 HklParameter _tmp36_;
3538 gdouble _tmp37_ = 0.0;
3539 HklLattice* _tmp38_;
3540 HklParameter* _tmp39_;
3541 HklParameter _tmp40_;
3542 gdouble _tmp41_ = 0.0;
3543 gboolean _tmp42_ = FALSE;
3544 HklSampleList* _tmp43_;
3545 HklSample* _tmp44_;
3546 gboolean _tmp50_;
3547
3548 _tmp5_ = sample;
3549
3550 _tmp6_ = _tmp5_->lattice;
3551
3552 lattice = _tmp6_;
3553
3554 _tmp7_ = gtk_list_store_new ((gint) REFLECTION_COL_N_COLUMNS, G_TYPE_INT, G_TYPE_DOUBLE, G_TYPE_DOUBLE, G_TYPE_DOUBLE, G_TYPE_BOOLEAN);
3555
3556 _g_object_unref0 (reflections);
3557
3558 reflections = _tmp7_;
3559
3560 _tmp8_ = sample;
3561
3562 _tmp9_ = reflections;
3563
3564 _hkl_gui_window_update_reflections (_tmp8_, _tmp9_);
3565
3566 _tmp10_ = priv->store_samples;
3567
3568 gtk_list_store_append (_tmp10_, &_tmp11_);
3569
3570 iter = _tmp11_;
3571
3572 _tmp12_ = priv->store_samples;
3573
3574 _tmp13_ = iter;
3575
3576 _tmp14_ = sample;
3577
3578 _tmp15_ = reflections;
3579
3580 _tmp16_ = sample;
3581
3582 _tmp17_ = _tmp16_->name;
3583
3584 _tmp18_ = lattice;
3585
3586 _tmp19_ = _tmp18_->a;
3587
3588 _tmp20_ = *_tmp19_;
3589
3590 _tmp21_ = hkl_parameter_get_value_unit (&_tmp20_);
3591
3592 _tmp22_ = lattice;
3593
3594 _tmp23_ = _tmp22_->b;
3595
3596 _tmp24_ = *_tmp23_;
3597
3598 _tmp25_ = hkl_parameter_get_value_unit (&_tmp24_);
3599
3600 _tmp26_ = lattice;
3601
3602 _tmp27_ = _tmp26_->c;
3603
3604 _tmp28_ = *_tmp27_;
3605
3606 _tmp29_ = hkl_parameter_get_value_unit (&_tmp28_);
3607
3608 _tmp30_ = lattice;
3609
3610 _tmp31_ = _tmp30_->alpha;
3611
3612 _tmp32_ = *_tmp31_;
3613
3614 _tmp33_ = hkl_parameter_get_value_unit (&_tmp32_);
3615
3616 _tmp34_ = lattice;
3617
3618 _tmp35_ = _tmp34_->beta;
3619
3620 _tmp36_ = *_tmp35_;
3621
3622 _tmp37_ = hkl_parameter_get_value_unit (&_tmp36_);
3623
3624 _tmp38_ = lattice;
3625
3626 _tmp39_ = _tmp38_->gamma;
3627
3628 _tmp40_ = *_tmp39_;
3629
3630 _tmp41_ = hkl_parameter_get_value_unit (&_tmp40_);
3631
3632 gtk_list_store_set (_tmp12_, &_tmp13_, SAMPLE_COL_SAMPLE, _tmp14_, SAMPLE_COL_REFLECTIONS, _tmp15_, SAMPLE_COL_NAME, _tmp17_, SAMPLE_COL_A, _tmp21_, SAMPLE_COL_B, _tmp25_, SAMPLE_COL_C, _tmp29_, SAMPLE_COL_ALPHA, _tmp33_, SAMPLE_COL_BETA, _tmp37_, SAMPLE_COL_GAMMA, _tmp41_, -1);
3633
3634 _tmp43_ = priv->samples;
3635
3636 _tmp44_ = _tmp43_->current;
3637
3638 if (_tmp44_ != NULL) {
3639
3640 HklSampleList* _tmp45_;
3641 HklSample* _tmp46_;
3642 const gchar* _tmp47_;
3643 HklSample* _tmp48_;
3644 const gchar* _tmp49_;
3645
3646 _tmp45_ = priv->samples;
3647
3648 _tmp46_ = _tmp45_->current;
3649
3650 _tmp47_ = _tmp46_->name;
3651
3652 _tmp48_ = sample;
3653
3654 _tmp49_ = _tmp48_->name;
3655
3656 _tmp42_ = g_strcmp0 (_tmp47_, _tmp49_) == 0;
3657
3658 } else {
3659
3660 _tmp42_ = FALSE;
3661
3662 }
3663
3664 _tmp50_ = _tmp42_;
3665
3666 if (_tmp50_) {
3667
3668 GtkTreePath* path = NULL;
3669 GtkListStore* _tmp51_;
3670 GtkTreeIter _tmp52_;
3671 GtkTreePath* _tmp53_ = NULL;
3672 GtkTreeView* _tmp54_;
3673 GtkTreePath* _tmp55_;
3674 GtkTreeView* _tmp56_;
3675 GtkListStore* _tmp57_;
3676
3677 _tmp51_ = priv->store_samples;
3678
3679 _tmp52_ = iter;
3680
3681 _tmp53_ = gtk_tree_model_get_path ((GtkTreeModel*) _tmp51_, &_tmp52_);
3682
3683 _gtk_tree_path_free0 (path);
3684
3685 path = _tmp53_;
3686
3687 _tmp54_ = priv->_treeview_crystals;
3688
3689 _tmp55_ = path;
3690
3691 gtk_tree_view_set_cursor (_tmp54_, _tmp55_, NULL, FALSE);
3692
3693 _tmp56_ = priv->_treeview_reflections;
3694
3695 _tmp57_ = reflections;
3696
3697 gtk_tree_view_set_model (_tmp56_, (GtkTreeModel*) _tmp57_);
3698
3699 _gtk_tree_path_free0 (path);
3700
3701 }
3702 }
3703 }
3704 }
3705
3706 _g_object_unref0 (reflections);
3707
3708 }
3709
3710
3711 static void hkl_gui_window_update_reflections (HklGuiWindow* self, HklSample* sample) {
3712 gboolean valid = FALSE;
3713 GtkTreeIter iter = {0};
3714 GtkListStore* _tmp0_;
3715 GtkTreeIter _tmp1_ = {0};
3716 gboolean _tmp2_ = FALSE;
3717
3718 g_return_if_fail (self != NULL);
3719
3720 g_return_if_fail (sample != NULL);
3721
3722 _tmp0_ = priv->store_samples;
3723
3724 _tmp2_ = gtk_tree_model_get_iter_first ((GtkTreeModel*) _tmp0_, &_tmp1_);
3725
3726 iter = _tmp1_;
3727
3728 valid = _tmp2_;
3729
3730 while (TRUE) {
3731
3732 gboolean _tmp3_;
3733 HklSample* sample_iter = NULL;
3734 GtkListStore* model = NULL;
3735 GtkListStore* _tmp4_;
3736 GtkTreeIter _tmp5_;
3737 HklSample* _tmp6_;
3738 HklSample* _tmp7_;
3739 GtkListStore* _tmp10_;
3740 gboolean _tmp11_ = FALSE;
3741
3742 _tmp3_ = valid;
3743
3744 if (!_tmp3_) {
3745
3746 break;
3747
3748 }
3749
3750 _tmp4_ = priv->store_samples;
3751
3752 _tmp5_ = iter;
3753
3754 gtk_tree_model_get ((GtkTreeModel*) _tmp4_, &_tmp5_, SAMPLE_COL_SAMPLE, &sample_iter, SAMPLE_COL_REFLECTIONS, &model, -1);
3755
3756 _tmp6_ = sample;
3757
3758 _tmp7_ = sample_iter;
3759
3760 if (_tmp6_ == _tmp7_) {
3761
3762 HklSample* _tmp8_;
3763 GtkListStore* _tmp9_;
3764
3765 _tmp8_ = sample;
3766
3767 _tmp9_ = model;
3768
3769 _hkl_gui_window_update_reflections (_tmp8_, _tmp9_);
3770
3771 _g_object_unref0 (model);
3772
3773 break;
3774
3775 }
3776
3777 _tmp10_ = priv->store_samples;
3778
3779 _tmp11_ = gtk_tree_model_iter_next ((GtkTreeModel*) _tmp10_, &iter);
3780
3781 valid = _tmp11_;
3782
3783 _g_object_unref0 (model);
3784
3785 }
3786 }
3787
3788
3789 static void hkl_gui_window_update_crystal_model (HklGuiWindow* self, HklSample* sample) {
3790 GtkTreeIter iter = {0};
3791 gboolean valid = FALSE;
3792 GtkListStore* _tmp0_;
3793 GtkTreeIter _tmp1_ = {0};
3794 gboolean _tmp2_ = FALSE;
3795
3796 g_return_if_fail (self != NULL);
3797
3798 g_return_if_fail (sample != NULL);
3799
3800 _tmp0_ = priv->store_samples;
3801
3802 _tmp2_ = gtk_tree_model_get_iter_first ((GtkTreeModel*) _tmp0_, &_tmp1_);
3803
3804 iter = _tmp1_;
3805
3806 valid = _tmp2_;
3807
3808 while (TRUE) {
3809
3810 gboolean _tmp3_;
3811 gchar* name = NULL;
3812 GtkListStore* _tmp4_;
3813 GtkTreeIter _tmp5_;
3814 const gchar* _tmp6_;
3815 HklSample* _tmp7_;
3816 const gchar* _tmp8_;
3817 GtkListStore* _tmp37_;
3818 gboolean _tmp38_ = FALSE;
3819
3820 _tmp3_ = valid;
3821
3822 if (!_tmp3_) {
3823
3824 break;
3825
3826 }
3827
3828 _tmp4_ = priv->store_samples;
3829
3830 _tmp5_ = iter;
3831
3832 gtk_tree_model_get ((GtkTreeModel*) _tmp4_, &_tmp5_, SAMPLE_COL_NAME, &name, -1);
3833
3834 _tmp6_ = name;
3835
3836 _tmp7_ = sample;
3837
3838 _tmp8_ = _tmp7_->name;
3839
3840 if (g_strcmp0 (_tmp6_, _tmp8_) == 0) {
3841
3842 HklSample* _tmp9_;
3843 HklLattice* _tmp10_;
3844 HklLattice* lattice;
3845 GtkListStore* _tmp11_;
3846 GtkTreeIter _tmp12_;
3847 HklLattice* _tmp13_;
3848 HklParameter* _tmp14_;
3849 HklParameter _tmp15_;
3850 gdouble _tmp16_ = 0.0;
3851 HklLattice* _tmp17_;
3852 HklParameter* _tmp18_;
3853 HklParameter _tmp19_;
3854 gdouble _tmp20_ = 0.0;
3855 HklLattice* _tmp21_;
3856 HklParameter* _tmp22_;
3857 HklParameter _tmp23_;
3858 gdouble _tmp24_ = 0.0;
3859 HklLattice* _tmp25_;
3860 HklParameter* _tmp26_;
3861 HklParameter _tmp27_;
3862 gdouble _tmp28_ = 0.0;
3863 HklLattice* _tmp29_;
3864 HklParameter* _tmp30_;
3865 HklParameter _tmp31_;
3866 gdouble _tmp32_ = 0.0;
3867 HklLattice* _tmp33_;
3868 HklParameter* _tmp34_;
3869 HklParameter _tmp35_;
3870 gdouble _tmp36_ = 0.0;
3871
3872 _tmp9_ = sample;
3873
3874 _tmp10_ = _tmp9_->lattice;
3875
3876 lattice = _tmp10_;
3877
3878 _tmp11_ = priv->store_samples;
3879
3880 _tmp12_ = iter;
3881
3882 _tmp13_ = lattice;
3883
3884 _tmp14_ = _tmp13_->a;
3885
3886 _tmp15_ = *_tmp14_;
3887
3888 _tmp16_ = hkl_parameter_get_value_unit (&_tmp15_);
3889
3890 _tmp17_ = lattice;
3891
3892 _tmp18_ = _tmp17_->b;
3893
3894 _tmp19_ = *_tmp18_;
3895
3896 _tmp20_ = hkl_parameter_get_value_unit (&_tmp19_);
3897
3898 _tmp21_ = lattice;
3899
3900 _tmp22_ = _tmp21_->c;
3901
3902 _tmp23_ = *_tmp22_;
3903
3904 _tmp24_ = hkl_parameter_get_value_unit (&_tmp23_);
3905
3906 _tmp25_ = lattice;
3907
3908 _tmp26_ = _tmp25_->alpha;
3909
3910 _tmp27_ = *_tmp26_;
3911
3912 _tmp28_ = hkl_parameter_get_value_unit (&_tmp27_);
3913
3914 _tmp29_ = lattice;
3915
3916 _tmp30_ = _tmp29_->beta;
3917
3918 _tmp31_ = *_tmp30_;
3919
3920 _tmp32_ = hkl_parameter_get_value_unit (&_tmp31_);
3921
3922 _tmp33_ = lattice;
3923
3924 _tmp34_ = _tmp33_->gamma;
3925
3926 _tmp35_ = *_tmp34_;
3927
3928 _tmp36_ = hkl_parameter_get_value_unit (&_tmp35_);
3929
3930 gtk_list_store_set (_tmp11_, &_tmp12_, SAMPLE_COL_A, _tmp16_, SAMPLE_COL_B, _tmp20_, SAMPLE_COL_C, _tmp24_, SAMPLE_COL_ALPHA, _tmp28_, SAMPLE_COL_BETA, _tmp32_, SAMPLE_COL_GAMMA, _tmp36_, -1);
3931
3932 _g_free0 (name);
3933
3934 break;
3935
3936 }
3937
3938 _tmp37_ = priv->store_samples;
3939
3940 _tmp38_ = gtk_tree_model_iter_next ((GtkTreeModel*) _tmp37_, &iter);
3941
3942 valid = _tmp38_;
3943
3944 _g_free0 (name);
3945
3946 }
3947 }
3948
3949
3950
3951
3952
3953
3954 static void hkl_gui_window_on_tree_view_pseudo_axes_cursor_changed (HklGuiWindow* self) {
3955 GtkTreePath* path = NULL;
3956 GtkTreeViewColumn* focus_column = NULL;
3957 GtkListStore* model = NULL;
3958 GtkTreeIter iter = {0};
3959 HklPseudoAxis* pseudoAxis = NULL;
3960 GtkTreeView* _tmp0_;
3961 GtkTreePath* _tmp1_ = NULL;
3962 GtkTreeViewColumn* _tmp2_ = NULL;
3963 GtkTreeViewColumn* _tmp3_;
3964 GtkListStore* _tmp4_;
3965 GtkTreeIter _tmp5_ = {0};
3966 GtkListStore* _tmp6_;
3967 GtkTreeIter _tmp7_;
3968 GeeHashMap* _tmp8_;
3969 gpointer _tmp9_ = NULL;
3970 GtkTreeView* _tmp10_;
3971
3972 g_return_if_fail (self != NULL);
3973
3974 _tmp0_ = priv->_treeview_pseudo_axes;
3975
3976 gtk_tree_view_get_cursor (_tmp0_, &_tmp1_, &_tmp2_);
3977
3978 _gtk_tree_path_free0 (path);
3979
3980 path = _tmp1_;
3981
3982 _g_object_unref0 (focus_column);
3983
3984 _tmp3_ = _g_object_ref0 (_tmp2_);
3985
3986 focus_column = _tmp3_;
3987
3988 _tmp4_ = priv->store_pseudo_axis;
3989
3990 gtk_tree_model_get_iter ((GtkTreeModel*) _tmp4_, &_tmp5_, path);
3991
3992 iter = _tmp5_;
3993
3994 _tmp6_ = priv->store_pseudo_axis;
3995
3996 _tmp7_ = iter;
3997
3998 gtk_tree_model_get ((GtkTreeModel*) _tmp6_, &_tmp7_, PSEUDO_AXIS_COL_PSEUDOAXIS, &pseudoAxis, -1);
3999
4000 _tmp8_ = priv->hash_store_pseudo_axis_parameter;
4001
4002 _tmp9_ = gee_abstract_map_get ((GeeAbstractMap*) _tmp8_, pseudoAxis);
4003
4004 _g_object_unref0 (model);
4005
4006 model = (GtkListStore*) _tmp9_;
4007
4008 _tmp10_ = priv->_treeview_pseudo_axes_parameters;
4009
4010 gtk_tree_view_set_model (_tmp10_, (GtkTreeModel*) model);
4011
4012 _g_object_unref0 (model);
4013
4014 _g_object_unref0 (focus_column);
4015
4016 _gtk_tree_path_free0 (path);
4017
4018 }
4019
4020
4021 static void hkl_gui_window_on_tree_view_crystals_cursor_changed (HklGuiWindow* self) {
4022 GtkTreePath* path = NULL;
4023 GtkTreeViewColumn* focus_column = NULL;
4024 GtkTreeModel* model = NULL;
4025 GtkListStore* reflections = NULL;
4026 GtkTreeIter iter = {0};
4027 gchar* name = NULL;
4028 GtkTreeView* _tmp0_;
4029 GtkTreePath* _tmp1_ = NULL;
4030 GtkTreeViewColumn* _tmp2_ = NULL;
4031 GtkTreeViewColumn* _tmp3_;
4032 GtkTreeView* _tmp4_;
4033 GtkTreeModel* _tmp5_ = NULL;
4034 GtkTreeModel* _tmp6_;
4035 GtkTreeIter _tmp7_ = {0};
4036 GtkTreeIter _tmp8_;
4037 HklSampleList* _tmp9_;
4038 HklPseudoAxisEngineList* _tmp10_;
4039 HklGeometry* _tmp11_;
4040 HklDetector* _tmp12_;
4041 HklSampleList* _tmp13_;
4042 HklSample* _tmp14_;
4043 GtkTreeView* _tmp15_;
4044
4045 g_return_if_fail (self != NULL);
4046
4047 _tmp0_ = priv->_treeview_crystals;
4048
4049 gtk_tree_view_get_cursor (_tmp0_, &_tmp1_, &_tmp2_);
4050
4051 _gtk_tree_path_free0 (path);
4052
4053 path = _tmp1_;
4054
4055 _g_object_unref0 (focus_column);
4056
4057 _tmp3_ = _g_object_ref0 (_tmp2_);
4058
4059 focus_column = _tmp3_;
4060
4061 _tmp4_ = priv->_treeview_crystals;
4062
4063 _tmp5_ = gtk_tree_view_get_model (_tmp4_);
4064
4065 _tmp6_ = _g_object_ref0 (_tmp5_);
4066
4067 _g_object_unref0 (model);
4068
4069 model = _tmp6_;
4070
4071 gtk_tree_model_get_iter (model, &_tmp7_, path);
4072
4073 iter = _tmp7_;
4074
4075 _tmp8_ = iter;
4076
4077 gtk_tree_model_get (model, &_tmp8_, SAMPLE_COL_NAME, &name, SAMPLE_COL_REFLECTIONS, &reflections, -1);
4078
4079 _tmp9_ = priv->samples;
4080
4081 hkl_sample_list_select_current (_tmp9_, name);
4082
4083 _tmp10_ = priv->engines;
4084
4085 _tmp11_ = priv->geometry;
4086
4087 _tmp12_ = priv->detector;
4088
4089 _tmp13_ = priv->samples;
4090
4091 _tmp14_ = _tmp13_->current;
4092
4093 hkl_pseudo_axis_engine_list_init (_tmp10_, _tmp11_, _tmp12_, _tmp14_);
4094
4095 _tmp15_ = priv->_treeview_reflections;
4096
4097 gtk_tree_view_set_model (_tmp15_, (GtkTreeModel*) reflections);
4098
4099 hkl_gui_window_update_lattice (self);
4100
4101 hkl_gui_window_update_lattice_parameters (self);
4102
4103 hkl_gui_window_update_reciprocal_lattice (self);
4104
4105 hkl_gui_window_update_UxUyUz (self);
4106
4107 hkl_gui_window_update_UB (self);
4108
4109 hkl_gui_window_update_pseudo_axes (self);
4110
4111 hkl_gui_window_update_pseudo_axes_frames (self);
4112
4113 _g_free0 (name);
4114
4115 _g_object_unref0 (reflections);
4116
4117 _g_object_unref0 (model);
4118
4119 _g_object_unref0 (focus_column);
4120
4121 _gtk_tree_path_free0 (path);
4122
4123 }
4124
4125 static void hkl_gui_window_on_spinbutton_lambda_value_changed (HklGuiWindow* self) {
4126 HklGeometry* _tmp0_;
4127 GtkSpinButton* _tmp1_;
4128 gdouble _tmp2_ = 0.0;
4129
4130 g_return_if_fail (self != NULL);
4131
4132 _tmp0_ = priv->geometry;
4133
4134 _tmp1_ = priv->_spinbutton_lambda;
4135
4136 _tmp2_ = gtk_spin_button_get_value (_tmp1_);
4137
4138 _tmp0_->source.wave_length = _tmp2_;
4139
4140 hkl_gui_window_update_pseudo_axes (self);
4141
4142 hkl_gui_window_update_pseudo_axes_frames (self);
4143
4144 }
4145
4146
4147 static void hkl_gui_window_on_spinbutton_uxuyuz_value_changed (HklGuiWindow* self) {
4148
4149 g_return_if_fail (self != NULL);
4150
4151 }
4152
4153
4154 static void hkl_gui_window_on_button2_clicked (HklGuiWindow* self) {
4155 HklSampleList* _tmp0_;
4156 HklSample* _tmp1_;
4157 HklSample* sample;
4158 HklSample* _tmp2_;
4159
4160 g_return_if_fail (self != NULL);
4161
4162 _tmp0_ = priv->samples;
4163
4164 _tmp1_ = _tmp0_->current;
4165
4166 sample = _tmp1_;
4167
4168 _tmp2_ = sample;
4169
4170 if (_tmp2_ != NULL) {
4171
4172 HklSample* _tmp3_;
4173 GtkSpinButton* _tmp4_;
4174 gdouble _tmp5_ = 0.0;
4175 GtkSpinButton* _tmp6_;
4176 gdouble _tmp7_ = 0.0;
4177 GtkSpinButton* _tmp8_;
4178 gdouble _tmp9_ = 0.0;
4179 GtkSpinButton* _tmp10_;
4180 gdouble _tmp11_ = 0.0;
4181 GtkSpinButton* _tmp12_;
4182 gdouble _tmp13_ = 0.0;
4183 GtkSpinButton* _tmp14_;
4184 gdouble _tmp15_ = 0.0;
4185 HklSample* _tmp16_;
4186 GtkSpinButton* _tmp17_;
4187 gdouble _tmp18_ = 0.0;
4188 GtkSpinButton* _tmp19_;
4189 gdouble _tmp20_ = 0.0;
4190 GtkSpinButton* _tmp21_;
4191 gdouble _tmp22_ = 0.0;
4192 HklSample* _tmp23_;
4193 HklLattice* _tmp24_;
4194 HklParameter* _tmp25_;
4195 GtkSpinButton* _tmp26_;
4196 gdouble _tmp27_ = 0.0;
4197 GtkSpinButton* _tmp28_;
4198 gdouble _tmp29_ = 0.0;
4199 HklParameter _tmp30_;
4200 HklSample* _tmp31_;
4201 HklLattice* _tmp32_;
4202 HklParameter* _tmp33_;
4203 GtkSpinButton* _tmp34_;
4204 gdouble _tmp35_ = 0.0;
4205 GtkSpinButton* _tmp36_;
4206 gdouble _tmp37_ = 0.0;
4207 HklParameter _tmp38_;
4208 HklSample* _tmp39_;
4209 HklLattice* _tmp40_;
4210 HklParameter* _tmp41_;
4211 GtkSpinButton* _tmp42_;
4212 gdouble _tmp43_ = 0.0;
4213 GtkSpinButton* _tmp44_;
4214 gdouble _tmp45_ = 0.0;
4215 HklParameter _tmp46_;
4216 HklSample* _tmp47_;
4217 HklLattice* _tmp48_;
4218 HklParameter* _tmp49_;
4219 GtkSpinButton* _tmp50_;
4220 gdouble _tmp51_ = 0.0;
4221 GtkSpinButton* _tmp52_;
4222 gdouble _tmp53_ = 0.0;
4223 HklParameter _tmp54_;
4224 HklSample* _tmp55_;
4225 HklLattice* _tmp56_;
4226 HklParameter* _tmp57_;
4227 GtkSpinButton* _tmp58_;
4228 gdouble _tmp59_ = 0.0;
4229 GtkSpinButton* _tmp60_;
4230 gdouble _tmp61_ = 0.0;
4231 HklParameter _tmp62_;
4232 HklSample* _tmp63_;
4233 HklLattice* _tmp64_;
4234 HklParameter* _tmp65_;
4235 GtkSpinButton* _tmp66_;
4236 gdouble _tmp67_ = 0.0;
4237 GtkSpinButton* _tmp68_;
4238 gdouble _tmp69_ = 0.0;
4239 HklParameter _tmp70_;
4240 HklSample* _tmp71_;
4241
4242 _tmp3_ = sample;
4243
4244 _tmp4_ = priv->_spinbutton_a;
4245
4246 _tmp5_ = gtk_spin_button_get_value (_tmp4_);
4247
4248 _tmp6_ = priv->_spinbutton_b;
4249
4250 _tmp7_ = gtk_spin_button_get_value (_tmp6_);
4251
4252 _tmp8_ = priv->_spinbutton_c;
4253
4254 _tmp9_ = gtk_spin_button_get_value (_tmp8_);
4255
4256 _tmp10_ = priv->_spinbutton_alpha;
4257
4258 _tmp11_ = gtk_spin_button_get_value (_tmp10_);
4259
4260 _tmp12_ = priv->_spinbutton_beta;
4261
4262 _tmp13_ = gtk_spin_button_get_value (_tmp12_);
4263
4264 _tmp14_ = priv->_spinbutton_gamma;
4265
4266 _tmp15_ = gtk_spin_button_get_value (_tmp14_);
4267
4268 hkl_sample_set_lattice (_tmp3_, _tmp5_, _tmp7_, _tmp9_, _tmp11_ * HKL_DEGTORAD, _tmp13_ * HKL_DEGTORAD, _tmp15_ * HKL_DEGTORAD);
4269
4270 _tmp16_ = sample;
4271
4272 _tmp17_ = priv->_spinbutton_ux;
4273
4274 _tmp18_ = gtk_spin_button_get_value (_tmp17_);
4275
4276 _tmp19_ = priv->_spinbutton_uy;
4277
4278 _tmp20_ = gtk_spin_button_get_value (_tmp19_);
4279
4280 _tmp21_ = priv->_spinbutton_uz;
4281
4282 _tmp22_ = gtk_spin_button_get_value (_tmp21_);
4283
4284 hkl_sample_set_U_from_euler (_tmp16_, _tmp18_ * HKL_DEGTORAD, _tmp20_ * HKL_DEGTORAD, _tmp22_ * HKL_DEGTORAD);
4285
4286 _tmp23_ = sample;
4287
4288 _tmp24_ = _tmp23_->lattice;
4289
4290 _tmp25_ = _tmp24_->a;
4291
4292 _tmp26_ = priv->_spinbutton_a_min;
4293
4294 _tmp27_ = gtk_spin_button_get_value (_tmp26_);
4295
4296 _tmp28_ = priv->_spinbutton_a_max;
4297
4298 _tmp29_ = gtk_spin_button_get_value (_tmp28_);
4299
4300 _tmp30_ = *_tmp25_;
4301
4302 hkl_parameter_set_range_unit (&_tmp30_, _tmp27_, _tmp29_);
4303
4304 _tmp31_ = sample;
4305
4306 _tmp32_ = _tmp31_->lattice;
4307
4308 _tmp33_ = _tmp32_->b;
4309
4310 _tmp34_ = priv->_spinbutton_b_min;
4311
4312 _tmp35_ = gtk_spin_button_get_value (_tmp34_);
4313
4314 _tmp36_ = priv->_spinbutton_b_max;
4315
4316 _tmp37_ = gtk_spin_button_get_value (_tmp36_);
4317
4318 _tmp38_ = *_tmp33_;
4319
4320 hkl_parameter_set_range_unit (&_tmp38_, _tmp35_, _tmp37_);
4321
4322 _tmp39_ = sample;
4323
4324 _tmp40_ = _tmp39_->lattice;
4325
4326 _tmp41_ = _tmp40_->c;
4327
4328 _tmp42_ = priv->_spinbutton_c_min;
4329
4330 _tmp43_ = gtk_spin_button_get_value (_tmp42_);
4331
4332 _tmp44_ = priv->_spinbutton_c_max;
4333
4334 _tmp45_ = gtk_spin_button_get_value (_tmp44_);
4335
4336 _tmp46_ = *_tmp41_;
4337
4338 hkl_parameter_set_range_unit (&_tmp46_, _tmp43_, _tmp45_);
4339
4340 _tmp47_ = sample;
4341
4342 _tmp48_ = _tmp47_->lattice;
4343
4344 _tmp49_ = _tmp48_->alpha;
4345
4346 _tmp50_ = priv->_spinbutton_alpha_min;
4347
4348 _tmp51_ = gtk_spin_button_get_value (_tmp50_);
4349
4350 _tmp52_ = priv->_spinbutton_alpha_max;
4351
4352 _tmp53_ = gtk_spin_button_get_value (_tmp52_);
4353
4354 _tmp54_ = *_tmp49_;
4355
4356 hkl_parameter_set_range_unit (&_tmp54_, _tmp51_, _tmp53_);
4357
4358 _tmp55_ = sample;
4359
4360 _tmp56_ = _tmp55_->lattice;
4361
4362 _tmp57_ = _tmp56_->beta;
4363
4364 _tmp58_ = priv->_spinbutton_beta_min;
4365
4366 _tmp59_ = gtk_spin_button_get_value (_tmp58_);
4367
4368 _tmp60_ = priv->_spinbutton_beta_max;
4369
4370 _tmp61_ = gtk_spin_button_get_value (_tmp60_);
4371
4372 _tmp62_ = *_tmp57_;
4373
4374 hkl_parameter_set_range_unit (&_tmp62_, _tmp59_, _tmp61_);
4375
4376 _tmp63_ = sample;
4377
4378 _tmp64_ = _tmp63_->lattice;
4379
4380 _tmp65_ = _tmp64_->gamma;
4381
4382 _tmp66_ = priv->_spinbutton_gamma_min;
4383
4384 _tmp67_ = gtk_spin_button_get_value (_tmp66_);
4385
4386 _tmp68_ = priv->_spinbutton_gamma_max;
4387
4388 _tmp69_ = gtk_spin_button_get_value (_tmp68_);
4389
4390 _tmp70_ = *_tmp65_;
4391
4392 hkl_parameter_set_range_unit (&_tmp70_, _tmp67_, _tmp69_);
4393
4394 _tmp71_ = sample;
4395
4396 hkl_gui_window_update_crystal_model (self, _tmp71_);
4397
4398 hkl_gui_window_update_reciprocal_lattice (self);
4399
4400 hkl_gui_window_update_UB (self);
4401
4402 hkl_gui_window_update_pseudo_axes (self);
4403
4404 hkl_gui_window_update_pseudo_axes_frames (self);
4405
4406 }
4407 }
4408
4409
4410 static void hkl_gui_window_on_checkbutton_a_toggled (HklGuiWindow* self) {
4411 HklSampleList* _tmp0_;
4412 HklSample* _tmp1_;
4413 HklSample* sample;
4414 HklSample* _tmp2_;
4415
4416 g_return_if_fail (self != NULL);
4417
4418 _tmp0_ = priv->samples;
4419
4420 _tmp1_ = _tmp0_->current;
4421
4422 sample = _tmp1_;
4423
4424 _tmp2_ = sample;
4425
4426 if (_tmp2_ != NULL) {
4427
4428 HklSample* _tmp3_;
4429 HklLattice* _tmp4_;
4430 HklParameter* _tmp5_;
4431 GtkCheckButton* _tmp6_;
4432 gboolean _tmp7_ = FALSE;
4433
4434 _tmp3_ = sample;
4435
4436 _tmp4_ = _tmp3_->lattice;
4437
4438 _tmp5_ = _tmp4_->a;
4439
4440 _tmp6_ = priv->_checkbutton_a;
4441
4442 _tmp7_ = gtk_toggle_button_get_active ((GtkToggleButton*) _tmp6_);
4443
4444 (*_tmp5_).fit = _tmp7_;
4445
4446 }
4447 }
4448
4449
4450 static void hkl_gui_window_on_checkbutton_b_toggled (HklGuiWindow* self) {
4451 HklSampleList* _tmp0_;
4452 HklSample* _tmp1_;
4453 HklSample* sample;
4454 HklSample* _tmp2_;
4455
4456 g_return_if_fail (self != NULL);
4457
4458 _tmp0_ = priv->samples;
4459
4460 _tmp1_ = _tmp0_->current;
4461
4462 sample = _tmp1_;
4463
4464 _tmp2_ = sample;
4465
4466 if (_tmp2_ != NULL) {
4467
4468 HklSample* _tmp3_;
4469 HklLattice* _tmp4_;
4470 HklParameter* _tmp5_;
4471 GtkCheckButton* _tmp6_;
4472 gboolean _tmp7_ = FALSE;
4473
4474 _tmp3_ = sample;
4475
4476 _tmp4_ = _tmp3_->lattice;
4477
4478 _tmp5_ = _tmp4_->b;
4479
4480 _tmp6_ = priv->_checkbutton_b;
4481
4482 _tmp7_ = gtk_toggle_button_get_active ((GtkToggleButton*) _tmp6_);
4483
4484 (*_tmp5_).fit = _tmp7_;
4485
4486 }
4487 }
4488
4489
4490 static void hkl_gui_window_on_checkbutton_c_toggled (HklGuiWindow* self) {
4491 HklSampleList* _tmp0_;
4492 HklSample* _tmp1_;
4493 HklSample* sample;
4494 HklSample* _tmp2_;
4495
4496 g_return_if_fail (self != NULL);
4497
4498 _tmp0_ = priv->samples;
4499
4500 _tmp1_ = _tmp0_->current;
4501
4502 sample = _tmp1_;
4503
4504 _tmp2_ = sample;
4505
4506 if (_tmp2_ != NULL) {
4507
4508 HklSample* _tmp3_;
4509 HklLattice* _tmp4_;
4510 HklParameter* _tmp5_;
4511 GtkCheckButton* _tmp6_;
4512 gboolean _tmp7_ = FALSE;
4513
4514 _tmp3_ = sample;
4515
4516 _tmp4_ = _tmp3_->lattice;
4517
4518 _tmp5_ = _tmp4_->c;
4519
4520 _tmp6_ = priv->_checkbutton_c;
4521
4522 _tmp7_ = gtk_toggle_button_get_active ((GtkToggleButton*) _tmp6_);
4523
4524 (*_tmp5_).fit = _tmp7_;
4525
4526 }
4527 }
4528
4529
4530 static void hkl_gui_window_on_checkbutton_alpha_toggled (HklGuiWindow* self) {
4531 HklSampleList* _tmp0_;
4532 HklSample* _tmp1_;
4533 HklSample* sample;
4534 HklSample* _tmp2_;
4535
4536 g_return_if_fail (self != NULL);
4537
4538 _tmp0_ = priv->samples;
4539
4540 _tmp1_ = _tmp0_->current;
4541
4542 sample = _tmp1_;
4543
4544 _tmp2_ = sample;
4545
4546 if (_tmp2_ != NULL) {
4547
4548 HklSample* _tmp3_;
4549 HklLattice* _tmp4_;
4550 HklParameter* _tmp5_;
4551 GtkCheckButton* _tmp6_;
4552 gboolean _tmp7_ = FALSE;
4553
4554 _tmp3_ = sample;
4555
4556 _tmp4_ = _tmp3_->lattice;
4557
4558 _tmp5_ = _tmp4_->alpha;
4559
4560 _tmp6_ = priv->_checkbutton_alpha;
4561
4562 _tmp7_ = gtk_toggle_button_get_active ((GtkToggleButton*) _tmp6_);
4563
4564 (*_tmp5_).fit = _tmp7_;
4565
4566 }
4567 }
4568
4569
4570 static void hkl_gui_window_on_checkbutton_beta_toggled (HklGuiWindow* self) {
4571 HklSampleList* _tmp0_;
4572 HklSample* _tmp1_;
4573 HklSample* sample;
4574 HklSample* _tmp2_;
4575
4576 g_return_if_fail (self != NULL);
4577
4578 _tmp0_ = priv->samples;
4579
4580 _tmp1_ = _tmp0_->current;
4581
4582 sample = _tmp1_;
4583
4584 _tmp2_ = sample;
4585
4586 if (_tmp2_ != NULL) {
4587
4588 HklSample* _tmp3_;
4589 HklLattice* _tmp4_;
4590 HklParameter* _tmp5_;
4591 GtkCheckButton* _tmp6_;
4592 gboolean _tmp7_ = FALSE;
4593
4594 _tmp3_ = sample;
4595
4596 _tmp4_ = _tmp3_->lattice;
4597
4598 _tmp5_ = _tmp4_->beta;
4599
4600 _tmp6_ = priv->_checkbutton_beta;
4601
4602 _tmp7_ = gtk_toggle_button_get_active ((GtkToggleButton*) _tmp6_);
4603
4604 (*_tmp5_).fit = _tmp7_;
4605
4606 }
4607 }
4608
4609
4610 static void hkl_gui_window_on_checkbutton_gamma_toggled (HklGuiWindow* self) {
4611 HklSampleList* _tmp0_;
4612 HklSample* _tmp1_;
4613 HklSample* sample;
4614 HklSample* _tmp2_;
4615
4616 g_return_if_fail (self != NULL);
4617
4618 _tmp0_ = priv->samples;
4619
4620 _tmp1_ = _tmp0_->current;
4621
4622 sample = _tmp1_;
4623
4624 _tmp2_ = sample;
4625
4626 if (_tmp2_ != NULL) {
4627
4628 HklSample* _tmp3_;
4629 HklLattice* _tmp4_;
4630 HklParameter* _tmp5_;
4631 GtkCheckButton* _tmp6_;
4632 gboolean _tmp7_ = FALSE;
4633
4634 _tmp3_ = sample;
4635
4636 _tmp4_ = _tmp3_->lattice;
4637
4638 _tmp5_ = _tmp4_->gamma;
4639
4640 _tmp6_ = priv->_checkbutton_gamma;
4641
4642 _tmp7_ = gtk_toggle_button_get_active ((GtkToggleButton*) _tmp6_);
4643
4644 (*_tmp5_).fit = _tmp7_;
4645
4646 }
4647 }
4648
4649
4650 static void hkl_gui_window_on_checkbutton_Ux_toggled (HklGuiWindow* self) {
4651 HklSampleList* _tmp0_;
4652 HklSample* _tmp1_;
4653 HklSample* sample;
4654 HklSample* _tmp2_;
4655
4656 g_return_if_fail (self != NULL);
4657
4658 _tmp0_ = priv->samples;
4659
4660 _tmp1_ = _tmp0_->current;
4661
4662 sample = _tmp1_;
4663
4664 _tmp2_ = sample;
4665
4666 if (_tmp2_ != NULL) {
4667
4668 HklSample* _tmp3_;
4669 HklParameter* _tmp4_;
4670 GtkCheckButton* _tmp5_;
4671 gboolean _tmp6_ = FALSE;
4672
4673 _tmp3_ = sample;
4674
4675 _tmp4_ = _tmp3_->ux;
4676
4677 _tmp5_ = priv->_checkbutton_Ux;
4678
4679 _tmp6_ = gtk_toggle_button_get_active ((GtkToggleButton*) _tmp5_);
4680
4681 (*_tmp4_).fit = _tmp6_;
4682
4683 }
4684 }
4685
4686
4687 static void hkl_gui_window_on_checkbutton_Uy_toggled (HklGuiWindow* self) {
4688 HklSampleList* _tmp0_;
4689 HklSample* _tmp1_;
4690 HklSample* sample;
4691 HklSample* _tmp2_;
4692
4693 g_return_if_fail (self != NULL);
4694
4695 _tmp0_ = priv->samples;
4696
4697 _tmp1_ = _tmp0_->current;
4698
4699 sample = _tmp1_;
4700
4701 _tmp2_ = sample;
4702
4703 if (_tmp2_ != NULL) {
4704
4705 HklSample* _tmp3_;
4706 HklParameter* _tmp4_;
4707 GtkCheckButton* _tmp5_;
4708 gboolean _tmp6_ = FALSE;
4709
4710 _tmp3_ = sample;
4711
4712 _tmp4_ = _tmp3_->uy;
4713
4714 _tmp5_ = priv->_checkbutton_Uy;
4715
4716 _tmp6_ = gtk_toggle_button_get_active ((GtkToggleButton*) _tmp5_);
4717
4718 (*_tmp4_).fit = _tmp6_;
4719
4720 }
4721 }
4722
4723
4724 static void hkl_gui_window_on_checkbutton_Uz_toggled (HklGuiWindow* self) {
4725 HklSampleList* _tmp0_;
4726 HklSample* _tmp1_;
4727 HklSample* sample;
4728 HklSample* _tmp2_;
4729
4730 g_return_if_fail (self != NULL);
4731
4732 _tmp0_ = priv->samples;
4733
4734 _tmp1_ = _tmp0_->current;
4735
4736 sample = _tmp1_;
4737
4738 _tmp2_ = sample;
4739
4740 if (_tmp2_ != NULL) {
4741
4742 HklSample* _tmp3_;
4743 HklParameter* _tmp4_;
4744 GtkCheckButton* _tmp5_;
4745 gboolean _tmp6_ = FALSE;
4746
4747 _tmp3_ = sample;
4748
4749 _tmp4_ = _tmp3_->uz;
4750
4751 _tmp5_ = priv->_checkbutton_Uz;
4752
4753 _tmp6_ = gtk_toggle_button_get_active ((GtkToggleButton*) _tmp5_);
4754
4755 (*_tmp4_).fit = _tmp6_;
4756
4757 }
4758 }
4759
4760
4761 static gdouble double_parse (const gchar* str) {
4762 gdouble result = 0.0;
4763 const gchar* _tmp0_;
4764 gdouble _tmp1_ = 0.0;
4765
4766 g_return_val_if_fail (str != NULL, 0.0);
4767
4768 _tmp0_ = str;
4769
4770 _tmp1_ = g_ascii_strtod (_tmp0_, NULL);
4771
4772 result = _tmp1_;
4773
4774 return result;
4775
4776 }
4777
4778
4779
4780
4781 static void hkl_gui_window_on_cell_tree_view_axes_write_edited (const gchar* path, const gchar* new_text, HklGuiWindow* self) {
4782 GtkTreeIter iter = {0};
4783 gdouble value = 0.0;
4784 HklAxis* axis = NULL;
4785 GtkListStore* _tmp0_;
4786 const gchar* _tmp1_;
4787 GtkTreeIter _tmp2_ = {0};
4788 GtkListStore* _tmp3_;
4789 GtkTreeIter _tmp4_;
4790 const gchar* _tmp5_;
4791 gdouble _tmp6_ = 0.0;
4792 HklAxis _tmp7_;
4793 HklGeometry* _tmp8_;
4794 GtkListStore* _tmp9_;
4795 GtkTreeIter _tmp10_;
4796
4797 g_return_if_fail (self != NULL);
4798
4799 g_return_if_fail (path != NULL);
4800
4801 g_return_if_fail (new_text != NULL);
4802
4803 _tmp0_ = priv->store_axis;
4804
4805 _tmp1_ = path;
4806
4807 gtk_tree_model_get_iter_from_string ((GtkTreeModel*) _tmp0_, &_tmp2_, _tmp1_);
4808
4809 iter = _tmp2_;
4810
4811 _tmp3_ = priv->store_axis;
4812
4813 _tmp4_ = iter;
4814
4815 gtk_tree_model_get ((GtkTreeModel*) _tmp3_, &_tmp4_, AXIS_COL_AXIS, &axis, -1);
4816
4817 _tmp5_ = new_text;
4818
4819 _tmp6_ = double_parse (_tmp5_);
4820
4821 value = _tmp6_;
4822
4823 _tmp7_ = *axis;
4824
4825 hkl_axis_set_value_unit (&_tmp7_, value);
4826
4827 _tmp8_ = priv->geometry;
4828 hkl_geometry_update (_tmp8_);
4829
4830 _tmp9_ = priv->store_axis;
4831
4832 _tmp10_ = iter;
4833
4834 gtk_list_store_set (_tmp9_, &_tmp10_, AXIS_COL_WRITE, value, -1);
4835
4836 hkl_gui_window_update_pseudo_axes (self);
4837
4838 hkl_gui_window_update_pseudo_axes_frames (self);
4839
4840 }
4841
4842
4843
4844
4845 static void hkl_gui_window_on_cell_tree_view_pseudo_axes_is_initialized_toggled (const gchar* path, HklGuiWindow* self) {
4846 GtkTreeModel* model = NULL;
4847 GtkTreeIter iter = {0};
4848 HklPseudoAxis* pseudoAxis = NULL;
4849 gboolean old_flag = FALSE;
4850 GtkTreeView* _tmp0_;
4851 GtkTreeModel* _tmp1_ = NULL;
4852 GtkTreeModel* _tmp2_;
4853 GtkTreeModel* _tmp3_;
4854 const gchar* _tmp4_;
4855 GtkTreeIter _tmp5_ = {0};
4856 GtkTreeModel* _tmp6_;
4857 GtkTreeIter _tmp7_;
4858 gboolean _tmp8_;
4859
4860 g_return_if_fail (self != NULL);
4861
4862 g_return_if_fail (path != NULL);
4863
4864 _tmp0_ = priv->_treeview_pseudo_axes;
4865
4866 _tmp1_ = gtk_tree_view_get_model (_tmp0_);
4867
4868 _tmp2_ = _g_object_ref0 (_tmp1_);
4869
4870 _g_object_unref0 (model);
4871
4872 model = _tmp2_;
4873
4874 _tmp3_ = model;
4875
4876 _tmp4_ = path;
4877
4878 gtk_tree_model_get_iter_from_string (_tmp3_, &_tmp5_, _tmp4_);
4879
4880 iter = _tmp5_;
4881
4882 _tmp6_ = model;
4883
4884 _tmp7_ = iter;
4885
4886 gtk_tree_model_get (_tmp6_, &_tmp7_, PSEUDO_AXIS_COL_PSEUDOAXIS, &pseudoAxis, PSEUDO_AXIS_COL_INITIALIZED, &old_flag, -1);
4887
4888 _tmp8_ = old_flag;
4889
4890 if (!_tmp8_) {
4891
4892 HklPseudoAxis* _tmp9_;
4893 HklPseudoAxisEngine* _tmp10_;
4894 gboolean _tmp11_ = FALSE;
4895
4896 _tmp9_ = pseudoAxis;
4897
4898 _tmp10_ = _tmp9_->engine;
4899
4900 _tmp11_ = hkl_pseudo_axis_engine_initialize (_tmp10_, NULL);
4901
4902 if (_tmp11_) {
4903
4904 hkl_gui_window_update_pseudo_axes (self);
4905
4906 }
4907 }
4908
4909 _g_object_unref0 (model);
4910
4911 }
4912
4913
4914 static void hkl_gui_window_on_cell_tree_view_pseudo_axes_parameters_value_edited (const gchar* path, const gchar* new_text, HklGuiWindow* self) {
4915 GtkListStore* model = NULL;
4916 GtkTreeIter iter = {0};
4917 gdouble value = 0.0;
4918 HklParameter* parameter;
4919 GtkTreeView* _tmp0_;
4920 GtkTreeModel* _tmp1_ = NULL;
4921 GtkListStore* _tmp2_;
4922 const gchar* _tmp3_;
4923 GtkTreeIter _tmp4_ = {0};
4924 GtkTreeIter _tmp5_;
4925 const gchar* _tmp6_;
4926 gdouble _tmp7_ = 0.0;
4927 HklParameter _tmp8_;
4928 GtkTreeIter _tmp9_;
4929
4930 g_return_if_fail (self != NULL);
4931
4932 g_return_if_fail (path != NULL);
4933
4934 g_return_if_fail (new_text != NULL);
4935
4936 parameter = NULL;
4937
4938 _tmp0_ = priv->_treeview_pseudo_axes_parameters;
4939
4940 _tmp1_ = gtk_tree_view_get_model (_tmp0_);
4941
4942 _tmp2_ = _g_object_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1_, GTK_TYPE_LIST_STORE) ? ((GtkListStore*) _tmp1_) : NULL);
4943
4944 _g_object_unref0 (model);
4945
4946 model = _tmp2_;
4947
4948 _tmp3_ = path;
4949
4950 gtk_tree_model_get_iter_from_string ((GtkTreeModel*) model, &_tmp4_, _tmp3_);
4951
4952 iter = _tmp4_;
4953
4954 _tmp5_ = iter;
4955
4956 gtk_tree_model_get ((GtkTreeModel*) model, &_tmp5_, PARAMETER_COL_PARAMETER, parameter, -1);
4957
4958 _tmp6_ = new_text;
4959
4960 _tmp7_ = double_parse (_tmp6_);
4961
4962 value = _tmp7_;
4963
4964 _tmp8_ = *parameter;
4965
4966 hkl_parameter_set_value_unit (&_tmp8_, value);
4967
4968 _tmp9_ = iter;
4969
4970 gtk_list_store_set (model, &_tmp9_, PARAMETER_COL_VALUE, value, -1);
4971
4972 hkl_gui_window_update_pseudo_axes (self);
4973
4974 hkl_gui_window_update_pseudo_axes_parameters (self);
4975
4976 _g_object_unref0 (model);
4977
4978 }
4979
4980
4981 static void hkl_gui_window_on_cell_tree_view_crystals_name_edited (const gchar* path, const gchar* new_text, HklGuiWindow* self) {
4982 GtkTreeModel* model = NULL;
4983 GtkTreeIter iter = {0};
4984 HklSample* sample = NULL;
4985 gchar* name = NULL;
4986 GtkTreeView* _tmp0_;
4987 GtkTreeModel* _tmp1_ = NULL;
4988 GtkTreeModel* _tmp2_;
4989 GtkTreeModel* _tmp3_;
4990 const gchar* _tmp4_;
4991 GtkTreeIter _tmp5_ = {0};
4992 GtkTreeModel* _tmp6_;
4993 GtkTreeIter _tmp7_;
4994 HklSampleList* _tmp8_;
4995 const gchar* _tmp9_;
4996 HklSample* _tmp10_ = NULL;
4997 HklSample* _tmp11_;
4998
4999 g_return_if_fail (self != NULL);
5000
5001 g_return_if_fail (path != NULL);
5002
5003 g_return_if_fail (new_text != NULL);
5004
5005 _tmp0_ = priv->_treeview_crystals;
5006
5007 _tmp1_ = gtk_tree_view_get_model (_tmp0_);
5008
5009 _tmp2_ = _g_object_ref0 (_tmp1_);
5010
5011 _g_object_unref0 (model);
5012
5013 model = _tmp2_;
5014
5015 _tmp3_ = model;
5016
5017 _tmp4_ = path;
5018
5019 gtk_tree_model_get_iter_from_string (_tmp3_, &_tmp5_, _tmp4_);
5020
5021 iter = _tmp5_;
5022
5023 _tmp6_ = model;
5024
5025 _tmp7_ = iter;
5026
5027 gtk_tree_model_get (_tmp6_, &_tmp7_, SAMPLE_COL_NAME, &name, -1);
5028
5029 _tmp8_ = priv->samples;
5030
5031 _tmp9_ = name;
5032
5033 _tmp10_ = hkl_sample_list_get_by_name (_tmp8_, _tmp9_);
5034
5035 sample = _tmp10_;
5036
5037 _tmp11_ = sample;
5038
5039 if (_tmp11_ != NULL) {
5040
5041 HklSample* _tmp12_;
5042 const gchar* _tmp13_;
5043
5044 _tmp12_ = sample;
5045
5046 _tmp13_ = new_text;
5047
5048 hkl_sample_set_name (_tmp12_, _tmp13_);
5049
5050 hkl_gui_window_update_tree_view_crystals (self);
5051
5052 }
5053
5054 _g_free0 (name);
5055
5056 _g_object_unref0 (model);
5057
5058 }
5059
5060
5061
5062
5063 static void hkl_gui_window_on_toolbutton_add_reflection_clicked (HklGuiWindow* self) {
5064 HklSampleList* _tmp0_;
5065 HklSample* _tmp1_;
5066 HklSample* sample;
5067 HklSample* _tmp2_;
5068
5069 g_return_if_fail (self != NULL);
5070
5071 _tmp0_ = priv->samples;
5072
5073 _tmp1_ = _tmp0_->current;
5074
5075 sample = _tmp1_;
5076
5077 _tmp2_ = sample;
5078
5079 if (_tmp2_ != NULL) {
5080
5081 gdouble h;
5082 gdouble k;
5083 gdouble l;
5084 HklSample* _tmp3_;
5085 HklGeometry* _tmp4_;
5086 HklDetector* _tmp5_;
5087 gdouble _tmp6_;
5088 gdouble _tmp7_;
5089 gdouble _tmp8_;
5090 HklSampleReflection* _tmp9_ = NULL;
5091 HklSample* _tmp10_;
5092
5093 h = (gdouble) 0;
5094
5095 k = (gdouble) 0;
5096
5097 l = (gdouble) 0;
5098
5099 _tmp3_ = sample;
5100
5101 _tmp4_ = priv->geometry;
5102
5103 _tmp5_ = priv->detector;
5104
5105 _tmp6_ = h;
5106
5107 _tmp7_ = k;
5108
5109 _tmp8_ = l;
5110
5111 _tmp9_ = hkl_sample_add_reflection (_tmp3_, _tmp4_, _tmp5_, _tmp6_, _tmp7_, _tmp8_);
5112
5113 _tmp10_ = sample;
5114
5115 hkl_gui_window_update_reflections (self, _tmp10_);
5116
5117 }
5118 }
5119
5120
5121 static void _gtk_tree_path_free0_ (gpointer var) {
5122
5123 (var == NULL) ? NULL : (var = (gtk_tree_path_free (var), NULL));
5124
5125 }
5126
5127
5128 static void _g_list_free__gtk_tree_path_free0_ (GList* self) {
5129
5130 g_list_foreach (self, (GFunc) _gtk_tree_path_free0_, NULL);
5131
5132 g_list_free (self);
5133
5134 }
5135
5136
5137 static void hkl_gui_window_on_toolbutton_goto_reflection_clicked (HklGuiWindow* self) {
5138 HklSampleList* _tmp0_;
5139 HklSample* _tmp1_;
5140 HklSample* sample;
5141 HklSample* _tmp2_;
5142
5143 g_return_if_fail (self != NULL);
5144
5145 _tmp0_ = priv->samples;
5146
5147 _tmp1_ = _tmp0_->current;
5148
5149 sample = _tmp1_;
5150
5151 _tmp2_ = sample;
5152
5153 if (_tmp2_ != NULL) {
5154
5155 GtkTreeSelection* selection = NULL;
5156 guint nb_rows = 0U;
5157 GtkTreeView* _tmp3_;
5158 GtkTreeSelection* _tmp4_ = NULL;
5159 GtkTreeSelection* _tmp5_;
5160 GtkTreeSelection* _tmp6_;
5161 gint _tmp7_ = 0;
5162 guint _tmp8_;
5163
5164 _tmp3_ = priv->_treeview_reflections;
5165
5166 _tmp4_ = gtk_tree_view_get_selection (_tmp3_);
5167
5168 _tmp5_ = _g_object_ref0 (_tmp4_);
5169
5170 _g_object_unref0 (selection);
5171
5172 selection = _tmp5_;
5173
5174 _tmp6_ = selection;
5175
5176 _tmp7_ = gtk_tree_selection_count_selected_rows (_tmp6_);
5177
5178 nb_rows = (guint) _tmp7_;
5179
5180 _tmp8_ = nb_rows;
5181
5182 if (_tmp8_ == ((guint) 1)) {
5183
5184 guint index = 0U;
5185 GtkTreeIter iter = {0};
5186 GtkTreeModel* model = NULL;
5187 GtkTreeSelection* _tmp9_;
5188 GtkTreeModel* _tmp10_ = NULL;
5189 GList* _tmp11_ = NULL;
5190 GtkTreeModel* _tmp12_;
5191 GList* list;
5192 GtkTreeModel* _tmp13_;
5193 GList* _tmp14_;
5194 gconstpointer _tmp15_;
5195 GtkTreeIter _tmp16_ = {0};
5196 GtkTreeModel* _tmp17_;
5197 GtkTreeIter _tmp18_;
5198 HklGeometry* _tmp19_;
5199 HklSample* _tmp20_;
5200 HklSampleReflection** _tmp21_;
5201 gint _tmp21__length1;
5202 guint _tmp22_;
5203 HklSampleReflection* _tmp23_;
5204 HklGeometry* _tmp24_;
5205
5206 _tmp9_ = selection;
5207
5208 _tmp11_ = gtk_tree_selection_get_selected_rows (_tmp9_, &_tmp10_);
5209
5210 _g_object_unref0 (model);
5211
5212 _tmp12_ = _g_object_ref0 (_tmp10_);
5213
5214 model = _tmp12_;
5215
5216 list = _tmp11_;
5217
5218 _tmp13_ = model;
5219
5220 _tmp14_ = list;
5221
5222 _tmp15_ = _tmp14_->data;
5223
5224 gtk_tree_model_get_iter (_tmp13_, &_tmp16_, (GtkTreePath*) _tmp15_);
5225
5226 iter = _tmp16_;
5227
5228 _tmp17_ = model;
5229
5230 _tmp18_ = iter;
5231
5232 gtk_tree_model_get (_tmp17_, &_tmp18_, REFLECTION_COL_INDEX, &index, -1);
5233
5234 _tmp19_ = priv->geometry;
5235
5236 _tmp20_ = sample;
5237
5238 _tmp21_ = _tmp20_->reflections;
5239
5240 _tmp21__length1 = _tmp20_->reflections_len;
5241
5242 _tmp22_ = index;
5243
5244 _tmp23_ = _tmp21_[_tmp22_];
5245
5246 _tmp24_ = _tmp23_->geometry;
5247
5248 hkl_geometry_init_geometry (_tmp19_, _tmp24_);
5249
5250 hkl_gui_window_update_source (self);
5251
5252 hkl_gui_window_update_axes (self);
5253
5254 hkl_gui_window_update_pseudo_axes (self);
5255
5256 __g_list_free__gtk_tree_path_free0_0 (list);
5257
5258 _g_object_unref0 (model);
5259
5260 } else {
5261 guint _tmp25_;
5262
5263 _tmp25_ = nb_rows;
5264
5265 if (_tmp25_ > ((guint) 0)) {
5266
5267 GtkStatusbar* _tmp26_;
5268
5269 _tmp26_ = priv->_statusBar;
5270
5271 gtk_statusbar_push (_tmp26_, (guint) 0, "Please select only one reflection.");
5272
5273 } else {
5274 GtkStatusbar* _tmp27_;
5275
5276 _tmp27_ = priv->_statusBar;
5277
5278 gtk_statusbar_push (_tmp27_, (guint) 0, "Please select at least one reflection.");
5279
5280 }
5281 }
5282
5283 _g_object_unref0 (selection);
5284
5285 }
5286 }
5287
5288
5289 static gpointer _gtk_tree_path_copy0 (gpointer self) {
5290
5291 return self ? gtk_tree_path_copy (self) : NULL;
5292
5293 }
5294
5295
5296 static void hkl_gui_window_on_toolbutton_del_reflection_clicked (HklGuiWindow* self) {
5297 HklSample* sample = NULL;
5298 HklSampleList* _tmp0_;
5299 HklSample* _tmp1_;
5300 HklSample* _tmp2_;
5301
5302 g_return_if_fail (self != NULL);
5303
5304 _tmp0_ = priv->samples;
5305
5306 _tmp1_ = _tmp0_->current;
5307
5308 sample = _tmp1_;
5309
5310 _tmp2_ = sample;
5311
5312 if (_tmp2_ != NULL) {
5313
5314 GtkTreeSelection* selection = NULL;
5315 guint nb_rows = 0U;
5316 GtkTreeView* _tmp3_;
5317 GtkTreeSelection* _tmp4_ = NULL;
5318 GtkTreeSelection* _tmp5_;
5319 GtkTreeSelection* _tmp6_;
5320 gint _tmp7_ = 0;
5321 guint _tmp8_;
5322
5323 _tmp3_ = priv->_treeview_reflections;
5324
5325 _tmp4_ = gtk_tree_view_get_selection (_tmp3_);
5326
5327 _tmp5_ = _g_object_ref0 (_tmp4_);
5328
5329 _g_object_unref0 (selection);
5330
5331 selection = _tmp5_;
5332
5333 _tmp6_ = selection;
5334
5335 _tmp7_ = gtk_tree_selection_count_selected_rows (_tmp6_);
5336
5337 nb_rows = (guint) _tmp7_;
5338
5339 _tmp8_ = nb_rows;
5340
5341 if (_tmp8_ > ((guint) 0)) {
5342
5343 GtkTreeModel* model = NULL;
5344 GtkTreeIter iter = {0};
5345 GtkTreeSelection* _tmp9_;
5346 GtkTreeModel* _tmp10_ = NULL;
5347 GList* _tmp11_ = NULL;
5348 GtkTreeModel* _tmp12_;
5349 GList* list;
5350 guint _tmp13_;
5351 guint* _tmp14_ = NULL;
5352 guint* indexes;
5353 gint indexes_length1;
5354 gint _indexes_size_;
5355 gint i;
5356 GList* _tmp15_;
5357 GtkMessageDialog* _tmp24_;
5358 GtkMessageDialog* dialog;
5359 GtkMessageDialog* _tmp25_;
5360 gint _tmp26_ = 0;
5361 gint respons;
5362 gint _tmp27_;
5363
5364 _tmp9_ = selection;
5365
5366 _tmp11_ = gtk_tree_selection_get_selected_rows (_tmp9_, &_tmp10_);
5367
5368 _g_object_unref0 (model);
5369
5370 _tmp12_ = _g_object_ref0 (_tmp10_);
5371
5372 model = _tmp12_;
5373
5374 list = _tmp11_;
5375
5376 _tmp13_ = nb_rows;
5377
5378 _tmp14_ = g_new0 (guint, _tmp13_);
5379
5380 indexes = _tmp14_;
5381
5382 indexes_length1 = _tmp13_;
5383
5384 _indexes_size_ = indexes_length1;
5385
5386 i = 0;
5387
5388 _tmp15_ = list;
5389
5390 {
5391 GList* path_collection = NULL;
5392 GList* path_it = NULL;
5393
5394 path_collection = _tmp15_;
5395
5396 for (path_it = path_collection; path_it != NULL; path_it = path_it->next) {
5397
5398 GtkTreePath* _tmp16_;
5399 GtkTreePath* path = NULL;
5400
5401 _tmp16_ = _gtk_tree_path_copy0 ((GtkTreePath*) path_it->data);
5402
5403 path = _tmp16_;
5404
5405 {
5406 GtkTreeModel* _tmp17_;
5407 GtkTreePath* _tmp18_;
5408 GtkTreeIter _tmp19_ = {0};
5409 GtkTreeModel* _tmp20_;
5410 GtkTreeIter _tmp21_;
5411 guint* _tmp22_;
5412 gint _tmp22__length1;
5413 gint _tmp23_;
5414
5415 _tmp17_ = model;
5416
5417 _tmp18_ = path;
5418
5419 gtk_tree_model_get_iter (_tmp17_, &_tmp19_, _tmp18_);
5420
5421 iter = _tmp19_;
5422
5423 _tmp20_ = model;
5424
5425 _tmp21_ = iter;
5426
5427 _tmp22_ = indexes;
5428
5429 _tmp22__length1 = indexes_length1;
5430
5431 _tmp23_ = i;
5432
5433 i = _tmp23_ + 1;
5434
5435 gtk_tree_model_get (_tmp20_, &_tmp21_, REFLECTION_COL_INDEX, &_tmp22_[_tmp23_], -1);
5436
5437 _gtk_tree_path_free0 (path);
5438
5439 }
5440 }
5441 }
5442
5443 _tmp24_ = (GtkMessageDialog*) gtk_message_dialog_new (NULL, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_WARNING, GTK_BUTTONS_YES_NO, "Are you sure that you want to delete reflections");
5444
5445 g_object_ref_sink (_tmp24_);
5446
5447 dialog = _tmp24_;
5448
5449 _tmp25_ = dialog;
5450
5451 _tmp26_ = gtk_dialog_run ((GtkDialog*) _tmp25_);
5452
5453 respons = _tmp26_;
5454
5455 _tmp27_ = respons;
5456
5457 switch (_tmp27_) {
5458
5459 case GTK_RESPONSE_YES:
5460
5461 {
5462 HklSample* _tmp39_;
5463 {
5464 gboolean _tmp28_;
5465
5466 i = 0;
5467
5468 _tmp28_ = TRUE;
5469
5470 while (TRUE) {
5471
5472 gboolean _tmp29_;
5473 gint _tmp31_;
5474 guint _tmp32_;
5475 guint* _tmp33_;
5476 gint _tmp33__length1;
5477 gint _tmp34_;
5478 guint _tmp35_;
5479 gint _tmp36_;
5480 guint index;
5481 HklSample* _tmp37_;
5482 guint _tmp38_;
5483
5484 _tmp29_ = _tmp28_;
5485
5486 if (!_tmp29_) {
5487
5488 gint _tmp30_;
5489
5490 _tmp30_ = i;
5491
5492 i = _tmp30_ + 1;
5493
5494 }
5495
5496 _tmp28_ = FALSE;
5497
5498 _tmp31_ = i;
5499
5500 _tmp32_ = nb_rows;
5501
5502 if (!(((guint) _tmp31_) < _tmp32_)) {
5503
5504 break;
5505
5506 }
5507
5508 _tmp33_ = indexes;
5509
5510 _tmp33__length1 = indexes_length1;
5511
5512 _tmp34_ = i;
5513
5514 _tmp35_ = _tmp33_[_tmp34_];
5515
5516 _tmp36_ = i;
5517
5518 index = _tmp35_ - _tmp36_;
5519
5520 _tmp37_ = sample;
5521
5522 _tmp38_ = index;
5523
5524 hkl_sample_del_reflection (_tmp37_, (gsize) _tmp38_);
5525
5526 }
5527 }
5528
5529 _tmp39_ = sample;
5530
5531 hkl_gui_window_update_reflections (self, _tmp39_);
5532
5533 break;
5534
5535 }
5536 default:
5537
5538 break;
5539
5540 }
5541
5542 _g_object_unref0 (dialog);
5543
5544 indexes = (g_free (indexes), NULL);
5545
5546 __g_list_free__gtk_tree_path_free0_0 (list);
5547
5548 _g_object_unref0 (model);
5549
5550 } else {
5551 GtkStatusbar* _tmp40_;
5552
5553 _tmp40_ = priv->_statusBar;
5554
5555 gtk_statusbar_push (_tmp40_, (guint) 0, "Please select at least one reflection.");
5556
5557 }
5558
5559 _g_object_unref0 (selection);
5560
5561 }
5562 }
5563
5564
5565 static void hkl_gui_window_on_toolbutton_setUB_clicked (HklGuiWindow* self) {
5566 HklSampleList* _tmp0_;
5567 HklSample* _tmp1_;
5568
5569 g_return_if_fail (self != NULL);
5570
5571 _tmp0_ = priv->samples;
5572
5573 _tmp1_ = _tmp0_->current;
5574
5575 if (_tmp1_ != NULL) {
5576
5577 HklMatrix UB = {0};
5578 HklSampleList* _tmp2_;
5579 HklSample* _tmp3_;
5580 HklMatrix _tmp4_ = {0};
5581 HklMatrix _tmp5_;
5582 gdouble** _tmp6_;
5583 gint _tmp6__length1;
5584 gdouble* _tmp7_;
5585 gint _tmp7__length1;
5586 GtkSpinButton* _tmp8_;
5587 gdouble _tmp9_ = 0.0;
5588 gdouble _tmp10_;
5589 HklMatrix _tmp11_;
5590 gdouble** _tmp12_;
5591 gint _tmp12__length1;
5592 gdouble* _tmp13_;
5593 gint _tmp13__length1;
5594 GtkSpinButton* _tmp14_;
5595 gdouble _tmp15_ = 0.0;
5596 gdouble _tmp16_;
5597 HklMatrix _tmp17_;
5598 gdouble** _tmp18_;
5599 gint _tmp18__length1;
5600 gdouble* _tmp19_;
5601 gint _tmp19__length1;
5602 GtkSpinButton* _tmp20_;
5603 gdouble _tmp21_ = 0.0;
5604 gdouble _tmp22_;
5605 HklMatrix _tmp23_;
5606 gdouble** _tmp24_;
5607 gint _tmp24__length1;
5608 gdouble* _tmp25_;
5609 gint _tmp25__length1;
5610 GtkSpinButton* _tmp26_;
5611 gdouble _tmp27_ = 0.0;
5612 gdouble _tmp28_;
5613 HklMatrix _tmp29_;
5614 gdouble** _tmp30_;
5615 gint _tmp30__length1;
5616 gdouble* _tmp31_;
5617 gint _tmp31__length1;
5618 GtkSpinButton* _tmp32_;
5619 gdouble _tmp33_ = 0.0;
5620 gdouble _tmp34_;
5621 HklMatrix _tmp35_;
5622 gdouble** _tmp36_;
5623 gint _tmp36__length1;
5624 gdouble* _tmp37_;
5625 gint _tmp37__length1;
5626 GtkSpinButton* _tmp38_;
5627 gdouble _tmp39_ = 0.0;
5628 gdouble _tmp40_;
5629 HklMatrix _tmp41_;
5630 gdouble** _tmp42_;
5631 gint _tmp42__length1;
5632 gdouble* _tmp43_;
5633 gint _tmp43__length1;
5634 GtkSpinButton* _tmp44_;
5635 gdouble _tmp45_ = 0.0;
5636 gdouble _tmp46_;
5637 HklMatrix _tmp47_;
5638 gdouble** _tmp48_;
5639 gint _tmp48__length1;
5640 gdouble* _tmp49_;
5641 gint _tmp49__length1;
5642 GtkSpinButton* _tmp50_;
5643 gdouble _tmp51_ = 0.0;
5644 gdouble _tmp52_;
5645 HklMatrix _tmp53_;
5646 gdouble** _tmp54_;
5647 gint _tmp54__length1;
5648 gdouble* _tmp55_;
5649 gint _tmp55__length1;
5650 GtkSpinButton* _tmp56_;
5651 gdouble _tmp57_ = 0.0;
5652 gdouble _tmp58_;
5653 HklSampleList* _tmp59_;
5654 HklSample* _tmp60_;
5655 HklSampleList* _tmp61_;
5656 HklSample* _tmp62_;
5657 FILE* _tmp63_;
5658 HklSampleList* _tmp64_;
5659 HklSample* _tmp65_;
5660
5661 _tmp2_ = priv->samples;
5662
5663 _tmp3_ = _tmp2_->current;
5664
5665 hkl_sample_get_UB (_tmp3_, &_tmp4_);
5666
5667 (&UB);
5668
5669 UB = _tmp4_;
5670
5671 _tmp5_ = UB;
5672
5673 _tmp6_ = _tmp5_.data;
5674
5675 _tmp6__length1 = -1;
5676
5677 _tmp7_ = _tmp6_[0];
5678
5679 _tmp7__length1 = -1;
5680
5681 _tmp8_ = priv->_spinbutton_U11;
5682
5683 _tmp9_ = gtk_spin_button_get_value (_tmp8_);
5684
5685 _tmp7_[0] = _tmp9_;
5686
5687 _tmp10_ = _tmp7_[0];
5688
5689 _tmp11_ = UB;
5690
5691 _tmp12_ = _tmp11_.data;
5692
5693 _tmp12__length1 = -1;
5694
5695 _tmp13_ = _tmp12_[0];
5696
5697 _tmp13__length1 = -1;
5698
5699 _tmp14_ = priv->_spinbutton_U12;
5700
5701 _tmp15_ = gtk_spin_button_get_value (_tmp14_);
5702
5703 _tmp13_[1] = _tmp15_;
5704
5705 _tmp16_ = _tmp13_[1];
5706
5707 _tmp17_ = UB;
5708
5709 _tmp18_ = _tmp17_.data;
5710
5711 _tmp18__length1 = -1;
5712
5713 _tmp19_ = _tmp18_[0];
5714
5715 _tmp19__length1 = -1;
5716
5717 _tmp20_ = priv->_spinbutton_U13;
5718
5719 _tmp21_ = gtk_spin_button_get_value (_tmp20_);
5720
5721 _tmp19_[2] = _tmp21_;
5722
5723 _tmp22_ = _tmp19_[2];
5724
5725 _tmp23_ = UB;
5726
5727 _tmp24_ = _tmp23_.data;
5728
5729 _tmp24__length1 = -1;
5730
5731 _tmp25_ = _tmp24_[1];
5732
5733 _tmp25__length1 = -1;
5734
5735 _tmp26_ = priv->_spinbutton_U21;
5736
5737 _tmp27_ = gtk_spin_button_get_value (_tmp26_);
5738
5739 _tmp25_[0] = _tmp27_;
5740
5741 _tmp28_ = _tmp25_[0];
5742
5743 _tmp29_ = UB;
5744
5745 _tmp30_ = _tmp29_.data;
5746
5747 _tmp30__length1 = -1;
5748
5749 _tmp31_ = _tmp30_[1];
5750
5751 _tmp31__length1 = -1;
5752
5753 _tmp32_ = priv->_spinbutton_U22;
5754
5755 _tmp33_ = gtk_spin_button_get_value (_tmp32_);
5756
5757 _tmp31_[1] = _tmp33_;
5758
5759 _tmp34_ = _tmp31_[1];
5760
5761 _tmp35_ = UB;
5762
5763 _tmp36_ = _tmp35_.data;
5764
5765 _tmp36__length1 = -1;
5766
5767 _tmp37_ = _tmp36_[1];
5768
5769 _tmp37__length1 = -1;
5770
5771 _tmp38_ = priv->_spinbutton_U23;
5772
5773 _tmp39_ = gtk_spin_button_get_value (_tmp38_);
5774
5775 _tmp37_[2] = _tmp39_;
5776
5777 _tmp40_ = _tmp37_[2];
5778
5779 _tmp41_ = UB;
5780
5781 _tmp42_ = _tmp41_.data;
5782
5783 _tmp42__length1 = -1;
5784
5785 _tmp43_ = _tmp42_[2];
5786
5787 _tmp43__length1 = -1;
5788
5789 _tmp44_ = priv->_spinbutton_U31;
5790
5791 _tmp45_ = gtk_spin_button_get_value (_tmp44_);
5792
5793 _tmp43_[0] = _tmp45_;
5794
5795 _tmp46_ = _tmp43_[0];
5796
5797 _tmp47_ = UB;
5798
5799 _tmp48_ = _tmp47_.data;
5800
5801 _tmp48__length1 = -1;
5802
5803 _tmp49_ = _tmp48_[2];
5804
5805 _tmp49__length1 = -1;
5806
5807 _tmp50_ = priv->_spinbutton_U32;
5808
5809 _tmp51_ = gtk_spin_button_get_value (_tmp50_);
5810
5811 _tmp49_[1] = _tmp51_;
5812
5813 _tmp52_ = _tmp49_[1];
5814
5815 _tmp53_ = UB;
5816
5817 _tmp54_ = _tmp53_.data;
5818
5819 _tmp54__length1 = -1;
5820
5821 _tmp55_ = _tmp54_[2];
5822
5823 _tmp55__length1 = -1;
5824
5825 _tmp56_ = priv->_spinbutton_U33;
5826
5827 _tmp57_ = gtk_spin_button_get_value (_tmp56_);
5828
5829 _tmp55_[2] = _tmp57_;
5830
5831 _tmp58_ = _tmp55_[2];
5832
5833 _tmp59_ = priv->samples;
5834
5835 _tmp60_ = _tmp59_->current;
5836
5837 hkl_sample_set_UB (_tmp60_, &UB);
5838
5839 _tmp61_ = priv->samples;
5840
5841 _tmp62_ = _tmp61_->current;
5842
5843 _tmp63_ = stdout;
5844
5845 hkl_sample_fprintf (_tmp63_, _tmp62_);
5846
5847 hkl_gui_window_update_lattice (self);
5848
5849 hkl_gui_window_update_lattice_parameters (self);
5850
5851 hkl_gui_window_update_reciprocal_lattice (self);
5852
5853 _tmp64_ = priv->samples;
5854
5855 _tmp65_ = _tmp64_->current;
5856
5857 hkl_gui_window_update_crystal_model (self, _tmp65_);
5858
5859 hkl_gui_window_update_UB (self);
5860
5861 hkl_gui_window_update_UxUyUz (self);
5862
5863 hkl_gui_window_update_pseudo_axes (self);
5864
5865 hkl_gui_window_update_pseudo_axes_frames (self);
5866
5867 (&UB);
5868
5869 }
5870 }
5871
5872
5873 static void hkl_gui_window_on_toolbutton_computeUB_clicked (HklGuiWindow* self) {
5874 HklSampleList* _tmp0_;
5875 HklSample* _tmp1_;
5876 HklSample* sample;
5877 HklSample* _tmp2_;
5878
5879 g_return_if_fail (self != NULL);
5880
5881 _tmp0_ = priv->samples;
5882
5883 _tmp1_ = _tmp0_->current;
5884
5885 sample = _tmp1_;
5886
5887 _tmp2_ = sample;
5888
5889 if (_tmp2_ != NULL) {
5890
5891 HklSample* _tmp3_;
5892
5893 _tmp3_ = sample;
5894
5895 hkl_sample_compute_UB_busing_levy (_tmp3_, (gsize) 0, (gsize) 1);
5896
5897 hkl_gui_window_update_UB (self);
5898
5899 hkl_gui_window_update_UxUyUz (self);
5900
5901 hkl_gui_window_update_pseudo_axes (self);
5902
5903 hkl_gui_window_update_pseudo_axes_frames (self);
5904
5905 }
5906 }
5907
5908
5909 static void hkl_gui_window_on_toolbutton_add_crystal_clicked (HklGuiWindow* self) {
5910 HklSample* sample = NULL;
5911 HklSample* _tmp0_;
5912 HklSample* _tmp1_;
5913
5914 g_return_if_fail (self != NULL);
5915
5916 _tmp0_ = hkl_sample_new ("new_sample", HKL_SAMPLE_TYPE_MONOCRYSTAL);
5917
5918 sample = _tmp0_;
5919
5920 _tmp1_ = sample;
5921
5922 if (_tmp1_ != NULL) {
5923
5924 GtkTreePath* path = NULL;
5925 GtkTreeViewColumn* column = NULL;
5926 HklSampleList* _tmp2_;
5927 HklSample* _tmp3_;
5928 HklSampleList* _tmp4_;
5929 GtkTreeView* _tmp5_;
5930 GtkTreePath* _tmp6_ = NULL;
5931 GtkTreeViewColumn* _tmp7_ = NULL;
5932 GtkTreeViewColumn* _tmp8_;
5933 GtkTreeView* _tmp9_;
5934 GtkTreeViewColumn* _tmp10_ = NULL;
5935 GtkTreeViewColumn* _tmp11_;
5936 GtkTreeView* _tmp12_;
5937 GtkTreePath* _tmp13_;
5938 GtkTreeViewColumn* _tmp14_;
5939
5940 _tmp2_ = priv->samples;
5941
5942 _tmp3_ = sample;
5943
5944 sample = NULL;
5945
5946 hkl_sample_list_append (_tmp2_, _tmp3_);
5947
5948 _tmp4_ = priv->samples;
5949
5950 hkl_sample_list_select_current (_tmp4_, "new_sample");
5951
5952 hkl_gui_window_update_tree_view_crystals (self);
5953
5954 _tmp5_ = priv->_treeview_crystals;
5955
5956 gtk_tree_view_get_cursor (_tmp5_, &_tmp6_, &_tmp7_);
5957
5958 _gtk_tree_path_free0 (path);
5959
5960 path = _tmp6_;
5961
5962 _g_object_unref0 (column);
5963
5964 _tmp8_ = _g_object_ref0 (_tmp7_);
5965
5966 column = _tmp8_;
5967
5968 _tmp9_ = priv->_treeview_crystals;
5969
5970 _tmp10_ = gtk_tree_view_get_column (_tmp9_, 0);
5971
5972 _tmp11_ = _g_object_ref0 (_tmp10_);
5973
5974 _g_object_unref0 (column);
5975
5976 column = _tmp11_;
5977
5978 _tmp12_ = priv->_treeview_crystals;
5979
5980 _tmp13_ = path;
5981
5982 _tmp14_ = column;
5983
5984 gtk_tree_view_set_cursor (_tmp12_, _tmp13_, _tmp14_, TRUE);
5985
5986 _g_object_unref0 (column);
5987
5988 _gtk_tree_path_free0 (path);
5989
5990 }
5991 }
5992
5993
5994 static void hkl_gui_window_on_toolbutton_copy_crystal_clicked (HklGuiWindow* self) {
5995 GtkTreePath* path = NULL;
5996 GtkTreeViewColumn* column = NULL;
5997 HklSampleList* _tmp0_;
5998 HklSample* _tmp1_;
5999 HklSample* old_sample;
6000 HklSample* _tmp2_;
6001 HklSampleList* _tmp4_;
6002 HklSample* _tmp5_;
6003 HklSample* _tmp6_;
6004 HklSample* sample;
6005 HklSample* _tmp7_;
6006 HklSampleList* _tmp8_;
6007 HklSample* _tmp9_;
6008 HklSampleList* _tmp10_;
6009 GtkTreeView* _tmp11_;
6010 GtkTreePath* _tmp12_ = NULL;
6011 GtkTreeViewColumn* _tmp13_ = NULL;
6012 GtkTreeViewColumn* _tmp14_;
6013 GtkTreeView* _tmp15_;
6014 GtkTreeViewColumn* _tmp16_ = NULL;
6015 GtkTreeViewColumn* _tmp17_;
6016 GtkTreeView* _tmp18_;
6017 GtkTreePath* _tmp19_;
6018 GtkTreeViewColumn* _tmp20_;
6019
6020 g_return_if_fail (self != NULL);
6021
6022 _tmp0_ = priv->samples;
6023
6024 _tmp1_ = _tmp0_->current;
6025
6026 old_sample = _tmp1_;
6027
6028 _tmp2_ = old_sample;
6029
6030 if (_tmp2_ == NULL) {
6031
6032 GtkStatusbar* _tmp3_;
6033
6034 _tmp3_ = priv->_statusBar;
6035
6036 gtk_statusbar_push (_tmp3_, (guint) 0, "Please select a crystal to copy.");
6037
6038 _g_object_unref0 (column);
6039
6040 _gtk_tree_path_free0 (path);
6041
6042 return;
6043
6044 }
6045
6046 _tmp4_ = priv->samples;
6047
6048 _tmp5_ = _tmp4_->current;
6049
6050 _tmp6_ = hkl_sample_new_copy (_tmp5_);
6051
6052 sample = _tmp6_;
6053
6054 _tmp7_ = sample;
6055
6056 hkl_sample_set_name (_tmp7_, "copy");
6057
6058 _tmp8_ = priv->samples;
6059
6060 _tmp9_ = sample;
6061
6062 sample = NULL;
6063
6064 hkl_sample_list_append (_tmp8_, _tmp9_);
6065
6066 _tmp10_ = priv->samples;
6067
6068 hkl_sample_list_select_current (_tmp10_, "copy");
6069
6070 hkl_gui_window_update_tree_view_crystals (self);
6071
6072 _tmp11_ = priv->_treeview_crystals;
6073
6074 gtk_tree_view_get_cursor (_tmp11_, &_tmp12_, &_tmp13_);
6075
6076 _gtk_tree_path_free0 (path);
6077
6078 path = _tmp12_;
6079
6080 _g_object_unref0 (column);
6081
6082 _tmp14_ = _g_object_ref0 (_tmp13_);
6083
6084 column = _tmp14_;
6085
6086 _tmp15_ = priv->_treeview_crystals;
6087
6088 _tmp16_ = gtk_tree_view_get_column (_tmp15_, 0);
6089
6090 _tmp17_ = _g_object_ref0 (_tmp16_);
6091
6092 _g_object_unref0 (column);
6093
6094 column = _tmp17_;
6095
6096 _tmp18_ = priv->_treeview_crystals;
6097
6098 _tmp19_ = path;
6099
6100 _tmp20_ = column;
6101
6102 gtk_tree_view_set_cursor (_tmp18_, _tmp19_, _tmp20_, TRUE);
6103
6104 _g_object_unref0 (column);
6105
6106 _gtk_tree_path_free0 (path);
6107
6108 }
6109
6110
6111 static void hkl_gui_window_on_toolbutton_del_crystal_clicked (HklGuiWindow* self) {
6112 HklSampleList* _tmp0_;
6113 HklSample* _tmp1_;
6114
6115 g_return_if_fail (self != NULL);
6116
6117 _tmp0_ = priv->samples;
6118
6119 _tmp1_ = _tmp0_->current;
6120
6121 if (_tmp1_ != NULL) {
6122
6123 HklSampleList* _tmp2_;
6124 HklSampleList* _tmp3_;
6125 HklSample* _tmp4_;
6126
6127 _tmp2_ = priv->samples;
6128
6129 _tmp3_ = priv->samples;
6130
6131 _tmp4_ = _tmp3_->current;
6132
6133 hkl_sample_list_del (_tmp2_, _tmp4_);
6134
6135 hkl_gui_window_update_tree_view_crystals (self);
6136
6137 }
6138 }
6139
6140
6141 static void hkl_gui_window_on_toolbutton_affiner_clicked (HklGuiWindow* self) {
6142 HklSampleList* _tmp0_;
6143 HklSample* _tmp1_;
6144 HklSample* sample;
6145 HklSample* _tmp2_;
6146 HklSample* _tmp4_;
6147
6148 g_return_if_fail (self != NULL);
6149
6150 _tmp0_ = priv->samples;
6151
6152 _tmp1_ = _tmp0_->current;
6153
6154 sample = _tmp1_;
6155
6156 _tmp2_ = sample;
6157
6158 if (_tmp2_ != NULL) {
6159
6160 HklSample* _tmp3_;
6161
6162 _tmp3_ = sample;
6163
6164 hkl_sample_affine (_tmp3_);
6165
6166 }
6167
6168 _tmp4_ = sample;
6169
6170 hkl_gui_window_update_crystal_model (self, _tmp4_);
6171
6172 hkl_gui_window_update_lattice (self);
6173
6174 hkl_gui_window_update_reciprocal_lattice (self);
6175
6176 hkl_gui_window_update_UB (self);
6177
6178 hkl_gui_window_update_UxUyUz (self);
6179
6180 }
6181
6182
6183 static gboolean hkl_gui_window_on_tree_view_reflections_key_press_event (GdkEventKey* event, HklGuiWindow* self) {
6184 gboolean result = FALSE;
6185
6186 g_return_val_if_fail (self != NULL, FALSE);
6187
6188 g_return_val_if_fail (event != NULL, FALSE);
6189
6190 result = TRUE;
6191
6192 return result;
6193
6194 }
6195
6196
6197 static gboolean hkl_gui_window_on_tree_view_crystals_key_press_event (GdkEventKey* event, HklGuiWindow* self) {
6198 gboolean result = FALSE;
6199
6200 g_return_val_if_fail (self != NULL, FALSE);
6201
6202 g_return_val_if_fail (event != NULL, FALSE);
6203
6204 result = TRUE;
6205
6206 return result;
6207
6208 }
6209
6210
6211 static void hkl_gui_window_on_menuitem5_activate (HklGuiWindow* self) {
6212 GtkDialog* _tmp0_;
6213
6214 g_return_if_fail (self != NULL);
6215
6216 _tmp0_ = priv->_dialog1;
6217
6218 gtk_widget_show ((GtkWidget*) _tmp0_);
6219
6220 }
6221
6222
6223 void hkl_gui_window_on_button1_clicked (HklGuiWindow* self) {
6224 GtkDialog* _tmp0_;
6225
6226 g_return_if_fail (self != NULL);
6227
6228 _tmp0_ = priv->_dialog1;
6229
6230 gtk_widget_hide ((GtkWidget*) _tmp0_);
6231
6232 }
6233
6234
6235 void hkl_gui_window_on_combobox1_changed (HklGuiWindow* self) {
6236 gsize idx = 0UL;
6237 HklGeometryConfig config = {0};
6238 GtkComboBox* _tmp0_;
6239 gint _tmp1_ = 0;
6240 HklGeometryConfig _tmp2_;
6241 HklGeometryConfig _tmp3_;
6242 HklGeometry* _tmp4_ = NULL;
6243 HklGeometryConfig _tmp5_;
6244 HklPseudoAxisEngineList* _tmp6_ = NULL;
6245 HklPseudoAxisEngineList* _tmp7_;
6246 HklGeometry* _tmp8_;
6247 HklDetector* _tmp9_;
6248 HklSampleList* _tmp10_;
6249 HklSample* _tmp11_;
6250
6251 g_return_if_fail (self != NULL);
6252
6253 _tmp0_ = priv->_combobox1;
6254
6255 _tmp1_ = gtk_combo_box_get_active (_tmp0_);
6256
6257 idx = (gsize) _tmp1_;
6258
6259 _tmp2_ = hkl_geometry_factory_configs[idx];
6260
6261 config = _tmp2_;
6262
6263 _tmp3_ = config;
6264
6265 _tmp4_ = hkl_geometry_factory_new (&_tmp3_, 50 * HKL_DEGTORAD);
6266
6267 _hkl_geometry_free0 (priv->geometry);
6268
6269 priv->geometry = _tmp4_;
6270
6271 _tmp5_ = config;
6272
6273 _tmp6_ = hkl_pseudo_axis_engine_list_factory (&_tmp5_);
6274
6275 _hkl_pseudo_axis_engine_list_free0 (priv->engines);
6276
6277 priv->engines = _tmp6_;
6278
6279 _tmp7_ = priv->engines;
6280
6281 _tmp8_ = priv->geometry;
6282
6283 _tmp9_ = priv->detector;
6284
6285 _tmp10_ = priv->samples;
6286
6287 _tmp11_ = _tmp10_->current;
6288
6289 hkl_pseudo_axis_engine_list_init (_tmp7_, _tmp8_, _tmp9_, _tmp11_);
6290
6291 hkl_gui_window_set_up_pseudo_axes_frames (self);
6292
6293 hkl_gui_window_set_up_tree_view_axes (self);
6294
6295 hkl_gui_window_set_up_tree_view_pseudo_axes_parameters (self);
6296
6297 hkl_gui_window_set_up_tree_view_pseudo_axes (self);
6298
6299 hkl_gui_window_set_up_tree_view_treeview1 (self);
6300
6301 hkl_gui_window_set_up_3D (self);
6302
6303 }
6304
6305 */
6306
6307 static void
6308 hkl_gui_window_class_init (HklGuiWindowClass *class)
6309 {
6310 GObjectClass *gobject_class = G_OBJECT_CLASS (class);
6311
6312 g_type_class_add_private (class, sizeof (HklGuiWindowPrivate));
6313
6314 /* virtual method */
6315 gobject_class->finalize = finalize;
6316 }
6317
6318
6319 static void hkl_gui_window_init (HklGuiWindow * self)
6320 {
6321 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
6322
6323 priv->diffractometer = NULL;
6324
6325 darray_init(priv->pseudo_frames);
6326
6327 priv->sample = hkl_sample_new ("test");
6328 priv->reciprocal = hkl_lattice_new_default ();
6329
6330 hkl_gui_window_get_widgets_and_objects_from_ui (self);
6331
6332 set_up_diffractometer_model (self);
6333
6334 //hkl_gui_window_set_up_tree_view_crystals (self);
6335
6336 //hkl_gui_window_update_tree_view_crystals (self);
6337
6338 //hkl_gui_window_update_source (self);
6339
6340 //hkl_gui_window_update_lattice (self);
6341
6342 //hkl_gui_window_update_lattice_parameters (self);
6343
6344 //hkl_gui_window_update_reciprocal_lattice (self);
6345
6346 //hkl_gui_window_update_UxUyUz (self);
6347
6348 //hkl_gui_window_update_UB (self);
6349
6350 //hkl_gui_window_connect_all_signals (self);
6351 }
6352
6353 int main (int argc, char ** argv)
6354 {
6355 gtk_init (&argc, &argv);
6356
6357 hkl_gui_window_new ();
6358
6359 gtk_main ();
6360
6361 return 0;
6362 }
Diffractometer computation library