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