?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
remove more useless code
[hkl.git] / gui / hkl-gui.c
blob64a769f85c59423421eb34f6082a2680cb7920a0
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 #define EMBED_BREAKPOINT asm volatile ("int3;")
44
45 G_DEFINE_TYPE (HklGuiWindow, hkl_gui_window, G_TYPE_OBJECT);
46
47 typedef enum {
48 REFLECTION_COL_INDEX = 0,
49 REFLECTION_COL_H,
50 REFLECTION_COL_K,
51 REFLECTION_COL_L,
52 REFLECTION_COL_FLAG,
53 REFLECTION_COL_REFLECTION,
54 REFLECTION_COL_N_COLUMNS
55 } ReflectionCol;
56
57 typedef enum {
58 AXIS_COL_AXIS = 0,
59 AXIS_COL_NAME,
60 AXIS_COL_READ,
61 AXIS_COL_WRITE,
62 AXIS_COL_MIN,
63 AXIS_COL_MAX,
64 AXIS_COL_N_COLUMNS
65 } AxisCol;
66
67 typedef enum {
68 PSEUDO_AXIS_COL_PARAMETER = 0,
69 PSEUDO_AXIS_COL_ENGINE,
70 PSEUDO_AXIS_COL_NAME,
71 PSEUDO_AXIS_COL_READ,
72 PSEUDO_AXIS_COL_WRITE,
73 PSEUDO_AXIS_COL_N_COLUMNS
74 } PseudoAxisCol;
75
76 typedef enum {
77 PARAMETER_COL_PARAMETER = 0,
78 PARAMETER_COL_NAME,
79 PARAMETER_COL_VALUE,
80 PARAMETER_COL_N_COLUMNS
81 } ParameterCol;
82
83 typedef enum {
84 SAMPLE_COL_SAMPLE = 0,
85 SAMPLE_COL_NAME,
86 SAMPLE_COL_A,
87 SAMPLE_COL_B,
88 SAMPLE_COL_C,
89 SAMPLE_COL_ALPHA,
90 SAMPLE_COL_BETA,
91 SAMPLE_COL_GAMMA,
92 SAMPLE_COL_N_COLUMNS
93 } SampleCol;
94
95 typedef enum {
96 SOLUTION_COL_INDEX = 0,
97 SOLUTION_COL_N_COLUMNS
98 } SolutionCol;
99
100 typedef enum {
101 DIFFRACTOMETER_COL_NAME = 0,
102 DIFFRACTOMETER_COL_FACTORY,
103 DIFFRACTOMETER_COL_DIFFRACTOMETER,
104 DIFFRACTOMETER_COL_N_COLUMNS
105 } DiffractometerCol;
106
107 /******************/
108 /* Diffractometer */
109 /******************/
110
111 struct diffractometer_t {
112 HklGeometry *geometry;
113 HklDetector *detector;
114 HklEngineList *engines;
115 };
116
117
118 static struct diffractometer_t *
119 create_diffractometer(HklFactory *factory)
120 {
121 struct diffractometer_t *self;
122
123 self = malloc(sizeof(*self));
124
125 self->geometry = hkl_factory_create_new_geometry (factory);
126 self->engines = hkl_factory_create_new_engine_list (factory);
127 self->detector = hkl_detector_factory_new (HKL_DETECTOR_TYPE_0D);
128 hkl_detector_idx_set (self->detector, 1);
129
130 return self;
131 }
132
133 static void
134 delete_diffractometer(struct diffractometer_t *self)
135 {
136 hkl_geometry_free(self->geometry);
137 hkl_engine_list_free(self->engines);
138 hkl_detector_free(self->detector);
139 }
140
141
142 static void
143 dump_diffractometer(struct diffractometer_t *self)
144 {
145 /* hkl_geometry_fprintf(stderr, self->geometry); */
146 /* hkl_engine_list_fprintf(stderr, self->engines); */
147 /* hkl_detector_fprintf(stderr, self->detector); */
148 }
149
150 static void
151 diffractometer_engine_list_init(struct diffractometer_t *self,
152 HklSample *sample)
153 {
154 g_return_if_fail(self != NULL);
155 g_return_if_fail(sample != NULL);
156
157 hkl_engine_list_init(self->engines,
158 self->geometry,
159 self->detector,
160 sample);
161 }
162
163 /****************/
164 /* HklGuiWindow */
165 /****************/
166
167 struct _HklGuiWindowPrivate {
168 GtkBuilder* builder;
169 GtkLabel* _label_UB11;
170 GtkLabel* _label_UB12;
171 GtkLabel* _label_UB13;
172 GtkLabel* _label_UB21;
173 GtkLabel* _label_UB22;
174 GtkLabel* _label_UB23;
175 GtkLabel* _label_UB31;
176 GtkLabel* _label_UB32;
177 GtkLabel* _label_UB33;
178 GtkButton* _button2;
179 GtkSpinButton* _spinbutton_a;
180 GtkSpinButton* _spinbutton_b;
181 GtkSpinButton* _spinbutton_c;
182 GtkSpinButton* _spinbutton_alpha;
183 GtkSpinButton* _spinbutton_beta;
184 GtkSpinButton* _spinbutton_gamma;
185 GtkSpinButton* _spinbutton_a_min;
186 GtkSpinButton* _spinbutton_b_min;
187 GtkSpinButton* _spinbutton_c_min;
188 GtkSpinButton* _spinbutton_alpha_min;
189 GtkSpinButton* _spinbutton_beta_min;
190 GtkSpinButton* _spinbutton_gamma_min;
191 GtkSpinButton* _spinbutton_a_max;
192 GtkSpinButton* _spinbutton_b_max;
193 GtkSpinButton* _spinbutton_c_max;
194 GtkSpinButton* _spinbutton_alpha_max;
195 GtkSpinButton* _spinbutton_beta_max;
196 GtkSpinButton* _spinbutton_gamma_max;
197 GtkSpinButton* _spinbutton_lambda;
198 GtkSpinButton* _spinbutton_a_star;
199 GtkSpinButton* _spinbutton_b_star;
200 GtkSpinButton* _spinbutton_c_star;
201 GtkSpinButton* _spinbutton_alpha_star;
202 GtkSpinButton* _spinbutton_beta_star;
203 GtkSpinButton* _spinbutton_gamma_star;
204 GtkSpinButton* _spinbutton_ux;
205 GtkSpinButton* _spinbutton_uy;
206 GtkSpinButton* _spinbutton_uz;
207 GtkSpinButton* _spinbutton_U11;
208 GtkSpinButton* _spinbutton_U12;
209 GtkSpinButton* _spinbutton_U13;
210 GtkSpinButton* _spinbutton_U21;
211 GtkSpinButton* _spinbutton_U22;
212 GtkSpinButton* _spinbutton_U23;
213 GtkSpinButton* _spinbutton_U31;
214 GtkSpinButton* _spinbutton_U32;
215 GtkSpinButton* _spinbutton_U33;
216 GtkCheckButton* _checkbutton_a;
217 GtkCheckButton* _checkbutton_b;
218 GtkCheckButton* _checkbutton_c;
219 GtkCheckButton* _checkbutton_alpha;
220 GtkCheckButton* _checkbutton_beta;
221 GtkCheckButton* _checkbutton_gamma;
222 GtkCheckButton* _checkbutton_ux;
223 GtkCheckButton* _checkbutton_uy;
224 GtkCheckButton* _checkbutton_uz;
225 GtkTreeView* _treeview_reflections;
226 GtkTreeView* _treeview_crystals;
227 GtkTreeView* _treeview_axes;
228 GtkTreeView* _treeview_pseudo_axes;
229 GtkTreeView* _treeview_pseudo_axes_parameters;
230 GtkTreeView* _treeview_solutions;
231 GtkToolButton* _toolbutton_add_reflection;
232 GtkToolButton* _toolbutton_goto_reflection;
233 GtkToolButton* _toolbutton_del_reflection;
234 GtkToolButton* _toolbutton_setUB;
235 GtkToolButton* _toolbutton_computeUB;
236 GtkToolButton* _toolbutton_add_crystal;
237 GtkToolButton* _toolbutton_copy_crystal;
238 GtkToolButton* _toolbutton_del_crystal;
239 GtkToolButton* _toolbutton_affiner;
240 GtkStatusbar* _statusbar;
241 GtkImageMenuItem* _menuitem5;
242 GtkVBox* _box_info_bar; /* fake for the infor bar */
243 GtkVBox* _vbox7;
244 GtkVBox* _vbox2;
245 GtkDialog* _dialog1;
246 GtkButton* _button1;
247 GtkComboBox* _combobox1;
248 GtkListStore* _liststore_diffractometer;
249 GtkListStore* _liststore_axis;
250 GtkListStore* _liststore_pseudo_axes;
251 GtkListStore* _liststore_solutions;
252 GtkListStore* _liststore_reflections;
253 GtkListStore* _liststore_crystals;
254
255 GtkInfoBar *info_bar;
256 GtkLabel *info_message;
257
258 darray(HklGuiEngine *) pseudo_frames;
259
260 struct diffractometer_t *diffractometer; /* unowned */
261 HklSample *sample; /* unowned */
262 HklLattice *reciprocal;
263 };
264
265 #define HKL_GUI_WINDOW_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), HKL_GUI_TYPE_WINDOW, HklGuiWindowPrivate))
266
267 static gboolean
268 finalize_liststore_diffractometer(GtkTreeModel *model,
269 GtkTreePath *path,
270 GtkTreeIter *iter,
271 gpointer data)
272 {
273 struct diffractometer_t *diffractometer;
274
275 gtk_tree_model_get(model, iter,
276 DIFFRACTOMETER_COL_DIFFRACTOMETER, &diffractometer,
277 -1);
278 delete_diffractometer(diffractometer);
279 return FALSE;
280 }
281
282 static gboolean
283 finalize_liststore_samples(GtkTreeModel *model,
284 GtkTreePath *path,
285 GtkTreeIter *iter,
286 gpointer data)
287 {
288 HklSample *sample = NULL;
289
290 gtk_tree_model_get(model, iter,
291 SAMPLE_COL_SAMPLE, &sample,
292 -1);
293 hkl_sample_free(sample);
294 return FALSE;
295 }
296
297 static void
298 finalize (GObject* object)
299 {
300 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(object);
301
302 g_object_unref(priv->builder);
303
304 darray_free(priv->pseudo_frames);
305
306 gtk_tree_model_foreach(GTK_TREE_MODEL(priv->_liststore_diffractometer),
307 finalize_liststore_diffractometer,
308 NULL);
309
310 gtk_tree_model_foreach(GTK_TREE_MODEL(priv->_liststore_crystals),
311 finalize_liststore_samples,
312 NULL);
313
314 G_OBJECT_CLASS (hkl_gui_window_parent_class)->finalize (object);
315 }
316
317 HklGuiWindow* hkl_gui_window_new (void)
318 {
319 return g_object_new (HKL_GUI_TYPE_WINDOW, NULL);
320 }
321
322
323 #define get_object(builder, type, priv, name) priv->_ ## name = type(gtk_builder_get_object(builder, #name))
324
325 static void
326 hkl_gui_window_get_widgets_and_objects_from_ui (HklGuiWindow* self)
327 {
328 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
329 GtkBuilder* builder;
330
331 g_return_if_fail (self != NULL);
332
333 priv->builder = builder = gtk_builder_new ();
334 gtk_builder_add_from_file (builder, "ghkl.ui", NULL);
335
336 get_object(builder, GTK_LIST_STORE, priv, liststore_diffractometer);
337 get_object(builder, GTK_LIST_STORE, priv, liststore_axis);
338 get_object(builder, GTK_LIST_STORE, priv, liststore_pseudo_axes);
339 get_object(builder, GTK_LIST_STORE, priv, liststore_reflections);
340 get_object(builder, GTK_LIST_STORE, priv, liststore_crystals);
341
342 get_object(builder, GTK_LABEL, priv, label_UB11);
343 get_object(builder, GTK_LABEL, priv, label_UB12);
344 get_object(builder, GTK_LABEL, priv, label_UB13);
345 get_object(builder, GTK_LABEL, priv, label_UB21);
346 get_object(builder, GTK_LABEL, priv, label_UB22);
347 get_object(builder, GTK_LABEL, priv, label_UB23);
348 get_object(builder, GTK_LABEL, priv, label_UB31);
349 get_object(builder, GTK_LABEL, priv, label_UB32);
350 get_object(builder, GTK_LABEL, priv, label_UB33);
351
352 get_object(builder, GTK_BUTTON, priv, button2);
353
354 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_a);
355 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_a_min);
356 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_a_max);
357 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_a_star);
358
359 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_b);
360 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_b_min);
361 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_b_max);
362 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_b_star);
363
364 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_c);
365 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_c_min);
366 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_c_max);
367 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_c_star);
368
369 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_alpha);
370 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_alpha_min);
371 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_alpha_max);
372 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_alpha_star);
373
374 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_beta);
375 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_beta_min);
376 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_beta_max);
377 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_beta_star);
378
379 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_gamma);
380 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_gamma_min);
381 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_gamma_max);
382 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_gamma_star);
383
384 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_lambda);
385
386 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_ux);
387 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_uy);
388 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_uz);
389
390 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_U11);
391 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_U12);
392 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_U13);
393 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_U21);
394 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_U22);
395 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_U23);
396 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_U31);
397 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_U32);
398 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_U33);
399
400
401 get_object(builder, GTK_CHECK_BUTTON, priv, checkbutton_a);
402 get_object(builder, GTK_CHECK_BUTTON, priv, checkbutton_b);
403 get_object(builder, GTK_CHECK_BUTTON, priv, checkbutton_c);
404 get_object(builder, GTK_CHECK_BUTTON, priv, checkbutton_alpha);
405 get_object(builder, GTK_CHECK_BUTTON, priv, checkbutton_beta);
406 get_object(builder, GTK_CHECK_BUTTON, priv, checkbutton_gamma);
407 get_object(builder, GTK_CHECK_BUTTON, priv, checkbutton_ux);
408 get_object(builder, GTK_CHECK_BUTTON, priv, checkbutton_uy);
409 get_object(builder, GTK_CHECK_BUTTON, priv, checkbutton_uz);
410
411
412 get_object(builder, GTK_TREE_VIEW, priv, treeview_reflections);
413 get_object(builder, GTK_TREE_VIEW, priv, treeview_crystals);
414 get_object(builder, GTK_TREE_VIEW, priv, treeview_axes);
415 get_object(builder, GTK_TREE_VIEW, priv, treeview_pseudo_axes);
416 get_object(builder, GTK_TREE_VIEW, priv, treeview_solutions);
417 priv->_treeview_pseudo_axes_parameters = GTK_TREE_VIEW(gtk_builder_get_object (builder, "treeview_pseudoAxes_parameters"));
418
419
420 get_object(builder, GTK_TOOL_BUTTON, priv, toolbutton_add_reflection);
421 get_object(builder, GTK_TOOL_BUTTON, priv, toolbutton_goto_reflection);
422 get_object(builder, GTK_TOOL_BUTTON, priv, toolbutton_del_reflection);
423 get_object(builder, GTK_TOOL_BUTTON, priv, toolbutton_setUB);
424 get_object(builder, GTK_TOOL_BUTTON, priv, toolbutton_computeUB);
425 get_object(builder, GTK_TOOL_BUTTON, priv, toolbutton_add_crystal);
426 get_object(builder, GTK_TOOL_BUTTON, priv, toolbutton_copy_crystal);
427 get_object(builder, GTK_TOOL_BUTTON, priv, toolbutton_del_crystal);
428 get_object(builder, GTK_TOOL_BUTTON, priv, toolbutton_affiner);
429
430 get_object(builder, GTK_STATUSBAR, priv, statusbar);
431
432 get_object(builder, GTK_IMAGE_MENU_ITEM, priv, menuitem5);
433
434 get_object(builder, GTK_VBOX, priv, vbox7);
435 get_object(builder, GTK_VBOX, priv, vbox2);
436 get_object(builder, GTK_VBOX, priv, box_info_bar);
437
438 get_object(builder, GTK_DIALOG, priv, dialog1);
439
440 get_object(builder, GTK_COMBO_BOX, priv, combobox1);
441
442 gtk_builder_connect_signals (builder, self);
443 }
444
445 static void
446 update_pseudo_axes_frames (HklGuiWindow* self)
447 {
448 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
449 HklGuiEngine **engine;
450
451 g_return_if_fail (self != NULL);
452
453 darray_foreach(engine, priv->pseudo_frames){
454 hkl_gui_engine_update(*engine);
455 }
456 }
457
458 static void
459 raise_error(HklGuiWindow *self, HklError **error)
460 {
461 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
462
463 g_return_if_fail (self != NULL);
464 g_return_if_fail (error != NULL);
465
466 /* show an error message */
467 gtk_label_set_text (GTK_LABEL (priv->info_message),
468 hkl_error_message_get(*error));
469 gtk_info_bar_set_message_type (priv->info_bar,
470 GTK_MESSAGE_ERROR);
471 gtk_widget_show (GTK_WIDGET(priv->info_bar));
472
473 hkl_error_clear(error);
474 }
475
476 static void
477 clear_error(HklGuiWindow *self, HklError **error)
478 {
479 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
480
481 g_return_if_fail (self != NULL);
482
483 gtk_widget_hide(GTK_WIDGET(priv->info_bar));
484 }
485
486 static gboolean
487 _update_axis (GtkTreeModel *model, GtkTreePath *path,
488 GtkTreeIter *iter, gpointer data)
489 {
490 HklParameter *parameter;
491 gdouble value, min, max;
492
493 gtk_tree_model_get (model, iter,
494 AXIS_COL_AXIS, &parameter,
495 -1);
496
497 hkl_parameter_min_max_unit_get(parameter, &min, &max);
498 value = hkl_parameter_value_unit_get(parameter);
499
500 gtk_list_store_set(GTK_LIST_STORE(model), iter,
501 AXIS_COL_READ, value,
502 AXIS_COL_WRITE, value,
503 AXIS_COL_MIN, min,
504 AXIS_COL_MAX, max,
505 -1);
506 return FALSE;
507 }
508
509 static void
510 update_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_axis),
517 _update_axis,
518 self);
519 }
520
521 static gboolean
522 _update_pseudo_axes (GtkTreeModel *model, GtkTreePath *path,
523 GtkTreeIter *iter, gpointer data)
524 {
525 HklParameter *parameter;
526 gdouble value, min, max;
527
528 gtk_tree_model_get (model, iter,
529 PSEUDO_AXIS_COL_PARAMETER, &parameter,
530 -1);
531
532 hkl_parameter_min_max_unit_get(parameter, &min, &max);
533 value = hkl_parameter_value_unit_get(parameter);
534
535 gtk_list_store_set(GTK_LIST_STORE(model), iter,
536 PSEUDO_AXIS_COL_READ, value,
537 PSEUDO_AXIS_COL_WRITE, value,
538 -1);
539 return FALSE;
540 }
541
542 static void
543 update_pseudo_axes (HklGuiWindow* self)
544 {
545 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
546
547 g_return_if_fail (self != NULL);
548
549 gtk_tree_model_foreach(GTK_TREE_MODEL(priv->_liststore_pseudo_axes),
550 _update_pseudo_axes,
551 self);
552 }
553
554 static void
555 update_solutions (HklGuiWindow* self)
556 {
557 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
558 const HklGeometryList *geometries;
559 const darray_item *items;
560 GtkTreeIter iter = {0};
561
562 g_return_if_fail (self != NULL);
563
564 geometries = hkl_engine_list_geometries(priv->diffractometer->engines);
565
566 gtk_list_store_clear(priv->_liststore_solutions);
567 items = hkl_geometry_list_items_get(geometries);
568 if (darray_size(*items)){
569 gint n_values = gtk_tree_model_get_n_columns (GTK_TREE_MODEL(priv->_liststore_solutions));
570 GValue *values = g_new0(GValue, n_values);
571 gint *columns = g_new0(gint, n_values);
572 gint i;
573
574 /* prepare the GValue before using them */
575 g_value_init(&values[0], G_TYPE_INT);
576 for(i=1; i<n_values; ++i)
577 g_value_init(&values[i], G_TYPE_DOUBLE);
578
579 for(i=0; i<darray_size(*items);++i){
580 gint column = 0;
581 const HklGeometry *geometry;
582 HklParameter **parameter;
583 const darray_parameter *parameters;
584
585 geometry = hkl_geometry_list_item_geometry_get(darray_item(*items, i));
586 parameters = hkl_geometry_axes_get(geometry);
587
588 g_value_set_int(&values[column], i);
589 columns[0] = column;
590
591 darray_foreach(parameter, *parameters){
592 double value = hkl_parameter_value_unit_get(*parameter);
593
594 column = column + 1;
595 g_value_set_double(&values[column], value);
596 columns[column] = column;
597 }
598 gtk_list_store_insert_with_valuesv(priv->_liststore_solutions,
599 &iter, i,
600 columns, values, n_values);
601 }
602 g_free(columns);
603 g_free(values);
604 }
605 }
606
607 static void
608 update_source (HklGuiWindow* self)
609 {
610 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
611
612 g_return_if_fail (self != NULL);
613
614 gtk_spin_button_set_value (priv->_spinbutton_lambda,
615 hkl_geometry_wavelength_get(priv->diffractometer->geometry));
616 }
617
618 static void
619 update_reflections (HklGuiWindow *self)
620 {
621 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
622
623 gtk_list_store_clear (priv->_liststore_reflections);
624
625 if(priv->sample){
626 HklSampleReflection* reflection = NULL;
627 guint index = 0;
628
629 reflection = hkl_sample_first_reflection_get(priv->sample);
630 while(reflection){
631 GtkTreeIter iter = {0};
632 gdouble h, k, l;
633 gboolean flag;
634
635 hkl_sample_reflection_hkl_get(reflection, &h, &k, &l);
636 flag = hkl_sample_reflection_flag_get(reflection);
637
638 gtk_list_store_append (priv->_liststore_reflections, &iter);
639
640 gtk_list_store_set (priv->_liststore_reflections,
641 &iter,
642 REFLECTION_COL_INDEX, index++,
643 REFLECTION_COL_H, h,
644 REFLECTION_COL_K, k,
645 REFLECTION_COL_L, l,
646 REFLECTION_COL_FLAG, flag,
647 REFLECTION_COL_REFLECTION, reflection,
648 -1);
649 reflection = hkl_sample_next_reflection_get(priv->sample,
650 reflection);
651 }
652 }
653 }
654
655 static gboolean
656 hkl_engine_to_axes(HklGuiWindow *self, HklEngine *engine)
657 {
658 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
659 HklError *error = NULL;
660 gboolean res = TRUE;
661
662 g_return_val_if_fail (self != NULL, FALSE);
663 g_return_val_if_fail (engine != NULL, FALSE);
664
665 if(hkl_engine_set(engine, &error)){
666 clear_error(self, &error);
667 hkl_engine_list_select_solution(priv->diffractometer->engines, 0);
668 hkl_engine_list_get(priv->diffractometer->engines);
669
670 update_axes (self);
671 update_pseudo_axes (self);
672 update_pseudo_axes_frames (self);
673 }else{
674 raise_error(self, &error);
675 dump_diffractometer(priv->diffractometer);
676 res = FALSE;
677 }
678 update_solutions (self);
679 return res;
680 }
681
682 static void
683 pseudo_axes_frame_changed_cb (HklGuiEngine *gui_engine, HklGuiWindow *self)
684 {
685 HklEngine *engine;
686
687 g_return_if_fail (self != NULL);
688
689 g_object_get(G_OBJECT(gui_engine),
690 "engine", &engine,
691 NULL);
692
693 hkl_engine_to_axes(self, engine);
694 }
695
696 static void
697 set_up_pseudo_axes_frames (HklGuiWindow* self)
698 {
699 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
700 HklGuiEngine **pseudo;
701 GtkVBox* vbox2;
702 HklEngine **engine;
703 darray_engine *engines;
704
705 g_return_if_fail (self != NULL);
706
707 darray_foreach (pseudo, priv->pseudo_frames){
708 gtk_container_remove(GTK_CONTAINER(priv->_vbox2),
709 GTK_WIDGET (hkl_gui_engine_get_frame (*pseudo)));
710 g_object_unref(*pseudo);
711 }
712 darray_size (priv->pseudo_frames) = 0;
713
714 engines = hkl_engine_list_engines (priv->diffractometer->engines);
715 darray_foreach (engine, *engines){
716 HklGuiEngine *pseudo;
717
718 pseudo = hkl_gui_engine_new (*engine);
719 darray_append(priv->pseudo_frames, pseudo);
720 gtk_container_add (GTK_CONTAINER (priv->_vbox2),
721 GTK_WIDGET (hkl_gui_engine_get_frame(pseudo)));
722
723 g_signal_connect_object (pseudo,
724 "changed",
725 G_CALLBACK(pseudo_axes_frame_changed_cb),
726 self, 0);
727 }
728
729 gtk_widget_show_all (GTK_WIDGET (priv->_vbox2));
730 }
731
732
733 static void
734 set_up_diffractometer_model (HklGuiWindow* self)
735 {
736 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
737 unsigned int i, n;
738 HklFactory **factories;
739
740 g_return_if_fail (self != NULL);
741
742 factories = hkl_factory_get_all(&n);
743 for(i=0; i<n; ++i){
744 GtkTreeIter iter = {0};
745
746 gtk_list_store_append (priv->_liststore_diffractometer, &iter);
747 gtk_list_store_set (priv->_liststore_diffractometer,
748 &iter,
749 DIFFRACTOMETER_COL_NAME, hkl_factory_name(factories[i]),
750 DIFFRACTOMETER_COL_FACTORY, factories[i],
751 DIFFRACTOMETER_COL_DIFFRACTOMETER, NULL,
752 -1);
753 }
754 }
755
756 static void
757 set_up_tree_view_axes (HklGuiWindow* self)
758 {
759 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
760 HklParameter **parameter;
761 const darray_parameter *parameters;
762 GtkCellRenderer* renderer = NULL;
763 GtkTreeViewColumn* column = NULL;
764 GList* columns;
765
766 g_return_if_fail (self != NULL);
767
768 gtk_list_store_clear (priv->_liststore_axis);
769
770 parameters = hkl_geometry_axes_get(priv->diffractometer->geometry);
771 darray_foreach (parameter, *parameters){
772 GtkTreeIter iter = {0};
773
774 gtk_list_store_append (priv->_liststore_axis, &iter);
775 gtk_list_store_set (priv->_liststore_axis, &iter,
776 AXIS_COL_AXIS, *parameter,
777 AXIS_COL_NAME, hkl_parameter_name_get(*parameter),
778 -1);
779 }
780
781 update_axes (self);
782 }
783
784 static void
785 set_up_tree_view_pseudo_axes (HklGuiWindow* self)
786 {
787 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
788 HklParameter **parameter;
789 const darray_parameter *parameters;
790 HklEngine **engine;
791 const darray_engine *engines;
792
793 GtkCellRendererText* renderer = NULL;
794 GtkTreeViewColumn* column = NULL;
795 GList* columns;
796
797 g_return_if_fail (self != NULL);
798
799 gtk_list_store_clear(priv->_liststore_pseudo_axes);
800
801 engines = hkl_engine_list_engines(priv->diffractometer->engines);
802 darray_foreach(engine, *engines){
803 parameters = hkl_engine_pseudo_axes(*engine);
804 darray_foreach(parameter, *parameters){
805 GtkTreeIter iter = {0};
806
807 gtk_list_store_append (priv->_liststore_pseudo_axes, &iter);
808 gtk_list_store_set (priv->_liststore_pseudo_axes, &iter,
809 PSEUDO_AXIS_COL_PARAMETER, *parameter,
810 PSEUDO_AXIS_COL_ENGINE, *engine,
811 PSEUDO_AXIS_COL_NAME, hkl_parameter_name_get(*parameter),
812 -1);
813 }
814 }
815
816 update_pseudo_axes (self);
817 }
818
819 static void
820 _delete_column(gpointer data,
821 gpointer user_data)
822 {
823 gtk_tree_view_remove_column (GTK_TREE_VIEW(user_data),
824 GTK_TREE_VIEW_COLUMN(data));
825 }
826
827 static void
828 set_up_tree_view_solutions (HklGuiWindow* self)
829 {
830 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
831 const darray_parameter *parameters;
832 int i;
833 GtkCellRenderer* renderer = NULL;
834 GtkTreeViewColumn* column = NULL;
835 GList* columns;
836 GType* types;
837 gint n_columns;
838
839 g_return_if_fail (self != NULL);
840
841 parameters = hkl_geometry_axes_get(priv->diffractometer->geometry);
842
843 n_columns = SOLUTION_COL_N_COLUMNS + darray_size(*parameters);
844
845 /* prepare types for the liststore */
846 types = g_new0 (GType, n_columns);
847
848 /* first remove all the columns */
849 columns = gtk_tree_view_get_columns (priv->_treeview_solutions);
850 g_list_foreach(columns, _delete_column, priv->_treeview_solutions);
851 g_list_free(columns);
852
853 /* now add the index column */
854 renderer = gtk_cell_renderer_text_new ();
855 column = gtk_tree_view_column_new_with_attributes ("index",
856 renderer, "text",
857 SOLUTION_COL_INDEX, NULL);
858
859 gtk_tree_view_append_column (priv->_treeview_solutions, column);
860 types[0] = G_TYPE_INT;
861
862 /* add the axes column */
863 for(i=1; i<n_columns; ++i){
864 HklParameter *parameter;
865
866 parameter = darray_item(*parameters, i - SOLUTION_COL_N_COLUMNS);
867 renderer = gtk_cell_renderer_text_new ();
868 column = gtk_tree_view_column_new_with_attributes (hkl_parameter_name_get(parameter),
869 renderer, "text",
870 i, NULL);
871
872 gtk_tree_view_append_column (priv->_treeview_solutions, column);
873 types[i] = G_TYPE_DOUBLE;
874 }
875
876 if (priv->_liststore_solutions)
877 g_object_unref(priv->_liststore_solutions);
878 priv->_liststore_solutions = gtk_list_store_newv (n_columns, types);
879 g_free (types);
880
881 gtk_tree_view_set_model (priv->_treeview_solutions,
882 GTK_TREE_MODEL(priv->_liststore_solutions));
883
884 update_solutions (self);
885 }
886
887 void
888 set_up_info_bar(HklGuiWindow *self)
889 {
890 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
891 GtkWidget *content_area;
892
893 g_return_if_fail (self != NULL);
894
895 /* set up info bar until we can use glade for this purpose or
896 * switch to gtk3 */
897 if (priv->info_bar)
898 return;
899
900 priv->info_bar = GTK_INFO_BAR(gtk_info_bar_new ());
901 gtk_widget_set_no_show_all (GTK_WIDGET(priv->info_bar), TRUE);
902
903 priv->info_message = GTK_LABEL(gtk_label_new (""));
904 gtk_widget_show (GTK_WIDGET(priv->info_message));
905
906 content_area = gtk_info_bar_get_content_area (GTK_INFO_BAR (priv->info_bar));
907 gtk_container_add (GTK_CONTAINER (content_area),
908 GTK_WIDGET(priv->info_message));
909 gtk_info_bar_add_button (priv->info_bar,
910 GTK_STOCK_OK, GTK_RESPONSE_OK);
911 g_signal_connect (priv->info_bar, "response",
912 G_CALLBACK (gtk_widget_hide), NULL);
913
914 gtk_box_pack_start(GTK_BOX(priv->_box_info_bar),
915 GTK_WIDGET(priv->info_bar),
916 TRUE, TRUE, 0);
917 }
918
919 void
920 hkl_gui_window_combobox1_changed_cb(GtkComboBox *combobox, gpointer *user_data)
921 {
922 HklGuiWindow *self = HKL_GUI_WINDOW(user_data);
923 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(user_data);
924 HklFactory *factory;
925 struct diffractometer_t *dif = NULL;
926
927 GtkTreeIter iter = {0};
928
929 if(gtk_combo_box_get_active_iter (combobox, &iter)){
930 gtk_tree_model_get(GTK_TREE_MODEL(priv->_liststore_diffractometer),
931 &iter,
932 DIFFRACTOMETER_COL_FACTORY, &factory,
933 DIFFRACTOMETER_COL_DIFFRACTOMETER, &dif,
934 -1);
935
936 if (!dif){
937 dif = create_diffractometer(factory);
938 gtk_list_store_set(priv->_liststore_diffractometer,
939 &iter,
940 DIFFRACTOMETER_COL_DIFFRACTOMETER, dif,
941 -1);
942 }
943 printf("toto\n");
944 }
945 priv->diffractometer = dif;
946 /* TODO check if this is the right place for this */
947 hkl_engine_list_init(dif->engines, dif->geometry, dif->detector, priv->sample);
948
949 set_up_pseudo_axes_frames(self);
950 set_up_tree_view_axes(self);
951 //hkl_gui_window_set_up_tree_view_pseudo_axes_parameters(self);
952 set_up_tree_view_pseudo_axes(self);
953
954 /* FIXME create the right solution Model Column */
955 /* this._solutionModelColumns = 0; */
956 set_up_tree_view_solutions(self);
957 set_up_info_bar(self);
958 #if HKL3D
959 set_up_3D(self);
960 #endif
961 }
962
963
964 /* axis read cb */
965 void
966 hkl_gui_window_cellrendererspin1_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
977 g_return_if_fail (renderer != NULL);
978 g_return_if_fail (path != NULL);
979 g_return_if_fail (new_text != NULL);
980 g_return_if_fail (user_data != NULL);
981
982 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL(priv->_liststore_axis),
983 &iter,
984 path);
985 gtk_tree_model_get (GTK_TREE_MODEL(priv->_liststore_axis), &iter,
986 AXIS_COL_AXIS, &parameter,
987 -1);
988
989 value = atof(new_text); /* TODO need to check for the right conversion */
990 hkl_parameter_value_unit_set (parameter, value, NULL);
991 hkl_geometry_axis_set(priv->diffractometer->geometry,
992 parameter);
993
994 hkl_engine_list_get(priv->diffractometer->engines);
995
996 /* ok so set the model with the new value */
997 gtk_list_store_set (priv->_liststore_axis, &iter,
998 AXIS_COL_READ, value,
999 AXIS_COL_WRITE, value,
1000 -1);
1001
1002 update_pseudo_axes (self);
1003 update_pseudo_axes_frames (self);
1004 }
1005
1006
1007 /* axis min cb */
1008 void
1009 hkl_gui_window_cellrendererspin3_edited_cb(GtkCellRendererText *renderer,
1010 gchar *path,
1011 gchar *new_text,
1012 gpointer user_data)
1013 {
1014 HklGuiWindow *self = HKL_GUI_WINDOW(user_data);
1015 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(user_data);
1016 GtkTreeIter iter = {0};
1017 gdouble value = 0.0;
1018 HklParameter* parameter = NULL;
1019 gdouble shit, max;
1020
1021 g_return_if_fail (renderer != NULL);
1022 g_return_if_fail (path != NULL);
1023 g_return_if_fail (new_text != NULL);
1024 g_return_if_fail (user_data != NULL);
1025
1026 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL(priv->_liststore_axis),
1027 &iter,
1028 path);
1029 gtk_tree_model_get (GTK_TREE_MODEL(priv->_liststore_axis), &iter,
1030 AXIS_COL_AXIS, &parameter,
1031 -1);
1032
1033 value = atof(new_text); /* TODO need to check for the right conversion */
1034 hkl_parameter_min_max_unit_get (parameter, &shit, &max);
1035 hkl_parameter_min_max_unit_set (parameter, value, max);
1036
1037 gtk_list_store_set (priv->_liststore_axis, &iter,
1038 AXIS_COL_MIN, value,
1039 -1);
1040
1041 update_pseudo_axes (self);
1042 }
1043
1044
1045 /* axis max cb */
1046 void
1047 hkl_gui_window_cellrendererspin4_edited_cb(GtkCellRendererText *renderer,
1048 gchar *path,
1049 gchar *new_text,
1050 gpointer user_data)
1051 {
1052 HklGuiWindow *self = HKL_GUI_WINDOW(user_data);
1053 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(user_data);
1054 GtkTreeIter iter = {0};
1055 gdouble value = 0.0;
1056 HklParameter* parameter = NULL;
1057 gdouble shit, min;
1058
1059 g_return_if_fail (renderer != NULL);
1060 g_return_if_fail (path != NULL);
1061 g_return_if_fail (new_text != NULL);
1062 g_return_if_fail (user_data != NULL);
1063
1064 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL(priv->_liststore_axis),
1065 &iter,
1066 path);
1067 gtk_tree_model_get (GTK_TREE_MODEL(priv->_liststore_axis), &iter,
1068 AXIS_COL_AXIS, &parameter,
1069 -1);
1070
1071 value = atof(new_text); /* TODO need to check for the right conversion */
1072 hkl_parameter_min_max_unit_get (parameter, &min, &shit);
1073 hkl_parameter_min_max_unit_set (parameter, min, value);
1074
1075 gtk_list_store_set (priv->_liststore_axis, &iter,
1076 AXIS_COL_MAX, value,
1077 -1);
1078
1079 update_pseudo_axes (self);
1080 }
1081
1082
1083 /* pseudo axis write */
1084 void
1085 hkl_gui_window_cellrenderertext5_edited_cb(GtkCellRendererText *renderer,
1086 gchar *path,
1087 gchar *new_text,
1088 gpointer user_data)
1089 {
1090 HklGuiWindow *self = HKL_GUI_WINDOW(user_data);
1091 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(user_data);
1092 GtkTreeIter iter = {0};
1093 gdouble value = 0.0;
1094 gdouble old_value;
1095 HklParameter* parameter = NULL;
1096 HklEngine *engine = NULL;
1097 HklError *error = NULL;
1098
1099 g_return_if_fail (renderer != NULL);
1100 g_return_if_fail (path != NULL);
1101 g_return_if_fail (new_text != NULL);
1102 g_return_if_fail (user_data != NULL);
1103
1104 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL(priv->_liststore_pseudo_axes),
1105 &iter,
1106 path);
1107 gtk_tree_model_get (GTK_TREE_MODEL(priv->_liststore_pseudo_axes), &iter,
1108 PSEUDO_AXIS_COL_PARAMETER, &parameter,
1109 PSEUDO_AXIS_COL_ENGINE, &engine,
1110 -1);
1111
1112 value = atof(new_text); /* TODO need to check for the right conversion */
1113 old_value = hkl_parameter_value_unit_get(parameter);
1114
1115 g_assert(error != NULL || error == NULL);
1116 hkl_parameter_value_unit_set (parameter, value, &error);
1117 if(error != NULL){
1118 raise_error(self, &error);
1119 }
1120
1121 if (hkl_engine_to_axes(self, engine)){
1122 gtk_list_store_set (priv->_liststore_pseudo_axes,
1123 &iter,
1124 PSEUDO_AXIS_COL_WRITE, value,
1125 -1);
1126 }else{
1127 hkl_parameter_value_unit_set(parameter, old_value, NULL);
1128 }
1129 }
1130
1131
1132 void
1133 hkl_gui_window_treeview_solutions_cursor_changed_cb (GtkTreeView *tree_view,
1134 gpointer user_data)
1135 {
1136 HklGuiWindow* self = HKL_GUI_WINDOW(user_data);
1137 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(user_data);
1138
1139 GtkTreePath* path = NULL;
1140 GtkTreeViewColumn* focus_column = NULL;
1141 GtkTreeIter iter = {0};
1142 gsize index = 0UL;
1143
1144 g_return_if_fail (tree_view != NULL);
1145 g_return_if_fail (user_data != NULL);
1146
1147 gtk_tree_view_get_cursor (tree_view, &path, &focus_column);
1148 gtk_tree_model_get_iter (GTK_TREE_MODEL(priv->_liststore_solutions), &iter, path);
1149 gtk_tree_model_get (GTK_TREE_MODEL(priv->_liststore_solutions), &iter,
1150 SOLUTION_COL_INDEX, &index,
1151 -1);
1152
1153 hkl_engine_list_select_solution (priv->diffractometer->engines, index);
1154 hkl_engine_list_get (priv->diffractometer->engines);
1155
1156 update_axes (self);
1157 update_pseudo_axes (self);
1158 update_pseudo_axes_frames (self);
1159
1160 gtk_tree_path_free (path);
1161 }
1162
1163 /* reflection h */
1164 void
1165 hkl_gui_window_cellrenderertext7_edited_cb(GtkCellRendererText* _sender, const gchar* path,
1166 const gchar* new_text, gpointer self)
1167 {
1168 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
1169
1170 g_return_if_fail (self != NULL);
1171 g_return_if_fail (path != NULL);
1172 g_return_if_fail (new_text != NULL);
1173
1174 if (priv->sample){
1175 gdouble h = 0.0;
1176 gdouble k = 0.0;
1177 gdouble l = 0.0;
1178 HklSampleReflection* reflection = NULL;
1179 GtkTreeIter iter = {0};
1180
1181 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL(priv->_liststore_reflections),
1182 &iter, path);
1183 gtk_tree_model_get (GTK_TREE_MODEL(priv->_liststore_reflections),
1184 &iter,
1185 REFLECTION_COL_REFLECTION, &reflection,
1186 -1);
1187
1188 hkl_sample_reflection_hkl_get (reflection, &h, &k, &l);
1189 h = atof(new_text);
1190 hkl_sample_reflection_hkl_set (reflection, h, k, l);
1191 gtk_list_store_set (priv->_liststore_reflections,
1192 &iter,
1193 REFLECTION_COL_H, h,
1194 -1);
1195 }
1196 }
1197
1198 /* reflection k */
1199 void
1200 hkl_gui_window_cellrenderertext8_edited_cb (GtkCellRendererText* _sender, const gchar* path,
1201 const gchar* new_text, gpointer self)
1202 {
1203 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
1204
1205 g_return_if_fail (self != NULL);
1206 g_return_if_fail (path != NULL);
1207 g_return_if_fail (new_text != NULL);
1208
1209 if (priv->sample){
1210 gdouble h = 0.0;
1211 gdouble k = 0.0;
1212 gdouble l = 0.0;
1213 HklSampleReflection* reflection = NULL;
1214 GtkTreeIter iter = {0};
1215
1216 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL(priv->_liststore_reflections),
1217 &iter, path);
1218 gtk_tree_model_get (GTK_TREE_MODEL(priv->_liststore_reflections),
1219 &iter,
1220 REFLECTION_COL_REFLECTION, &reflection,
1221 -1);
1222
1223 hkl_sample_reflection_hkl_get (reflection, &h, &k, &l);
1224 k = atof(new_text);
1225 hkl_sample_reflection_hkl_set (reflection, h, k, l);
1226 gtk_list_store_set (priv->_liststore_reflections,
1227 &iter,
1228 REFLECTION_COL_K, k,
1229 -1);
1230 }
1231 }
1232
1233 /* reflection l */
1234 void
1235 hkl_gui_window_cellrenderertext9_edited_cb (GtkCellRendererText* _sender, const gchar* path,
1236 const gchar* new_text, gpointer self)
1237 {
1238 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
1239
1240 g_return_if_fail (self != NULL);
1241 g_return_if_fail (path != NULL);
1242 g_return_if_fail (new_text != NULL);
1243
1244 if (priv->sample){
1245 gdouble h = 0.0;
1246 gdouble k = 0.0;
1247 gdouble l = 0.0;
1248 HklSampleReflection* reflection = NULL;
1249 GtkTreeIter iter = {0};
1250
1251 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL(priv->_liststore_reflections),
1252 &iter, path);
1253 gtk_tree_model_get (GTK_TREE_MODEL(priv->_liststore_reflections),
1254 &iter,
1255 REFLECTION_COL_REFLECTION, &reflection,
1256 -1);
1257
1258 hkl_sample_reflection_hkl_get (reflection, &h, &k, &l);
1259 l = atof(new_text);
1260 hkl_sample_reflection_hkl_set (reflection, h, k, l);
1261 gtk_list_store_set (priv->_liststore_reflections,
1262 &iter,
1263 REFLECTION_COL_L, l,
1264 -1);
1265 }
1266 }
1267
1268 /* reflection flag */
1269 void
1270 hkl_gui_window_cellrenderertoggle1_toggled_cb (GtkCellRendererToggle* renderer, const gchar* path,
1271 gpointer self)
1272 {
1273 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
1274
1275 g_return_if_fail (self != NULL);
1276 g_return_if_fail (path != NULL);
1277
1278 if (priv->sample){
1279 gboolean flag;
1280 HklSampleReflection* reflection = NULL;
1281 GtkTreeIter iter = {0};
1282
1283 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL(priv->_liststore_reflections),
1284 &iter, path);
1285 gtk_tree_model_get (GTK_TREE_MODEL(priv->_liststore_reflections),
1286 &iter,
1287 REFLECTION_COL_REFLECTION, &reflection,
1288 -1);
1289
1290 flag = gtk_cell_renderer_toggle_get_active(renderer);
1291 hkl_sample_reflection_flag_set (reflection, flag);
1292 gtk_list_store_set (priv->_liststore_reflections,
1293 &iter,
1294 REFLECTION_COL_FLAG, flag,
1295 -1);
1296 }
1297 }
1298
1299 gboolean
1300 hkl_gui_window_treeview_reflections_key_press_event_cb (GtkWidget* _sender, GdkEventKey* event,
1301 gpointer self)
1302 {
1303 return TRUE;
1304 }
1305
1306 void
1307 hkl_gui_window_toolbutton_add_reflection_clicked_cb(GtkToolButton* _sender,
1308 gpointer self)
1309 {
1310 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
1311
1312 if (priv->diffractometer == NULL){
1313 gtk_statusbar_push (priv->_statusbar, 0,
1314 "Please select a diffractometer before adding reflections");
1315 return;
1316 }
1317
1318 if (priv->sample) {
1319 HklSampleReflection *reflection = NULL;
1320 GtkTreeIter iter = {0};
1321 gboolean flag;
1322 gint n_rows;
1323
1324 reflection = hkl_sample_reflection_new(priv->diffractometer->geometry,
1325 priv->diffractometer->detector,
1326 0, 0, 0);
1327 hkl_sample_add_reflection(priv->sample, reflection);
1328 flag = hkl_sample_reflection_flag_get(reflection);
1329
1330 n_rows = gtk_tree_model_iter_n_children(GTK_TREE_MODEL(priv->_liststore_reflections),
1331 NULL );
1332 gtk_list_store_insert_with_values (priv->_liststore_reflections,
1333 &iter, -1,
1334 REFLECTION_COL_INDEX, n_rows,
1335 REFLECTION_COL_H, 0.,
1336 REFLECTION_COL_K, 0.,
1337 REFLECTION_COL_L, 0.,
1338 REFLECTION_COL_FLAG, flag,
1339 REFLECTION_COL_REFLECTION, reflection,
1340 -1);
1341 }
1342 }
1343
1344 void
1345 hkl_gui_window_toolbutton_goto_reflection_clicked_cb (GtkToolButton* _sender, gpointer user_data)
1346 {
1347 HklGuiWindow *self = HKL_GUI_WINDOW(user_data);
1348 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(user_data);
1349
1350 g_return_if_fail (self != NULL);
1351
1352 if (priv->sample) {
1353 GtkTreeSelection* selection = NULL;
1354 guint nb_rows = 0U;
1355
1356 selection = gtk_tree_view_get_selection (priv->_treeview_reflections);
1357 nb_rows = gtk_tree_selection_count_selected_rows (selection);
1358
1359 if (nb_rows == 1) {
1360 HklSampleReflection *reflection;
1361 GtkTreeIter iter = {0};
1362 GtkTreeModel* model = NULL;
1363 GtkTreePath *treepath;
1364 GList* list;
1365
1366 model = GTK_TREE_MODEL(priv->_liststore_reflections);
1367
1368 list = gtk_tree_selection_get_selected_rows (selection,
1369 &model);
1370
1371 treepath = g_list_nth_data(list, 0);
1372
1373 gtk_tree_model_get_iter (GTK_TREE_MODEL(priv->_liststore_reflections),
1374 &iter, treepath);
1375
1376 gtk_tree_model_get (GTK_TREE_MODEL(priv->_liststore_reflections),
1377 &iter,
1378 REFLECTION_COL_REFLECTION, &reflection,
1379 -1);
1380
1381 hkl_geometry_set (priv->diffractometer->geometry,
1382 hkl_sample_reflection_geometry_get(reflection));
1383
1384 update_source (self);
1385
1386 update_axes (self);
1387
1388 update_pseudo_axes (self);
1389
1390 g_list_free_full (list, (GDestroyNotify) gtk_tree_path_free);
1391 } else
1392 if (nb_rows > 1)
1393 gtk_statusbar_push (priv->_statusbar, 0,
1394 "Please select only one reflection.");
1395 else
1396 gtk_statusbar_push (priv->_statusbar, 0,
1397 "Please select at least one reflection.");
1398 }
1399 }
1400
1401 static void
1402 _del_reflection(gpointer data, gpointer user_data)
1403 {
1404 HklSampleReflection *reflection;
1405 GtkTreeIter iter = {0};
1406 GtkTreePath *treepath = data;
1407 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(user_data);
1408
1409 gtk_tree_model_get_iter (GTK_TREE_MODEL(priv->_liststore_reflections),
1410 &iter, treepath);
1411
1412 gtk_tree_model_get (GTK_TREE_MODEL(priv->_liststore_reflections),
1413 &iter,
1414 REFLECTION_COL_REFLECTION, &reflection,
1415 -1);
1416 hkl_sample_del_reflection(priv->sample, reflection);
1417 }
1418
1419 void
1420 hkl_gui_window_toolbutton_del_reflection_clicked_cb (GtkToolButton* _sender, gpointer user_data)
1421 {
1422 HklGuiWindow *self = HKL_GUI_WINDOW(user_data);
1423 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(user_data);
1424 HklSample* sample = NULL;
1425
1426 g_return_if_fail (self != NULL);
1427
1428 if (priv->sample) {
1429 GtkTreeSelection* selection = NULL;
1430 guint nb_rows = 0U;
1431
1432 selection = gtk_tree_view_get_selection (priv->_treeview_reflections);
1433 nb_rows = gtk_tree_selection_count_selected_rows (selection);
1434 if (nb_rows > 0) {
1435 GtkTreeModel* model = NULL;
1436 GList* list;
1437 guint* indexes;
1438 gint i;
1439 GtkMessageDialog* dialog;
1440
1441 model = GTK_TREE_MODEL(priv->_liststore_reflections);
1442 list = gtk_tree_selection_get_selected_rows (selection, &model);
1443
1444
1445 dialog = GTK_MESSAGE_DIALOG(
1446 gtk_message_dialog_new (NULL,
1447 GTK_DIALOG_DESTROY_WITH_PARENT,
1448 GTK_MESSAGE_WARNING,
1449 GTK_BUTTONS_YES_NO,
1450 "Are you sure that you want to delete reflections"));
1451
1452 switch (gtk_dialog_run (GTK_DIALOG(dialog))) {
1453 case GTK_RESPONSE_YES:
1454 {
1455 g_list_foreach(list, _del_reflection, self);
1456 update_reflections (self);
1457 break;
1458 }
1459 default:
1460 break;
1461 }
1462 gtk_widget_destroy (GTK_WIDGET(dialog));
1463 g_list_free_full (list, (GDestroyNotify) gtk_tree_path_free);
1464 } else {
1465 gtk_statusbar_push (priv->_statusbar, 0,
1466 "Please select at least one reflection.");
1467 }
1468 }
1469 }
1470
1471 /* crystal name */
1472 void
1473 hkl_gui_window_cellrenderertext10_edited_cb(GtkCellRendererText* _sender, const gchar* path,
1474 const gchar* new_text, gpointer user_data)
1475 {
1476 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(user_data);
1477
1478 GtkTreeModel* model = NULL;
1479 GtkTreeIter iter = {0};
1480 HklSample* sample = NULL;
1481 gchar* name = NULL;
1482
1483 g_return_if_fail (user_data != NULL);
1484 g_return_if_fail (path != NULL);
1485 g_return_if_fail (new_text != NULL);
1486
1487 model = GTK_TREE_MODEL(priv->_liststore_crystals);
1488
1489 gtk_tree_model_get_iter_from_string (model, &iter, path);
1490
1491 gtk_tree_model_get (model, &iter,
1492 SAMPLE_COL_SAMPLE, &sample,
1493 -1);
1494
1495 hkl_sample_name_set (sample, new_text);
1496
1497 gtk_list_store_set(priv->_liststore_crystals, &iter,
1498 SAMPLE_COL_NAME, new_text,
1499 -1);
1500 }
1501
1502 #define set_lattice(lattice, parameter) do{ \
1503 const HklParameter *p; \
1504 gdouble min, max, value; \
1505 gboolean fit; \
1506 p = hkl_lattice_## parameter ##_get((lattice)); \
1507 value = hkl_parameter_value_unit_get(p); \
1508 hkl_parameter_min_max_unit_get(p, &min, &max); \
1509 fit = hkl_parameter_fit_get(p); \
1510 gtk_spin_button_set_value(priv->_spinbutton_## parameter, value); \
1511 gtk_spin_button_set_value(priv->_spinbutton_## parameter ##_min, min); \
1512 gtk_spin_button_set_value(priv->_spinbutton_## parameter ##_max, max); \
1513 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(priv->_checkbutton_ ## parameter), fit); \
1514 }while(0)
1515
1516 static void
1517 update_lattice (HklGuiWindow* self)
1518 {
1519 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
1520
1521 g_return_if_fail (self != NULL);
1522
1523 if (priv->sample != NULL) {
1524 const HklLattice *lattice;
1525 lattice = hkl_sample_lattice_get(priv->sample);
1526 set_lattice(lattice, a);
1527 set_lattice(lattice, b);
1528 set_lattice(lattice, c);
1529 set_lattice(lattice, alpha);
1530 set_lattice(lattice, beta);
1531 set_lattice(lattice, gamma);
1532 }
1533 }
1534
1535 #define set_reciprocal_lattice(lattice, parameter) do{ \
1536 const HklParameter *p; \
1537 gdouble value; \
1538 p = hkl_lattice_## parameter ##_get((lattice)); \
1539 value = hkl_parameter_value_unit_get(p); \
1540 gtk_spin_button_set_value(priv->_spinbutton_## parameter ##_star, value); \
1541 }while(0)
1542
1543 static void
1544 update_reciprocal_lattice (HklGuiWindow* self)
1545 {
1546 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
1547
1548 g_return_if_fail (self != NULL);
1549
1550 if (priv->sample != NULL) {
1551 hkl_lattice_reciprocal (hkl_sample_lattice_get(priv->sample),
1552 priv->reciprocal);
1553
1554 set_reciprocal_lattice(priv->reciprocal, a);
1555 set_reciprocal_lattice(priv->reciprocal, b);
1556 set_reciprocal_lattice(priv->reciprocal, c);
1557 set_reciprocal_lattice(priv->reciprocal, alpha);
1558 set_reciprocal_lattice(priv->reciprocal, beta);
1559 set_reciprocal_lattice(priv->reciprocal, gamma);
1560 }
1561 }
1562
1563 #define set_ux_uy_uz(sample, parameter) do { \
1564 const HklParameter *p; \
1565 p = hkl_sample_## parameter ##_get((sample)); \
1566 gboolean fit = hkl_parameter_fit_get(p); \
1567 gtk_spin_button_set_value(priv->_spinbutton_## parameter, \
1568 hkl_parameter_value_unit_get(p)); \
1569 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(priv->_checkbutton_## parameter), fit); \
1570 }while(0)
1571
1572 static void
1573 update_ux_uy_uz (HklGuiWindow* self)
1574 {
1575 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
1576
1577 g_return_if_fail (self != NULL);
1578
1579 if (priv->sample != NULL) {
1580 set_ux_uy_uz(priv->sample, ux);
1581 set_ux_uy_uz(priv->sample, uy);
1582 set_ux_uy_uz(priv->sample, uz);
1583 }
1584 }
1585
1586 static void
1587 update_UB (HklGuiWindow* self)
1588 {
1589 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
1590
1591 g_return_if_fail (self != NULL);
1592
1593 if (priv->sample != NULL) {
1594 const HklMatrix *UB = hkl_sample_UB_get (priv->sample);
1595 gchar *text = g_new0 (gchar, G_ASCII_DTOSTR_BUF_SIZE);
1596
1597 gtk_label_set_text(priv->_label_UB11,
1598 g_ascii_dtostr(text,
1599 G_ASCII_DTOSTR_BUF_SIZE,
1600 hkl_matrix_get(UB, 0, 0)));
1601 gtk_label_set_text(priv->_label_UB12,
1602 g_ascii_dtostr(text,
1603 G_ASCII_DTOSTR_BUF_SIZE,
1604 hkl_matrix_get(UB, 0, 1)));
1605 gtk_label_set_text(priv->_label_UB13,
1606 g_ascii_dtostr(text,
1607 G_ASCII_DTOSTR_BUF_SIZE,
1608 hkl_matrix_get(UB, 0, 2)));
1609 gtk_label_set_text(priv->_label_UB21,
1610 g_ascii_dtostr(text,
1611 G_ASCII_DTOSTR_BUF_SIZE,
1612 hkl_matrix_get(UB, 1, 0)));
1613 gtk_label_set_text(priv->_label_UB22,
1614 g_ascii_dtostr(text,
1615 G_ASCII_DTOSTR_BUF_SIZE,
1616 hkl_matrix_get(UB, 1, 1)));
1617 gtk_label_set_text(priv->_label_UB23,
1618 g_ascii_dtostr(text,
1619 G_ASCII_DTOSTR_BUF_SIZE,
1620 hkl_matrix_get(UB, 1, 2)));
1621 gtk_label_set_text(priv->_label_UB31,
1622 g_ascii_dtostr(text,
1623 G_ASCII_DTOSTR_BUF_SIZE,
1624 hkl_matrix_get(UB, 2, 0)));
1625 gtk_label_set_text(priv->_label_UB32,
1626 g_ascii_dtostr(text,
1627 G_ASCII_DTOSTR_BUF_SIZE,
1628 hkl_matrix_get(UB, 2, 1)));
1629 gtk_label_set_text(priv->_label_UB33,
1630 g_ascii_dtostr(text,
1631 G_ASCII_DTOSTR_BUF_SIZE,
1632 hkl_matrix_get(UB, 2, 2)));
1633 g_free(text);
1634 }
1635 }
1636
1637 void
1638 hkl_gui_window_treeview_crystals_cursor_changed_cb (GtkTreeView* _sender, gpointer user_data)
1639 {
1640 GtkTreePath* path = NULL;
1641 GtkTreeViewColumn* column = NULL;
1642 GtkTreeIter iter = {0};
1643
1644 HklGuiWindow *self = HKL_GUI_WINDOW(user_data);
1645 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(user_data);
1646 HklSample *sample;
1647
1648 g_return_if_fail (user_data != NULL);
1649
1650 gtk_tree_view_get_cursor (priv->_treeview_crystals, &path, &column);
1651 if(path){
1652 if (gtk_tree_model_get_iter (GTK_TREE_MODEL(priv->_liststore_crystals),
1653 &iter, path) == TRUE){
1654 gtk_tree_model_get (GTK_TREE_MODEL(priv->_liststore_crystals),
1655 &iter,
1656 SAMPLE_COL_SAMPLE, &sample,
1657 -1);
1658
1659 if(sample){
1660 priv->sample = sample;
1661 diffractometer_engine_list_init(priv->diffractometer,
1662 priv->sample);
1663 update_reflections(self);
1664 update_lattice(self);
1665 update_reciprocal_lattice (self);
1666 update_ux_uy_uz (self);
1667 update_UB (self);
1668 update_pseudo_axes (self);
1669 update_pseudo_axes_frames (self);
1670 }
1671 }
1672 gtk_tree_path_free (path);
1673 }
1674 }
1675
1676
1677
1678 static GtkTreeIter
1679 _add_sample(HklGuiWindow *self, HklSample *sample)
1680 {
1681 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
1682 GtkTreeIter iter = {0};
1683 const HklLattice *lattice;
1684 gdouble a, b, c, alpha, beta, gamma;
1685
1686 g_return_val_if_fail (self != NULL, iter);
1687
1688 lattice = hkl_sample_lattice_get(sample);
1689 a = hkl_parameter_value_unit_get(hkl_lattice_a_get(lattice));
1690 b = hkl_parameter_value_unit_get(hkl_lattice_b_get(lattice));
1691 c = hkl_parameter_value_unit_get(hkl_lattice_c_get(lattice));
1692 alpha = hkl_parameter_value_unit_get(hkl_lattice_alpha_get(lattice));
1693 beta = hkl_parameter_value_unit_get(hkl_lattice_beta_get(lattice));
1694 gamma = hkl_parameter_value_unit_get(hkl_lattice_gamma_get(lattice));
1695
1696 gtk_list_store_insert_with_values(priv->_liststore_crystals,
1697 &iter, -1,
1698 SAMPLE_COL_SAMPLE, sample,
1699 SAMPLE_COL_NAME, hkl_sample_name_get(sample),
1700 SAMPLE_COL_A, a,
1701 SAMPLE_COL_B, b,
1702 SAMPLE_COL_C, c,
1703 SAMPLE_COL_ALPHA, alpha,
1704 SAMPLE_COL_BETA, beta,
1705 SAMPLE_COL_GAMMA, gamma,
1706 -1);
1707 return iter;
1708 }
1709
1710 static void
1711 set_up_tree_view_crystals (HklGuiWindow* self)
1712 {
1713 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
1714 GtkTreeIter iter = {0};
1715 GtkTreePath *path = NULL;
1716
1717 g_return_if_fail (self != NULL);
1718
1719 iter = _add_sample(self, priv->sample);
1720
1721 path = gtk_tree_model_get_path(GTK_TREE_MODEL(priv->_liststore_crystals),
1722 &iter);
1723
1724 gtk_tree_view_set_cursor(priv->_treeview_crystals, path, NULL, FALSE);
1725
1726 gtk_tree_path_free(path);
1727 }
1728
1729 static void
1730 _add_sample_and_edit_name(HklGuiWindow *self, HklSample *sample)
1731 {
1732 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
1733 GtkTreeIter iter = {0};
1734 GtkTreePath* path = NULL;
1735 GtkTreeViewColumn* column = NULL;
1736
1737 iter = _add_sample(self, sample);
1738
1739 path = gtk_tree_model_get_path(GTK_TREE_MODEL(priv->_liststore_crystals),
1740 &iter);
1741 column = gtk_tree_view_get_column (priv->_treeview_crystals, 0);
1742 gtk_tree_view_set_cursor (priv->_treeview_crystals, path, column, TRUE);
1743
1744 gtk_tree_path_free(path);
1745 }
1746
1747 void
1748 hkl_gui_window_toolbutton_add_crystal_clicked_cb (GtkToolButton* _sender, gpointer user_data)
1749 {
1750 HklGuiWindow *self = HKL_GUI_WINDOW(user_data);
1751 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(user_data);
1752 HklSample *sample;
1753
1754 g_return_if_fail (user_data != NULL);
1755
1756 sample = hkl_sample_new ("new");
1757 if(sample)
1758 _add_sample_and_edit_name(self, sample);
1759 }
1760
1761 void
1762 hkl_gui_window_toolbutton_copy_crystal_clicked_cb (GtkToolButton* _sender, gpointer user_data)
1763 {
1764 HklGuiWindow *self = HKL_GUI_WINDOW(user_data);
1765 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(user_data);
1766 HklSample *copy = NULL;
1767
1768 g_return_if_fail (self != NULL);
1769
1770 if(priv->sample) {
1771 copy = hkl_sample_new_copy(priv->sample);
1772 if (copy)
1773 _add_sample_and_edit_name(self, copy);
1774 }else
1775 gtk_statusbar_push (priv->_statusbar, (guint) 0, "Please select a crystal to copy.");
1776 }
1777
1778 void
1779 hkl_gui_window_toolbutton_del_crystal_clicked_cb (GtkToolButton* _sender, gpointer user_data)
1780 {
1781 HklGuiWindow *self = HKL_GUI_WINDOW(user_data);
1782 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(user_data);
1783
1784 g_return_if_fail (user_data != NULL);
1785
1786 if (priv->sample != NULL) {
1787 guint n_rows;
1788
1789 n_rows = gtk_tree_model_iter_n_children(GTK_TREE_MODEL(priv->_liststore_crystals),
1790 NULL );
1791 if (n_rows == 1)
1792 return;
1793 else {
1794 GtkTreeIter iter = {0};
1795 GtkTreePath *path = NULL;
1796 GtkTreeViewColumn *column = NULL;
1797
1798 gtk_tree_view_get_cursor(priv->_treeview_crystals,
1799 &path, &column);
1800 if (path){
1801 if (gtk_tree_model_get_iter (GTK_TREE_MODEL(priv->_liststore_crystals),
1802 &iter, path) == TRUE) {
1803 gtk_tree_path_free(path);
1804
1805 hkl_sample_free(priv->sample);
1806 if (gtk_list_store_remove(priv->_liststore_crystals,
1807 &iter) == TRUE){
1808 path = gtk_tree_model_get_path(GTK_TREE_MODEL(priv->_liststore_crystals),
1809 &iter);
1810 gtk_tree_view_set_cursor(priv->_treeview_crystals,
1811 path, NULL, FALSE);
1812 }
1813 }
1814 }
1815 }
1816 }
1817 }
1818
1819 /*
1820
1821
1822 static void _hkl_gui_window_on_spinbutton_lambda_value_changed_gtk_spin_button_value_changed (GtkSpinButton* _sender, gpointer self) {
1823
1824 hkl_gui_window_on_spinbutton_lambda_value_changed (self);
1825
1826 }
1827
1828
1829 static void _hkl_gui_window_on_spinbutton_uxuyuz_value_changed_gtk_spin_button_value_changed (GtkSpinButton* _sender, gpointer self) {
1830
1831 hkl_gui_window_on_spinbutton_uxuyuz_value_changed (self);
1832
1833 }
1834
1835
1836 static void _hkl_gui_window_on_button2_clicked_gtk_button_clicked (GtkButton* _sender, gpointer self) {
1837
1838 hkl_gui_window_on_button2_clicked (self);
1839
1840 }
1841
1842
1843 static void _hkl_gui_window_on_checkbutton_a_toggled_gtk_toggle_button_toggled (GtkToggleButton* _sender, gpointer self) {
1844
1845 hkl_gui_window_on_checkbutton_a_toggled (self);
1846
1847 }
1848
1849
1850 static void _hkl_gui_window_on_checkbutton_b_toggled_gtk_toggle_button_toggled (GtkToggleButton* _sender, gpointer self) {
1851
1852 hkl_gui_window_on_checkbutton_b_toggled (self);
1853
1854 }
1855
1856
1857 static void _hkl_gui_window_on_checkbutton_c_toggled_gtk_toggle_button_toggled (GtkToggleButton* _sender, gpointer self) {
1858
1859 hkl_gui_window_on_checkbutton_c_toggled (self);
1860
1861 }
1862
1863
1864 static void _hkl_gui_window_on_checkbutton_alpha_toggled_gtk_toggle_button_toggled (GtkToggleButton* _sender, gpointer self) {
1865
1866 hkl_gui_window_on_checkbutton_alpha_toggled (self);
1867
1868 }
1869
1870
1871 static void _hkl_gui_window_on_checkbutton_beta_toggled_gtk_toggle_button_toggled (GtkToggleButton* _sender, gpointer self) {
1872
1873 hkl_gui_window_on_checkbutton_beta_toggled (self);
1874
1875 }
1876
1877
1878 static void _hkl_gui_window_on_checkbutton_gamma_toggled_gtk_toggle_button_toggled (GtkToggleButton* _sender, gpointer self) {
1879
1880 hkl_gui_window_on_checkbutton_gamma_toggled (self);
1881
1882 }
1883
1884
1885 static void _hkl_gui_window_on_checkbutton_Ux_toggled_gtk_toggle_button_toggled (GtkToggleButton* _sender, gpointer self) {
1886
1887 hkl_gui_window_on_checkbutton_Ux_toggled (self);
1888
1889 }
1890
1891
1892 static void _hkl_gui_window_on_checkbutton_Uy_toggled_gtk_toggle_button_toggled (GtkToggleButton* _sender, gpointer self) {
1893
1894 hkl_gui_window_on_checkbutton_Uy_toggled (self);
1895
1896 }
1897
1898
1899 static void _hkl_gui_window_on_checkbutton_Uz_toggled_gtk_toggle_button_toggled (GtkToggleButton* _sender, gpointer self) {
1900
1901 hkl_gui_window_on_checkbutton_Uz_toggled (self);
1902
1903 }
1904
1905
1906 static void _hkl_gui_window_on_tree_view_pseudo_axes_cursor_changed_gtk_tree_view_cursor_changed (GtkTreeView* _sender, gpointer self) {
1907
1908 hkl_gui_window_on_tree_view_pseudo_axes_cursor_changed (self);
1909
1910 }
1911
1912
1913 static gboolean _hkl_gui_window_on_tree_view_crystals_key_press_event_gtk_widget_key_press_event (GtkWidget* _sender, GdkEventKey* event, gpointer self) {
1914 gboolean result;
1915 result = hkl_gui_window_on_tree_view_crystals_key_press_event (event, self);
1916
1917 return result;
1918
1919 }
1920
1921
1922
1923
1924 static void _hkl_gui_window_on_toolbutton_setUB_clicked_gtk_tool_button_clicked (GtkToolButton* _sender, gpointer self) {
1925
1926 hkl_gui_window_on_toolbutton_setUB_clicked (self);
1927
1928 }
1929
1930
1931 static void _hkl_gui_window_on_toolbutton_computeUB_clicked_gtk_tool_button_clicked (GtkToolButton* _sender, gpointer self) {
1932
1933 hkl_gui_window_on_toolbutton_computeUB_clicked (self);
1934
1935 }
1936
1937
1938 static void _hkl_gui_window_on_toolbutton_affiner_clicked_gtk_tool_button_clicked (GtkToolButton* _sender, gpointer self) {
1939
1940 hkl_gui_window_on_toolbutton_affiner_clicked (self);
1941
1942 }
1943
1944
1945 static void _hkl_gui_window_on_menuitem5_activate_gtk_menu_item_activate (GtkMenuItem* _sender, gpointer self) {
1946
1947 hkl_gui_window_on_menuitem5_activate (self);
1948
1949 }
1950
1951
1952 static void _hkl_gui_window_on_button1_clicked_gtk_button_clicked (GtkButton* _sender, gpointer self) {
1953
1954 hkl_gui_window_on_button1_clicked (self);
1955
1956 }
1957
1958
1959 static void _hkl_gui_window_on_combobox1_changed_gtk_combo_box_changed (GtkComboBox* _sender, gpointer self) {
1960
1961 hkl_gui_window_on_combobox1_changed (self);
1962 }
1963
1964 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) {
1965
1966 hkl_gui_window_on_cell_tree_view_pseudo_axes_is_initialized_toggled (path, self);
1967
1968 }
1969
1970
1971 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) {
1972
1973 hkl_gui_window_on_cell_tree_view_pseudo_axes_parameters_value_edited (path, new_text, self);
1974
1975 }
1976
1977
1978 static void hkl_gui_window_set_up_tree_view_pseudo_axes_parameters (HklGuiWindow* self) {
1979 GtkCellRendererText* renderer = NULL;
1980 GtkTreeViewColumn* column = NULL;
1981 GtkTreeView* _tmp0_;
1982 GList* _tmp1_ = NULL;
1983 GList* columns;
1984 GList* _tmp2_;
1985 GtkCellRendererText* _tmp5_;
1986 GtkCellRendererText* _tmp6_;
1987 GtkTreeViewColumn* _tmp7_;
1988 GtkTreeView* _tmp8_;
1989 GtkTreeViewColumn* _tmp9_;
1990 GtkCellRendererText* _tmp10_;
1991 GtkCellRendererText* _tmp11_;
1992 GtkCellRendererText* _tmp12_;
1993 GtkCellRendererText* _tmp13_;
1994 GtkTreeViewColumn* _tmp14_;
1995 GtkTreeView* _tmp15_;
1996 GtkTreeViewColumn* _tmp16_;
1997
1998 g_return_if_fail (self != NULL);
1999
2000 _tmp0_ = priv->_treeview_pseudo_axes_parameters;
2001
2002 _tmp1_ = gtk_tree_view_get_columns (_tmp0_);
2003
2004 columns = _tmp1_;
2005
2006 _tmp2_ = columns;
2007
2008 {
2009 GList* col_collection = NULL;
2010 GList* col_it = NULL;
2011
2012 col_collection = _tmp2_;
2013
2014 for (col_it = col_collection; col_it != NULL; col_it = col_it->next) {
2015
2016 GtkTreeViewColumn* col = NULL;
2017
2018 col = (GtkTreeViewColumn*) col_it->data;
2019
2020 {
2021 GtkTreeView* _tmp3_;
2022 GtkTreeViewColumn* _tmp4_;
2023
2024 _tmp3_ = priv->_treeview_pseudo_axes_parameters;
2025
2026 _tmp4_ = col;
2027
2028 gtk_tree_view_remove_column (_tmp3_, _tmp4_);
2029
2030 }
2031 }
2032 }
2033
2034 _tmp5_ = (GtkCellRendererText*) gtk_cell_renderer_text_new ();
2035
2036 g_object_ref_sink (_tmp5_);
2037
2038 _g_object_unref0 (renderer);
2039
2040 renderer = _tmp5_;
2041
2042 _tmp6_ = renderer;
2043
2044 _tmp7_ = gtk_tree_view_column_new_with_attributes ("name", (GtkCellRenderer*) _tmp6_, "text", PARAMETER_COL_NAME, NULL);
2045
2046 g_object_ref_sink (_tmp7_);
2047
2048 _g_object_unref0 (column);
2049
2050 column = _tmp7_;
2051
2052 _tmp8_ = priv->_treeview_pseudo_axes_parameters;
2053
2054 _tmp9_ = column;
2055
2056 gtk_tree_view_append_column (_tmp8_, _tmp9_);
2057
2058 _tmp10_ = (GtkCellRendererText*) gtk_cell_renderer_text_new ();
2059
2060 g_object_ref_sink (_tmp10_);
2061
2062 _g_object_unref0 (renderer);
2063
2064 renderer = _tmp10_;
2065
2066 _tmp11_ = renderer;
2067
2068 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);
2069
2070 _tmp12_ = renderer;
2071
2072 g_object_set (_tmp12_, "editable", TRUE, NULL);
2073
2074 _tmp13_ = renderer;
2075
2076 _tmp14_ = gtk_tree_view_column_new_with_attributes ("read", (GtkCellRenderer*) _tmp13_, "text", PARAMETER_COL_VALUE, NULL);
2077
2078 g_object_ref_sink (_tmp14_);
2079
2080 _g_object_unref0 (column);
2081
2082 column = _tmp14_;
2083
2084 _tmp15_ = priv->_treeview_pseudo_axes_parameters;
2085
2086 _tmp16_ = column;
2087
2088 gtk_tree_view_append_column (_tmp15_, _tmp16_);
2089
2090 _g_list_free0 (columns);
2091
2092 _g_object_unref0 (column);
2093
2094 _g_object_unref0 (renderer);
2095
2096 }
2097
2098
2099 static void _hkl_gui_window_on_tree_view1_cursor_changed_gtk_tree_view_cursor_changed (GtkTreeView* _sender, gpointer self) {
2100
2101 hkl_gui_window_on_tree_view1_cursor_changed (self);
2102
2103 }
2104
2105
2106
2107
2108
2109
2110
2111 static void hkl_gui_window_set_up_3D (HklGuiWindow* self) {
2112 HklGeometry* _tmp0_;
2113 HklGeometryConfig* _tmp1_;
2114 HklGeometryType _tmp2_;
2115 GtkVBox* _tmp7_;
2116 HklGui3DFrame* _tmp8_;
2117 GtkFrame* _tmp9_ = NULL;
2118 GtkFrame* _tmp10_;
2119 GtkVBox* _tmp11_;
2120
2121 g_return_if_fail (self != NULL);
2122
2123 _tmp0_ = priv->geometry;
2124
2125 _tmp1_ = _tmp0_->config;
2126
2127 _tmp2_ = (*_tmp1_).type;
2128
2129 switch (_tmp2_) {
2130
2131 case HKL_GEOMETRY_TYPE_KAPPA6C:
2132
2133 {
2134 HklGeometry* _tmp3_;
2135 HklGui3DFrame* _tmp4_;
2136
2137 _tmp3_ = priv->geometry;
2138
2139 _tmp4_ = hkl_gui_3d_frame_new ("../data/diffabs.yaml", _tmp3_);
2140
2141 _g_object_unref0 (priv->Frame3D);
2142
2143 priv->Frame3D = _tmp4_;
2144
2145 break;
2146
2147 }
2148
2149 case HKL_GEOMETRY_TYPE_KAPPA4C_VERTICAL:
2150
2151 {
2152 HklGeometry* _tmp5_;
2153 HklGui3DFrame* _tmp6_;
2154
2155 _tmp5_ = priv->geometry;
2156
2157 _tmp6_ = hkl_gui_3d_frame_new ("../data/cristal4C.yaml", _tmp5_);
2158
2159 _g_object_unref0 (priv->Frame3D);
2160
2161 priv->Frame3D = _tmp6_;
2162
2163 break;
2164
2165 }
2166 default:
2167
2168 break;
2169
2170 }
2171
2172 _tmp7_ = priv->_vbox7;
2173
2174 _tmp8_ = priv->Frame3D;
2175
2176 _tmp9_ = hkl_gui_3d_frame_frame (_tmp8_);
2177
2178 _tmp10_ = _tmp9_;
2179
2180 gtk_box_pack_start ((GtkBox*) _tmp7_, (GtkWidget*) _tmp10_, TRUE, TRUE, (guint) 0);
2181
2182 _g_object_unref0 (_tmp10_);
2183
2184 _tmp11_ = priv->_vbox7;
2185
2186 gtk_widget_show_all ((GtkWidget*) _tmp11_);
2187
2188 }
2189
2190
2191
2192 static void hkl_gui_window_update_pseudo_axes_parameters (HklGuiWindow* self) {
2193 GeeHashMap* _tmp0_;
2194 GeeMapIterator* _tmp1_ = NULL;
2195 GeeMapIterator* iter;
2196
2197 g_return_if_fail (self != NULL);
2198
2199 _tmp0_ = priv->hash_store_pseudo_axis_parameter;
2200
2201 _tmp1_ = gee_abstract_map_map_iterator ((GeeAbstractMap*) _tmp0_);
2202
2203 iter = _tmp1_;
2204
2205 while (TRUE) {
2206
2207 GeeMapIterator* _tmp2_;
2208 gboolean _tmp3_ = FALSE;
2209 GtkListStore* model = NULL;
2210 GtkTreeIter iter2 = {0};
2211 gboolean valid = FALSE;
2212 GeeMapIterator* _tmp4_;
2213 gpointer _tmp5_ = NULL;
2214 GtkListStore* _tmp6_;
2215 GtkTreeIter _tmp7_ = {0};
2216 gboolean _tmp8_ = FALSE;
2217
2218 _tmp2_ = iter;
2219
2220 _tmp3_ = gee_map_iterator_next (_tmp2_);
2221
2222 if (!_tmp3_) {
2223
2224 break;
2225
2226 }
2227
2228 _tmp4_ = iter;
2229
2230 _tmp5_ = gee_map_iterator_get_value (_tmp4_);
2231
2232 _g_object_unref0 (model);
2233
2234 model = (GtkListStore*) _tmp5_;
2235
2236 _tmp6_ = model;
2237
2238 _tmp8_ = gtk_tree_model_get_iter_first ((GtkTreeModel*) _tmp6_, &_tmp7_);
2239
2240 iter2 = _tmp7_;
2241
2242 valid = _tmp8_;
2243
2244 while (TRUE) {
2245
2246 gboolean _tmp9_;
2247 HklParameter* parameter = NULL;
2248 GtkListStore* _tmp10_;
2249 GtkTreeIter _tmp11_;
2250 GtkListStore* _tmp12_;
2251 GtkTreeIter _tmp13_;
2252 HklParameter* _tmp14_;
2253 const gchar* _tmp15_;
2254 HklParameter* _tmp16_;
2255 HklParameter _tmp17_;
2256 gdouble _tmp18_ = 0.0;
2257 GtkListStore* _tmp19_;
2258 gboolean _tmp20_ = FALSE;
2259
2260 _tmp9_ = valid;
2261
2262 if (!_tmp9_) {
2263
2264 break;
2265
2266 }
2267
2268 _tmp10_ = model;
2269
2270 _tmp11_ = iter2;
2271
2272 gtk_tree_model_get ((GtkTreeModel*) _tmp10_, &_tmp11_, PARAMETER_COL_PARAMETER, &parameter, -1);
2273
2274 _tmp12_ = model;
2275
2276 _tmp13_ = iter2;
2277
2278 _tmp14_ = parameter;
2279
2280 _tmp15_ = (*_tmp14_).name;
2281
2282 _tmp16_ = parameter;
2283
2284 _tmp17_ = *_tmp16_;
2285
2286 _tmp18_ = hkl_parameter_get_value_unit (&_tmp17_);
2287
2288 gtk_list_store_set (_tmp12_, &_tmp13_, PARAMETER_COL_NAME, _tmp15_, PARAMETER_COL_VALUE, _tmp18_, -1);
2289
2290 _tmp19_ = model;
2291
2292 _tmp20_ = gtk_tree_model_iter_next ((GtkTreeModel*) _tmp19_, &iter2);
2293
2294 valid = _tmp20_;
2295
2296 }
2297
2298 _g_object_unref0 (model);
2299
2300 }
2301
2302 _g_object_unref0 (iter);
2303
2304 }
2305
2306
2307
2308
2309
2310
2311
2312
2313
2314
2315 static void hkl_gui_window_on_tree_view_pseudo_axes_cursor_changed (HklGuiWindow* self) {
2316 GtkTreePath* path = NULL;
2317 GtkTreeViewColumn* focus_column = NULL;
2318 GtkListStore* model = NULL;
2319 GtkTreeIter iter = {0};
2320 HklPseudoAxis* pseudoAxis = NULL;
2321 GtkTreeView* _tmp0_;
2322 GtkTreePath* _tmp1_ = NULL;
2323 GtkTreeViewColumn* _tmp2_ = NULL;
2324 GtkTreeViewColumn* _tmp3_;
2325 GtkListStore* _tmp4_;
2326 GtkTreeIter _tmp5_ = {0};
2327 GtkListStore* _tmp6_;
2328 GtkTreeIter _tmp7_;
2329 GeeHashMap* _tmp8_;
2330 gpointer _tmp9_ = NULL;
2331 GtkTreeView* _tmp10_;
2332
2333 g_return_if_fail (self != NULL);
2334
2335 _tmp0_ = priv->_treeview_pseudo_axes;
2336
2337 gtk_tree_view_get_cursor (_tmp0_, &_tmp1_, &_tmp2_);
2338
2339 _gtk_tree_path_free0 (path);
2340
2341 path = _tmp1_;
2342
2343 _g_object_unref0 (focus_column);
2344
2345 _tmp3_ = _g_object_ref0 (_tmp2_);
2346
2347 focus_column = _tmp3_;
2348
2349 _tmp4_ = priv->store_pseudo_axis;
2350
2351 gtk_tree_model_get_iter ((GtkTreeModel*) _tmp4_, &_tmp5_, path);
2352
2353 iter = _tmp5_;
2354
2355 _tmp6_ = priv->store_pseudo_axis;
2356
2357 _tmp7_ = iter;
2358
2359 gtk_tree_model_get ((GtkTreeModel*) _tmp6_, &_tmp7_, PSEUDO_AXIS_COL_PSEUDOAXIS, &pseudoAxis, -1);
2360
2361 _tmp8_ = priv->hash_store_pseudo_axis_parameter;
2362
2363 _tmp9_ = gee_abstract_map_get ((GeeAbstractMap*) _tmp8_, pseudoAxis);
2364
2365 _g_object_unref0 (model);
2366
2367 model = (GtkListStore*) _tmp9_;
2368
2369 _tmp10_ = priv->_treeview_pseudo_axes_parameters;
2370
2371 gtk_tree_view_set_model (_tmp10_, (GtkTreeModel*) model);
2372
2373 _g_object_unref0 (model);
2374
2375 _g_object_unref0 (focus_column);
2376
2377 _gtk_tree_path_free0 (path);
2378
2379 }
2380
2381 static void hkl_gui_window_on_spinbutton_lambda_value_changed (HklGuiWindow* self) {
2382 HklGeometry* _tmp0_;
2383 GtkSpinButton* _tmp1_;
2384 gdouble _tmp2_ = 0.0;
2385
2386 g_return_if_fail (self != NULL);
2387
2388 _tmp0_ = priv->geometry;
2389
2390 _tmp1_ = priv->_spinbutton_lambda;
2391
2392 _tmp2_ = gtk_spin_button_get_value (_tmp1_);
2393
2394 _tmp0_->source.wave_length = _tmp2_;
2395
2396 hkl_gui_window_update_pseudo_axes (self);
2397
2398 hkl_gui_window_update_pseudo_axes_frames (self);
2399
2400 }
2401
2402
2403 static void hkl_gui_window_on_spinbutton_uxuyuz_value_changed (HklGuiWindow* self) {
2404
2405 g_return_if_fail (self != NULL);
2406
2407 }
2408
2409
2410 static void hkl_gui_window_on_button2_clicked (HklGuiWindow* self) {
2411 HklSampleList* _tmp0_;
2412 HklSample* _tmp1_;
2413 HklSample* sample;
2414 HklSample* _tmp2_;
2415
2416 g_return_if_fail (self != NULL);
2417
2418 _tmp0_ = priv->samples;
2419
2420 _tmp1_ = _tmp0_->current;
2421
2422 sample = _tmp1_;
2423
2424 _tmp2_ = sample;
2425
2426 if (_tmp2_ != NULL) {
2427
2428 HklSample* _tmp3_;
2429 GtkSpinButton* _tmp4_;
2430 gdouble _tmp5_ = 0.0;
2431 GtkSpinButton* _tmp6_;
2432 gdouble _tmp7_ = 0.0;
2433 GtkSpinButton* _tmp8_;
2434 gdouble _tmp9_ = 0.0;
2435 GtkSpinButton* _tmp10_;
2436 gdouble _tmp11_ = 0.0;
2437 GtkSpinButton* _tmp12_;
2438 gdouble _tmp13_ = 0.0;
2439 GtkSpinButton* _tmp14_;
2440 gdouble _tmp15_ = 0.0;
2441 HklSample* _tmp16_;
2442 GtkSpinButton* _tmp17_;
2443 gdouble _tmp18_ = 0.0;
2444 GtkSpinButton* _tmp19_;
2445 gdouble _tmp20_ = 0.0;
2446 GtkSpinButton* _tmp21_;
2447 gdouble _tmp22_ = 0.0;
2448 HklSample* _tmp23_;
2449 HklLattice* _tmp24_;
2450 HklParameter* _tmp25_;
2451 GtkSpinButton* _tmp26_;
2452 gdouble _tmp27_ = 0.0;
2453 GtkSpinButton* _tmp28_;
2454 gdouble _tmp29_ = 0.0;
2455 HklParameter _tmp30_;
2456 HklSample* _tmp31_;
2457 HklLattice* _tmp32_;
2458 HklParameter* _tmp33_;
2459 GtkSpinButton* _tmp34_;
2460 gdouble _tmp35_ = 0.0;
2461 GtkSpinButton* _tmp36_;
2462 gdouble _tmp37_ = 0.0;
2463 HklParameter _tmp38_;
2464 HklSample* _tmp39_;
2465 HklLattice* _tmp40_;
2466 HklParameter* _tmp41_;
2467 GtkSpinButton* _tmp42_;
2468 gdouble _tmp43_ = 0.0;
2469 GtkSpinButton* _tmp44_;
2470 gdouble _tmp45_ = 0.0;
2471 HklParameter _tmp46_;
2472 HklSample* _tmp47_;
2473 HklLattice* _tmp48_;
2474 HklParameter* _tmp49_;
2475 GtkSpinButton* _tmp50_;
2476 gdouble _tmp51_ = 0.0;
2477 GtkSpinButton* _tmp52_;
2478 gdouble _tmp53_ = 0.0;
2479 HklParameter _tmp54_;
2480 HklSample* _tmp55_;
2481 HklLattice* _tmp56_;
2482 HklParameter* _tmp57_;
2483 GtkSpinButton* _tmp58_;
2484 gdouble _tmp59_ = 0.0;
2485 GtkSpinButton* _tmp60_;
2486 gdouble _tmp61_ = 0.0;
2487 HklParameter _tmp62_;
2488 HklSample* _tmp63_;
2489 HklLattice* _tmp64_;
2490 HklParameter* _tmp65_;
2491 GtkSpinButton* _tmp66_;
2492 gdouble _tmp67_ = 0.0;
2493 GtkSpinButton* _tmp68_;
2494 gdouble _tmp69_ = 0.0;
2495 HklParameter _tmp70_;
2496 HklSample* _tmp71_;
2497
2498 _tmp3_ = sample;
2499
2500 _tmp4_ = priv->_spinbutton_a;
2501
2502 _tmp5_ = gtk_spin_button_get_value (_tmp4_);
2503
2504 _tmp6_ = priv->_spinbutton_b;
2505
2506 _tmp7_ = gtk_spin_button_get_value (_tmp6_);
2507
2508 _tmp8_ = priv->_spinbutton_c;
2509
2510 _tmp9_ = gtk_spin_button_get_value (_tmp8_);
2511
2512 _tmp10_ = priv->_spinbutton_alpha;
2513
2514 _tmp11_ = gtk_spin_button_get_value (_tmp10_);
2515
2516 _tmp12_ = priv->_spinbutton_beta;
2517
2518 _tmp13_ = gtk_spin_button_get_value (_tmp12_);
2519
2520 _tmp14_ = priv->_spinbutton_gamma;
2521
2522 _tmp15_ = gtk_spin_button_get_value (_tmp14_);
2523
2524 hkl_sample_set_lattice (_tmp3_, _tmp5_, _tmp7_, _tmp9_, _tmp11_ * HKL_DEGTORAD, _tmp13_ * HKL_DEGTORAD, _tmp15_ * HKL_DEGTORAD);
2525
2526 _tmp16_ = sample;
2527
2528 _tmp17_ = priv->_spinbutton_ux;
2529
2530 _tmp18_ = gtk_spin_button_get_value (_tmp17_);
2531
2532 _tmp19_ = priv->_spinbutton_uy;
2533
2534 _tmp20_ = gtk_spin_button_get_value (_tmp19_);
2535
2536 _tmp21_ = priv->_spinbutton_uz;
2537
2538 _tmp22_ = gtk_spin_button_get_value (_tmp21_);
2539
2540 hkl_sample_set_U_from_euler (_tmp16_, _tmp18_ * HKL_DEGTORAD, _tmp20_ * HKL_DEGTORAD, _tmp22_ * HKL_DEGTORAD);
2541
2542 _tmp23_ = sample;
2543
2544 _tmp24_ = _tmp23_->lattice;
2545
2546 _tmp25_ = _tmp24_->a;
2547
2548 _tmp26_ = priv->_spinbutton_a_min;
2549
2550 _tmp27_ = gtk_spin_button_get_value (_tmp26_);
2551
2552 _tmp28_ = priv->_spinbutton_a_max;
2553
2554 _tmp29_ = gtk_spin_button_get_value (_tmp28_);
2555
2556 _tmp30_ = *_tmp25_;
2557
2558 hkl_parameter_set_range_unit (&_tmp30_, _tmp27_, _tmp29_);
2559
2560 _tmp31_ = sample;
2561
2562 _tmp32_ = _tmp31_->lattice;
2563
2564 _tmp33_ = _tmp32_->b;
2565
2566 _tmp34_ = priv->_spinbutton_b_min;
2567
2568 _tmp35_ = gtk_spin_button_get_value (_tmp34_);
2569
2570 _tmp36_ = priv->_spinbutton_b_max;
2571
2572 _tmp37_ = gtk_spin_button_get_value (_tmp36_);
2573
2574 _tmp38_ = *_tmp33_;
2575
2576 hkl_parameter_set_range_unit (&_tmp38_, _tmp35_, _tmp37_);
2577
2578 _tmp39_ = sample;
2579
2580 _tmp40_ = _tmp39_->lattice;
2581
2582 _tmp41_ = _tmp40_->c;
2583
2584 _tmp42_ = priv->_spinbutton_c_min;
2585
2586 _tmp43_ = gtk_spin_button_get_value (_tmp42_);
2587
2588 _tmp44_ = priv->_spinbutton_c_max;
2589
2590 _tmp45_ = gtk_spin_button_get_value (_tmp44_);
2591
2592 _tmp46_ = *_tmp41_;
2593
2594 hkl_parameter_set_range_unit (&_tmp46_, _tmp43_, _tmp45_);
2595
2596 _tmp47_ = sample;
2597
2598 _tmp48_ = _tmp47_->lattice;
2599
2600 _tmp49_ = _tmp48_->alpha;
2601
2602 _tmp50_ = priv->_spinbutton_alpha_min;
2603
2604 _tmp51_ = gtk_spin_button_get_value (_tmp50_);
2605
2606 _tmp52_ = priv->_spinbutton_alpha_max;
2607
2608 _tmp53_ = gtk_spin_button_get_value (_tmp52_);
2609
2610 _tmp54_ = *_tmp49_;
2611
2612 hkl_parameter_set_range_unit (&_tmp54_, _tmp51_, _tmp53_);
2613
2614 _tmp55_ = sample;
2615
2616 _tmp56_ = _tmp55_->lattice;
2617
2618 _tmp57_ = _tmp56_->beta;
2619
2620 _tmp58_ = priv->_spinbutton_beta_min;
2621
2622 _tmp59_ = gtk_spin_button_get_value (_tmp58_);
2623
2624 _tmp60_ = priv->_spinbutton_beta_max;
2625
2626 _tmp61_ = gtk_spin_button_get_value (_tmp60_);
2627
2628 _tmp62_ = *_tmp57_;
2629
2630 hkl_parameter_set_range_unit (&_tmp62_, _tmp59_, _tmp61_);
2631
2632 _tmp63_ = sample;
2633
2634 _tmp64_ = _tmp63_->lattice;
2635
2636 _tmp65_ = _tmp64_->gamma;
2637
2638 _tmp66_ = priv->_spinbutton_gamma_min;
2639
2640 _tmp67_ = gtk_spin_button_get_value (_tmp66_);
2641
2642 _tmp68_ = priv->_spinbutton_gamma_max;
2643
2644 _tmp69_ = gtk_spin_button_get_value (_tmp68_);
2645
2646 _tmp70_ = *_tmp65_;
2647
2648 hkl_parameter_set_range_unit (&_tmp70_, _tmp67_, _tmp69_);
2649
2650 _tmp71_ = sample;
2651
2652 hkl_gui_window_update_crystal_model (self, _tmp71_);
2653
2654 hkl_gui_window_update_reciprocal_lattice (self);
2655
2656 hkl_gui_window_update_UB (self);
2657
2658 hkl_gui_window_update_pseudo_axes (self);
2659
2660 hkl_gui_window_update_pseudo_axes_frames (self);
2661
2662 }
2663 }
2664
2665
2666 static void hkl_gui_window_on_checkbutton_a_toggled (HklGuiWindow* self) {
2667 HklSampleList* _tmp0_;
2668 HklSample* _tmp1_;
2669 HklSample* sample;
2670 HklSample* _tmp2_;
2671
2672 g_return_if_fail (self != NULL);
2673
2674 _tmp0_ = priv->samples;
2675
2676 _tmp1_ = _tmp0_->current;
2677
2678 sample = _tmp1_;
2679
2680 _tmp2_ = sample;
2681
2682 if (_tmp2_ != NULL) {
2683
2684 HklSample* _tmp3_;
2685 HklLattice* _tmp4_;
2686 HklParameter* _tmp5_;
2687 GtkCheckButton* _tmp6_;
2688 gboolean _tmp7_ = FALSE;
2689
2690 _tmp3_ = sample;
2691
2692 _tmp4_ = _tmp3_->lattice;
2693
2694 _tmp5_ = _tmp4_->a;
2695
2696 _tmp6_ = priv->_checkbutton_a;
2697
2698 _tmp7_ = gtk_toggle_button_get_active ((GtkToggleButton*) _tmp6_);
2699
2700 (*_tmp5_).fit = _tmp7_;
2701
2702 }
2703 }
2704
2705
2706 static void hkl_gui_window_on_checkbutton_b_toggled (HklGuiWindow* self) {
2707 HklSampleList* _tmp0_;
2708 HklSample* _tmp1_;
2709 HklSample* sample;
2710 HklSample* _tmp2_;
2711
2712 g_return_if_fail (self != NULL);
2713
2714 _tmp0_ = priv->samples;
2715
2716 _tmp1_ = _tmp0_->current;
2717
2718 sample = _tmp1_;
2719
2720 _tmp2_ = sample;
2721
2722 if (_tmp2_ != NULL) {
2723
2724 HklSample* _tmp3_;
2725 HklLattice* _tmp4_;
2726 HklParameter* _tmp5_;
2727 GtkCheckButton* _tmp6_;
2728 gboolean _tmp7_ = FALSE;
2729
2730 _tmp3_ = sample;
2731
2732 _tmp4_ = _tmp3_->lattice;
2733
2734 _tmp5_ = _tmp4_->b;
2735
2736 _tmp6_ = priv->_checkbutton_b;
2737
2738 _tmp7_ = gtk_toggle_button_get_active ((GtkToggleButton*) _tmp6_);
2739
2740 (*_tmp5_).fit = _tmp7_;
2741
2742 }
2743 }
2744
2745
2746 static void hkl_gui_window_on_checkbutton_c_toggled (HklGuiWindow* self) {
2747 HklSampleList* _tmp0_;
2748 HklSample* _tmp1_;
2749 HklSample* sample;
2750 HklSample* _tmp2_;
2751
2752 g_return_if_fail (self != NULL);
2753
2754 _tmp0_ = priv->samples;
2755
2756 _tmp1_ = _tmp0_->current;
2757
2758 sample = _tmp1_;
2759
2760 _tmp2_ = sample;
2761
2762 if (_tmp2_ != NULL) {
2763
2764 HklSample* _tmp3_;
2765 HklLattice* _tmp4_;
2766 HklParameter* _tmp5_;
2767 GtkCheckButton* _tmp6_;
2768 gboolean _tmp7_ = FALSE;
2769
2770 _tmp3_ = sample;
2771
2772 _tmp4_ = _tmp3_->lattice;
2773
2774 _tmp5_ = _tmp4_->c;
2775
2776 _tmp6_ = priv->_checkbutton_c;
2777
2778 _tmp7_ = gtk_toggle_button_get_active ((GtkToggleButton*) _tmp6_);
2779
2780 (*_tmp5_).fit = _tmp7_;
2781
2782 }
2783 }
2784
2785
2786 static void hkl_gui_window_on_checkbutton_alpha_toggled (HklGuiWindow* self) {
2787 HklSampleList* _tmp0_;
2788 HklSample* _tmp1_;
2789 HklSample* sample;
2790 HklSample* _tmp2_;
2791
2792 g_return_if_fail (self != NULL);
2793
2794 _tmp0_ = priv->samples;
2795
2796 _tmp1_ = _tmp0_->current;
2797
2798 sample = _tmp1_;
2799
2800 _tmp2_ = sample;
2801
2802 if (_tmp2_ != NULL) {
2803
2804 HklSample* _tmp3_;
2805 HklLattice* _tmp4_;
2806 HklParameter* _tmp5_;
2807 GtkCheckButton* _tmp6_;
2808 gboolean _tmp7_ = FALSE;
2809
2810 _tmp3_ = sample;
2811
2812 _tmp4_ = _tmp3_->lattice;
2813
2814 _tmp5_ = _tmp4_->alpha;
2815
2816 _tmp6_ = priv->_checkbutton_alpha;
2817
2818 _tmp7_ = gtk_toggle_button_get_active ((GtkToggleButton*) _tmp6_);
2819
2820 (*_tmp5_).fit = _tmp7_;
2821
2822 }
2823 }
2824
2825
2826 static void hkl_gui_window_on_checkbutton_beta_toggled (HklGuiWindow* self) {
2827 HklSampleList* _tmp0_;
2828 HklSample* _tmp1_;
2829 HklSample* sample;
2830 HklSample* _tmp2_;
2831
2832 g_return_if_fail (self != NULL);
2833
2834 _tmp0_ = priv->samples;
2835
2836 _tmp1_ = _tmp0_->current;
2837
2838 sample = _tmp1_;
2839
2840 _tmp2_ = sample;
2841
2842 if (_tmp2_ != NULL) {
2843
2844 HklSample* _tmp3_;
2845 HklLattice* _tmp4_;
2846 HklParameter* _tmp5_;
2847 GtkCheckButton* _tmp6_;
2848 gboolean _tmp7_ = FALSE;
2849
2850 _tmp3_ = sample;
2851
2852 _tmp4_ = _tmp3_->lattice;
2853
2854 _tmp5_ = _tmp4_->beta;
2855
2856 _tmp6_ = priv->_checkbutton_beta;
2857
2858 _tmp7_ = gtk_toggle_button_get_active ((GtkToggleButton*) _tmp6_);
2859
2860 (*_tmp5_).fit = _tmp7_;
2861
2862 }
2863 }
2864
2865
2866 static void hkl_gui_window_on_checkbutton_gamma_toggled (HklGuiWindow* self) {
2867 HklSampleList* _tmp0_;
2868 HklSample* _tmp1_;
2869 HklSample* sample;
2870 HklSample* _tmp2_;
2871
2872 g_return_if_fail (self != NULL);
2873
2874 _tmp0_ = priv->samples;
2875
2876 _tmp1_ = _tmp0_->current;
2877
2878 sample = _tmp1_;
2879
2880 _tmp2_ = sample;
2881
2882 if (_tmp2_ != NULL) {
2883
2884 HklSample* _tmp3_;
2885 HklLattice* _tmp4_;
2886 HklParameter* _tmp5_;
2887 GtkCheckButton* _tmp6_;
2888 gboolean _tmp7_ = FALSE;
2889
2890 _tmp3_ = sample;
2891
2892 _tmp4_ = _tmp3_->lattice;
2893
2894 _tmp5_ = _tmp4_->gamma;
2895
2896 _tmp6_ = priv->_checkbutton_gamma;
2897
2898 _tmp7_ = gtk_toggle_button_get_active ((GtkToggleButton*) _tmp6_);
2899
2900 (*_tmp5_).fit = _tmp7_;
2901
2902 }
2903 }
2904
2905
2906 static void hkl_gui_window_on_checkbutton_Ux_toggled (HklGuiWindow* self) {
2907 HklSampleList* _tmp0_;
2908 HklSample* _tmp1_;
2909 HklSample* sample;
2910 HklSample* _tmp2_;
2911
2912 g_return_if_fail (self != NULL);
2913
2914 _tmp0_ = priv->samples;
2915
2916 _tmp1_ = _tmp0_->current;
2917
2918 sample = _tmp1_;
2919
2920 _tmp2_ = sample;
2921
2922 if (_tmp2_ != NULL) {
2923
2924 HklSample* _tmp3_;
2925 HklParameter* _tmp4_;
2926 GtkCheckButton* _tmp5_;
2927 gboolean _tmp6_ = FALSE;
2928
2929 _tmp3_ = sample;
2930
2931 _tmp4_ = _tmp3_->ux;
2932
2933 _tmp5_ = priv->_checkbutton_Ux;
2934
2935 _tmp6_ = gtk_toggle_button_get_active ((GtkToggleButton*) _tmp5_);
2936
2937 (*_tmp4_).fit = _tmp6_;
2938
2939 }
2940 }
2941
2942
2943 static void hkl_gui_window_on_checkbutton_Uy_toggled (HklGuiWindow* self) {
2944 HklSampleList* _tmp0_;
2945 HklSample* _tmp1_;
2946 HklSample* sample;
2947 HklSample* _tmp2_;
2948
2949 g_return_if_fail (self != NULL);
2950
2951 _tmp0_ = priv->samples;
2952
2953 _tmp1_ = _tmp0_->current;
2954
2955 sample = _tmp1_;
2956
2957 _tmp2_ = sample;
2958
2959 if (_tmp2_ != NULL) {
2960
2961 HklSample* _tmp3_;
2962 HklParameter* _tmp4_;
2963 GtkCheckButton* _tmp5_;
2964 gboolean _tmp6_ = FALSE;
2965
2966 _tmp3_ = sample;
2967
2968 _tmp4_ = _tmp3_->uy;
2969
2970 _tmp5_ = priv->_checkbutton_Uy;
2971
2972 _tmp6_ = gtk_toggle_button_get_active ((GtkToggleButton*) _tmp5_);
2973
2974 (*_tmp4_).fit = _tmp6_;
2975
2976 }
2977 }
2978
2979
2980 static void hkl_gui_window_on_checkbutton_Uz_toggled (HklGuiWindow* self) {
2981 HklSampleList* _tmp0_;
2982 HklSample* _tmp1_;
2983 HklSample* sample;
2984 HklSample* _tmp2_;
2985
2986 g_return_if_fail (self != NULL);
2987
2988 _tmp0_ = priv->samples;
2989
2990 _tmp1_ = _tmp0_->current;
2991
2992 sample = _tmp1_;
2993
2994 _tmp2_ = sample;
2995
2996 if (_tmp2_ != NULL) {
2997
2998 HklSample* _tmp3_;
2999 HklParameter* _tmp4_;
3000 GtkCheckButton* _tmp5_;
3001 gboolean _tmp6_ = FALSE;
3002
3003 _tmp3_ = sample;
3004
3005 _tmp4_ = _tmp3_->uz;
3006
3007 _tmp5_ = priv->_checkbutton_Uz;
3008
3009 _tmp6_ = gtk_toggle_button_get_active ((GtkToggleButton*) _tmp5_);
3010
3011 (*_tmp4_).fit = _tmp6_;
3012
3013 }
3014 }
3015
3016 static void hkl_gui_window_on_cell_tree_view_pseudo_axes_is_initialized_toggled (const gchar* path, HklGuiWindow* self) {
3017 GtkTreeModel* model = NULL;
3018 GtkTreeIter iter = {0};
3019 HklPseudoAxis* pseudoAxis = NULL;
3020 gboolean old_flag = FALSE;
3021 GtkTreeView* _tmp0_;
3022 GtkTreeModel* _tmp1_ = NULL;
3023 GtkTreeModel* _tmp2_;
3024 GtkTreeModel* _tmp3_;
3025 const gchar* _tmp4_;
3026 GtkTreeIter _tmp5_ = {0};
3027 GtkTreeModel* _tmp6_;
3028 GtkTreeIter _tmp7_;
3029 gboolean _tmp8_;
3030
3031 g_return_if_fail (self != NULL);
3032
3033 g_return_if_fail (path != NULL);
3034
3035 _tmp0_ = priv->_treeview_pseudo_axes;
3036
3037 _tmp1_ = gtk_tree_view_get_model (_tmp0_);
3038
3039 _tmp2_ = _g_object_ref0 (_tmp1_);
3040
3041 _g_object_unref0 (model);
3042
3043 model = _tmp2_;
3044
3045 _tmp3_ = model;
3046
3047 _tmp4_ = path;
3048
3049 gtk_tree_model_get_iter_from_string (_tmp3_, &_tmp5_, _tmp4_);
3050
3051 iter = _tmp5_;
3052
3053 _tmp6_ = model;
3054
3055 _tmp7_ = iter;
3056
3057 gtk_tree_model_get (_tmp6_, &_tmp7_, PSEUDO_AXIS_COL_PSEUDOAXIS, &pseudoAxis, PSEUDO_AXIS_COL_INITIALIZED, &old_flag, -1);
3058
3059 _tmp8_ = old_flag;
3060
3061 if (!_tmp8_) {
3062
3063 HklPseudoAxis* _tmp9_;
3064 HklPseudoAxisEngine* _tmp10_;
3065 gboolean _tmp11_ = FALSE;
3066
3067 _tmp9_ = pseudoAxis;
3068
3069 _tmp10_ = _tmp9_->engine;
3070
3071 _tmp11_ = hkl_pseudo_axis_engine_initialize (_tmp10_, NULL);
3072
3073 if (_tmp11_) {
3074
3075 hkl_gui_window_update_pseudo_axes (self);
3076
3077 }
3078 }
3079
3080 _g_object_unref0 (model);
3081
3082 }
3083
3084
3085 static void hkl_gui_window_on_cell_tree_view_pseudo_axes_parameters_value_edited (const gchar* path, const gchar* new_text, HklGuiWindow* self) {
3086 GtkListStore* model = NULL;
3087 GtkTreeIter iter = {0};
3088 gdouble value = 0.0;
3089 HklParameter* parameter;
3090 GtkTreeView* _tmp0_;
3091 GtkTreeModel* _tmp1_ = NULL;
3092 GtkListStore* _tmp2_;
3093 const gchar* _tmp3_;
3094 GtkTreeIter _tmp4_ = {0};
3095 GtkTreeIter _tmp5_;
3096 const gchar* _tmp6_;
3097 gdouble _tmp7_ = 0.0;
3098 HklParameter _tmp8_;
3099 GtkTreeIter _tmp9_;
3100
3101 g_return_if_fail (self != NULL);
3102
3103 g_return_if_fail (path != NULL);
3104
3105 g_return_if_fail (new_text != NULL);
3106
3107 parameter = NULL;
3108
3109 _tmp0_ = priv->_treeview_pseudo_axes_parameters;
3110
3111 _tmp1_ = gtk_tree_view_get_model (_tmp0_);
3112
3113 _tmp2_ = _g_object_ref0 (G_TYPE_CHECK_INSTANCE_TYPE (_tmp1_, GTK_TYPE_LIST_STORE) ? ((GtkListStore*) _tmp1_) : NULL);
3114
3115 _g_object_unref0 (model);
3116
3117 model = _tmp2_;
3118
3119 _tmp3_ = path;
3120
3121 gtk_tree_model_get_iter_from_string ((GtkTreeModel*) model, &_tmp4_, _tmp3_);
3122
3123 iter = _tmp4_;
3124
3125 _tmp5_ = iter;
3126
3127 gtk_tree_model_get ((GtkTreeModel*) model, &_tmp5_, PARAMETER_COL_PARAMETER, parameter, -1);
3128
3129 _tmp6_ = new_text;
3130
3131 _tmp7_ = double_parse (_tmp6_);
3132
3133 value = _tmp7_;
3134
3135 _tmp8_ = *parameter;
3136
3137 hkl_parameter_set_value_unit (&_tmp8_, value);
3138
3139 _tmp9_ = iter;
3140
3141 gtk_list_store_set (model, &_tmp9_, PARAMETER_COL_VALUE, value, -1);
3142
3143 hkl_gui_window_update_pseudo_axes (self);
3144
3145 hkl_gui_window_update_pseudo_axes_parameters (self);
3146
3147 _g_object_unref0 (model);
3148
3149 }
3150
3151
3152
3153
3154
3155
3156
3157
3158 static void _gtk_tree_path_free0_ (gpointer var) {
3159
3160 (var == NULL) ? NULL : (var = (gtk_tree_path_free (var), NULL));
3161
3162 }
3163
3164
3165 static void _g_list_free__gtk_tree_path_free0_ (GList* self) {
3166
3167 g_list_foreach (self, (GFunc) _gtk_tree_path_free0_, NULL);
3168
3169 g_list_free (self);
3170
3171 }
3172
3173
3174
3175
3176 static gpointer _gtk_tree_path_copy0 (gpointer self) {
3177
3178 return self ? gtk_tree_path_copy (self) : NULL;
3179
3180 }
3181
3182
3183
3184
3185 static void hkl_gui_window_on_toolbutton_setUB_clicked (HklGuiWindow* self) {
3186 HklSampleList* _tmp0_;
3187 HklSample* _tmp1_;
3188
3189 g_return_if_fail (self != NULL);
3190
3191 _tmp0_ = priv->samples;
3192
3193 _tmp1_ = _tmp0_->current;
3194
3195 if (_tmp1_ != NULL) {
3196
3197 HklMatrix UB = {0};
3198 HklSampleList* _tmp2_;
3199 HklSample* _tmp3_;
3200 HklMatrix _tmp4_ = {0};
3201 HklMatrix _tmp5_;
3202 gdouble** _tmp6_;
3203 gint _tmp6__length1;
3204 gdouble* _tmp7_;
3205 gint _tmp7__length1;
3206 GtkSpinButton* _tmp8_;
3207 gdouble _tmp9_ = 0.0;
3208 gdouble _tmp10_;
3209 HklMatrix _tmp11_;
3210 gdouble** _tmp12_;
3211 gint _tmp12__length1;
3212 gdouble* _tmp13_;
3213 gint _tmp13__length1;
3214 GtkSpinButton* _tmp14_;
3215 gdouble _tmp15_ = 0.0;
3216 gdouble _tmp16_;
3217 HklMatrix _tmp17_;
3218 gdouble** _tmp18_;
3219 gint _tmp18__length1;
3220 gdouble* _tmp19_;
3221 gint _tmp19__length1;
3222 GtkSpinButton* _tmp20_;
3223 gdouble _tmp21_ = 0.0;
3224 gdouble _tmp22_;
3225 HklMatrix _tmp23_;
3226 gdouble** _tmp24_;
3227 gint _tmp24__length1;
3228 gdouble* _tmp25_;
3229 gint _tmp25__length1;
3230 GtkSpinButton* _tmp26_;
3231 gdouble _tmp27_ = 0.0;
3232 gdouble _tmp28_;
3233 HklMatrix _tmp29_;
3234 gdouble** _tmp30_;
3235 gint _tmp30__length1;
3236 gdouble* _tmp31_;
3237 gint _tmp31__length1;
3238 GtkSpinButton* _tmp32_;
3239 gdouble _tmp33_ = 0.0;
3240 gdouble _tmp34_;
3241 HklMatrix _tmp35_;
3242 gdouble** _tmp36_;
3243 gint _tmp36__length1;
3244 gdouble* _tmp37_;
3245 gint _tmp37__length1;
3246 GtkSpinButton* _tmp38_;
3247 gdouble _tmp39_ = 0.0;
3248 gdouble _tmp40_;
3249 HklMatrix _tmp41_;
3250 gdouble** _tmp42_;
3251 gint _tmp42__length1;
3252 gdouble* _tmp43_;
3253 gint _tmp43__length1;
3254 GtkSpinButton* _tmp44_;
3255 gdouble _tmp45_ = 0.0;
3256 gdouble _tmp46_;
3257 HklMatrix _tmp47_;
3258 gdouble** _tmp48_;
3259 gint _tmp48__length1;
3260 gdouble* _tmp49_;
3261 gint _tmp49__length1;
3262 GtkSpinButton* _tmp50_;
3263 gdouble _tmp51_ = 0.0;
3264 gdouble _tmp52_;
3265 HklMatrix _tmp53_;
3266 gdouble** _tmp54_;
3267 gint _tmp54__length1;
3268 gdouble* _tmp55_;
3269 gint _tmp55__length1;
3270 GtkSpinButton* _tmp56_;
3271 gdouble _tmp57_ = 0.0;
3272 gdouble _tmp58_;
3273 HklSampleList* _tmp59_;
3274 HklSample* _tmp60_;
3275 HklSampleList* _tmp61_;
3276 HklSample* _tmp62_;
3277 FILE* _tmp63_;
3278 HklSampleList* _tmp64_;
3279 HklSample* _tmp65_;
3280
3281 _tmp2_ = priv->samples;
3282
3283 _tmp3_ = _tmp2_->current;
3284
3285 hkl_sample_get_UB (_tmp3_, &_tmp4_);
3286
3287 (&UB);
3288
3289 UB = _tmp4_;
3290
3291 _tmp5_ = UB;
3292
3293 _tmp6_ = _tmp5_.data;
3294
3295 _tmp6__length1 = -1;
3296
3297 _tmp7_ = _tmp6_[0];
3298
3299 _tmp7__length1 = -1;
3300
3301 _tmp8_ = priv->_spinbutton_U11;
3302
3303 _tmp9_ = gtk_spin_button_get_value (_tmp8_);
3304
3305 _tmp7_[0] = _tmp9_;
3306
3307 _tmp10_ = _tmp7_[0];
3308
3309 _tmp11_ = UB;
3310
3311 _tmp12_ = _tmp11_.data;
3312
3313 _tmp12__length1 = -1;
3314
3315 _tmp13_ = _tmp12_[0];
3316
3317 _tmp13__length1 = -1;
3318
3319 _tmp14_ = priv->_spinbutton_U12;
3320
3321 _tmp15_ = gtk_spin_button_get_value (_tmp14_);
3322
3323 _tmp13_[1] = _tmp15_;
3324
3325 _tmp16_ = _tmp13_[1];
3326
3327 _tmp17_ = UB;
3328
3329 _tmp18_ = _tmp17_.data;
3330
3331 _tmp18__length1 = -1;
3332
3333 _tmp19_ = _tmp18_[0];
3334
3335 _tmp19__length1 = -1;
3336
3337 _tmp20_ = priv->_spinbutton_U13;
3338
3339 _tmp21_ = gtk_spin_button_get_value (_tmp20_);
3340
3341 _tmp19_[2] = _tmp21_;
3342
3343 _tmp22_ = _tmp19_[2];
3344
3345 _tmp23_ = UB;
3346
3347 _tmp24_ = _tmp23_.data;
3348
3349 _tmp24__length1 = -1;
3350
3351 _tmp25_ = _tmp24_[1];
3352
3353 _tmp25__length1 = -1;
3354
3355 _tmp26_ = priv->_spinbutton_U21;
3356
3357 _tmp27_ = gtk_spin_button_get_value (_tmp26_);
3358
3359 _tmp25_[0] = _tmp27_;
3360
3361 _tmp28_ = _tmp25_[0];
3362
3363 _tmp29_ = UB;
3364
3365 _tmp30_ = _tmp29_.data;
3366
3367 _tmp30__length1 = -1;
3368
3369 _tmp31_ = _tmp30_[1];
3370
3371 _tmp31__length1 = -1;
3372
3373 _tmp32_ = priv->_spinbutton_U22;
3374
3375 _tmp33_ = gtk_spin_button_get_value (_tmp32_);
3376
3377 _tmp31_[1] = _tmp33_;
3378
3379 _tmp34_ = _tmp31_[1];
3380
3381 _tmp35_ = UB;
3382
3383 _tmp36_ = _tmp35_.data;
3384
3385 _tmp36__length1 = -1;
3386
3387 _tmp37_ = _tmp36_[1];
3388
3389 _tmp37__length1 = -1;
3390
3391 _tmp38_ = priv->_spinbutton_U23;
3392
3393 _tmp39_ = gtk_spin_button_get_value (_tmp38_);
3394
3395 _tmp37_[2] = _tmp39_;
3396
3397 _tmp40_ = _tmp37_[2];
3398
3399 _tmp41_ = UB;
3400
3401 _tmp42_ = _tmp41_.data;
3402
3403 _tmp42__length1 = -1;
3404
3405 _tmp43_ = _tmp42_[2];
3406
3407 _tmp43__length1 = -1;
3408
3409 _tmp44_ = priv->_spinbutton_U31;
3410
3411 _tmp45_ = gtk_spin_button_get_value (_tmp44_);
3412
3413 _tmp43_[0] = _tmp45_;
3414
3415 _tmp46_ = _tmp43_[0];
3416
3417 _tmp47_ = UB;
3418
3419 _tmp48_ = _tmp47_.data;
3420
3421 _tmp48__length1 = -1;
3422
3423 _tmp49_ = _tmp48_[2];
3424
3425 _tmp49__length1 = -1;
3426
3427 _tmp50_ = priv->_spinbutton_U32;
3428
3429 _tmp51_ = gtk_spin_button_get_value (_tmp50_);
3430
3431 _tmp49_[1] = _tmp51_;
3432
3433 _tmp52_ = _tmp49_[1];
3434
3435 _tmp53_ = UB;
3436
3437 _tmp54_ = _tmp53_.data;
3438
3439 _tmp54__length1 = -1;
3440
3441 _tmp55_ = _tmp54_[2];
3442
3443 _tmp55__length1 = -1;
3444
3445 _tmp56_ = priv->_spinbutton_U33;
3446
3447 _tmp57_ = gtk_spin_button_get_value (_tmp56_);
3448
3449 _tmp55_[2] = _tmp57_;
3450
3451 _tmp58_ = _tmp55_[2];
3452
3453 _tmp59_ = priv->samples;
3454
3455 _tmp60_ = _tmp59_->current;
3456
3457 hkl_sample_set_UB (_tmp60_, &UB);
3458
3459 _tmp61_ = priv->samples;
3460
3461 _tmp62_ = _tmp61_->current;
3462
3463 _tmp63_ = stdout;
3464
3465 hkl_sample_fprintf (_tmp63_, _tmp62_);
3466
3467 hkl_gui_window_update_lattice (self);
3468
3469 hkl_gui_window_update_lattice_parameters (self);
3470
3471 hkl_gui_window_update_reciprocal_lattice (self);
3472
3473 _tmp64_ = priv->samples;
3474
3475 _tmp65_ = _tmp64_->current;
3476
3477 hkl_gui_window_update_crystal_model (self, _tmp65_);
3478
3479 hkl_gui_window_update_UB (self);
3480
3481 hkl_gui_window_update_UxUyUz (self);
3482
3483 hkl_gui_window_update_pseudo_axes (self);
3484
3485 hkl_gui_window_update_pseudo_axes_frames (self);
3486
3487 (&UB);
3488
3489 }
3490 }
3491
3492
3493 static void hkl_gui_window_on_toolbutton_computeUB_clicked (HklGuiWindow* self) {
3494 HklSampleList* _tmp0_;
3495 HklSample* _tmp1_;
3496 HklSample* sample;
3497 HklSample* _tmp2_;
3498
3499 g_return_if_fail (self != NULL);
3500
3501 _tmp0_ = priv->samples;
3502
3503 _tmp1_ = _tmp0_->current;
3504
3505 sample = _tmp1_;
3506
3507 _tmp2_ = sample;
3508
3509 if (_tmp2_ != NULL) {
3510
3511 HklSample* _tmp3_;
3512
3513 _tmp3_ = sample;
3514
3515 hkl_sample_compute_UB_busing_levy (_tmp3_, (gsize) 0, (gsize) 1);
3516
3517 hkl_gui_window_update_UB (self);
3518
3519 hkl_gui_window_update_UxUyUz (self);
3520
3521 hkl_gui_window_update_pseudo_axes (self);
3522
3523 hkl_gui_window_update_pseudo_axes_frames (self);
3524
3525 }
3526 }
3527
3528
3529 static void hkl_gui_window_on_toolbutton_affiner_clicked (HklGuiWindow* self) {
3530 HklSampleList* _tmp0_;
3531 HklSample* _tmp1_;
3532 HklSample* sample;
3533 HklSample* _tmp2_;
3534 HklSample* _tmp4_;
3535
3536 g_return_if_fail (self != NULL);
3537
3538 _tmp0_ = priv->samples;
3539
3540 _tmp1_ = _tmp0_->current;
3541
3542 sample = _tmp1_;
3543
3544 _tmp2_ = sample;
3545
3546 if (_tmp2_ != NULL) {
3547
3548 HklSample* _tmp3_;
3549
3550 _tmp3_ = sample;
3551
3552 hkl_sample_affine (_tmp3_);
3553
3554 }
3555
3556 _tmp4_ = sample;
3557
3558 hkl_gui_window_update_crystal_model (self, _tmp4_);
3559
3560 hkl_gui_window_update_lattice (self);
3561
3562 hkl_gui_window_update_reciprocal_lattice (self);
3563
3564 hkl_gui_window_update_UB (self);
3565
3566 hkl_gui_window_update_UxUyUz (self);
3567
3568 }
3569
3570
3571
3572
3573 static gboolean hkl_gui_window_on_tree_view_crystals_key_press_event (GdkEventKey* event, HklGuiWindow* self) {
3574 gboolean result = FALSE;
3575
3576 g_return_val_if_fail (self != NULL, FALSE);
3577
3578 g_return_val_if_fail (event != NULL, FALSE);
3579
3580 result = TRUE;
3581
3582 return result;
3583
3584 }
3585
3586
3587 static void hkl_gui_window_on_menuitem5_activate (HklGuiWindow* self) {
3588 GtkDialog* _tmp0_;
3589
3590 g_return_if_fail (self != NULL);
3591
3592 _tmp0_ = priv->_dialog1;
3593
3594 gtk_widget_show ((GtkWidget*) _tmp0_);
3595
3596 }
3597
3598
3599 void hkl_gui_window_on_button1_clicked (HklGuiWindow* self) {
3600 GtkDialog* _tmp0_;
3601
3602 g_return_if_fail (self != NULL);
3603
3604 _tmp0_ = priv->_dialog1;
3605
3606 gtk_widget_hide ((GtkWidget*) _tmp0_);
3607
3608 }
3609
3610 */
3611
3612 static void
3613 hkl_gui_window_class_init (HklGuiWindowClass *class)
3614 {
3615 GObjectClass *gobject_class = G_OBJECT_CLASS (class);
3616
3617 g_type_class_add_private (class, sizeof (HklGuiWindowPrivate));
3618
3619 /* virtual method */
3620 gobject_class->finalize = finalize;
3621 }
3622
3623
3624 static void hkl_gui_window_init (HklGuiWindow * self)
3625 {
3626 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
3627
3628 priv->diffractometer = NULL;
3629
3630 darray_init(priv->pseudo_frames);
3631
3632 priv->sample = hkl_sample_new ("test");
3633 priv->reciprocal = hkl_lattice_new_default ();
3634
3635 hkl_gui_window_get_widgets_and_objects_from_ui (self);
3636
3637 set_up_diffractometer_model (self);
3638
3639 set_up_tree_view_crystals (self);
3640
3641 //hkl_gui_window_update_source (self);
3642 }
3643
3644 int main (int argc, char ** argv)
3645 {
3646 gtk_init (&argc, &argv);
3647
3648 hkl_gui_window_new ();
3649
3650 gtk_main ();
3651
3652 return 0;
3653 }
Diffractometer computation library