gtk2_ardour/transform_dialog.cc

   1 /*
   2    Copyright (C) 2009-2014 Paul Davis
   3    Author: David Robillard
   4
   5    This program is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 2 of the License, or
   8    (at your option) any later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program; if not, write to the Free Software
  17    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18 */
  19
  20 #include <gtkmm/box.h>
  21 #include <gtkmm/label.h>
  22 #include <gtkmm/stock.h>
  23
  24 #include "transform_dialog.h"
  25
  26 #include "pbd/i18n.h"
  27
  28 using namespace std;
  29 using namespace Gtk;
  30 using namespace ARDOUR;
  31
  32 TransformDialog::Model::Model()
  33         : source_list(Gtk::ListStore::create(source_cols))
  34         , property_list(Gtk::ListStore::create(property_cols))
  35         , operator_list(Gtk::ListStore::create(operator_cols))
  36 {
  37         static const char* source_labels[] = {
  38                 /* no NOTHING */
  39                 _("this note's"),
  40                 _("the previous note's"),
  41                 _("this note's index"),
  42                 _("the number of notes"),
  43                 _("exactly"),
  44                 _("a random number from"),
  45                 NULL
  46         };
  47         for (int s = 0; source_labels[s]; ++s) {
  48                 Gtk::TreeModel::Row row = *(source_list->append());
  49                 row[source_cols.source] = (Source)(s + 1);  // Skip NOTHING
  50                 row[source_cols.label]  = source_labels[s];
  51         }
  52         // Special row for ramp, which doesn't correspond to a source
  53         Gtk::TreeModel::Row row = *(source_list->append());
  54         row[source_cols.source] = Value::NOWHERE;
  55         row[source_cols.label]  = _("equal steps from");
  56
  57         static const char* property_labels[] = {
  58                 _("note number"),
  59                 _("velocity"),
  60                 _("start time"),
  61                 _("length"),
  62                 _("channel"),
  63                 NULL
  64         };
  65         for (int p = 0; property_labels[p]; ++p) {
  66                 Gtk::TreeModel::Row row = *(property_list->append());
  67                 row[property_cols.property] = (Property)p;
  68                 row[property_cols.label]    = property_labels[p];
  69         }
  70
  71         static const char* operator_labels[] = {
  72                 /* no PUSH */ "+", "-", "*", "/", "mod", NULL
  73         };
  74         for (int o = 0; operator_labels[o]; ++o) {
  75                 Gtk::TreeModel::Row row = *(operator_list->append());
  76                 row[operator_cols.op]    = (Operator)(o + 1);  // Skip PUSH
  77                 row[operator_cols.label] = operator_labels[o];
  78         }
  79 }
  80
  81 TransformDialog::TransformDialog()
  82         : ArdourDialog(_("Transform"), false, false)
  83 {
  84         _property_combo.set_model(_model.property_list);
  85         _property_combo.pack_start(_model.property_cols.label);
  86         _property_combo.set_active(1);
  87         _property_combo.signal_changed().connect(
  88                 sigc::mem_fun(this, &TransformDialog::property_changed));
  89
  90         Gtk::HBox* property_hbox = Gtk::manage(new Gtk::HBox);
  91         property_hbox->pack_start(*Gtk::manage(new Gtk::Label(_("Set "))), false, false);
  92         property_hbox->pack_start(_property_combo, false, false);
  93         property_hbox->pack_start(*Gtk::manage(new Gtk::Label(_(" to "))), false, false);
  94
  95         _seed_chooser = Gtk::manage(new ValueChooser(_model));
  96         _seed_chooser->set_target_property(MidiModel::NoteDiffCommand::Velocity);
  97         _seed_chooser->source_combo.set_active(0);
  98         property_hbox->pack_start(*_seed_chooser, false, false);
  99
 100         Gtk::HBox* add_hbox = Gtk::manage(new Gtk::HBox);
 101         _add_button.add(
 102                 *manage(new Gtk::Image(Gtk::Stock::ADD, Gtk::ICON_SIZE_BUTTON)));
 103         add_hbox->pack_start(_add_button, false, false);
 104         _add_button.signal_clicked().connect(
 105                 sigc::mem_fun(*this, &TransformDialog::add_clicked));
 106
 107         get_vbox()->set_spacing(6);
 108         get_vbox()->pack_start(*property_hbox, false, false);
 109         get_vbox()->pack_start(_operations_box, false, false);
 110         get_vbox()->pack_start(*add_hbox, false, false);
 111
 112         add_button(Stock::CANCEL, Gtk::RESPONSE_CANCEL);
 113         add_button(_("Transform"), Gtk::RESPONSE_OK);
 114
 115         show_all();
 116         _seed_chooser->value_spinner.hide();
 117         _seed_chooser->source_changed();
 118 }
 119
 120 TransformDialog::ValueChooser::ValueChooser(const Model& model)
 121         : model(model)
 122         , target_property((Property)1)
 123         , to_label(" to ")
 124 {
 125         source_combo.set_model(model.source_list);
 126         source_combo.pack_start(model.source_cols.label);
 127         source_combo.signal_changed().connect(
 128                 sigc::mem_fun(this, &TransformDialog::ValueChooser::source_changed));
 129
 130         property_combo.set_model(model.property_list);
 131         property_combo.pack_start(model.property_cols.label);
 132
 133         set_spacing(4);
 134         pack_start(source_combo, false, false);
 135         pack_start(property_combo, false, false);
 136         pack_start(value_spinner, false, false);
 137         pack_start(to_label, false, false);
 138         pack_start(max_spinner, false, false);
 139         show_all();
 140
 141         source_combo.set_active(4);
 142         property_combo.set_active(1);
 143         set_target_property(MidiModel::NoteDiffCommand::Velocity);
 144         max_spinner.set_value(127);
 145         source_changed();
 146 }
 147
 148 static void
 149 set_spinner_for(Gtk::SpinButton&                     spinner,
 150                 MidiModel::NoteDiffCommand::Property prop)
 151 {
 152         switch (prop) {
 153         case MidiModel::NoteDiffCommand::NoteNumber:
 154         case MidiModel::NoteDiffCommand::Velocity:
 155                 spinner.get_adjustment()->set_lower(1); // no 0, note off
 156                 spinner.get_adjustment()->set_upper(127);
 157                 spinner.get_adjustment()->set_step_increment(1);
 158                 spinner.get_adjustment()->set_page_increment(10);
 159                 spinner.set_digits(0);
 160                 break;
 161         case MidiModel::NoteDiffCommand::StartTime:
 162                 spinner.get_adjustment()->set_lower(0);
 163                 spinner.get_adjustment()->set_upper(1024);
 164                 spinner.get_adjustment()->set_step_increment(0.125);
 165                 spinner.get_adjustment()->set_page_increment(1.0);
 166                 spinner.set_digits(2);
 167                 break;
 168         case MidiModel::NoteDiffCommand::Length:
 169                 spinner.get_adjustment()->set_lower(1.0 / 64.0);
 170                 spinner.get_adjustment()->set_upper(32);
 171                 spinner.get_adjustment()->set_step_increment(1.0 / 64.0);
 172                 spinner.get_adjustment()->set_page_increment(1.0);
 173                 spinner.set_digits(2);
 174                 break;
 175         case MidiModel::NoteDiffCommand::Channel:
 176                 spinner.get_adjustment()->set_lower(0);
 177                 spinner.get_adjustment()->set_upper(15);
 178                 spinner.get_adjustment()->set_step_increment(1);
 179                 spinner.get_adjustment()->set_page_increment(10);
 180                 spinner.set_digits(0);
 181                 break;
 182         }
 183         spinner.set_value(
 184                 std::min(spinner.get_adjustment()->get_upper(),
 185                          std::max(spinner.get_adjustment()->get_lower(), spinner.get_value())));
 186 }
 187
 188 void
 189 TransformDialog::ValueChooser::set_target_property(Property prop)
 190 {
 191         target_property = prop;
 192         set_spinner_for(value_spinner, prop);
 193         set_spinner_for(max_spinner, prop);
 194 }
 195
 196 void
 197 TransformDialog::ValueChooser::source_changed()
 198 {
 199         Gtk::TreeModel::const_iterator s      = source_combo.get_active();
 200         const Source                   source = (*s)[model.source_cols.source];
 201
 202         value_spinner.hide();
 203         to_label.hide();
 204         max_spinner.hide();
 205         if (source == Value::LITERAL) {
 206                 value_spinner.show();
 207                 property_combo.hide();
 208         } else if (source == Value::RANDOM) {
 209                 value_spinner.show();
 210                 to_label.show();
 211                 max_spinner.show();
 212                 property_combo.hide();
 213         } else if (source == Value::NOWHERE) {
 214                 /* Bit of a kludge, hijack this for ramps since it's the only thing
 215                    that doesn't correspond to a source.  When we add more fancy
 216                    code-generating value chooser options, the column model will need to
 217                    be changed a bit to reflect this. */
 218                 value_spinner.show();
 219                 to_label.show();
 220                 max_spinner.show();
 221                 property_combo.hide();
 222         } else if (source == Value::INDEX || source == Value::N_NOTES) {
 223                 value_spinner.hide();
 224                 property_combo.hide();
 225         } else {
 226                 value_spinner.hide();
 227                 property_combo.show();
 228         }
 229 }
 230
 231 void
 232 TransformDialog::ValueChooser::get(std::list<Operation>& ops)
 233 {
 234         Gtk::TreeModel::const_iterator s      = source_combo.get_active();
 235         const Source                   source = (*s)[model.source_cols.source];
 236
 237         if (source == Transform::Value::RANDOM) {
 238                 /* Special case: a RANDOM value is always 0..1, so here we produce some
 239                    code to produce a random number in a range: "rand value *". */
 240                 const double a     = value_spinner.get_value();
 241                 const double b     = max_spinner.get_value();
 242                 const double min   = std::min(a, b);
 243                 const double max   = std::max(a, b);
 244                 const double range = max - min;
 245
 246                 // "rand range * min +" ((rand * range) + min)
 247                 ops.push_back(Operation(Operation::PUSH, Value(Value::RANDOM)));
 248                 ops.push_back(Operation(Operation::PUSH, Value(range)));
 249                 ops.push_back(Operation(Operation::MULT));
 250                 ops.push_back(Operation(Operation::PUSH, Value(min)));
 251                 ops.push_back(Operation(Operation::ADD));
 252                 return;
 253         } else if (source == Transform::Value::NOWHERE) {
 254                 /* Special case: hijack NOWHERE for ramps (see above).  The language
 255                    knows nothing of ramps, we generate code to calculate the
 256                    appropriate value here. */
 257                 const double first = value_spinner.get_value();
 258                 const double last  = max_spinner.get_value();
 259                 const double rise  = last - first;
 260
 261                 // "index rise * n_notes 1 - / first +" (index * rise / (n_notes - 1) + first)
 262                 ops.push_back(Operation(Operation::PUSH, Value(Value::INDEX)));
 263                 ops.push_back(Operation(Operation::PUSH, Value(rise)));
 264                 ops.push_back(Operation(Operation::MULT));
 265                 ops.push_back(Operation(Operation::PUSH, Value(Value::N_NOTES)));
 266                 ops.push_back(Operation(Operation::PUSH, Value(1)));
 267                 ops.push_back(Operation(Operation::SUB));
 268                 ops.push_back(Operation(Operation::DIV));
 269                 ops.push_back(Operation(Operation::PUSH, Value(first)));
 270                 ops.push_back(Operation(Operation::ADD));
 271                 return;
 272         }
 273
 274         // Produce a simple Value
 275         Value val((*s)[model.source_cols.source]);
 276         if (val.source == Transform::Value::THIS_NOTE ||
 277             val.source == Transform::Value::PREV_NOTE) {
 278                 Gtk::TreeModel::const_iterator p = property_combo.get_active();
 279                 val.prop = (*p)[model.property_cols.property];
 280         } else if (val.source == Transform::Value::LITERAL) {
 281                 val.value = Variant(
 282                         MidiModel::NoteDiffCommand::value_type(target_property),
 283                         value_spinner.get_value());
 284         }
 285         ops.push_back(Operation(Operation::PUSH, val));
 286 }
 287
 288 TransformDialog::OperationChooser::OperationChooser(const Model& model)
 289         : model(model)
 290         , value_chooser(model)
 291 {
 292         operator_combo.set_model(model.operator_list);
 293         operator_combo.pack_start(model.operator_cols.label);
 294         operator_combo.set_active(0);
 295
 296         pack_start(operator_combo, false, false);
 297         pack_start(value_chooser, false, false);
 298         pack_start(*Gtk::manage(new Gtk::Label(" ")), true, true);
 299         pack_start(remove_button, false, false);
 300
 301         remove_button.add(
 302                 *manage(new Gtk::Image(Gtk::Stock::REMOVE, Gtk::ICON_SIZE_BUTTON)));
 303
 304         remove_button.signal_clicked().connect(
 305                 sigc::mem_fun(*this, &TransformDialog::OperationChooser::remove_clicked));
 306
 307         value_chooser.source_combo.set_active(0);
 308
 309         show_all();
 310         value_chooser.property_combo.hide();
 311         value_chooser.value_spinner.set_value(1);
 312         value_chooser.source_changed();
 313 }
 314
 315 void
 316 TransformDialog::OperationChooser::get(std::list<Operation>& ops)
 317 {
 318         Gtk::TreeModel::const_iterator o = operator_combo.get_active();
 319
 320         value_chooser.get(ops);
 321         ops.push_back(Operation((*o)[model.operator_cols.op]));
 322 }
 323
 324 void
 325 TransformDialog::OperationChooser::remove_clicked()
 326 {
 327         delete this;
 328 }
 329
 330 Transform::Program
 331 TransformDialog::get()
 332 {
 333         Transform::Program prog;
 334
 335         // Set target property
 336         prog.prop = (*_property_combo.get_active())[_model.property_cols.property];
 337
 338         // Append code to push seed to stack
 339         _seed_chooser->get(prog.ops);
 340
 341         // Append all operations' code to program
 342         const std::vector<Gtk::Widget*>& choosers = _operations_box.get_children();
 343         for (std::vector<Gtk::Widget*>::const_iterator o = choosers.begin();
 344              o != choosers.end(); ++o) {
 345                 OperationChooser* chooser = dynamic_cast<OperationChooser*>(*o);
 346                 if (chooser) {
 347                         chooser->get(prog.ops);
 348                 }
 349         }
 350
 351         return prog;
 352 }
 353
 354 void
 355 TransformDialog::property_changed()
 356 {
 357         Gtk::TreeModel::const_iterator i = _property_combo.get_active();
 358         _seed_chooser->set_target_property((*i)[_model.property_cols.property]);
 359 }
 360
 361 void
 362 TransformDialog::add_clicked()
 363 {
 364         _operations_box.pack_start(
 365                 *Gtk::manage(new OperationChooser(_model)), false, false);
 366 }