gtk2_ardour/export_dialog.cc

   1 /*
   2     Copyright (C) 1999-2005 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
  21 #include <unistd.h>
  22 #include <utility>
  23 #include <sys/stat.h>
  24 #include <fstream>
  25
  26 #include <samplerate.h>
  27
  28 #include <pbd/convert.h>
  29 #include <pbd/xml++.h>
  30
  31 #include <gtkmm2ext/utils.h>
  32 #include <gtkmm2ext/window_title.h>
  33
  34 #include <ardour/export.h>
  35 #include <ardour/sndfile_helpers.h>
  36 #include <ardour/audio_track.h>
  37 #include <ardour/audioregion.h>
  38 #include <ardour/audioengine.h>
  39 #include <ardour/gdither.h>
  40 #include <ardour/utils.h>
  41
  42 #include "export_dialog.h"
  43 #include "ardour_ui.h"
  44 #include "public_editor.h"
  45 #include "keyboard.h"
  46
  47 #include "i18n.h"
  48
  49 #define FRAME_NAME "BaseFrame"
  50
  51 using namespace std;
  52 using namespace ARDOUR;
  53 using namespace PBD;
  54 using namespace sigc;
  55 using namespace Gtk;
  56 using namespace Gtkmm2ext;
  57
  58 static const gchar *sample_rates[] = {
  59         N_("22.05kHz"),
  60         N_("44.1kHz"),
  61         N_("48kHz"),
  62         N_("88.2kHz"),
  63         N_("96kHz"),
  64         N_("192kHz"),
  65         0
  66 };
  67
  68 static const gchar *src_quality[] = {
  69         N_("best"),
  70         N_("fastest"),
  71         N_("linear"),
  72         N_("better"),
  73         N_("intermediate"),
  74         0
  75 };
  76
  77 static const gchar *dither_types[] = {
  78         N_("None"),
  79         N_("Rectangular"),
  80         N_("Shaped Noise"),
  81         N_("Triangular"),
  82         0
  83 };
  84
  85 static const gchar* channel_strings[] = {
  86         N_("stereo"),
  87         N_("mono"),
  88         0
  89 };
  90
  91 static const gchar* cue_file_types[] = {
  92         N_("None"),
  93         N_("CUE"),
  94         N_("TOC"),
  95         0
  96 };
  97
  98 ExportDialog::ExportDialog(PublicEditor& e)
  99         : ArdourDialog ("export dialog"),
 100           editor (e),
 101           format_table (9, 2),
 102           format_frame (_("Format")),
 103           cue_file_label (_("CD Marker File Type"), 1.0, 0.5),
 104           channel_count_label (_("Channels"), 1.0, 0.5),
 105           header_format_label (_("File Type"), 1.0, 0.5),
 106           bitdepth_format_label (_("Sample Format"), 1.0, 0.5),
 107           endian_format_label (_("Sample Endianness"), 1.0, 0.5),
 108           sample_rate_label (_("Sample Rate"), 1.0, 0.5),
 109           src_quality_label (_("Conversion Quality"), 1.0, 0.5),
 110           dither_type_label (_("Dither Type"), 1.0, 0.5),
 111           cuefile_only_checkbox (_("Export CD Marker File Only")),
 112           file_browse_button (_("Browse")),
 113           track_selector_button (_("Specific tracks ..."))
 114 {
 115         guint32 n;
 116         guint32 len;
 117         guint32 maxlen;
 118
 119         session = 0;
 120         track_and_master_selection_allowed = true;
 121         channel_count_selection_allowed = true;
 122         export_cd_markers_allowed = true;
 123
 124         WindowTitle title(Glib::get_application_name());
 125         title += _("Export");
 126
 127         set_title (title.get_string());
 128         set_wmclass (X_("ardour_export"), "Ardour");
 129         set_name ("ExportWindow");
 130         add_events (Gdk::KEY_PRESS_MASK|Gdk::KEY_RELEASE_MASK);
 131
 132         spec.running = false;
 133
 134         file_entry.set_name ("ExportFileNameEntry");
 135
 136         master_list = ListStore::create (exp_cols);
 137         master_selector.set_model (master_list);
 138
 139         master_selector.set_name ("ExportTrackSelector");
 140         master_selector.set_size_request (-1, 100);
 141         master_selector.append_column(_("Output"), exp_cols.output);
 142         master_selector.append_column_editable(_("Left"), exp_cols.left);
 143         master_selector.append_column_editable(_("Right"), exp_cols.right);
 144         master_selector.get_column(0)->set_min_width(100);
 145
 146         master_selector.get_column(1)->set_min_width(40);
 147         master_selector.get_column(1)->set_sizing(Gtk::TREE_VIEW_COLUMN_AUTOSIZE);
 148         master_selector.get_column(2)->set_min_width(40);
 149         master_selector.get_column(2)->set_sizing(Gtk::TREE_VIEW_COLUMN_AUTOSIZE);
 150         master_selector.get_selection()->set_mode (Gtk::SELECTION_NONE);
 151
 152         track_list = ListStore::create (exp_cols);
 153         track_selector.set_model (track_list);
 154
 155         track_selector.set_name ("ExportTrackSelector");
 156         track_selector.set_size_request (-1, 130);
 157         track_selector.append_column(_("Output"), exp_cols.output);
 158         track_selector.append_column_editable(_("Left"), exp_cols.left);
 159         track_selector.append_column_editable(_("Right"), exp_cols.right);
 160
 161         track_selector.get_column(0)->set_min_width(100);
 162         track_selector.get_column(1)->set_min_width(40);
 163         track_selector.get_column(1)->set_sizing(Gtk::TREE_VIEW_COLUMN_AUTOSIZE);
 164         track_selector.get_column(2)->set_min_width(40);
 165         track_selector.get_column(2)->set_sizing(Gtk::TREE_VIEW_COLUMN_AUTOSIZE);
 166         track_selector.get_selection()->set_mode (Gtk::SELECTION_NONE);
 167
 168         progress_bar.set_name ("ExportProgress");
 169
 170         format_frame.add (format_table);
 171         format_frame.set_name (FRAME_NAME);
 172
 173         track_scroll.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
 174         master_scroll.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
 175
 176         get_vbox()->pack_start (file_frame, false, false);
 177
 178         hpacker.set_spacing (5);
 179         hpacker.set_border_width (5);
 180         hpacker.pack_start (format_frame, false, false);
 181
 182         master_scroll.add (master_selector);
 183         track_scroll.add (track_selector);
 184
 185         master_scroll.set_size_request (220, 100);
 186         track_scroll.set_size_request (220, 100);
 187
 188         /* we may hide some of these later */
 189         track_vpacker.pack_start (master_scroll);
 190         track_vpacker.pack_start (track_scroll);
 191         track_vpacker.pack_start (track_selector_button, Gtk::PACK_EXPAND_PADDING);
 192
 193         hpacker.pack_start (track_vpacker);
 194
 195         get_vbox()->pack_start (hpacker);
 196
 197         track_selector_button.set_name ("EditorGTKButton");
 198         track_selector_button.signal_clicked().connect (mem_fun(*this, &ExportDialog::track_selector_button_click));
 199
 200         get_vbox()->pack_start (progress_bar, false, false);
 201
 202         Gtkmm2ext::set_size_request_to_display_given_text (file_entry, X_("Kg/quite/a/reasonable/size/for/files/i/think"), 5, 8);
 203
 204         file_hbox.set_spacing (5);
 205         file_hbox.set_border_width (5);
 206         file_hbox.pack_start (file_entry, true, true);
 207         file_hbox.pack_start (file_browse_button, false, false);
 208
 209         file_frame.add (file_hbox);
 210         file_frame.set_border_width (5);
 211         file_frame.set_name (FRAME_NAME);
 212
 213         /* pop_strings needs to be created on the stack because set_popdown_strings()
 214            takes a reference.
 215         */
 216
 217         vector<string> pop_strings = I18N (sample_rates);
 218         Gtkmm2ext::set_popdown_strings (sample_rate_combo, pop_strings);
 219         sample_rate_combo.set_active_text (pop_strings.front());
 220         pop_strings = I18N (src_quality);
 221         Gtkmm2ext::set_popdown_strings (src_quality_combo, pop_strings);
 222         src_quality_combo.set_active_text (pop_strings.front());
 223         pop_strings = I18N (dither_types);
 224         Gtkmm2ext::set_popdown_strings (dither_type_combo, pop_strings);
 225         dither_type_combo.set_active_text (pop_strings.front());
 226         pop_strings = I18N (channel_strings);
 227         Gtkmm2ext::set_popdown_strings (channel_count_combo, pop_strings);
 228         channel_count_combo.set_active_text (pop_strings.front());
 229         pop_strings = I18N ((const char **) sndfile_header_formats_strings);
 230         Gtkmm2ext::set_popdown_strings (header_format_combo, pop_strings);
 231         header_format_combo.set_active_text (pop_strings.front());
 232         pop_strings = I18N ((const char **) sndfile_bitdepth_formats_strings);
 233         Gtkmm2ext::set_popdown_strings (bitdepth_format_combo, pop_strings);
 234         bitdepth_format_combo.set_active_text (pop_strings.front());
 235         pop_strings = I18N ((const char **) sndfile_endian_formats_strings);
 236         Gtkmm2ext::set_popdown_strings (endian_format_combo, pop_strings);
 237         endian_format_combo.set_active_text (pop_strings.front());
 238         pop_strings = I18N (cue_file_types);
 239         Gtkmm2ext::set_popdown_strings (cue_file_combo, pop_strings);
 240         cue_file_combo.set_active_text (pop_strings.front());
 241
 242         /* this will re-sensitized as soon as a non RIFF/WAV
 243            header format is chosen.
 244         */
 245
 246         endian_format_combo.set_sensitive (false);
 247
 248         /* determine longest strings at runtime */
 249
 250         maxlen = 0;
 251         const char *longest = X_("gl"); /* translators: one ascender, one descender */
 252         string longest_str;
 253
 254         for (n = 0; n < SNDFILE_HEADER_FORMATS; ++n) {
 255                 if ((len = strlen (sndfile_header_formats_strings[n])) > maxlen) {
 256                         maxlen = len;
 257                         longest = sndfile_header_formats_strings[n];
 258                 }
 259         }
 260
 261         for (n = 0; n < SNDFILE_BITDEPTH_FORMATS; ++n) {
 262                 if ((len = strlen (sndfile_bitdepth_formats_strings[n])) > maxlen) {
 263                         maxlen = len;
 264                         longest = sndfile_bitdepth_formats_strings[n];
 265                 }
 266         }
 267
 268         for (n = 0; n < SNDFILE_ENDIAN_FORMATS; ++n) {
 269                 if ((len = strlen (sndfile_endian_formats_strings[n])) > maxlen) {
 270                         maxlen = len;
 271                         longest = sndfile_endian_formats_strings[n];
 272                 }
 273         }
 274
 275         longest_str = longest;
 276
 277         /* force ascender + descender */
 278
 279         longest_str[0] = 'g';
 280         longest_str[1] = 'l';
 281
 282         //Gtkmm2ext::set_size_request_to_display_given_text (header_format_combo, longest_str.c_str(), 5+FUDGE, 5);
 283
 284         // TRANSLATORS: "slereg" is "stereo" with ascender and descender substituted
 285         //Gtkmm2ext::set_size_request_to_display_given_text (channel_count_combo, _("slereg"), 5+FUDGE, 5);
 286
 287 /*      header_format_combo.set_focus_on_click (true);
 288         bitdepth_format_combo.set_focus_on_click (true);
 289         endian_format_combo.set_focus_on_click (true);
 290         channel_count_combo.set_focus_on_click (true);
 291         src_quality_combo.set_focus_on_click (true);
 292         dither_type_combo.set_focus_on_click (true);
 293         sample_rate_combo.set_focus_on_click (true);
 294         cue_file_combo.set_focus_on_click (true);
 295 */
 296         dither_type_label.set_name ("ExportFormatLabel");
 297         sample_rate_label.set_name ("ExportFormatLabel");
 298         src_quality_label.set_name ("ExportFormatLabel");
 299         channel_count_label.set_name ("ExportFormatLabel");
 300         header_format_label.set_name ("ExportFormatLabel");
 301         bitdepth_format_label.set_name ("ExportFormatLabel");
 302         endian_format_label.set_name ("ExportFormatLabel");
 303         cue_file_label.set_name ("ExportFormatLabel");
 304
 305         header_format_combo.set_name ("ExportFormatDisplay");
 306         bitdepth_format_combo.set_name ("ExportFormatDisplay");
 307         endian_format_combo.set_name ("ExportFormatDisplay");
 308         channel_count_combo.set_name ("ExportFormatDisplay");
 309         dither_type_combo.set_name ("ExportFormatDisplay");
 310         src_quality_combo.set_name ("ExportFormatDisplay");
 311         sample_rate_combo.set_name ("ExportFormatDisplay");
 312         cue_file_combo.set_name ("ExportFormatDisplay");
 313
 314         cuefile_only_checkbox.set_name ("ExportCheckbox");
 315
 316         format_table.set_homogeneous (false);
 317         format_table.set_border_width (5);
 318         format_table.set_col_spacings (5);
 319         format_table.set_row_spacings (5);
 320
 321         format_table.attach (channel_count_label, 0, 1, 0, 1);
 322         format_table.attach (channel_count_combo, 1, 2, 0, 1);
 323
 324         format_table.attach (header_format_label, 0, 1, 1, 2);
 325         format_table.attach (header_format_combo, 1, 2, 1, 2);
 326
 327         format_table.attach (bitdepth_format_label, 0, 1, 2, 3);
 328         format_table.attach (bitdepth_format_combo, 1, 2, 2, 3);
 329
 330         format_table.attach (endian_format_label, 0, 1, 3, 4);
 331         format_table.attach (endian_format_combo, 1, 2, 3, 4);
 332
 333         format_table.attach (sample_rate_label, 0, 1, 4, 5);
 334         format_table.attach (sample_rate_combo, 1, 2, 4, 5);
 335
 336         format_table.attach (src_quality_label, 0, 1, 5, 6);
 337         format_table.attach (src_quality_combo, 1, 2, 5, 6);
 338
 339         format_table.attach (dither_type_label, 0, 1, 6, 7);
 340         format_table.attach (dither_type_combo, 1, 2, 6, 7);
 341
 342         format_table.attach (cue_file_label, 0, 1, 7, 8);
 343         format_table.attach (cue_file_combo, 1, 2, 7, 8);
 344         format_table.attach (cuefile_only_checkbox, 0, 2, 8, 9);
 345
 346         file_entry.set_name ("ExportFileDisplay");
 347
 348         signal_delete_event().connect (mem_fun(*this, &ExportDialog::window_closed));
 349
 350         cancel_button = add_button (Stock::CANCEL, RESPONSE_CANCEL);
 351         cancel_button->signal_clicked().connect (mem_fun(*this, &ExportDialog::end_dialog));
 352         ok_button = add_button (_("Export"), RESPONSE_ACCEPT);
 353         ok_button->signal_clicked().connect (mem_fun(*this, &ExportDialog::do_export));
 354
 355         file_browse_button.set_name ("EditorGTKButton");
 356         file_browse_button.signal_clicked().connect (mem_fun(*this, &ExportDialog::browse));
 357
 358         channel_count_combo.signal_changed().connect (mem_fun(*this, &ExportDialog::channels_chosen));
 359         bitdepth_format_combo.signal_changed().connect (mem_fun(*this, &ExportDialog::bitdepth_chosen));
 360         header_format_combo.signal_changed().connect (mem_fun(*this, &ExportDialog::header_chosen));
 361         sample_rate_combo.signal_changed().connect (mem_fun(*this, &ExportDialog::sample_rate_chosen));
 362         cue_file_combo.signal_changed().connect (mem_fun(*this, &ExportDialog::cue_file_type_chosen));
 363 }
 364
 365 ExportDialog::~ExportDialog()
 366 {
 367 }
 368
 369 void
 370 ExportDialog::do_not_allow_track_and_master_selection()
 371 {
 372         track_and_master_selection_allowed = false;
 373         track_vpacker.set_no_show_all();
 374 }
 375
 376 void
 377 ExportDialog::do_not_allow_channel_count_selection()
 378 {
 379         channel_count_selection_allowed = false;
 380         channel_count_combo.set_no_show_all();
 381         channel_count_label.set_no_show_all();
 382 }
 383
 384 void
 385 ExportDialog::do_not_allow_export_cd_markers()
 386 {
 387         export_cd_markers_allowed = false;
 388         cue_file_label.set_no_show_all();
 389         cue_file_combo.set_no_show_all();
 390         cuefile_only_checkbox.set_no_show_all();
 391 }
 392
 393 void
 394 ExportDialog::connect_to_session (Session *s)
 395 {
 396         session = s;
 397         session->GoingAway.connect (mem_fun(*this, &Window::hide_all));
 398
 399         switch (session->frame_rate()) {
 400         case 22050:
 401                 sample_rate_combo.set_active_text (_("22.05kHz"));
 402                 break;
 403         case 44100:
 404                 sample_rate_combo.set_active_text (_("44.1kHz"));
 405                 break;
 406         case 48000:
 407                 sample_rate_combo.set_active_text (_("48kHz"));
 408                 break;
 409         case 88200:
 410                 sample_rate_combo.set_active_text (_("88.2kHz"));
 411                 break;
 412         case 96000:
 413                 sample_rate_combo.set_active_text (_("96kHz"));
 414                 break;
 415         case 192000:
 416                 sample_rate_combo.set_active_text (_("192kHz"));
 417                 break;
 418         default:
 419                 sample_rate_combo.set_active_text (_("44.1kHz"));
 420                 break;
 421         }
 422
 423         src_quality_combo.set_sensitive (false);
 424
 425         set_state();
 426 }
 427
 428 void
 429 ExportDialog::set_state()
 430 {
 431         XMLNode* node = session->instant_xml(X_("ExportDialog"), session->path());
 432         XMLProperty* prop;
 433
 434         if (node) {
 435
 436                 if ((prop = node->property (X_("sample_rate"))) != 0) {
 437                         sample_rate_combo.set_active_text(prop->value());
 438                 }
 439                 if ((prop = node->property (X_("src_quality"))) != 0) {
 440                         src_quality_combo.set_active_text(prop->value());
 441                 }
 442                 if ((prop = node->property (X_("dither_type"))) != 0) {
 443                         dither_type_combo.set_active_text(prop->value());
 444                 }
 445                 if ((prop = node->property (X_("channel_count"))) != 0) {
 446                         channel_count_combo.set_active_text(prop->value());
 447                 }
 448                 if ((prop = node->property (X_("header_format"))) != 0) {
 449                         header_format_combo.set_active_text(prop->value());
 450                 }
 451                 if ((prop = node->property (X_("bitdepth_format"))) != 0) {
 452                         bitdepth_format_combo.set_active_text(prop->value());
 453                 }
 454                 if ((prop = node->property (X_("endian_format"))) != 0) {
 455                         endian_format_combo.set_active_text(prop->value());
 456                 }
 457                 if ((prop = node->property (X_("filename"))) != 0) {
 458                         file_entry.set_text(prop->value());
 459                 }
 460                 if ((prop = node->property (X_("cue_file_type"))) != 0) {
 461                         cue_file_combo.set_active_text(prop->value());
 462                 }
 463         }
 464
 465         header_chosen ();
 466         bitdepth_chosen();
 467         channels_chosen();
 468         sample_rate_chosen();
 469
 470         if (session->master_out()) {
 471                 track_scroll.hide ();
 472         } else {
 473                 master_scroll.hide ();
 474                 track_selector_button.hide ();
 475         }
 476
 477         if (!node) {
 478                 return;
 479         }
 480
 481         if (session->master_out()) {
 482                 XMLNode* master = find_named_node(*node, (X_("Master")));
 483                 int nchns;
 484
 485                 if (!master) {
 486
 487                         /* default is to use all */
 488                         if (channel_count_combo.get_active_text() == _("mono")) {
 489                                 nchns = 1;
 490                         } else {
 491                                 nchns = 2;
 492                         }
 493
 494                         TreeModel::Children rows = master_selector.get_model()->children();
 495                         for (uint32_t r = 0; r < session->master_out()->n_outputs(); ++r) {
 496                                 if (nchns == 2) {
 497                                         if (r % 2) {
 498                                                 rows[r][exp_cols.right] = true;
 499                                         } else {
 500                                                 rows[r][exp_cols.left] = true;
 501                                         }
 502                                 } else {
 503                                         rows[r][exp_cols.left] = true;
 504                                 }
 505                         }
 506
 507                 } else {
 508                         /* XXX use XML state */
 509                 }
 510         }
 511
 512         XMLNode* tracks = find_named_node(*node, (X_("Tracks")));
 513         if (!tracks) {
 514                 return;
 515         }
 516
 517         XMLNodeList track_list = tracks->children(X_("Track"));
 518         TreeModel::Children rows = track_selector.get_model()->children();
 519         TreeModel::Children::iterator ri = rows.begin();
 520         TreeModel::Row row;
 521
 522         for (XMLNodeIterator it = track_list.begin(); it != track_list.end(); ++it, ++ri) {
 523                 if (ri == rows.end()){
 524                         break;
 525                 }
 526
 527                 XMLNode* track = *it;
 528                 row = *ri;
 529
 530                 if ((prop = track->property(X_("channel1"))) != 0) {
 531                         if (prop->value() == X_("on")) {
 532                                 row[exp_cols.left] = true;
 533                         } else {
 534                                 row[exp_cols.left] = false;
 535                         }
 536                 }
 537
 538                 if ((prop = track->property(X_("channel2"))) != 0) {
 539                         if (prop->value() == X_("on")) {
 540                                 row[exp_cols.right] = true;
 541                         } else {
 542                                 row[exp_cols.right] = false;
 543                         }
 544                 }
 545         }
 546 }
 547
 548 void
 549 ExportDialog::save_state()
 550 {
 551         if (!session) {
 552                 return;
 553         }
 554
 555         XMLNode* node = new XMLNode(X_("ExportDialog"));
 556
 557         node->add_property(X_("sample_rate"), sample_rate_combo.get_active_text());
 558         node->add_property(X_("src_quality"), src_quality_combo.get_active_text());
 559         node->add_property(X_("dither_type"), dither_type_combo.get_active_text());
 560         node->add_property(X_("channel_count"), channel_count_combo.get_active_text());
 561         node->add_property(X_("header_format"), header_format_combo.get_active_text());
 562         node->add_property(X_("bitdepth_format"), bitdepth_format_combo.get_active_text());
 563         node->add_property(X_("endian_format"), endian_format_combo.get_active_text());
 564         node->add_property(X_("filename"), file_entry.get_text());
 565         node->add_property(X_("cue_file_type"), cue_file_combo.get_active_text());
 566
 567         XMLNode* tracks = new XMLNode(X_("Tracks"));
 568
 569         TreeModel::Children rows = track_selector.get_model()->children();
 570         TreeModel::Row row;
 571         for (TreeModel::Children::iterator ri = rows.begin(); ri != rows.end(); ++ri) {
 572                 XMLNode* track = new XMLNode(X_("Track"));
 573
 574                 row = *ri;
 575                 track->add_property(X_("channel1"), row[exp_cols.left] ? X_("on") : X_("off"));
 576                 track->add_property(X_("channel2"), row[exp_cols.right] ? X_("on") : X_("off"));
 577
 578                 tracks->add_child_nocopy(*track);
 579         }
 580         node->add_child_nocopy(*tracks);
 581
 582         session->add_instant_xml(*node, session->path());
 583 }
 584
 585 void
 586 ExportDialog::set_range (nframes_t start, nframes_t end)
 587 {
 588         spec.start_frame = start;
 589         spec.end_frame = end;
 590 }
 591
 592 gint
 593 ExportDialog::progress_timeout ()
 594 {
 595         progress_bar.set_fraction (spec.progress);
 596         return TRUE;
 597 }
 598
 599 void
 600 frames_to_cd_frames_string (char* buf, nframes_t when, nframes_t fr)
 601 {
 602
 603   long unsigned int remainder;
 604   int mins, secs, frames;
 605
 606         mins = when / (60 * fr);
 607         remainder = when - (mins * 60 * fr);
 608         secs = remainder / fr;
 609         remainder -= secs * fr;
 610         frames = remainder / (fr / 75);
 611         sprintf (buf, " %02d:%02d:%02d", mins, secs, frames);
 612
 613 }
 614
 615 struct LocationSortByStart {
 616     bool operator() (Location *a, Location *b) {
 617             return a->start() < b->start();
 618     }
 619 };
 620
 621 void
 622 ExportDialog::export_toc_file (Locations::LocationList& locations, const string& path)
 623 {
 624         if(!export_cd_markers_allowed){
 625                 return;
 626         }
 627
 628     string filepath = path + ".toc";
 629         ofstream out (filepath.c_str());
 630         long unsigned int last_end_time = spec.start_frame, last_start_time = spec.start_frame;
 631         int numtracks = 0;
 632         gchar buf[18];
 633
 634         if (!out) {
 635                 error << string_compose(_("Editor: cannot open \"%1\" as export file for CD toc file"), filepath) << endmsg;
 636                 return;
 637         }
 638         out << "CD_DA" << endl;
 639         out << "CD_TEXT {" << endl << "  LANGUAGE_MAP {" << endl << "    0 : EN" << endl << "  }" << endl;
 640         out << "  LANGUAGE 0 {" << endl << "    TITLE \"" << session->name() << "\"" << endl << "  }" << endl << "}" << endl;
 641
 642         Locations::LocationList::iterator i;
 643         Locations::LocationList temp;
 644
 645         for (i = locations.begin(); i != locations.end(); ++i) {
 646           if ((*i)->start() >= spec.start_frame && (*i)->end() <= spec.end_frame && (*i)->is_cd_marker() && !(*i)->is_end()) {
 647             temp.push_back (*i);
 648             if (!(*i)->is_mark()) {
 649               numtracks ++;
 650             }
 651           }
 652         }
 653
 654         if (numtracks == 0 ) {
 655                     /* the user supplied no track markers.
 656                        we now treat the session as one track.*/
 657
 658                     out << endl << "TRACK AUDIO" << endl;
 659
 660                     out << "COPY" << endl;
 661
 662                     out << "NO PRE_EMPHASIS" << endl;
 663
 664                     /* XXX add session properties for catalog etc.
 665                        (so far only the session name is used) */
 666
 667                     out << "CD_TEXT {" << endl << "  LANGUAGE 0 {" << endl << "     TITLE \"" << session->name() << "\"" << endl;
 668                     out << "  }" << endl << "}" << endl;
 669
 670                     out << "FILE \"" << path << "\" ";
 671                     out << "00:00:00 " ;
 672                     frames_to_cd_frames_string (buf, spec.end_frame - spec.start_frame, session->frame_rate());
 673                     out << buf << endl;
 674                     out << "START 00:00:00" << endl;
 675
 676                     last_start_time = spec.start_frame;
 677                     last_end_time = spec.end_frame;
 678         }
 679
 680         if (temp.size()) {
 681                 LocationSortByStart cmp;
 682                 temp.sort (cmp);
 683
 684                 for (i = temp.begin(); i != temp.end(); ++i) {
 685
 686                       if (!(*i)->is_mark()) {
 687                         /*this is a track */
 688                         out << endl << "TRACK AUDIO" << endl;
 689
 690                         if ((*i)->cd_info.find("scms") != (*i)->cd_info.end())  {
 691                           out << "NO ";
 692                         }
 693                         out << "COPY" << endl;
 694
 695                         if ((*i)->cd_info.find("preemph") != (*i)->cd_info.end())  {
 696                           out << "PRE_EMPHASIS" << endl;
 697                         } else {
 698                           out << "NO PRE_EMPHASIS" << endl;
 699                         }
 700
 701                         if ((*i)->cd_info.find("isrc") != (*i)->cd_info.end())  {
 702                           out << "ISRC \"" << (*i)->cd_info["isrc"] << "\"" << endl;
 703                         }
 704
 705                         out << "CD_TEXT {" << endl << "  LANGUAGE 0 {" << endl << "     TITLE \"" << (*i)->name() << "\"" << endl;
 706                         if ((*i)->cd_info.find("performer") != (*i)->cd_info.end()) {
 707                           out << "     PERFORMER \"" << (*i)->cd_info["performer"]  << "\"" << endl;
 708                         }
 709                         if ((*i)->cd_info.find("string_composer") != (*i)->cd_info.end()) {
 710                           out  << "     COMPOSER \"" << (*i)->cd_info["string_composer"] << "\"" << endl;
 711                         }
 712
 713                         if ((*i)->cd_info.find("isrc") != (*i)->cd_info.end()) {
 714                           out  << "     ISRC \"";
 715                           out << (*i)->cd_info["isrc"].substr(0,2) << "-";
 716                           out << (*i)->cd_info["isrc"].substr(2,3) << "-";
 717                           out << (*i)->cd_info["isrc"].substr(5,2) << "-";
 718                           out << (*i)->cd_info["isrc"].substr(7,5) << "\"" << endl;
 719                         }
 720
 721                         out << "  }" << endl << "}" << endl;
 722
 723                         frames_to_cd_frames_string (buf, last_end_time - spec.start_frame, session->frame_rate());
 724                         out << "FILE \"" << path << "\" " << buf;
 725
 726                         frames_to_cd_frames_string (buf, (*i)->end() - last_end_time, session->frame_rate());
 727                         out << buf << endl;
 728
 729                         frames_to_cd_frames_string (buf, (*i)->start() - last_end_time, session->frame_rate());
 730                         out << "START" << buf << endl;
 731
 732                         last_start_time = (*i)->start();
 733                         last_end_time = (*i)->end();
 734
 735
 736                       } else  if ((*i)->start() < last_end_time) {
 737                         /* this is an index within a track */
 738
 739                         frames_to_cd_frames_string (buf, (*i)->start() - last_start_time, session->frame_rate());
 740                         out << "INDEX" << buf << endl;
 741                       }
 742                 }
 743         }
 744
 745 }
 746
 747 void
 748 ExportDialog::export_cue_file (Locations::LocationList& locations, const string& path)
 749 {
 750         if(!export_cd_markers_allowed){
 751                 return;
 752         }
 753
 754     string filepath = path + ".cue";
 755         ofstream out (filepath.c_str());
 756         gchar buf[18];
 757         long unsigned int last_track_end = spec.start_frame;
 758         int numtracks = 0, tracknum = 0, indexnum = 0;
 759
 760         if (!out) {
 761                 error << string_compose(_("Editor: cannot open \"%1\" as export file for CD cue file"), filepath) << endmsg;
 762                 return;
 763         }
 764
 765         Locations::LocationList::iterator i;
 766         Locations::LocationList temp;
 767
 768         for (i = locations.begin(); i != locations.end(); ++i) {
 769                 if ((*i)->start() >= spec.start_frame && (*i)->end() <= spec.end_frame && (*i)->is_cd_marker() && !(*i)->is_end()) {
 770                         temp.push_back (*i);
 771                         if (!(*i)->is_mark()) {
 772                                 numtracks++;
 773                         }
 774                 }
 775         }
 776
 777         out << "REM Cue file generated by Ardour" << endl;
 778         out << "TITLE \"" << session->name() << "\"" << endl;
 779
 780         if ((header_format_combo.get_active_text() == N_("WAV"))) {
 781                   out << "FILE " << path  << " WAVE" << endl;
 782         } else {
 783                   out << "FILE " << path  << ' ' << (header_format_combo.get_active_text()) << endl;
 784         }
 785
 786         if (numtracks == 0) {
 787                     /* the user has supplied no track markers.
 788                        the entire export is treated as one track.
 789                     */
 790
 791                   numtracks++;
 792                   tracknum++;
 793                   indexnum = 0;
 794                   out << endl << "TRACK " << tracknum << " AUDIO" << endl;
 795                   out << "FLAGS " ;
 796
 797                   out << "DCP " << endl;
 798
 799                   /* use the session name*/
 800
 801                   if (session->name() != "") {
 802                     out << "TITLE \"" << session->name() << "\"" << endl;
 803                   }
 804
 805                   /* no pregap in this case */
 806
 807                   out << "INDEX 00 00:00:00" << endl;
 808                   indexnum++;
 809                   out << "INDEX 01 00:00:00" << endl;
 810                   indexnum++;
 811                   last_track_end = spec.end_frame;
 812         }
 813
 814         if (temp.size()) {
 815                 LocationSortByStart cmp;
 816                 temp.sort (cmp);
 817
 818                 for ( i = temp.begin(); i != temp.end(); ++i) {
 819
 820                     if (!(*i)->is_mark() && ((*i)->start() >= last_track_end)) {
 821                       /* this is a track and it doesn't start inside another one*/
 822
 823                       tracknum++;
 824                       indexnum = 0;
 825                       out << endl << "TRACK " << tracknum << " AUDIO" << endl;
 826                       out << "FLAGS " ;
 827
 828                       if ((*i)->cd_info.find("scms") != (*i)->cd_info.end())  {
 829                         out << "SCMS ";
 830                       } else {
 831                         out << "DCP ";
 832                       }
 833
 834                       if ((*i)->cd_info.find("preemph") != (*i)->cd_info.end())  {
 835                         out << "PRE";
 836                       }
 837                       out << endl;
 838
 839                       if ((*i)->cd_info.find("isrc") != (*i)->cd_info.end())  {
 840                         out << "ISRC " << (*i)->cd_info["isrc"] << endl;
 841
 842                       }
 843                       if ((*i)->name() != "") {
 844                         out << "TITLE \"" << (*i)->name() << "\"" << endl;
 845                       }
 846
 847                       if ((*i)->cd_info.find("performer") != (*i)->cd_info.end()) {
 848                         out << "PERFORMER \"" <<  (*i)->cd_info["performer"] << "\"" << endl;
 849                       }
 850
 851                       if ((*i)->cd_info.find("string_composer") != (*i)->cd_info.end()) {
 852                         out << "SONGWRITER \"" << (*i)->cd_info["string_composer"]  << "\"" << endl;
 853                       }
 854                         snprintf (buf, sizeof(buf), "INDEX %02d", indexnum);
 855                         out << buf;
 856                         frames_to_cd_frames_string (buf, last_track_end - spec.start_frame, session->frame_rate());
 857                         out << buf << endl;
 858                         indexnum++;
 859                         last_track_end = (*i)->end();
 860                     }
 861                     if ((tracknum > 0) && ((*i)->start() < last_track_end)) {
 862                       /*this is an index and it lies within a track*/
 863                       snprintf (buf, sizeof(buf), "INDEX %02d", indexnum);
 864                       out << buf;
 865                       frames_to_cd_frames_string (buf,(*i)->start() - spec.start_frame, session->frame_rate());
 866                       out << buf << endl;
 867                       indexnum++;
 868                     }
 869                 }
 870         }
 871
 872 }
 873
 874 void
 875 ExportDialog::do_export_cd_markers (const string& path,const string& cuefile_type)
 876 {
 877         if (cuefile_type == _("TOC")) {
 878                 session->locations()->apply (*this, &ExportDialog::export_toc_file, path);
 879         } else {
 880                 session->locations()->apply (*this, &ExportDialog::export_cue_file, path);
 881         }
 882 }
 883
 884
 885 void
 886 ExportDialog::do_export ()
 887 {
 888         string filepath = file_entry.get_text();
 889
 890         if(!is_filepath_valid(filepath)){
 891                 return;
 892         }
 893
 894         if (export_cd_markers_allowed) {
 895                 if (cue_file_combo.get_active_text () != _("None")) {
 896                         do_export_cd_markers (file_entry.get_text(), cue_file_combo.get_active_text ());
 897                 }
 898
 899                 if (cuefile_only_checkbox.get_active()) {
 900                         end_dialog ();
 901                         return;
 902                 }
 903         }
 904
 905         ok_button->set_sensitive(false);
 906         save_state();
 907
 908         set_modal (true);
 909
 910         // read user input into spec
 911         initSpec(filepath);
 912
 913         progress_connection = Glib::signal_timeout().connect (mem_fun(*this, &ExportDialog::progress_timeout), 100);
 914         cancel_label.set_text (_("Stop Export"));
 915
 916         export_audio_data();
 917
 918         progress_connection.disconnect ();
 919         end_dialog ();
 920 }
 921
 922 void
 923 ExportDialog::end_dialog ()
 924 {
 925         if (spec.running) {
 926                 spec.stop = true;
 927
 928                 while (spec.running) {
 929                         if (gtk_events_pending()) {
 930                                 gtk_main_iteration ();
 931                         } else {
 932                                 usleep (10000);
 933                         }
 934                 }
 935         }
 936
 937         session->finalize_audio_export ();
 938
 939         hide_all ();
 940
 941         set_modal (false);
 942         ok_button->set_sensitive(true);
 943 }
 944
 945 void
 946 ExportDialog::start_export ()
 947 {
 948         if (session == 0) {
 949                 return;
 950         }
 951
 952         /* If the filename hasn't been set before, use the
 953            current session's export directory as a default
 954            location for the export.
 955         */
 956
 957         if (file_entry.get_text().length() == 0) {
 958                 string dir = session->export_dir();
 959                 string::size_type last_slash;
 960
 961                 if ((last_slash = dir.find_last_of ('/')) != string::npos && last_slash != 0) {
 962                         dir = dir.substr (0, last_slash+1);
 963                 }
 964
 965                 if (!wants_dir()) {
 966                         dir = dir + "export.wav";
 967                 }
 968
 969                 file_entry.set_text (dir);
 970         }
 971
 972         progress_bar.set_fraction (0);
 973         cancel_label.set_text (_("Cancel"));
 974
 975         show_all ();
 976
 977         if (session->master_out()) {
 978                 track_scroll.hide ();
 979         } else {
 980                 master_scroll.hide ();
 981                 track_selector_button.hide ();
 982         }
 983 }
 984
 985 void
 986 ExportDialog::header_chosen ()
 987 {
 988         if (sndfile_header_format_from_string (header_format_combo.get_active_text ()) == SF_FORMAT_WAV) {
 989                 endian_format_combo.set_sensitive (false);
 990         } else {
 991                 endian_format_combo.set_sensitive (true);
 992         }
 993 }
 994
 995 void
 996 ExportDialog::bitdepth_chosen ()
 997 {
 998         int format = sndfile_bitdepth_format_from_string (bitdepth_format_combo.get_active_text ());
 999         switch (format) {
1000         case SF_FORMAT_PCM_24:
1001         case SF_FORMAT_PCM_32:
1002         case SF_FORMAT_FLOAT:
1003                 dither_type_combo.set_sensitive (false);
1004                 break;
1005
1006         default:
1007                 dither_type_combo.set_sensitive (true);
1008                 break;
1009         }
1010 }
1011
1012 void
1013 ExportDialog::cue_file_type_chosen ()
1014 {
1015         if (cue_file_combo.get_active_text () != "None") {
1016                 cuefile_only_checkbox.set_sensitive (true);
1017         } else {
1018                 cuefile_only_checkbox.set_active (false);
1019                 cuefile_only_checkbox.set_sensitive (false);
1020         }
1021 }
1022
1023 void
1024 ExportDialog::sample_rate_chosen ()
1025 {
1026         string sr_str = sample_rate_combo.get_active_text();
1027         nframes_t rate;
1028
1029         if (sr_str == N_("22.05kHz")) {
1030                 rate = 22050;
1031         } else if (sr_str == _("44.1kHz")) {
1032                 rate = 44100;
1033         } else if (sr_str == _("48kHz")) {
1034                 rate = 48000;
1035         } else if (sr_str == _("88.2kHz")) {
1036                 rate = 88200;
1037         } else if (sr_str == _("96kHz")) {
1038                 rate = 96000;
1039         } else if (sr_str == _("192kHz")) {
1040                 rate = 192000;
1041         } else {
1042                 rate = session->frame_rate();
1043         }
1044
1045         if (rate != session->frame_rate()) {
1046                 src_quality_combo.set_sensitive (true);
1047         } else {
1048                 src_quality_combo.set_sensitive (false);
1049         }
1050 }
1051
1052 void
1053 ExportDialog::channels_chosen ()
1054 {
1055         bool mono;
1056
1057         mono = (channel_count_combo.get_active_text() == _("mono"));
1058
1059         if (mono) {
1060                 track_selector.get_column(2)->set_visible(false);
1061                 track_selector.get_column(1)->set_title(_("Export"));
1062
1063                 if (session->master_out()) {
1064                         master_selector.get_column(2)->set_visible(false);
1065                         master_selector.get_column(1)->set_title(_("Export"));
1066                 }
1067
1068         } else {
1069                 track_selector.get_column(2)->set_visible(true);
1070                 track_selector.get_column(1)->set_title(_("Left"));
1071
1072                 if (session->master_out()) {
1073                         master_selector.get_column(2)->set_visible(true);
1074                         master_selector.get_column(1)->set_title(_("Left"));
1075                 }
1076         }
1077
1078         fill_lists();
1079 }
1080
1081 void
1082 ExportDialog::fill_lists ()
1083 {
1084         track_list->clear();
1085         master_list->clear();
1086
1087         boost::shared_ptr<Session::RouteList> routes = session->get_routes ();
1088
1089         for (Session::RouteList::iterator ri = routes->begin(); ri != routes->end(); ++ri) {
1090
1091                 boost::shared_ptr<Route> route = (*ri);
1092
1093                 if (route->hidden()) {
1094                         continue;
1095                 }
1096
1097                 for (uint32_t i=0; i < route->n_outputs(); ++i) {
1098                         string name;
1099                         if (route->n_outputs() == 1) {
1100                                 name = route->name();
1101                         } else {
1102                                 name = string_compose("%1: out-%2", route->name(), i+1);
1103                         }
1104
1105                         if (route == session->master_out()) {
1106                                 TreeModel::iterator iter = master_list->append();
1107                                 TreeModel::Row row = *iter;
1108                                 row[exp_cols.output] = name;
1109                                 row[exp_cols.left] = false;
1110                                 row[exp_cols.right] = false;
1111                                 row[exp_cols.port] = route->output (i);
1112                         } else {
1113                                 TreeModel::iterator iter = track_list->append();
1114                                 TreeModel::Row row = *iter;
1115                                 row[exp_cols.output] = name;
1116                                 row[exp_cols.left] = false;
1117                                 row[exp_cols.right] = false;
1118                                 row[exp_cols.port] = route->output (i);
1119                         }
1120                 }
1121         }
1122 }
1123
1124
1125 bool
1126 ExportDialog::is_filepath_valid(string &filepath)
1127 {
1128         // sanity check file name first
1129
1130         struct stat statbuf;
1131
1132         if (filepath.empty()) {
1133                 string txt = _("Please enter a valid filename.");
1134                 MessageDialog msg (*this, txt, false, MESSAGE_ERROR, BUTTONS_OK, true);
1135                 msg.run();
1136                 return false;
1137         }
1138
1139         // check if file exists already and warn
1140
1141         if (stat (filepath.c_str(), &statbuf) == 0) {
1142                 if (S_ISDIR (statbuf.st_mode)) {
1143                         string txt = _("Please specify a complete filename for the audio file.");
1144                         MessageDialog msg (*this, txt, false, MESSAGE_ERROR, BUTTONS_OK, true);
1145                         msg.run();
1146                         return false;
1147                 }
1148                 else {
1149                         string txt = _("File already exists, do you want to overwrite it?");
1150                         MessageDialog msg (*this, txt, false, MESSAGE_QUESTION, BUTTONS_YES_NO, true);
1151                         if ((ResponseType) msg.run() == Gtk::RESPONSE_NO) {
1152                                 return false;
1153                         }
1154                 }
1155         }
1156
1157         // directory needs to exist and be writable
1158
1159         string dirpath = Glib::path_get_dirname (filepath);
1160         if (::access (dirpath.c_str(), W_OK) != 0) {
1161                 string txt = _("Cannot write file in: ") + dirpath;
1162                 MessageDialog msg (*this, txt, false, MESSAGE_ERROR, BUTTONS_OK, true);
1163                 msg.run();
1164                 return false;
1165         }
1166
1167         return true;
1168 }
1169
1170 void
1171 ExportDialog::initSpec(string &filepath)
1172 {
1173         spec.path = filepath;
1174         spec.progress = 0;
1175         spec.running = true;
1176         spec.stop = false;
1177         spec.port_map.clear();
1178
1179         if (channel_count_combo.get_active_text() == _("mono")) {
1180                 spec.channels = 1;
1181         } else {
1182                 spec.channels = 2;
1183         }
1184
1185         spec.format = 0;
1186
1187         spec.format |= sndfile_header_format_from_string (header_format_combo.get_active_text ());
1188
1189         if ((spec.format & SF_FORMAT_WAV) == 0) {
1190                 /* RIFF/WAV specifies endianess */
1191                 spec.format |= sndfile_endian_format_from_string (endian_format_combo.get_active_text ());
1192         }
1193
1194         spec.format |= sndfile_bitdepth_format_from_string (bitdepth_format_combo.get_active_text ());
1195
1196         string sr_str = sample_rate_combo.get_active_text();
1197         if (sr_str == N_("22.05kHz")) {
1198                 spec.sample_rate = 22050;
1199         } else if (sr_str == _("44.1kHz")) {
1200                 spec.sample_rate = 44100;
1201         } else if (sr_str == _("48kHz")) {
1202                 spec.sample_rate = 48000;
1203         } else if (sr_str == _("88.2kHz")) {
1204                 spec.sample_rate = 88200;
1205         } else if (sr_str == _("96kHz")) {
1206                 spec.sample_rate = 96000;
1207         } else if (sr_str == _("192kHz")) {
1208                 spec.sample_rate = 192000;
1209         } else {
1210                 spec.sample_rate = session->frame_rate();
1211         }
1212
1213         string src_str = src_quality_combo.get_active_text();
1214         if (src_str == _("fastest")) {
1215                 spec.src_quality = SRC_ZERO_ORDER_HOLD;
1216         } else if (src_str == _("linear")) {
1217                 spec.src_quality = SRC_LINEAR;
1218         } else if (src_str == _("better")) {
1219                 spec.src_quality = SRC_SINC_FASTEST;
1220         } else if (src_str == _("intermediate")) {
1221                 spec.src_quality = SRC_SINC_MEDIUM_QUALITY;
1222         } else {
1223                 spec.src_quality = SRC_SINC_BEST_QUALITY;
1224         }
1225
1226         string dither_str = dither_type_combo.get_active_text();
1227         if (dither_str == _("None")) {
1228                 spec.dither_type = GDitherNone;
1229         } else if (dither_str == _("Rectangular")) {
1230                 spec.dither_type = GDitherRect;
1231         } else if (dither_str == _("Triangular")) {
1232                 spec.dither_type = GDitherTri;
1233         } else {
1234                 spec.dither_type = GDitherShaped;
1235         }
1236
1237         write_track_and_master_selection_to_spec();
1238 }
1239
1240
1241 void
1242 ExportDialog::write_track_and_master_selection_to_spec()
1243 {
1244         if(!track_and_master_selection_allowed){
1245                 return;
1246         }
1247
1248         uint32_t chan=0;
1249         Port *last_port = 0;
1250
1251         TreeModel::Children rows = master_selector.get_model()->children();
1252         TreeModel::Children::iterator ri;
1253         TreeModel::Row row;
1254         for (ri = rows.begin(); ri != rows.end(); ++ri) {
1255                 row = *ri;
1256                 Port* port = row[exp_cols.port];
1257
1258                 if (last_port != port) {
1259                         chan = 0;
1260                 }
1261
1262                 if (row[exp_cols.left]) {
1263                         spec.port_map[0].push_back (std::pair<Port*,uint32_t>(port, chan));
1264                 }
1265
1266                 if (spec.channels == 2) {
1267                         if (row[exp_cols.right]) {
1268                                 spec.port_map[1].push_back (std::pair<Port*,uint32_t>(port, chan));
1269                         }
1270                 }
1271         }
1272
1273         chan = 0;
1274         rows = track_selector.get_model()->children();
1275
1276         for (ri = rows.begin(); ri != rows.end(); ++ri) {
1277                 row = *ri;
1278
1279                 Port* port = row[exp_cols.port];
1280
1281                 if (last_port != port) {
1282                         chan = 0;
1283                 }
1284
1285                 if (row[exp_cols.left]) {
1286                         spec.port_map[0].push_back (std::pair<Port*,uint32_t>(port, chan));
1287                 }
1288
1289                 if (spec.channels == 2) {
1290                         if (row[exp_cols.right]) {
1291                                 spec.port_map[1].push_back (std::pair<Port*,uint32_t>(port, chan));
1292                         }
1293
1294                 }
1295
1296                 last_port = port;
1297                 ++chan;
1298         }
1299 }
1300
1301
1302 gint
1303 ExportDialog::window_closed (GdkEventAny *ignored)
1304 {
1305         end_dialog ();
1306         return TRUE;
1307 }
1308
1309 void
1310 ExportDialog::browse ()
1311 {
1312         FileChooserDialog dialog("Export to file", browse_action());
1313         dialog.set_transient_for(*this);
1314         dialog.set_filename (file_entry.get_text());
1315
1316         dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
1317         dialog.add_button(Gtk::Stock::OK, Gtk::RESPONSE_OK);
1318
1319         int result = dialog.run();
1320
1321         if (result == Gtk::RESPONSE_OK) {
1322                 string filename = dialog.get_filename();
1323
1324                 if (filename.length()) {
1325                         file_entry.set_text (filename);
1326                 }
1327         }
1328 }
1329
1330 void
1331 ExportDialog::track_selector_button_click ()
1332 {
1333         if (track_scroll.is_visible ()) {
1334                 track_scroll.hide ();
1335         } else {
1336                 track_scroll.show_all ();
1337         }
1338 }