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-2015 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>
30 #include <glib-object.h>
36 #include "hkl-gui-macros.h"
38 # include <gtk/gtkgl.h>
39 # include "hkl-gui-3d.h"
41 #include "hkl-gui-pseudoaxes.h"
43 #define HKL_GUI_TYPE_WINDOW (hkl_gui_window_get_type ())
44 #define HKL_GUI_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), HKL_GUI_TYPE_WINDOW, HklGuiWindow))
45 #define HKL_GUI_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), HKL_GUI_TYPE_WINDOW, HklGuiWindowClass))
46 #define HKL_GUI_IS_WINDOW(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), HKL_GUI_TYPE_WINDOW))
47 #define HKL_GUI_IS_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), HKL_GUI_TYPE_WINDOW))
48 #define HKL_GUI_WINDOW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), HKL_GUI_TYPE_WINDOW, HklGuiWindowClass))
50 #define EMBED_BREAKPOINT asm volatile ("int3;")
52 G_DEFINE_TYPE (HklGuiWindow
, hkl_gui_window
, G_TYPE_OBJECT
);
55 REFLECTION_COL_INDEX
= 0,
60 REFLECTION_COL_REFLECTION
,
61 REFLECTION_COL_N_COLUMNS
75 PSEUDO_AXIS_COL_IDX
= 0,
76 PSEUDO_AXIS_COL_ENGINE
,
79 PSEUDO_AXIS_COL_WRITE
,
80 PSEUDO_AXIS_COL_N_COLUMNS
84 PARAMETER_COL_PARAMETER
= 0,
87 PARAMETER_COL_N_COLUMNS
91 SAMPLE_COL_SAMPLE
= 0,
103 SOLUTION_COL_INDEX
= 0,
104 SOLUTION_COL_HKL_GEOMETRY_LIST_ITEM
,
105 SOLUTION_COL_N_COLUMNS
109 DIFFRACTOMETER_COL_NAME
= 0,
110 DIFFRACTOMETER_COL_FACTORY
,
111 DIFFRACTOMETER_COL_DIFFRACTOMETER
,
112 DIFFRACTOMETER_COL_N_COLUMNS
119 struct diffractometer_t
{
121 HklGeometry
*geometry
;
122 HklDetector
*detector
;
123 HklEngineList
*engines
;
124 HklGeometryList
*solutions
;
128 static struct diffractometer_t
*
129 create_diffractometer(HklFactory
*factory
)
131 struct diffractometer_t
*self
;
133 self
= malloc(sizeof(*self
));
135 self
->factory
= factory
;
136 self
->geometry
= hkl_factory_create_new_geometry (factory
);
137 self
->engines
= hkl_factory_create_new_engine_list (factory
);
138 self
->detector
= hkl_detector_factory_new (HKL_DETECTOR_TYPE_0D
);
139 self
->solutions
= NULL
;
145 delete_diffractometer(struct diffractometer_t
*self
)
147 hkl_geometry_free(self
->geometry
);
148 hkl_engine_list_free(self
->engines
);
149 hkl_detector_free(self
->detector
);
151 hkl_geometry_list_free(self
->solutions
);
156 dump_diffractometer(struct diffractometer_t
*self
)
158 /* hkl_geometry_fprintf(stderr, self->geometry); */
159 /* hkl_engine_list_fprintf(stderr, self->engines); */
160 /* hkl_detector_fprintf(stderr, self->detector); */
164 diffractometer_set_sample(struct diffractometer_t
*self
,
167 hkl_engine_list_init(self
->engines
,
171 hkl_engine_list_get(self
->engines
);
175 diffractometer_set_wavelength(struct diffractometer_t
*self
,
178 if(hkl_geometry_wavelength_set(self
->geometry
,
179 wavelength
, HKL_UNIT_USER
, NULL
))
180 hkl_engine_list_get(self
->engines
);
184 diffractometer_set_solutions(struct diffractometer_t
*self
, HklGeometryList
*solutions
)
188 hkl_geometry_list_free(self
->solutions
);
189 self
->solutions
= solutions
;
192 return NULL
!= solutions
;
196 diffractometer_pseudo_axis_values_set(struct diffractometer_t
*self
,
197 HklEngine
*engine
, gdouble values
[], guint n_values
,
200 HklGeometryList
*solutions
;
203 solutions
= hkl_engine_pseudo_axis_values_set(engine
, values
, n_values
, HKL_UNIT_USER
, error
);
205 return diffractometer_set_solutions(self
, solutions
);
209 diffractometer_set_solution(struct diffractometer_t
*self
,
210 const HklGeometryListItem
*item
)
212 hkl_engine_list_select_solution(self
->engines
, item
);
220 struct _HklGuiWindowPrivate
{
222 GtkLabel
* label_UB11
;
223 GtkLabel
* label_UB12
;
224 GtkLabel
* label_UB13
;
225 GtkLabel
* label_UB21
;
226 GtkLabel
* label_UB22
;
227 GtkLabel
* label_UB23
;
228 GtkLabel
* label_UB31
;
229 GtkLabel
* label_UB32
;
230 GtkLabel
* label_UB33
;
232 GtkSpinButton
* spinbutton_a
;
233 GtkSpinButton
* spinbutton_b
;
234 GtkSpinButton
* spinbutton_c
;
235 GtkSpinButton
* spinbutton_alpha
;
236 GtkSpinButton
* spinbutton_beta
;
237 GtkSpinButton
* spinbutton_gamma
;
238 GtkSpinButton
* spinbutton_a_min
;
239 GtkSpinButton
* spinbutton_b_min
;
240 GtkSpinButton
* spinbutton_c_min
;
241 GtkSpinButton
* spinbutton_alpha_min
;
242 GtkSpinButton
* spinbutton_beta_min
;
243 GtkSpinButton
* spinbutton_gamma_min
;
244 GtkSpinButton
* spinbutton_a_max
;
245 GtkSpinButton
* spinbutton_b_max
;
246 GtkSpinButton
* spinbutton_c_max
;
247 GtkSpinButton
* spinbutton_alpha_max
;
248 GtkSpinButton
* spinbutton_beta_max
;
249 GtkSpinButton
* spinbutton_gamma_max
;
250 GtkSpinButton
* spinbutton_lambda
;
251 GtkSpinButton
* spinbutton_a_star
;
252 GtkSpinButton
* spinbutton_b_star
;
253 GtkSpinButton
* spinbutton_c_star
;
254 GtkSpinButton
* spinbutton_alpha_star
;
255 GtkSpinButton
* spinbutton_beta_star
;
256 GtkSpinButton
* spinbutton_gamma_star
;
257 GtkSpinButton
* spinbutton_ux
;
258 GtkSpinButton
* spinbutton_uy
;
259 GtkSpinButton
* spinbutton_uz
;
260 GtkSpinButton
* spinbutton_U11
;
261 GtkSpinButton
* spinbutton_U12
;
262 GtkSpinButton
* spinbutton_U13
;
263 GtkSpinButton
* spinbutton_U21
;
264 GtkSpinButton
* spinbutton_U22
;
265 GtkSpinButton
* spinbutton_U23
;
266 GtkSpinButton
* spinbutton_U31
;
267 GtkSpinButton
* spinbutton_U32
;
268 GtkSpinButton
* spinbutton_U33
;
269 GtkCheckButton
* checkbutton_a
;
270 GtkCheckButton
* checkbutton_b
;
271 GtkCheckButton
* checkbutton_c
;
272 GtkCheckButton
* checkbutton_alpha
;
273 GtkCheckButton
* checkbutton_beta
;
274 GtkCheckButton
* checkbutton_gamma
;
275 GtkCheckButton
* checkbutton_ux
;
276 GtkCheckButton
* checkbutton_uy
;
277 GtkCheckButton
* checkbutton_uz
;
278 GtkTreeView
* treeview_reflections
;
279 GtkTreeView
* treeview_crystals
;
280 GtkTreeView
* treeview_axes
;
281 GtkTreeView
* treeview_pseudo_axes
;
282 GtkTreeView
* treeview_solutions
;
283 GtkToolButton
* toolbutton_add_reflection
;
284 GtkToolButton
* toolbutton_goto_reflection
;
285 GtkToolButton
* toolbutton_del_reflection
;
286 GtkToolButton
* toolbutton_setUB
;
287 GtkToolButton
* toolbutton_computeUB
;
288 GtkToolButton
* toolbutton_add_crystal
;
289 GtkToolButton
* toolbutton_copy_crystal
;
290 GtkToolButton
* toolbutton_del_crystal
;
291 GtkToolButton
* toolbutton_affiner
;
292 GtkStatusbar
* statusbar
;
293 GtkImageMenuItem
* menuitem5
;
294 GtkVBox
* box_info_bar
; /* fake for the infor bar */
299 GtkComboBox
* combobox1
;
300 GtkListStore
* liststore_diffractometer
;
301 GtkListStore
* liststore_axis
;
302 GtkListStore
* liststore_pseudo_axes
;
303 GtkListStore
* liststore_solutions
;
304 GtkListStore
* liststore_reflections
;
305 GtkListStore
* liststore_crystals
;
307 GtkInfoBar
*info_bar
;
308 GtkLabel
*info_message
;
310 darray(HklGuiEngine
*) pseudo_frames
;
315 struct diffractometer_t
*diffractometer
; /* unowned */
316 HklSample
*sample
; /* unowned */
317 HklLattice
*reciprocal
;
320 #define HKL_GUI_WINDOW_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), HKL_GUI_TYPE_WINDOW, HklGuiWindowPrivate))
323 finalize_liststore_diffractometer(GtkTreeModel
*model
,
328 struct diffractometer_t
*diffractometer
;
330 gtk_tree_model_get(model
, iter
,
331 DIFFRACTOMETER_COL_DIFFRACTOMETER
, &diffractometer
,
333 delete_diffractometer(diffractometer
);
338 finalize_liststore_samples(GtkTreeModel
*model
,
343 HklSample
*sample
= NULL
;
345 gtk_tree_model_get(model
, iter
,
346 SAMPLE_COL_SAMPLE
, &sample
,
348 hkl_sample_free(sample
);
353 finalize (GObject
* object
)
355 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(object
);
357 g_object_unref(priv
->builder
);
359 darray_free(priv
->pseudo_frames
);
361 gtk_tree_model_foreach(GTK_TREE_MODEL(priv
->liststore_diffractometer
),
362 finalize_liststore_diffractometer
,
365 gtk_tree_model_foreach(GTK_TREE_MODEL(priv
->liststore_crystals
),
366 finalize_liststore_samples
,
369 G_OBJECT_CLASS (hkl_gui_window_parent_class
)->finalize (object
);
372 HklGuiWindow
* hkl_gui_window_new (void)
374 return g_object_new (HKL_GUI_TYPE_WINDOW
, NULL
);
378 hkl_gui_window_get_widgets_and_objects_from_ui (HklGuiWindow
* self
)
380 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
383 g_return_if_fail (self
!= NULL
);
385 priv
->builder
= builder
= gtk_builder_new ();
386 get_ui(builder
, "ghkl.ui");
388 get_object(builder
, GTK_LIST_STORE
, priv
, liststore_diffractometer
);
389 get_object(builder
, GTK_LIST_STORE
, priv
, liststore_axis
);
390 get_object(builder
, GTK_LIST_STORE
, priv
, liststore_pseudo_axes
);
391 get_object(builder
, GTK_LIST_STORE
, priv
, liststore_reflections
);
392 get_object(builder
, GTK_LIST_STORE
, priv
, liststore_crystals
);
394 get_object(builder
, GTK_LABEL
, priv
, label_UB11
);
395 get_object(builder
, GTK_LABEL
, priv
, label_UB12
);
396 get_object(builder
, GTK_LABEL
, priv
, label_UB13
);
397 get_object(builder
, GTK_LABEL
, priv
, label_UB21
);
398 get_object(builder
, GTK_LABEL
, priv
, label_UB22
);
399 get_object(builder
, GTK_LABEL
, priv
, label_UB23
);
400 get_object(builder
, GTK_LABEL
, priv
, label_UB31
);
401 get_object(builder
, GTK_LABEL
, priv
, label_UB32
);
402 get_object(builder
, GTK_LABEL
, priv
, label_UB33
);
404 get_object(builder
, GTK_BUTTON
, priv
, button2
);
406 get_object(builder
, GTK_SPIN_BUTTON
, priv
, spinbutton_a
);
407 get_object(builder
, GTK_SPIN_BUTTON
, priv
, spinbutton_a_min
);
408 get_object(builder
, GTK_SPIN_BUTTON
, priv
, spinbutton_a_max
);
409 get_object(builder
, GTK_SPIN_BUTTON
, priv
, spinbutton_a_star
);
411 get_object(builder
, GTK_SPIN_BUTTON
, priv
, spinbutton_b
);
412 get_object(builder
, GTK_SPIN_BUTTON
, priv
, spinbutton_b_min
);
413 get_object(builder
, GTK_SPIN_BUTTON
, priv
, spinbutton_b_max
);
414 get_object(builder
, GTK_SPIN_BUTTON
, priv
, spinbutton_b_star
);
416 get_object(builder
, GTK_SPIN_BUTTON
, priv
, spinbutton_c
);
417 get_object(builder
, GTK_SPIN_BUTTON
, priv
, spinbutton_c_min
);
418 get_object(builder
, GTK_SPIN_BUTTON
, priv
, spinbutton_c_max
);
419 get_object(builder
, GTK_SPIN_BUTTON
, priv
, spinbutton_c_star
);
421 get_object(builder
, GTK_SPIN_BUTTON
, priv
, spinbutton_alpha
);
422 get_object(builder
, GTK_SPIN_BUTTON
, priv
, spinbutton_alpha_min
);
423 get_object(builder
, GTK_SPIN_BUTTON
, priv
, spinbutton_alpha_max
);
424 get_object(builder
, GTK_SPIN_BUTTON
, priv
, spinbutton_alpha_star
);
426 get_object(builder
, GTK_SPIN_BUTTON
, priv
, spinbutton_beta
);
427 get_object(builder
, GTK_SPIN_BUTTON
, priv
, spinbutton_beta_min
);
428 get_object(builder
, GTK_SPIN_BUTTON
, priv
, spinbutton_beta_max
);
429 get_object(builder
, GTK_SPIN_BUTTON
, priv
, spinbutton_beta_star
);
431 get_object(builder
, GTK_SPIN_BUTTON
, priv
, spinbutton_gamma
);
432 get_object(builder
, GTK_SPIN_BUTTON
, priv
, spinbutton_gamma_min
);
433 get_object(builder
, GTK_SPIN_BUTTON
, priv
, spinbutton_gamma_max
);
434 get_object(builder
, GTK_SPIN_BUTTON
, priv
, spinbutton_gamma_star
);
436 get_object(builder
, GTK_SPIN_BUTTON
, priv
, spinbutton_lambda
);
438 get_object(builder
, GTK_SPIN_BUTTON
, priv
, spinbutton_ux
);
439 get_object(builder
, GTK_SPIN_BUTTON
, priv
, spinbutton_uy
);
440 get_object(builder
, GTK_SPIN_BUTTON
, priv
, spinbutton_uz
);
442 get_object(builder
, GTK_SPIN_BUTTON
, priv
, spinbutton_U11
);
443 get_object(builder
, GTK_SPIN_BUTTON
, priv
, spinbutton_U12
);
444 get_object(builder
, GTK_SPIN_BUTTON
, priv
, spinbutton_U13
);
445 get_object(builder
, GTK_SPIN_BUTTON
, priv
, spinbutton_U21
);
446 get_object(builder
, GTK_SPIN_BUTTON
, priv
, spinbutton_U22
);
447 get_object(builder
, GTK_SPIN_BUTTON
, priv
, spinbutton_U23
);
448 get_object(builder
, GTK_SPIN_BUTTON
, priv
, spinbutton_U31
);
449 get_object(builder
, GTK_SPIN_BUTTON
, priv
, spinbutton_U32
);
450 get_object(builder
, GTK_SPIN_BUTTON
, priv
, spinbutton_U33
);
453 get_object(builder
, GTK_CHECK_BUTTON
, priv
, checkbutton_a
);
454 get_object(builder
, GTK_CHECK_BUTTON
, priv
, checkbutton_b
);
455 get_object(builder
, GTK_CHECK_BUTTON
, priv
, checkbutton_c
);
456 get_object(builder
, GTK_CHECK_BUTTON
, priv
, checkbutton_alpha
);
457 get_object(builder
, GTK_CHECK_BUTTON
, priv
, checkbutton_beta
);
458 get_object(builder
, GTK_CHECK_BUTTON
, priv
, checkbutton_gamma
);
459 get_object(builder
, GTK_CHECK_BUTTON
, priv
, checkbutton_ux
);
460 get_object(builder
, GTK_CHECK_BUTTON
, priv
, checkbutton_uy
);
461 get_object(builder
, GTK_CHECK_BUTTON
, priv
, checkbutton_uz
);
464 get_object(builder
, GTK_TREE_VIEW
, priv
, treeview_reflections
);
465 get_object(builder
, GTK_TREE_VIEW
, priv
, treeview_crystals
);
466 get_object(builder
, GTK_TREE_VIEW
, priv
, treeview_axes
);
467 get_object(builder
, GTK_TREE_VIEW
, priv
, treeview_pseudo_axes
);
468 get_object(builder
, GTK_TREE_VIEW
, priv
, treeview_solutions
);
470 get_object(builder
, GTK_TOOL_BUTTON
, priv
, toolbutton_add_reflection
);
471 get_object(builder
, GTK_TOOL_BUTTON
, priv
, toolbutton_goto_reflection
);
472 get_object(builder
, GTK_TOOL_BUTTON
, priv
, toolbutton_del_reflection
);
473 get_object(builder
, GTK_TOOL_BUTTON
, priv
, toolbutton_setUB
);
474 get_object(builder
, GTK_TOOL_BUTTON
, priv
, toolbutton_computeUB
);
475 get_object(builder
, GTK_TOOL_BUTTON
, priv
, toolbutton_add_crystal
);
476 get_object(builder
, GTK_TOOL_BUTTON
, priv
, toolbutton_copy_crystal
);
477 get_object(builder
, GTK_TOOL_BUTTON
, priv
, toolbutton_del_crystal
);
478 get_object(builder
, GTK_TOOL_BUTTON
, priv
, toolbutton_affiner
);
480 get_object(builder
, GTK_STATUSBAR
, priv
, statusbar
);
482 get_object(builder
, GTK_IMAGE_MENU_ITEM
, priv
, menuitem5
);
484 get_object(builder
, GTK_VBOX
, priv
, vbox7
);
485 get_object(builder
, GTK_VBOX
, priv
, vbox2
);
486 get_object(builder
, GTK_VBOX
, priv
, box_info_bar
);
488 get_object(builder
, GTK_DIALOG
, priv
, dialog1
);
490 get_object(builder
, GTK_COMBO_BOX
, priv
, combobox1
);
492 gtk_builder_connect_signals (builder
, self
);
496 update_pseudo_axes_frames (HklGuiWindow
* self
)
498 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
499 HklGuiEngine
**engine
;
501 g_return_if_fail (self
!= NULL
);
503 darray_foreach(engine
, priv
->pseudo_frames
){
504 hkl_gui_engine_update(*engine
);
509 raise_error(HklGuiWindow
*self
, GError
**error
)
511 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
513 g_return_if_fail (error
!= NULL
);
515 /* show an error message */
516 gtk_label_set_text (GTK_LABEL (priv
->info_message
),
518 gtk_info_bar_set_message_type (priv
->info_bar
,
520 gtk_widget_show (GTK_WIDGET(priv
->info_bar
));
522 g_clear_error(error
);
526 clear_error(HklGuiWindow
*self
, GError
**error
)
528 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
530 g_return_if_fail (self
!= NULL
);
532 gtk_widget_hide(GTK_WIDGET(priv
->info_bar
));
536 _update_axis (GtkTreeModel
*model
, GtkTreePath
*path
,
537 GtkTreeIter
*iter
, gpointer data
)
539 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(data
);
541 const HklParameter
*axis
;
542 gdouble value
, min
, max
;
544 gtk_tree_model_get (model
, iter
,
545 AXIS_COL_NAME
, &name
,
548 axis
= hkl_geometry_axis_get(priv
->diffractometer
->geometry
, name
, NULL
);
549 hkl_parameter_min_max_get(axis
, &min
, &max
, HKL_UNIT_USER
);
550 value
= hkl_parameter_value_get(axis
, HKL_UNIT_USER
);
552 gtk_list_store_set(GTK_LIST_STORE(model
), iter
,
553 AXIS_COL_READ
, value
,
554 AXIS_COL_WRITE
, value
,
562 update_axes (HklGuiWindow
* self
)
564 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
566 g_return_if_fail (self
!= NULL
);
568 gtk_tree_model_foreach(GTK_TREE_MODEL(priv
->liststore_axis
),
574 _update_pseudo_axes (GtkTreeModel
*model
, GtkTreePath
*path
,
575 GtkTreeIter
*iter
, gpointer data
)
577 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(data
);
579 const HklEngine
*engine
;
580 const HklParameter
*pseudo_axis
;
581 gdouble value
, min
, max
;
583 gtk_tree_model_get (model
, iter
,
584 PSEUDO_AXIS_COL_ENGINE
, &engine
,
585 PSEUDO_AXIS_COL_NAME
, &name
,
588 pseudo_axis
= hkl_engine_pseudo_axis_get(engine
, name
, NULL
);
589 hkl_parameter_min_max_get(pseudo_axis
, &min
, &max
, HKL_UNIT_USER
);
590 value
= hkl_parameter_value_get(pseudo_axis
, HKL_UNIT_USER
);
592 gtk_list_store_set(GTK_LIST_STORE(model
), iter
,
593 PSEUDO_AXIS_COL_READ
, value
,
594 PSEUDO_AXIS_COL_WRITE
, value
,
600 update_pseudo_axes (HklGuiWindow
* self
)
602 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
604 g_return_if_fail (self
!= NULL
);
606 gtk_tree_model_foreach(GTK_TREE_MODEL(priv
->liststore_pseudo_axes
),
612 update_solutions (HklGuiWindow
* self
)
614 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
615 GtkTreeIter iter
= {0};
617 g_return_if_fail (self
!= NULL
);
618 g_return_if_fail (priv
->diffractometer
->solutions
!= NULL
);
620 const HklGeometryListItem
*item
;
621 gtk_list_store_clear(priv
->liststore_solutions
);
623 gint n_values
= gtk_tree_model_get_n_columns (GTK_TREE_MODEL(priv
->liststore_solutions
));
624 GValue
*values
= g_new0(GValue
, n_values
);
625 gint
*columns
= g_new0(gint
, n_values
);
628 /* prepare the GValue before using them */
629 g_value_init(&values
[SOLUTION_COL_INDEX
], G_TYPE_INT
);
630 g_value_init(&values
[SOLUTION_COL_HKL_GEOMETRY_LIST_ITEM
], G_TYPE_POINTER
);
631 for(i
=SOLUTION_COL_N_COLUMNS
; i
<n_values
; ++i
)
632 g_value_init(&values
[i
], G_TYPE_DOUBLE
);
635 HKL_GEOMETRY_LIST_FOREACH(item
, priv
->diffractometer
->solutions
){
636 const HklGeometry
*geometry
= hkl_geometry_list_item_geometry_get(item
);
637 unsigned int n_v
= darray_size(*hkl_geometry_axis_names_get(geometry
));
640 hkl_geometry_axis_values_get(geometry
, v
, n_v
, HKL_UNIT_USER
);
642 g_value_set_int(&values
[SOLUTION_COL_INDEX
], i
);
643 g_value_set_pointer(&values
[SOLUTION_COL_HKL_GEOMETRY_LIST_ITEM
], (gpointer
)item
);
644 columns
[SOLUTION_COL_INDEX
] = SOLUTION_COL_INDEX
;
645 columns
[SOLUTION_COL_HKL_GEOMETRY_LIST_ITEM
] = SOLUTION_COL_HKL_GEOMETRY_LIST_ITEM
;
647 for(unsigned int j
=0; j
<n_v
; ++j
){
648 g_value_set_double(&values
[SOLUTION_COL_N_COLUMNS
+ j
], v
[j
]);
649 columns
[SOLUTION_COL_N_COLUMNS
+ j
] = SOLUTION_COL_N_COLUMNS
+ j
;
651 gtk_list_store_insert_with_valuesv(priv
->liststore_solutions
,
653 columns
, values
, n_values
);
661 update_source (HklGuiWindow
* self
)
663 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
665 g_return_if_fail (self
!= NULL
);
667 gtk_spin_button_set_value (priv
->spinbutton_lambda
,
668 hkl_geometry_wavelength_get(priv
->diffractometer
->geometry
,
673 update_reflections (HklGuiWindow
*self
)
675 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
677 gtk_list_store_clear (priv
->liststore_reflections
);
680 HklSampleReflection
* reflection
;
683 HKL_SAMPLE_REFLECTIONS_FOREACH(reflection
, priv
->sample
){
684 GtkTreeIter iter
= {0};
688 hkl_sample_reflection_hkl_get(reflection
, &h
, &k
, &l
);
689 flag
= hkl_sample_reflection_flag_get(reflection
);
691 gtk_list_store_append (priv
->liststore_reflections
, &iter
);
693 gtk_list_store_set (priv
->liststore_reflections
,
695 REFLECTION_COL_INDEX
, index
++,
699 REFLECTION_COL_FLAG
, flag
,
700 REFLECTION_COL_REFLECTION
, reflection
,
707 update_3d(HklGuiWindow
*self
)
710 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
713 hkl_gui_3d_is_colliding(priv
->frame3d
);
714 hkl_gui_3d_invalidate(priv
->frame3d
);
720 pseudo_axes_frame_changed_cb (HklGuiEngine
*gui_engine
, HklGuiWindow
*self
)
722 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
724 GtkListStore
*liststore
;
726 GtkTreeIter iter
= {0};
728 GError
*error
= NULL
;
730 g_object_get(gui_engine
,
732 "liststore", &liststore
,
735 n_values
= darray_size(*hkl_engine_pseudo_axis_names_get(engine
));
736 gdouble values
[n_values
];
738 /* extract all the values from the listore */
739 valid
= gtk_tree_model_get_iter_first(GTK_TREE_MODEL(liststore
), &iter
);
744 gtk_tree_model_get (GTK_TREE_MODEL(liststore
), &iter
,
745 PSEUDO_COL_IDX
, &it_idx
,
746 PSEUDO_COL_VALUE
, &it_value
,
749 values
[it_idx
] = it_value
;
751 valid
= gtk_tree_model_iter_next(GTK_TREE_MODEL(liststore
), &iter
);
754 if(diffractometer_pseudo_axis_values_set(priv
->diffractometer
, engine
,
755 values
, n_values
, &error
)){
757 update_pseudo_axes (self
);
758 update_pseudo_axes_frames (self
);
759 update_solutions (self
);
762 raise_error(self
, &error
);
764 g_object_unref(liststore
);
769 set_up_pseudo_axes_frames (HklGuiWindow
* self
)
771 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
772 HklGuiEngine
**pseudo
;
775 darray_engine
*engines
;
777 g_return_if_fail (self
!= NULL
);
779 darray_foreach (pseudo
, priv
->pseudo_frames
){
780 gtk_container_remove(GTK_CONTAINER(priv
->vbox2
),
781 GTK_WIDGET (hkl_gui_engine_get_frame (*pseudo
)));
782 g_object_unref(*pseudo
);
784 darray_size (priv
->pseudo_frames
) = 0;
786 engines
= hkl_engine_list_engines_get (priv
->diffractometer
->engines
);
787 darray_foreach (engine
, *engines
){
788 HklGuiEngine
*pseudo
;
790 pseudo
= hkl_gui_engine_new (*engine
);
791 darray_append(priv
->pseudo_frames
, pseudo
);
792 gtk_container_add (GTK_CONTAINER (priv
->vbox2
),
793 GTK_WIDGET (hkl_gui_engine_get_frame(pseudo
)));
795 g_signal_connect_object (pseudo
,
797 G_CALLBACK(pseudo_axes_frame_changed_cb
),
801 gtk_widget_show_all (GTK_WIDGET (priv
->vbox2
));
806 set_up_diffractometer_model (HklGuiWindow
* self
)
808 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
810 HklFactory
**factories
;
812 g_return_if_fail (self
!= NULL
);
814 factories
= hkl_factory_get_all(&n
);
816 GtkTreeIter iter
= {0};
818 gtk_list_store_append (priv
->liststore_diffractometer
, &iter
);
819 gtk_list_store_set (priv
->liststore_diffractometer
, &iter
,
820 DIFFRACTOMETER_COL_NAME
, hkl_factory_name_get(factories
[i
]),
821 DIFFRACTOMETER_COL_FACTORY
, factories
[i
],
822 DIFFRACTOMETER_COL_DIFFRACTOMETER
, NULL
,
828 set_up_tree_view_axes (HklGuiWindow
* self
)
830 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
831 const darray_string
*axes
;
833 GtkCellRenderer
* renderer
= NULL
;
834 GtkTreeViewColumn
* column
= NULL
;
836 GtkTreeIter iter
= {0};
838 gtk_list_store_clear (priv
->liststore_axis
);
840 axes
= hkl_geometry_axis_names_get(priv
->diffractometer
->geometry
);
841 darray_foreach (axis
, *axes
){
842 gtk_list_store_append (priv
->liststore_axis
, &iter
);
843 gtk_list_store_set (priv
->liststore_axis
, &iter
,
844 AXIS_COL_NAME
, *axis
,
852 set_up_tree_view_pseudo_axes (HklGuiWindow
* self
)
854 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
855 HklParameter
**parameter
;
857 const darray_engine
*engines
;
859 gtk_list_store_clear(priv
->liststore_pseudo_axes
);
861 engines
= hkl_engine_list_engines_get(priv
->diffractometer
->engines
);
862 darray_foreach(engine
, *engines
){
863 const darray_string
*pseudo_axes
= hkl_engine_pseudo_axis_names_get(*engine
);
864 GtkTreeIter iter
= {0};
867 for(idx
=0; idx
<darray_size(*pseudo_axes
); ++idx
){
868 gtk_list_store_append (priv
->liststore_pseudo_axes
, &iter
);
869 gtk_list_store_set (priv
->liststore_pseudo_axes
, &iter
,
870 PSEUDO_AXIS_COL_IDX
, idx
,
871 PSEUDO_AXIS_COL_ENGINE
, *engine
,
872 PSEUDO_AXIS_COL_NAME
, darray_item(*pseudo_axes
, idx
),
877 update_pseudo_axes (self
);
881 _delete_column(gpointer data
,
884 gtk_tree_view_remove_column (GTK_TREE_VIEW(user_data
),
885 GTK_TREE_VIEW_COLUMN(data
));
889 set_up_tree_view_solutions (HklGuiWindow
* self
)
891 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
892 const darray_string
*axes
;
894 GtkCellRenderer
* renderer
= NULL
;
895 GtkTreeViewColumn
* column
= NULL
;
900 axes
= hkl_geometry_axis_names_get(priv
->diffractometer
->geometry
);
902 n_columns
= SOLUTION_COL_N_COLUMNS
+ darray_size(*axes
);
904 /* prepare types for the liststore */
905 types
= g_new0 (GType
, n_columns
);
907 /* first remove all the columns */
908 columns
= gtk_tree_view_get_columns (priv
->treeview_solutions
);
909 g_list_foreach(columns
, _delete_column
, priv
->treeview_solutions
);
910 g_list_free(columns
);
912 /* now add the index column */
913 renderer
= gtk_cell_renderer_text_new ();
914 column
= gtk_tree_view_column_new_with_attributes ("index",
916 SOLUTION_COL_INDEX
, NULL
);
918 gtk_tree_view_append_column (priv
->treeview_solutions
, column
);
920 types
[0] = G_TYPE_INT
;
921 types
[1] = G_TYPE_POINTER
;
923 /* add the axes column */
924 for(i
=SOLUTION_COL_N_COLUMNS
; i
<n_columns
; ++i
){
927 axis
= darray_item(*axes
, i
- SOLUTION_COL_N_COLUMNS
);
928 renderer
= gtk_cell_renderer_text_new ();
929 column
= gtk_tree_view_column_new_with_attributes (axis
,
933 gtk_tree_view_append_column (priv
->treeview_solutions
, column
);
934 types
[i
] = G_TYPE_DOUBLE
;
937 if (priv
->liststore_solutions
)
938 g_object_unref(priv
->liststore_solutions
);
939 priv
->liststore_solutions
= gtk_list_store_newv (n_columns
, types
);
942 gtk_tree_view_set_model (priv
->treeview_solutions
,
943 GTK_TREE_MODEL(priv
->liststore_solutions
));
945 update_solutions (self
);
949 set_up_info_bar(HklGuiWindow
*self
)
951 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
952 GtkWidget
*content_area
;
954 g_return_if_fail (self
!= NULL
);
956 /* set up info bar until we can use glade for this purpose or
961 priv
->info_bar
= GTK_INFO_BAR(gtk_info_bar_new ());
962 gtk_widget_set_no_show_all (GTK_WIDGET(priv
->info_bar
), TRUE
);
964 priv
->info_message
= GTK_LABEL(gtk_label_new (""));
965 gtk_widget_show (GTK_WIDGET(priv
->info_message
));
967 content_area
= gtk_info_bar_get_content_area (GTK_INFO_BAR (priv
->info_bar
));
968 gtk_container_add (GTK_CONTAINER (content_area
),
969 GTK_WIDGET(priv
->info_message
));
970 gtk_info_bar_add_button (priv
->info_bar
,
971 GTK_STOCK_OK
, GTK_RESPONSE_OK
);
972 g_signal_connect (priv
->info_bar
, "response",
973 G_CALLBACK (gtk_widget_hide
), NULL
);
975 gtk_box_pack_start(GTK_BOX(priv
->box_info_bar
),
976 GTK_WIDGET(priv
->info_bar
),
981 set_up_lambda(HklGuiWindow
*self
)
983 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
985 g_object_set(G_OBJECT(priv
->spinbutton_lambda
),
989 gtk_spin_button_set_value(priv
->spinbutton_lambda
,
990 hkl_geometry_wavelength_get(priv
->diffractometer
->geometry
,
995 set_up_3D (HklGuiWindow
* self
)
999 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
1000 char *filename
= NULL
;
1001 const char *name
= hkl_factory_name_get(priv
->diffractometer
->factory
);
1003 if(!strcmp("K6C", name
))
1004 filename
= get_model("diffabs.yaml");
1005 else if (!strcmp("K4CV", name
))
1006 filename
= get_model("cristal4C.yaml");
1009 gtk_widget_destroy(GTK_WIDGET(hkl_gui_3d_frame_get(priv
->frame3d
)));
1010 g_object_unref(priv
->frame3d
);
1011 priv
->frame3d
= NULL
;
1015 priv
->frame3d
= hkl_gui_3d_new(filename
, priv
->diffractometer
->geometry
);
1017 gtk_box_pack_start (GTK_BOX(priv
->vbox7
),
1018 GTK_WIDGET(hkl_gui_3d_frame_get(priv
->frame3d
)),
1019 TRUE
, TRUE
, (guint
) 0);
1021 gtk_widget_show_all (GTK_WIDGET(priv
->vbox7
));
1026 /* select diffractometer */
1028 hkl_gui_window_combobox1_changed_cb(GtkComboBox
*combobox
, gpointer
*user_data
)
1030 HklGuiWindow
*self
= HKL_GUI_WINDOW(user_data
);
1031 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(user_data
);
1032 HklFactory
*factory
;
1033 struct diffractometer_t
*dif
= NULL
;
1035 GtkTreeIter iter
= {0};
1037 if(gtk_combo_box_get_active_iter (combobox
, &iter
)){
1038 gtk_tree_model_get(GTK_TREE_MODEL(priv
->liststore_diffractometer
),
1040 DIFFRACTOMETER_COL_FACTORY
, &factory
,
1041 DIFFRACTOMETER_COL_DIFFRACTOMETER
, &dif
,
1045 dif
= create_diffractometer(factory
);
1046 gtk_list_store_set(priv
->liststore_diffractometer
,
1048 DIFFRACTOMETER_COL_DIFFRACTOMETER
, dif
,
1052 if(dif
!= priv
->diffractometer
){
1053 priv
->diffractometer
= dif
;
1055 diffractometer_set_sample(dif
, priv
->sample
);
1057 set_up_lambda(self
);
1058 set_up_pseudo_axes_frames(self
);
1059 set_up_tree_view_axes(self
);
1060 set_up_tree_view_pseudo_axes(self
);
1061 set_up_tree_view_solutions(self
);
1062 set_up_info_bar(self
);
1070 hkl_gui_window_cellrendererspin1_edited_cb(GtkCellRendererText
*renderer
,
1075 HklGuiWindow
*self
= HKL_GUI_WINDOW(user_data
);
1076 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(user_data
);
1077 GtkTreeIter iter
= {0};
1078 gdouble value
= 0.0;
1080 HklParameter
*parameter
;
1082 g_return_if_fail (renderer
!= NULL
);
1083 g_return_if_fail (path
!= NULL
);
1084 g_return_if_fail (new_text
!= NULL
);
1085 g_return_if_fail (user_data
!= NULL
);
1087 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL(priv
->liststore_axis
),
1090 gtk_tree_model_get (GTK_TREE_MODEL(priv
->liststore_axis
), &iter
,
1091 AXIS_COL_NAME
, &axis
,
1094 value
= atof(new_text
); /* TODO need to check for the right conversion */
1096 /* set the axis value */
1097 parameter
= hkl_parameter_new_copy(hkl_geometry_axis_get(priv
->diffractometer
->geometry
,
1099 hkl_parameter_value_set (parameter
, value
, HKL_UNIT_USER
, NULL
);
1100 hkl_geometry_axis_set(priv
->diffractometer
->geometry
,
1101 axis
, parameter
, NULL
);
1102 hkl_parameter_free(parameter
);
1104 hkl_engine_list_get(priv
->diffractometer
->engines
);
1106 /* ok so set the model with the new value */
1107 gtk_list_store_set (priv
->liststore_axis
, &iter
,
1108 AXIS_COL_READ
, value
,
1109 AXIS_COL_WRITE
, value
,
1112 update_pseudo_axes (self
);
1113 update_pseudo_axes_frames (self
);
1119 hkl_gui_window_cellrendererspin3_edited_cb(GtkCellRendererText
*renderer
,
1124 HklGuiWindow
*self
= HKL_GUI_WINDOW(user_data
);
1125 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(user_data
);
1126 GtkTreeIter iter
= {0};
1127 gdouble value
= 0.0;
1129 HklParameter
* parameter
= NULL
;
1132 g_return_if_fail (renderer
!= NULL
);
1133 g_return_if_fail (path
!= NULL
);
1134 g_return_if_fail (new_text
!= NULL
);
1135 g_return_if_fail (user_data
!= NULL
);
1137 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL(priv
->liststore_axis
),
1140 gtk_tree_model_get (GTK_TREE_MODEL(priv
->liststore_axis
), &iter
,
1141 AXIS_COL_NAME
, &axis
,
1144 value
= atof(new_text
); /* TODO need to check for the right conversion */
1146 parameter
= hkl_parameter_new_copy(hkl_geometry_axis_get(priv
->diffractometer
->geometry
,
1148 hkl_parameter_min_max_get (parameter
, &shit
, &max
, HKL_UNIT_USER
);
1149 hkl_parameter_min_max_set (parameter
, value
, max
, HKL_UNIT_USER
, NULL
); /* TODO error */
1150 hkl_geometry_axis_set(priv
->diffractometer
->geometry
,
1151 axis
, parameter
, NULL
);
1152 hkl_parameter_free(parameter
);
1154 gtk_list_store_set (priv
->liststore_axis
, &iter
,
1155 AXIS_COL_MIN
, value
,
1158 update_pseudo_axes (self
);
1164 hkl_gui_window_cellrendererspin4_edited_cb(GtkCellRendererText
*renderer
,
1169 HklGuiWindow
*self
= HKL_GUI_WINDOW(user_data
);
1170 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(user_data
);
1171 GtkTreeIter iter
= {0};
1172 gdouble value
= 0.0;
1174 HklParameter
* parameter
= NULL
;
1177 g_return_if_fail (renderer
!= NULL
);
1178 g_return_if_fail (path
!= NULL
);
1179 g_return_if_fail (new_text
!= NULL
);
1180 g_return_if_fail (user_data
!= NULL
);
1182 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL(priv
->liststore_axis
),
1185 gtk_tree_model_get (GTK_TREE_MODEL(priv
->liststore_axis
), &iter
,
1186 AXIS_COL_NAME
, &axis
,
1189 value
= atof(new_text
); /* TODO need to check for the right conversion */
1192 parameter
= hkl_parameter_new_copy(hkl_geometry_axis_get(priv
->diffractometer
->geometry
,
1194 hkl_parameter_min_max_get (parameter
, &min
, &shit
, HKL_UNIT_USER
);
1195 hkl_parameter_min_max_set (parameter
, min
, value
, HKL_UNIT_USER
, NULL
);
1196 hkl_geometry_axis_set(priv
->diffractometer
->geometry
,
1197 axis
, parameter
, NULL
);
1198 hkl_parameter_free(parameter
);
1201 gtk_list_store_set (priv
->liststore_axis
, &iter
,
1202 AXIS_COL_MAX
, value
,
1205 update_pseudo_axes (self
);
1209 /* pseudo axis write */
1211 hkl_gui_window_cellrenderertext5_edited_cb(GtkCellRendererText
*renderer
,
1216 HklGuiWindow
*self
= HKL_GUI_WINDOW(user_data
);
1217 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(user_data
);
1218 GtkTreeIter iter
= {0};
1219 gdouble value
= 0.0;
1222 HklEngine
*engine
= NULL
;
1224 GtkTreeIter it
= {0};
1226 GError
*error
= NULL
;
1228 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL(priv
->liststore_pseudo_axes
),
1231 gtk_tree_model_get (GTK_TREE_MODEL(priv
->liststore_pseudo_axes
), &iter
,
1232 PSEUDO_AXIS_COL_IDX
, &idx
,
1233 PSEUDO_AXIS_COL_ENGINE
, &engine
,
1234 PSEUDO_AXIS_COL_WRITE
, &old_value
,
1237 n_values
= darray_size(*hkl_engine_pseudo_axis_names_get(engine
));
1238 gdouble values
[n_values
];
1240 /* extract all the values from the listore */
1242 valid
= gtk_tree_model_get_iter_first(GTK_TREE_MODEL(priv
->liststore_pseudo_axes
), &it
);
1245 HklEngine
*it_engine
;
1248 gtk_tree_model_get (GTK_TREE_MODEL(priv
->liststore_pseudo_axes
), &it
,
1249 PSEUDO_AXIS_COL_IDX
, &it_idx
,
1250 PSEUDO_AXIS_COL_ENGINE
, &it_engine
,
1251 PSEUDO_AXIS_COL_WRITE
, &it_value
,
1254 if(engine
== it_engine
)
1255 values
[it_idx
] = it_value
;
1257 valid
= gtk_tree_model_iter_next(GTK_TREE_MODEL(priv
->liststore_pseudo_axes
), &it
);
1260 /* replace with the new value */
1261 value
= atof(new_text
); /* TODO need to check for the right conversion */
1262 values
[idx
] = value
;
1264 if(diffractometer_pseudo_axis_values_set(priv
->diffractometer
, engine
,
1265 values
, n_values
, &error
)){
1266 gtk_list_store_set (priv
->liststore_pseudo_axes
,
1268 PSEUDO_AXIS_COL_WRITE
, value
,
1272 update_pseudo_axes (self
);
1273 update_pseudo_axes_frames (self
);
1274 update_solutions (self
);
1277 raise_error(self
, &error
);
1282 hkl_gui_window_treeview_solutions_cursor_changed_cb (GtkTreeView
*tree_view
,
1285 HklGuiWindow
* self
= HKL_GUI_WINDOW(user_data
);
1286 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(user_data
);
1288 GtkTreePath
* path
= NULL
;
1289 GtkTreeViewColumn
* focus_column
= NULL
;
1290 GtkTreeIter iter
= {0};
1291 const HklGeometryListItem
*solution
;
1293 gtk_tree_view_get_cursor (tree_view
, &path
, &focus_column
);
1294 gtk_tree_model_get_iter (GTK_TREE_MODEL(priv
->liststore_solutions
), &iter
, path
);
1295 gtk_tree_model_get (GTK_TREE_MODEL(priv
->liststore_solutions
), &iter
,
1296 SOLUTION_COL_HKL_GEOMETRY_LIST_ITEM
, &solution
,
1299 diffractometer_set_solution(priv
->diffractometer
, solution
);
1302 update_pseudo_axes (self
);
1303 update_pseudo_axes_frames (self
);
1306 gtk_tree_path_free (path
);
1309 /* reflection h k l */
1310 #define HKL_GUI_WINDOW_CELLRENDERERTEXT_HKL_EDITED_CB(_number, _hkl, _HKL) \
1312 hkl_gui_window_cellrenderertext ## _number ## _edited_cb(GtkCellRendererText* _sender, const gchar* path, \
1313 const gchar* new_text, gpointer user_data) \
1315 HklGuiWindow *self = HKL_GUI_WINDOW(user_data); \
1316 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(user_data); \
1318 g_return_if_fail (self != NULL); \
1319 g_return_if_fail (path != NULL); \
1320 g_return_if_fail (new_text != NULL); \
1322 if (priv->sample){ \
1326 HklSampleReflection* reflection = NULL; \
1327 GtkTreeIter iter = {0}; \
1328 GError *error = NULL; \
1330 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL(priv->liststore_reflections), \
1332 gtk_tree_model_get (GTK_TREE_MODEL(priv->liststore_reflections), \
1334 REFLECTION_COL_REFLECTION, &reflection, \
1337 hkl_sample_reflection_hkl_get (reflection, &h, &k, &l); \
1338 _hkl = atof(new_text); \
1339 if(!hkl_sample_reflection_hkl_set (reflection, h, k, l, NULL)) \
1340 raise_error(self, &error); \
1342 gtk_list_store_set (priv->liststore_reflections, \
1344 REFLECTION_COL_ ## _HKL, _hkl, \
1349 HKL_GUI_WINDOW_CELLRENDERERTEXT_HKL_EDITED_CB(7, h
, H
);
1350 HKL_GUI_WINDOW_CELLRENDERERTEXT_HKL_EDITED_CB(8, k
, K
);
1351 HKL_GUI_WINDOW_CELLRENDERERTEXT_HKL_EDITED_CB(9, l
, L
);
1354 /* reflection flag */
1356 hkl_gui_window_cellrenderertoggle1_toggled_cb (GtkCellRendererToggle
* renderer
, const gchar
* path
,
1359 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
1361 g_return_if_fail (self
!= NULL
);
1362 g_return_if_fail (path
!= NULL
);
1366 HklSampleReflection
* reflection
= NULL
;
1367 GtkTreeIter iter
= {0};
1369 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL(priv
->liststore_reflections
),
1371 gtk_tree_model_get (GTK_TREE_MODEL(priv
->liststore_reflections
),
1373 REFLECTION_COL_REFLECTION
, &reflection
,
1376 flag
= gtk_cell_renderer_toggle_get_active(renderer
);
1377 hkl_sample_reflection_flag_set (reflection
, flag
);
1378 gtk_list_store_set (priv
->liststore_reflections
,
1380 REFLECTION_COL_FLAG
, flag
,
1386 hkl_gui_window_treeview_reflections_key_press_event_cb (GtkWidget
* _sender
, GdkEventKey
* event
,
1393 hkl_gui_window_toolbutton_add_reflection_clicked_cb(GtkToolButton
* _sender
,
1396 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
1398 if (priv
->diffractometer
== NULL
){
1399 gtk_statusbar_push (priv
->statusbar
, 0,
1400 "Please select a diffractometer before adding reflections");
1405 HklSampleReflection
*reflection
= NULL
;
1406 GtkTreeIter iter
= {0};
1409 GError
*error
= NULL
;
1411 reflection
= hkl_sample_reflection_new(priv
->diffractometer
->geometry
,
1412 priv
->diffractometer
->detector
,
1415 raise_error(self
, &error
);
1417 hkl_sample_add_reflection(priv
->sample
, reflection
);
1418 flag
= hkl_sample_reflection_flag_get(reflection
);
1420 n_rows
= gtk_tree_model_iter_n_children(GTK_TREE_MODEL(priv
->liststore_reflections
),
1422 gtk_list_store_insert_with_values (priv
->liststore_reflections
,
1424 REFLECTION_COL_INDEX
, n_rows
,
1425 REFLECTION_COL_H
, 0.,
1426 REFLECTION_COL_K
, 0.,
1427 REFLECTION_COL_L
, 0.,
1428 REFLECTION_COL_FLAG
, flag
,
1429 REFLECTION_COL_REFLECTION
, reflection
,
1436 hkl_gui_window_toolbutton_goto_reflection_clicked_cb (GtkToolButton
* _sender
, gpointer user_data
)
1438 HklGuiWindow
*self
= HKL_GUI_WINDOW(user_data
);
1439 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(user_data
);
1441 g_return_if_fail (self
!= NULL
);
1444 GtkTreeSelection
* selection
= NULL
;
1447 selection
= gtk_tree_view_get_selection (priv
->treeview_reflections
);
1448 nb_rows
= gtk_tree_selection_count_selected_rows (selection
);
1451 HklSampleReflection
*reflection
;
1452 GtkTreeIter iter
= {0};
1453 GtkTreeModel
* model
= NULL
;
1454 GtkTreePath
*treepath
;
1457 model
= GTK_TREE_MODEL(priv
->liststore_reflections
);
1459 list
= gtk_tree_selection_get_selected_rows (selection
,
1462 treepath
= g_list_nth_data(list
, 0);
1464 gtk_tree_model_get_iter (GTK_TREE_MODEL(priv
->liststore_reflections
),
1467 gtk_tree_model_get (GTK_TREE_MODEL(priv
->liststore_reflections
),
1469 REFLECTION_COL_REFLECTION
, &reflection
,
1472 hkl_geometry_set (priv
->diffractometer
->geometry
,
1473 hkl_sample_reflection_geometry_get(reflection
));
1475 update_source (self
);
1477 update_pseudo_axes (self
);
1480 g_list_free_full (list
, (GDestroyNotify
) gtk_tree_path_free
);
1483 gtk_statusbar_push (priv
->statusbar
, 0,
1484 "Please select only one reflection.");
1486 gtk_statusbar_push (priv
->statusbar
, 0,
1487 "Please select at least one reflection.");
1492 _del_reflection(gpointer data
, gpointer user_data
)
1494 HklSampleReflection
*reflection
;
1495 GtkTreeIter iter
= {0};
1496 GtkTreePath
*treepath
= data
;
1497 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(user_data
);
1499 gtk_tree_model_get_iter (GTK_TREE_MODEL(priv
->liststore_reflections
),
1502 gtk_tree_model_get (GTK_TREE_MODEL(priv
->liststore_reflections
),
1504 REFLECTION_COL_REFLECTION
, &reflection
,
1506 hkl_sample_del_reflection(priv
->sample
, reflection
);
1510 hkl_gui_window_toolbutton_del_reflection_clicked_cb (GtkToolButton
* _sender
, gpointer user_data
)
1512 HklGuiWindow
*self
= HKL_GUI_WINDOW(user_data
);
1513 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(user_data
);
1514 HklSample
* sample
= NULL
;
1516 g_return_if_fail (self
!= NULL
);
1519 GtkTreeSelection
* selection
= NULL
;
1522 selection
= gtk_tree_view_get_selection (priv
->treeview_reflections
);
1523 nb_rows
= gtk_tree_selection_count_selected_rows (selection
);
1525 GtkTreeModel
* model
= NULL
;
1529 GtkMessageDialog
* dialog
;
1531 model
= GTK_TREE_MODEL(priv
->liststore_reflections
);
1532 list
= gtk_tree_selection_get_selected_rows (selection
, &model
);
1535 dialog
= GTK_MESSAGE_DIALOG(
1536 gtk_message_dialog_new (NULL
,
1537 GTK_DIALOG_DESTROY_WITH_PARENT
,
1538 GTK_MESSAGE_WARNING
,
1540 "Are you sure that you want to delete reflections"));
1542 switch (gtk_dialog_run (GTK_DIALOG(dialog
))) {
1543 case GTK_RESPONSE_YES
:
1545 g_list_foreach(list
, _del_reflection
, self
);
1546 update_reflections (self
);
1552 gtk_widget_destroy (GTK_WIDGET(dialog
));
1553 g_list_free_full (list
, (GDestroyNotify
) gtk_tree_path_free
);
1555 gtk_statusbar_push (priv
->statusbar
, 0,
1556 "Please select at least one reflection.");
1562 set_up_tree_view_reflections(HklGuiWindow
*self
)
1564 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
1565 GtkTreeSelection
* selection
= NULL
;
1567 selection
= gtk_tree_view_get_selection (priv
->treeview_reflections
);
1568 gtk_tree_selection_set_mode(selection
, GTK_SELECTION_MULTIPLE
);
1573 hkl_gui_window_cellrenderertext10_edited_cb(GtkCellRendererText
* _sender
, const gchar
* path
,
1574 const gchar
* new_text
, gpointer user_data
)
1576 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(user_data
);
1578 GtkTreeModel
* model
= NULL
;
1579 GtkTreeIter iter
= {0};
1580 HklSample
* sample
= NULL
;
1583 g_return_if_fail (user_data
!= NULL
);
1584 g_return_if_fail (path
!= NULL
);
1585 g_return_if_fail (new_text
!= NULL
);
1587 model
= GTK_TREE_MODEL(priv
->liststore_crystals
);
1589 gtk_tree_model_get_iter_from_string (model
, &iter
, path
);
1591 gtk_tree_model_get (model
, &iter
,
1592 SAMPLE_COL_SAMPLE
, &sample
,
1595 hkl_sample_name_set (sample
, new_text
);
1597 gtk_list_store_set(priv
->liststore_crystals
, &iter
,
1598 SAMPLE_COL_NAME
, new_text
,
1602 #define set_lattice(lattice, parameter) do{ \
1603 const HklParameter *p; \
1604 gdouble min, max, value; \
1606 p = hkl_lattice_## parameter ##_get((lattice)); \
1607 value = hkl_parameter_value_get(p, HKL_UNIT_USER); \
1608 hkl_parameter_min_max_get(p, &min, &max, HKL_UNIT_USER); \
1609 fit = hkl_parameter_fit_get(p); \
1610 gtk_spin_button_set_value(priv->spinbutton_## parameter, value); \
1611 gtk_spin_button_set_value(priv->spinbutton_## parameter ##_min, min); \
1612 gtk_spin_button_set_value(priv->spinbutton_## parameter ##_max, max); \
1613 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(priv->checkbutton_ ## parameter), fit); \
1617 update_lattice (HklGuiWindow
* self
)
1619 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
1621 g_return_if_fail (self
!= NULL
);
1623 if (priv
->sample
!= NULL
) {
1624 const HklLattice
*lattice
;
1625 lattice
= hkl_sample_lattice_get(priv
->sample
);
1626 set_lattice(lattice
, a
);
1627 set_lattice(lattice
, b
);
1628 set_lattice(lattice
, c
);
1629 set_lattice(lattice
, alpha
);
1630 set_lattice(lattice
, beta
);
1631 set_lattice(lattice
, gamma
);
1635 #define set_reciprocal_lattice(lattice, parameter) do{ \
1636 const HklParameter *p; \
1638 p = hkl_lattice_## parameter ##_get((lattice)); \
1639 value = hkl_parameter_value_get(p, HKL_UNIT_USER); \
1640 gtk_spin_button_set_value(priv->spinbutton_## parameter ##_star, value); \
1644 update_reciprocal_lattice (HklGuiWindow
* self
)
1646 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
1648 g_return_if_fail (self
!= NULL
);
1650 if (priv
->sample
!= NULL
) {
1651 hkl_lattice_reciprocal (hkl_sample_lattice_get(priv
->sample
),
1654 set_reciprocal_lattice(priv
->reciprocal
, a
);
1655 set_reciprocal_lattice(priv
->reciprocal
, b
);
1656 set_reciprocal_lattice(priv
->reciprocal
, c
);
1657 set_reciprocal_lattice(priv
->reciprocal
, alpha
);
1658 set_reciprocal_lattice(priv
->reciprocal
, beta
);
1659 set_reciprocal_lattice(priv
->reciprocal
, gamma
);
1663 #define set_ux_uy_uz(sample, parameter) do { \
1664 const HklParameter *p; \
1665 p = hkl_sample_## parameter ##_get((sample)); \
1666 gboolean fit = hkl_parameter_fit_get(p); \
1667 gtk_spin_button_set_value(priv->spinbutton_## parameter, \
1668 hkl_parameter_value_get(p, HKL_UNIT_USER)); \
1669 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(priv->checkbutton_## parameter), fit); \
1673 update_ux_uy_uz (HklGuiWindow
* self
)
1675 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
1677 g_return_if_fail (self
!= NULL
);
1679 if (priv
->sample
!= NULL
) {
1680 set_ux_uy_uz(priv
->sample
, ux
);
1681 set_ux_uy_uz(priv
->sample
, uy
);
1682 set_ux_uy_uz(priv
->sample
, uz
);
1686 #define set_UB(i, j) do{ \
1687 gtk_label_set_markup(priv->label_UB ## i ## j, \
1688 g_ascii_formatd(text, \
1689 G_ASCII_DTOSTR_BUF_SIZE, \
1690 "<tt> %+.4f </tt>", \
1691 hkl_matrix_get(UB, i - 1, j - 1))); \
1695 update_UB (HklGuiWindow
* self
)
1697 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
1699 g_return_if_fail (self
!= NULL
);
1701 if (priv
->sample
!= NULL
) {
1702 const HklMatrix
*UB
= hkl_sample_UB_get (priv
->sample
);
1703 gchar
*text
= g_new0 (gchar
, G_ASCII_DTOSTR_BUF_SIZE
);
1720 hkl_gui_window_treeview_crystals_cursor_changed_cb (GtkTreeView
* _sender
, gpointer user_data
)
1722 GtkTreePath
* path
= NULL
;
1723 GtkTreeViewColumn
* column
= NULL
;
1724 GtkTreeIter iter
= {0};
1726 HklGuiWindow
*self
= HKL_GUI_WINDOW(user_data
);
1727 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(user_data
);
1730 g_return_if_fail (user_data
!= NULL
);
1732 gtk_tree_view_get_cursor (priv
->treeview_crystals
, &path
, &column
);
1734 if (gtk_tree_model_get_iter (GTK_TREE_MODEL(priv
->liststore_crystals
),
1735 &iter
, path
) == TRUE
){
1736 gtk_tree_model_get (GTK_TREE_MODEL(priv
->liststore_crystals
),
1738 SAMPLE_COL_SAMPLE
, &sample
,
1741 if(sample
&& sample
!= priv
->sample
){
1742 priv
->sample
= sample
;
1744 update_reflections(self
);
1745 update_lattice(self
);
1746 update_reciprocal_lattice (self
);
1747 update_ux_uy_uz (self
);
1750 if(priv
->diffractometer
){
1751 diffractometer_set_sample(priv
->diffractometer
,
1754 update_pseudo_axes (self
);
1755 update_pseudo_axes_frames (self
);
1756 update_solutions(self
);
1760 gtk_tree_path_free (path
);
1767 _add_sample(HklGuiWindow
*self
, HklSample
*sample
)
1769 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
1770 GtkTreeIter iter
= {0};
1771 const HklLattice
*lattice
;
1772 gdouble a
, b
, c
, alpha
, beta
, gamma
;
1774 g_return_val_if_fail (self
!= NULL
, iter
);
1776 lattice
= hkl_sample_lattice_get(sample
);
1777 a
= hkl_parameter_value_get(hkl_lattice_a_get(lattice
), HKL_UNIT_USER
);
1778 b
= hkl_parameter_value_get(hkl_lattice_b_get(lattice
), HKL_UNIT_USER
);
1779 c
= hkl_parameter_value_get(hkl_lattice_c_get(lattice
), HKL_UNIT_USER
);
1780 alpha
= hkl_parameter_value_get(hkl_lattice_alpha_get(lattice
),
1782 beta
= hkl_parameter_value_get(hkl_lattice_beta_get(lattice
),
1784 gamma
= hkl_parameter_value_get(hkl_lattice_gamma_get(lattice
),
1787 gtk_list_store_insert_with_values(priv
->liststore_crystals
,
1789 SAMPLE_COL_SAMPLE
, sample
,
1790 SAMPLE_COL_NAME
, hkl_sample_name_get(sample
),
1794 SAMPLE_COL_ALPHA
, alpha
,
1795 SAMPLE_COL_BETA
, beta
,
1796 SAMPLE_COL_GAMMA
, gamma
,
1802 set_up_tree_view_crystals (HklGuiWindow
* self
)
1804 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
1805 GtkTreeIter iter
= {0};
1806 GtkTreePath
*path
= NULL
;
1808 g_return_if_fail (self
!= NULL
);
1810 iter
= _add_sample(self
, hkl_sample_new("default"));
1812 path
= gtk_tree_model_get_path(GTK_TREE_MODEL(priv
->liststore_crystals
),
1815 gtk_tree_view_set_cursor(priv
->treeview_crystals
, path
, NULL
, FALSE
);
1817 gtk_tree_path_free(path
);
1821 _add_sample_and_edit_name(HklGuiWindow
*self
, HklSample
*sample
)
1823 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
1824 GtkTreeIter iter
= {0};
1825 GtkTreePath
* path
= NULL
;
1826 GtkTreeViewColumn
* column
= NULL
;
1828 iter
= _add_sample(self
, sample
);
1830 path
= gtk_tree_model_get_path(GTK_TREE_MODEL(priv
->liststore_crystals
),
1832 column
= gtk_tree_view_get_column (priv
->treeview_crystals
, 0);
1833 gtk_tree_view_set_cursor (priv
->treeview_crystals
, path
, column
, TRUE
);
1835 gtk_tree_path_free(path
);
1839 hkl_gui_window_toolbutton_add_crystal_clicked_cb (GtkToolButton
* _sender
, gpointer user_data
)
1841 HklGuiWindow
*self
= HKL_GUI_WINDOW(user_data
);
1842 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(user_data
);
1845 g_return_if_fail (user_data
!= NULL
);
1847 sample
= hkl_sample_new ("new");
1849 _add_sample_and_edit_name(self
, sample
);
1853 hkl_gui_window_toolbutton_copy_crystal_clicked_cb (GtkToolButton
* _sender
, gpointer user_data
)
1855 HklGuiWindow
*self
= HKL_GUI_WINDOW(user_data
);
1856 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(user_data
);
1857 HklSample
*copy
= NULL
;
1859 g_return_if_fail (self
!= NULL
);
1862 copy
= hkl_sample_new_copy(priv
->sample
);
1864 _add_sample_and_edit_name(self
, copy
);
1866 gtk_statusbar_push (priv
->statusbar
, (guint
) 0, "Please select a crystal to copy.");
1870 hkl_gui_window_toolbutton_del_crystal_clicked_cb (GtkToolButton
* _sender
, gpointer user_data
)
1872 HklGuiWindow
*self
= HKL_GUI_WINDOW(user_data
);
1873 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(user_data
);
1875 g_return_if_fail (user_data
!= NULL
);
1877 if (priv
->sample
!= NULL
) {
1880 n_rows
= gtk_tree_model_iter_n_children(GTK_TREE_MODEL(priv
->liststore_crystals
),
1885 GtkTreeIter iter
= {0};
1886 GtkTreePath
*path
= NULL
;
1887 GtkTreeViewColumn
*column
= NULL
;
1889 gtk_tree_view_get_cursor(priv
->treeview_crystals
,
1892 if (gtk_tree_model_get_iter (GTK_TREE_MODEL(priv
->liststore_crystals
),
1893 &iter
, path
) == TRUE
) {
1894 gtk_tree_path_free(path
);
1896 hkl_sample_free(priv
->sample
);
1897 if (gtk_list_store_remove(priv
->liststore_crystals
,
1899 path
= gtk_tree_model_get_path(GTK_TREE_MODEL(priv
->liststore_crystals
),
1901 gtk_tree_view_set_cursor(priv
->treeview_crystals
,
1910 #define get_lattice_parameter(lattice, parameter, _error) do{ \
1911 HklParameter *p = hkl_parameter_new_copy(hkl_lattice_## parameter ##_get(lattice)); \
1912 if(!hkl_parameter_min_max_set(p, \
1913 gtk_spin_button_get_value(priv->spinbutton_## parameter ##_min), \
1914 gtk_spin_button_get_value(priv->spinbutton_## parameter ##_max), \
1915 HKL_UNIT_USER, _error)){ \
1916 raise_error(self, _error); \
1917 hkl_parameter_free(p); \
1920 hkl_parameter_fit_set(p, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->checkbutton_## parameter))); \
1921 if(!hkl_lattice_ ## parameter ## _set(lattice, p, _error)){ \
1922 raise_error(self, _error); \
1923 hkl_parameter_free(p); \
1927 hkl_parameter_free(p); \
1930 #define get_ux_uy_uz(sample, parameter, _error) do { \
1932 p = hkl_parameter_new_copy(hkl_sample_## parameter ##_get(sample)); \
1933 if(!hkl_parameter_value_set(p, \
1934 gtk_spin_button_get_value (priv->spinbutton_## parameter), \
1935 HKL_UNIT_USER, _error)){ \
1936 raise_error(self, _error); \
1937 hkl_parameter_free(p); \
1940 hkl_parameter_fit_set(p, \
1941 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->checkbutton_## parameter))); \
1942 if(!hkl_sample_ ## parameter ## _set(sample, p, _error)){ \
1943 raise_error(self, _error); \
1944 hkl_parameter_free(p); \
1948 hkl_parameter_free(p); \
1953 _update_crystal_model(GtkTreeModel
*model
,
1958 HklGuiWindow
*self
= HKL_GUI_WINDOW(data
);
1959 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(data
);
1960 HklSample
*sample
= NULL
;
1962 gtk_tree_model_get(model
, iter
,
1963 SAMPLE_COL_SAMPLE
, &sample
,
1965 if(priv
->sample
== sample
){
1966 const HklLattice
*lattice
;
1967 gdouble a
, b
, c
, alpha
, beta
, gamma
;
1969 lattice
= hkl_sample_lattice_get(sample
);
1970 a
= hkl_parameter_value_get(hkl_lattice_a_get(lattice
),
1972 b
= hkl_parameter_value_get(hkl_lattice_b_get(lattice
),
1974 c
= hkl_parameter_value_get(hkl_lattice_c_get(lattice
),
1976 alpha
= hkl_parameter_value_get(hkl_lattice_alpha_get(lattice
),
1978 beta
= hkl_parameter_value_get(hkl_lattice_beta_get(lattice
),
1980 gamma
= hkl_parameter_value_get(hkl_lattice_gamma_get(lattice
),
1983 gtk_list_store_set(priv
->liststore_crystals
,
1985 SAMPLE_COL_NAME
, hkl_sample_name_get(sample
),
1989 SAMPLE_COL_ALPHA
, alpha
,
1990 SAMPLE_COL_BETA
, beta
,
1991 SAMPLE_COL_GAMMA
, gamma
,
1999 update_crystal_model(HklGuiWindow
*self
)
2001 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
2003 gtk_tree_model_foreach(GTK_TREE_MODEL(priv
->liststore_crystals
),
2004 _update_crystal_model
,
2008 /* apply crystal parameters */
2010 hkl_gui_window_button2_clicked_cb (GtkButton
* _sender
, gpointer user_data
)
2012 HklGuiWindow
*self
= HKL_GUI_WINDOW(user_data
);
2013 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(user_data
);
2015 g_return_if_fail (self
!= NULL
);
2017 if (priv
->sample
!= NULL
) {
2018 gdouble a
, b
, c
, alpha
, beta
, gamma
;
2020 HklLattice
*lattice
;
2022 GError
*error
= NULL
;
2024 fprintf(stderr
, "%s\n", __func__
);
2025 /* lattice parameters */
2026 a
= gtk_spin_button_get_value (priv
->spinbutton_a
);
2027 b
= gtk_spin_button_get_value (priv
->spinbutton_b
);
2028 c
= gtk_spin_button_get_value (priv
->spinbutton_c
);
2029 alpha
= gtk_spin_button_get_value (priv
->spinbutton_alpha
);
2030 beta
= gtk_spin_button_get_value (priv
->spinbutton_beta
);
2031 gamma
= gtk_spin_button_get_value (priv
->spinbutton_gamma
);
2033 lattice
= hkl_lattice_new(a
, b
, c
,
2034 alpha
* HKL_DEGTORAD
,
2035 beta
* HKL_DEGTORAD
,
2036 gamma
* HKL_DEGTORAD
, &error
);
2038 raise_error(self
, &error
);
2041 get_lattice_parameter(lattice
, a
, &error
);
2042 get_lattice_parameter(lattice
, b
, &error
);
2043 get_lattice_parameter(lattice
, c
, &error
);
2044 get_lattice_parameter(lattice
, alpha
, &error
);
2045 get_lattice_parameter(lattice
, beta
, &error
);
2046 get_lattice_parameter(lattice
, gamma
, &error
);
2048 hkl_sample_lattice_set(priv
->sample
, lattice
);
2050 hkl_lattice_free(lattice
);
2053 get_ux_uy_uz(priv
->sample
, ux
, &error
);
2054 get_ux_uy_uz(priv
->sample
, uy
, &error
);
2055 get_ux_uy_uz(priv
->sample
, uz
, &error
);
2057 if(priv
->diffractometer
)
2058 diffractometer_set_sample(priv
->diffractometer
,
2061 update_crystal_model (self
);
2062 update_reciprocal_lattice (self
);
2064 update_pseudo_axes (self
);
2065 update_pseudo_axes_frames (self
);
2071 hkl_gui_window_spinbutton_lambda_value_changed_cb (GtkSpinButton
* _sender
, gpointer user_data
)
2073 HklGuiWindow
*self
= HKL_GUI_WINDOW(user_data
);
2074 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(user_data
);
2076 diffractometer_set_wavelength(priv
->diffractometer
,
2077 gtk_spin_button_get_value(_sender
));
2078 update_pseudo_axes (self
);
2079 update_pseudo_axes_frames (self
);
2083 hkl_gui_window_spinbutton_ux_value_changed_cb (GtkSpinButton
*_senser
, gpointer user_data
)
2085 HklGuiWindow
*self
= HKL_GUI_WINDOW(user_data
);
2086 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(user_data
);
2087 GError
*error
= NULL
;
2089 get_ux_uy_uz(priv
->sample
, ux
, &error
);
2091 if(priv
->diffractometer
)
2092 diffractometer_set_sample(priv
->diffractometer
,
2096 update_pseudo_axes (self
);
2097 update_pseudo_axes_frames (self
);
2101 hkl_gui_window_spinbutton_uy_value_changed_cb (GtkSpinButton
*_senser
, gpointer user_data
)
2103 HklGuiWindow
*self
= HKL_GUI_WINDOW(user_data
);
2104 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(user_data
);
2105 GError
*error
= NULL
;
2107 get_ux_uy_uz(priv
->sample
, uy
, &error
);
2109 if(priv
->diffractometer
)
2110 diffractometer_set_sample(priv
->diffractometer
,
2114 update_pseudo_axes (self
);
2115 update_pseudo_axes_frames (self
);
2119 hkl_gui_window_spinbutton_uz_value_changed_cb (GtkSpinButton
*_senser
, gpointer user_data
)
2121 HklGuiWindow
*self
= HKL_GUI_WINDOW(user_data
);
2122 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(user_data
);
2123 GError
*error
= NULL
;
2125 get_ux_uy_uz(priv
->sample
, uz
, &error
);
2127 if(priv
->diffractometer
)
2128 diffractometer_set_sample(priv
->diffractometer
,
2132 update_pseudo_axes (self
);
2133 update_pseudo_axes_frames (self
);
2137 hkl_gui_window_toolbutton_setUB_clicked_cb(GtkToolButton
* _sender
, gpointer user_data
)
2139 HklGuiWindow
*self
= HKL_GUI_WINDOW(user_data
);
2140 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(user_data
);
2143 GError
*error
= NULL
;
2145 UB
= hkl_matrix_new_full(gtk_spin_button_get_value(priv
->spinbutton_U11
),
2146 gtk_spin_button_get_value(priv
->spinbutton_U12
),
2147 gtk_spin_button_get_value(priv
->spinbutton_U13
),
2148 gtk_spin_button_get_value(priv
->spinbutton_U21
),
2149 gtk_spin_button_get_value(priv
->spinbutton_U22
),
2150 gtk_spin_button_get_value(priv
->spinbutton_U23
),
2151 gtk_spin_button_get_value(priv
->spinbutton_U31
),
2152 gtk_spin_button_get_value(priv
->spinbutton_U32
),
2153 gtk_spin_button_get_value(priv
->spinbutton_U33
));
2155 if(!hkl_sample_UB_set (priv
->sample
, UB
, &error
))
2156 raise_error(self
, &error
);
2158 if(priv
->diffractometer
){
2159 diffractometer_set_sample(priv
->diffractometer
,
2162 update_lattice (self
);
2163 update_crystal_model (self
);
2164 update_reciprocal_lattice (self
);
2166 update_ux_uy_uz (self
);
2167 update_pseudo_axes (self
);
2168 update_pseudo_axes_frames (self
);
2172 hkl_matrix_free(UB
);
2176 hkl_gui_window_toolbutton_computeUB_clicked_cb (GtkToolButton
* _sender
, gpointer user_data
)
2178 HklGuiWindow
*self
= HKL_GUI_WINDOW(user_data
);
2179 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(user_data
);
2180 GtkTreeSelection
* selection
= NULL
;
2183 selection
= gtk_tree_view_get_selection (priv
->treeview_reflections
);
2184 nb_rows
= gtk_tree_selection_count_selected_rows (selection
);
2186 GtkTreeModel
* model
= NULL
;
2188 GtkTreeIter iter
= {0};
2190 HklSampleReflection
*ref1
, *ref2
;
2191 GError
*error
= NULL
;
2193 model
= GTK_TREE_MODEL(priv
->liststore_reflections
);
2194 list
= gtk_tree_selection_get_selected_rows (selection
, &model
);
2196 /* get the first reflection */
2197 path
= g_list_nth_data(list
, 0);
2198 gtk_tree_model_get_iter (GTK_TREE_MODEL(priv
->liststore_reflections
),
2201 gtk_tree_model_get (GTK_TREE_MODEL(priv
->liststore_reflections
), &iter
,
2202 REFLECTION_COL_REFLECTION
, &ref1
,
2205 /* get the second one */
2206 path
= g_list_nth_data(list
, 1);
2207 gtk_tree_model_get_iter (GTK_TREE_MODEL(priv
->liststore_reflections
),
2210 gtk_tree_model_get (GTK_TREE_MODEL(priv
->liststore_reflections
), &iter
,
2211 REFLECTION_COL_REFLECTION
, &ref2
,
2214 if(!hkl_sample_compute_UB_busing_levy(priv
->sample
,
2215 ref1
, ref2
, &error
)){
2216 raise_error(self
, &error
);
2218 if(priv
->diffractometer
)
2219 diffractometer_set_sample(priv
->diffractometer
,
2223 update_ux_uy_uz (self
);
2224 update_pseudo_axes (self
);
2225 update_pseudo_axes_frames (self
);
2227 g_list_free_full (list
, (GDestroyNotify
) gtk_tree_path_free
);
2229 gtk_statusbar_push (priv
->statusbar
, 0,
2230 "Please select at least two reflection.");
2235 hkl_gui_window_toolbutton_affiner_clicked_cb (GtkToolButton
* _sender
, gpointer user_data
)
2237 HklGuiWindow
*self
= HKL_GUI_WINDOW(user_data
);
2238 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(user_data
);
2239 GError
*error
= NULL
;
2241 if(!hkl_sample_affine (priv
->sample
, &error
)){
2242 raise_error(self
, &error
);
2244 if(priv
->diffractometer
)
2245 diffractometer_set_sample(priv
->diffractometer
,
2248 update_lattice (self
);
2249 update_crystal_model (self
);
2250 update_reciprocal_lattice (self
);
2252 update_ux_uy_uz (self
);
2253 update_pseudo_axes (self
);
2254 update_pseudo_axes_frames (self
);
2258 #define TOGGLE_LATTICE_CB(_parameter) \
2259 void hkl_gui_window_checkbutton_ ## _parameter ## _toggled_cb(GtkCheckButton *checkbutton, \
2260 gpointer user_data) \
2262 HklGuiWindow *self = HKL_GUI_WINDOW(user_data); \
2263 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(user_data); \
2264 HklLattice *lattice; \
2266 GError *error = NULL; \
2267 lattice = hkl_lattice_new_copy(hkl_sample_lattice_get(priv->sample)); \
2268 p = hkl_parameter_new_copy(hkl_lattice_## _parameter ##_get(lattice)); \
2269 hkl_parameter_fit_set(p, \
2270 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(checkbutton))); \
2271 if(!hkl_lattice_## _parameter ##_set(lattice, p, &error)){ \
2272 raise_error(self, &error); \
2274 hkl_sample_lattice_set(priv->sample, lattice); \
2276 hkl_parameter_free(p); \
2277 hkl_lattice_free(lattice); \
2280 TOGGLE_LATTICE_CB(a
);
2281 TOGGLE_LATTICE_CB(b
);
2282 TOGGLE_LATTICE_CB(c
);
2283 TOGGLE_LATTICE_CB(alpha
);
2284 TOGGLE_LATTICE_CB(beta
);
2285 TOGGLE_LATTICE_CB(gamma
);
2287 #define TOGGLE_UX_UY_UZ(_parameter) \
2288 void hkl_gui_window_checkbutton_ ## _parameter ## _toggled_cb(GtkCheckButton *checkbutton, \
2289 gpointer user_data) \
2291 HklGuiWindow *self = HKL_GUI_WINDOW(user_data); \
2292 HklGuiWindowPrivate *priv = HKL_GUI_WINDOW_GET_PRIVATE(user_data); \
2294 GError *error = NULL; \
2295 p = hkl_parameter_new_copy(hkl_sample_ ## _parameter ## _get(priv->sample)); \
2296 hkl_parameter_fit_set(p, \
2297 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(checkbutton))); \
2298 if(!hkl_sample_ ## _parameter ## _set(priv->sample, p, &error)){ \
2299 raise_error(self, &error); \
2301 hkl_parameter_free(p); \
2304 TOGGLE_UX_UY_UZ(ux
);
2305 TOGGLE_UX_UY_UZ(uy
);
2306 TOGGLE_UX_UY_UZ(uz
);
2310 static gboolean _hkl_gui_window_on_tree_view_crystals_key_press_event_gtk_widget_key_press_event (GtkWidget* _sender, GdkEventKey* event, gpointer self) {
2312 result = hkl_gui_window_on_tree_view_crystals_key_press_event (event, self);
2318 static gboolean hkl_gui_window_on_tree_view_crystals_key_press_event (GdkEventKey* event, HklGuiWindow* self) {
2319 gboolean result = FALSE;
2321 g_return_val_if_fail (self != NULL, FALSE);
2323 g_return_val_if_fail (event != NULL, FALSE);
2334 hkl_gui_window_class_init (HklGuiWindowClass
*class)
2336 GObjectClass
*gobject_class
= G_OBJECT_CLASS (class);
2338 g_type_class_add_private (class, sizeof (HklGuiWindowPrivate
));
2340 /* virtual method */
2341 gobject_class
->finalize
= finalize
;
2345 static void hkl_gui_window_init (HklGuiWindow
* self
)
2347 HklGuiWindowPrivate
*priv
= HKL_GUI_WINDOW_GET_PRIVATE(self
);
2349 priv
->diffractometer
= NULL
;
2350 priv
->sample
= NULL
;
2352 darray_init(priv
->pseudo_frames
);
2354 priv
->reciprocal
= hkl_lattice_new_default ();
2356 hkl_gui_window_get_widgets_and_objects_from_ui (self
);
2358 set_up_diffractometer_model (self
);
2360 set_up_tree_view_crystals (self
);
2362 set_up_tree_view_reflections(self
);
2365 int main (int argc
, char ** argv
)
2367 gtk_init (&argc
, &argv
);
2369 gtk_gl_init(&argc
, &argv
);
2371 hkl_gui_window_new ();