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