gui/hkl-gui-pseudoaxes.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 #include "hkl-gui-pseudoaxes.h"
  23
  24 PseudoAxesFrame::PseudoAxesFrame(HklPseudoAxisEngine *engine)
  25 {
  26         Gtk::CellRenderer * renderer;
  27
  28         _engine = engine;
  29
  30         //Get Glade UI:
  31         _refGlade = Gtk::Builder::create();
  32         try{
  33                 _refGlade->add_from_file("pseudo.ui");
  34         }catch(...){
  35                 std::string filename = Glib::build_filename(PKGDATA, "pseudo.ui");
  36                 if(!_refGlade->add_from_file(filename))
  37                         exit(1);
  38         }
  39
  40         // widgets
  41         _refGlade->get_widget("frame1", _frame1);
  42         _refGlade->get_widget("label2", _label2);
  43         _refGlade->get_widget("combobox1", _combobox1);
  44         _refGlade->get_widget("expander1", _expander1);
  45         _refGlade->get_widget("treeview1", _treeview1);
  46         _refGlade->get_widget("treeview2", _treeview2);
  47         _refGlade->get_widget("button1", _button1);
  48         _refGlade->get_widget("button2", _button2);
  49
  50         // objects
  51         _mode_ListStore = Glib::RefPtr<Gtk::ListStore>::cast_dynamic(
  52                 _refGlade->get_object("liststore1"));
  53         _pseudoAxis_ListStore = Glib::RefPtr<Gtk::ListStore>::cast_dynamic(
  54                 _refGlade->get_object("liststore2"));
  55         _mode_parameter_ListStore = Glib::RefPtr<Gtk::ListStore>::cast_dynamic(
  56                 _refGlade->get_object("liststore3"));
  57
  58         // title
  59         _label2->set_label(_engine->info->name);
  60
  61         // update all the liststore
  62         this->updatePseudoAxis();
  63         this->updateMode();
  64         this->updateModeParameters();
  65
  66         // connect signals
  67         _combobox1->signal_changed().connect(
  68                 sigc::mem_fun(*this, &PseudoAxesFrame::on_combobox1_changed) );
  69
  70         renderer = _treeview1->get_column_cell_renderer(1); // 1 is the index of the value column
  71         dynamic_cast<Gtk::CellRendererText *>(renderer)->signal_edited().connect(
  72                 sigc::mem_fun(*this, &PseudoAxesFrame::on_cell_TreeView_pseudoAxis_value_edited));
  73
  74         _button1->signal_clicked ().connect (
  75                 sigc::mem_fun (*this, &PseudoAxesFrame::on_button1_clicked) );
  76
  77         _button2->signal_clicked ().connect (
  78                 sigc::mem_fun (*this, &PseudoAxesFrame::on_button2_clicked) );
  79
  80         renderer = _treeview2->get_column_cell_renderer(1); // 1 is the index of the value column
  81         dynamic_cast<Gtk::CellRendererText *>(renderer)->signal_edited().connect(
  82                 sigc::mem_fun(*this, &PseudoAxesFrame::on_cell_treeview2_mode_parameter_value_edited));
  83
  84
  85 }
  86
  87 PseudoAxesFrame::~PseudoAxesFrame(void)
  88 {
  89 }
  90
  91 void PseudoAxesFrame::update(void)
  92 {
  93         Gtk::CellRenderer *renderer;
  94         this->updatePseudoAxis();
  95
  96         renderer = _treeview1->get_column_cell_renderer(1); // 1 is the index of the value column
  97         renderer->property_cell_background().set_value("white");
  98 }
  99
 100 /************/
 101 /* Callback */
 102 /************/
 103
 104 void PseudoAxesFrame::on_combobox1_changed(void)
 105 {
 106         Gtk::TreeModel::iterator iter = _combobox1->get_active();
 107         Gtk::ListStore::Row row = *(iter);
 108         hkl_pseudo_axis_engine_select_mode(_engine, row[_mode_columns.mode]);
 109         this->updateModeParameters();
 110         this->_signal_changed();
 111 }
 112
 113 void PseudoAxesFrame::on_cell_TreeView_pseudoAxis_value_edited(Glib::ustring const & spath,
 114                                                                Glib::ustring const & newText)
 115 {
 116         double value;
 117         HklPseudoAxis *pseudo;
 118
 119         Gtk::TreePath path(spath);
 120         Gtk::TreeModel::iterator iter = _pseudoAxis_ListStore->get_iter(path);
 121         Gtk::ListStore::Row row = *(iter);
 122
 123         sscanf(newText.c_str(), "%lf", &value);
 124
 125         pseudo = row[_pseudoAxis_columns.pseudo];
 126         if(pseudo){
 127                 Gtk::CellRenderer *renderer;
 128
 129                 renderer = _treeview1->get_column_cell_renderer(1); // 1 is the index of the value column
 130                 renderer->property_cell_background().set_value("red");
 131                 hkl_parameter_set_value_unit((HklParameter *)pseudo, value);
 132                 row[_pseudoAxis_columns.value] = value;
 133         }
 134 }
 135
 136 void PseudoAxesFrame::on_button1_clicked(void)
 137 {
 138         if(hkl_pseudo_axis_engine_set(_engine, NULL)){
 139                 HklGeometryListItem *top;
 140
 141                 top = list_top(&_engine->engines->geometries->items,
 142                                HklGeometryListItem, node);
 143                 hkl_geometry_init_geometry(_engine->engines->geometry, top->geometry);
 144                 this->_signal_changed();
 145         }
 146 }
 147
 148 void PseudoAxesFrame::on_button2_clicked(void)
 149 {
 150         if(hkl_pseudo_axis_engine_initialize(_engine, NULL))
 151                 this->updateModeParameters(); //some initialize function modify the parameters
 152 }
 153
 154 void PseudoAxesFrame::on_cell_treeview2_mode_parameter_value_edited(Glib::ustring const & spath,
 155                                                                     Glib::ustring const & newText)
 156 {
 157         double value;
 158         HklParameter *parameter;
 159
 160         Gtk::TreePath path(spath);
 161         Gtk::TreeModel::iterator iter = _mode_parameter_ListStore->get_iter(path);
 162         Gtk::ListStore::Row row = *(iter);
 163
 164         sscanf(newText.c_str(), "%lf", &value);
 165
 166         parameter = row[_mode_parameter_columns.parameter];
 167         if(parameter){
 168                 hkl_parameter_set_value_unit(parameter, value);
 169                 row[_mode_parameter_columns.value] = value;
 170         }
 171 }
 172
 173 /****************/
 174 /* Non-Callback */
 175 /****************/
 176
 177 void PseudoAxesFrame::updatePseudoAxis(void)
 178 {
 179         HklPseudoAxis *pseudo_axis;
 180
 181         _pseudoAxis_ListStore->clear();
 182         list_for_each(&_engine->pseudo_axes, pseudo_axis, list){
 183                 Gtk::TreeRow row = *(_pseudoAxis_ListStore->append());
 184                 row[_pseudoAxis_columns.name] = pseudo_axis->parameter.name;
 185                 row[_pseudoAxis_columns.value] = hkl_parameter_get_value_unit(&pseudo_axis->parameter);
 186                 row[_pseudoAxis_columns.pseudo] = pseudo_axis;
 187         }
 188 }
 189
 190 void PseudoAxesFrame::updateMode(void)
 191 {
 192         HklPseudoAxisEngineMode *mode;;
 193
 194         _mode_ListStore->clear();
 195         list_for_each(&this->_engine->modes, mode, list){
 196                 Gtk::TreeRow row = *(_mode_ListStore->append());
 197                 row[_mode_columns.name] = mode->info->name;
 198                 row[_mode_columns.mode] = mode;
 199         }
 200 }
 201
 202 void PseudoAxesFrame::updateModeParameters(void)
 203 {
 204         size_t i;
 205
 206         if(_engine->mode){
 207                 size_t len = _engine->mode->parameters_len;
 208                 if(len){
 209                         _mode_parameter_ListStore->clear();
 210                         for(i=0; i<len; ++i){
 211                                 Gtk::TreeRow row = *(_mode_parameter_ListStore->append());
 212                                 row[_mode_parameter_columns.name] = _engine->mode->parameters[i].name;
 213                                 row[_mode_parameter_columns.value] = hkl_parameter_get_value_unit(&_engine->mode->parameters[i]);
 214                                 row[_mode_parameter_columns.parameter] = &_engine->mode->parameters[i];
 215                         }
 216                         _expander1->set_expanded(1);
 217                         _expander1->show();
 218                 }else
 219                         _expander1->hide();
 220         }else
 221                 _expander1->hide();
 222 }
 223
 224 /***********/
 225 /* signals */
 226 /***********/
 227
 228 PseudoAxesFrame::type_signal_changed PseudoAxesFrame::signal_changed(void)
 229 {
 230         return _signal_changed;
 231 }