src/wx/film_editor.cc

   1 /*
   2     Copyright (C) 2012 Carl Hetherington <cth@carlh.net>
   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 /** @file src/film_editor.cc
  21  *  @brief A wx widget to edit a film's metadata, and perform various functions.
  22  */
  23
  24 #include <iostream>
  25 #include <iomanip>
  26 #include <wx/wx.h>
  27 #include <wx/notebook.h>
  28 #include <boost/thread.hpp>
  29 #include <boost/filesystem.hpp>
  30 #include <boost/lexical_cast.hpp>
  31 #include "lib/format.h"
  32 #include "lib/film.h"
  33 #include "lib/transcode_job.h"
  34 #include "lib/exceptions.h"
  35 #include "lib/ab_transcode_job.h"
  36 #include "lib/job_manager.h"
  37 #include "lib/filter.h"
  38 #include "lib/config.h"
  39 #include "lib/ffmpeg_decoder.h"
  40 #include "lib/external_audio_decoder.h"
  41 #include "filter_dialog.h"
  42 #include "wx_util.h"
  43 #include "film_editor.h"
  44 #include "gain_calculator_dialog.h"
  45 #include "sound_processor.h"
  46 #include "dci_metadata_dialog.h"
  47 #include "scaler.h"
  48 #include "audio_dialog.h"
  49
  50 using std::string;
  51 using std::cout;
  52 using std::stringstream;
  53 using std::pair;
  54 using std::fixed;
  55 using std::setprecision;
  56 using std::list;
  57 using std::vector;
  58 using boost::shared_ptr;
  59 using boost::dynamic_pointer_cast;
  60
  61 /** @param f Film to edit */
  62 FilmEditor::FilmEditor (shared_ptr<Film> f, wxWindow* parent)
  63         : wxPanel (parent)
  64         , _film (f)
  65         , _generally_sensitive (true)
  66         , _audio_dialog (0)
  67 {
  68         wxBoxSizer* s = new wxBoxSizer (wxVERTICAL);
  69         SetSizer (s);
  70         _notebook = new wxNotebook (this, wxID_ANY);
  71         s->Add (_notebook, 1);
  72
  73         make_film_panel ();
  74         _notebook->AddPage (_film_panel, _("Film"), true);
  75         make_video_panel ();
  76         _notebook->AddPage (_video_panel, _("Video"), false);
  77         make_audio_panel ();
  78         _notebook->AddPage (_audio_panel, _("Audio"), false);
  79         make_subtitle_panel ();
  80         _notebook->AddPage (_subtitle_panel, _("Subtitles"), false);
  81
  82         set_film (_film);
  83         connect_to_widgets ();
  84
  85         JobManager::instance()->ActiveJobsChanged.connect (
  86                 bind (&FilmEditor::active_jobs_changed, this, _1)
  87                 );
  88
  89         setup_visibility ();
  90         setup_formats ();
  91 }
  92
  93 void
  94 FilmEditor::make_film_panel ()
  95 {
  96         _film_panel = new wxPanel (_notebook);
  97         _film_sizer = new wxBoxSizer (wxVERTICAL);
  98         _film_panel->SetSizer (_film_sizer);
  99
 100         wxFlexGridSizer* grid = new wxFlexGridSizer (2, 4, 4);
 101         _film_sizer->Add (grid, 0, wxALL, 8);
 102
 103         add_label_to_sizer (grid, _film_panel, _("Name"));
 104         _name = new wxTextCtrl (_film_panel, wxID_ANY);
 105         grid->Add (_name, 1, wxEXPAND);
 106
 107         add_label_to_sizer (grid, _film_panel, _("DCP Name"));
 108         _dcp_name = new wxStaticText (_film_panel, wxID_ANY, wxT (""));
 109         grid->Add (_dcp_name, 0, wxALIGN_CENTER_VERTICAL | wxSHRINK);
 110
 111         _use_dci_name = new wxCheckBox (_film_panel, wxID_ANY, _("Use DCI name"));
 112         grid->Add (_use_dci_name, 1, wxEXPAND);
 113         _edit_dci_button = new wxButton (_film_panel, wxID_ANY, _("Details..."));
 114         grid->Add (_edit_dci_button, 0);
 115
 116         add_label_to_sizer (grid, _film_panel, _("Content"));
 117         _content = new wxFilePickerCtrl (_film_panel, wxID_ANY, wxT (""), _("Select Content File"), wxT("*.*"));
 118         grid->Add (_content, 1, wxEXPAND);
 119
 120         _trust_content_header = new wxCheckBox (_film_panel, wxID_ANY, _("Trust content's header"));
 121         video_control (_trust_content_header);
 122         grid->Add (_trust_content_header, 1);
 123         grid->AddSpacer (0);
 124
 125         add_label_to_sizer (grid, _film_panel, _("Content Type"));
 126         _dcp_content_type = new wxChoice (_film_panel, wxID_ANY);
 127         grid->Add (_dcp_content_type);
 128
 129         video_control (add_label_to_sizer (grid, _film_panel, _("Original Frame Rate")));
 130         _source_frame_rate = new wxStaticText (_film_panel, wxID_ANY, wxT (""));
 131         grid->Add (video_control (_source_frame_rate), 1, wxALIGN_CENTER_VERTICAL);
 132
 133         {
 134                 add_label_to_sizer (grid, _film_panel, _("DCP Frame Rate"));
 135                 wxBoxSizer* s = new wxBoxSizer (wxHORIZONTAL);
 136                 _dcp_frame_rate = new wxChoice (_film_panel, wxID_ANY);
 137                 s->Add (_dcp_frame_rate, 1, wxALIGN_CENTER_VERTICAL);
 138                 _best_dcp_frame_rate = new wxButton (_film_panel, wxID_ANY, _("Use best"));
 139                 s->Add (_best_dcp_frame_rate, 1, wxALIGN_CENTER_VERTICAL | wxALL | wxEXPAND, 6);
 140                 grid->Add (s, 1);
 141         }
 142
 143         video_control (add_label_to_sizer (grid, _film_panel, _("Original Size")));
 144         _original_size = new wxStaticText (_film_panel, wxID_ANY, wxT (""));
 145         grid->Add (video_control (_original_size), 1, wxALIGN_CENTER_VERTICAL);
 146
 147         video_control (add_label_to_sizer (grid, _film_panel, _("Length")));
 148         _length = new wxStaticText (_film_panel, wxID_ANY, wxT (""));
 149         grid->Add (video_control (_length), 1, wxALIGN_CENTER_VERTICAL);
 150
 151
 152         {
 153                 video_control (add_label_to_sizer (grid, _film_panel, _("Trim frames")));
 154                 wxBoxSizer* s = new wxBoxSizer (wxHORIZONTAL);
 155                 video_control (add_label_to_sizer (s, _film_panel, _("Start")));
 156                 _trim_start = new wxSpinCtrl (_film_panel, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize (64, -1));
 157                 s->Add (video_control (_trim_start));
 158                 video_control (add_label_to_sizer (s, _film_panel, _("End")));
 159                 _trim_end = new wxSpinCtrl (_film_panel, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize (64, -1));
 160                 s->Add (video_control (_trim_end));
 161
 162                 grid->Add (s);
 163         }
 164
 165         _dcp_ab = new wxCheckBox (_film_panel, wxID_ANY, _("A/B"));
 166         video_control (_dcp_ab);
 167         grid->Add (_dcp_ab, 1);
 168         grid->AddSpacer (0);
 169
 170         /* STILL-only stuff */
 171         {
 172                 still_control (add_label_to_sizer (grid, _film_panel, _("Duration")));
 173                 wxSizer* s = new wxBoxSizer (wxHORIZONTAL);
 174                 _still_duration = new wxSpinCtrl (_film_panel);
 175                 still_control (_still_duration);
 176                 s->Add (_still_duration, 1, wxEXPAND);
 177                 /// TRANSLATORS: `s' here is an abbreviation for seconds, the unit of time
 178                 still_control (add_label_to_sizer (s, _film_panel, _("s")));
 179                 grid->Add (s);
 180         }
 181
 182         vector<DCPContentType const *> const ct = DCPContentType::all ();
 183         for (vector<DCPContentType const *>::const_iterator i = ct.begin(); i != ct.end(); ++i) {
 184                 _dcp_content_type->Append (std_to_wx ((*i)->pretty_name ()));
 185         }
 186
 187         list<int> const dfr = Config::instance()->allowed_dcp_frame_rates ();
 188         for (list<int>::const_iterator i = dfr.begin(); i != dfr.end(); ++i) {
 189                 _dcp_frame_rate->Append (std_to_wx (boost::lexical_cast<string> (*i)));
 190         }
 191 }
 192
 193 void
 194 FilmEditor::connect_to_widgets ()
 195 {
 196         _name->Connect (wxID_ANY, wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler (FilmEditor::name_changed), 0, this);
 197         _use_dci_name->Connect (wxID_ANY, wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler (FilmEditor::use_dci_name_toggled), 0, this);
 198         _edit_dci_button->Connect (wxID_ANY, wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler (FilmEditor::edit_dci_button_clicked), 0, this);
 199         _format->Connect (wxID_ANY, wxEVT_COMMAND_CHOICE_SELECTED, wxCommandEventHandler (FilmEditor::format_changed), 0, this);
 200         _content->Connect (wxID_ANY, wxEVT_COMMAND_FILEPICKER_CHANGED, wxCommandEventHandler (FilmEditor::content_changed), 0, this);
 201         _trust_content_header->Connect (wxID_ANY, wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler (FilmEditor::trust_content_header_changed), 0, this);
 202         _left_crop->Connect (wxID_ANY, wxEVT_COMMAND_SPINCTRL_UPDATED, wxCommandEventHandler (FilmEditor::left_crop_changed), 0, this);
 203         _right_crop->Connect (wxID_ANY, wxEVT_COMMAND_SPINCTRL_UPDATED, wxCommandEventHandler (FilmEditor::right_crop_changed), 0, this);
 204         _top_crop->Connect (wxID_ANY, wxEVT_COMMAND_SPINCTRL_UPDATED, wxCommandEventHandler (FilmEditor::top_crop_changed), 0, this);
 205         _bottom_crop->Connect (wxID_ANY, wxEVT_COMMAND_SPINCTRL_UPDATED, wxCommandEventHandler (FilmEditor::bottom_crop_changed), 0, this);
 206         _filters_button->Connect (wxID_ANY, wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler (FilmEditor::edit_filters_clicked), 0, this);
 207         _scaler->Connect (wxID_ANY, wxEVT_COMMAND_CHOICE_SELECTED, wxCommandEventHandler (FilmEditor::scaler_changed), 0, this);
 208         _dcp_content_type->Connect (wxID_ANY, wxEVT_COMMAND_CHOICE_SELECTED, wxCommandEventHandler (FilmEditor::dcp_content_type_changed), 0, this);
 209         _dcp_frame_rate->Connect (wxID_ANY, wxEVT_COMMAND_CHOICE_SELECTED, wxCommandEventHandler (FilmEditor::dcp_frame_rate_changed), 0, this);
 210         _best_dcp_frame_rate->Connect (wxID_ANY, wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler (FilmEditor::best_dcp_frame_rate_clicked), 0, this);
 211         _dcp_ab->Connect (wxID_ANY, wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler (FilmEditor::dcp_ab_toggled), 0, this);
 212         _still_duration->Connect (wxID_ANY, wxEVT_COMMAND_SPINCTRL_UPDATED, wxCommandEventHandler (FilmEditor::still_duration_changed), 0, this);
 213         _trim_start->Connect (wxID_ANY, wxEVT_COMMAND_SPINCTRL_UPDATED, wxCommandEventHandler (FilmEditor::trim_start_changed), 0, this);
 214         _trim_end->Connect (wxID_ANY, wxEVT_COMMAND_SPINCTRL_UPDATED, wxCommandEventHandler (FilmEditor::trim_end_changed), 0, this);
 215         _with_subtitles->Connect (wxID_ANY, wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler (FilmEditor::with_subtitles_toggled), 0, this);
 216         _subtitle_offset->Connect (wxID_ANY, wxEVT_COMMAND_SPINCTRL_UPDATED, wxCommandEventHandler (FilmEditor::subtitle_offset_changed), 0, this);
 217         _subtitle_scale->Connect (wxID_ANY, wxEVT_COMMAND_SPINCTRL_UPDATED, wxCommandEventHandler (FilmEditor::subtitle_scale_changed), 0, this);
 218         _colour_lut->Connect (wxID_ANY, wxEVT_COMMAND_CHOICE_SELECTED, wxCommandEventHandler (FilmEditor::colour_lut_changed), 0, this);
 219         _j2k_bandwidth->Connect (wxID_ANY, wxEVT_COMMAND_SPINCTRL_UPDATED, wxCommandEventHandler (FilmEditor::j2k_bandwidth_changed), 0, this);
 220         _subtitle_stream->Connect (wxID_ANY, wxEVT_COMMAND_CHOICE_SELECTED, wxCommandEventHandler (FilmEditor::subtitle_stream_changed), 0, this);
 221         _audio_stream->Connect (wxID_ANY, wxEVT_COMMAND_CHOICE_SELECTED, wxCommandEventHandler (FilmEditor::audio_stream_changed), 0, this);
 222         _audio_gain->Connect (wxID_ANY, wxEVT_COMMAND_SPINCTRL_UPDATED, wxCommandEventHandler (FilmEditor::audio_gain_changed), 0, this);
 223         _audio_gain_calculate_button->Connect (
 224                 wxID_ANY, wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler (FilmEditor::audio_gain_calculate_button_clicked), 0, this
 225                 );
 226         _show_audio->Connect (wxID_ANY, wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler (FilmEditor::show_audio_clicked), 0, this);
 227         _audio_delay->Connect (wxID_ANY, wxEVT_COMMAND_SPINCTRL_UPDATED, wxCommandEventHandler (FilmEditor::audio_delay_changed), 0, this);
 228         _use_content_audio->Connect (wxID_ANY, wxEVT_COMMAND_RADIOBUTTON_SELECTED, wxCommandEventHandler (FilmEditor::use_audio_changed), 0, this);
 229         _use_external_audio->Connect (wxID_ANY, wxEVT_COMMAND_RADIOBUTTON_SELECTED, wxCommandEventHandler (FilmEditor::use_audio_changed), 0, this);
 230         for (int i = 0; i < MAX_AUDIO_CHANNELS; ++i) {
 231                 _external_audio[i]->Connect (
 232                         wxID_ANY, wxEVT_COMMAND_FILEPICKER_CHANGED, wxCommandEventHandler (FilmEditor::external_audio_changed), 0, this
 233                         );
 234         }
 235 }
 236
 237 void
 238 FilmEditor::make_video_panel ()
 239 {
 240         _video_panel = new wxPanel (_notebook);
 241         _video_sizer = new wxBoxSizer (wxVERTICAL);
 242         _video_panel->SetSizer (_video_sizer);
 243
 244         wxFlexGridSizer* grid = new wxFlexGridSizer (2, 4, 4);
 245         _video_sizer->Add (grid, 0, wxALL, 8);
 246
 247         add_label_to_sizer (grid, _video_panel, _("Format"));
 248         _format = new wxChoice (_video_panel, wxID_ANY);
 249         grid->Add (_format);
 250
 251         add_label_to_sizer (grid, _video_panel, _("Left crop"));
 252         _left_crop = new wxSpinCtrl (_video_panel, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize (64, -1));
 253         grid->Add (_left_crop);
 254
 255         add_label_to_sizer (grid, _video_panel, _("Right crop"));
 256         _right_crop = new wxSpinCtrl (_video_panel, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize (64, -1));
 257         grid->Add (_right_crop);
 258
 259         add_label_to_sizer (grid, _video_panel, _("Top crop"));
 260         _top_crop = new wxSpinCtrl (_video_panel, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize (64, -1));
 261         grid->Add (_top_crop);
 262
 263         add_label_to_sizer (grid, _video_panel, _("Bottom crop"));
 264         _bottom_crop = new wxSpinCtrl (_video_panel, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize (64, -1));
 265         grid->Add (_bottom_crop);
 266
 267         /* VIDEO-only stuff */
 268         {
 269                 video_control (add_label_to_sizer (grid, _video_panel, _("Filters")));
 270                 wxSizer* s = new wxBoxSizer (wxHORIZONTAL);
 271                 _filters = new wxStaticText (_video_panel, wxID_ANY, _("None"));
 272                 video_control (_filters);
 273                 s->Add (_filters, 1, wxEXPAND | wxALIGN_CENTER_VERTICAL | wxTOP | wxBOTTOM | wxRIGHT, 6);
 274                 _filters_button = new wxButton (_video_panel, wxID_ANY, _("Edit..."));
 275                 video_control (_filters_button);
 276                 s->Add (_filters_button, 0);
 277                 grid->Add (s, 1);
 278         }
 279
 280         video_control (add_label_to_sizer (grid, _video_panel, _("Scaler")));
 281         _scaler = new wxChoice (_video_panel, wxID_ANY);
 282         grid->Add (video_control (_scaler), 1);
 283
 284         vector<Scaler const *> const sc = Scaler::all ();
 285         for (vector<Scaler const *>::const_iterator i = sc.begin(); i != sc.end(); ++i) {
 286                 _scaler->Append (std_to_wx ((*i)->name()));
 287         }
 288
 289         add_label_to_sizer (grid, _video_panel, _("Colour look-up table"));
 290         _colour_lut = new wxChoice (_video_panel, wxID_ANY);
 291         for (int i = 0; i < 2; ++i) {
 292                 _colour_lut->Append (std_to_wx (colour_lut_index_to_name (i)));
 293         }
 294         _colour_lut->SetSelection (0);
 295         grid->Add (_colour_lut, 1, wxEXPAND);
 296
 297         {
 298                 add_label_to_sizer (grid, _video_panel, _("JPEG2000 bandwidth"));
 299                 wxSizer* s = new wxBoxSizer (wxHORIZONTAL);
 300                 _j2k_bandwidth = new wxSpinCtrl (_video_panel, wxID_ANY);
 301                 s->Add (_j2k_bandwidth, 1);
 302                 add_label_to_sizer (s, _video_panel, _("MBps"));
 303                 grid->Add (s, 1);
 304         }
 305
 306         _left_crop->SetRange (0, 1024);
 307         _top_crop->SetRange (0, 1024);
 308         _right_crop->SetRange (0, 1024);
 309         _bottom_crop->SetRange (0, 1024);
 310         _still_duration->SetRange (1, 60 * 60);
 311         _trim_start->SetRange (0, 100);
 312         _trim_end->SetRange (0, 100);
 313         _j2k_bandwidth->SetRange (50, 250);
 314 }
 315
 316 void
 317 FilmEditor::make_audio_panel ()
 318 {
 319         _audio_panel = new wxPanel (_notebook);
 320         _audio_sizer = new wxBoxSizer (wxVERTICAL);
 321         _audio_panel->SetSizer (_audio_sizer);
 322
 323         wxFlexGridSizer* grid = new wxFlexGridSizer (2, 4, 4);
 324         _audio_sizer->Add (grid, 0, wxALL, 8);
 325
 326         _show_audio = new wxButton (_audio_panel, wxID_ANY, _("Show Audio..."));
 327         grid->Add (_show_audio, 1);
 328         grid->AddSpacer (0);
 329
 330         {
 331                 video_control (add_label_to_sizer (grid, _audio_panel, _("Audio Gain")));
 332                 wxBoxSizer* s = new wxBoxSizer (wxHORIZONTAL);
 333                 _audio_gain = new wxSpinCtrl (_audio_panel);
 334                 s->Add (video_control (_audio_gain), 1);
 335                 video_control (add_label_to_sizer (s, _audio_panel, _("dB")));
 336                 _audio_gain_calculate_button = new wxButton (_audio_panel, wxID_ANY, _("Calculate..."));
 337                 video_control (_audio_gain_calculate_button);
 338                 s->Add (_audio_gain_calculate_button, 1, wxEXPAND);
 339                 grid->Add (s);
 340         }
 341
 342         {
 343                 video_control (add_label_to_sizer (grid, _audio_panel, _("Audio Delay")));
 344                 wxBoxSizer* s = new wxBoxSizer (wxHORIZONTAL);
 345                 _audio_delay = new wxSpinCtrl (_audio_panel);
 346                 s->Add (video_control (_audio_delay), 1);
 347                 /// TRANSLATORS: this is an abbreviation for milliseconds, the unit of time
 348                 video_control (add_label_to_sizer (s, _audio_panel, _("ms")));
 349                 grid->Add (s);
 350         }
 351
 352         {
 353                 _use_content_audio = new wxRadioButton (_audio_panel, wxID_ANY, _("Use content's audio"), wxDefaultPosition, wxDefaultSize, wxRB_GROUP);
 354                 grid->Add (video_control (_use_content_audio));
 355                 wxBoxSizer* s = new wxBoxSizer (wxHORIZONTAL);
 356                 _audio_stream = new wxChoice (_audio_panel, wxID_ANY);
 357                 s->Add (video_control (_audio_stream), 1);
 358                 _audio = new wxStaticText (_audio_panel, wxID_ANY, wxT (""));
 359                 s->Add (video_control (_audio), 1, wxALIGN_CENTER_VERTICAL | wxLEFT, 8);
 360                 grid->Add (s, 1, wxEXPAND);
 361         }
 362
 363         _use_external_audio = new wxRadioButton (_audio_panel, wxID_ANY, _("Use external audio"));
 364         grid->Add (_use_external_audio);
 365         grid->AddSpacer (0);
 366
 367         for (int i = 0; i < MAX_AUDIO_CHANNELS; ++i) {
 368                 add_label_to_sizer (grid, _audio_panel, std_to_wx (audio_channel_name (i)));
 369                 _external_audio[i] = new wxFilePickerCtrl (_audio_panel, wxID_ANY, wxT (""), _("Select Audio File"), wxT ("*.wav"));
 370                 grid->Add (_external_audio[i], 1, wxEXPAND);
 371         }
 372
 373         _audio_gain->SetRange (-60, 60);
 374         _audio_delay->SetRange (-1000, 1000);
 375 }
 376
 377 void
 378 FilmEditor::make_subtitle_panel ()
 379 {
 380         _subtitle_panel = new wxPanel (_notebook);
 381         _subtitle_sizer = new wxBoxSizer (wxVERTICAL);
 382         _subtitle_panel->SetSizer (_subtitle_sizer);
 383         wxFlexGridSizer* grid = new wxFlexGridSizer (2, 4, 4);
 384         _subtitle_sizer->Add (grid, 0, wxALL, 8);
 385
 386         _with_subtitles = new wxCheckBox (_subtitle_panel, wxID_ANY, _("With Subtitles"));
 387         video_control (_with_subtitles);
 388         grid->Add (_with_subtitles, 1);
 389
 390         _subtitle_stream = new wxChoice (_subtitle_panel, wxID_ANY);
 391         grid->Add (video_control (_subtitle_stream));
 392
 393         video_control (add_label_to_sizer (grid, _subtitle_panel, _("Subtitle Offset")));
 394         _subtitle_offset = new wxSpinCtrl (_subtitle_panel);
 395         grid->Add (video_control (_subtitle_offset), 1);
 396
 397         {
 398                 video_control (add_label_to_sizer (grid, _subtitle_panel, _("Subtitle Scale")));
 399                 wxBoxSizer* s = new wxBoxSizer (wxHORIZONTAL);
 400                 _subtitle_scale = new wxSpinCtrl (_subtitle_panel);
 401                 s->Add (video_control (_subtitle_scale));
 402                 video_control (add_label_to_sizer (s, _subtitle_panel, _("%")));
 403                 grid->Add (s);
 404         }
 405
 406         _subtitle_offset->SetRange (-1024, 1024);
 407         _subtitle_scale->SetRange (1, 1000);
 408 }
 409
 410 /** Called when the left crop widget has been changed */
 411 void
 412 FilmEditor::left_crop_changed (wxCommandEvent &)
 413 {
 414         if (!_film) {
 415                 return;
 416         }
 417
 418         _film->set_left_crop (_left_crop->GetValue ());
 419 }
 420
 421 /** Called when the right crop widget has been changed */
 422 void
 423 FilmEditor::right_crop_changed (wxCommandEvent &)
 424 {
 425         if (!_film) {
 426                 return;
 427         }
 428
 429         _film->set_right_crop (_right_crop->GetValue ());
 430 }
 431
 432 /** Called when the top crop widget has been changed */
 433 void
 434 FilmEditor::top_crop_changed (wxCommandEvent &)
 435 {
 436         if (!_film) {
 437                 return;
 438         }
 439
 440         _film->set_top_crop (_top_crop->GetValue ());
 441 }
 442
 443 /** Called when the bottom crop value has been changed */
 444 void
 445 FilmEditor::bottom_crop_changed (wxCommandEvent &)
 446 {
 447         if (!_film) {
 448                 return;
 449         }
 450
 451         _film->set_bottom_crop (_bottom_crop->GetValue ());
 452 }
 453
 454 /** Called when the content filename has been changed */
 455 void
 456 FilmEditor::content_changed (wxCommandEvent &)
 457 {
 458         if (!_film) {
 459                 return;
 460         }
 461
 462         try {
 463                 _film->set_content (wx_to_std (_content->GetPath ()));
 464         } catch (std::exception& e) {
 465                 _content->SetPath (std_to_wx (_film->directory ()));
 466                 error_dialog (this, wxString::Format (_("Could not set content: %s"), e.what ()));
 467         }
 468 }
 469
 470 void
 471 FilmEditor::trust_content_header_changed (wxCommandEvent &)
 472 {
 473         if (!_film) {
 474                 return;
 475         }
 476
 477         _film->set_trust_content_header (_trust_content_header->GetValue ());
 478 }
 479
 480 /** Called when the DCP A/B switch has been toggled */
 481 void
 482 FilmEditor::dcp_ab_toggled (wxCommandEvent &)
 483 {
 484         if (!_film) {
 485                 return;
 486         }
 487
 488         _film->set_dcp_ab (_dcp_ab->GetValue ());
 489 }
 490
 491 /** Called when the name widget has been changed */
 492 void
 493 FilmEditor::name_changed (wxCommandEvent &)
 494 {
 495         if (!_film) {
 496                 return;
 497         }
 498
 499         _film->set_name (string (_name->GetValue().mb_str()));
 500 }
 501
 502 void
 503 FilmEditor::subtitle_offset_changed (wxCommandEvent &)
 504 {
 505         if (!_film) {
 506                 return;
 507         }
 508
 509         _film->set_subtitle_offset (_subtitle_offset->GetValue ());
 510 }
 511
 512 void
 513 FilmEditor::subtitle_scale_changed (wxCommandEvent &)
 514 {
 515         if (!_film) {
 516                 return;
 517         }
 518
 519         _film->set_subtitle_scale (_subtitle_scale->GetValue() / 100.0);
 520 }
 521
 522 void
 523 FilmEditor::colour_lut_changed (wxCommandEvent &)
 524 {
 525         if (!_film) {
 526                 return;
 527         }
 528
 529         _film->set_colour_lut (_colour_lut->GetSelection ());
 530 }
 531
 532 void
 533 FilmEditor::j2k_bandwidth_changed (wxCommandEvent &)
 534 {
 535         if (!_film) {
 536                 return;
 537         }
 538
 539         _film->set_j2k_bandwidth (_j2k_bandwidth->GetValue() * 1e6);
 540 }
 541
 542 void
 543 FilmEditor::dcp_frame_rate_changed (wxCommandEvent &)
 544 {
 545         if (!_film) {
 546                 return;
 547         }
 548
 549         _film->set_dcp_frame_rate (
 550                 boost::lexical_cast<int> (
 551                         wx_to_std (_dcp_frame_rate->GetString (_dcp_frame_rate->GetSelection ()))
 552                         )
 553                 );
 554 }
 555
 556
 557 /** Called when the metadata stored in the Film object has changed;
 558  *  so that we can update the GUI.
 559  *  @param p Property of the Film that has changed.
 560  */
 561 void
 562 FilmEditor::film_changed (Film::Property p)
 563 {
 564         ensure_ui_thread ();
 565
 566         if (!_film) {
 567                 return;
 568         }
 569
 570         stringstream s;
 571
 572         switch (p) {
 573         case Film::NONE:
 574                 break;
 575         case Film::CONTENT:
 576                 checked_set (_content, _film->content ());
 577                 setup_visibility ();
 578                 setup_formats ();
 579                 setup_subtitle_control_sensitivity ();
 580                 setup_streams ();
 581                 break;
 582         case Film::TRUST_CONTENT_HEADER:
 583                 checked_set (_trust_content_header, _film->trust_content_header ());
 584                 break;
 585         case Film::SUBTITLE_STREAMS:
 586                 setup_subtitle_control_sensitivity ();
 587                 setup_streams ();
 588                 break;
 589         case Film::CONTENT_AUDIO_STREAMS:
 590                 setup_streams ();
 591                 break;
 592         case Film::FORMAT:
 593         {
 594                 int n = 0;
 595                 vector<Format const *>::iterator i = _formats.begin ();
 596                 while (i != _formats.end() && *i != _film->format ()) {
 597                         ++i;
 598                         ++n;
 599                 }
 600                 if (i == _formats.end()) {
 601                         checked_set (_format, -1);
 602                 } else {
 603                         checked_set (_format, n);
 604                 }
 605                 setup_dcp_name ();
 606                 break;
 607         }
 608         case Film::CROP:
 609                 checked_set (_left_crop, _film->crop().left);
 610                 checked_set (_right_crop, _film->crop().right);
 611                 checked_set (_top_crop, _film->crop().top);
 612                 checked_set (_bottom_crop, _film->crop().bottom);
 613                 break;
 614         case Film::FILTERS:
 615         {
 616                 pair<string, string> p = Filter::ffmpeg_strings (_film->filters ());
 617                 if (p.first.empty () && p.second.empty ()) {
 618                         _filters->SetLabel (_("None"));
 619                 } else {
 620                         string const b = p.first + " " + p.second;
 621                         _filters->SetLabel (std_to_wx (b));
 622                 }
 623                 _film_sizer->Layout ();
 624                 break;
 625         }
 626         case Film::NAME:
 627                 checked_set (_name, _film->name());
 628                 setup_dcp_name ();
 629                 break;
 630         case Film::SOURCE_FRAME_RATE:
 631                 s << fixed << setprecision(2) << _film->source_frame_rate();
 632                 _source_frame_rate->SetLabel (std_to_wx (s.str ()));
 633                 break;
 634         case Film::SIZE:
 635                 if (_film->size().width == 0 && _film->size().height == 0) {
 636                         _original_size->SetLabel (wxT (""));
 637                 } else {
 638                         s << _film->size().width << " x " << _film->size().height;
 639                         _original_size->SetLabel (std_to_wx (s.str ()));
 640                 }
 641                 break;
 642         case Film::LENGTH:
 643                 if (_film->source_frame_rate() > 0 && _film->length()) {
 644                         s << _film->length().get() << " " << _("frames") << "; " << seconds_to_hms (_film->length().get() / _film->source_frame_rate());
 645                 } else if (_film->length()) {
 646                         s << _film->length().get() << " " << _("frames");
 647                 }
 648                 _length->SetLabel (std_to_wx (s.str ()));
 649                 if (_film->length()) {
 650                         _trim_start->SetRange (0, _film->length().get());
 651                         _trim_end->SetRange (0, _film->length().get());
 652                 }
 653                 break;
 654         case Film::DCP_INTRINSIC_DURATION:
 655                 break;
 656         case Film::DCP_CONTENT_TYPE:
 657                 checked_set (_dcp_content_type, DCPContentType::as_index (_film->dcp_content_type ()));
 658                 setup_dcp_name ();
 659                 break;
 660         case Film::DCP_AB:
 661                 checked_set (_dcp_ab, _film->dcp_ab ());
 662                 break;
 663         case Film::SCALER:
 664                 checked_set (_scaler, Scaler::as_index (_film->scaler ()));
 665                 break;
 666         case Film::TRIM_START:
 667                 checked_set (_trim_start, _film->trim_start());
 668                 break;
 669         case Film::TRIM_END:
 670                 checked_set (_trim_end, _film->trim_end());
 671                 break;
 672         case Film::AUDIO_GAIN:
 673                 checked_set (_audio_gain, _film->audio_gain ());
 674                 break;
 675         case Film::AUDIO_DELAY:
 676                 checked_set (_audio_delay, _film->audio_delay ());
 677                 break;
 678         case Film::STILL_DURATION:
 679                 checked_set (_still_duration, _film->still_duration ());
 680                 break;
 681         case Film::WITH_SUBTITLES:
 682                 checked_set (_with_subtitles, _film->with_subtitles ());
 683                 setup_subtitle_control_sensitivity ();
 684                 setup_dcp_name ();
 685                 break;
 686         case Film::SUBTITLE_OFFSET:
 687                 checked_set (_subtitle_offset, _film->subtitle_offset ());
 688                 break;
 689         case Film::SUBTITLE_SCALE:
 690                 checked_set (_subtitle_scale, _film->subtitle_scale() * 100);
 691                 break;
 692         case Film::COLOUR_LUT:
 693                 checked_set (_colour_lut, _film->colour_lut ());
 694                 break;
 695         case Film::J2K_BANDWIDTH:
 696                 checked_set (_j2k_bandwidth, double (_film->j2k_bandwidth()) / 1e6);
 697                 break;
 698         case Film::USE_DCI_NAME:
 699                 checked_set (_use_dci_name, _film->use_dci_name ());
 700                 setup_dcp_name ();
 701                 break;
 702         case Film::DCI_METADATA:
 703                 setup_dcp_name ();
 704                 break;
 705         case Film::CONTENT_AUDIO_STREAM:
 706                 if (_film->content_audio_stream()) {
 707                         checked_set (_audio_stream, _film->content_audio_stream()->to_string());
 708                 }
 709                 setup_dcp_name ();
 710                 setup_audio_details ();
 711                 setup_audio_control_sensitivity ();
 712                 break;
 713         case Film::USE_CONTENT_AUDIO:
 714                 checked_set (_use_content_audio, _film->use_content_audio());
 715                 checked_set (_use_external_audio, !_film->use_content_audio());
 716                 setup_dcp_name ();
 717                 setup_audio_details ();
 718                 setup_audio_control_sensitivity ();
 719                 break;
 720         case Film::SUBTITLE_STREAM:
 721                 if (_film->subtitle_stream()) {
 722                         checked_set (_subtitle_stream, _film->subtitle_stream()->to_string());
 723                 }
 724                 break;
 725         case Film::EXTERNAL_AUDIO:
 726         {
 727                 vector<string> a = _film->external_audio ();
 728                 for (size_t i = 0; i < a.size() && i < MAX_AUDIO_CHANNELS; ++i) {
 729                         checked_set (_external_audio[i], a[i]);
 730                 }
 731                 setup_audio_details ();
 732                 break;
 733         }
 734         case Film::DCP_FRAME_RATE:
 735                 for (unsigned int i = 0; i < _dcp_frame_rate->GetCount(); ++i) {
 736                         if (wx_to_std (_dcp_frame_rate->GetString(i)) == boost::lexical_cast<string> (_film->dcp_frame_rate())) {
 737                                 if (_dcp_frame_rate->GetSelection() != int(i)) {
 738                                         _dcp_frame_rate->SetSelection (i);
 739                                         break;
 740                                 }
 741                         }
 742                 }
 743         }
 744 }
 745
 746 /** Called when the format widget has been changed */
 747 void
 748 FilmEditor::format_changed (wxCommandEvent &)
 749 {
 750         if (!_film) {
 751                 return;
 752         }
 753
 754         int const n = _format->GetSelection ();
 755         if (n >= 0) {
 756                 assert (n < int (_formats.size()));
 757                 _film->set_format (_formats[n]);
 758         }
 759 }
 760
 761 /** Called when the DCP content type widget has been changed */
 762 void
 763 FilmEditor::dcp_content_type_changed (wxCommandEvent &)
 764 {
 765         if (!_film) {
 766                 return;
 767         }
 768
 769         int const n = _dcp_content_type->GetSelection ();
 770         if (n != wxNOT_FOUND) {
 771                 _film->set_dcp_content_type (DCPContentType::from_index (n));
 772         }
 773 }
 774
 775 /** Sets the Film that we are editing */
 776 void
 777 FilmEditor::set_film (shared_ptr<Film> f)
 778 {
 779         _film = f;
 780
 781         set_things_sensitive (_film != 0);
 782
 783         if (_film) {
 784                 _film->Changed.connect (bind (&FilmEditor::film_changed, this, _1));
 785         }
 786
 787         if (_film) {
 788                 FileChanged (_film->directory ());
 789         } else {
 790                 FileChanged (wx_to_std (N_("")));
 791         }
 792
 793         if (_audio_dialog) {
 794                 _audio_dialog->set_film (_film);
 795         }
 796
 797         film_changed (Film::NAME);
 798         film_changed (Film::USE_DCI_NAME);
 799         film_changed (Film::CONTENT);
 800         film_changed (Film::TRUST_CONTENT_HEADER);
 801         film_changed (Film::DCP_CONTENT_TYPE);
 802         film_changed (Film::FORMAT);
 803         film_changed (Film::CROP);
 804         film_changed (Film::FILTERS);
 805         film_changed (Film::SCALER);
 806         film_changed (Film::TRIM_START);
 807         film_changed (Film::TRIM_END);
 808         film_changed (Film::DCP_AB);
 809         film_changed (Film::CONTENT_AUDIO_STREAM);
 810         film_changed (Film::EXTERNAL_AUDIO);
 811         film_changed (Film::USE_CONTENT_AUDIO);
 812         film_changed (Film::AUDIO_GAIN);
 813         film_changed (Film::AUDIO_DELAY);
 814         film_changed (Film::STILL_DURATION);
 815         film_changed (Film::WITH_SUBTITLES);
 816         film_changed (Film::SUBTITLE_OFFSET);
 817         film_changed (Film::SUBTITLE_SCALE);
 818         film_changed (Film::COLOUR_LUT);
 819         film_changed (Film::J2K_BANDWIDTH);
 820         film_changed (Film::DCI_METADATA);
 821         film_changed (Film::SIZE);
 822         film_changed (Film::LENGTH);
 823         film_changed (Film::CONTENT_AUDIO_STREAMS);
 824         film_changed (Film::SUBTITLE_STREAMS);
 825         film_changed (Film::SOURCE_FRAME_RATE);
 826         film_changed (Film::DCP_FRAME_RATE);
 827 }
 828
 829 /** Updates the sensitivity of lots of widgets to a given value.
 830  *  @param s true to make sensitive, false to make insensitive.
 831  */
 832 void
 833 FilmEditor::set_things_sensitive (bool s)
 834 {
 835         _generally_sensitive = s;
 836
 837         _name->Enable (s);
 838         _use_dci_name->Enable (s);
 839         _edit_dci_button->Enable (s);
 840         _format->Enable (s);
 841         _content->Enable (s);
 842         _trust_content_header->Enable (s);
 843         _left_crop->Enable (s);
 844         _right_crop->Enable (s);
 845         _top_crop->Enable (s);
 846         _bottom_crop->Enable (s);
 847         _filters_button->Enable (s);
 848         _scaler->Enable (s);
 849         _audio_stream->Enable (s);
 850         _dcp_content_type->Enable (s);
 851         _dcp_frame_rate->Enable (s);
 852         _trim_start->Enable (s);
 853         _trim_end->Enable (s);
 854         _dcp_ab->Enable (s);
 855         _colour_lut->Enable (s);
 856         _j2k_bandwidth->Enable (s);
 857         _audio_gain->Enable (s);
 858         _audio_gain_calculate_button->Enable (s);
 859         _show_audio->Enable (s);
 860         _audio_delay->Enable (s);
 861         _still_duration->Enable (s);
 862
 863         setup_subtitle_control_sensitivity ();
 864         setup_audio_control_sensitivity ();
 865 }
 866
 867 /** Called when the `Edit filters' button has been clicked */
 868 void
 869 FilmEditor::edit_filters_clicked (wxCommandEvent &)
 870 {
 871         FilterDialog* d = new FilterDialog (this, _film->filters());
 872         d->ActiveChanged.connect (bind (&Film::set_filters, _film, _1));
 873         d->ShowModal ();
 874         d->Destroy ();
 875 }
 876
 877 /** Called when the scaler widget has been changed */
 878 void
 879 FilmEditor::scaler_changed (wxCommandEvent &)
 880 {
 881         if (!_film) {
 882                 return;
 883         }
 884
 885         int const n = _scaler->GetSelection ();
 886         if (n >= 0) {
 887                 _film->set_scaler (Scaler::from_index (n));
 888         }
 889 }
 890
 891 void
 892 FilmEditor::audio_gain_changed (wxCommandEvent &)
 893 {
 894         if (!_film) {
 895                 return;
 896         }
 897
 898         _film->set_audio_gain (_audio_gain->GetValue ());
 899 }
 900
 901 void
 902 FilmEditor::audio_delay_changed (wxCommandEvent &)
 903 {
 904         if (!_film) {
 905                 return;
 906         }
 907
 908         _film->set_audio_delay (_audio_delay->GetValue ());
 909 }
 910
 911 wxControl *
 912 FilmEditor::video_control (wxControl* c)
 913 {
 914         _video_controls.push_back (c);
 915         return c;
 916 }
 917
 918 wxControl *
 919 FilmEditor::still_control (wxControl* c)
 920 {
 921         _still_controls.push_back (c);
 922         return c;
 923 }
 924
 925 void
 926 FilmEditor::setup_visibility ()
 927 {
 928         ContentType c = VIDEO;
 929
 930         if (_film) {
 931                 c = _film->content_type ();
 932         }
 933
 934         for (list<wxControl*>::iterator i = _video_controls.begin(); i != _video_controls.end(); ++i) {
 935                 (*i)->Show (c == VIDEO);
 936         }
 937
 938         for (list<wxControl*>::iterator i = _still_controls.begin(); i != _still_controls.end(); ++i) {
 939                 (*i)->Show (c == STILL);
 940         }
 941
 942         _notebook->InvalidateBestSize ();
 943
 944         _film_sizer->Layout ();
 945         _film_sizer->SetSizeHints (_film_panel);
 946         _video_sizer->Layout ();
 947         _video_sizer->SetSizeHints (_video_panel);
 948         _audio_sizer->Layout ();
 949         _audio_sizer->SetSizeHints (_audio_panel);
 950         _subtitle_sizer->Layout ();
 951         _subtitle_sizer->SetSizeHints (_subtitle_panel);
 952
 953         _notebook->Fit ();
 954         Fit ();
 955 }
 956
 957 void
 958 FilmEditor::still_duration_changed (wxCommandEvent &)
 959 {
 960         if (!_film) {
 961                 return;
 962         }
 963
 964         _film->set_still_duration (_still_duration->GetValue ());
 965 }
 966
 967 void
 968 FilmEditor::trim_start_changed (wxCommandEvent &)
 969 {
 970         if (!_film) {
 971                 return;
 972         }
 973
 974         _film->set_trim_start (_trim_start->GetValue ());
 975 }
 976
 977 void
 978 FilmEditor::trim_end_changed (wxCommandEvent &)
 979 {
 980         if (!_film) {
 981                 return;
 982         }
 983
 984         _film->set_trim_end (_trim_end->GetValue ());
 985 }
 986
 987 void
 988 FilmEditor::audio_gain_calculate_button_clicked (wxCommandEvent &)
 989 {
 990         GainCalculatorDialog* d = new GainCalculatorDialog (this);
 991         d->ShowModal ();
 992
 993         if (d->wanted_fader() == 0 || d->actual_fader() == 0) {
 994                 d->Destroy ();
 995                 return;
 996         }
 997
 998         _audio_gain->SetValue (
 999                 Config::instance()->sound_processor()->db_for_fader_change (
1000                         d->wanted_fader (),
1001                         d->actual_fader ()
1002                         )
1003                 );
1004
1005         /* This appears to be necessary, as the change is not signalled,
1006            I think.
1007         */
1008         wxCommandEvent dummy;
1009         audio_gain_changed (dummy);
1010
1011         d->Destroy ();
1012 }
1013
1014 void
1015 FilmEditor::setup_formats ()
1016 {
1017         ContentType c = VIDEO;
1018
1019         if (_film) {
1020                 c = _film->content_type ();
1021         }
1022
1023         _formats.clear ();
1024
1025         vector<Format const *> fmt = Format::all ();
1026         for (vector<Format const *>::iterator i = fmt.begin(); i != fmt.end(); ++i) {
1027                 if (c == VIDEO && dynamic_cast<FixedFormat const *> (*i)) {
1028                         _formats.push_back (*i);
1029                 } else if (c == STILL && dynamic_cast<VariableFormat const *> (*i)) {
1030                         _formats.push_back (*i);
1031                 }
1032         }
1033
1034         _format->Clear ();
1035         for (vector<Format const *>::iterator i = _formats.begin(); i != _formats.end(); ++i) {
1036                 _format->Append (std_to_wx ((*i)->name ()));
1037         }
1038
1039         _film_sizer->Layout ();
1040 }
1041
1042 void
1043 FilmEditor::with_subtitles_toggled (wxCommandEvent &)
1044 {
1045         if (!_film) {
1046                 return;
1047         }
1048
1049         _film->set_with_subtitles (_with_subtitles->GetValue ());
1050 }
1051
1052 void
1053 FilmEditor::setup_subtitle_control_sensitivity ()
1054 {
1055         bool h = false;
1056         if (_generally_sensitive && _film) {
1057                 h = !_film->subtitle_streams().empty();
1058         }
1059
1060         _with_subtitles->Enable (h);
1061
1062         bool j = false;
1063         if (_film) {
1064                 j = _film->with_subtitles ();
1065         }
1066
1067         _subtitle_stream->Enable (j);
1068         _subtitle_offset->Enable (j);
1069         _subtitle_scale->Enable (j);
1070 }
1071
1072 void
1073 FilmEditor::setup_audio_control_sensitivity ()
1074 {
1075         _use_content_audio->Enable (_generally_sensitive);
1076         _use_external_audio->Enable (_generally_sensitive);
1077
1078         bool const source = _generally_sensitive && _use_content_audio->GetValue();
1079         bool const external = _generally_sensitive && _use_external_audio->GetValue();
1080
1081         _audio_stream->Enable (source);
1082         for (int i = 0; i < MAX_AUDIO_CHANNELS; ++i) {
1083                 _external_audio[i]->Enable (external);
1084         }
1085 }
1086
1087 void
1088 FilmEditor::use_dci_name_toggled (wxCommandEvent &)
1089 {
1090         if (!_film) {
1091                 return;
1092         }
1093
1094         _film->set_use_dci_name (_use_dci_name->GetValue ());
1095 }
1096
1097 void
1098 FilmEditor::edit_dci_button_clicked (wxCommandEvent &)
1099 {
1100         if (!_film) {
1101                 return;
1102         }
1103
1104         DCIMetadataDialog* d = new DCIMetadataDialog (this, _film->dci_metadata ());
1105         d->ShowModal ();
1106         _film->set_dci_metadata (d->dci_metadata ());
1107         d->Destroy ();
1108 }
1109
1110 void
1111 FilmEditor::setup_streams ()
1112 {
1113         _audio_stream->Clear ();
1114         vector<shared_ptr<AudioStream> > a = _film->content_audio_streams ();
1115         for (vector<shared_ptr<AudioStream> >::iterator i = a.begin(); i != a.end(); ++i) {
1116                 shared_ptr<FFmpegAudioStream> ffa = dynamic_pointer_cast<FFmpegAudioStream> (*i);
1117                 assert (ffa);
1118                 _audio_stream->Append (std_to_wx (ffa->name()), new wxStringClientData (std_to_wx (ffa->to_string ())));
1119         }
1120
1121         if (_film->use_content_audio() && _film->audio_stream()) {
1122                 checked_set (_audio_stream, _film->audio_stream()->to_string());
1123         }
1124
1125         _subtitle_stream->Clear ();
1126         vector<shared_ptr<SubtitleStream> > s = _film->subtitle_streams ();
1127         for (vector<shared_ptr<SubtitleStream> >::iterator i = s.begin(); i != s.end(); ++i) {
1128                 _subtitle_stream->Append (std_to_wx ((*i)->name()), new wxStringClientData (std_to_wx ((*i)->to_string ())));
1129         }
1130         if (_film->subtitle_stream()) {
1131                 checked_set (_subtitle_stream, _film->subtitle_stream()->to_string());
1132         } else {
1133                 _subtitle_stream->SetSelection (wxNOT_FOUND);
1134         }
1135 }
1136
1137 void
1138 FilmEditor::audio_stream_changed (wxCommandEvent &)
1139 {
1140         if (!_film) {
1141                 return;
1142         }
1143
1144         _film->set_content_audio_stream (
1145                 audio_stream_factory (
1146                         string_client_data (_audio_stream->GetClientObject (_audio_stream->GetSelection ())),
1147                         Film::state_version
1148                         )
1149                 );
1150 }
1151
1152 void
1153 FilmEditor::subtitle_stream_changed (wxCommandEvent &)
1154 {
1155         if (!_film) {
1156                 return;
1157         }
1158
1159         _film->set_subtitle_stream (
1160                 subtitle_stream_factory (
1161                         string_client_data (_subtitle_stream->GetClientObject (_subtitle_stream->GetSelection ())),
1162                         Film::state_version
1163                         )
1164                 );
1165 }
1166
1167 void
1168 FilmEditor::setup_audio_details ()
1169 {
1170         if (!_film->audio_stream()) {
1171                 _audio->SetLabel (wxT (""));
1172         } else {
1173                 stringstream s;
1174                 if (_film->audio_stream()->channels() == 1) {
1175                         s << _("1 channel");
1176                 } else {
1177                         s << _film->audio_stream()->channels () << " " << _("channels");
1178                 }
1179                 s << ", " << _film->audio_stream()->sample_rate() << _("Hz");
1180                 _audio->SetLabel (std_to_wx (s.str ()));
1181         }
1182 }
1183
1184 void
1185 FilmEditor::active_jobs_changed (bool a)
1186 {
1187         set_things_sensitive (!a);
1188 }
1189
1190 void
1191 FilmEditor::use_audio_changed (wxCommandEvent &)
1192 {
1193         _film->set_use_content_audio (_use_content_audio->GetValue());
1194 }
1195
1196 void
1197 FilmEditor::external_audio_changed (wxCommandEvent &)
1198 {
1199         vector<string> a;
1200         for (int i = 0; i < MAX_AUDIO_CHANNELS; ++i) {
1201                 a.push_back (wx_to_std (_external_audio[i]->GetPath()));
1202         }
1203
1204         _film->set_external_audio (a);
1205 }
1206
1207 void
1208 FilmEditor::setup_dcp_name ()
1209 {
1210         string s = _film->dcp_name (true);
1211         if (s.length() > 28) {
1212                 _dcp_name->SetLabel (std_to_wx (s.substr (0, 28)) + N_("..."));
1213                 _dcp_name->SetToolTip (std_to_wx (s));
1214         } else {
1215                 _dcp_name->SetLabel (std_to_wx (s));
1216         }
1217 }
1218
1219 void
1220 FilmEditor::show_audio_clicked (wxCommandEvent &)
1221 {
1222         if (_audio_dialog) {
1223                 _audio_dialog->Destroy ();
1224                 _audio_dialog = 0;
1225         }
1226
1227         _audio_dialog = new AudioDialog (this);
1228         _audio_dialog->Show ();
1229         _audio_dialog->set_film (_film);
1230 }
1231
1232 void
1233 FilmEditor::best_dcp_frame_rate_clicked (wxCommandEvent &)
1234 {
1235         if (!_film) {
1236                 return;
1237         }
1238
1239         _film->set_dcp_frame_rate (best_dcp_frame_rate (_film->source_frame_rate ()));
1240 }