gtk2_ardour/sfdb_ui.cc

   1 /*
   2     Copyright (C) 2005-2006 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #ifdef WAF_BUILD
  21 #include "gtk2ardour-config.h"
  22 #endif
  23
  24 #include "i18n.h"
  25
  26 #include <map>
  27 #include <cerrno>
  28 #include <sstream>
  29
  30 #include <unistd.h>
  31 #include <limits.h>
  32
  33 #include <gtkmm/box.h>
  34 #include <gtkmm/stock.h>
  35
  36 #include <pbd/gstdio_compat.h>
  37 #include <glibmm/fileutils.h>
  38
  39 #include "pbd/convert.h"
  40 #include "pbd/tokenizer.h"
  41 #include "pbd/enumwriter.h"
  42 #include "pbd/pthread_utils.h"
  43 #include "pbd/xml++.h"
  44
  45 #include <gtkmm2ext/utils.h>
  46
  47 #include "evoral/SMF.hpp"
  48
  49 #include "ardour/audio_library.h"
  50 #include "ardour/auditioner.h"
  51 #include "ardour/audioregion.h"
  52 #include "ardour/audiofilesource.h"
  53 #include "ardour/midi_region.h"
  54 #include "ardour/smf_source.h"
  55 #include "ardour/region_factory.h"
  56 #include "ardour/source_factory.h"
  57 #include "ardour/session.h"
  58 #include "ardour/session_directory.h"
  59 #include "ardour/srcfilesource.h"
  60
  61 #include "ardour_ui.h"
  62 #include "editing.h"
  63 #include "gui_thread.h"
  64 #include "prompter.h"
  65 #include "sfdb_ui.h"
  66 #include "editing.h"
  67 #include "gain_meter.h"
  68 #include "main_clock.h"
  69 #include "public_editor.h"
  70 #include "timers.h"
  71 #include "ui_config.h"
  72
  73 #include "sfdb_freesound_mootcher.h"
  74
  75 using namespace ARDOUR;
  76 using namespace PBD;
  77 using namespace std;
  78 using namespace Gtk;
  79 using namespace Gtkmm2ext;
  80 using namespace Editing;
  81
  82 using std::string;
  83
  84 string SoundFileBrowser::persistent_folder;
  85 typedef TreeView::Selection::ListHandle_Path ListPath;
  86
  87 static ImportMode
  88 string2importmode (string str)
  89 {
  90         if (str == _("as new tracks")) {
  91                 return ImportAsTrack;
  92         } else if (str == _("to selected tracks")) {
  93                 return ImportToTrack;
  94         } else if (str == _("to region list")) {
  95                 return ImportAsRegion;
  96         } else if (str == _("as new tape tracks")) {
  97                 return ImportAsTapeTrack;
  98         }
  99
 100         warning << string_compose (_("programming error: unknown import mode string %1"), str) << endmsg;
 101
 102         return ImportAsTrack;
 103 }
 104
 105 static string
 106 importmode2string (ImportMode mode)
 107 {
 108         switch (mode) {
 109         case ImportAsTrack:
 110                 return _("as new tracks");
 111         case ImportToTrack:
 112                 return _("to selected tracks");
 113         case ImportAsRegion:
 114                 return _("to region list");
 115         case ImportAsTapeTrack:
 116                 return _("as new tape tracks");
 117         }
 118         abort(); /*NOTREACHED*/
 119         return _("as new tracks");
 120 }
 121
 122 SoundFileBox::SoundFileBox (bool /*persistent*/)
 123         : table (6, 2),
 124           length_clock ("sfboxLengthClock", true, "", false, false, true, false),
 125           timecode_clock ("sfboxTimecodeClock", true, "", false, false, false, false),
 126           main_box (false, 6),
 127           autoplay_btn (_("Auto-play")),
 128           seek_slider(0,1000,1),
 129           _seeking(false)
 130
 131 {
 132         set_name (X_("SoundFileBox"));
 133         set_size_request (300, -1);
 134
 135         preview_label.set_markup (_("<b>Sound File Information</b>"));
 136
 137         border_frame.set_label_widget (preview_label);
 138         border_frame.add (main_box);
 139
 140         pack_start (border_frame, true, true);
 141         set_border_width (6);
 142
 143         main_box.set_border_width (6);
 144
 145         length.set_text (_("Length:"));
 146         length.set_alignment (1, 0.5);
 147         timecode.set_text (_("Timestamp:"));
 148         timecode.set_alignment (1, 0.5);
 149         format.set_text (_("Format:"));
 150         format.set_alignment (1, 0.5);
 151         channels.set_text (_("Channels:"));
 152         channels.set_alignment (1, 0.5);
 153         samplerate.set_text (_("Sample rate:"));
 154         samplerate.set_alignment (1, 0.5);
 155
 156         preview_label.set_max_width_chars (50);
 157         preview_label.set_ellipsize (Pango::ELLIPSIZE_END);
 158
 159         format_text.set_max_width_chars (20);
 160         format_text.set_ellipsize (Pango::ELLIPSIZE_END);
 161         format_text.set_alignment (0, 1);
 162
 163         table.set_col_spacings (6);
 164         table.set_homogeneous (false);
 165         table.set_row_spacings (6);
 166
 167         table.attach (channels, 0, 1, 0, 1, FILL, FILL);
 168         table.attach (samplerate, 0, 1, 1, 2, FILL, FILL);
 169         table.attach (format, 0, 1, 2, 4, FILL, FILL);
 170         table.attach (length, 0, 1, 4, 5, FILL, FILL);
 171         table.attach (timecode, 0, 1, 5, 6, FILL, FILL);
 172
 173         table.attach (channels_value, 1, 2, 0, 1, FILL, FILL);
 174         table.attach (samplerate_value, 1, 2, 1, 2, FILL, FILL);
 175         table.attach (format_text, 1, 2, 2, 4, FILL, FILL);
 176         table.attach (length_clock, 1, 2, 4, 5, FILL, FILL);
 177         table.attach (timecode_clock, 1, 2, 5, 6, FILL, FILL);
 178
 179         length_clock.set_mode (ARDOUR_UI::instance()->secondary_clock->mode());
 180         timecode_clock.set_mode (AudioClock::Timecode);
 181
 182         main_box.pack_start (table, false, false);
 183
 184         tags_entry.set_editable (true);
 185         tags_entry.set_wrap_mode(Gtk::WRAP_WORD);
 186         tags_entry.signal_focus_out_event().connect (sigc::mem_fun (*this, &SoundFileBox::tags_entry_left));
 187
 188         Label* label = manage (new Label (_("Tags:")));
 189         label->set_alignment (0.0f, 0.5f);
 190         main_box.pack_start (*label, false, false);
 191         main_box.pack_start (tags_entry, true, true);
 192
 193         main_box.pack_start (bottom_box, false, false);
 194
 195         play_btn.set_image (*(manage (new Image (Stock::MEDIA_PLAY, ICON_SIZE_BUTTON))));
 196 //      play_btn.set_label (_("Play"));
 197
 198         stop_btn.set_image (*(manage (new Image (Stock::MEDIA_STOP, ICON_SIZE_BUTTON))));
 199 //      stop_btn.set_label (_("Stop"));
 200
 201         bottom_box.set_homogeneous (false);
 202         bottom_box.set_spacing (6);
 203         bottom_box.pack_start(play_btn, true, true);
 204         bottom_box.pack_start(stop_btn, true, true);
 205         bottom_box.pack_start(autoplay_btn, false, false);
 206
 207         seek_slider.set_draw_value(false);
 208
 209         seek_slider.add_events(Gdk::BUTTON_PRESS_MASK|Gdk::BUTTON_RELEASE_MASK);
 210         seek_slider.signal_button_press_event().connect(sigc::mem_fun(*this, &SoundFileBox::seek_button_press), false);
 211         seek_slider.signal_button_release_event().connect(sigc::mem_fun(*this, &SoundFileBox::seek_button_release), false);
 212         main_box.pack_start (seek_slider, false, false);
 213
 214         play_btn.signal_clicked().connect (sigc::mem_fun (*this, &SoundFileBox::audition));
 215         stop_btn.signal_clicked().connect (sigc::mem_fun (*this, &SoundFileBox::stop_audition));
 216
 217         stop_btn.set_sensitive (false);
 218
 219         channels_value.set_alignment (0.0f, 0.5f);
 220         samplerate_value.set_alignment (0.0f, 0.5f);
 221 }
 222
 223 void
 224 SoundFileBox::set_session(Session* s)
 225 {
 226         SessionHandlePtr::set_session (s);
 227
 228         length_clock.set_session (s);
 229         timecode_clock.set_session (s);
 230
 231         if (!_session) {
 232                 play_btn.set_sensitive (false);
 233                 stop_btn.set_sensitive (false);
 234                 auditioner_connections.drop_connections();
 235         } else {
 236                 auditioner_connections.drop_connections();
 237                 _session->AuditionActive.connect(auditioner_connections, invalidator (*this), boost::bind (&SoundFileBox::audition_active, this, _1), gui_context());
 238                 _session->the_auditioner()->AuditionProgress.connect(auditioner_connections, invalidator (*this), boost::bind (&SoundFileBox::audition_progress, this, _1, _2), gui_context());
 239         }
 240 }
 241
 242 void
 243 SoundFileBox::audition_active(bool active) {
 244         stop_btn.set_sensitive (active);
 245         seek_slider.set_sensitive (active);
 246         if (!active) {
 247                 seek_slider.set_value(0);
 248         }
 249 }
 250
 251 void
 252 SoundFileBox::audition_progress(ARDOUR::framecnt_t pos, ARDOUR::framecnt_t len) {
 253         if (!_seeking) {
 254                 seek_slider.set_value( 1000.0 * pos / len);
 255                 seek_slider.set_sensitive (true);
 256         }
 257 }
 258
 259 bool
 260 SoundFileBox::seek_button_press(GdkEventButton*) {
 261         _seeking = true;
 262         return false; // pass on to slider
 263 }
 264
 265 bool
 266 SoundFileBox::seek_button_release(GdkEventButton*) {
 267         _seeking = false;
 268         _session->the_auditioner()->seek_to_percent(seek_slider.get_value() / 10.0);
 269         seek_slider.set_sensitive (false);
 270         return false; // pass on to slider
 271 }
 272
 273 bool
 274 SoundFileBox::setup_labels (const string& filename)
 275 {
 276         if (!path.empty()) {
 277                 // save existing tags
 278                 tags_changed ();
 279         }
 280
 281         path = filename;
 282
 283         string error_msg;
 284
 285         if (SMFSource::valid_midi_file (path)) {
 286
 287                 boost::shared_ptr<SMFSource> ms;
 288                 try {
 289                         ms = boost::dynamic_pointer_cast<SMFSource> (
 290                                 SourceFactory::createExternal (DataType::MIDI, *_session,
 291                                                                path, 0, Source::Flag (0), false));
 292                 } catch (const std::exception& e) {
 293                         error << string_compose(_("Could not read file: %1 (%2)."),
 294                                                 path, e.what()) << endmsg;
 295                 }
 296
 297                 preview_label.set_markup (_("<b>Midi File Information</b>"));
 298
 299                 format_text.set_text ("MIDI");
 300                 samplerate_value.set_text ("-");
 301                 tags_entry.get_buffer()->set_text ("");
 302                 timecode_clock.set (0);
 303                 tags_entry.set_sensitive (false);
 304
 305                 if (ms) {
 306                         channels_value.set_text (to_string(ms->num_tracks(), std::dec));
 307                         length_clock.set (ms->length(ms->timeline_position()));
 308                 } else {
 309                         channels_value.set_text ("");
 310                         length_clock.set (0);
 311                 }
 312
 313                 if (_session && ms) {
 314                         play_btn.set_sensitive (true);
 315                 } else {
 316                         play_btn.set_sensitive (false);
 317                 }
 318
 319                 return true;
 320         }
 321
 322         if(!AudioFileSource::get_soundfile_info (filename, sf_info, error_msg)) {
 323
 324                 preview_label.set_markup (_("<b>Sound File Information</b>"));
 325                 format_text.set_text ("");
 326                 channels_value.set_text ("");
 327                 samplerate_value.set_text ("");
 328                 tags_entry.get_buffer()->set_text ("");
 329
 330                 length_clock.set (0);
 331                 timecode_clock.set (0);
 332
 333                 tags_entry.set_sensitive (false);
 334                 play_btn.set_sensitive (false);
 335
 336                 return false;
 337         }
 338
 339         preview_label.set_markup (string_compose ("<b>%1</b>", Glib::Markup::escape_text (Glib::path_get_basename (filename))));
 340         std::string n = sf_info.format_name;
 341         if (n.substr (0, 8) == X_("Format: ")) {
 342                 n = n.substr (8);
 343         }
 344         format_text.set_text (n);
 345         channels_value.set_text (to_string (sf_info.channels, std::dec));
 346
 347         if (_session && sf_info.samplerate != _session->frame_rate()) {
 348                 samplerate.set_markup (string_compose ("<b>%1</b>", _("Sample rate:")));
 349                 samplerate_value.set_markup (string_compose (X_("<b>%1 Hz</b>"), sf_info.samplerate));
 350                 samplerate_value.set_name ("NewSessionSR1Label");
 351                 samplerate.set_name ("NewSessionSR1Label");
 352         } else {
 353                 samplerate.set_text (_("Sample rate:"));
 354                 samplerate_value.set_text (string_compose (X_("%1 Hz"), sf_info.samplerate));
 355                 samplerate_value.set_name ("NewSessionSR2Label");
 356                 samplerate.set_name ("NewSessionSR2Label");
 357         }
 358
 359         framecnt_t const nfr = _session ? _session->nominal_frame_rate() : 25;
 360         double src_coef = (double) nfr / sf_info.samplerate;
 361
 362         length_clock.set (sf_info.length * src_coef + 0.5, true);
 363         timecode_clock.set (sf_info.timecode * src_coef + 0.5, true);
 364
 365         // this is a hack that is fixed in trunk, i think (august 26th, 2007)
 366
 367         vector<string> tags = Library->get_tags (string ("//") + filename);
 368
 369         stringstream tag_string;
 370         for (vector<string>::iterator i = tags.begin(); i != tags.end(); ++i) {
 371                 if (i != tags.begin()) {
 372                         tag_string << ", ";
 373                 }
 374                 tag_string << *i;
 375         }
 376         tags_entry.get_buffer()->set_text (tag_string.str());
 377
 378         tags_entry.set_sensitive (true);
 379         if (_session) {
 380                 play_btn.set_sensitive (true);
 381         }
 382
 383         return true;
 384 }
 385
 386 bool
 387 SoundFileBox::autoplay() const
 388 {
 389         return autoplay_btn.get_active();
 390 }
 391
 392 bool
 393 SoundFileBox::audition_oneshot()
 394 {
 395         audition ();
 396         return false;
 397 }
 398
 399 void
 400 SoundFileBox::audition ()
 401 {
 402         if (!_session) {
 403                 return;
 404         }
 405
 406         _session->cancel_audition();
 407
 408         if (!Glib::file_test (path, Glib::FILE_TEST_EXISTS)) {
 409                 warning << string_compose(_("Could not read file: %1 (%2)."), path, strerror(errno)) << endmsg;
 410                 return;
 411         }
 412
 413         boost::shared_ptr<Region> r;
 414
 415         if (SMFSource::valid_midi_file (path)) {
 416
 417                 boost::shared_ptr<SMFSource> ms =
 418                         boost::dynamic_pointer_cast<SMFSource> (
 419                                         SourceFactory::createExternal (DataType::MIDI, *_session,
 420                                                                                          path, 0, Source::Flag (0), false));
 421
 422                 string rname = region_name_from_path (ms->path(), false);
 423
 424                 PropertyList plist;
 425
 426                 plist.add (ARDOUR::Properties::start, 0);
 427                 plist.add (ARDOUR::Properties::length, ms->length(ms->timeline_position()));
 428                 plist.add (ARDOUR::Properties::name, rname);
 429                 plist.add (ARDOUR::Properties::layer, 0);
 430
 431                 r = boost::dynamic_pointer_cast<MidiRegion> (RegionFactory::create (boost::dynamic_pointer_cast<Source>(ms), plist, false));
 432                 assert(r);
 433
 434         } else {
 435
 436                 SourceList srclist;
 437                 boost::shared_ptr<AudioFileSource> afs;
 438                 bool old_sbp = AudioSource::get_build_peakfiles ();
 439
 440                 /* don't even think of building peakfiles for these files */
 441
 442                 AudioSource::set_build_peakfiles (false);
 443
 444                 for (int n = 0; n < sf_info.channels; ++n) {
 445                         try {
 446                                 afs = boost::dynamic_pointer_cast<AudioFileSource> (
 447                                         SourceFactory::createExternal (DataType::AUDIO, *_session,
 448                                                                                          path, n,
 449                                                                                          Source::Flag (ARDOUR::AudioFileSource::NoPeakFile), false));
 450                                 if (afs->sample_rate() != _session->nominal_frame_rate()) {
 451                                         boost::shared_ptr<SrcFileSource> sfs (new SrcFileSource(*_session, afs, _src_quality));
 452                                         srclist.push_back(sfs);
 453                                 } else {
 454                                         srclist.push_back(afs);
 455                                 }
 456
 457                         } catch (failed_constructor& err) {
 458                                 error << _("Could not access soundfile: ") << path << endmsg;
 459                                 AudioSource::set_build_peakfiles (old_sbp);
 460                                 return;
 461                         }
 462                 }
 463
 464                 AudioSource::set_build_peakfiles (old_sbp);
 465
 466                 if (srclist.empty()) {
 467                         return;
 468                 }
 469
 470                 afs = boost::dynamic_pointer_cast<AudioFileSource> (srclist[0]);
 471                 string rname = region_name_from_path (afs->path(), false);
 472
 473                 PropertyList plist;
 474
 475                 plist.add (ARDOUR::Properties::start, 0);
 476                 plist.add (ARDOUR::Properties::length, srclist[0]->length(srclist[0]->timeline_position()));
 477                 plist.add (ARDOUR::Properties::name, rname);
 478                 plist.add (ARDOUR::Properties::layer, 0);
 479
 480                 r = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (srclist, plist, false));
 481         }
 482
 483         frameoffset_t audition_position = 0;
 484         switch(_import_position) {
 485                 case ImportAtTimestamp:
 486                         audition_position = 0;
 487                         break;
 488                 case ImportAtPlayhead:
 489                         audition_position = _session->transport_frame();
 490                         break;
 491                 case ImportAtStart:
 492                         audition_position = _session->current_start_frame();
 493                         break;
 494                 case ImportAtEditPoint:
 495                         audition_position = PublicEditor::instance().get_preferred_edit_position ();
 496                         break;
 497         }
 498         r->set_position(audition_position);
 499
 500         _session->audition_region(r);
 501 }
 502
 503 void
 504 SoundFileBox::stop_audition ()
 505 {
 506         if (_session) {
 507                 _session->cancel_audition();
 508         }
 509 }
 510
 511 bool
 512 SoundFileBox::tags_entry_left (GdkEventFocus *)
 513 {
 514         tags_changed ();
 515         return false;
 516 }
 517
 518 void
 519 SoundFileBox::tags_changed ()
 520 {
 521         string tag_string = tags_entry.get_buffer()->get_text ();
 522
 523         if (tag_string.empty()) {
 524                 return;
 525         }
 526
 527         vector<string> tags;
 528
 529         if (!PBD::tokenize (tag_string, string(",\n"), std::back_inserter (tags), true)) {
 530                 warning << _("SoundFileBox: Could not tokenize string: ") << tag_string << endmsg;
 531                 return;
 532         }
 533
 534         save_tags (tags);
 535 }
 536
 537 void
 538 SoundFileBox::save_tags (const vector<string>& tags)
 539 {
 540         Library->set_tags (string ("//") + path, tags);
 541         Library->save_changes ();
 542 }
 543
 544 SoundFileBrowser::SoundFileBrowser (string title, ARDOUR::Session* s, bool persistent)
 545         : ArdourWindow (title)
 546         , found_list (ListStore::create(found_list_columns))
 547         , freesound_list (ListStore::create(freesound_list_columns))
 548         , chooser (FILE_CHOOSER_ACTION_OPEN)
 549         , preview (persistent)
 550         , found_search_btn (_("Search"))
 551         , found_list_view (found_list)
 552         , freesound_search_btn (_("Search"))
 553         , freesound_list_view (freesound_list)
 554         , resetting_ourselves (false)
 555         , matches (0)
 556         , _status (0)
 557         , _done (false)
 558         , import_button (_("Import"))
 559         , close_button (Stock::CLOSE)
 560         , gm (0)
 561 {
 562
 563 #ifdef GTKOSX
 564         try {
 565                 /* add_shortcut_folder throws an exception if the folder being added already has a shortcut */
 566                 chooser.add_shortcut_folder_uri("file:///Library/GarageBand/Apple Loops");
 567                 chooser.add_shortcut_folder_uri("file:///Library/Audio/Apple Loops");
 568                 chooser.add_shortcut_folder_uri("file:///Library/Application Support/GarageBand/Instrument Library/Sampler/Sampler Files");
 569                 chooser.add_shortcut_folder_uri("file:///Volumes");
 570         }
 571         catch (Glib::Error & e) {
 572                 std::cerr << "sfdb.add_shortcut_folder() threw Glib::Error " << e.what() << std::endl;
 573         }
 574 #endif
 575
 576         //add the file chooser
 577
 578         chooser.set_border_width (12);
 579
 580         audio_and_midi_filter.add_custom (FILE_FILTER_FILENAME, sigc::mem_fun (*this, &SoundFileBrowser::on_audio_and_midi_filter));
 581         audio_and_midi_filter.set_name (_("Audio and MIDI files"));
 582
 583         audio_filter.add_custom (FILE_FILTER_FILENAME, sigc::mem_fun(*this, &SoundFileBrowser::on_audio_filter));
 584         audio_filter.set_name (_("Audio files"));
 585
 586         midi_filter.add_custom (FILE_FILTER_FILENAME, sigc::mem_fun(*this, &SoundFileBrowser::on_midi_filter));
 587         midi_filter.set_name (_("MIDI files"));
 588
 589         matchall_filter.add_pattern ("*.*");
 590         matchall_filter.set_name (_("All files"));
 591
 592         chooser.add_filter (audio_and_midi_filter);
 593         chooser.add_filter (audio_filter);
 594         chooser.add_filter (midi_filter);
 595         chooser.add_filter (matchall_filter);
 596         chooser.set_select_multiple (true);
 597         chooser.signal_update_preview().connect(sigc::mem_fun(*this, &SoundFileBrowser::update_preview));
 598         chooser.signal_file_activated().connect (sigc::mem_fun (*this, &SoundFileBrowser::chooser_file_activated));
 599
 600 #ifdef GTKOSX
 601         /* some broken redraw behaviour - this is a bandaid */
 602         chooser.signal_selection_changed().connect (mem_fun (chooser, &Widget::queue_draw));
 603 #endif
 604
 605         if (!persistent_folder.empty()) {
 606                 chooser.set_current_folder (persistent_folder);
 607         }
 608
 609         notebook.append_page (chooser, _("Browse Files"));
 610
 611         hpacker.set_spacing (6);
 612         hpacker.pack_start (notebook, true, true);
 613         hpacker.pack_start (preview, false, false);
 614
 615         vpacker.set_spacing (6);
 616         vpacker.pack_start (hpacker, true, true);
 617
 618         add (vpacker);
 619
 620         //add tag search
 621
 622         VBox* vbox;
 623         HBox* hbox;
 624
 625
 626         hbox = manage(new HBox);
 627         hbox->pack_start (found_entry);
 628         hbox->pack_start (found_search_btn);
 629
 630         Gtk::ScrolledWindow *scroll = manage(new ScrolledWindow);
 631         scroll->add(found_list_view);
 632         scroll->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
 633
 634         vbox = manage(new VBox);
 635         vbox->pack_start (*hbox, PACK_SHRINK);
 636         vbox->pack_start (*scroll);
 637
 638         found_list_view.append_column(_("Paths"), found_list_columns.pathname);
 639
 640         found_list_view.get_selection()->signal_changed().connect(sigc::mem_fun(*this, &SoundFileBrowser::found_list_view_selected));
 641
 642         found_list_view.signal_row_activated().connect (sigc::mem_fun (*this, &SoundFileBrowser::found_list_view_activated));
 643
 644         found_search_btn.signal_clicked().connect(sigc::mem_fun(*this, &SoundFileBrowser::found_search_clicked));
 645         found_entry.signal_activate().connect(sigc::mem_fun(*this, &SoundFileBrowser::found_search_clicked));
 646
 647         notebook.append_page (*vbox, _("Search Tags"));
 648
 649         //add freesound search
 650
 651         HBox* passbox;
 652         Label* label;
 653
 654         passbox = manage(new HBox);
 655         passbox->set_spacing (6);
 656
 657         label = manage (new Label);
 658         label->set_text (_("Tags:"));
 659         passbox->pack_start (*label, false, false);
 660         passbox->pack_start (freesound_entry, true, true);
 661
 662         label = manage (new Label);
 663         label->set_text (_("Sort:"));
 664         passbox->pack_start (*label, false, false);
 665         passbox->pack_start (freesound_sort, false, false);
 666         freesound_sort.clear_items();
 667
 668         // Order of the following must correspond with enum sortMethod
 669         // in sfdb_freesound_mootcher.h
 670         freesound_sort.append_text(_("None"));
 671         freesound_sort.append_text(_("Longest"));
 672         freesound_sort.append_text(_("Shortest"));
 673         freesound_sort.append_text(_("Newest"));
 674         freesound_sort.append_text(_("Oldest"));
 675         freesound_sort.append_text(_("Most downloaded"));
 676         freesound_sort.append_text(_("Least downloaded"));
 677         freesound_sort.append_text(_("Highest rated"));
 678         freesound_sort.append_text(_("Lowest rated"));
 679         freesound_sort.set_active(0);
 680
 681         passbox->pack_start (freesound_search_btn, false, false);
 682         passbox->pack_start (freesound_more_btn, false, false);
 683         freesound_more_btn.set_label(_("More"));
 684         freesound_more_btn.set_sensitive(false);
 685
 686         passbox->pack_start (freesound_similar_btn, false, false);
 687         freesound_similar_btn.set_label(_("Similar"));
 688         freesound_similar_btn.set_sensitive(false);
 689
 690         scroll = manage(new ScrolledWindow);
 691         scroll->add(freesound_list_view);
 692         scroll->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
 693
 694         vbox = manage(new VBox);
 695         vbox->set_spacing (3);
 696         vbox->pack_start (*passbox, PACK_SHRINK);
 697         vbox->pack_start (*scroll);
 698
 699         freesound_list_view.append_column(_("ID")      , freesound_list_columns.id);
 700         freesound_list_view.append_column(_("Filename"), freesound_list_columns.filename);
 701         // freesound_list_view.append_column(_("URI")     , freesound_list_columns.uri);
 702         freesound_list_view.append_column(_("Duration"), freesound_list_columns.duration);
 703         freesound_list_view.append_column(_("Size"), freesound_list_columns.filesize);
 704         freesound_list_view.append_column(_("Samplerate"), freesound_list_columns.smplrate);
 705         freesound_list_view.append_column(_("License"), freesound_list_columns.license);
 706         freesound_list_view.get_column(0)->set_alignment(0.5);
 707         freesound_list_view.get_column(1)->set_expand(true); // filename
 708         freesound_list_view.get_column(1)->set_resizable(true); // filename
 709         freesound_list_view.get_column(2)->set_alignment(0.5);
 710         freesound_list_view.get_column(3)->set_alignment(0.5);
 711         freesound_list_view.get_column(4)->set_alignment(0.5);
 712         freesound_list_view.get_column(5)->set_alignment(0.5);
 713
 714         freesound_list_view.get_selection()->signal_changed().connect(sigc::mem_fun(*this, &SoundFileBrowser::freesound_list_view_selected));
 715         freesound_list_view.set_tooltip_column(1);
 716
 717         freesound_list_view.get_selection()->set_mode (SELECTION_MULTIPLE);
 718         freesound_list_view.signal_row_activated().connect (sigc::mem_fun (*this, &SoundFileBrowser::freesound_list_view_activated));
 719         freesound_search_btn.signal_clicked().connect(sigc::mem_fun(*this, &SoundFileBrowser::freesound_search_clicked));
 720         freesound_entry.signal_activate().connect(sigc::mem_fun(*this, &SoundFileBrowser::freesound_search_clicked));
 721         freesound_more_btn.signal_clicked().connect(sigc::mem_fun(*this, &SoundFileBrowser::freesound_more_clicked));
 722         freesound_similar_btn.signal_clicked().connect(sigc::mem_fun(*this, &SoundFileBrowser::freesound_similar_clicked));
 723         notebook.append_page (*vbox, _("Search Freesound"));
 724
 725         notebook.set_size_request (500, -1);
 726         notebook.signal_switch_page().connect (sigc::hide_return (sigc::hide (sigc::hide (sigc::mem_fun (*this, &SoundFileBrowser::reset_options)))));
 727
 728         set_session (s);
 729
 730         Gtk::HButtonBox* button_box = manage (new HButtonBox);
 731
 732         button_box->set_layout (BUTTONBOX_END);
 733         button_box->pack_start (close_button, false, false);
 734         close_button.signal_clicked().connect (sigc::bind (sigc::mem_fun (*this, &SoundFileBrowser::do_something), RESPONSE_CLOSE));
 735
 736         button_box->pack_start (import_button, false, false);
 737         import_button.signal_clicked().connect (sigc::bind (sigc::mem_fun (*this, &SoundFileBrowser::do_something), RESPONSE_OK));
 738
 739         Gtkmm2ext::UI::instance()->set_tip (import_button, _("Press to import selected files"));
 740         Gtkmm2ext::UI::instance()->set_tip (close_button, _("Press to close this window without importing any files"));
 741
 742         vpacker.pack_end (*button_box, false, false);
 743
 744         set_wmclass (X_("import"), PROGRAM_NAME);
 745 }
 746
 747 SoundFileBrowser::~SoundFileBrowser ()
 748 {
 749         persistent_folder = chooser.get_current_folder();
 750 }
 751
 752 int
 753 SoundFileBrowser::run ()
 754 {
 755         set_modal (true);
 756         show_all ();
 757         present ();
 758
 759         _done = false;
 760
 761         while (!_done) {
 762                 gtk_main_iteration ();
 763         }
 764
 765         return _status;
 766 }
 767
 768 void
 769 SoundFileBrowser::set_action_sensitive (bool yn)
 770 {
 771         import_button.set_sensitive (yn);
 772 }
 773
 774 void
 775 SoundFileBrowser::do_something (int action)
 776 {
 777         _done = true;
 778         _status = action;
 779 }
 780
 781 void
 782 SoundFileBrowser::on_show ()
 783 {
 784         ArdourWindow::on_show ();
 785         start_metering ();
 786 }
 787
 788 void
 789 SoundFileBrowser::clear_selection ()
 790 {
 791         chooser.unselect_all ();
 792         found_list_view.get_selection()->unselect_all ();
 793 }
 794
 795 void
 796 SoundFileBrowser::chooser_file_activated ()
 797 {
 798         preview.audition ();
 799 }
 800
 801 void
 802 SoundFileBrowser::found_list_view_activated (const TreeModel::Path&, TreeViewColumn*)
 803 {
 804         preview.audition ();
 805 }
 806
 807 void
 808 SoundFileBrowser::freesound_list_view_activated (const TreeModel::Path&, TreeViewColumn*)
 809 {
 810         preview.audition ();
 811 }
 812
 813 void
 814 SoundFileBrowser::set_session (Session* s)
 815 {
 816         ArdourWindow::set_session (s);
 817         preview.set_session (s);
 818
 819         if (_session) {
 820                 add_gain_meter ();
 821         } else {
 822                 remove_gain_meter ();
 823         }
 824 }
 825
 826 void
 827 SoundFileBrowser::add_gain_meter ()
 828 {
 829         delete gm;
 830
 831         gm = new GainMeter (_session, 250);
 832
 833         boost::shared_ptr<Route> r = _session->the_auditioner ();
 834
 835         gm->set_controls (r, r->shared_peak_meter(), r->amp());
 836         gm->set_fader_name (X_("GainFader"));
 837
 838         meter_packer.set_border_width (12);
 839         meter_packer.pack_start (*gm, false, true);
 840         hpacker.pack_end (meter_packer, false, false);
 841         meter_packer.show_all ();
 842         start_metering ();
 843 }
 844
 845 void
 846 SoundFileBrowser::remove_gain_meter ()
 847 {
 848         if (gm) {
 849                 meter_packer.remove (*gm);
 850                 hpacker.remove (meter_packer);
 851                 delete gm;
 852                 gm = 0;
 853         }
 854 }
 855
 856 void
 857 SoundFileBrowser::start_metering ()
 858 {
 859         metering_connection = Timers::super_rapid_connect (sigc::mem_fun(*this, &SoundFileBrowser::meter));
 860 }
 861
 862 void
 863 SoundFileBrowser::stop_metering ()
 864 {
 865         metering_connection.disconnect();
 866 }
 867
 868 void
 869 SoundFileBrowser::meter ()
 870 {
 871         if (is_mapped () && _session && gm) {
 872                 gm->update_meters ();
 873         }
 874 }
 875
 876 bool
 877 SoundFileBrowser::on_audio_filter (const FileFilter::Info& filter_info)
 878 {
 879         return AudioFileSource::safe_audio_file_extension (filter_info.filename);
 880 }
 881
 882 bool
 883 SoundFileBrowser::on_midi_filter (const FileFilter::Info& filter_info)
 884 {
 885         return SMFSource::safe_midi_file_extension (filter_info.filename);
 886 }
 887
 888 bool
 889 SoundFileBrowser::on_audio_and_midi_filter (const FileFilter::Info& filter_info)
 890 {
 891         return on_audio_filter (filter_info) || on_midi_filter (filter_info);
 892 }
 893
 894 void
 895 SoundFileBrowser::update_preview ()
 896 {
 897         if (preview.setup_labels (chooser.get_preview_filename())) {
 898                 if (preview.autoplay()) {
 899                         Glib::signal_idle().connect (sigc::mem_fun (preview, &SoundFileBox::audition_oneshot));
 900                 }
 901         }
 902 }
 903
 904 void
 905 SoundFileBrowser::found_list_view_selected ()
 906 {
 907         if (!reset_options ()) {
 908                 set_action_sensitive (false);
 909         } else {
 910                 string file;
 911
 912                 ListPath rows = found_list_view.get_selection()->get_selected_rows ();
 913
 914                 if (!rows.empty()) {
 915                         TreeIter iter = found_list->get_iter(*rows.begin());
 916                         file = (*iter)[found_list_columns.pathname];
 917                         chooser.set_filename (file);
 918                         set_action_sensitive (true);
 919                 } else {
 920                         set_action_sensitive (false);
 921                 }
 922
 923                 preview.setup_labels (file);
 924         }
 925 }
 926
 927 void
 928 SoundFileBrowser::found_search_clicked ()
 929 {
 930         string tag_string = found_entry.get_text ();
 931
 932         vector<string> tags;
 933
 934         if (!PBD::tokenize (tag_string, string(","), std::back_inserter (tags), true)) {
 935                 warning << _("SoundFileBrowser: Could not tokenize string: ") << tag_string << endmsg;
 936                 return;
 937         }
 938
 939         vector<string> results;
 940         Library->search_members_and (results, tags);
 941
 942         found_list->clear();
 943         for (vector<string>::iterator i = results.begin(); i != results.end(); ++i) {
 944                 TreeModel::iterator new_row = found_list->append();
 945                 TreeModel::Row row = *new_row;
 946                 string path = Glib::filename_from_uri (string ("file:") + *i);
 947                 row[found_list_columns.pathname] = path;
 948         }
 949 }
 950
 951
 952 std::string
 953 SoundFileBrowser::freesound_get_audio_file(Gtk::TreeIter iter)
 954 {
 955
 956         Mootcher *mootcher = new Mootcher;
 957         std::string file;
 958
 959         string id  = (*iter)[freesound_list_columns.id];
 960         string uri = (*iter)[freesound_list_columns.uri];
 961         string ofn = (*iter)[freesound_list_columns.filename];
 962
 963         if (mootcher->checkAudioFile(ofn, id)) {
 964                 // file already exists, no need to download it again
 965                 file = mootcher->audioFileName;
 966                 delete mootcher;
 967                 (*iter)[freesound_list_columns.started] = false;
 968                 return file;
 969         }
 970         if (!(*iter)[freesound_list_columns.started]) {
 971                 // start downloading the sound file
 972                 (*iter)[freesound_list_columns.started] = true;
 973                 mootcher->fetchAudioFile(ofn, id, uri, this);
 974         }
 975         return "";
 976 }
 977
 978 void
 979 SoundFileBrowser::freesound_list_view_selected ()
 980 {
 981
 982         if (!reset_options ()) {
 983                 set_action_sensitive (false);
 984         } else {
 985                 std::string file;
 986                 ListPath rows = freesound_list_view.get_selection()->get_selected_rows ();
 987                 for (ListPath::iterator i = rows.begin() ; i != rows.end(); ++i) {
 988                         file = freesound_get_audio_file (freesound_list->get_iter(*i));
 989                 }
 990
 991                 switch (rows.size()) {
 992                         case 0:
 993                                 // nothing selected
 994                                 freesound_similar_btn.set_sensitive(false);
 995                                 set_action_sensitive (false);
 996                                 break;
 997                         case 1:
 998                                 // exactly one item selected
 999                                 if (file != "") {
1000                                         // file exists on disk already
1001                                         chooser.set_filename (file);
1002                                         preview.setup_labels (file);
1003                                         set_action_sensitive (true);
1004                                 }
1005                                 freesound_similar_btn.set_sensitive(true);
1006                                 break;
1007                         default:
1008                                 // multiple items selected
1009                                 preview.setup_labels ("");
1010                                 freesound_similar_btn.set_sensitive(false);
1011                                 break;
1012                 }
1013
1014         }
1015 }
1016
1017 void
1018 SoundFileBrowser::refresh_display(std::string ID, std::string file)
1019 {
1020         // called when the mootcher has finished downloading a file
1021         ListPath rows = freesound_list_view.get_selection()->get_selected_rows ();
1022         if (rows.size() == 1) {
1023                 // there's a single item selected in the freesound list
1024                 //XXX make a function to be used to construct the actual file name both here and in the mootcher
1025                 Gtk::TreeIter row = freesound_list->get_iter(*rows.begin());
1026                 std::string selected_ID = (*row)[freesound_list_columns.id];
1027                 if (ID == selected_ID) {
1028                         // the selected item in the freesound list is the item that has just finished downloading
1029                         chooser.set_filename(file);
1030                         preview.setup_labels (file);
1031                         set_action_sensitive (true);
1032                 }
1033         }
1034 }
1035
1036 void
1037 SoundFileBrowser::freesound_search_clicked ()
1038 {
1039         freesound_page = 1;
1040         freesound_list->clear();
1041         matches = 0;
1042         freesound_search();
1043 }
1044
1045 void
1046 SoundFileBrowser::freesound_more_clicked ()
1047 {
1048         char row_path[21];
1049         freesound_page++;
1050         freesound_search();
1051         snprintf(row_path, 21, "%d", (freesound_page - 1) * 100);
1052         freesound_list_view.scroll_to_row(Gtk::TreePath(row_path), 0);
1053 }
1054
1055 void
1056 SoundFileBrowser::freesound_similar_clicked ()
1057 {
1058         ListPath rows = freesound_list_view.get_selection()->get_selected_rows ();
1059         if (rows.size() == 1) {
1060                 Mootcher mootcher;
1061                 string id;
1062                 Gtk::TreeIter iter = freesound_list->get_iter(*rows.begin());
1063                 id = (*iter)[freesound_list_columns.id];
1064                 freesound_list->clear();
1065
1066                 GdkCursor *prev_cursor;
1067                 prev_cursor = gdk_window_get_cursor (get_window()->gobj());
1068                 gdk_window_set_cursor (get_window()->gobj(), gdk_cursor_new(GDK_WATCH));
1069                 gdk_flush();
1070
1071                 std::string theString = mootcher.searchSimilar(id);
1072
1073                 gdk_window_set_cursor (get_window()->gobj(), prev_cursor);
1074                 handle_freesound_results(theString);
1075         }
1076 }
1077
1078 void
1079 SoundFileBrowser::freesound_search()
1080 {
1081         Mootcher mootcher;
1082
1083         string search_string = freesound_entry.get_text ();
1084         enum sortMethod sort_method = (enum sortMethod) freesound_sort.get_active_row_number();
1085
1086         GdkCursor *prev_cursor;
1087         prev_cursor = gdk_window_get_cursor (get_window()->gobj());
1088         gdk_window_set_cursor (get_window()->gobj(), gdk_cursor_new(GDK_WATCH));
1089         gdk_flush();
1090
1091         std::string theString = mootcher.searchText(
1092                         search_string,
1093                         freesound_page,
1094 #ifdef GTKOSX
1095                         "", // OSX eats anything incl mp3
1096 #else
1097                         "type:wav OR type:aiff OR type:flac OR type:aif OR type:ogg OR type:oga",
1098 #endif
1099                         sort_method
1100                         );
1101
1102         gdk_window_set_cursor (get_window()->gobj(), prev_cursor);
1103         handle_freesound_results(theString);
1104 }
1105
1106 void
1107 SoundFileBrowser::handle_freesound_results(std::string theString) {
1108         XMLTree doc;
1109         doc.read_buffer( theString );
1110         XMLNode *root = doc.root();
1111
1112         if (!root) {
1113                 error << "no root XML node!" << endmsg;
1114                 return;
1115         }
1116
1117         if ( strcmp(root->name().c_str(), "response") != 0) {
1118                 error << string_compose ("root node name == %1 != \"response\"", root->name()) << endmsg;
1119                 return;
1120         }
1121
1122         // find out how many pages are available to search
1123         int freesound_n_pages = 1;
1124         XMLNode *res = root->child("num_pages");
1125         if (res) {
1126                 string result = res->child("text")->content();
1127                 freesound_n_pages = atoi(result);
1128         }
1129
1130         int more_pages = freesound_n_pages - freesound_page;
1131
1132         if (more_pages > 0) {
1133                 freesound_more_btn.set_sensitive(true);
1134                 freesound_more_btn.set_tooltip_text(string_compose(P_(
1135                                                 "%1 more page of 100 results available",
1136                                                 "%1 more pages of 100 results available",
1137                                                 more_pages), more_pages));
1138         } else {
1139                 freesound_more_btn.set_sensitive(false);
1140                 freesound_more_btn.set_tooltip_text(_("No more results available"));
1141         }
1142
1143         XMLNode *sounds_root = root->child("sounds");
1144         if (!sounds_root) {
1145                 error << "no child node \"sounds\" found!" << endmsg;
1146                 return;
1147         }
1148
1149         XMLNodeList sounds = sounds_root->children();
1150         if (sounds.size() == 0) {
1151                 /* nothing found */
1152                 return;
1153         }
1154
1155         XMLNodeConstIterator niter;
1156         XMLNode *node;
1157         for (niter = sounds.begin(); niter != sounds.end(); ++niter) {
1158                 node = *niter;
1159                 if( strcmp( node->name().c_str(), "resource") != 0 ) {
1160                         error << string_compose ("node->name()=%1 != \"resource\"", node->name()) << endmsg;
1161                         break;
1162                 }
1163
1164                 // node->dump(cerr, "node:");
1165
1166
1167                 XMLNode *id_node  = node->child ("id");
1168                 XMLNode *uri_node = node->child ("serve");
1169                 XMLNode *ofn_node = node->child ("original_filename");
1170                 XMLNode *dur_node = node->child ("duration");
1171                 XMLNode *siz_node = node->child ("filesize");
1172                 XMLNode *srt_node = node->child ("samplerate");
1173                 XMLNode *lic_node = node->child ("license");
1174
1175                 if (id_node && uri_node && ofn_node && dur_node && siz_node && srt_node) {
1176
1177                         std::string  id =  id_node->child("text")->content();
1178                         std::string uri = uri_node->child("text")->content();
1179                         std::string ofn = ofn_node->child("text")->content();
1180                         std::string dur = dur_node->child("text")->content();
1181                         std::string siz = siz_node->child("text")->content();
1182                         std::string srt = srt_node->child("text")->content();
1183                         std::string lic = lic_node->child("text")->content();
1184
1185                         std::string r;
1186                         // cerr << "id=" << id << ",uri=" << uri << ",ofn=" << ofn << ",dur=" << dur << endl;
1187
1188                         double duration_seconds = atof(dur);
1189                         double h, m, s;
1190                         char duration_hhmmss[16];
1191                         if (duration_seconds >= 99 * 60 * 60) {
1192                                 strcpy(duration_hhmmss, ">99h");
1193                         } else {
1194                                 s = modf(duration_seconds/60, &m) * 60;
1195                                 m = modf(m/60, &h) * 60;
1196                                 sprintf(duration_hhmmss, "%02.fh:%02.fm:%04.1fs",
1197                                                 h, m, s
1198                                        );
1199                         }
1200
1201                         double size_bytes = atof(siz);
1202                         char bsize[32];
1203                         if (size_bytes < 1000) {
1204                                 sprintf(bsize, "%.0f %s", size_bytes, _("B"));
1205                         } else if (size_bytes < 1000000 ) {
1206                                 sprintf(bsize, "%.1f %s", size_bytes / 1000.0, _("kB"));
1207                         } else if (size_bytes < 10000000) {
1208                                 sprintf(bsize, "%.1f %s", size_bytes / 1000000.0, _("MB"));
1209                         } else if (size_bytes < 1000000000) {
1210                                 sprintf(bsize, "%.2f %s", size_bytes / 1000000.0, _("MB"));
1211                         } else {
1212                                 sprintf(bsize, "%.2f %s", size_bytes / 1000000000.0, _("GB"));
1213                         }
1214
1215                         /* see http://www.freesound.org/help/faq/#licenses */
1216                         char shortlicense[64];
1217                         if(!lic.compare(0, 42, "http://creativecommons.org/licenses/by-nc/")){
1218                                 sprintf(shortlicense, "CC-BY-NC");
1219                         } else if(!lic.compare(0, 39, "http://creativecommons.org/licenses/by/")) {
1220                                 sprintf(shortlicense, "CC-BY");
1221                         } else if(!lic.compare("http://creativecommons.org/licenses/sampling+/1.0/")) {
1222                                 sprintf(shortlicense, "sampling+");
1223                         } else if(!lic.compare(0, 40, "http://creativecommons.org/publicdomain/")) {
1224                                 sprintf(shortlicense, "PD");
1225                         } else {
1226                                 snprintf(shortlicense, 64, "%s", lic.c_str());
1227                                 shortlicense[63]= '\0';
1228                         }
1229
1230                         TreeModel::iterator new_row = freesound_list->append();
1231                         TreeModel::Row row = *new_row;
1232
1233                         row[freesound_list_columns.id      ] = id;
1234                         row[freesound_list_columns.uri     ] = uri;
1235                         row[freesound_list_columns.filename] = ofn;
1236                         row[freesound_list_columns.duration] = duration_hhmmss;
1237                         row[freesound_list_columns.filesize] = bsize;
1238                         row[freesound_list_columns.smplrate] = srt;
1239                         row[freesound_list_columns.license ] = shortlicense;
1240                         matches++;
1241                 }
1242         }
1243 }
1244
1245 vector<string>
1246 SoundFileBrowser::get_paths ()
1247 {
1248         vector<string> results;
1249
1250         int n = notebook.get_current_page ();
1251
1252         if (n == 0) {
1253                 vector<string> filenames = chooser.get_filenames();
1254                 vector<string>::iterator i;
1255
1256                 for (i = filenames.begin(); i != filenames.end(); ++i) {
1257                         GStatBuf buf;
1258                         if ((!g_stat((*i).c_str(), &buf)) && S_ISREG(buf.st_mode)) {
1259                                 results.push_back (*i);
1260                         }
1261                 }
1262
1263         } else if (n == 1) {
1264
1265                 ListPath rows = found_list_view.get_selection()->get_selected_rows ();
1266                 for (ListPath::iterator i = rows.begin() ; i != rows.end(); ++i) {
1267                         TreeIter iter = found_list->get_iter(*i);
1268                         string str = (*iter)[found_list_columns.pathname];
1269
1270                         results.push_back (str);
1271                 }
1272         } else {
1273                 ListPath rows = freesound_list_view.get_selection()->get_selected_rows ();
1274                 for (ListPath::iterator i = rows.begin() ; i != rows.end(); ++i) {
1275                         string str = freesound_get_audio_file (freesound_list->get_iter(*i));
1276                         if (str != "") {
1277                                 results.push_back (str);
1278                         }
1279                 }
1280         }
1281
1282         return results;
1283 }
1284
1285 void
1286 SoundFileOmega::reset_options_noret ()
1287 {
1288         if (!resetting_ourselves) {
1289                 (void) reset_options ();
1290         }
1291 }
1292
1293 bool
1294 SoundFileOmega::reset_options ()
1295 {
1296         vector<string> paths = get_paths ();
1297
1298         if (paths.empty()) {
1299
1300                 channel_combo.set_sensitive (false);
1301                 action_combo.set_sensitive (false);
1302                 where_combo.set_sensitive (false);
1303                 copy_files_btn.set_active (true);
1304                 copy_files_btn.set_sensitive (false);
1305
1306                 return false;
1307
1308         } else {
1309
1310                 channel_combo.set_sensitive (true);
1311                 action_combo.set_sensitive (true);
1312                 where_combo.set_sensitive (true);
1313
1314                 /* if we get through this function successfully, this may be
1315                    reset at the end, once we know if we can use hard links
1316                    to do embedding (or if we are importing a MIDI file).
1317                 */
1318
1319                 if (UIConfiguration::instance().get_only_copy_imported_files()) {
1320                         copy_files_btn.set_sensitive (false);
1321                 } else {
1322                         copy_files_btn.set_sensitive (false);
1323                 }
1324         }
1325
1326         bool same_size;
1327         bool src_needed;
1328         bool selection_includes_multichannel;
1329         bool selection_can_be_embedded_with_links = check_link_status (_session, paths);
1330         ImportMode mode;
1331
1332         /* See if we are thinking about importing any MIDI files */
1333         vector<string>::iterator i = paths.begin ();
1334         while (i != paths.end() && SMFSource::valid_midi_file (*i) == false) {
1335                 ++i;
1336         }
1337         bool const have_a_midi_file = (i != paths.end ());
1338
1339         if (check_info (paths, same_size, src_needed, selection_includes_multichannel)) {
1340                 Glib::signal_idle().connect (sigc::mem_fun (*this, &SoundFileOmega::bad_file_message));
1341                 return false;
1342         }
1343
1344         string existing_choice;
1345         vector<string> action_strings;
1346
1347         resetting_ourselves = true;
1348
1349         if (chooser.get_filter() == &audio_filter) {
1350
1351                 /* AUDIO */
1352
1353                 if (selected_audio_track_cnt > 0) {
1354                         if (channel_combo.get_active_text().length()) {
1355                                 ImportDisposition id = get_channel_disposition();
1356
1357                                 switch (id) {
1358                                 case Editing::ImportDistinctFiles:
1359                                         if (selected_audio_track_cnt == paths.size()) {
1360                                                 action_strings.push_back (importmode2string (ImportToTrack));
1361                                         }
1362                                         break;
1363
1364                                 case Editing::ImportDistinctChannels:
1365                                         /* XXX it would be nice to allow channel-per-selected track
1366                                            but its too hard we don't want to deal with all the
1367                                            different per-file + per-track channel configurations.
1368                                         */
1369                                         break;
1370
1371                                 default:
1372                                         action_strings.push_back (importmode2string (ImportToTrack));
1373                                         break;
1374                                 }
1375                         }
1376                 }
1377
1378         }  else {
1379
1380                 /* MIDI ONLY */
1381
1382                 if (selected_midi_track_cnt > 0) {
1383                         action_strings.push_back (importmode2string (ImportToTrack));
1384                 }
1385         }
1386
1387         action_strings.push_back (importmode2string (ImportAsTrack));
1388         action_strings.push_back (importmode2string (ImportAsRegion));
1389         action_strings.push_back (importmode2string (ImportAsTapeTrack));
1390
1391         existing_choice = action_combo.get_active_text();
1392
1393         set_popdown_strings (action_combo, action_strings);
1394
1395         /* preserve any existing choice, if possible */
1396
1397
1398         if (existing_choice.length()) {
1399                 vector<string>::iterator x;
1400                 for (x = action_strings.begin(); x != action_strings.end(); ++x) {
1401                         if (*x == existing_choice) {
1402                                 action_combo.set_active_text (existing_choice);
1403                                 break;
1404                         }
1405                 }
1406                 if (x == action_strings.end()) {
1407                         action_combo.set_active_text (action_strings.front());
1408                 }
1409         } else {
1410                 action_combo.set_active_text (action_strings.front());
1411         }
1412
1413         resetting_ourselves = false;
1414
1415         if ((mode = get_mode()) == ImportAsRegion) {
1416                 where_combo.set_sensitive (false);
1417         } else {
1418                 where_combo.set_sensitive (true);
1419         }
1420
1421         vector<string> channel_strings;
1422
1423         if (mode == ImportAsTrack || mode == ImportAsTapeTrack || mode == ImportToTrack) {
1424                 channel_strings.push_back (_("one track per file"));
1425
1426                 if (selection_includes_multichannel) {
1427                         channel_strings.push_back (_("one track per channel"));
1428                 }
1429
1430                 if (paths.size() > 1) {
1431                         /* tape tracks are a single region per track, so we cannot
1432                            sequence multiple files.
1433                         */
1434                         if (mode != ImportAsTapeTrack) {
1435                                 channel_strings.push_back (_("sequence files"));
1436                         }
1437                         if (same_size) {
1438                                 channel_strings.push_back (_("all files in one track"));
1439                                 channel_strings.push_back (_("merge files"));
1440                         }
1441
1442                 }
1443
1444         } else {
1445                 channel_strings.push_back (_("one region per file"));
1446
1447                 if (selection_includes_multichannel) {
1448                         channel_strings.push_back (_("one region per channel"));
1449                 }
1450
1451                 if (paths.size() > 1) {
1452                         if (same_size) {
1453                                 channel_strings.push_back (_("all files in one region"));
1454                         }
1455                 }
1456         }
1457
1458         resetting_ourselves = true;
1459
1460         existing_choice = channel_combo.get_active_text();
1461
1462         set_popdown_strings (channel_combo, channel_strings);
1463
1464         /* preserve any existing choice, if possible */
1465
1466         if (existing_choice.length()) {
1467                 vector<string>::iterator x;
1468                 for (x = channel_strings.begin(); x != channel_strings.end(); ++x) {
1469                         if (*x == existing_choice) {
1470                                 channel_combo.set_active_text (existing_choice);
1471                                 break;
1472                         }
1473                 }
1474                 if (x == channel_strings.end()) {
1475                         channel_combo.set_active_text (channel_strings.front());
1476                 }
1477         } else {
1478                 channel_combo.set_active_text (channel_strings.front());
1479         }
1480
1481         resetting_ourselves = false;
1482
1483         if (src_needed) {
1484                 src_combo.set_sensitive (true);
1485         } else {
1486                 src_combo.set_sensitive (false);
1487         }
1488
1489         /* We must copy MIDI files or those from Freesound
1490          * or any file if we are under nsm control */
1491         bool const must_copy = _session->get_nsm_state() || have_a_midi_file || notebook.get_current_page() == 2;
1492
1493         if (UIConfiguration::instance().get_only_copy_imported_files()) {
1494
1495                 if (selection_can_be_embedded_with_links && !must_copy) {
1496                         copy_files_btn.set_sensitive (true);
1497                 } else {
1498                         if (must_copy) {
1499                                 copy_files_btn.set_active (true);
1500                         }
1501                         copy_files_btn.set_sensitive (false);
1502                 }
1503
1504         }  else {
1505
1506                 if (must_copy) {
1507                         copy_files_btn.set_active (true);
1508                 }
1509                 copy_files_btn.set_sensitive (!must_copy);
1510         }
1511
1512         return true;
1513 }
1514
1515
1516 bool
1517 SoundFileOmega::bad_file_message()
1518 {
1519         MessageDialog msg (*this,
1520                            string_compose (_("One or more of the selected files\ncannot be used by %1"), PROGRAM_NAME),
1521                            true,
1522                            Gtk::MESSAGE_INFO,
1523                            Gtk::BUTTONS_OK);
1524         msg.run ();
1525         resetting_ourselves = true;
1526         chooser.unselect_uri (chooser.get_preview_uri());
1527         resetting_ourselves = false;
1528
1529         return false;
1530 }
1531
1532 bool
1533 SoundFileOmega::check_info (const vector<string>& paths, bool& same_size, bool& src_needed, bool& multichannel)
1534 {
1535         SoundFileInfo info;
1536         framepos_t sz = 0;
1537         bool err = false;
1538         string errmsg;
1539
1540         same_size = true;
1541         src_needed = false;
1542         multichannel = false;
1543
1544         for (vector<string>::const_iterator i = paths.begin(); i != paths.end(); ++i) {
1545
1546                 if (AudioFileSource::get_soundfile_info (*i, info, errmsg)) {
1547                         if (info.channels > 1) {
1548                                 multichannel = true;
1549                         }
1550                         if (sz == 0) {
1551                                 sz = info.length;
1552                         } else {
1553                                 if (sz != info.length) {
1554                                         same_size = false;
1555                                 }
1556                         }
1557
1558                         if (info.samplerate != _session->frame_rate()) {
1559                                 src_needed = true;
1560                         }
1561
1562                 } else if (SMFSource::valid_midi_file (*i)) {
1563
1564                         Evoral::SMF reader;
1565                         reader.open(*i);
1566                         if (reader.num_tracks() > 1) {
1567                                 multichannel = true; // "channel" == track here...
1568                         }
1569
1570                         /* XXX we need err = true handling here in case
1571                            we can't check the file
1572                         */
1573
1574                 } else {
1575                         err = true;
1576                 }
1577         }
1578
1579         return err;
1580 }
1581
1582
1583 bool
1584 SoundFileOmega::check_link_status (const Session* s, const vector<string>& paths)
1585 {
1586 #ifdef PLATFORM_WINDOWS
1587         return false;
1588 #else
1589         std::string tmpdir(Glib::build_filename (s->session_directory().sound_path(), "linktest"));
1590         bool ret = false;
1591
1592         if (g_mkdir (tmpdir.c_str(), 0744)) {
1593                 if (errno != EEXIST) {
1594                         return false;
1595                 }
1596         }
1597
1598         for (vector<string>::const_iterator i = paths.begin(); i != paths.end(); ++i) {
1599
1600                 char tmpc[PATH_MAX+1];
1601
1602                 snprintf (tmpc, sizeof(tmpc), "%s/%s", tmpdir.c_str(), Glib::path_get_basename (*i).c_str());
1603
1604                 /* can we link ? */
1605
1606                 if (link ((*i).c_str(), tmpc)) {
1607                         goto out;
1608                 }
1609
1610                 ::g_unlink (tmpc);
1611         }
1612
1613         ret = true;
1614
1615   out:
1616         g_rmdir (tmpdir.c_str());
1617         return ret;
1618 #endif
1619 }
1620
1621 SoundFileChooser::SoundFileChooser (string title, ARDOUR::Session* s)
1622         : SoundFileBrowser (title, s, false)
1623 {
1624         chooser.set_select_multiple (false);
1625         found_list_view.get_selection()->set_mode (SELECTION_SINGLE);
1626         freesound_list_view.get_selection()->set_mode (SELECTION_SINGLE);
1627 }
1628
1629 void
1630 SoundFileChooser::on_hide ()
1631 {
1632         ArdourWindow::on_hide();
1633         stop_metering ();
1634
1635         if (_session) {
1636                 _session->cancel_audition();
1637         }
1638 }
1639
1640 string
1641 SoundFileChooser::get_filename ()
1642 {
1643         vector<string> paths;
1644
1645         paths = get_paths ();
1646
1647         if (paths.empty()) {
1648                 return string ();
1649         }
1650
1651         if (!Glib::file_test (paths.front(), Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_REGULAR)) {
1652                 return string();
1653         }
1654
1655         return paths.front();
1656 }
1657
1658 SoundFileOmega::SoundFileOmega (string title, ARDOUR::Session* s,
1659                                 uint32_t selected_audio_tracks,
1660                                 uint32_t selected_midi_tracks,
1661                                 bool persistent,
1662                                 Editing::ImportMode mode_hint)
1663         : SoundFileBrowser (title, s, persistent)
1664         , copy_files_btn ( _("Copy files to session"))
1665         , selected_audio_track_cnt (selected_audio_tracks)
1666         , selected_midi_track_cnt (selected_midi_tracks)
1667 {
1668         VBox* vbox;
1669         HBox* hbox;
1670         vector<string> str;
1671
1672         set_size_request (-1, 450);
1673
1674         block_two.set_border_width (12);
1675         block_three.set_border_width (12);
1676         block_four.set_border_width (12);
1677
1678         options.set_spacing (12);
1679
1680         str.clear ();
1681         str.push_back (_("file timestamp"));
1682         str.push_back (_("edit point"));
1683         str.push_back (_("playhead"));
1684         str.push_back (_("session start"));
1685         set_popdown_strings (where_combo, str);
1686         where_combo.set_active_text (str.front());
1687         where_combo.signal_changed().connect (sigc::mem_fun (*this, &SoundFileOmega::where_combo_changed));
1688
1689         Label* l = manage (new Label);
1690         l->set_markup (_("<b>Add files as ...</b>"));
1691
1692         vbox = manage (new VBox);
1693         vbox->set_border_width (12);
1694         vbox->set_spacing (6);
1695         vbox->pack_start (*l, false, false);
1696         vbox->pack_start (action_combo, false, false);
1697         hbox = manage (new HBox);
1698         hbox->pack_start (*vbox, false, false);
1699         options.pack_start (*hbox, false, false);
1700
1701         l = manage (new Label);
1702         l->set_markup (_("<b>Insert at</b>"));
1703
1704         vbox = manage (new VBox);
1705         vbox->set_border_width (12);
1706         vbox->set_spacing (6);
1707         vbox->pack_start (*l, false, false);
1708         vbox->pack_start (where_combo, false, false);
1709         hbox = manage (new HBox);
1710         hbox->pack_start (*vbox, false, false);
1711         options.pack_start (*hbox, false, false);
1712
1713
1714         l = manage (new Label);
1715         l->set_markup (_("<b>Mapping</b>"));
1716
1717         vbox = manage (new VBox);
1718         vbox->set_border_width (12);
1719         vbox->set_spacing (6);
1720         vbox->pack_start (*l, false, false);
1721         vbox->pack_start (channel_combo, false, false);
1722         hbox = manage (new HBox);
1723         hbox->pack_start (*vbox, false, false);
1724         options.pack_start (*hbox, false, false);
1725
1726         str.clear ();
1727         str.push_back (_("one track per file"));
1728         set_popdown_strings (channel_combo, str);
1729         channel_combo.set_active_text (str.front());
1730         channel_combo.set_sensitive (false);
1731
1732         l = manage (new Label);
1733         l->set_markup (_("<b>Conversion quality</b>"));
1734
1735         vbox = manage (new VBox);
1736         vbox->set_border_width (12);
1737         vbox->set_spacing (6);
1738         vbox->pack_start (*l, false, false);
1739         vbox->pack_start (src_combo, false, false);
1740         hbox = manage (new HBox);
1741         hbox->pack_start (*vbox, false, false);
1742         options.pack_start (*hbox, false, false);
1743
1744         l = manage (new Label);
1745         l->set_markup (_("<b>Instrument</b>"));
1746
1747         vbox = manage (new VBox);
1748         vbox->set_border_width (12);
1749         vbox->set_spacing (6);
1750         vbox->pack_start (*l, false, false);
1751         vbox->pack_start (instrument_combo, false, false);
1752         hbox = manage (new HBox);
1753         hbox->pack_start (*vbox, false, false);
1754         options.pack_start (*hbox, false, false);
1755
1756         str.clear ();
1757         str.push_back (_("Best"));
1758         str.push_back (_("Good"));
1759         str.push_back (_("Quick"));
1760         str.push_back (_("Fast"));
1761         str.push_back (_("Fastest"));
1762
1763         set_popdown_strings (src_combo, str);
1764         src_combo.set_active_text (str.front());
1765         src_combo.set_sensitive (false);
1766         src_combo.signal_changed().connect (sigc::mem_fun (*this, &SoundFileOmega::src_combo_changed));
1767
1768         action_combo.signal_changed().connect (sigc::mem_fun (*this, &SoundFileOmega::reset_options_noret));
1769         channel_combo.signal_changed().connect (sigc::mem_fun (*this, &SoundFileOmega::reset_options_noret));
1770
1771         copy_files_btn.set_active (true);
1772
1773         Gtk::Label* copy_label = dynamic_cast<Gtk::Label*>(copy_files_btn.get_child());
1774
1775         if (copy_label) {
1776                 copy_label->set_size_request (175, -1);
1777                 copy_label->set_line_wrap (true);
1778         }
1779
1780         block_four.pack_start (copy_files_btn, false, false);
1781
1782         options.pack_start (block_four, false, false);
1783
1784         vpacker.pack_start (options, false, false);
1785
1786         /* setup disposition map */
1787
1788         disposition_map.insert (pair<string,ImportDisposition>(_("one track per file"), ImportDistinctFiles));
1789         disposition_map.insert (pair<string,ImportDisposition>(_("one track per channel"), ImportDistinctChannels));
1790         disposition_map.insert (pair<string,ImportDisposition>(_("merge files"), ImportMergeFiles));
1791         disposition_map.insert (pair<string,ImportDisposition>(_("sequence files"), ImportSerializeFiles));
1792
1793         disposition_map.insert (pair<string,ImportDisposition>(_("one region per file"), ImportDistinctFiles));
1794         disposition_map.insert (pair<string,ImportDisposition>(_("one region per channel"), ImportDistinctChannels));
1795         disposition_map.insert (pair<string,ImportDisposition>(_("all files in one region"), ImportMergeFiles));
1796         disposition_map.insert (pair<string,ImportDisposition>(_("all files in one track"), ImportMergeFiles));
1797
1798         chooser.signal_selection_changed().connect (sigc::mem_fun (*this, &SoundFileOmega::file_selection_changed));
1799
1800         /* set size requests for a couple of combos to allow them to display the longest text
1801            they will ever be asked to display.  This prevents them being resized when the user
1802            selects a file to import, which in turn prevents the size of the dialog from jumping
1803            around. */
1804
1805         str.clear ();
1806         str.push_back (_("one track per file"));
1807         str.push_back (_("one track per channel"));
1808         str.push_back (_("sequence files"));
1809         str.push_back (_("all files in one region"));
1810         set_popdown_strings (channel_combo, str);
1811
1812         str.clear ();
1813         str.push_back (importmode2string (ImportAsTrack));
1814         str.push_back (importmode2string (ImportToTrack));
1815         str.push_back (importmode2string (ImportAsRegion));
1816         str.push_back (importmode2string (ImportAsTapeTrack));
1817         set_popdown_strings (action_combo, str);
1818         action_combo.set_active_text (importmode2string(mode_hint));
1819
1820         reset (selected_audio_tracks, selected_midi_tracks);
1821 }
1822
1823 void
1824 SoundFileOmega::set_mode (ImportMode mode)
1825 {
1826         action_combo.set_active_text (importmode2string (mode));
1827 }
1828
1829 ImportMode
1830 SoundFileOmega::get_mode () const
1831 {
1832         return string2importmode (action_combo.get_active_text());
1833 }
1834
1835 void
1836 SoundFileOmega::on_hide ()
1837 {
1838         ArdourWindow::on_hide();
1839         if (_session) {
1840                 _session->cancel_audition();
1841         }
1842 }
1843
1844 ImportPosition
1845 SoundFileOmega::get_position() const
1846 {
1847         string str = where_combo.get_active_text();
1848
1849         if (str == _("file timestamp")) {
1850                 return ImportAtTimestamp;
1851         } else if (str == _("edit point")) {
1852                 return ImportAtEditPoint;
1853         } else if (str == _("playhead")) {
1854                 return ImportAtPlayhead;
1855         } else {
1856                 return ImportAtStart;
1857         }
1858 }
1859
1860 SrcQuality
1861 SoundFileOmega::get_src_quality() const
1862 {
1863         string str = src_combo.get_active_text();
1864
1865         if (str == _("Best")) {
1866                 return SrcBest;
1867         } else if (str == _("Good")) {
1868                 return SrcGood;
1869         } else if (str == _("Quick")) {
1870                 return SrcQuick;
1871         } else if (str == _("Fast")) {
1872                 return SrcFast;
1873         } else {
1874                 return SrcFastest;
1875         }
1876 }
1877
1878 void
1879 SoundFileOmega::src_combo_changed()
1880 {
1881         preview.set_src_quality(get_src_quality());
1882 }
1883
1884 void
1885 SoundFileOmega::where_combo_changed()
1886 {
1887         preview.set_import_position(get_position());
1888 }
1889
1890 ImportDisposition
1891 SoundFileOmega::get_channel_disposition () const
1892 {
1893         /* we use a map here because the channel combo can contain different strings
1894            depending on the state of the other combos. the map contains all possible strings
1895            and the ImportDisposition enum that corresponds to it.
1896         */
1897
1898         string str = channel_combo.get_active_text();
1899         DispositionMap::const_iterator x = disposition_map.find (str);
1900
1901         if (x == disposition_map.end()) {
1902                 fatal << string_compose (_("programming error: %1 (%2)"), "unknown string for import disposition", str) << endmsg;
1903                 abort(); /*NOTREACHED*/
1904         }
1905
1906         return x->second;
1907 }
1908
1909 void
1910 SoundFileOmega::reset (uint32_t selected_audio_tracks, uint32_t selected_midi_tracks)
1911 {
1912         selected_audio_track_cnt = selected_audio_tracks;
1913         selected_midi_track_cnt = selected_midi_tracks;
1914
1915         if (selected_audio_track_cnt == 0 && selected_midi_track_cnt > 0) {
1916                 chooser.set_filter (midi_filter);
1917         } else if (selected_midi_track_cnt == 0 && selected_audio_track_cnt > 0) {
1918                 chooser.set_filter (audio_filter);
1919         } else {
1920                 chooser.set_filter (audio_and_midi_filter);
1921         }
1922
1923         reset_options ();
1924 }
1925
1926 void
1927 SoundFileOmega::file_selection_changed ()
1928 {
1929         if (resetting_ourselves) {
1930                 return;
1931         }
1932
1933         if (!reset_options ()) {
1934                 set_action_sensitive (false);
1935         } else {
1936                 if (chooser.get_filenames().size() > 0) {
1937                         set_action_sensitive (true);
1938                 } else {
1939                         set_action_sensitive (false);
1940                 }
1941         }
1942 }
1943
1944 void
1945 SoundFileOmega::do_something (int action)
1946 {
1947         SoundFileBrowser::do_something (action);
1948
1949         if (action == RESPONSE_CLOSE) {
1950                 hide ();
1951                 return;
1952         }
1953
1954         /* lets do it */
1955
1956         vector<string> paths = get_paths ();
1957         ImportPosition pos = get_position ();
1958         ImportMode mode = get_mode ();
1959         ImportDisposition chns = get_channel_disposition ();
1960         PluginInfoPtr instrument = instrument_combo.selected_instrument();
1961         framepos_t where;
1962
1963         switch (pos) {
1964         case ImportAtEditPoint:
1965                 where = PublicEditor::instance().get_preferred_edit_position ();
1966                 break;
1967         case ImportAtTimestamp:
1968                 where = -1;
1969                 break;
1970         case ImportAtPlayhead:
1971                 where = _session->transport_frame();
1972                 break;
1973         case ImportAtStart:
1974                 where = _session->current_start_frame();
1975                 break;
1976         }
1977
1978         SrcQuality quality = get_src_quality();
1979
1980         if (copy_files_btn.get_active()) {
1981                 PublicEditor::instance().do_import (paths, chns, mode, quality, where, instrument);
1982         } else {
1983                 PublicEditor::instance().do_embed (paths, chns, mode, where, instrument);
1984         }
1985 }
1986