gui/hkl-gui.cpp

   1 /* This file is part of the hkl library.
   2  *
   3  * The hkl library is free software: you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation, either version 3 of the License, or
   6  * (at your option) any later version.
   7  *
   8  * The hkl library is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with the hkl library.  If not, see <http://www.gnu.org/licenses/>.
  15  *
  16  * Copyright (C) 2003-2014 Synchrotron SOLEIL
  17  *                         L'Orme des Merisiers Saint-Aubin
  18  *                         BP 48 91192 GIF-sur-YVETTE CEDEX
  19  *
  20  * Authors: Picca Frédéric-Emmanuel <picca@synchrotron-soleil.fr>
  21  */
  22
  23 #include "hkl-gui.h"
  24
  25 HKLWindow::HKLWindow(void)
  26 {
  27         LOG;
  28
  29         size_t i;
  30
  31         _factory = NULL;
  32         _geometry = NULL;
  33         _engines = NULL;
  34
  35         _detector = hkl_detector_factory_new(HKL_DETECTOR_TYPE_0D);
  36         hkl_detector_idx_set(_detector, 1);
  37
  38         // add a default crystal
  39         _sample = hkl_sample_new("test");
  40         _samples.insert(std::pair<std::string, HklSample *>(hkl_sample_name_get(_sample),
  41                                                             _sample));
  42
  43         // create the reciprocal lattice
  44         _reciprocal = hkl_lattice_new_default();
  45
  46 #ifdef HKL3D
  47         _Scene = NULL;
  48 #endif
  49
  50         // Sets the border width of the window.
  51         this->set_border_width(10);
  52
  53         this->get_widgets_and_objects_from_ui();
  54
  55         _diffractometerModelColumns = NULL;
  56         this->set_up_diffractometer_model();
  57
  58         this->set_up_TreeView_reflections();
  59         this->set_up_TreeView_crystals();
  60
  61         //update the widgets
  62         this->updateTreeViewCrystals();
  63         this->updateSource();
  64         this->updateLattice();
  65         this->updateLatticeParameters();
  66         this->updateReciprocalLattice();
  67         this->updateUxUyUz();
  68         this->updateUB();
  69
  70         this->connect_all_signals();
  71
  72         this->show_all_children();
  73 }
  74
  75 HKLWindow::~HKLWindow()
  76 {
  77         LOG;
  78
  79         hkl_geometry_free(_geometry);
  80         hkl_detector_free(_detector);
  81         hkl_engine_list_free(_engines);
  82         hkl_lattice_free(_reciprocal);
  83
  84         //clear all the samples of the map
  85         std::map<std::string, HklSample *>::iterator it;
  86         for (it=_samples.begin(); it!=_samples.end(); ++it)
  87                 hkl_sample_free(it->second);
  88
  89         if(_diffractometerModelColumns)
  90                 delete _diffractometerModelColumns;
  91
  92         if(_solutionModelColumns)
  93                 delete _solutionModelColumns;
  94 }
  95
  96 void HKLWindow::get_widgets_and_objects_from_ui(void)
  97 {
  98         //Get Glade UI:
  99         _refGlade = Gtk::Builder::create();
 100         try{
 101                 _refGlade->add_from_file("ghkl.ui");
 102         }catch(...){
 103                 std::string filename = Glib::build_filename(PKGDATA, "ghkl.ui");
 104                 if(!_refGlade->add_from_file(filename))
 105                         exit(1);
 106         }
 107
 108         // objects
 109         _diffractometerModel = Glib::RefPtr<Gtk::ListStore>::cast_dynamic(
 110                 _refGlade->get_object("liststore1"));
 111
 112         // window1
 113         _refGlade->get_widget("label_UB11", _label_UB11);
 114         _refGlade->get_widget("label_UB12", _label_UB12);
 115         _refGlade->get_widget("label_UB13", _label_UB13);
 116         _refGlade->get_widget("label_UB21", _label_UB21);
 117         _refGlade->get_widget("label_UB22", _label_UB22);
 118         _refGlade->get_widget("label_UB23", _label_UB23);
 119         _refGlade->get_widget("label_UB31", _label_UB31);
 120         _refGlade->get_widget("label_UB32", _label_UB32);
 121         _refGlade->get_widget("label_UB33", _label_UB33);
 122         _refGlade->get_widget("button2", _button2);
 123         _refGlade->get_widget("spinbutton_a_star", _spinbutton_a_star);
 124         _refGlade->get_widget("spinbutton_b_star", _spinbutton_b_star);
 125         _refGlade->get_widget("spinbutton_c_star", _spinbutton_c_star);
 126         _refGlade->get_widget("spinbutton_alpha_star", _spinbutton_alpha_star);
 127         _refGlade->get_widget("spinbutton_beta_star", _spinbutton_beta_star);
 128         _refGlade->get_widget("spinbutton_gamma_star", _spinbutton_gamma_star);
 129         _refGlade->get_widget("spinbutton_a", _spinbutton_a);
 130         _refGlade->get_widget("spinbutton_b", _spinbutton_b);
 131         _refGlade->get_widget("spinbutton_c", _spinbutton_c);
 132         _refGlade->get_widget("spinbutton_alpha", _spinbutton_alpha);
 133         _refGlade->get_widget("spinbutton_beta", _spinbutton_beta);
 134         _refGlade->get_widget("spinbutton_gamma", _spinbutton_gamma);
 135         _refGlade->get_widget("spinbutton_a_min", _spinbutton_a_min);
 136         _refGlade->get_widget("spinbutton_b_min", _spinbutton_b_min);
 137         _refGlade->get_widget("spinbutton_c_min", _spinbutton_c_min);
 138         _refGlade->get_widget("spinbutton_alpha_min", _spinbutton_alpha_min);
 139         _refGlade->get_widget("spinbutton_beta_min", _spinbutton_beta_min);
 140         _refGlade->get_widget("spinbutton_gamma_min", _spinbutton_gamma_min);
 141         _refGlade->get_widget("spinbutton_a_max", _spinbutton_a_max);
 142         _refGlade->get_widget("spinbutton_b_max", _spinbutton_b_max);
 143         _refGlade->get_widget("spinbutton_c_max", _spinbutton_c_max);
 144         _refGlade->get_widget("spinbutton_alpha_max", _spinbutton_alpha_max);
 145         _refGlade->get_widget("spinbutton_beta_max", _spinbutton_beta_max);
 146         _refGlade->get_widget("spinbutton_gamma_max", _spinbutton_gamma_max);
 147         _refGlade->get_widget("spinbutton_lambda", _spinbutton_lambda);
 148         _refGlade->get_widget("spinbutton_ux", _spinbutton_ux);
 149         _refGlade->get_widget("spinbutton_uy", _spinbutton_uy);
 150         _refGlade->get_widget("spinbutton_uz", _spinbutton_uz);
 151         _refGlade->get_widget("spinbutton_U11", _spinbutton_U11);
 152         _refGlade->get_widget("spinbutton_U12", _spinbutton_U12);
 153         _refGlade->get_widget("spinbutton_U13", _spinbutton_U13);
 154         _refGlade->get_widget("spinbutton_U21", _spinbutton_U21);
 155         _refGlade->get_widget("spinbutton_U22", _spinbutton_U22);
 156         _refGlade->get_widget("spinbutton_U23", _spinbutton_U23);
 157         _refGlade->get_widget("spinbutton_U31", _spinbutton_U31);
 158         _refGlade->get_widget("spinbutton_U32", _spinbutton_U32);
 159         _refGlade->get_widget("spinbutton_U33", _spinbutton_U33);
 160         _refGlade->get_widget("checkbutton_a", _checkbutton_a);
 161         _refGlade->get_widget("checkbutton_b", _checkbutton_b);
 162         _refGlade->get_widget("checkbutton_c", _checkbutton_c);
 163         _refGlade->get_widget("checkbutton_alpha", _checkbutton_alpha);
 164         _refGlade->get_widget("checkbutton_beta", _checkbutton_beta);
 165         _refGlade->get_widget("checkbutton_gamma", _checkbutton_gamma);
 166         _refGlade->get_widget("checkbutton_ux", _checkbutton_ux);
 167         _refGlade->get_widget("checkbutton_uy", _checkbutton_uy);
 168         _refGlade->get_widget("checkbutton_uz", _checkbutton_uz);
 169         _refGlade->get_widget("treeview_reflections", _treeViewReflections);
 170         _refGlade->get_widget("treeview_crystals", _treeViewCrystals);
 171         _refGlade->get_widget("treeview_axes", _TreeView_axes);
 172         _refGlade->get_widget("treeview_pseudoAxes", _TreeView_pseudoAxes);
 173         _refGlade->get_widget("treeview_pseudoAxes_parameters", _TreeView_pseudoAxes_parameters);
 174         _refGlade->get_widget("treeview1", _treeview1);
 175         _refGlade->get_widget("toolbutton_add_reflection", _toolbutton_add_reflection);
 176         _refGlade->get_widget("toolbutton_goto_reflection", _toolbutton_goto_reflection);
 177         _refGlade->get_widget("toolbutton_del_reflection", _toolbutton_del_reflection);
 178         _refGlade->get_widget("toolbutton_setUB", _toolbutton_setUB);
 179         _refGlade->get_widget("toolbutton_computeUB", _toolbutton_computeUB);
 180         _refGlade->get_widget("toolbutton_add_crystal", _toolbutton_add_crystal);
 181         _refGlade->get_widget("toolbutton_copy_crystal", _toolbutton_copy_crystal);
 182         _refGlade->get_widget("toolbutton_del_crystal", _toolbutton_del_crystal);
 183         _refGlade->get_widget("toolbutton_affiner", _toolbutton_affiner);
 184         _refGlade->get_widget("statusbar", _statusBar);
 185         _refGlade->get_widget("menuitem5", _menuitem5);
 186         _refGlade->get_widget("vbox7", _vbox7);
 187         _refGlade->get_widget("imagemenuitem5", _imagemenuitem5);
 188
 189         // dialog1
 190         _refGlade->get_widget("dialog1", _dialog1);
 191         _refGlade->get_widget("button1", _button1);
 192         _refGlade->get_widget("combobox1", _combobox1);
 193 }
 194
 195 void HKLWindow::connect_all_signals(void)
 196 {
 197         LOG;
 198
 199         _spinbutton_a->signal_value_changed().connect(
 200                 mem_fun(*this, &HKLWindow::on_spinbutton_a_value_changed));
 201         _spinbutton_b->signal_value_changed().connect(
 202                 mem_fun(*this, &HKLWindow::on_spinbutton_b_value_changed));
 203         _spinbutton_c->signal_value_changed().connect(
 204                 mem_fun(*this, &HKLWindow::on_spinbutton_c_value_changed));
 205         _spinbutton_alpha->signal_value_changed().connect(
 206                 mem_fun(*this, &HKLWindow::on_spinbutton_alpha_value_changed));
 207         _spinbutton_beta->signal_value_changed().connect(
 208                 mem_fun(*this, &HKLWindow::on_spinbutton_beta_value_changed));
 209         _spinbutton_gamma->signal_value_changed().connect(
 210                 mem_fun(*this, &HKLWindow::on_spinbutton_gamma_value_changed));
 211         _spinbutton_a_min->signal_value_changed().connect(
 212                 mem_fun(*this, &HKLWindow::on_spinbutton_a_min_value_changed));
 213         _spinbutton_b_min->signal_value_changed().connect(
 214                 mem_fun(*this, &HKLWindow::on_spinbutton_b_min_value_changed));
 215         _spinbutton_c_min->signal_value_changed().connect(
 216                 mem_fun(*this, &HKLWindow::on_spinbutton_c_min_value_changed));
 217         _spinbutton_alpha_min->signal_value_changed().connect(
 218                 mem_fun(*this, &HKLWindow::on_spinbutton_alpha_min_value_changed));
 219         _spinbutton_beta_min->signal_value_changed().connect(
 220                 mem_fun(*this, &HKLWindow::on_spinbutton_beta_min_value_changed));
 221         _spinbutton_gamma_min->signal_value_changed().connect(
 222                 mem_fun(*this, &HKLWindow::on_spinbutton_gamma_min_value_changed));
 223         _spinbutton_a_max->signal_value_changed().connect(
 224                 mem_fun(*this, &HKLWindow::on_spinbutton_a_max_value_changed));
 225         _spinbutton_b_max->signal_value_changed().connect(
 226                 mem_fun(*this, &HKLWindow::on_spinbutton_b_max_value_changed));
 227         _spinbutton_c_max->signal_value_changed().connect(
 228                 mem_fun(*this, &HKLWindow::on_spinbutton_c_max_value_changed));
 229         _spinbutton_alpha_max->signal_value_changed().connect(
 230                 mem_fun(*this, &HKLWindow::on_spinbutton_alpha_max_value_changed));
 231         _spinbutton_beta_max->signal_value_changed().connect(
 232                 mem_fun(*this, &HKLWindow::on_spinbutton_beta_max_value_changed));
 233         _spinbutton_gamma_max->signal_value_changed().connect(
 234                 mem_fun(*this, &HKLWindow::on_spinbutton_gamma_max_value_changed));
 235         _spinbutton_lambda->signal_value_changed().connect(
 236                 mem_fun(*this, &HKLWindow::on_spinbutton_lambda_value_changed));
 237         _spinbutton_ux->signal_value_changed().connect(
 238                 mem_fun(*this, &HKLWindow::on_spinbutton_uxuyuz_value_changed));
 239         _spinbutton_uy->signal_value_changed().connect(
 240                 mem_fun(*this, &HKLWindow::on_spinbutton_uxuyuz_value_changed));
 241         _spinbutton_uz->signal_value_changed().connect(
 242                 mem_fun(*this, &HKLWindow::on_spinbutton_uxuyuz_value_changed));
 243
 244         _button2->signal_clicked().connect(
 245                 mem_fun(*this, &HKLWindow::on_button2_clicked));
 246
 247         _checkbutton_a->signal_toggled().connect(
 248                 mem_fun(*this, &HKLWindow::on_checkbutton_a_toggled));
 249         _checkbutton_b->signal_toggled().connect(
 250                 mem_fun(*this, &HKLWindow::on_checkbutton_b_toggled));
 251         _checkbutton_c->signal_toggled().connect(
 252                 mem_fun(*this, &HKLWindow::on_checkbutton_c_toggled));
 253         _checkbutton_alpha->signal_toggled().connect(
 254                 mem_fun(*this, &HKLWindow::on_checkbutton_alpha_toggled));
 255         _checkbutton_beta->signal_toggled().connect(
 256                 mem_fun(*this, &HKLWindow::on_checkbutton_beta_toggled));
 257         _checkbutton_gamma->signal_toggled().connect(
 258                 mem_fun(*this, &HKLWindow::on_checkbutton_gamma_toggled));
 259         _checkbutton_ux->signal_toggled().connect(
 260                 mem_fun(*this, &HKLWindow::on_checkbutton_ux_toggled));
 261         _checkbutton_uy->signal_toggled().connect(
 262                 mem_fun(*this, &HKLWindow::on_checkbutton_uy_toggled));
 263         _checkbutton_uz->signal_toggled().connect(
 264                 mem_fun(*this, &HKLWindow::on_checkbutton_uz_toggled));
 265
 266         _treeViewReflections->signal_key_press_event().connect(
 267                 mem_fun(*this, &HKLWindow::on_treeViewReflections_key_press_event));
 268         _TreeView_pseudoAxes->signal_cursor_changed().connect(
 269                 mem_fun(*this, &HKLWindow::on_treeView_pseudoAxes_cursor_changed));
 270         _treeViewCrystals->signal_cursor_changed().connect(
 271                 mem_fun(*this, &HKLWindow::on_treeViewCrystals_cursor_changed));
 272         _treeViewCrystals->signal_key_press_event().connect(
 273                 mem_fun(*this, &HKLWindow::on_treeViewCrystals_key_press_event));
 274
 275         _toolbutton_add_reflection->signal_clicked().connect(
 276                 mem_fun(*this, &HKLWindow::on_toolbutton_add_reflection_clicked));
 277         _toolbutton_goto_reflection->signal_clicked().connect(
 278                 mem_fun(*this, &HKLWindow::on_toolbutton_goto_reflection_clicked));
 279         _toolbutton_del_reflection->signal_clicked().connect(
 280                 mem_fun(*this, &HKLWindow::on_toolbutton_del_reflection_clicked));
 281         _toolbutton_setUB->signal_clicked().connect(
 282                 mem_fun(*this, &HKLWindow::on_toolbutton_setUB_clicked));
 283         _toolbutton_computeUB->signal_clicked().connect(
 284                 mem_fun(*this, &HKLWindow::on_toolbutton_computeUB_clicked));
 285         _toolbutton_add_crystal->signal_clicked().connect(
 286                 mem_fun(*this, &HKLWindow::on_toolbutton_add_crystal_clicked));
 287         _toolbutton_copy_crystal->signal_clicked().connect(
 288                 mem_fun(*this, &HKLWindow::on_toolbutton_copy_crystal_clicked));
 289         _toolbutton_del_crystal->signal_clicked().connect(
 290                 mem_fun(*this, &HKLWindow::on_toolbutton_del_crystal_clicked));
 291         _toolbutton_affiner->signal_clicked().connect(
 292                 mem_fun(*this, &HKLWindow::on_toolbutton_affiner_clicked));
 293
 294         _menuitem5->signal_activate().connect(
 295                 mem_fun(*this, &HKLWindow::on_menuitem5_activate));
 296
 297         _imagemenuitem5->signal_activate().connect(&gtk_main_quit);
 298
 299         // dialog1
 300         _button1->signal_clicked().connect(
 301                 mem_fun(*this, &HKLWindow::on_button1_clicked));
 302         _combobox1->signal_changed().connect(
 303                 mem_fun(*this, &HKLWindow::on_combobox1_changed));
 304 }
 305
 306 void HKLWindow::set_up_pseudo_axes_frames(void)
 307 {
 308         LOG;
 309
 310         size_t i;
 311         HklEngine **engine;
 312         Gtk::VBox *vbox2 = NULL;
 313         PseudoAxesFrame *pseudo;
 314         darray_engine *engines = hkl_engine_list_engines_get(this->_engines);
 315
 316         _refGlade->get_widget("vbox2", vbox2);
 317
 318         // first clear the previous frames
 319         for(i=0; i<_pseudoAxesFrames.size(); ++i){
 320                 vbox2->remove(_pseudoAxesFrames[i]->frame());
 321                 delete _pseudoAxesFrames[i];
 322         }
 323         _pseudoAxesFrames.clear();
 324
 325         darray_foreach(engine, *engines){
 326                 pseudo = new PseudoAxesFrame (*engine);
 327                 _pseudoAxesFrames.push_back (pseudo);
 328                 vbox2->add (pseudo->frame());
 329                 pseudo->signal_changed ().connect (
 330                         sigc::mem_fun (*this, &HKLWindow::on_pseudoAxesFrame_changed) );
 331         }
 332         vbox2->show_all();
 333 }
 334
 335 void HKLWindow::set_up_diffractometer_model(void)
 336 {
 337         unsigned int i;
 338         unsigned int n;
 339         HklFactory **factories;
 340
 341         if(_diffractometerModelColumns)
 342                 delete _diffractometerModelColumns;
 343         _diffractometerModelColumns = new DiffractometerModelColumns();
 344
 345         factories = hkl_factory_get_all(&n);
 346         for (i=0; i<n; ++i){
 347                 Gtk::ListStore::Row row;
 348
 349                 row = *(_diffractometerModel->append());
 350                 row[_diffractometerModelColumns->name] = hkl_factory_name(factories[i]);
 351         }
 352 }
 353
 354 void HKLWindow::set_up_TreeView_axes(void)
 355 {
 356         LOG;
 357
 358         size_t i;
 359         int index;
 360         const char **axes;
 361         size_t axes_length;
 362
 363         Gtk::CellRenderer * renderer;
 364
 365         //Create the Model
 366         _axeModel = Gtk::ListStore::create(_axeModelColumns);
 367
 368         // add the columns
 369         _TreeView_axes->remove_all_columns();
 370
 371         index = _TreeView_axes->append_column("name", _axeModelColumns.name);
 372
 373         index = _TreeView_axes->append_column_numeric_editable("read",
 374                                                                _axeModelColumns.read, "%lf");
 375         renderer = _TreeView_axes->get_column_cell_renderer(index-1);
 376         dynamic_cast<Gtk::CellRendererText *>(renderer)->signal_edited().connect(
 377                 sigc::mem_fun(*this, &HKLWindow::on_cell_TreeView_axes_read_edited));
 378
 379         index = _TreeView_axes->append_column_numeric_editable("write",
 380                                                                _axeModelColumns.write, "%lf");
 381         renderer = _TreeView_axes->get_column_cell_renderer(index-1);
 382         dynamic_cast<Gtk::CellRendererText *>(renderer)->signal_edited().connect(
 383                 sigc::mem_fun(*this, &HKLWindow::on_cell_TreeView_axes_write_edited));
 384
 385         index = _TreeView_axes->append_column_numeric_editable("min",
 386                                                                _axeModelColumns.min, "%lf");
 387         renderer = _TreeView_axes->get_column_cell_renderer(index-1);
 388         dynamic_cast<Gtk::CellRendererText *>(renderer)->signal_edited().connect(
 389                 sigc::mem_fun(*this, &HKLWindow::on_cell_TreeView_axes_min_edited));
 390
 391         index = _TreeView_axes->append_column_numeric_editable("max",
 392                                                                _axeModelColumns.max, "%lf");
 393         renderer = _TreeView_axes->get_column_cell_renderer(index-1);
 394         dynamic_cast<Gtk::CellRendererText *>(renderer)->signal_edited().connect(
 395                 sigc::mem_fun(*this, &HKLWindow::on_cell_TreeView_axes_max_edited));
 396
 397         //Fill the models from the diffractometerAxes
 398         axes = hkl_factory_axes_get(this->_factory, &axes_length);
 399         for(i=0; i<axes_length; ++i){
 400                 Gtk::ListStore::Row row = *(_axeModel->append());
 401                 // this static_cast is wrong but for now it
 402                 // works. This should be fixed with the C version of
 403                 // the gui.
 404                 row[_axeModelColumns.axis] = const_cast<HklParameter *>(hkl_geometry_axis_get(this->_geometry, axes[i], NULL));
 405                 row[_axeModelColumns.name] = axes[i];
 406         }
 407
 408         //Set the model for the TreeView
 409         _TreeView_axes->set_model(_axeModel);
 410         this->updateAxes();
 411 }
 412
 413 void HKLWindow::set_up_TreeView_pseudoAxes(void)
 414 {
 415         LOG;
 416
 417         int index;
 418         Gtk::CellRenderer * renderer;
 419         HklEngine **engine;
 420         darray_engine *engines = hkl_engine_list_engines_get(this->_engines);
 421
 422         /* add the columns */
 423         _TreeView_pseudoAxes->remove_all_columns();
 424
 425         _TreeView_pseudoAxes->append_column("name", _pseudoAxeModelColumns.name);
 426
 427         _TreeView_pseudoAxes->append_column_numeric("read", _pseudoAxeModelColumns.read, "%lf");
 428
 429         index = _TreeView_pseudoAxes->append_column_numeric_editable("write", _pseudoAxeModelColumns.write, "%lf");
 430         renderer = _TreeView_pseudoAxes->get_column_cell_renderer(index-1);
 431         dynamic_cast<Gtk::CellRendererText *>(renderer)->signal_edited().connect(
 432                 sigc::mem_fun(*this,
 433                               &HKLWindow::on_cell_TreeView_pseudoAxes_write_edited));
 434
 435         _TreeView_pseudoAxes->append_column_numeric("min", _pseudoAxeModelColumns.min, "%lf");
 436
 437         _TreeView_pseudoAxes->append_column_numeric("max", _pseudoAxeModelColumns.max, "%lf");
 438
 439         //Create the Model
 440         _pseudoAxeModel = Gtk::ListStore::create(_pseudoAxeModelColumns);
 441
 442         //Fill the models from the diffractometer pseudoAxes
 443         darray_foreach(engine, *engines){
 444                 const char **pseudo_axis;
 445                 const darray_string *pseudo_axes = hkl_engine_pseudo_axes_names_get(*engine);
 446                 const darray_string *parameters = hkl_engine_parameters_names_get(*engine);
 447
 448                 darray_foreach(pseudo_axis, *pseudo_axes){
 449                         Gtk::ListStore::Row row = *(_pseudoAxeModel->append());
 450                         row[_pseudoAxeModelColumns.engine] = *engine;
 451                         row[_pseudoAxeModelColumns.name] = *pseudo_axis;
 452
 453
 454                         if(darray_size(*parameters)){
 455                                 Glib::RefPtr<Gtk::ListStore> model = Gtk::ListStore::create(_parameterModelColumns);
 456                                 const char **parameter;
 457
 458                                 darray_foreach(parameter, *parameters){
 459                                         Glib::RefPtr<Gtk::ListStore> model = Gtk::ListStore::create(_parameterModelColumns);
 460                                         row = *(model->append());
 461                                         row[_parameterModelColumns.engine] = *engine;
 462                                         row[_parameterModelColumns.name] = *parameter;
 463                                         row[_parameterModelColumns.value] = hkl_parameter_value_unit_get(hkl_engine_parameter_get(*engine, *parameter, NULL));
 464                                 }
 465                                 _mapPseudoAxeParameterModel.insert(std::pair<std::string, Glib::RefPtr<Gtk::ListStore> >(*pseudo_axis, model));
 466                         }
 467                 }
 468         }
 469
 470         //Set the model for the TreeView
 471         _TreeView_pseudoAxes->set_model(_pseudoAxeModel);
 472         this->updatePseudoAxes();
 473 }
 474
 475 void HKLWindow::set_up_TreeView_pseudoAxes_parameters(void)
 476 {
 477         LOG;
 478
 479         int index;
 480         Gtk::CellRenderer * renderer;
 481
 482         // add the columns
 483         _TreeView_pseudoAxes_parameters->remove_all_columns();
 484
 485         _TreeView_pseudoAxes_parameters->append_column(
 486                 "name", _parameterModelColumns.name);
 487
 488         index = _TreeView_pseudoAxes_parameters->append_column_numeric_editable(
 489                 "value", _parameterModelColumns.value, "%lf");
 490         renderer = _TreeView_pseudoAxes_parameters->get_column_cell_renderer(index-1);
 491
 492         // connect the signal_edited
 493         dynamic_cast<Gtk::CellRendererText *>(renderer)->signal_edited().connect(
 494                 sigc::mem_fun(*this,
 495                               &HKLWindow::on_cell_TreeView_pseudoAxes_parameters_value_edited));
 496 }
 497
 498 void HKLWindow::set_up_TreeView_treeview1(void)
 499 {
 500         LOG;
 501
 502         size_t i, axes_length;
 503         const char **axes;
 504
 505         //Create the Columns
 506         if(_solutionModelColumns)
 507                 delete _solutionModelColumns;
 508         _solutionModelColumns = new SolutionModelColumns(this->_factory);
 509
 510         /* add the columns */
 511         _treeview1->remove_all_columns();
 512         axes = hkl_factory_axes_get(this->_factory, &axes_length);
 513         for(i=0;i<axes_length;++i)
 514                 _treeview1->append_column_numeric(axes[i],
 515                                                   _solutionModelColumns->axes[i],
 516                                                   "%lf");
 517
 518         //Create the model from the columns
 519         _solutionModel = Gtk::ListStore::create(*_solutionModelColumns);
 520
 521         _treeview1->set_model(_solutionModel);
 522
 523         _treeview1->signal_cursor_changed().connect(mem_fun(*this, &HKLWindow::on_treeview1_cursor_changed));
 524
 525         this->updateSolutions();
 526 }
 527
 528 void HKLWindow::set_up_TreeView_reflections(void)
 529 {
 530         LOG;
 531
 532         int index;
 533         Gtk::CellRenderer *renderer;
 534
 535         //Set up the treeViewReflections
 536         _treeViewReflections->remove_all_columns();
 537
 538         _treeViewReflections->append_column("index", _reflectionModelColumns.index);
 539
 540         index = _treeViewReflections->append_column_numeric_editable("h", _reflectionModelColumns.h, "%lf");
 541         renderer = _treeViewReflections->get_column_cell_renderer(index-1);
 542         dynamic_cast<Gtk::CellRendererText *>(renderer)->signal_edited().connect(
 543                 sigc::mem_fun(*this, &HKLWindow::on_cell_TreeView_reflections_h_edited));
 544
 545         index = _treeViewReflections->append_column_numeric_editable("k", _reflectionModelColumns.k, "%lf");
 546         renderer = _treeViewReflections->get_column_cell_renderer(index-1);
 547         dynamic_cast<Gtk::CellRendererText *>(renderer)->signal_edited().connect(
 548                 sigc::mem_fun(*this, &HKLWindow::on_cell_TreeView_reflections_k_edited));
 549
 550         index = _treeViewReflections->append_column_numeric_editable("l", _reflectionModelColumns.l, "%lf");
 551         renderer = _treeViewReflections->get_column_cell_renderer(index-1);
 552         dynamic_cast<Gtk::CellRendererText *>(renderer)->signal_edited().connect(
 553                 sigc::mem_fun(*this, &HKLWindow::on_cell_TreeView_reflections_l_edited));
 554
 555         index = _treeViewReflections->append_column_editable("flag", _reflectionModelColumns.flag);
 556         renderer = _treeViewReflections->get_column_cell_renderer(index-1);
 557         dynamic_cast<Gtk::CellRendererToggle *>(renderer)->signal_toggled().connect(
 558                 sigc::mem_fun(*this, &HKLWindow::on_cell_TreeView_reflections_flag_toggled));
 559
 560         _treeViewReflections->get_selection()->set_mode(Gtk::SELECTION_MULTIPLE);
 561 }
 562
 563 void HKLWindow::set_up_TreeView_crystals(void)
 564 {
 565         LOG;
 566
 567         int index;
 568         Gtk::CellRenderer *renderer;
 569
 570         //Set up the treeViewCrystals
 571         _treeViewCrystals->remove_all_columns();
 572
 573         index = _treeViewCrystals->append_column_editable("name", _crystalModelColumns.name);
 574         renderer = _treeViewCrystals->get_column_cell_renderer(index-1);
 575         dynamic_cast<Gtk::CellRendererText *>(renderer)->signal_edited().connect(
 576                 sigc::mem_fun(*this, &HKLWindow::on_cell_TreeView_crystals_name_edited));
 577
 578         _treeViewCrystals->append_column_numeric("a", _crystalModelColumns.a, "%lf");
 579         _treeViewCrystals->append_column_numeric("b", _crystalModelColumns.b, "%lf");
 580         _treeViewCrystals->append_column_numeric("c", _crystalModelColumns.c, "%lf");
 581         _treeViewCrystals->append_column_numeric("alpha", _crystalModelColumns.alpha, "%lf");
 582         _treeViewCrystals->append_column_numeric("beta", _crystalModelColumns.beta, "%lf");
 583         _treeViewCrystals->append_column_numeric("gamma", _crystalModelColumns.gamma, "%lf");
 584
 585         _treeViewCrystals->get_selection()->set_mode(Gtk::SELECTION_MULTIPLE);
 586 }
 587
 588 #ifdef HKL3D
 589
 590 void HKLWindow::set_up_3D(void)
 591 {
 592         LOG;
 593         const char *model;
 594
 595         if(_Scene)
 596                 delete _Scene;
 597
 598         // for now the connection with the model is done in the part of the code
 599         // It should be store in the config part of the geometry ?
 600         const char *name = hkl_geometry_name_get(this->_geometry);
 601         if (!strcmp("K6C", name))
 602                 model = "../data/diffabs.yaml";
 603         else if(!strcmp("K4CV", name))
 604                 model = "../data/cristal4C.yaml";
 605
 606         if(model){
 607                 _Scene = new Hkl3DFrame(model, _geometry);
 608                 this->_vbox7->pack_start(_Scene->frame());
 609                 this->_vbox7->show_all();
 610         }else
 611                 _Scene = NULL;
 612 }
 613
 614 #endif
 615
 616 void HKLWindow::updateSource(void)
 617 {
 618         LOG;
 619
 620         if(_geometry){
 621                 double wavelength = hkl_geometry_wavelength_get(this->_geometry);
 622                 _spinbutton_lambda->set_value(wavelength);
 623         }
 624 }
 625
 626 void HKLWindow::updateAxes(void)
 627 {
 628         LOG;
 629
 630         // update the model
 631         Gtk::TreeModel::Children rows = _axeModel->children();
 632         Gtk::TreeModel::Children::iterator iter = rows.begin();
 633         Gtk::TreeModel::Children::iterator end = rows.end();
 634         while(iter != end){
 635                 double min;
 636                 double max;
 637                 HklParameter * axis;
 638
 639                 Gtk::TreeRow row = *iter;
 640                 axis = row[_axeModelColumns.axis];
 641                 row[_axeModelColumns.read] = hkl_parameter_value_unit_get(axis);
 642                 row[_axeModelColumns.write] = hkl_parameter_value_unit_get(axis);
 643                 hkl_parameter_min_max_unit_get(axis, &min, &max);
 644                 row[_axeModelColumns.min] = min;
 645                 row[_axeModelColumns.max] = max;
 646                 ++iter;
 647         }
 648 }
 649
 650 void HKLWindow::updatePseudoAxes(void)
 651 {
 652         LOG;
 653
 654         // first compute all the pseudoAxes values
 655         hkl_engine_list_get(_engines);
 656
 657         // update the model
 658         Gtk::TreeModel::Children rows = _pseudoAxeModel->children();
 659         Gtk::TreeModel::Children::iterator iter = rows.begin();
 660         Gtk::TreeModel::Children::iterator end = rows.end();
 661         while(iter != end){
 662                 double min;
 663                 double max;
 664                 const HklParameter *parameter;
 665                 Gtk::TreeRow row = *iter;
 666
 667                 parameter = hkl_engine_pseudo_axis_get(row[_pseudoAxeModelColumns.engine],
 668                                                        row[_pseudoAxeModelColumns.name],
 669                                                        NULL);
 670                 row[_pseudoAxeModelColumns.read] = hkl_parameter_value_unit_get(parameter);
 671                 row[_pseudoAxeModelColumns.write] = hkl_parameter_value_unit_get(parameter);
 672                 hkl_parameter_min_max_unit_get(parameter, &min, &max);
 673                 row[_pseudoAxeModelColumns.min] = min;
 674                 row[_pseudoAxeModelColumns.max] = max;
 675
 676                 ++iter;
 677         }
 678 }
 679
 680 void HKLWindow::update_pseudoAxes_parameters(void)
 681 {
 682         LOG;
 683
 684         std::map<std::string, Glib::RefPtr<Gtk::ListStore> >::iterator iter = _mapPseudoAxeParameterModel.begin();
 685         std::map<std::string, Glib::RefPtr<Gtk::ListStore> >::iterator end = _mapPseudoAxeParameterModel.end();
 686         while(iter != end){
 687                 Gtk::TreeModel::Children rows = iter->second->children();
 688                 Gtk::TreeModel::Children::iterator iter_row = rows.begin();
 689                 Gtk::TreeModel::Children::iterator end_row = rows.end();
 690                 while(iter_row != end_row){
 691                         Gtk::TreeRow row = *iter_row;
 692                         const HklParameter *parameter = hkl_engine_parameter_get(row[_parameterModelColumns.engine],
 693                                                                                  row[_parameterModelColumns.name],
 694                                                                                  NULL);
 695                         row[_parameterModelColumns.value] = hkl_parameter_value_unit_get(parameter);
 696                         ++iter_row;
 697                 }
 698                 ++iter;
 699         }
 700 }
 701
 702 void HKLWindow::updateLattice(void)
 703 {
 704         LOG;
 705
 706         if(_sample){
 707                 const HklLattice *lattice = hkl_sample_lattice_get(_sample);
 708                 double a = hkl_parameter_value_unit_get(hkl_lattice_a_get(lattice));
 709                 double b = hkl_parameter_value_unit_get(hkl_lattice_b_get(lattice));
 710                 double c = hkl_parameter_value_unit_get(hkl_lattice_c_get(lattice));
 711                 double alpha = hkl_parameter_value_unit_get(hkl_lattice_alpha_get(lattice));
 712                 double beta = hkl_parameter_value_unit_get(hkl_lattice_beta_get(lattice));
 713                 double gamma = hkl_parameter_value_unit_get(hkl_lattice_gamma_get(lattice));
 714
 715                 _spinbutton_a->set_value(a);
 716                 _spinbutton_b->set_value(b);
 717                 _spinbutton_c->set_value(c);
 718                 _spinbutton_alpha->set_value(alpha);
 719                 _spinbutton_beta->set_value(beta);
 720                 _spinbutton_gamma->set_value(gamma);
 721         }
 722 }
 723
 724 void HKLWindow::updateLatticeParameters(void)
 725 {
 726         LOG;
 727
 728         if(_sample){
 729                 double min;
 730                 double max;
 731                 bool to_fit;
 732                 const HklLattice *lattice = hkl_sample_lattice_get(_sample);
 733                 const HklParameter *parameter;
 734
 735                 parameter = hkl_lattice_a_get(lattice);
 736                 hkl_parameter_min_max_unit_get(parameter, &min, &max);
 737                 to_fit = hkl_parameter_fit_get(parameter);
 738                 _spinbutton_a_min->set_value(min);
 739                 _spinbutton_a_max->set_value(max);
 740                 _checkbutton_a->set_active(to_fit);
 741
 742                 parameter = hkl_lattice_b_get(lattice);
 743                 hkl_parameter_min_max_unit_get(parameter, &min, &max);
 744                 to_fit = hkl_parameter_fit_get(parameter);
 745                 _spinbutton_b_min->set_value(min);
 746                 _spinbutton_b_max->set_value(max);
 747                 _checkbutton_b->set_active(to_fit);
 748
 749                 parameter = hkl_lattice_c_get(lattice);
 750                 hkl_parameter_min_max_unit_get(parameter, &min, &max);
 751                 to_fit = hkl_parameter_fit_get(parameter);
 752                 _spinbutton_c_min->set_value(min);
 753                 _spinbutton_c_max->set_value(max);
 754                 _checkbutton_c->set_active(to_fit);
 755
 756                 parameter = hkl_lattice_alpha_get(lattice);
 757                 hkl_parameter_min_max_unit_get(parameter, &min, &max);
 758                 to_fit = hkl_parameter_fit_get(parameter);
 759                 _spinbutton_alpha_min->set_value(min);
 760                 _spinbutton_alpha_max->set_value(max);
 761                 _checkbutton_alpha->set_active(to_fit);
 762
 763                 parameter = hkl_lattice_beta_get(lattice);
 764                 hkl_parameter_min_max_unit_get(parameter, &min, &max);
 765                 to_fit = hkl_parameter_fit_get(parameter);
 766                 _spinbutton_beta_min->set_value(min);
 767                 _spinbutton_beta_max->set_value(max);
 768                 _checkbutton_beta->set_active(to_fit);
 769
 770                 parameter = hkl_lattice_gamma_get(lattice);
 771                 hkl_parameter_min_max_unit_get(parameter, &min, &max);
 772                 to_fit = hkl_parameter_fit_get(parameter);
 773                 _spinbutton_gamma_min->set_value(min);
 774                 _spinbutton_gamma_max->set_value(max);
 775                 _checkbutton_gamma->set_active(to_fit);
 776         }
 777 }
 778
 779 void HKLWindow::updateReciprocalLattice(void)
 780 {
 781         LOG;
 782
 783         if(_sample){
 784                 hkl_lattice_reciprocal(hkl_sample_lattice_get(_sample),
 785                                        _reciprocal);
 786
 787                 _spinbutton_a_star->set_value(
 788                         hkl_parameter_value_unit_get(
 789                                 hkl_lattice_a_get(_reciprocal)));
 790                 _spinbutton_b_star->set_value(
 791                         hkl_parameter_value_unit_get(
 792                                 hkl_lattice_b_get(_reciprocal)));
 793                 _spinbutton_c_star->set_value(
 794                         hkl_parameter_value_unit_get(
 795                                 hkl_lattice_c_get(_reciprocal)));
 796                 _spinbutton_alpha_star->set_value(
 797                         hkl_parameter_value_unit_get(
 798                                 hkl_lattice_alpha_get(_reciprocal)));
 799                 _spinbutton_beta_star->set_value(
 800                         hkl_parameter_value_unit_get(
 801                                 hkl_lattice_beta_get(_reciprocal)));
 802                 _spinbutton_gamma_star->set_value(
 803                         hkl_parameter_value_unit_get(
 804                                 hkl_lattice_gamma_get(_reciprocal)));
 805         }
 806 }
 807
 808 void HKLWindow::updateUB(void)
 809 {
 810         LOG;
 811
 812         if(_sample){
 813                 static const char *format = "%f";
 814                 char tmp[100];
 815                 const HklMatrix *UB;
 816
 817                 UB = hkl_sample_UB_get(_sample);
 818                 sprintf(tmp, format, hkl_matrix_get(UB, 0, 0));
 819                 _label_UB11->set_text(tmp);
 820                 sprintf(tmp, format, hkl_matrix_get(UB, 0, 1));
 821                 _label_UB12->set_text(tmp);
 822                 sprintf(tmp, format, hkl_matrix_get(UB, 0, 2));
 823                 _label_UB13->set_text(tmp);
 824                 sprintf(tmp, format, hkl_matrix_get(UB, 1, 0));
 825                 _label_UB21->set_text(tmp);
 826                 sprintf(tmp, format, hkl_matrix_get(UB, 1, 1));
 827                 _label_UB22->set_text(tmp);
 828                 sprintf(tmp, format, hkl_matrix_get(UB, 1, 2));
 829                 _label_UB23->set_text(tmp);
 830                 sprintf(tmp, format, hkl_matrix_get(UB, 2, 0));
 831                 _label_UB31->set_text(tmp);
 832                 sprintf(tmp, format, hkl_matrix_get(UB, 2, 1));
 833                 _label_UB32->set_text(tmp);
 834                 sprintf(tmp, format, hkl_matrix_get(UB, 2, 2));
 835                 _label_UB33->set_text(tmp);
 836         }
 837 }
 838
 839 void HKLWindow::updateUxUyUz(void)
 840 {
 841         LOG;
 842
 843         if(_sample){
 844                 _spinbutton_ux->set_value(
 845                         hkl_parameter_value_unit_get(
 846                                 hkl_sample_ux_get(_sample)));
 847                 _spinbutton_uy->set_value(
 848                         hkl_parameter_value_unit_get(
 849                                 hkl_sample_uy_get(_sample)));
 850                 _spinbutton_uz->set_value(
 851                         hkl_parameter_value_unit_get(
 852                                 hkl_sample_uz_get(_sample)));
 853                 _checkbutton_ux->set_active(
 854                         hkl_parameter_fit_get(
 855                                 hkl_sample_ux_get(_sample)));
 856                 _checkbutton_uy->set_active(
 857                         hkl_parameter_fit_get(
 858                                 hkl_sample_uy_get(_sample)));
 859                 _checkbutton_uz->set_active(
 860                         hkl_parameter_fit_get(
 861                                 hkl_sample_uz_get(_sample)));
 862         }
 863 }
 864
 865 void HKLWindow::updateTreeViewCrystals(void)
 866 {
 867         LOG;
 868
 869         size_t i;
 870         HklSample *sample;
 871
 872         Gtk::ListStore::Row row;
 873         Gtk::TreeModel::Children::iterator iter_row;
 874         Gtk::TreeModel::Children::iterator iter_current;
 875         Glib::ustring current_crystal_name;
 876
 877         bool is_current_crystal_set = false;
 878
 879         //clear all data in the models
 880         _crystalModel = Gtk::ListStore::create(_crystalModelColumns);
 881
 882         // erase all reflections.
 883         _mapReflectionModel.clear();
 884
 885         if(_sample){
 886                 is_current_crystal_set = true;
 887                 current_crystal_name = hkl_sample_name_get(_sample);
 888         }
 889
 890         //Fill the models from the crystalList
 891         std::map<std::string, HklSample *>::iterator it;
 892         for(it=_samples.begin(); it!=_samples.end(); ++it){
 893                 const HklLattice *lattice;
 894                 const char *name;
 895
 896                 sample = it->second;
 897                 lattice = hkl_sample_lattice_get(sample);
 898                 name = hkl_sample_name_get(sample);
 899                 iter_row = *(_crystalModel->append());
 900                 if (is_current_crystal_set && current_crystal_name == name)
 901                         iter_current = iter_row;
 902                 row = *(iter_row);
 903                 row[_crystalModelColumns.name] = name;
 904                 row[_crystalModelColumns.a] = hkl_parameter_value_unit_get(hkl_lattice_a_get(lattice));
 905                 row[_crystalModelColumns.b] = hkl_parameter_value_unit_get(hkl_lattice_b_get(lattice));
 906                 row[_crystalModelColumns.c] = hkl_parameter_value_unit_get(hkl_lattice_c_get(lattice));
 907                 row[_crystalModelColumns.alpha] = hkl_parameter_value_unit_get(hkl_lattice_alpha_get(lattice));
 908                 row[_crystalModelColumns.beta] = hkl_parameter_value_unit_get(hkl_lattice_beta_get(lattice));
 909                 row[_crystalModelColumns.gamma] = hkl_parameter_value_unit_get(hkl_lattice_gamma_get(lattice));
 910
 911                 Glib::RefPtr<Gtk::ListStore> listStore = Gtk::ListStore::create(_reflectionModelColumns);
 912                 _mapReflectionModel[name] = listStore;
 913                 this->updateReflections(sample, listStore);
 914         }
 915
 916         //Set the model for the TreeView
 917         _treeViewCrystals->set_model(_crystalModel);
 918         if (is_current_crystal_set)
 919         {
 920                 Gtk::TreeModel::Path path = _crystalModel->get_path(iter_current);
 921                 _treeViewCrystals->set_cursor(path);
 922                 _treeViewReflections->set_model(_mapReflectionModel[current_crystal_name]);
 923         }
 924 }
 925
 926 void HKLWindow::updateReflections(const HklSample *sample,
 927                                   Glib::RefPtr<Gtk::ListStore> & listStore)
 928 {
 929         LOG;
 930
 931         size_t i = 0;
 932
 933         listStore->clear();
 934         Gtk::ListStore::Row row;
 935         HklSampleReflection *reflection = hkl_sample_first_reflection_get(const_cast<HklSample *>(sample));
 936         while(reflection){
 937                 double h, k, l;
 938
 939                 hkl_sample_reflection_hkl_get(reflection, &h, &k, &l);
 940
 941                 row = *(listStore->append());
 942                 row[_reflectionModelColumns.index] = i++;
 943                 row[_reflectionModelColumns.reflection] = reflection;
 944                 row[_reflectionModelColumns.h] = h;
 945                 row[_reflectionModelColumns.k] = k;
 946                 row[_reflectionModelColumns.l] = l;
 947                 row[_reflectionModelColumns.flag] = hkl_sample_reflection_flag_get(reflection);
 948                 reflection = hkl_sample_next_reflection_get(const_cast<HklSample *>(sample),
 949                                                             reflection);
 950         }
 951 }
 952
 953 void HKLWindow::updateStatusBar(const GError *error)
 954 {
 955         LOG;
 956
 957         _statusBar->push(error->message);
 958 }
 959
 960 void HKLWindow::updateCrystalModel(HklSample * sample)
 961 {
 962         LOG;
 963
 964         Gtk::TreeModel::Children children = _crystalModel->children();
 965         Gtk::TreeModel::Children::iterator iter = children.begin();
 966         Gtk::TreeModel::Children::iterator end = children.end();
 967         while (iter != end){
 968                 Gtk::TreeModel::Row const & row = *iter;
 969                 if (row[_crystalModelColumns.name] == hkl_sample_name_get(sample)){
 970                         const HklLattice *lattice = hkl_sample_lattice_get(sample);
 971                         row[_crystalModelColumns.a] = hkl_parameter_value_unit_get(
 972                                 hkl_lattice_a_get(lattice));
 973                         row[_crystalModelColumns.b] = hkl_parameter_value_unit_get(
 974                                 hkl_lattice_b_get(lattice));
 975                         row[_crystalModelColumns.c] = hkl_parameter_value_unit_get(
 976                                 hkl_lattice_c_get(lattice));
 977                         row[_crystalModelColumns.alpha] = hkl_parameter_value_unit_get(
 978                                 hkl_lattice_alpha_get(lattice));
 979                         row[_crystalModelColumns.beta] = hkl_parameter_value_unit_get(
 980                                 hkl_lattice_beta_get(lattice));
 981                         row[_crystalModelColumns.gamma] = hkl_parameter_value_unit_get(
 982                                 hkl_lattice_gamma_get(lattice));
 983                         iter = end;
 984                 }
 985                 else
 986                         ++iter;
 987         }
 988 }
 989
 990 void HKLWindow::updatePseudoAxesFrames(void)
 991 {
 992         LOG;
 993
 994         size_t i;
 995
 996         for(i=0; i<_pseudoAxesFrames.size(); ++i)
 997                 _pseudoAxesFrames[i]->update();
 998 }
 999
1000 void HKLWindow::updateSolutions(void)
1001 {
1002         LOG;
1003
1004         size_t i = 0;
1005         const HklGeometryList *geometries = hkl_engine_list_geometries_get(this->_engines);
1006         const HklGeometryListItem *item;
1007
1008         _solutionModel->clear();
1009         Gtk::ListStore::Row row;
1010         HKL_GEOMETRY_LIST_FOREACH(item, geometries){
1011                 const char **axes;
1012                 size_t j, axes_length;
1013                 const HklGeometry *geometry;
1014
1015                 row = *(_solutionModel->append());
1016                 row[_solutionModelColumns->index] = i++;
1017                 row[_solutionModelColumns->item] = item;
1018
1019                 geometry = hkl_geometry_list_item_geometry_get(item);
1020                 axes = hkl_factory_axes_get(this->_factory, &axes_length);
1021                 for(j=0; j<axes_length; ++j){
1022                         const HklParameter *axis;
1023
1024                         axis = hkl_geometry_axis_get(geometry, axes[j], NULL);
1025                         row[_solutionModelColumns->axes[j]] = hkl_parameter_value_unit_get(axis);
1026                 }
1027         }
1028 }