?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
implemente the checkbutton toggled
[hkl.git] / gui / hkl-gui.c
blob2cba5ac6d223e1420088368db766524db856a5a6
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-2014 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_set_sample(struct diffractometer_t *self,
152 HklSample *sample)
153 {
154 hkl_engine_list_init(self->engines,
155 self->geometry,
156 self->detector,
157 sample);
158 hkl_engine_list_get(self->engines);
159 }
160
161 static void
162 diffractometer_set_wavelength(struct diffractometer_t *self,
163 double wavelength)
164 {
165 hkl_geometry_wavelength_set(self->geometry,
166 wavelength);
167 hkl_engine_list_get(self->engines);
168 }
169
170 /****************/
171 /* HklGuiWindow */
172 /****************/
173
174 struct _HklGuiWindowPrivate {
175 GtkBuilder* builder;
176 GtkLabel* _label_UB11;
177 GtkLabel* _label_UB12;
178 GtkLabel* _label_UB13;
179 GtkLabel* _label_UB21;
180 GtkLabel* _label_UB22;
181 GtkLabel* _label_UB23;
182 GtkLabel* _label_UB31;
183 GtkLabel* _label_UB32;
184 GtkLabel* _label_UB33;
185 GtkButton* _button2;
186 GtkSpinButton* _spinbutton_a;
187 GtkSpinButton* _spinbutton_b;
188 GtkSpinButton* _spinbutton_c;
189 GtkSpinButton* _spinbutton_alpha;
190 GtkSpinButton* _spinbutton_beta;
191 GtkSpinButton* _spinbutton_gamma;
192 GtkSpinButton* _spinbutton_a_min;
193 GtkSpinButton* _spinbutton_b_min;
194 GtkSpinButton* _spinbutton_c_min;
195 GtkSpinButton* _spinbutton_alpha_min;
196 GtkSpinButton* _spinbutton_beta_min;
197 GtkSpinButton* _spinbutton_gamma_min;
198 GtkSpinButton* _spinbutton_a_max;
199 GtkSpinButton* _spinbutton_b_max;
200 GtkSpinButton* _spinbutton_c_max;
201 GtkSpinButton* _spinbutton_alpha_max;
202 GtkSpinButton* _spinbutton_beta_max;
203 GtkSpinButton* _spinbutton_gamma_max;
204 GtkSpinButton* _spinbutton_lambda;
205 GtkSpinButton* _spinbutton_a_star;
206 GtkSpinButton* _spinbutton_b_star;
207 GtkSpinButton* _spinbutton_c_star;
208 GtkSpinButton* _spinbutton_alpha_star;
209 GtkSpinButton* _spinbutton_beta_star;
210 GtkSpinButton* _spinbutton_gamma_star;
211 GtkSpinButton* _spinbutton_ux;
212 GtkSpinButton* _spinbutton_uy;
213 GtkSpinButton* _spinbutton_uz;
214 GtkSpinButton* _spinbutton_U11;
215 GtkSpinButton* _spinbutton_U12;
216 GtkSpinButton* _spinbutton_U13;
217 GtkSpinButton* _spinbutton_U21;
218 GtkSpinButton* _spinbutton_U22;
219 GtkSpinButton* _spinbutton_U23;
220 GtkSpinButton* _spinbutton_U31;
221 GtkSpinButton* _spinbutton_U32;
222 GtkSpinButton* _spinbutton_U33;
223 GtkCheckButton* _checkbutton_a;
224 GtkCheckButton* _checkbutton_b;
225 GtkCheckButton* _checkbutton_c;
226 GtkCheckButton* _checkbutton_alpha;
227 GtkCheckButton* _checkbutton_beta;
228 GtkCheckButton* _checkbutton_gamma;
229 GtkCheckButton* _checkbutton_ux;
230 GtkCheckButton* _checkbutton_uy;
231 GtkCheckButton* _checkbutton_uz;
232 GtkTreeView* _treeview_reflections;
233 GtkTreeView* _treeview_crystals;
234 GtkTreeView* _treeview_axes;
235 GtkTreeView* _treeview_pseudo_axes;
236 GtkTreeView* _treeview_solutions;
237 GtkToolButton* _toolbutton_add_reflection;
238 GtkToolButton* _toolbutton_goto_reflection;
239 GtkToolButton* _toolbutton_del_reflection;
240 GtkToolButton* _toolbutton_setUB;
241 GtkToolButton* _toolbutton_computeUB;
242 GtkToolButton* _toolbutton_add_crystal;
243 GtkToolButton* _toolbutton_copy_crystal;
244 GtkToolButton* _toolbutton_del_crystal;
245 GtkToolButton* _toolbutton_affiner;
246 GtkStatusbar* _statusbar;
247 GtkImageMenuItem* _menuitem5;
248 GtkVBox* _box_info_bar; /* fake for the infor bar */
249 GtkVBox* _vbox7;
250 GtkVBox* _vbox2;
251 GtkDialog* _dialog1;
252 GtkButton* _button1;
253 GtkComboBox* _combobox1;
254 GtkListStore* _liststore_diffractometer;
255 GtkListStore* _liststore_axis;
256 GtkListStore* _liststore_pseudo_axes;
257 GtkListStore* _liststore_solutions;
258 GtkListStore* _liststore_reflections;
259 GtkListStore* _liststore_crystals;
260
261 GtkInfoBar *info_bar;
262 GtkLabel *info_message;
263
264 darray(HklGuiEngine *) pseudo_frames;
265
266 struct diffractometer_t *diffractometer; /* unowned */
267 HklSample *sample; /* unowned */
268 HklLattice *reciprocal;
269 };
270
271 #define HKL_GUI_WINDOW_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), HKL_GUI_TYPE_WINDOW, HklGuiWindowPrivate))
272
273 static gboolean
274 finalize_liststore_diffractometer(GtkTreeModel *model,
275 GtkTreePath *path,
276 GtkTreeIter *iter,
277 gpointer data)
278 {
279 struct diffractometer_t *diffractometer;
280
281 gtk_tree_model_get(model, iter,
282 DIFFRACTOMETER_COL_DIFFRACTOMETER, &diffractometer,
283 -1);
284 delete_diffractometer(diffractometer);
285 return FALSE;
286 }
287
288 static gboolean
289 finalize_liststore_samples(GtkTreeModel *model,
290 GtkTreePath *path,
291 GtkTreeIter *iter,
292 gpointer data)
293 {
294 HklSample *sample = NULL;
295
296 gtk_tree_model_get(model, iter,
297 SAMPLE_COL_SAMPLE, &sample,
298 -1);
299 hkl_sample_free(sample);
300 return FALSE;
301 }
302
303 static void
304 finalize (GObject* object)
305 {
306 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(object);
307
308 g_object_unref(priv->builder);
309
310 darray_free(priv->pseudo_frames);
311
312 gtk_tree_model_foreach(GTK_TREE_MODEL(priv->_liststore_diffractometer),
313 finalize_liststore_diffractometer,
314 NULL);
315
316 gtk_tree_model_foreach(GTK_TREE_MODEL(priv->_liststore_crystals),
317 finalize_liststore_samples,
318 NULL);
319
320 G_OBJECT_CLASS (hkl_gui_window_parent_class)->finalize (object);
321 }
322
323 HklGuiWindow* hkl_gui_window_new (void)
324 {
325 return g_object_new (HKL_GUI_TYPE_WINDOW, NULL);
326 }
327
328
329 #define get_object(builder, type, priv, name) priv->_ ## name = type(gtk_builder_get_object(builder, #name))
330
331 static void
332 hkl_gui_window_get_widgets_and_objects_from_ui (HklGuiWindow* self)
333 {
334 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
335 GtkBuilder* builder;
336
337 g_return_if_fail (self != NULL);
338
339 priv->builder = builder = gtk_builder_new ();
340 gtk_builder_add_from_file (builder, "ghkl.ui", NULL);
341
342 get_object(builder, GTK_LIST_STORE, priv, liststore_diffractometer);
343 get_object(builder, GTK_LIST_STORE, priv, liststore_axis);
344 get_object(builder, GTK_LIST_STORE, priv, liststore_pseudo_axes);
345 get_object(builder, GTK_LIST_STORE, priv, liststore_reflections);
346 get_object(builder, GTK_LIST_STORE, priv, liststore_crystals);
347
348 get_object(builder, GTK_LABEL, priv, label_UB11);
349 get_object(builder, GTK_LABEL, priv, label_UB12);
350 get_object(builder, GTK_LABEL, priv, label_UB13);
351 get_object(builder, GTK_LABEL, priv, label_UB21);
352 get_object(builder, GTK_LABEL, priv, label_UB22);
353 get_object(builder, GTK_LABEL, priv, label_UB23);
354 get_object(builder, GTK_LABEL, priv, label_UB31);
355 get_object(builder, GTK_LABEL, priv, label_UB32);
356 get_object(builder, GTK_LABEL, priv, label_UB33);
357
358 get_object(builder, GTK_BUTTON, priv, button2);
359
360 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_a);
361 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_a_min);
362 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_a_max);
363 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_a_star);
364
365 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_b);
366 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_b_min);
367 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_b_max);
368 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_b_star);
369
370 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_c);
371 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_c_min);
372 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_c_max);
373 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_c_star);
374
375 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_alpha);
376 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_alpha_min);
377 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_alpha_max);
378 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_alpha_star);
379
380 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_beta);
381 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_beta_min);
382 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_beta_max);
383 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_beta_star);
384
385 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_gamma);
386 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_gamma_min);
387 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_gamma_max);
388 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_gamma_star);
389
390 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_lambda);
391
392 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_ux);
393 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_uy);
394 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_uz);
395
396 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_U11);
397 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_U12);
398 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_U13);
399 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_U21);
400 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_U22);
401 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_U23);
402 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_U31);
403 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_U32);
404 get_object(builder, GTK_SPIN_BUTTON, priv, spinbutton_U33);
405
406
407 get_object(builder, GTK_CHECK_BUTTON, priv, checkbutton_a);
408 get_object(builder, GTK_CHECK_BUTTON, priv, checkbutton_b);
409 get_object(builder, GTK_CHECK_BUTTON, priv, checkbutton_c);
410 get_object(builder, GTK_CHECK_BUTTON, priv, checkbutton_alpha);
411 get_object(builder, GTK_CHECK_BUTTON, priv, checkbutton_beta);
412 get_object(builder, GTK_CHECK_BUTTON, priv, checkbutton_gamma);
413 get_object(builder, GTK_CHECK_BUTTON, priv, checkbutton_ux);
414 get_object(builder, GTK_CHECK_BUTTON, priv, checkbutton_uy);
415 get_object(builder, GTK_CHECK_BUTTON, priv, checkbutton_uz);
416
417
418 get_object(builder, GTK_TREE_VIEW, priv, treeview_reflections);
419 get_object(builder, GTK_TREE_VIEW, priv, treeview_crystals);
420 get_object(builder, GTK_TREE_VIEW, priv, treeview_axes);
421 get_object(builder, GTK_TREE_VIEW, priv, treeview_pseudo_axes);
422 get_object(builder, GTK_TREE_VIEW, priv, treeview_solutions);
423
424 get_object(builder, GTK_TOOL_BUTTON, priv, toolbutton_add_reflection);
425 get_object(builder, GTK_TOOL_BUTTON, priv, toolbutton_goto_reflection);
426 get_object(builder, GTK_TOOL_BUTTON, priv, toolbutton_del_reflection);
427 get_object(builder, GTK_TOOL_BUTTON, priv, toolbutton_setUB);
428 get_object(builder, GTK_TOOL_BUTTON, priv, toolbutton_computeUB);
429 get_object(builder, GTK_TOOL_BUTTON, priv, toolbutton_add_crystal);
430 get_object(builder, GTK_TOOL_BUTTON, priv, toolbutton_copy_crystal);
431 get_object(builder, GTK_TOOL_BUTTON, priv, toolbutton_del_crystal);
432 get_object(builder, GTK_TOOL_BUTTON, priv, toolbutton_affiner);
433
434 get_object(builder, GTK_STATUSBAR, priv, statusbar);
435
436 get_object(builder, GTK_IMAGE_MENU_ITEM, priv, menuitem5);
437
438 get_object(builder, GTK_VBOX, priv, vbox7);
439 get_object(builder, GTK_VBOX, priv, vbox2);
440 get_object(builder, GTK_VBOX, priv, box_info_bar);
441
442 get_object(builder, GTK_DIALOG, priv, dialog1);
443
444 get_object(builder, GTK_COMBO_BOX, priv, combobox1);
445
446 gtk_builder_connect_signals (builder, self);
447 }
448
449 static void
450 update_pseudo_axes_frames (HklGuiWindow* self)
451 {
452 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
453 HklGuiEngine **engine;
454
455 g_return_if_fail (self != NULL);
456
457 darray_foreach(engine, priv->pseudo_frames){
458 hkl_gui_engine_update(*engine);
459 }
460 }
461
462 static void
463 raise_error(HklGuiWindow *self, HklError **error)
464 {
465 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
466
467 g_return_if_fail (self != NULL);
468 g_return_if_fail (error != NULL);
469
470 /* show an error message */
471 gtk_label_set_text (GTK_LABEL (priv->info_message),
472 hkl_error_message_get(*error));
473 gtk_info_bar_set_message_type (priv->info_bar,
474 GTK_MESSAGE_ERROR);
475 gtk_widget_show (GTK_WIDGET(priv->info_bar));
476
477 hkl_error_clear(error);
478 }
479
480 static void
481 clear_error(HklGuiWindow *self, HklError **error)
482 {
483 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
484
485 g_return_if_fail (self != NULL);
486
487 gtk_widget_hide(GTK_WIDGET(priv->info_bar));
488 }
489
490 static gboolean
491 _update_axis (GtkTreeModel *model, GtkTreePath *path,
492 GtkTreeIter *iter, gpointer data)
493 {
494 HklParameter *parameter;
495 gdouble value, min, max;
496
497 gtk_tree_model_get (model, iter,
498 AXIS_COL_AXIS, &parameter,
499 -1);
500
501 hkl_parameter_min_max_unit_get(parameter, &min, &max);
502 value = hkl_parameter_value_unit_get(parameter);
503
504 gtk_list_store_set(GTK_LIST_STORE(model), iter,
505 AXIS_COL_READ, value,
506 AXIS_COL_WRITE, value,
507 AXIS_COL_MIN, min,
508 AXIS_COL_MAX, max,
509 -1);
510 return FALSE;
511 }
512
513 static void
514 update_axes (HklGuiWindow* self)
515 {
516 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
517
518 g_return_if_fail (self != NULL);
519
520 gtk_tree_model_foreach(GTK_TREE_MODEL(priv->_liststore_axis),
521 _update_axis,
522 self);
523 }
524
525 static gboolean
526 _update_pseudo_axes (GtkTreeModel *model, GtkTreePath *path,
527 GtkTreeIter *iter, gpointer data)
528 {
529 HklParameter *parameter;
530 gdouble value, min, max;
531
532 gtk_tree_model_get (model, iter,
533 PSEUDO_AXIS_COL_PARAMETER, &parameter,
534 -1);
535
536 hkl_parameter_min_max_unit_get(parameter, &min, &max);
537 value = hkl_parameter_value_unit_get(parameter);
538
539 gtk_list_store_set(GTK_LIST_STORE(model), iter,
540 PSEUDO_AXIS_COL_READ, value,
541 PSEUDO_AXIS_COL_WRITE, value,
542 -1);
543 return FALSE;
544 }
545
546 static void
547 update_pseudo_axes (HklGuiWindow* self)
548 {
549 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
550
551 g_return_if_fail (self != NULL);
552
553 gtk_tree_model_foreach(GTK_TREE_MODEL(priv->_liststore_pseudo_axes),
554 _update_pseudo_axes,
555 self);
556 }
557
558 static void
559 update_solutions (HklGuiWindow* self)
560 {
561 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
562 const HklGeometryList *geometries;
563 const darray_item *items;
564 GtkTreeIter iter = {0};
565
566 g_return_if_fail (self != NULL);
567
568 if(priv->diffractometer){
569 geometries = hkl_engine_list_geometries(priv->diffractometer->engines);
570
571 gtk_list_store_clear(priv->_liststore_solutions);
572 items = hkl_geometry_list_items_get(geometries);
573 if (darray_size(*items)){
574 gint n_values = gtk_tree_model_get_n_columns (GTK_TREE_MODEL(priv->_liststore_solutions));
575 GValue *values = g_new0(GValue, n_values);
576 gint *columns = g_new0(gint, n_values);
577 gint i;
578
579 /* prepare the GValue before using them */
580 g_value_init(&values[0], G_TYPE_INT);
581 for(i=1; i<n_values; ++i)
582 g_value_init(&values[i], G_TYPE_DOUBLE);
583
584 for(i=0; i<darray_size(*items);++i){
585 gint column = 0;
586 const HklGeometry *geometry;
587 HklParameter **parameter;
588 const darray_parameter *parameters;
589
590 geometry = hkl_geometry_list_item_geometry_get(darray_item(*items, i));
591 parameters = hkl_geometry_axes_get(geometry);
592
593 g_value_set_int(&values[column], i);
594 columns[0] = column;
595
596 darray_foreach(parameter, *parameters){
597 double value = hkl_parameter_value_unit_get(*parameter);
598
599 column = column + 1;
600 g_value_set_double(&values[column], value);
601 columns[column] = column;
602 }
603 gtk_list_store_insert_with_valuesv(priv->_liststore_solutions,
604 &iter, i,
605 columns, values, n_values);
606 }
607 g_free(columns);
608 g_free(values);
609 }
610 }
611 }
612
613 static void
614 update_source (HklGuiWindow* self)
615 {
616 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
617
618 g_return_if_fail (self != NULL);
619
620 gtk_spin_button_set_value (priv->_spinbutton_lambda,
621 hkl_geometry_wavelength_get(priv->diffractometer->geometry));
622 }
623
624 static void
625 update_reflections (HklGuiWindow *self)
626 {
627 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
628
629 gtk_list_store_clear (priv->_liststore_reflections);
630
631 if(priv->sample){
632 HklSampleReflection* reflection = NULL;
633 guint index = 0;
634
635 reflection = hkl_sample_first_reflection_get(priv->sample);
636 while(reflection){
637 GtkTreeIter iter = {0};
638 gdouble h, k, l;
639 gboolean flag;
640
641 hkl_sample_reflection_hkl_get(reflection, &h, &k, &l);
642 flag = hkl_sample_reflection_flag_get(reflection);
643
644 gtk_list_store_append (priv->_liststore_reflections, &iter);
645
646 gtk_list_store_set (priv->_liststore_reflections,
647 &iter,
648 REFLECTION_COL_INDEX, index++,
649 REFLECTION_COL_H, h,
650 REFLECTION_COL_K, k,
651 REFLECTION_COL_L, l,
652 REFLECTION_COL_FLAG, flag,
653 REFLECTION_COL_REFLECTION, reflection,
654 -1);
655 reflection = hkl_sample_next_reflection_get(priv->sample,
656 reflection);
657 }
658 }
659 }
660
661 static gboolean
662 hkl_engine_to_axes(HklGuiWindow *self, HklEngine *engine)
663 {
664 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
665 HklError *error = NULL;
666 gboolean res = TRUE;
667
668 g_return_val_if_fail (self != NULL, FALSE);
669 g_return_val_if_fail (engine != NULL, FALSE);
670
671 if(hkl_engine_set(engine, &error)){
672 clear_error(self, &error);
673 hkl_engine_list_select_solution(priv->diffractometer->engines, 0);
674 hkl_engine_list_get(priv->diffractometer->engines);
675
676 update_axes (self);
677 update_pseudo_axes (self);
678 update_pseudo_axes_frames (self);
679 }else{
680 raise_error(self, &error);
681 dump_diffractometer(priv->diffractometer);
682 res = FALSE;
683 }
684 update_solutions (self);
685 return res;
686 }
687
688 static void
689 pseudo_axes_frame_changed_cb (HklGuiEngine *gui_engine, HklGuiWindow *self)
690 {
691 HklEngine *engine;
692
693 g_return_if_fail (self != NULL);
694
695 g_object_get(G_OBJECT(gui_engine),
696 "engine", &engine,
697 NULL);
698
699 hkl_engine_to_axes(self, engine);
700 }
701
702 static void
703 set_up_pseudo_axes_frames (HklGuiWindow* self)
704 {
705 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
706 HklGuiEngine **pseudo;
707 GtkVBox* vbox2;
708 HklEngine **engine;
709 darray_engine *engines;
710
711 g_return_if_fail (self != NULL);
712
713 darray_foreach (pseudo, priv->pseudo_frames){
714 gtk_container_remove(GTK_CONTAINER(priv->_vbox2),
715 GTK_WIDGET (hkl_gui_engine_get_frame (*pseudo)));
716 g_object_unref(*pseudo);
717 }
718 darray_size (priv->pseudo_frames) = 0;
719
720 engines = hkl_engine_list_engines (priv->diffractometer->engines);
721 darray_foreach (engine, *engines){
722 HklGuiEngine *pseudo;
723
724 pseudo = hkl_gui_engine_new (*engine);
725 darray_append(priv->pseudo_frames, pseudo);
726 gtk_container_add (GTK_CONTAINER (priv->_vbox2),
727 GTK_WIDGET (hkl_gui_engine_get_frame(pseudo)));
728
729 g_signal_connect_object (pseudo,
730 "changed",
731 G_CALLBACK(pseudo_axes_frame_changed_cb),
732 self, 0);
733 }
734
735 gtk_widget_show_all (GTK_WIDGET (priv->_vbox2));
736 }
737
738
739 static void
740 set_up_diffractometer_model (HklGuiWindow* self)
741 {
742 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
743 unsigned int i, n;
744 HklFactory **factories;
745
746 g_return_if_fail (self != NULL);
747
748 factories = hkl_factory_get_all(&n);
749 for(i=0; i<n; ++i){
750 GtkTreeIter iter = {0};
751
752 gtk_list_store_append (priv->_liststore_diffractometer, &iter);
753 gtk_list_store_set (priv->_liststore_diffractometer,
754 &iter,
755 DIFFRACTOMETER_COL_NAME, hkl_factory_name(factories[i]),
756 DIFFRACTOMETER_COL_FACTORY, factories[i],
757 DIFFRACTOMETER_COL_DIFFRACTOMETER, NULL,
758 -1);
759 }
760 }
761
762 static void
763 set_up_tree_view_axes (HklGuiWindow* self)
764 {
765 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
766 HklParameter **parameter;
767 const darray_parameter *parameters;
768 GtkCellRenderer* renderer = NULL;
769 GtkTreeViewColumn* column = NULL;
770 GList* columns;
771
772 g_return_if_fail (self != NULL);
773
774 gtk_list_store_clear (priv->_liststore_axis);
775
776 parameters = hkl_geometry_axes_get(priv->diffractometer->geometry);
777 darray_foreach (parameter, *parameters){
778 GtkTreeIter iter = {0};
779
780 gtk_list_store_append (priv->_liststore_axis, &iter);
781 gtk_list_store_set (priv->_liststore_axis, &iter,
782 AXIS_COL_AXIS, *parameter,
783 AXIS_COL_NAME, hkl_parameter_name_get(*parameter),
784 -1);
785 }
786
787 update_axes (self);
788 }
789
790 static void
791 set_up_tree_view_pseudo_axes (HklGuiWindow* self)
792 {
793 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
794 HklParameter **parameter;
795 const darray_parameter *parameters;
796 HklEngine **engine;
797 const darray_engine *engines;
798
799 GtkCellRendererText* renderer = NULL;
800 GtkTreeViewColumn* column = NULL;
801 GList* columns;
802
803 g_return_if_fail (self != NULL);
804
805 gtk_list_store_clear(priv->_liststore_pseudo_axes);
806
807 engines = hkl_engine_list_engines(priv->diffractometer->engines);
808 darray_foreach(engine, *engines){
809 parameters = hkl_engine_pseudo_axes(*engine);
810 darray_foreach(parameter, *parameters){
811 GtkTreeIter iter = {0};
812
813 gtk_list_store_append (priv->_liststore_pseudo_axes, &iter);
814 gtk_list_store_set (priv->_liststore_pseudo_axes, &iter,
815 PSEUDO_AXIS_COL_PARAMETER, *parameter,
816 PSEUDO_AXIS_COL_ENGINE, *engine,
817 PSEUDO_AXIS_COL_NAME, hkl_parameter_name_get(*parameter),
818 -1);
819 }
820 }
821
822 update_pseudo_axes (self);
823 }
824
825 static void
826 _delete_column(gpointer data,
827 gpointer user_data)
828 {
829 gtk_tree_view_remove_column (GTK_TREE_VIEW(user_data),
830 GTK_TREE_VIEW_COLUMN(data));
831 }
832
833 static void
834 set_up_tree_view_solutions (HklGuiWindow* self)
835 {
836 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
837 const darray_parameter *parameters;
838 int i;
839 GtkCellRenderer* renderer = NULL;
840 GtkTreeViewColumn* column = NULL;
841 GList* columns;
842 GType* types;
843 gint n_columns;
844
845 g_return_if_fail (self != NULL);
846
847 parameters = hkl_geometry_axes_get(priv->diffractometer->geometry);
848
849 n_columns = SOLUTION_COL_N_COLUMNS + darray_size(*parameters);
850
851 /* prepare types for the liststore */
852 types = g_new0 (GType, n_columns);
853
854 /* first remove all the columns */
855 columns = gtk_tree_view_get_columns (priv->_treeview_solutions);
856 g_list_foreach(columns, _delete_column, priv->_treeview_solutions);
857 g_list_free(columns);
858
859 /* now add the index column */
860 renderer = gtk_cell_renderer_text_new ();
861 column = gtk_tree_view_column_new_with_attributes ("index",
862 renderer, "text",
863 SOLUTION_COL_INDEX, NULL);
864
865 gtk_tree_view_append_column (priv->_treeview_solutions, column);
866 types[0] = G_TYPE_INT;
867
868 /* add the axes column */
869 for(i=1; i<n_columns; ++i){
870 HklParameter *parameter;
871
872 parameter = darray_item(*parameters, i - SOLUTION_COL_N_COLUMNS);
873 renderer = gtk_cell_renderer_text_new ();
874 column = gtk_tree_view_column_new_with_attributes (hkl_parameter_name_get(parameter),
875 renderer, "text",
876 i, NULL);
877
878 gtk_tree_view_append_column (priv->_treeview_solutions, column);
879 types[i] = G_TYPE_DOUBLE;
880 }
881
882 if (priv->_liststore_solutions)
883 g_object_unref(priv->_liststore_solutions);
884 priv->_liststore_solutions = gtk_list_store_newv (n_columns, types);
885 g_free (types);
886
887 gtk_tree_view_set_model (priv->_treeview_solutions,
888 GTK_TREE_MODEL(priv->_liststore_solutions));
889
890 update_solutions (self);
891 }
892
893 void
894 set_up_info_bar(HklGuiWindow *self)
895 {
896 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
897 GtkWidget *content_area;
898
899 g_return_if_fail (self != NULL);
900
901 /* set up info bar until we can use glade for this purpose or
902 * switch to gtk3 */
903 if (priv->info_bar)
904 return;
905
906 priv->info_bar = GTK_INFO_BAR(gtk_info_bar_new ());
907 gtk_widget_set_no_show_all (GTK_WIDGET(priv->info_bar), TRUE);
908
909 priv->info_message = GTK_LABEL(gtk_label_new (""));
910 gtk_widget_show (GTK_WIDGET(priv->info_message));
911
912 content_area = gtk_info_bar_get_content_area (GTK_INFO_BAR (priv->info_bar));
913 gtk_container_add (GTK_CONTAINER (content_area),
914 GTK_WIDGET(priv->info_message));
915 gtk_info_bar_add_button (priv->info_bar,
916 GTK_STOCK_OK, GTK_RESPONSE_OK);
917 g_signal_connect (priv->info_bar, "response",
918 G_CALLBACK (gtk_widget_hide), NULL);
919
920 gtk_box_pack_start(GTK_BOX(priv->_box_info_bar),
921 GTK_WIDGET(priv->info_bar),
922 TRUE, TRUE, 0);
923 }
924
925 static void
926 set_up_lambda(HklGuiWindow *self)
927 {
928 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
929
930 g_object_set(G_OBJECT(priv->_spinbutton_lambda),
931 "sensitive", TRUE,
932 NULL);
933
934 gtk_spin_button_set_value(priv->_spinbutton_lambda,
935 hkl_geometry_wavelength_get(priv->diffractometer->geometry));
936 }
937
938 /* select diffractometer */
939 void
940 hkl_gui_window_combobox1_changed_cb(GtkComboBox *combobox, gpointer *user_data)
941 {
942 HklGuiWindow *self = HKL_GUI_WINDOW(user_data);
943 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(user_data);
944 HklFactory *factory;
945 struct diffractometer_t *dif = NULL;
946
947 GtkTreeIter iter = {0};
948
949 if(gtk_combo_box_get_active_iter (combobox, &iter)){
950 gtk_tree_model_get(GTK_TREE_MODEL(priv->_liststore_diffractometer),
951 &iter,
952 DIFFRACTOMETER_COL_FACTORY, &factory,
953 DIFFRACTOMETER_COL_DIFFRACTOMETER, &dif,
954 -1);
955
956 if (!dif){
957 dif = create_diffractometer(factory);
958 gtk_list_store_set(priv->_liststore_diffractometer,
959 &iter,
960 DIFFRACTOMETER_COL_DIFFRACTOMETER, dif,
961 -1);
962 }
963 }
964 if(dif != priv->diffractometer){
965 priv->diffractometer = dif;
966
967 diffractometer_set_sample(dif, priv->sample);
968
969 set_up_lambda(self);
970 set_up_pseudo_axes_frames(self);
971 set_up_tree_view_axes(self);
972 set_up_tree_view_pseudo_axes(self);
973 set_up_tree_view_solutions(self);
974 set_up_info_bar(self);
975 #if HKL3D
976 set_up_3D(self);
977 #endif
978 }
979 }
980
981
982 /* axis read cb */
983 void
984 hkl_gui_window_cellrendererspin1_edited_cb(GtkCellRendererText *renderer,
985 gchar *path,
986 gchar *new_text,
987 gpointer user_data)
988 {
989 HklGuiWindow *self = HKL_GUI_WINDOW(user_data);
990 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(user_data);
991 GtkTreeIter iter = {0};
992 gdouble value = 0.0;
993 HklParameter* parameter = NULL;
994
995 g_return_if_fail (renderer != NULL);
996 g_return_if_fail (path != NULL);
997 g_return_if_fail (new_text != NULL);
998 g_return_if_fail (user_data != NULL);
999
1000 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL(priv->_liststore_axis),
1001 &iter,
1002 path);
1003 gtk_tree_model_get (GTK_TREE_MODEL(priv->_liststore_axis), &iter,
1004 AXIS_COL_AXIS, &parameter,
1005 -1);
1006
1007 value = atof(new_text); /* TODO need to check for the right conversion */
1008 hkl_parameter_value_unit_set (parameter, value, NULL);
1009 hkl_geometry_axis_set(priv->diffractometer->geometry,
1010 parameter);
1011
1012 hkl_engine_list_get(priv->diffractometer->engines);
1013
1014 /* ok so set the model with the new value */
1015 gtk_list_store_set (priv->_liststore_axis, &iter,
1016 AXIS_COL_READ, value,
1017 AXIS_COL_WRITE, value,
1018 -1);
1019
1020 update_pseudo_axes (self);
1021 update_pseudo_axes_frames (self);
1022 }
1023
1024
1025 /* axis min cb */
1026 void
1027 hkl_gui_window_cellrendererspin3_edited_cb(GtkCellRendererText *renderer,
1028 gchar *path,
1029 gchar *new_text,
1030 gpointer user_data)
1031 {
1032 HklGuiWindow *self = HKL_GUI_WINDOW(user_data);
1033 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(user_data);
1034 GtkTreeIter iter = {0};
1035 gdouble value = 0.0;
1036 HklParameter* parameter = NULL;
1037 gdouble shit, max;
1038
1039 g_return_if_fail (renderer != NULL);
1040 g_return_if_fail (path != NULL);
1041 g_return_if_fail (new_text != NULL);
1042 g_return_if_fail (user_data != NULL);
1043
1044 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL(priv->_liststore_axis),
1045 &iter,
1046 path);
1047 gtk_tree_model_get (GTK_TREE_MODEL(priv->_liststore_axis), &iter,
1048 AXIS_COL_AXIS, &parameter,
1049 -1);
1050
1051 value = atof(new_text); /* TODO need to check for the right conversion */
1052 hkl_parameter_min_max_unit_get (parameter, &shit, &max);
1053 hkl_parameter_min_max_unit_set (parameter, value, max);
1054
1055 gtk_list_store_set (priv->_liststore_axis, &iter,
1056 AXIS_COL_MIN, value,
1057 -1);
1058
1059 update_pseudo_axes (self);
1060 }
1061
1062
1063 /* axis max cb */
1064 void
1065 hkl_gui_window_cellrendererspin4_edited_cb(GtkCellRendererText *renderer,
1066 gchar *path,
1067 gchar *new_text,
1068 gpointer user_data)
1069 {
1070 HklGuiWindow *self = HKL_GUI_WINDOW(user_data);
1071 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(user_data);
1072 GtkTreeIter iter = {0};
1073 gdouble value = 0.0;
1074 HklParameter* parameter = NULL;
1075 gdouble shit, min;
1076
1077 g_return_if_fail (renderer != NULL);
1078 g_return_if_fail (path != NULL);
1079 g_return_if_fail (new_text != NULL);
1080 g_return_if_fail (user_data != NULL);
1081
1082 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL(priv->_liststore_axis),
1083 &iter,
1084 path);
1085 gtk_tree_model_get (GTK_TREE_MODEL(priv->_liststore_axis), &iter,
1086 AXIS_COL_AXIS, &parameter,
1087 -1);
1088
1089 value = atof(new_text); /* TODO need to check for the right conversion */
1090 hkl_parameter_min_max_unit_get (parameter, &min, &shit);
1091 hkl_parameter_min_max_unit_set (parameter, min, value);
1092
1093 gtk_list_store_set (priv->_liststore_axis, &iter,
1094 AXIS_COL_MAX, value,
1095 -1);
1096
1097 update_pseudo_axes (self);
1098 }
1099
1100
1101 /* pseudo axis write */
1102 void
1103 hkl_gui_window_cellrenderertext5_edited_cb(GtkCellRendererText *renderer,
1104 gchar *path,
1105 gchar *new_text,
1106 gpointer user_data)
1107 {
1108 HklGuiWindow *self = HKL_GUI_WINDOW(user_data);
1109 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(user_data);
1110 GtkTreeIter iter = {0};
1111 gdouble value = 0.0;
1112 gdouble old_value;
1113 HklParameter* parameter = NULL;
1114 HklEngine *engine = NULL;
1115 HklError *error = NULL;
1116
1117 g_return_if_fail (renderer != NULL);
1118 g_return_if_fail (path != NULL);
1119 g_return_if_fail (new_text != NULL);
1120 g_return_if_fail (user_data != NULL);
1121
1122 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL(priv->_liststore_pseudo_axes),
1123 &iter,
1124 path);
1125 gtk_tree_model_get (GTK_TREE_MODEL(priv->_liststore_pseudo_axes), &iter,
1126 PSEUDO_AXIS_COL_PARAMETER, &parameter,
1127 PSEUDO_AXIS_COL_ENGINE, &engine,
1128 -1);
1129
1130 value = atof(new_text); /* TODO need to check for the right conversion */
1131 old_value = hkl_parameter_value_unit_get(parameter);
1132
1133 g_assert(error != NULL || error == NULL);
1134 hkl_parameter_value_unit_set (parameter, value, &error);
1135 if(error != NULL){
1136 raise_error(self, &error);
1137 }
1138
1139 if (hkl_engine_to_axes(self, engine)){
1140 gtk_list_store_set (priv->_liststore_pseudo_axes,
1141 &iter,
1142 PSEUDO_AXIS_COL_WRITE, value,
1143 -1);
1144 }else{
1145 hkl_parameter_value_unit_set(parameter, old_value, NULL);
1146 }
1147 }
1148
1149
1150 void
1151 hkl_gui_window_treeview_solutions_cursor_changed_cb (GtkTreeView *tree_view,
1152 gpointer user_data)
1153 {
1154 HklGuiWindow* self = HKL_GUI_WINDOW(user_data);
1155 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(user_data);
1156
1157 GtkTreePath* path = NULL;
1158 GtkTreeViewColumn* focus_column = NULL;
1159 GtkTreeIter iter = {0};
1160 gsize index = 0UL;
1161
1162 g_return_if_fail (tree_view != NULL);
1163 g_return_if_fail (user_data != NULL);
1164
1165 gtk_tree_view_get_cursor (tree_view, &path, &focus_column);
1166 gtk_tree_model_get_iter (GTK_TREE_MODEL(priv->_liststore_solutions), &iter, path);
1167 gtk_tree_model_get (GTK_TREE_MODEL(priv->_liststore_solutions), &iter,
1168 SOLUTION_COL_INDEX, &index,
1169 -1);
1170
1171 hkl_engine_list_select_solution (priv->diffractometer->engines, index);
1172 hkl_engine_list_get (priv->diffractometer->engines);
1173
1174 update_axes (self);
1175 update_pseudo_axes (self);
1176 update_pseudo_axes_frames (self);
1177
1178 gtk_tree_path_free (path);
1179 }
1180
1181 /* reflection h */
1182 void
1183 hkl_gui_window_cellrenderertext7_edited_cb(GtkCellRendererText* _sender, const gchar* path,
1184 const gchar* new_text, gpointer self)
1185 {
1186 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
1187
1188 g_return_if_fail (self != NULL);
1189 g_return_if_fail (path != NULL);
1190 g_return_if_fail (new_text != NULL);
1191
1192 if (priv->sample){
1193 gdouble h = 0.0;
1194 gdouble k = 0.0;
1195 gdouble l = 0.0;
1196 HklSampleReflection* reflection = NULL;
1197 GtkTreeIter iter = {0};
1198
1199 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL(priv->_liststore_reflections),
1200 &iter, path);
1201 gtk_tree_model_get (GTK_TREE_MODEL(priv->_liststore_reflections),
1202 &iter,
1203 REFLECTION_COL_REFLECTION, &reflection,
1204 -1);
1205
1206 hkl_sample_reflection_hkl_get (reflection, &h, &k, &l);
1207 h = atof(new_text);
1208 hkl_sample_reflection_hkl_set (reflection, h, k, l);
1209 gtk_list_store_set (priv->_liststore_reflections,
1210 &iter,
1211 REFLECTION_COL_H, h,
1212 -1);
1213 }
1214 }
1215
1216 /* reflection k */
1217 void
1218 hkl_gui_window_cellrenderertext8_edited_cb (GtkCellRendererText* _sender, const gchar* path,
1219 const gchar* new_text, gpointer self)
1220 {
1221 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
1222
1223 g_return_if_fail (self != NULL);
1224 g_return_if_fail (path != NULL);
1225 g_return_if_fail (new_text != NULL);
1226
1227 if (priv->sample){
1228 gdouble h = 0.0;
1229 gdouble k = 0.0;
1230 gdouble l = 0.0;
1231 HklSampleReflection* reflection = NULL;
1232 GtkTreeIter iter = {0};
1233
1234 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL(priv->_liststore_reflections),
1235 &iter, path);
1236 gtk_tree_model_get (GTK_TREE_MODEL(priv->_liststore_reflections),
1237 &iter,
1238 REFLECTION_COL_REFLECTION, &reflection,
1239 -1);
1240
1241 hkl_sample_reflection_hkl_get (reflection, &h, &k, &l);
1242 k = atof(new_text);
1243 hkl_sample_reflection_hkl_set (reflection, h, k, l);
1244 gtk_list_store_set (priv->_liststore_reflections,
1245 &iter,
1246 REFLECTION_COL_K, k,
1247 -1);
1248 }
1249 }
1250
1251 /* reflection l */
1252 void
1253 hkl_gui_window_cellrenderertext9_edited_cb (GtkCellRendererText* _sender, const gchar* path,
1254 const gchar* new_text, gpointer self)
1255 {
1256 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
1257
1258 g_return_if_fail (self != NULL);
1259 g_return_if_fail (path != NULL);
1260 g_return_if_fail (new_text != NULL);
1261
1262 if (priv->sample){
1263 gdouble h = 0.0;
1264 gdouble k = 0.0;
1265 gdouble l = 0.0;
1266 HklSampleReflection* reflection = NULL;
1267 GtkTreeIter iter = {0};
1268
1269 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL(priv->_liststore_reflections),
1270 &iter, path);
1271 gtk_tree_model_get (GTK_TREE_MODEL(priv->_liststore_reflections),
1272 &iter,
1273 REFLECTION_COL_REFLECTION, &reflection,
1274 -1);
1275
1276 hkl_sample_reflection_hkl_get (reflection, &h, &k, &l);
1277 l = atof(new_text);
1278 hkl_sample_reflection_hkl_set (reflection, h, k, l);
1279 gtk_list_store_set (priv->_liststore_reflections,
1280 &iter,
1281 REFLECTION_COL_L, l,
1282 -1);
1283 }
1284 }
1285
1286 /* reflection flag */
1287 void
1288 hkl_gui_window_cellrenderertoggle1_toggled_cb (GtkCellRendererToggle* renderer, const gchar* path,
1289 gpointer self)
1290 {
1291 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
1292
1293 g_return_if_fail (self != NULL);
1294 g_return_if_fail (path != NULL);
1295
1296 if (priv->sample){
1297 gboolean flag;
1298 HklSampleReflection* reflection = NULL;
1299 GtkTreeIter iter = {0};
1300
1301 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL(priv->_liststore_reflections),
1302 &iter, path);
1303 gtk_tree_model_get (GTK_TREE_MODEL(priv->_liststore_reflections),
1304 &iter,
1305 REFLECTION_COL_REFLECTION, &reflection,
1306 -1);
1307
1308 flag = gtk_cell_renderer_toggle_get_active(renderer);
1309 hkl_sample_reflection_flag_set (reflection, flag);
1310 gtk_list_store_set (priv->_liststore_reflections,
1311 &iter,
1312 REFLECTION_COL_FLAG, flag,
1313 -1);
1314 }
1315 }
1316
1317 gboolean
1318 hkl_gui_window_treeview_reflections_key_press_event_cb (GtkWidget* _sender, GdkEventKey* event,
1319 gpointer self)
1320 {
1321 return TRUE;
1322 }
1323
1324 void
1325 hkl_gui_window_toolbutton_add_reflection_clicked_cb(GtkToolButton* _sender,
1326 gpointer self)
1327 {
1328 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
1329
1330 if (priv->diffractometer == NULL){
1331 gtk_statusbar_push (priv->_statusbar, 0,
1332 "Please select a diffractometer before adding reflections");
1333 return;
1334 }
1335
1336 if (priv->sample) {
1337 HklSampleReflection *reflection = NULL;
1338 GtkTreeIter iter = {0};
1339 gboolean flag;
1340 gint n_rows;
1341
1342 reflection = hkl_sample_reflection_new(priv->diffractometer->geometry,
1343 priv->diffractometer->detector,
1344 0, 0, 0);
1345 hkl_sample_add_reflection(priv->sample, reflection);
1346 flag = hkl_sample_reflection_flag_get(reflection);
1347
1348 n_rows = gtk_tree_model_iter_n_children(GTK_TREE_MODEL(priv->_liststore_reflections),
1349 NULL);
1350 gtk_list_store_insert_with_values (priv->_liststore_reflections,
1351 &iter, -1,
1352 REFLECTION_COL_INDEX, n_rows,
1353 REFLECTION_COL_H, 0.,
1354 REFLECTION_COL_K, 0.,
1355 REFLECTION_COL_L, 0.,
1356 REFLECTION_COL_FLAG, flag,
1357 REFLECTION_COL_REFLECTION, reflection,
1358 -1);
1359 }
1360 }
1361
1362 void
1363 hkl_gui_window_toolbutton_goto_reflection_clicked_cb (GtkToolButton* _sender, gpointer user_data)
1364 {
1365 HklGuiWindow *self = HKL_GUI_WINDOW(user_data);
1366 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(user_data);
1367
1368 g_return_if_fail (self != NULL);
1369
1370 if (priv->sample) {
1371 GtkTreeSelection* selection = NULL;
1372 guint nb_rows = 0U;
1373
1374 selection = gtk_tree_view_get_selection (priv->_treeview_reflections);
1375 nb_rows = gtk_tree_selection_count_selected_rows (selection);
1376
1377 if (nb_rows == 1) {
1378 HklSampleReflection *reflection;
1379 GtkTreeIter iter = {0};
1380 GtkTreeModel* model = NULL;
1381 GtkTreePath *treepath;
1382 GList* list;
1383
1384 model = GTK_TREE_MODEL(priv->_liststore_reflections);
1385
1386 list = gtk_tree_selection_get_selected_rows (selection,
1387 &model);
1388
1389 treepath = g_list_nth_data(list, 0);
1390
1391 gtk_tree_model_get_iter (GTK_TREE_MODEL(priv->_liststore_reflections),
1392 &iter, treepath);
1393
1394 gtk_tree_model_get (GTK_TREE_MODEL(priv->_liststore_reflections),
1395 &iter,
1396 REFLECTION_COL_REFLECTION, &reflection,
1397 -1);
1398
1399 hkl_geometry_set (priv->diffractometer->geometry,
1400 hkl_sample_reflection_geometry_get(reflection));
1401
1402 update_source (self);
1403
1404 update_axes (self);
1405
1406 update_pseudo_axes (self);
1407
1408 g_list_free_full (list, (GDestroyNotify) gtk_tree_path_free);
1409 } else
1410 if (nb_rows > 1)
1411 gtk_statusbar_push (priv->_statusbar, 0,
1412 "Please select only one reflection.");
1413 else
1414 gtk_statusbar_push (priv->_statusbar, 0,
1415 "Please select at least one reflection.");
1416 }
1417 }
1418
1419 static void
1420 _del_reflection(gpointer data, gpointer user_data)
1421 {
1422 HklSampleReflection *reflection;
1423 GtkTreeIter iter = {0};
1424 GtkTreePath *treepath = data;
1425 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(user_data);
1426
1427 gtk_tree_model_get_iter (GTK_TREE_MODEL(priv->_liststore_reflections),
1428 &iter, treepath);
1429
1430 gtk_tree_model_get (GTK_TREE_MODEL(priv->_liststore_reflections),
1431 &iter,
1432 REFLECTION_COL_REFLECTION, &reflection,
1433 -1);
1434 hkl_sample_del_reflection(priv->sample, reflection);
1435 }
1436
1437 void
1438 hkl_gui_window_toolbutton_del_reflection_clicked_cb (GtkToolButton* _sender, gpointer user_data)
1439 {
1440 HklGuiWindow *self = HKL_GUI_WINDOW(user_data);
1441 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(user_data);
1442 HklSample* sample = NULL;
1443
1444 g_return_if_fail (self != NULL);
1445
1446 if (priv->sample) {
1447 GtkTreeSelection* selection = NULL;
1448 guint nb_rows = 0U;
1449
1450 selection = gtk_tree_view_get_selection (priv->_treeview_reflections);
1451 nb_rows = gtk_tree_selection_count_selected_rows (selection);
1452 if (nb_rows > 0) {
1453 GtkTreeModel* model = NULL;
1454 GList* list;
1455 guint* indexes;
1456 gint i;
1457 GtkMessageDialog* dialog;
1458
1459 model = GTK_TREE_MODEL(priv->_liststore_reflections);
1460 list = gtk_tree_selection_get_selected_rows (selection, &model);
1461
1462
1463 dialog = GTK_MESSAGE_DIALOG(
1464 gtk_message_dialog_new (NULL,
1465 GTK_DIALOG_DESTROY_WITH_PARENT,
1466 GTK_MESSAGE_WARNING,
1467 GTK_BUTTONS_YES_NO,
1468 "Are you sure that you want to delete reflections"));
1469
1470 switch (gtk_dialog_run (GTK_DIALOG(dialog))) {
1471 case GTK_RESPONSE_YES:
1472 {
1473 g_list_foreach(list, _del_reflection, self);
1474 update_reflections (self);
1475 break;
1476 }
1477 default:
1478 break;
1479 }
1480 gtk_widget_destroy (GTK_WIDGET(dialog));
1481 g_list_free_full (list, (GDestroyNotify) gtk_tree_path_free);
1482 } else {
1483 gtk_statusbar_push (priv->_statusbar, 0,
1484 "Please select at least one reflection.");
1485 }
1486 }
1487 }
1488
1489 static void
1490 set_up_tree_view_reflections(HklGuiWindow *self)
1491 {
1492 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
1493 GtkTreeSelection* selection = NULL;
1494
1495 selection = gtk_tree_view_get_selection (priv->_treeview_reflections);
1496 gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
1497 }
1498
1499 /* crystal name */
1500 void
1501 hkl_gui_window_cellrenderertext10_edited_cb(GtkCellRendererText* _sender, const gchar* path,
1502 const gchar* new_text, gpointer user_data)
1503 {
1504 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(user_data);
1505
1506 GtkTreeModel* model = NULL;
1507 GtkTreeIter iter = {0};
1508 HklSample* sample = NULL;
1509 gchar* name = NULL;
1510
1511 g_return_if_fail (user_data != NULL);
1512 g_return_if_fail (path != NULL);
1513 g_return_if_fail (new_text != NULL);
1514
1515 model = GTK_TREE_MODEL(priv->_liststore_crystals);
1516
1517 gtk_tree_model_get_iter_from_string (model, &iter, path);
1518
1519 gtk_tree_model_get (model, &iter,
1520 SAMPLE_COL_SAMPLE, &sample,
1521 -1);
1522
1523 hkl_sample_name_set (sample, new_text);
1524
1525 gtk_list_store_set(priv->_liststore_crystals, &iter,
1526 SAMPLE_COL_NAME, new_text,
1527 -1);
1528 }
1529
1530 #define set_lattice(lattice, parameter) do{ \
1531 const HklParameter *p; \
1532 gdouble min, max, value; \
1533 gboolean fit; \
1534 p = hkl_lattice_## parameter ##_get((lattice)); \
1535 value = hkl_parameter_value_unit_get(p); \
1536 hkl_parameter_min_max_unit_get(p, &min, &max); \
1537 fit = hkl_parameter_fit_get(p); \
1538 gtk_spin_button_set_value(priv->_spinbutton_## parameter, value); \
1539 gtk_spin_button_set_value(priv->_spinbutton_## parameter ##_min, min); \
1540 gtk_spin_button_set_value(priv->_spinbutton_## parameter ##_max, max); \
1541 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(priv->_checkbutton_ ## parameter), fit); \
1542 }while(0)
1543
1544 static void
1545 update_lattice (HklGuiWindow* self)
1546 {
1547 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
1548
1549 g_return_if_fail (self != NULL);
1550
1551 if (priv->sample != NULL) {
1552 const HklLattice *lattice;
1553 lattice = hkl_sample_lattice_get(priv->sample);
1554 set_lattice(lattice, a);
1555 set_lattice(lattice, b);
1556 set_lattice(lattice, c);
1557 set_lattice(lattice, alpha);
1558 set_lattice(lattice, beta);
1559 set_lattice(lattice, gamma);
1560 }
1561 }
1562
1563 #define set_reciprocal_lattice(lattice, parameter) do{ \
1564 const HklParameter *p; \
1565 gdouble value; \
1566 p = hkl_lattice_## parameter ##_get((lattice)); \
1567 value = hkl_parameter_value_unit_get(p); \
1568 gtk_spin_button_set_value(priv->_spinbutton_## parameter ##_star, value); \
1569 }while(0)
1570
1571 static void
1572 update_reciprocal_lattice (HklGuiWindow* self)
1573 {
1574 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
1575
1576 g_return_if_fail (self != NULL);
1577
1578 if (priv->sample != NULL) {
1579 hkl_lattice_reciprocal (hkl_sample_lattice_get(priv->sample),
1580 priv->reciprocal);
1581
1582 set_reciprocal_lattice(priv->reciprocal, a);
1583 set_reciprocal_lattice(priv->reciprocal, b);
1584 set_reciprocal_lattice(priv->reciprocal, c);
1585 set_reciprocal_lattice(priv->reciprocal, alpha);
1586 set_reciprocal_lattice(priv->reciprocal, beta);
1587 set_reciprocal_lattice(priv->reciprocal, gamma);
1588 }
1589 }
1590
1591 #define set_ux_uy_uz(sample, parameter) do { \
1592 const HklParameter *p; \
1593 p = hkl_sample_## parameter ##_get((sample)); \
1594 gboolean fit = hkl_parameter_fit_get(p); \
1595 gtk_spin_button_set_value(priv->_spinbutton_## parameter, \
1596 hkl_parameter_value_unit_get(p)); \
1597 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(priv->_checkbutton_## parameter), fit); \
1598 }while(0)
1599
1600 static void
1601 update_ux_uy_uz (HklGuiWindow* self)
1602 {
1603 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
1604
1605 g_return_if_fail (self != NULL);
1606
1607 if (priv->sample != NULL) {
1608 set_ux_uy_uz(priv->sample, ux);
1609 set_ux_uy_uz(priv->sample, uy);
1610 set_ux_uy_uz(priv->sample, uz);
1611 }
1612 }
1613
1614 #define set_UB(i, j) do{ \
1615 gtk_label_set_markup(priv->_label_UB ## i ## j, \
1616 g_ascii_formatd(text, \
1617 G_ASCII_DTOSTR_BUF_SIZE, \
1618 "<tt> %+.4f </tt>", \
1619 hkl_matrix_get(UB, i - 1, j - 1))); \
1620 }while(0)
1621
1622 static void
1623 update_UB (HklGuiWindow* self)
1624 {
1625 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
1626
1627 g_return_if_fail (self != NULL);
1628
1629 if (priv->sample != NULL) {
1630 const HklMatrix *UB = hkl_sample_UB_get (priv->sample);
1631 gchar *text = g_new0 (gchar, G_ASCII_DTOSTR_BUF_SIZE);
1632
1633 set_UB(1, 1);
1634 set_UB(1, 2);
1635 set_UB(1, 3);
1636 set_UB(2, 1);
1637 set_UB(2, 2);
1638 set_UB(2, 3);
1639 set_UB(3, 1);
1640 set_UB(3, 2);
1641 set_UB(3, 3);
1642
1643 g_free(text);
1644 }
1645 }
1646
1647 void
1648 hkl_gui_window_treeview_crystals_cursor_changed_cb (GtkTreeView* _sender, gpointer user_data)
1649 {
1650 GtkTreePath* path = NULL;
1651 GtkTreeViewColumn* column = NULL;
1652 GtkTreeIter iter = {0};
1653
1654 HklGuiWindow *self = HKL_GUI_WINDOW(user_data);
1655 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(user_data);
1656 HklSample *sample;
1657
1658 g_return_if_fail (user_data != NULL);
1659
1660 gtk_tree_view_get_cursor (priv->_treeview_crystals, &path, &column);
1661 if(path){
1662 if (gtk_tree_model_get_iter (GTK_TREE_MODEL(priv->_liststore_crystals),
1663 &iter, path) == TRUE){
1664 gtk_tree_model_get (GTK_TREE_MODEL(priv->_liststore_crystals),
1665 &iter,
1666 SAMPLE_COL_SAMPLE, &sample,
1667 -1);
1668
1669 if(sample && sample != priv->sample){
1670 priv->sample = sample;
1671
1672 update_reflections(self);
1673 update_lattice(self);
1674 update_reciprocal_lattice (self);
1675 update_ux_uy_uz (self);
1676 update_UB (self);
1677
1678 if(priv->diffractometer){
1679 diffractometer_set_sample(priv->diffractometer,
1680 priv->sample);
1681
1682 update_pseudo_axes (self);
1683 update_pseudo_axes_frames (self);
1684 update_solutions(self);
1685 }
1686 }
1687 }
1688 gtk_tree_path_free (path);
1689 }
1690 }
1691
1692
1693
1694 static GtkTreeIter
1695 _add_sample(HklGuiWindow *self, HklSample *sample)
1696 {
1697 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
1698 GtkTreeIter iter = {0};
1699 const HklLattice *lattice;
1700 gdouble a, b, c, alpha, beta, gamma;
1701
1702 g_return_val_if_fail (self != NULL, iter);
1703
1704 lattice = hkl_sample_lattice_get(sample);
1705 a = hkl_parameter_value_unit_get(hkl_lattice_a_get(lattice));
1706 b = hkl_parameter_value_unit_get(hkl_lattice_b_get(lattice));
1707 c = hkl_parameter_value_unit_get(hkl_lattice_c_get(lattice));
1708 alpha = hkl_parameter_value_unit_get(hkl_lattice_alpha_get(lattice));
1709 beta = hkl_parameter_value_unit_get(hkl_lattice_beta_get(lattice));
1710 gamma = hkl_parameter_value_unit_get(hkl_lattice_gamma_get(lattice));
1711
1712 gtk_list_store_insert_with_values(priv->_liststore_crystals,
1713 &iter, -1,
1714 SAMPLE_COL_SAMPLE, sample,
1715 SAMPLE_COL_NAME, hkl_sample_name_get(sample),
1716 SAMPLE_COL_A, a,
1717 SAMPLE_COL_B, b,
1718 SAMPLE_COL_C, c,
1719 SAMPLE_COL_ALPHA, alpha,
1720 SAMPLE_COL_BETA, beta,
1721 SAMPLE_COL_GAMMA, gamma,
1722 -1);
1723 return iter;
1724 }
1725
1726 static void
1727 set_up_tree_view_crystals (HklGuiWindow* self)
1728 {
1729 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
1730 GtkTreeIter iter = {0};
1731 GtkTreePath *path = NULL;
1732
1733 g_return_if_fail (self != NULL);
1734
1735 iter = _add_sample(self, hkl_sample_new("default"));
1736
1737 path = gtk_tree_model_get_path(GTK_TREE_MODEL(priv->_liststore_crystals),
1738 &iter);
1739
1740 gtk_tree_view_set_cursor(priv->_treeview_crystals, path, NULL, FALSE);
1741
1742 gtk_tree_path_free(path);
1743 }
1744
1745 static void
1746 _add_sample_and_edit_name(HklGuiWindow *self, HklSample *sample)
1747 {
1748 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
1749 GtkTreeIter iter = {0};
1750 GtkTreePath* path = NULL;
1751 GtkTreeViewColumn* column = NULL;
1752
1753 iter = _add_sample(self, sample);
1754
1755 path = gtk_tree_model_get_path(GTK_TREE_MODEL(priv->_liststore_crystals),
1756 &iter);
1757 column = gtk_tree_view_get_column (priv->_treeview_crystals, 0);
1758 gtk_tree_view_set_cursor (priv->_treeview_crystals, path, column, TRUE);
1759
1760 gtk_tree_path_free(path);
1761 }
1762
1763 void
1764 hkl_gui_window_toolbutton_add_crystal_clicked_cb (GtkToolButton* _sender, gpointer user_data)
1765 {
1766 HklGuiWindow *self = HKL_GUI_WINDOW(user_data);
1767 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(user_data);
1768 HklSample *sample;
1769
1770 g_return_if_fail (user_data != NULL);
1771
1772 sample = hkl_sample_new ("new");
1773 if(sample)
1774 _add_sample_and_edit_name(self, sample);
1775 }
1776
1777 void
1778 hkl_gui_window_toolbutton_copy_crystal_clicked_cb (GtkToolButton* _sender, gpointer user_data)
1779 {
1780 HklGuiWindow *self = HKL_GUI_WINDOW(user_data);
1781 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(user_data);
1782 HklSample *copy = NULL;
1783
1784 g_return_if_fail (self != NULL);
1785
1786 if(priv->sample) {
1787 copy = hkl_sample_new_copy(priv->sample);
1788 if (copy)
1789 _add_sample_and_edit_name(self, copy);
1790 }else
1791 gtk_statusbar_push (priv->_statusbar, (guint) 0, "Please select a crystal to copy.");
1792 }
1793
1794 void
1795 hkl_gui_window_toolbutton_del_crystal_clicked_cb (GtkToolButton* _sender, gpointer user_data)
1796 {
1797 HklGuiWindow *self = HKL_GUI_WINDOW(user_data);
1798 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(user_data);
1799
1800 g_return_if_fail (user_data != NULL);
1801
1802 if (priv->sample != NULL) {
1803 guint n_rows;
1804
1805 n_rows = gtk_tree_model_iter_n_children(GTK_TREE_MODEL(priv->_liststore_crystals),
1806 NULL );
1807 if (n_rows == 1)
1808 return;
1809 else {
1810 GtkTreeIter iter = {0};
1811 GtkTreePath *path = NULL;
1812 GtkTreeViewColumn *column = NULL;
1813
1814 gtk_tree_view_get_cursor(priv->_treeview_crystals,
1815 &path, &column);
1816 if (path){
1817 if (gtk_tree_model_get_iter (GTK_TREE_MODEL(priv->_liststore_crystals),
1818 &iter, path) == TRUE) {
1819 gtk_tree_path_free(path);
1820
1821 hkl_sample_free(priv->sample);
1822 if (gtk_list_store_remove(priv->_liststore_crystals,
1823 &iter) == TRUE){
1824 path = gtk_tree_model_get_path(GTK_TREE_MODEL(priv->_liststore_crystals),
1825 &iter);
1826 gtk_tree_view_set_cursor(priv->_treeview_crystals,
1827 path, NULL, FALSE);
1828 }
1829 }
1830 }
1831 }
1832 }
1833 }
1834
1835 #define get_lattice_parameter(lattice, parameter) do{ \
1836 HklParameter *p = hkl_parameter_new_copy(hkl_lattice_## parameter ##_get(lattice)); \
1837 hkl_parameter_min_max_unit_set(p, \
1838 gtk_spin_button_get_value(priv->_spinbutton_## parameter ##_min), \
1839 gtk_spin_button_get_value(priv->_spinbutton_## parameter ##_max)); \
1840 hkl_parameter_fit_set(p, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->_checkbutton_## parameter))); \
1841 hkl_lattice_## parameter ##_set(lattice, p); \
1842 hkl_parameter_free(p); \
1843 } while(0)
1844
1845 #define get_ux_uy_uz(sample, parameter) do { \
1846 HklParameter *p; \
1847 p = hkl_parameter_new_copy(hkl_sample_## parameter ##_get(sample)); \
1848 hkl_parameter_value_unit_set(p, \
1849 gtk_spin_button_get_value (priv->_spinbutton_## parameter), \
1850 NULL); \
1851 hkl_parameter_fit_set(p, \
1852 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->_checkbutton_## parameter))); \
1853 hkl_sample_## parameter ##_set(sample, p); \
1854 hkl_parameter_free(p); \
1855 }while(0)
1856
1857
1858 static gboolean
1859 _update_crystal_model(GtkTreeModel *model,
1860 GtkTreePath *path,
1861 GtkTreeIter *iter,
1862 gpointer data)
1863 {
1864 HklGuiWindow *self = HKL_GUI_WINDOW(data);
1865 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(data);
1866 HklSample *sample = NULL;
1867
1868 gtk_tree_model_get(model, iter,
1869 SAMPLE_COL_SAMPLE, &sample,
1870 -1);
1871 if(priv->sample == sample){
1872 const HklLattice *lattice;
1873 gdouble a, b, c, alpha, beta, gamma;
1874
1875 lattice = hkl_sample_lattice_get(sample);
1876 a = hkl_parameter_value_unit_get(hkl_lattice_a_get(lattice));
1877 b = hkl_parameter_value_unit_get(hkl_lattice_b_get(lattice));
1878 c = hkl_parameter_value_unit_get(hkl_lattice_c_get(lattice));
1879 alpha = hkl_parameter_value_unit_get(hkl_lattice_alpha_get(lattice));
1880 beta = hkl_parameter_value_unit_get(hkl_lattice_beta_get(lattice));
1881 gamma = hkl_parameter_value_unit_get(hkl_lattice_gamma_get(lattice));
1882
1883 gtk_list_store_set(priv->_liststore_crystals,
1884 iter,
1885 SAMPLE_COL_NAME, hkl_sample_name_get(sample),
1886 SAMPLE_COL_A, a,
1887 SAMPLE_COL_B, b,
1888 SAMPLE_COL_C, c,
1889 SAMPLE_COL_ALPHA, alpha,
1890 SAMPLE_COL_BETA, beta,
1891 SAMPLE_COL_GAMMA, gamma,
1892 -1);
1893 return TRUE;
1894 }
1895 return FALSE;
1896 }
1897
1898 static void
1899 update_crystal_model(HklGuiWindow *self)
1900 {
1901 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
1902
1903 gtk_tree_model_foreach(GTK_TREE_MODEL(priv->_liststore_crystals),
1904 _update_crystal_model,
1905 self);
1906 }
1907
1908 /* apply crystal parameters */
1909 void
1910 hkl_gui_window_button2_clicked_cb (GtkButton* _sender, gpointer user_data)
1911 {
1912 HklGuiWindow *self = HKL_GUI_WINDOW(user_data);
1913 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(user_data);
1914
1915 g_return_if_fail (self != NULL);
1916
1917 if (priv->sample != NULL) {
1918 gdouble a, b, c, alpha, beta, gamma;
1919 gdouble ux, uy, uz;
1920 HklLattice *lattice;
1921 HklParameter *p;
1922
1923 fprintf(stderr, "%s\n", __func__);
1924 /* lattice parameters */
1925 a = gtk_spin_button_get_value (priv->_spinbutton_a);
1926 b = gtk_spin_button_get_value (priv->_spinbutton_b);
1927 c = gtk_spin_button_get_value (priv->_spinbutton_c);
1928 alpha = gtk_spin_button_get_value (priv->_spinbutton_alpha);
1929 beta = gtk_spin_button_get_value (priv->_spinbutton_beta);
1930 gamma = gtk_spin_button_get_value (priv->_spinbutton_gamma);
1931
1932 lattice = hkl_lattice_new(a, b, c,
1933 alpha * HKL_DEGTORAD,
1934 beta * HKL_DEGTORAD,
1935 gamma * HKL_DEGTORAD);
1936
1937 get_lattice_parameter(lattice, a);
1938 get_lattice_parameter(lattice, b);
1939 get_lattice_parameter(lattice, c);
1940 get_lattice_parameter(lattice, alpha);
1941 get_lattice_parameter(lattice, beta);
1942 get_lattice_parameter(lattice, gamma);
1943
1944 hkl_sample_lattice_set(priv->sample, lattice);
1945
1946 hkl_lattice_free(lattice);
1947
1948 /* UB */
1949 get_ux_uy_uz(priv->sample, ux);
1950 get_ux_uy_uz(priv->sample, uy);
1951 get_ux_uy_uz(priv->sample, uz);
1952
1953 if(priv->diffractometer)
1954 diffractometer_set_sample(priv->diffractometer,
1955 priv->sample);
1956
1957 update_crystal_model (self);
1958 update_reciprocal_lattice (self);
1959 update_UB (self);
1960 update_pseudo_axes (self);
1961 update_pseudo_axes_frames (self);
1962 }
1963 }
1964
1965 void
1966 hkl_gui_window_spinbutton_lambda_value_changed_cb (GtkSpinButton* _sender, gpointer user_data)
1967 {
1968 HklGuiWindow *self = HKL_GUI_WINDOW(user_data);
1969 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(user_data);
1970
1971 diffractometer_set_wavelength(priv->diffractometer,
1972 gtk_spin_button_get_value(_sender));
1973 update_pseudo_axes (self);
1974 update_pseudo_axes_frames (self);
1975 }
1976
1977 void
1978 hkl_gui_window_spinbutton_ux_value_changed_cb (GtkSpinButton *_senser, gpointer user_data)
1979 {
1980 HklGuiWindow *self = HKL_GUI_WINDOW(user_data);
1981 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(user_data);
1982
1983 get_ux_uy_uz(priv->sample, ux);
1984
1985 if(priv->diffractometer)
1986 diffractometer_set_sample(priv->diffractometer,
1987 priv->sample);
1988
1989 update_UB (self);
1990 update_pseudo_axes (self);
1991 update_pseudo_axes_frames (self);
1992 }
1993
1994 void
1995 hkl_gui_window_spinbutton_uy_value_changed_cb (GtkSpinButton *_senser, gpointer user_data)
1996 {
1997 HklGuiWindow *self = HKL_GUI_WINDOW(user_data);
1998 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(user_data);
1999
2000 get_ux_uy_uz(priv->sample, uy);
2001
2002 if(priv->diffractometer)
2003 diffractometer_set_sample(priv->diffractometer,
2004 priv->sample);
2005
2006 update_UB (self);
2007 update_pseudo_axes (self);
2008 update_pseudo_axes_frames (self);
2009 }
2010
2011 void
2012 hkl_gui_window_spinbutton_uz_value_changed_cb (GtkSpinButton *_senser, gpointer user_data)
2013 {
2014 HklGuiWindow *self = HKL_GUI_WINDOW(user_data);
2015 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(user_data);
2016
2017 get_ux_uy_uz(priv->sample, uz);
2018
2019 if(priv->diffractometer)
2020 diffractometer_set_sample(priv->diffractometer,
2021 priv->sample);
2022
2023 update_UB (self);
2024 update_pseudo_axes (self);
2025 update_pseudo_axes_frames (self);
2026 }
2027
2028 void
2029 hkl_gui_window_toolbutton_setUB_clicked_cb(GtkToolButton* _sender, gpointer user_data)
2030 {
2031 HklGuiWindow *self = HKL_GUI_WINDOW(user_data);
2032 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(user_data);
2033
2034 HklMatrix *UB;
2035
2036 UB = hkl_matrix_new_full(gtk_spin_button_get_value(priv->_spinbutton_U11),
2037 gtk_spin_button_get_value(priv->_spinbutton_U12),
2038 gtk_spin_button_get_value(priv->_spinbutton_U13),
2039 gtk_spin_button_get_value(priv->_spinbutton_U21),
2040 gtk_spin_button_get_value(priv->_spinbutton_U22),
2041 gtk_spin_button_get_value(priv->_spinbutton_U23),
2042 gtk_spin_button_get_value(priv->_spinbutton_U31),
2043 gtk_spin_button_get_value(priv->_spinbutton_U32),
2044 gtk_spin_button_get_value(priv->_spinbutton_U33));
2045
2046 hkl_sample_UB_set (priv->sample, UB, NULL);
2047 if(priv->diffractometer)
2048 diffractometer_set_sample(priv->diffractometer,
2049 priv->sample);
2050
2051 update_lattice (self);
2052 update_crystal_model (self);
2053 update_reciprocal_lattice (self);
2054 update_UB (self);
2055 update_ux_uy_uz (self);
2056 update_pseudo_axes (self);
2057 update_pseudo_axes_frames (self);
2058
2059 hkl_matrix_free(UB);
2060 }
2061
2062 void
2063 hkl_gui_window_toolbutton_computeUB_clicked_cb (GtkToolButton* _sender, gpointer user_data)
2064 {
2065 HklGuiWindow *self = HKL_GUI_WINDOW(user_data);
2066 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(user_data);
2067 GtkTreeSelection* selection = NULL;
2068 guint nb_rows = 0U;
2069
2070 selection = gtk_tree_view_get_selection (priv->_treeview_reflections);
2071 nb_rows = gtk_tree_selection_count_selected_rows (selection);
2072 if (nb_rows > 1) {
2073 GtkTreeModel* model = NULL;
2074 GList* list;
2075 GtkTreeIter iter = {0};
2076 GtkTreePath *path;
2077 HklSampleReflection *ref1, *ref2;
2078
2079 model = GTK_TREE_MODEL(priv->_liststore_reflections);
2080 list = gtk_tree_selection_get_selected_rows (selection, &model);
2081
2082 /* get the first reflection */
2083 path = g_list_nth_data(list, 0);
2084 gtk_tree_model_get_iter (GTK_TREE_MODEL(priv->_liststore_reflections),
2085 &iter,
2086 path);
2087 gtk_tree_model_get (GTK_TREE_MODEL(priv->_liststore_reflections), &iter,
2088 REFLECTION_COL_REFLECTION, &ref1,
2089 -1);
2090
2091 /* get the second one */
2092 path = g_list_nth_data(list, 1);
2093 gtk_tree_model_get_iter (GTK_TREE_MODEL(priv->_liststore_reflections),
2094 &iter,
2095 path);
2096 gtk_tree_model_get (GTK_TREE_MODEL(priv->_liststore_reflections), &iter,
2097 REFLECTION_COL_REFLECTION, &ref2,
2098 -1);
2099
2100 hkl_sample_compute_UB_busing_levy(priv->sample,
2101 ref1, ref2);
2102
2103 if(priv->diffractometer)
2104 diffractometer_set_sample(priv->diffractometer,
2105 priv->sample);
2106
2107 update_UB (self);
2108 update_ux_uy_uz (self);
2109 update_pseudo_axes (self);
2110 update_pseudo_axes_frames (self);
2111
2112 g_list_free_full (list, (GDestroyNotify) gtk_tree_path_free);
2113 } else {
2114 gtk_statusbar_push (priv->_statusbar, 0,
2115 "Please select at least two reflection.");
2116 }
2117 }
2118
2119 void
2120 hkl_gui_window_toolbutton_affiner_clicked_cb (GtkToolButton* _sender, gpointer user_data)
2121 {
2122 HklGuiWindow *self = HKL_GUI_WINDOW(user_data);
2123 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(user_data);
2124
2125 hkl_sample_affine (priv->sample);
2126 if(priv->diffractometer)
2127 diffractometer_set_sample(priv->diffractometer,
2128 priv->sample);
2129
2130 update_lattice (self);
2131 update_crystal_model (self);
2132 update_reciprocal_lattice (self);
2133 update_UB (self);
2134 update_ux_uy_uz (self);
2135 update_pseudo_axes (self);
2136 update_pseudo_axes_frames (self);
2137 }
2138
2139 #define toggle_lattice(parameter) do{ \
2140 HklGuiWindow *self = HKL_GUI_WINDOW(user_data); \
2141 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(user_data); \
2142 HklLattice *lattice; \
2143 HklParameter *p; \
2144 lattice = hkl_lattice_new_copy(hkl_sample_lattice_get(priv->sample)); \
2145 p = hkl_parameter_new_copy(hkl_lattice_## parameter ##_get(lattice)); \
2146 hkl_parameter_fit_set(p, \
2147 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(checkbutton))); \
2148 hkl_lattice_## parameter ##_set(lattice, p); \
2149 hkl_sample_lattice_set(priv->sample, lattice); \
2150 }while(0)
2151
2152 void
2153 hkl_gui_window_checkbutton_a_toggled_cb(GtkCheckButton *checkbutton,
2154 gpointer user_data)
2155 {
2156 toggle_lattice(a);
2157 }
2158
2159 void
2160 hkl_gui_window_checkbutton_b_toggled_cb(GtkCheckButton *checkbutton,
2161 gpointer user_data)
2162 {
2163 toggle_lattice(b);
2164 }
2165
2166 void
2167 hkl_gui_window_checkbutton_c_toggled_cb(GtkCheckButton *checkbutton,
2168 gpointer user_data)
2169 {
2170 toggle_lattice(c);
2171 }
2172
2173 void
2174 hkl_gui_window_checkbutton_alpha_toggled_cb(GtkCheckButton *checkbutton,
2175 gpointer user_data)
2176 {
2177 toggle_lattice(alpha);
2178 }
2179
2180 void
2181 hkl_gui_window_checkbutton_beta_toggled_cb(GtkCheckButton *checkbutton,
2182 gpointer user_data)
2183 {
2184 toggle_lattice(beta);
2185 }
2186
2187 void
2188 hkl_gui_window_checkbutton_gamma_toggled_cb(GtkCheckButton *checkbutton,
2189 gpointer user_data)
2190 {
2191 toggle_lattice(gamma);
2192 }
2193
2194 /*
2195
2196 static gboolean _hkl_gui_window_on_tree_view_crystals_key_press_event_gtk_widget_key_press_event (GtkWidget* _sender, GdkEventKey* event, gpointer self) {
2197 gboolean result;
2198 result = hkl_gui_window_on_tree_view_crystals_key_press_event (event, self);
2199
2200 return result;
2201
2202 }
2203
2204 static void hkl_gui_window_set_up_3D (HklGuiWindow* self) {
2205 HklGeometry* _tmp0_;
2206 HklGeometryConfig* _tmp1_;
2207 HklGeometryType _tmp2_;
2208 GtkVBox* _tmp7_;
2209 HklGui3DFrame* _tmp8_;
2210 GtkFrame* _tmp9_ = NULL;
2211 GtkFrame* _tmp10_;
2212 GtkVBox* _tmp11_;
2213
2214 g_return_if_fail (self != NULL);
2215
2216 _tmp0_ = priv->geometry;
2217
2218 _tmp1_ = _tmp0_->config;
2219
2220 _tmp2_ = (*_tmp1_).type;
2221
2222 switch (_tmp2_) {
2223
2224 case HKL_GEOMETRY_TYPE_KAPPA6C:
2225
2226 {
2227 HklGeometry* _tmp3_;
2228 HklGui3DFrame* _tmp4_;
2229
2230 _tmp3_ = priv->geometry;
2231
2232 _tmp4_ = hkl_gui_3d_frame_new ("../data/diffabs.yaml", _tmp3_);
2233
2234 _g_object_unref0 (priv->Frame3D);
2235
2236 priv->Frame3D = _tmp4_;
2237
2238 break;
2239
2240 }
2241
2242 case HKL_GEOMETRY_TYPE_KAPPA4C_VERTICAL:
2243
2244 {
2245 HklGeometry* _tmp5_;
2246 HklGui3DFrame* _tmp6_;
2247
2248 _tmp5_ = priv->geometry;
2249
2250 _tmp6_ = hkl_gui_3d_frame_new ("../data/cristal4C.yaml", _tmp5_);
2251
2252 _g_object_unref0 (priv->Frame3D);
2253
2254 priv->Frame3D = _tmp6_;
2255
2256 break;
2257
2258 }
2259 default:
2260
2261 break;
2262
2263 }
2264
2265 _tmp7_ = priv->_vbox7;
2266
2267 _tmp8_ = priv->Frame3D;
2268
2269 _tmp9_ = hkl_gui_3d_frame_frame (_tmp8_);
2270
2271 _tmp10_ = _tmp9_;
2272
2273 gtk_box_pack_start ((GtkBox*) _tmp7_, (GtkWidget*) _tmp10_, TRUE, TRUE, (guint) 0);
2274
2275 _g_object_unref0 (_tmp10_);
2276
2277 _tmp11_ = priv->_vbox7;
2278
2279 gtk_widget_show_all ((GtkWidget*) _tmp11_);
2280
2281 }
2282
2283 static void hkl_gui_window_on_checkbutton_Ux_toggled (HklGuiWindow* self) {
2284 HklSampleList* _tmp0_;
2285 HklSample* _tmp1_;
2286 HklSample* sample;
2287 HklSample* _tmp2_;
2288
2289 g_return_if_fail (self != NULL);
2290
2291 _tmp0_ = priv->samples;
2292
2293 _tmp1_ = _tmp0_->current;
2294
2295 sample = _tmp1_;
2296
2297 _tmp2_ = sample;
2298
2299 if (_tmp2_ != NULL) {
2300
2301 HklSample* _tmp3_;
2302 HklParameter* _tmp4_;
2303 GtkCheckButton* _tmp5_;
2304 gboolean _tmp6_ = FALSE;
2305
2306 _tmp3_ = sample;
2307
2308 _tmp4_ = _tmp3_->ux;
2309
2310 _tmp5_ = priv->_checkbutton_Ux;
2311
2312 _tmp6_ = gtk_toggle_button_get_active ((GtkToggleButton*) _tmp5_);
2313
2314 (*_tmp4_).fit = _tmp6_;
2315
2316 }
2317 }
2318
2319
2320 static void hkl_gui_window_on_checkbutton_Uy_toggled (HklGuiWindow* self) {
2321 HklSampleList* _tmp0_;
2322 HklSample* _tmp1_;
2323 HklSample* sample;
2324 HklSample* _tmp2_;
2325
2326 g_return_if_fail (self != NULL);
2327
2328 _tmp0_ = priv->samples;
2329
2330 _tmp1_ = _tmp0_->current;
2331
2332 sample = _tmp1_;
2333
2334 _tmp2_ = sample;
2335
2336 if (_tmp2_ != NULL) {
2337
2338 HklSample* _tmp3_;
2339 HklParameter* _tmp4_;
2340 GtkCheckButton* _tmp5_;
2341 gboolean _tmp6_ = FALSE;
2342
2343 _tmp3_ = sample;
2344
2345 _tmp4_ = _tmp3_->uy;
2346
2347 _tmp5_ = priv->_checkbutton_Uy;
2348
2349 _tmp6_ = gtk_toggle_button_get_active ((GtkToggleButton*) _tmp5_);
2350
2351 (*_tmp4_).fit = _tmp6_;
2352
2353 }
2354 }
2355
2356
2357 static void hkl_gui_window_on_checkbutton_Uz_toggled (HklGuiWindow* self) {
2358 HklSampleList* _tmp0_;
2359 HklSample* _tmp1_;
2360 HklSample* sample;
2361 HklSample* _tmp2_;
2362
2363 g_return_if_fail (self != NULL);
2364
2365 _tmp0_ = priv->samples;
2366
2367 _tmp1_ = _tmp0_->current;
2368
2369 sample = _tmp1_;
2370
2371 _tmp2_ = sample;
2372
2373 if (_tmp2_ != NULL) {
2374
2375 HklSample* _tmp3_;
2376 HklParameter* _tmp4_;
2377 GtkCheckButton* _tmp5_;
2378 gboolean _tmp6_ = FALSE;
2379
2380 _tmp3_ = sample;
2381
2382 _tmp4_ = _tmp3_->uz;
2383
2384 _tmp5_ = priv->_checkbutton_Uz;
2385
2386 _tmp6_ = gtk_toggle_button_get_active ((GtkToggleButton*) _tmp5_);
2387
2388 (*_tmp4_).fit = _tmp6_;
2389
2390 }
2391 }
2392
2393 static void hkl_gui_window_on_cell_tree_view_pseudo_axes_is_initialized_toggled (const gchar* path, HklGuiWindow* self) {
2394 GtkTreeModel* model = NULL;
2395 GtkTreeIter iter = {0};
2396 HklPseudoAxis* pseudoAxis = NULL;
2397 gboolean old_flag = FALSE;
2398 GtkTreeView* _tmp0_;
2399 GtkTreeModel* _tmp1_ = NULL;
2400 GtkTreeModel* _tmp2_;
2401 GtkTreeModel* _tmp3_;
2402 const gchar* _tmp4_;
2403 GtkTreeIter _tmp5_ = {0};
2404 GtkTreeModel* _tmp6_;
2405 GtkTreeIter _tmp7_;
2406 gboolean _tmp8_;
2407
2408 g_return_if_fail (self != NULL);
2409
2410 g_return_if_fail (path != NULL);
2411
2412 _tmp0_ = priv->_treeview_pseudo_axes;
2413
2414 _tmp1_ = gtk_tree_view_get_model (_tmp0_);
2415
2416 _tmp2_ = _g_object_ref0 (_tmp1_);
2417
2418 _g_object_unref0 (model);
2419
2420 model = _tmp2_;
2421
2422 _tmp3_ = model;
2423
2424 _tmp4_ = path;
2425
2426 gtk_tree_model_get_iter_from_string (_tmp3_, &_tmp5_, _tmp4_);
2427
2428 iter = _tmp5_;
2429
2430 _tmp6_ = model;
2431
2432 _tmp7_ = iter;
2433
2434 gtk_tree_model_get (_tmp6_, &_tmp7_, PSEUDO_AXIS_COL_PSEUDOAXIS, &pseudoAxis, PSEUDO_AXIS_COL_INITIALIZED, &old_flag, -1);
2435
2436 _tmp8_ = old_flag;
2437
2438 if (!_tmp8_) {
2439
2440 HklPseudoAxis* _tmp9_;
2441 HklPseudoAxisEngine* _tmp10_;
2442 gboolean _tmp11_ = FALSE;
2443
2444 _tmp9_ = pseudoAxis;
2445
2446 _tmp10_ = _tmp9_->engine;
2447
2448 _tmp11_ = hkl_pseudo_axis_engine_initialize (_tmp10_, NULL);
2449
2450 if (_tmp11_) {
2451
2452 hkl_gui_window_update_pseudo_axes (self);
2453
2454 }
2455 }
2456
2457 _g_object_unref0 (model);
2458
2459 }
2460
2461 static gboolean hkl_gui_window_on_tree_view_crystals_key_press_event (GdkEventKey* event, HklGuiWindow* self) {
2462 gboolean result = FALSE;
2463
2464 g_return_val_if_fail (self != NULL, FALSE);
2465
2466 g_return_val_if_fail (event != NULL, FALSE);
2467
2468 result = TRUE;
2469
2470 return result;
2471
2472 }
2473
2474
2475 static void hkl_gui_window_on_menuitem5_activate (HklGuiWindow* self) {
2476 GtkDialog* _tmp0_;
2477
2478 g_return_if_fail (self != NULL);
2479
2480 _tmp0_ = priv->_dialog1;
2481
2482 gtk_widget_show ((GtkWidget*) _tmp0_);
2483
2484 }
2485
2486
2487 void hkl_gui_window_on_button1_clicked (HklGuiWindow* self) {
2488 GtkDialog* _tmp0_;
2489
2490 g_return_if_fail (self != NULL);
2491
2492 _tmp0_ = priv->_dialog1;
2493
2494 gtk_widget_hide ((GtkWidget*) _tmp0_);
2495
2496 }
2497
2498 */
2499
2500 static void
2501 hkl_gui_window_class_init (HklGuiWindowClass *class)
2502 {
2503 GObjectClass *gobject_class = G_OBJECT_CLASS (class);
2504
2505 g_type_class_add_private (class, sizeof (HklGuiWindowPrivate));
2506
2507 /* virtual method */
2508 gobject_class->finalize = finalize;
2509 }
2510
2511
2512 static void hkl_gui_window_init (HklGuiWindow * self)
2513 {
2514 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(self);
2515
2516 priv->diffractometer = NULL;
2517 priv->sample = NULL;
2518
2519 darray_init(priv->pseudo_frames);
2520
2521 priv->reciprocal = hkl_lattice_new_default ();
2522
2523 hkl_gui_window_get_widgets_and_objects_from_ui (self);
2524
2525 set_up_diffractometer_model (self);
2526
2527 set_up_tree_view_crystals (self);
2528
2529 set_up_tree_view_reflections(self);
2530 }
2531
2532 int main (int argc, char ** argv)
2533 {
2534 gtk_init (&argc, &argv);
2535
2536 hkl_gui_window_new ();
2537
2538 gtk_main ();
2539
2540 return 0;
2541 }
Diffractometer computation library