1 /* This file is part of the hkl library.
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.
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.
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/>.
16 * Copyright (C) 2003-2014 Synchrotron SOLEIL
17 * L'Orme des Merisiers Saint-Aubin
18 * BP 48 91192 GIF-sur-YVETTE CEDEX
20 * Authors: Picca Frédéric-Emmanuel <picca@synchrotron-soleil.fr>
25 #include <glib-object.h>
28 #include "hkl-gui-pseudoaxes.h"
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))
43 #define EMBED_BREAKPOINT asm volatile ("int3;")
45 G_DEFINE_TYPE (HklGuiWindow
, hkl_gui_window
, G_TYPE_OBJECT
);
48 REFLECTION_COL_INDEX
= 0,
53 REFLECTION_COL_REFLECTION
,
54 REFLECTION_COL_N_COLUMNS
68 PSEUDO_AXIS_COL_PARAMETER
= 0,
69 PSEUDO_AXIS_COL_ENGINE
,
72 PSEUDO_AXIS_COL_WRITE
,
73 PSEUDO_AXIS_COL_N_COLUMNS
77 PARAMETER_COL_PARAMETER
= 0,
80 PARAMETER_COL_N_COLUMNS
84 SAMPLE_COL_SAMPLE
= 0,
96 SOLUTION_COL_INDEX
= 0,
97 SOLUTION_COL_N_COLUMNS
101 DIFFRACTOMETER_COL_NAME
= 0,
102 DIFFRACTOMETER_COL_FACTORY
,
103 DIFFRACTOMETER_COL_DIFFRACTOMETER
,
104 DIFFRACTOMETER_COL_N_COLUMNS
111 struct diffractometer_t
{
112 HklGeometry
*geometry
;
113 HklDetector
*detector
;
114 HklEngineList
*engines
;
118 static struct diffractometer_t
*
119 create_diffractometer(HklFactory
*factory
)
121 struct diffractometer_t
*self
;
123 self
= malloc(sizeof(*self
));
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);
134 delete_diffractometer(struct diffractometer_t
*self
)
136 hkl_geometry_free(self
->geometry
);
137 hkl_engine_list_free(self
->engines
);
138 hkl_detector_free(self
->detector
);
143 dump_diffractometer(struct diffractometer_t
*self
)
145 /* hkl_geometry_fprintf(stderr, self->geometry); */
146 /* hkl_engine_list_fprintf(stderr, self->engines); */
147 /* hkl_detector_fprintf(stderr, self->detector); */
151 diffractometer_set_sample(struct diffractometer_t
*self
,
154 hkl_engine_list_init(self
->engines
,
158 hkl_engine_list_get(self
->engines
);
162 diffractometer_set_wavelength(struct diffractometer_t
*self
,
165 hkl_geometry_wavelength_set(self
->geometry
,
167 hkl_engine_list_get(self
->engines
);
174 struct _HklGuiWindowPrivate
{
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
;
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 */
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
;
261 GtkInfoBar
*info_bar
;
262 GtkLabel
*info_message
;
264 darray(HklGuiEngine
*) pseudo_frames
;
266 struct diffractometer_t
*diffractometer
; /* unowned */
267 HklSample
*sample
; /* unowned */
268 HklLattice
*reciprocal
;
271 #define HKL_GUI_WINDOW_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), HKL_GUI_TYPE_WINDOW, HklGuiWindowPrivate))
274 finalize_liststore_diffractometer(GtkTreeModel
*model
,
279 struct diffractometer_t
*diffractometer
;
281 gtk_tree_model_get(model
, iter
,
282 DIFFRACTOMETER_COL_DIFFRACTOMETER
, &diffractometer
,
284 delete_diffractometer(diffractometer
);
289 finalize_liststore_samples(GtkTreeModel
*model
,
294 HklSample
*sample
= NULL
;
296 gtk_tree_model_get(model
, iter
,
297 SAMPLE_COL_SAMPLE
, &sample
,
299 hkl_sample_free(sample
);
304 finalize (GObject
* object
)
306 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(object
);
308 g_object_unref(priv
->builder
);
310 darray_free(priv
->pseudo_frames
);
312 gtk_tree_model_foreach(GTK_TREE_MODEL(priv
->_liststore_diffractometer
),
313 finalize_liststore_diffractometer
,
316 gtk_tree_model_foreach(GTK_TREE_MODEL(priv
->_liststore_crystals
),
317 finalize_liststore_samples
,
320 G_OBJECT_CLASS (hkl_gui_window_parent_class
)->finalize (object
);
323 HklGuiWindow
* hkl_gui_window_new (void)
325 return g_object_new (HKL_GUI_TYPE_WINDOW
, NULL
);
329 #define get_object(builder, type, priv, name) priv->_ ## name = type(gtk_builder_get_object(builder, #name))
332 hkl_gui_window_get_widgets_and_objects_from_ui (HklGuiWindow
* self
)
334 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
337 g_return_if_fail (self
!= NULL
);
339 priv
->builder
= builder
= gtk_builder_new ();
340 gtk_builder_add_from_file (builder
, "ghkl.ui", NULL
);
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
);
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
);
358 get_object(builder
, GTK_BUTTON
, priv
, button2
);
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
);
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
);
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
);
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
);
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
);
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
);
390 get_object(builder
, GTK_SPIN_BUTTON
, priv
, spinbutton_lambda
);
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
);
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
);
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
);
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
);
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
);
434 get_object(builder
, GTK_STATUSBAR
, priv
, statusbar
);
436 get_object(builder
, GTK_IMAGE_MENU_ITEM
, priv
, menuitem5
);
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
);
442 get_object(builder
, GTK_DIALOG
, priv
, dialog1
);
444 get_object(builder
, GTK_COMBO_BOX
, priv
, combobox1
);
446 gtk_builder_connect_signals (builder
, self
);
450 update_pseudo_axes_frames (HklGuiWindow
* self
)
452 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
453 HklGuiEngine
**engine
;
455 g_return_if_fail (self
!= NULL
);
457 darray_foreach(engine
, priv
->pseudo_frames
){
458 hkl_gui_engine_update(*engine
);
463 raise_error(HklGuiWindow
*self
, HklError
**error
)
465 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
467 g_return_if_fail (self
!= NULL
);
468 g_return_if_fail (error
!= NULL
);
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
,
475 gtk_widget_show (GTK_WIDGET(priv
->info_bar
));
477 hkl_error_clear(error
);
481 clear_error(HklGuiWindow
*self
, HklError
**error
)
483 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
485 g_return_if_fail (self
!= NULL
);
487 gtk_widget_hide(GTK_WIDGET(priv
->info_bar
));
491 _update_axis (GtkTreeModel
*model
, GtkTreePath
*path
,
492 GtkTreeIter
*iter
, gpointer data
)
494 HklParameter
*parameter
;
495 gdouble value
, min
, max
;
497 gtk_tree_model_get (model
, iter
,
498 AXIS_COL_AXIS
, ¶meter
,
501 hkl_parameter_min_max_unit_get(parameter
, &min
, &max
);
502 value
= hkl_parameter_value_unit_get(parameter
);
504 gtk_list_store_set(GTK_LIST_STORE(model
), iter
,
505 AXIS_COL_READ
, value
,
506 AXIS_COL_WRITE
, value
,
514 update_axes (HklGuiWindow
* self
)
516 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
518 g_return_if_fail (self
!= NULL
);
520 gtk_tree_model_foreach(GTK_TREE_MODEL(priv
->_liststore_axis
),
526 _update_pseudo_axes (GtkTreeModel
*model
, GtkTreePath
*path
,
527 GtkTreeIter
*iter
, gpointer data
)
529 HklParameter
*parameter
;
530 gdouble value
, min
, max
;
532 gtk_tree_model_get (model
, iter
,
533 PSEUDO_AXIS_COL_PARAMETER
, ¶meter
,
536 hkl_parameter_min_max_unit_get(parameter
, &min
, &max
);
537 value
= hkl_parameter_value_unit_get(parameter
);
539 gtk_list_store_set(GTK_LIST_STORE(model
), iter
,
540 PSEUDO_AXIS_COL_READ
, value
,
541 PSEUDO_AXIS_COL_WRITE
, value
,
547 update_pseudo_axes (HklGuiWindow
* self
)
549 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
551 g_return_if_fail (self
!= NULL
);
553 gtk_tree_model_foreach(GTK_TREE_MODEL(priv
->_liststore_pseudo_axes
),
559 update_solutions (HklGuiWindow
* self
)
561 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
562 const HklGeometryList
*geometries
;
563 const darray_item
*items
;
564 GtkTreeIter iter
= {0};
566 g_return_if_fail (self
!= NULL
);
568 if(priv
->diffractometer
){
569 geometries
= hkl_engine_list_geometries(priv
->diffractometer
->engines
);
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
);
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
);
584 for(i
=0; i
<darray_size(*items
);++i
){
586 const HklGeometry
*geometry
;
587 HklParameter
**parameter
;
588 const darray_parameter
*parameters
;
590 geometry
= hkl_geometry_list_item_geometry_get(darray_item(*items
, i
));
591 parameters
= hkl_geometry_axes_get(geometry
);
593 g_value_set_int(&values
[column
], i
);
596 darray_foreach(parameter
, *parameters
){
597 double value
= hkl_parameter_value_unit_get(*parameter
);
600 g_value_set_double(&values
[column
], value
);
601 columns
[column
] = column
;
603 gtk_list_store_insert_with_valuesv(priv
->_liststore_solutions
,
605 columns
, values
, n_values
);
614 update_source (HklGuiWindow
* self
)
616 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
618 g_return_if_fail (self
!= NULL
);
620 gtk_spin_button_set_value (priv
->_spinbutton_lambda
,
621 hkl_geometry_wavelength_get(priv
->diffractometer
->geometry
));
625 update_reflections (HklGuiWindow
*self
)
627 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
629 gtk_list_store_clear (priv
->_liststore_reflections
);
632 HklSampleReflection
* reflection
= NULL
;
635 reflection
= hkl_sample_first_reflection_get(priv
->sample
);
637 GtkTreeIter iter
= {0};
641 hkl_sample_reflection_hkl_get(reflection
, &h
, &k
, &l
);
642 flag
= hkl_sample_reflection_flag_get(reflection
);
644 gtk_list_store_append (priv
->_liststore_reflections
, &iter
);
646 gtk_list_store_set (priv
->_liststore_reflections
,
648 REFLECTION_COL_INDEX
, index
++,
652 REFLECTION_COL_FLAG
, flag
,
653 REFLECTION_COL_REFLECTION
, reflection
,
655 reflection
= hkl_sample_next_reflection_get(priv
->sample
,
662 hkl_engine_to_axes(HklGuiWindow
*self
, HklEngine
*engine
)
664 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
665 HklError
*error
= NULL
;
668 g_return_val_if_fail (self
!= NULL
, FALSE
);
669 g_return_val_if_fail (engine
!= NULL
, FALSE
);
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
);
677 update_pseudo_axes (self
);
678 update_pseudo_axes_frames (self
);
680 raise_error(self
, &error
);
681 dump_diffractometer(priv
->diffractometer
);
684 update_solutions (self
);
689 pseudo_axes_frame_changed_cb (HklGuiEngine
*gui_engine
, HklGuiWindow
*self
)
693 g_return_if_fail (self
!= NULL
);
695 g_object_get(G_OBJECT(gui_engine
),
699 hkl_engine_to_axes(self
, engine
);
703 set_up_pseudo_axes_frames (HklGuiWindow
* self
)
705 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
706 HklGuiEngine
**pseudo
;
709 darray_engine
*engines
;
711 g_return_if_fail (self
!= NULL
);
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
);
718 darray_size (priv
->pseudo_frames
) = 0;
720 engines
= hkl_engine_list_engines (priv
->diffractometer
->engines
);
721 darray_foreach (engine
, *engines
){
722 HklGuiEngine
*pseudo
;
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
)));
729 g_signal_connect_object (pseudo
,
731 G_CALLBACK(pseudo_axes_frame_changed_cb
),
735 gtk_widget_show_all (GTK_WIDGET (priv
->_vbox2
));
740 set_up_diffractometer_model (HklGuiWindow
* self
)
742 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
744 HklFactory
**factories
;
746 g_return_if_fail (self
!= NULL
);
748 factories
= hkl_factory_get_all(&n
);
750 GtkTreeIter iter
= {0};
752 gtk_list_store_append (priv
->_liststore_diffractometer
, &iter
);
753 gtk_list_store_set (priv
->_liststore_diffractometer
,
755 DIFFRACTOMETER_COL_NAME
, hkl_factory_name(factories
[i
]),
756 DIFFRACTOMETER_COL_FACTORY
, factories
[i
],
757 DIFFRACTOMETER_COL_DIFFRACTOMETER
, NULL
,
763 set_up_tree_view_axes (HklGuiWindow
* self
)
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
;
772 g_return_if_fail (self
!= NULL
);
774 gtk_list_store_clear (priv
->_liststore_axis
);
776 parameters
= hkl_geometry_axes_get(priv
->diffractometer
->geometry
);
777 darray_foreach (parameter
, *parameters
){
778 GtkTreeIter iter
= {0};
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
),
791 set_up_tree_view_pseudo_axes (HklGuiWindow
* self
)
793 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
794 HklParameter
**parameter
;
795 const darray_parameter
*parameters
;
797 const darray_engine
*engines
;
799 GtkCellRendererText
* renderer
= NULL
;
800 GtkTreeViewColumn
* column
= NULL
;
803 g_return_if_fail (self
!= NULL
);
805 gtk_list_store_clear(priv
->_liststore_pseudo_axes
);
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};
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
),
822 update_pseudo_axes (self
);
826 _delete_column(gpointer data
,
829 gtk_tree_view_remove_column (GTK_TREE_VIEW(user_data
),
830 GTK_TREE_VIEW_COLUMN(data
));
834 set_up_tree_view_solutions (HklGuiWindow
* self
)
836 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
837 const darray_parameter
*parameters
;
839 GtkCellRenderer
* renderer
= NULL
;
840 GtkTreeViewColumn
* column
= NULL
;
845 g_return_if_fail (self
!= NULL
);
847 parameters
= hkl_geometry_axes_get(priv
->diffractometer
->geometry
);
849 n_columns
= SOLUTION_COL_N_COLUMNS
+ darray_size(*parameters
);
851 /* prepare types for the liststore */
852 types
= g_new0 (GType
, n_columns
);
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
);
859 /* now add the index column */
860 renderer
= gtk_cell_renderer_text_new ();
861 column
= gtk_tree_view_column_new_with_attributes ("index",
863 SOLUTION_COL_INDEX
, NULL
);
865 gtk_tree_view_append_column (priv
->_treeview_solutions
, column
);
866 types
[0] = G_TYPE_INT
;
868 /* add the axes column */
869 for(i
=1; i
<n_columns
; ++i
){
870 HklParameter
*parameter
;
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
),
878 gtk_tree_view_append_column (priv
->_treeview_solutions
, column
);
879 types
[i
] = G_TYPE_DOUBLE
;
882 if (priv
->_liststore_solutions
)
883 g_object_unref(priv
->_liststore_solutions
);
884 priv
->_liststore_solutions
= gtk_list_store_newv (n_columns
, types
);
887 gtk_tree_view_set_model (priv
->_treeview_solutions
,
888 GTK_TREE_MODEL(priv
->_liststore_solutions
));
890 update_solutions (self
);
894 set_up_info_bar(HklGuiWindow
*self
)
896 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
897 GtkWidget
*content_area
;
899 g_return_if_fail (self
!= NULL
);
901 /* set up info bar until we can use glade for this purpose or
906 priv
->info_bar
= GTK_INFO_BAR(gtk_info_bar_new ());
907 gtk_widget_set_no_show_all (GTK_WIDGET(priv
->info_bar
), TRUE
);
909 priv
->info_message
= GTK_LABEL(gtk_label_new (""));
910 gtk_widget_show (GTK_WIDGET(priv
->info_message
));
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
);
920 gtk_box_pack_start(GTK_BOX(priv
->_box_info_bar
),
921 GTK_WIDGET(priv
->info_bar
),
926 set_up_lambda(HklGuiWindow
*self
)
928 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
930 g_object_set(G_OBJECT(priv
->_spinbutton_lambda
),
934 gtk_spin_button_set_value(priv
->_spinbutton_lambda
,
935 hkl_geometry_wavelength_get(priv
->diffractometer
->geometry
));
938 /* select diffractometer */
940 hkl_gui_window_combobox1_changed_cb(GtkComboBox
*combobox
, gpointer
*user_data
)
942 HklGuiWindow
*self
= HKL_GUI_WINDOW(user_data
);
943 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(user_data
);
945 struct diffractometer_t
*dif
= NULL
;
947 GtkTreeIter iter
= {0};
949 if(gtk_combo_box_get_active_iter (combobox
, &iter
)){
950 gtk_tree_model_get(GTK_TREE_MODEL(priv
->_liststore_diffractometer
),
952 DIFFRACTOMETER_COL_FACTORY
, &factory
,
953 DIFFRACTOMETER_COL_DIFFRACTOMETER
, &dif
,
957 dif
= create_diffractometer(factory
);
958 gtk_list_store_set(priv
->_liststore_diffractometer
,
960 DIFFRACTOMETER_COL_DIFFRACTOMETER
, dif
,
964 if(dif
!= priv
->diffractometer
){
965 priv
->diffractometer
= dif
;
967 diffractometer_set_sample(dif
, priv
->sample
);
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
);
984 hkl_gui_window_cellrendererspin1_edited_cb(GtkCellRendererText
*renderer
,
989 HklGuiWindow
*self
= HKL_GUI_WINDOW(user_data
);
990 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(user_data
);
991 GtkTreeIter iter
= {0};
993 HklParameter
* parameter
= NULL
;
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
);
1000 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL(priv
->_liststore_axis
),
1003 gtk_tree_model_get (GTK_TREE_MODEL(priv
->_liststore_axis
), &iter
,
1004 AXIS_COL_AXIS
, ¶meter
,
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
,
1012 hkl_engine_list_get(priv
->diffractometer
->engines
);
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
,
1020 update_pseudo_axes (self
);
1021 update_pseudo_axes_frames (self
);
1027 hkl_gui_window_cellrendererspin3_edited_cb(GtkCellRendererText
*renderer
,
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
;
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
);
1044 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL(priv
->_liststore_axis
),
1047 gtk_tree_model_get (GTK_TREE_MODEL(priv
->_liststore_axis
), &iter
,
1048 AXIS_COL_AXIS
, ¶meter
,
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
);
1055 gtk_list_store_set (priv
->_liststore_axis
, &iter
,
1056 AXIS_COL_MIN
, value
,
1059 update_pseudo_axes (self
);
1065 hkl_gui_window_cellrendererspin4_edited_cb(GtkCellRendererText
*renderer
,
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
;
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
);
1082 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL(priv
->_liststore_axis
),
1085 gtk_tree_model_get (GTK_TREE_MODEL(priv
->_liststore_axis
), &iter
,
1086 AXIS_COL_AXIS
, ¶meter
,
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
);
1093 gtk_list_store_set (priv
->_liststore_axis
, &iter
,
1094 AXIS_COL_MAX
, value
,
1097 update_pseudo_axes (self
);
1101 /* pseudo axis write */
1103 hkl_gui_window_cellrenderertext5_edited_cb(GtkCellRendererText
*renderer
,
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;
1113 HklParameter
* parameter
= NULL
;
1114 HklEngine
*engine
= NULL
;
1115 HklError
*error
= NULL
;
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
);
1122 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL(priv
->_liststore_pseudo_axes
),
1125 gtk_tree_model_get (GTK_TREE_MODEL(priv
->_liststore_pseudo_axes
), &iter
,
1126 PSEUDO_AXIS_COL_PARAMETER
, ¶meter
,
1127 PSEUDO_AXIS_COL_ENGINE
, &engine
,
1130 value
= atof(new_text
); /* TODO need to check for the right conversion */
1131 old_value
= hkl_parameter_value_unit_get(parameter
);
1133 g_assert(error
!= NULL
|| error
== NULL
);
1134 hkl_parameter_value_unit_set (parameter
, value
, &error
);
1136 raise_error(self
, &error
);
1139 if (hkl_engine_to_axes(self
, engine
)){
1140 gtk_list_store_set (priv
->_liststore_pseudo_axes
,
1142 PSEUDO_AXIS_COL_WRITE
, value
,
1145 hkl_parameter_value_unit_set(parameter
, old_value
, NULL
);
1151 hkl_gui_window_treeview_solutions_cursor_changed_cb (GtkTreeView
*tree_view
,
1154 HklGuiWindow
* self
= HKL_GUI_WINDOW(user_data
);
1155 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(user_data
);
1157 GtkTreePath
* path
= NULL
;
1158 GtkTreeViewColumn
* focus_column
= NULL
;
1159 GtkTreeIter iter
= {0};
1162 g_return_if_fail (tree_view
!= NULL
);
1163 g_return_if_fail (user_data
!= NULL
);
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
,
1171 hkl_engine_list_select_solution (priv
->diffractometer
->engines
, index
);
1172 hkl_engine_list_get (priv
->diffractometer
->engines
);
1175 update_pseudo_axes (self
);
1176 update_pseudo_axes_frames (self
);
1178 gtk_tree_path_free (path
);
1183 hkl_gui_window_cellrenderertext7_edited_cb(GtkCellRendererText
* _sender
, const gchar
* path
,
1184 const gchar
* new_text
, gpointer self
)
1186 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
1188 g_return_if_fail (self
!= NULL
);
1189 g_return_if_fail (path
!= NULL
);
1190 g_return_if_fail (new_text
!= NULL
);
1196 HklSampleReflection
* reflection
= NULL
;
1197 GtkTreeIter iter
= {0};
1199 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL(priv
->_liststore_reflections
),
1201 gtk_tree_model_get (GTK_TREE_MODEL(priv
->_liststore_reflections
),
1203 REFLECTION_COL_REFLECTION
, &reflection
,
1206 hkl_sample_reflection_hkl_get (reflection
, &h
, &k
, &l
);
1208 hkl_sample_reflection_hkl_set (reflection
, h
, k
, l
);
1209 gtk_list_store_set (priv
->_liststore_reflections
,
1211 REFLECTION_COL_H
, h
,
1218 hkl_gui_window_cellrenderertext8_edited_cb (GtkCellRendererText
* _sender
, const gchar
* path
,
1219 const gchar
* new_text
, gpointer self
)
1221 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
1223 g_return_if_fail (self
!= NULL
);
1224 g_return_if_fail (path
!= NULL
);
1225 g_return_if_fail (new_text
!= NULL
);
1231 HklSampleReflection
* reflection
= NULL
;
1232 GtkTreeIter iter
= {0};
1234 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL(priv
->_liststore_reflections
),
1236 gtk_tree_model_get (GTK_TREE_MODEL(priv
->_liststore_reflections
),
1238 REFLECTION_COL_REFLECTION
, &reflection
,
1241 hkl_sample_reflection_hkl_get (reflection
, &h
, &k
, &l
);
1243 hkl_sample_reflection_hkl_set (reflection
, h
, k
, l
);
1244 gtk_list_store_set (priv
->_liststore_reflections
,
1246 REFLECTION_COL_K
, k
,
1253 hkl_gui_window_cellrenderertext9_edited_cb (GtkCellRendererText
* _sender
, const gchar
* path
,
1254 const gchar
* new_text
, gpointer self
)
1256 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
1258 g_return_if_fail (self
!= NULL
);
1259 g_return_if_fail (path
!= NULL
);
1260 g_return_if_fail (new_text
!= NULL
);
1266 HklSampleReflection
* reflection
= NULL
;
1267 GtkTreeIter iter
= {0};
1269 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL(priv
->_liststore_reflections
),
1271 gtk_tree_model_get (GTK_TREE_MODEL(priv
->_liststore_reflections
),
1273 REFLECTION_COL_REFLECTION
, &reflection
,
1276 hkl_sample_reflection_hkl_get (reflection
, &h
, &k
, &l
);
1278 hkl_sample_reflection_hkl_set (reflection
, h
, k
, l
);
1279 gtk_list_store_set (priv
->_liststore_reflections
,
1281 REFLECTION_COL_L
, l
,
1286 /* reflection flag */
1288 hkl_gui_window_cellrenderertoggle1_toggled_cb (GtkCellRendererToggle
* renderer
, const gchar
* path
,
1291 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
1293 g_return_if_fail (self
!= NULL
);
1294 g_return_if_fail (path
!= NULL
);
1298 HklSampleReflection
* reflection
= NULL
;
1299 GtkTreeIter iter
= {0};
1301 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL(priv
->_liststore_reflections
),
1303 gtk_tree_model_get (GTK_TREE_MODEL(priv
->_liststore_reflections
),
1305 REFLECTION_COL_REFLECTION
, &reflection
,
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
,
1312 REFLECTION_COL_FLAG
, flag
,
1318 hkl_gui_window_treeview_reflections_key_press_event_cb (GtkWidget
* _sender
, GdkEventKey
* event
,
1325 hkl_gui_window_toolbutton_add_reflection_clicked_cb(GtkToolButton
* _sender
,
1328 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
1330 if (priv
->diffractometer
== NULL
){
1331 gtk_statusbar_push (priv
->_statusbar
, 0,
1332 "Please select a diffractometer before adding reflections");
1337 HklSampleReflection
*reflection
= NULL
;
1338 GtkTreeIter iter
= {0};
1342 reflection
= hkl_sample_reflection_new(priv
->diffractometer
->geometry
,
1343 priv
->diffractometer
->detector
,
1345 hkl_sample_add_reflection(priv
->sample
, reflection
);
1346 flag
= hkl_sample_reflection_flag_get(reflection
);
1348 n_rows
= gtk_tree_model_iter_n_children(GTK_TREE_MODEL(priv
->_liststore_reflections
),
1350 gtk_list_store_insert_with_values (priv
->_liststore_reflections
,
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
,
1363 hkl_gui_window_toolbutton_goto_reflection_clicked_cb (GtkToolButton
* _sender
, gpointer user_data
)
1365 HklGuiWindow
*self
= HKL_GUI_WINDOW(user_data
);
1366 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(user_data
);
1368 g_return_if_fail (self
!= NULL
);
1371 GtkTreeSelection
* selection
= NULL
;
1374 selection
= gtk_tree_view_get_selection (priv
->_treeview_reflections
);
1375 nb_rows
= gtk_tree_selection_count_selected_rows (selection
);
1378 HklSampleReflection
*reflection
;
1379 GtkTreeIter iter
= {0};
1380 GtkTreeModel
* model
= NULL
;
1381 GtkTreePath
*treepath
;
1384 model
= GTK_TREE_MODEL(priv
->_liststore_reflections
);
1386 list
= gtk_tree_selection_get_selected_rows (selection
,
1389 treepath
= g_list_nth_data(list
, 0);
1391 gtk_tree_model_get_iter (GTK_TREE_MODEL(priv
->_liststore_reflections
),
1394 gtk_tree_model_get (GTK_TREE_MODEL(priv
->_liststore_reflections
),
1396 REFLECTION_COL_REFLECTION
, &reflection
,
1399 hkl_geometry_set (priv
->diffractometer
->geometry
,
1400 hkl_sample_reflection_geometry_get(reflection
));
1402 update_source (self
);
1406 update_pseudo_axes (self
);
1408 g_list_free_full (list
, (GDestroyNotify
) gtk_tree_path_free
);
1411 gtk_statusbar_push (priv
->_statusbar
, 0,
1412 "Please select only one reflection.");
1414 gtk_statusbar_push (priv
->_statusbar
, 0,
1415 "Please select at least one reflection.");
1420 _del_reflection(gpointer data
, gpointer user_data
)
1422 HklSampleReflection
*reflection
;
1423 GtkTreeIter iter
= {0};
1424 GtkTreePath
*treepath
= data
;
1425 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(user_data
);
1427 gtk_tree_model_get_iter (GTK_TREE_MODEL(priv
->_liststore_reflections
),
1430 gtk_tree_model_get (GTK_TREE_MODEL(priv
->_liststore_reflections
),
1432 REFLECTION_COL_REFLECTION
, &reflection
,
1434 hkl_sample_del_reflection(priv
->sample
, reflection
);
1438 hkl_gui_window_toolbutton_del_reflection_clicked_cb (GtkToolButton
* _sender
, gpointer user_data
)
1440 HklGuiWindow
*self
= HKL_GUI_WINDOW(user_data
);
1441 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(user_data
);
1442 HklSample
* sample
= NULL
;
1444 g_return_if_fail (self
!= NULL
);
1447 GtkTreeSelection
* selection
= NULL
;
1450 selection
= gtk_tree_view_get_selection (priv
->_treeview_reflections
);
1451 nb_rows
= gtk_tree_selection_count_selected_rows (selection
);
1453 GtkTreeModel
* model
= NULL
;
1457 GtkMessageDialog
* dialog
;
1459 model
= GTK_TREE_MODEL(priv
->_liststore_reflections
);
1460 list
= gtk_tree_selection_get_selected_rows (selection
, &model
);
1463 dialog
= GTK_MESSAGE_DIALOG(
1464 gtk_message_dialog_new (NULL
,
1465 GTK_DIALOG_DESTROY_WITH_PARENT
,
1466 GTK_MESSAGE_WARNING
,
1468 "Are you sure that you want to delete reflections"));
1470 switch (gtk_dialog_run (GTK_DIALOG(dialog
))) {
1471 case GTK_RESPONSE_YES
:
1473 g_list_foreach(list
, _del_reflection
, self
);
1474 update_reflections (self
);
1480 gtk_widget_destroy (GTK_WIDGET(dialog
));
1481 g_list_free_full (list
, (GDestroyNotify
) gtk_tree_path_free
);
1483 gtk_statusbar_push (priv
->_statusbar
, 0,
1484 "Please select at least one reflection.");
1490 set_up_tree_view_reflections(HklGuiWindow
*self
)
1492 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
1493 GtkTreeSelection
* selection
= NULL
;
1495 selection
= gtk_tree_view_get_selection (priv
->_treeview_reflections
);
1496 gtk_tree_selection_set_mode(selection
, GTK_SELECTION_MULTIPLE
);
1501 hkl_gui_window_cellrenderertext10_edited_cb(GtkCellRendererText
* _sender
, const gchar
* path
,
1502 const gchar
* new_text
, gpointer user_data
)
1504 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(user_data
);
1506 GtkTreeModel
* model
= NULL
;
1507 GtkTreeIter iter
= {0};
1508 HklSample
* sample
= NULL
;
1511 g_return_if_fail (user_data
!= NULL
);
1512 g_return_if_fail (path
!= NULL
);
1513 g_return_if_fail (new_text
!= NULL
);
1515 model
= GTK_TREE_MODEL(priv
->_liststore_crystals
);
1517 gtk_tree_model_get_iter_from_string (model
, &iter
, path
);
1519 gtk_tree_model_get (model
, &iter
,
1520 SAMPLE_COL_SAMPLE
, &sample
,
1523 hkl_sample_name_set (sample
, new_text
);
1525 gtk_list_store_set(priv
->_liststore_crystals
, &iter
,
1526 SAMPLE_COL_NAME
, new_text
,
1530 #define set_lattice(lattice, parameter) do{ \
1531 const HklParameter *p; \
1532 gdouble min, max, value; \
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); \
1545 update_lattice (HklGuiWindow
* self
)
1547 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
1549 g_return_if_fail (self
!= NULL
);
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
);
1563 #define set_reciprocal_lattice(lattice, parameter) do{ \
1564 const HklParameter *p; \
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); \
1572 update_reciprocal_lattice (HklGuiWindow
* self
)
1574 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
1576 g_return_if_fail (self
!= NULL
);
1578 if (priv
->sample
!= NULL
) {
1579 hkl_lattice_reciprocal (hkl_sample_lattice_get(priv
->sample
),
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
);
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); \
1601 update_ux_uy_uz (HklGuiWindow
* self
)
1603 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
1605 g_return_if_fail (self
!= NULL
);
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
);
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))); \
1623 update_UB (HklGuiWindow
* self
)
1625 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
1627 g_return_if_fail (self
!= NULL
);
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
);
1648 hkl_gui_window_treeview_crystals_cursor_changed_cb (GtkTreeView
* _sender
, gpointer user_data
)
1650 GtkTreePath
* path
= NULL
;
1651 GtkTreeViewColumn
* column
= NULL
;
1652 GtkTreeIter iter
= {0};
1654 HklGuiWindow
*self
= HKL_GUI_WINDOW(user_data
);
1655 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(user_data
);
1658 g_return_if_fail (user_data
!= NULL
);
1660 gtk_tree_view_get_cursor (priv
->_treeview_crystals
, &path
, &column
);
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
),
1666 SAMPLE_COL_SAMPLE
, &sample
,
1669 if(sample
&& sample
!= priv
->sample
){
1670 priv
->sample
= sample
;
1672 update_reflections(self
);
1673 update_lattice(self
);
1674 update_reciprocal_lattice (self
);
1675 update_ux_uy_uz (self
);
1678 if(priv
->diffractometer
){
1679 diffractometer_set_sample(priv
->diffractometer
,
1682 update_pseudo_axes (self
);
1683 update_pseudo_axes_frames (self
);
1684 update_solutions(self
);
1688 gtk_tree_path_free (path
);
1695 _add_sample(HklGuiWindow
*self
, HklSample
*sample
)
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
;
1702 g_return_val_if_fail (self
!= NULL
, iter
);
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
));
1712 gtk_list_store_insert_with_values(priv
->_liststore_crystals
,
1714 SAMPLE_COL_SAMPLE
, sample
,
1715 SAMPLE_COL_NAME
, hkl_sample_name_get(sample
),
1719 SAMPLE_COL_ALPHA
, alpha
,
1720 SAMPLE_COL_BETA
, beta
,
1721 SAMPLE_COL_GAMMA
, gamma
,
1727 set_up_tree_view_crystals (HklGuiWindow
* self
)
1729 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
1730 GtkTreeIter iter
= {0};
1731 GtkTreePath
*path
= NULL
;
1733 g_return_if_fail (self
!= NULL
);
1735 iter
= _add_sample(self
, hkl_sample_new("default"));
1737 path
= gtk_tree_model_get_path(GTK_TREE_MODEL(priv
->_liststore_crystals
),
1740 gtk_tree_view_set_cursor(priv
->_treeview_crystals
, path
, NULL
, FALSE
);
1742 gtk_tree_path_free(path
);
1746 _add_sample_and_edit_name(HklGuiWindow
*self
, HklSample
*sample
)
1748 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
1749 GtkTreeIter iter
= {0};
1750 GtkTreePath
* path
= NULL
;
1751 GtkTreeViewColumn
* column
= NULL
;
1753 iter
= _add_sample(self
, sample
);
1755 path
= gtk_tree_model_get_path(GTK_TREE_MODEL(priv
->_liststore_crystals
),
1757 column
= gtk_tree_view_get_column (priv
->_treeview_crystals
, 0);
1758 gtk_tree_view_set_cursor (priv
->_treeview_crystals
, path
, column
, TRUE
);
1760 gtk_tree_path_free(path
);
1764 hkl_gui_window_toolbutton_add_crystal_clicked_cb (GtkToolButton
* _sender
, gpointer user_data
)
1766 HklGuiWindow
*self
= HKL_GUI_WINDOW(user_data
);
1767 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(user_data
);
1770 g_return_if_fail (user_data
!= NULL
);
1772 sample
= hkl_sample_new ("new");
1774 _add_sample_and_edit_name(self
, sample
);
1778 hkl_gui_window_toolbutton_copy_crystal_clicked_cb (GtkToolButton
* _sender
, gpointer user_data
)
1780 HklGuiWindow
*self
= HKL_GUI_WINDOW(user_data
);
1781 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(user_data
);
1782 HklSample
*copy
= NULL
;
1784 g_return_if_fail (self
!= NULL
);
1787 copy
= hkl_sample_new_copy(priv
->sample
);
1789 _add_sample_and_edit_name(self
, copy
);
1791 gtk_statusbar_push (priv
->_statusbar
, (guint
) 0, "Please select a crystal to copy.");
1795 hkl_gui_window_toolbutton_del_crystal_clicked_cb (GtkToolButton
* _sender
, gpointer user_data
)
1797 HklGuiWindow
*self
= HKL_GUI_WINDOW(user_data
);
1798 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(user_data
);
1800 g_return_if_fail (user_data
!= NULL
);
1802 if (priv
->sample
!= NULL
) {
1805 n_rows
= gtk_tree_model_iter_n_children(GTK_TREE_MODEL(priv
->_liststore_crystals
),
1810 GtkTreeIter iter
= {0};
1811 GtkTreePath
*path
= NULL
;
1812 GtkTreeViewColumn
*column
= NULL
;
1814 gtk_tree_view_get_cursor(priv
->_treeview_crystals
,
1817 if (gtk_tree_model_get_iter (GTK_TREE_MODEL(priv
->_liststore_crystals
),
1818 &iter
, path
) == TRUE
) {
1819 gtk_tree_path_free(path
);
1821 hkl_sample_free(priv
->sample
);
1822 if (gtk_list_store_remove(priv
->_liststore_crystals
,
1824 path
= gtk_tree_model_get_path(GTK_TREE_MODEL(priv
->_liststore_crystals
),
1826 gtk_tree_view_set_cursor(priv
->_treeview_crystals
,
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); \
1845 #define get_ux_uy_uz(sample, parameter) do { \
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), \
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); \
1859 _update_crystal_model(GtkTreeModel
*model
,
1864 HklGuiWindow
*self
= HKL_GUI_WINDOW(data
);
1865 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(data
);
1866 HklSample
*sample
= NULL
;
1868 gtk_tree_model_get(model
, iter
,
1869 SAMPLE_COL_SAMPLE
, &sample
,
1871 if(priv
->sample
== sample
){
1872 const HklLattice
*lattice
;
1873 gdouble a
, b
, c
, alpha
, beta
, gamma
;
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
));
1883 gtk_list_store_set(priv
->_liststore_crystals
,
1885 SAMPLE_COL_NAME
, hkl_sample_name_get(sample
),
1889 SAMPLE_COL_ALPHA
, alpha
,
1890 SAMPLE_COL_BETA
, beta
,
1891 SAMPLE_COL_GAMMA
, gamma
,
1899 update_crystal_model(HklGuiWindow
*self
)
1901 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
1903 gtk_tree_model_foreach(GTK_TREE_MODEL(priv
->_liststore_crystals
),
1904 _update_crystal_model
,
1908 /* apply crystal parameters */
1910 hkl_gui_window_button2_clicked_cb (GtkButton
* _sender
, gpointer user_data
)
1912 HklGuiWindow
*self
= HKL_GUI_WINDOW(user_data
);
1913 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(user_data
);
1915 g_return_if_fail (self
!= NULL
);
1917 if (priv
->sample
!= NULL
) {
1918 gdouble a
, b
, c
, alpha
, beta
, gamma
;
1920 HklLattice
*lattice
;
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
);
1932 lattice
= hkl_lattice_new(a
, b
, c
,
1933 alpha
* HKL_DEGTORAD
,
1934 beta
* HKL_DEGTORAD
,
1935 gamma
* HKL_DEGTORAD
);
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
);
1944 hkl_sample_lattice_set(priv
->sample
, lattice
);
1946 hkl_lattice_free(lattice
);
1949 get_ux_uy_uz(priv
->sample
, ux
);
1950 get_ux_uy_uz(priv
->sample
, uy
);
1951 get_ux_uy_uz(priv
->sample
, uz
);
1953 if(priv
->diffractometer
)
1954 diffractometer_set_sample(priv
->diffractometer
,
1957 update_crystal_model (self
);
1958 update_reciprocal_lattice (self
);
1960 update_pseudo_axes (self
);
1961 update_pseudo_axes_frames (self
);
1966 hkl_gui_window_spinbutton_lambda_value_changed_cb (GtkSpinButton
* _sender
, gpointer user_data
)
1968 HklGuiWindow
*self
= HKL_GUI_WINDOW(user_data
);
1969 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(user_data
);
1971 diffractometer_set_wavelength(priv
->diffractometer
,
1972 gtk_spin_button_get_value(_sender
));
1973 update_pseudo_axes (self
);
1974 update_pseudo_axes_frames (self
);
1978 hkl_gui_window_spinbutton_ux_value_changed_cb (GtkSpinButton
*_senser
, gpointer user_data
)
1980 HklGuiWindow
*self
= HKL_GUI_WINDOW(user_data
);
1981 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(user_data
);
1983 get_ux_uy_uz(priv
->sample
, ux
);
1985 if(priv
->diffractometer
)
1986 diffractometer_set_sample(priv
->diffractometer
,
1990 update_pseudo_axes (self
);
1991 update_pseudo_axes_frames (self
);
1995 hkl_gui_window_spinbutton_uy_value_changed_cb (GtkSpinButton
*_senser
, gpointer user_data
)
1997 HklGuiWindow
*self
= HKL_GUI_WINDOW(user_data
);
1998 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(user_data
);
2000 get_ux_uy_uz(priv
->sample
, uy
);
2002 if(priv
->diffractometer
)
2003 diffractometer_set_sample(priv
->diffractometer
,
2007 update_pseudo_axes (self
);
2008 update_pseudo_axes_frames (self
);
2012 hkl_gui_window_spinbutton_uz_value_changed_cb (GtkSpinButton
*_senser
, gpointer user_data
)
2014 HklGuiWindow
*self
= HKL_GUI_WINDOW(user_data
);
2015 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(user_data
);
2017 get_ux_uy_uz(priv
->sample
, uz
);
2019 if(priv
->diffractometer
)
2020 diffractometer_set_sample(priv
->diffractometer
,
2024 update_pseudo_axes (self
);
2025 update_pseudo_axes_frames (self
);
2029 hkl_gui_window_toolbutton_setUB_clicked_cb(GtkToolButton
* _sender
, gpointer user_data
)
2031 HklGuiWindow
*self
= HKL_GUI_WINDOW(user_data
);
2032 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(user_data
);
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
));
2046 hkl_sample_UB_set (priv
->sample
, UB
, NULL
);
2047 if(priv
->diffractometer
)
2048 diffractometer_set_sample(priv
->diffractometer
,
2051 update_lattice (self
);
2052 update_crystal_model (self
);
2053 update_reciprocal_lattice (self
);
2055 update_ux_uy_uz (self
);
2056 update_pseudo_axes (self
);
2057 update_pseudo_axes_frames (self
);
2059 hkl_matrix_free(UB
);
2063 hkl_gui_window_toolbutton_computeUB_clicked_cb (GtkToolButton
* _sender
, gpointer user_data
)
2065 HklGuiWindow
*self
= HKL_GUI_WINDOW(user_data
);
2066 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(user_data
);
2067 GtkTreeSelection
* selection
= NULL
;
2070 selection
= gtk_tree_view_get_selection (priv
->_treeview_reflections
);
2071 nb_rows
= gtk_tree_selection_count_selected_rows (selection
);
2073 GtkTreeModel
* model
= NULL
;
2075 GtkTreeIter iter
= {0};
2077 HklSampleReflection
*ref1
, *ref2
;
2079 model
= GTK_TREE_MODEL(priv
->_liststore_reflections
);
2080 list
= gtk_tree_selection_get_selected_rows (selection
, &model
);
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
),
2087 gtk_tree_model_get (GTK_TREE_MODEL(priv
->_liststore_reflections
), &iter
,
2088 REFLECTION_COL_REFLECTION
, &ref1
,
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
),
2096 gtk_tree_model_get (GTK_TREE_MODEL(priv
->_liststore_reflections
), &iter
,
2097 REFLECTION_COL_REFLECTION
, &ref2
,
2100 hkl_sample_compute_UB_busing_levy(priv
->sample
,
2103 if(priv
->diffractometer
)
2104 diffractometer_set_sample(priv
->diffractometer
,
2108 update_ux_uy_uz (self
);
2109 update_pseudo_axes (self
);
2110 update_pseudo_axes_frames (self
);
2112 g_list_free_full (list
, (GDestroyNotify
) gtk_tree_path_free
);
2114 gtk_statusbar_push (priv
->_statusbar
, 0,
2115 "Please select at least two reflection.");
2120 hkl_gui_window_toolbutton_affiner_clicked_cb (GtkToolButton
* _sender
, gpointer user_data
)
2122 HklGuiWindow
*self
= HKL_GUI_WINDOW(user_data
);
2123 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(user_data
);
2125 hkl_sample_affine (priv
->sample
);
2126 if(priv
->diffractometer
)
2127 diffractometer_set_sample(priv
->diffractometer
,
2130 update_lattice (self
);
2131 update_crystal_model (self
);
2132 update_reciprocal_lattice (self
);
2134 update_ux_uy_uz (self
);
2135 update_pseudo_axes (self
);
2136 update_pseudo_axes_frames (self
);
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; \
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); \
2153 hkl_gui_window_checkbutton_a_toggled_cb(GtkCheckButton
*checkbutton
,
2160 hkl_gui_window_checkbutton_b_toggled_cb(GtkCheckButton
*checkbutton
,
2167 hkl_gui_window_checkbutton_c_toggled_cb(GtkCheckButton
*checkbutton
,
2174 hkl_gui_window_checkbutton_alpha_toggled_cb(GtkCheckButton
*checkbutton
,
2177 toggle_lattice(alpha
);
2181 hkl_gui_window_checkbutton_beta_toggled_cb(GtkCheckButton
*checkbutton
,
2184 toggle_lattice(beta
);
2188 hkl_gui_window_checkbutton_gamma_toggled_cb(GtkCheckButton
*checkbutton
,
2191 toggle_lattice(gamma
);
2196 static gboolean _hkl_gui_window_on_tree_view_crystals_key_press_event_gtk_widget_key_press_event (GtkWidget* _sender, GdkEventKey* event, gpointer self) {
2198 result = hkl_gui_window_on_tree_view_crystals_key_press_event (event, self);
2204 static void hkl_gui_window_set_up_3D (HklGuiWindow* self) {
2205 HklGeometry* _tmp0_;
2206 HklGeometryConfig* _tmp1_;
2207 HklGeometryType _tmp2_;
2209 HklGui3DFrame* _tmp8_;
2210 GtkFrame* _tmp9_ = NULL;
2214 g_return_if_fail (self != NULL);
2216 _tmp0_ = priv->geometry;
2218 _tmp1_ = _tmp0_->config;
2220 _tmp2_ = (*_tmp1_).type;
2224 case HKL_GEOMETRY_TYPE_KAPPA6C:
2227 HklGeometry* _tmp3_;
2228 HklGui3DFrame* _tmp4_;
2230 _tmp3_ = priv->geometry;
2232 _tmp4_ = hkl_gui_3d_frame_new ("../data/diffabs.yaml", _tmp3_);
2234 _g_object_unref0 (priv->Frame3D);
2236 priv->Frame3D = _tmp4_;
2242 case HKL_GEOMETRY_TYPE_KAPPA4C_VERTICAL:
2245 HklGeometry* _tmp5_;
2246 HklGui3DFrame* _tmp6_;
2248 _tmp5_ = priv->geometry;
2250 _tmp6_ = hkl_gui_3d_frame_new ("../data/cristal4C.yaml", _tmp5_);
2252 _g_object_unref0 (priv->Frame3D);
2254 priv->Frame3D = _tmp6_;
2265 _tmp7_ = priv->_vbox7;
2267 _tmp8_ = priv->Frame3D;
2269 _tmp9_ = hkl_gui_3d_frame_frame (_tmp8_);
2273 gtk_box_pack_start ((GtkBox*) _tmp7_, (GtkWidget*) _tmp10_, TRUE, TRUE, (guint) 0);
2275 _g_object_unref0 (_tmp10_);
2277 _tmp11_ = priv->_vbox7;
2279 gtk_widget_show_all ((GtkWidget*) _tmp11_);
2283 static void hkl_gui_window_on_checkbutton_Ux_toggled (HklGuiWindow* self) {
2284 HklSampleList* _tmp0_;
2289 g_return_if_fail (self != NULL);
2291 _tmp0_ = priv->samples;
2293 _tmp1_ = _tmp0_->current;
2299 if (_tmp2_ != NULL) {
2302 HklParameter* _tmp4_;
2303 GtkCheckButton* _tmp5_;
2304 gboolean _tmp6_ = FALSE;
2308 _tmp4_ = _tmp3_->ux;
2310 _tmp5_ = priv->_checkbutton_Ux;
2312 _tmp6_ = gtk_toggle_button_get_active ((GtkToggleButton*) _tmp5_);
2314 (*_tmp4_).fit = _tmp6_;
2320 static void hkl_gui_window_on_checkbutton_Uy_toggled (HklGuiWindow* self) {
2321 HklSampleList* _tmp0_;
2326 g_return_if_fail (self != NULL);
2328 _tmp0_ = priv->samples;
2330 _tmp1_ = _tmp0_->current;
2336 if (_tmp2_ != NULL) {
2339 HklParameter* _tmp4_;
2340 GtkCheckButton* _tmp5_;
2341 gboolean _tmp6_ = FALSE;
2345 _tmp4_ = _tmp3_->uy;
2347 _tmp5_ = priv->_checkbutton_Uy;
2349 _tmp6_ = gtk_toggle_button_get_active ((GtkToggleButton*) _tmp5_);
2351 (*_tmp4_).fit = _tmp6_;
2357 static void hkl_gui_window_on_checkbutton_Uz_toggled (HklGuiWindow* self) {
2358 HklSampleList* _tmp0_;
2363 g_return_if_fail (self != NULL);
2365 _tmp0_ = priv->samples;
2367 _tmp1_ = _tmp0_->current;
2373 if (_tmp2_ != NULL) {
2376 HklParameter* _tmp4_;
2377 GtkCheckButton* _tmp5_;
2378 gboolean _tmp6_ = FALSE;
2382 _tmp4_ = _tmp3_->uz;
2384 _tmp5_ = priv->_checkbutton_Uz;
2386 _tmp6_ = gtk_toggle_button_get_active ((GtkToggleButton*) _tmp5_);
2388 (*_tmp4_).fit = _tmp6_;
2393 static gboolean hkl_gui_window_on_tree_view_crystals_key_press_event (GdkEventKey* event, HklGuiWindow* self) {
2394 gboolean result = FALSE;
2396 g_return_val_if_fail (self != NULL, FALSE);
2398 g_return_val_if_fail (event != NULL, FALSE);
2409 hkl_gui_window_class_init (HklGuiWindowClass
*class)
2411 GObjectClass
*gobject_class
= G_OBJECT_CLASS (class);
2413 g_type_class_add_private (class, sizeof (HklGuiWindowPrivate
));
2415 /* virtual method */
2416 gobject_class
->finalize
= finalize
;
2420 static void hkl_gui_window_init (HklGuiWindow
* self
)
2422 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
2424 priv
->diffractometer
= NULL
;
2425 priv
->sample
= NULL
;
2427 darray_init(priv
->pseudo_frames
);
2429 priv
->reciprocal
= hkl_lattice_new_default ();
2431 hkl_gui_window_get_widgets_and_objects_from_ui (self
);
2433 set_up_diffractometer_model (self
);
2435 set_up_tree_view_crystals (self
);
2437 set_up_tree_view_reflections(self
);
2440 int main (int argc
, char ** argv
)
2442 gtk_init (&argc
, &argv
);
2444 hkl_gui_window_new ();