X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;f=src%2Fwx%2Ffilm_editor.cc;h=feb49ed78a394b392f93e118ae604fe3e2948ce9;hb=d62877ae6c4e316e43f4052e4b9ba673610012cf;hp=c90122affe9eb20b7783de01deead58d61eaa915;hpb=58bf77268a8e82e73d7f17ab2fe6dcd29370ade3;p=dcpomatic.git

diff --git a/src/wx/film_editor.cc b/src/wx/film_editor.cc
index c90122aff..feb49ed78 100644
--- a/src/wx/film_editor.cc
+++ b/src/wx/film_editor.cc
@@ -25,6 +25,7 @@
 #include <iomanip>
 #include <wx/wx.h>
 #include <wx/notebook.h>
+#include <wx/listctrl.h>
 #include <boost/thread.hpp>
 #include <boost/filesystem.hpp>
 #include <boost/lexical_cast.hpp>
@@ -37,14 +38,19 @@
 #include "lib/filter.h"
 #include "lib/config.h"
 #include "lib/ffmpeg_decoder.h"
-#include "lib/external_audio_decoder.h"
+#include "lib/imagemagick_content.h"
+#include "lib/sndfile_content.h"
+#include "lib/dcp_content_type.h"
 #include "filter_dialog.h"
 #include "wx_util.h"
 #include "film_editor.h"
 #include "gain_calculator_dialog.h"
 #include "sound_processor.h"
-#include "dci_name_dialog.h"
+#include "dci_metadata_dialog.h"
 #include "scaler.h"
+#include "audio_dialog.h"
+#include "imagemagick_content_dialog.h"
+#include "audio_mapping_view.h"
 
 using std::string;
 using std::cout;
@@ -55,21 +61,24 @@ using std::setprecision;
 using std::list;
 using std::vector;
 using boost::shared_ptr;
+using boost::weak_ptr;
 using boost::dynamic_pointer_cast;
+using boost::lexical_cast;
 
 /** @param f Film to edit */
 FilmEditor::FilmEditor (shared_ptr<Film> f, wxWindow* parent)
 	: wxPanel (parent)
-	, _film (f)
 	, _generally_sensitive (true)
+	, _audio_dialog (0)
 {
 	wxBoxSizer* s = new wxBoxSizer (wxVERTICAL);
-	SetSizer (s);
 	_notebook = new wxNotebook (this, wxID_ANY);
 	s->Add (_notebook, 1);
 
 	make_film_panel ();
 	_notebook->AddPage (_film_panel, _("Film"), true);
+	make_content_panel ();
+	_notebook->AddPage (_content_panel, _("Content"), false);
 	make_video_panel ();
 	_notebook->AddPage (_video_panel, _("Video"), false);
 	make_audio_panel ();
@@ -77,98 +86,107 @@ FilmEditor::FilmEditor (shared_ptr<Film> f, wxWindow* parent)
 	make_subtitle_panel ();
 	_notebook->AddPage (_subtitle_panel, _("Subtitles"), false);
 
-	set_film (_film);
+	set_film (f);
 	connect_to_widgets ();
 
 	JobManager::instance()->ActiveJobsChanged.connect (
 		bind (&FilmEditor::active_jobs_changed, this, _1)
 		);
 	
-	setup_visibility ();
 	setup_formats ();
+
+	SetSizerAndFit (s);
 }
 
 void
 FilmEditor::make_film_panel ()
 {
 	_film_panel = new wxPanel (_notebook);
-	_film_sizer = new wxFlexGridSizer (2, 4, 4);
-	wxBoxSizer* pad = new wxBoxSizer (wxVERTICAL);
-	pad->Add (_film_sizer, 0, wxALL, 8);
-	_film_panel->SetSizer (pad);
+	_film_sizer = new wxBoxSizer (wxVERTICAL);
+	_film_panel->SetSizer (_film_sizer);
 
-	add_label_to_sizer (_film_sizer, _film_panel, "Name");
-	_name = new wxTextCtrl (_film_panel, wxID_ANY);
-	_film_sizer->Add (_name, 1, wxEXPAND);
+	wxGridBagSizer* grid = new wxGridBagSizer (4, 4);
+	_film_sizer->Add (grid, 0, wxALL, 8);
 
-	add_label_to_sizer (_film_sizer, _film_panel, "DCP Name");
+	int r = 0;
+	
+	add_label_to_grid_bag_sizer (grid, _film_panel, _("Name"), wxGBPosition (r, 0));
+	_name = new wxTextCtrl (_film_panel, wxID_ANY);
+	grid->Add (_name, wxGBPosition(r, 1), wxDefaultSpan, wxEXPAND);
+	++r;
+	
+	add_label_to_grid_bag_sizer (grid, _film_panel, _("DCP Name"), wxGBPosition (r, 0));
 	_dcp_name = new wxStaticText (_film_panel, wxID_ANY, wxT (""));
-	_film_sizer->Add (_dcp_name, 0, wxALIGN_CENTER_VERTICAL | wxSHRINK);
-
-	_use_dci_name = new wxCheckBox (_film_panel, wxID_ANY, wxT ("Use DCI name"));
-	_film_sizer->Add (_use_dci_name, 1, wxEXPAND);
-	_edit_dci_button = new wxButton (_film_panel, wxID_ANY, wxT ("Details..."));
-	_film_sizer->Add (_edit_dci_button, 0);
+	grid->Add (_dcp_name, wxGBPosition(r, 1), wxDefaultSpan, wxALIGN_CENTER_VERTICAL);
+	++r;
 
-	add_label_to_sizer (_film_sizer, _film_panel, "Content");
-	_content = new wxFilePickerCtrl (_film_panel, wxID_ANY, wxT (""), wxT ("Select Content File"), wxT("*.*"));
-	_film_sizer->Add (_content, 1, wxEXPAND);
+	_use_dci_name = new wxCheckBox (_film_panel, wxID_ANY, _("Use DCI name"));
+	grid->Add (_use_dci_name, wxGBPosition (r, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL);
+	_edit_dci_button = new wxButton (_film_panel, wxID_ANY, _("Details..."));
+	grid->Add (_edit_dci_button, wxGBPosition (r, 1), wxDefaultSpan);
+	++r;
 
-	_trust_content_header = new wxCheckBox (_film_panel, wxID_ANY, wxT ("Trust content's header"));
-	video_control (_trust_content_header);
-	_film_sizer->Add (_trust_content_header, 1);
-	_film_sizer->AddSpacer (0);
+	_trust_content_headers = new wxCheckBox (_film_panel, wxID_ANY, _("Trust content's header"));
+	grid->Add (_trust_content_headers, wxGBPosition (r, 0), wxGBSpan(1, 2));
+	++r;
 
-	add_label_to_sizer (_film_sizer, _film_panel, "Content Type");
-	_dcp_content_type = new wxComboBox (_film_panel, wxID_ANY, wxT (""), wxDefaultPosition, wxDefaultSize, 0, 0, wxCB_READONLY);
-	_film_sizer->Add (_dcp_content_type);
+	add_label_to_grid_bag_sizer (grid, _film_panel, _("Content Type"), wxGBPosition (r, 0));
+	_dcp_content_type = new wxChoice (_film_panel, wxID_ANY);
+	grid->Add (_dcp_content_type, wxGBPosition (r, 1));
+	++r;
 
-	video_control (add_label_to_sizer (_film_sizer, _film_panel, "Frames Per Second"));
-	_frames_per_second = new wxStaticText (_film_panel, wxID_ANY, wxT (""));
-	_film_sizer->Add (video_control (_frames_per_second), 1, wxALIGN_CENTER_VERTICAL);
-	
-	video_control (add_label_to_sizer (_film_sizer, _film_panel, "Original Size"));
-	_original_size = new wxStaticText (_film_panel, wxID_ANY, wxT (""));
-	_film_sizer->Add (video_control (_original_size), 1, wxALIGN_CENTER_VERTICAL);
+	{
+		add_label_to_grid_bag_sizer (grid, _film_panel, _("DCP Frame Rate"), wxGBPosition (r, 0));
+		wxBoxSizer* s = new wxBoxSizer (wxHORIZONTAL);
+		_dcp_frame_rate = new wxChoice (_film_panel, wxID_ANY);
+		s->Add (_dcp_frame_rate, 1, wxALIGN_CENTER_VERTICAL);
+		_best_dcp_frame_rate = new wxButton (_film_panel, wxID_ANY, _("Use best"));
+		s->Add (_best_dcp_frame_rate, 1, wxALIGN_CENTER_VERTICAL | wxALL | wxEXPAND, 6);
+		grid->Add (s, wxGBPosition (r, 1));
+	}
+	++r;
+
+	_frame_rate_description = new wxStaticText (_film_panel, wxID_ANY, wxT (" \n \n "), wxDefaultPosition, wxDefaultSize);
+	grid->Add (_frame_rate_description, wxGBPosition (r, 0), wxGBSpan (1, 2), wxEXPAND | wxALIGN_CENTER_VERTICAL | wxALL, 6);
+	wxFont font = _frame_rate_description->GetFont();
+	font.SetStyle(wxFONTSTYLE_ITALIC);
+	font.SetPointSize(font.GetPointSize() - 1);
+	_frame_rate_description->SetFont(font);
+	++r;
 	
-	video_control (add_label_to_sizer (_film_sizer, _film_panel, "Length"));
+	add_label_to_grid_bag_sizer (grid, _film_panel, _("Length"), wxGBPosition (r, 0));
 	_length = new wxStaticText (_film_panel, wxID_ANY, wxT (""));
-	_film_sizer->Add (video_control (_length), 1, wxALIGN_CENTER_VERTICAL);
+	grid->Add (_length, wxGBPosition (r, 1), wxDefaultSpan, wxALIGN_CENTER_VERTICAL);
+	++r;
 
 
 	{
-		video_control (add_label_to_sizer (_film_sizer, _film_panel, "Trim frames"));
+		add_label_to_grid_bag_sizer (grid, _film_panel, _("Trim frames"), wxGBPosition (r, 0));
 		wxBoxSizer* s = new wxBoxSizer (wxHORIZONTAL);
-		video_control (add_label_to_sizer (s, _film_panel, "Start"));
-		_dcp_trim_start = new wxSpinCtrl (_film_panel, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize (64, -1));
-		s->Add (video_control (_dcp_trim_start));
-		video_control (add_label_to_sizer (s, _film_panel, "End"));
-		_dcp_trim_end = new wxSpinCtrl (_film_panel, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize (64, -1));
-		s->Add (video_control (_dcp_trim_end));
-
-		_film_sizer->Add (s);
+		add_label_to_sizer (s, _film_panel, _("Start"));
+		_trim_start = new wxSpinCtrl (_film_panel, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize (64, -1));
+		s->Add (_trim_start);
+		add_label_to_sizer (s, _film_panel, _("End"));
+		_trim_end = new wxSpinCtrl (_film_panel, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize (64, -1));
+		s->Add (_trim_end);
+
+		grid->Add (s, wxGBPosition (r, 1));
 	}
+	++r;
 
-	_dcp_ab = new wxCheckBox (_film_panel, wxID_ANY, wxT ("A/B"));
-	video_control (_dcp_ab);
-	_film_sizer->Add (_dcp_ab, 1);
-	_film_sizer->AddSpacer (0);
-
-	/* STILL-only stuff */
-	{
-		still_control (add_label_to_sizer (_film_sizer, _film_panel, "Duration"));
-		wxSizer* s = new wxBoxSizer (wxHORIZONTAL);
-		_still_duration = new wxSpinCtrl (_film_panel);
-		still_control (_still_duration);
-		s->Add (_still_duration, 1, wxEXPAND);
-		still_control (add_label_to_sizer (s, _film_panel, "s"));
-		_film_sizer->Add (s);
-	}
+	_ab = new wxCheckBox (_film_panel, wxID_ANY, _("A/B"));
+	grid->Add (_ab, wxGBPosition (r, 0));
+	++r;
 
 	vector<DCPContentType const *> const ct = DCPContentType::all ();
 	for (vector<DCPContentType const *>::const_iterator i = ct.begin(); i != ct.end(); ++i) {
 		_dcp_content_type->Append (std_to_wx ((*i)->pretty_name ()));
 	}
+
+	list<int> const dfr = Config::instance()->allowed_dcp_frame_rates ();
+	for (list<int>::const_iterator i = dfr.begin(); i != dfr.end(); ++i) {
+		_dcp_frame_rate->Append (std_to_wx (boost::lexical_cast<string> (*i)));
+	}
 }
 
 void
@@ -177,165 +195,222 @@ FilmEditor::connect_to_widgets ()
 	_name->Connect (wxID_ANY, wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler (FilmEditor::name_changed), 0, this);
 	_use_dci_name->Connect (wxID_ANY, wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler (FilmEditor::use_dci_name_toggled), 0, this);
 	_edit_dci_button->Connect (wxID_ANY, wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler (FilmEditor::edit_dci_button_clicked), 0, this);
-	_format->Connect (wxID_ANY, wxEVT_COMMAND_COMBOBOX_SELECTED, wxCommandEventHandler (FilmEditor::format_changed), 0, this);
-	_content->Connect (wxID_ANY, wxEVT_COMMAND_FILEPICKER_CHANGED, wxCommandEventHandler (FilmEditor::content_changed), 0, this);
-	_trust_content_header->Connect (wxID_ANY, wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler (FilmEditor::trust_content_header_changed), 0, this);
+	_format->Connect (wxID_ANY, wxEVT_COMMAND_CHOICE_SELECTED, wxCommandEventHandler (FilmEditor::format_changed), 0, this);
+	_trust_content_headers->Connect (wxID_ANY, wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler (FilmEditor::trust_content_headers_changed), 0, this);
+	_content->Connect (wxID_ANY, wxEVT_COMMAND_LIST_ITEM_SELECTED, wxListEventHandler (FilmEditor::content_selection_changed), 0, this);
+	_content->Connect (wxID_ANY, wxEVT_COMMAND_LIST_ITEM_DESELECTED, wxListEventHandler (FilmEditor::content_selection_changed), 0, this);
+	_content->Connect (wxID_ANY, wxEVT_COMMAND_LIST_ITEM_ACTIVATED, wxListEventHandler (FilmEditor::content_activated), 0, this);
+	_content_add->Connect (wxID_ANY, wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler (FilmEditor::content_add_clicked), 0, this);
+	_content_remove->Connect (wxID_ANY, wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler (FilmEditor::content_remove_clicked), 0, this);
+	_content_edit->Connect (wxID_ANY, wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler (FilmEditor::content_edit_clicked), 0, this);
+	_content_earlier->Connect (wxID_ANY, wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler (FilmEditor::content_earlier_clicked), 0, this);
+	_content_later->Connect (wxID_ANY, wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler (FilmEditor::content_later_clicked), 0, this);
 	_left_crop->Connect (wxID_ANY, wxEVT_COMMAND_SPINCTRL_UPDATED, wxCommandEventHandler (FilmEditor::left_crop_changed), 0, this);
 	_right_crop->Connect (wxID_ANY, wxEVT_COMMAND_SPINCTRL_UPDATED, wxCommandEventHandler (FilmEditor::right_crop_changed), 0, this);
 	_top_crop->Connect (wxID_ANY, wxEVT_COMMAND_SPINCTRL_UPDATED, wxCommandEventHandler (FilmEditor::top_crop_changed), 0, this);
 	_bottom_crop->Connect (wxID_ANY, wxEVT_COMMAND_SPINCTRL_UPDATED, wxCommandEventHandler (FilmEditor::bottom_crop_changed), 0, this);
 	_filters_button->Connect (wxID_ANY, wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler (FilmEditor::edit_filters_clicked), 0, this);
-	_scaler->Connect (wxID_ANY, wxEVT_COMMAND_COMBOBOX_SELECTED, wxCommandEventHandler (FilmEditor::scaler_changed), 0, this);
-	_dcp_content_type->Connect (wxID_ANY, wxEVT_COMMAND_COMBOBOX_SELECTED, wxCommandEventHandler (FilmEditor::dcp_content_type_changed), 0, this);
-	_dcp_ab->Connect (wxID_ANY, wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler (FilmEditor::dcp_ab_toggled), 0, this);
-	_still_duration->Connect (wxID_ANY, wxEVT_COMMAND_SPINCTRL_UPDATED, wxCommandEventHandler (FilmEditor::still_duration_changed), 0, this);
-	_dcp_trim_start->Connect (wxID_ANY, wxEVT_COMMAND_SPINCTRL_UPDATED, wxCommandEventHandler (FilmEditor::dcp_trim_start_changed), 0, this);
-	_dcp_trim_end->Connect (wxID_ANY, wxEVT_COMMAND_SPINCTRL_UPDATED, wxCommandEventHandler (FilmEditor::dcp_trim_end_changed), 0, this);
+	_scaler->Connect (wxID_ANY, wxEVT_COMMAND_CHOICE_SELECTED, wxCommandEventHandler (FilmEditor::scaler_changed), 0, this);
+	_dcp_content_type->Connect (wxID_ANY, wxEVT_COMMAND_CHOICE_SELECTED, wxCommandEventHandler (FilmEditor::dcp_content_type_changed), 0, this);
+	_dcp_frame_rate->Connect (wxID_ANY, wxEVT_COMMAND_CHOICE_SELECTED, wxCommandEventHandler (FilmEditor::dcp_frame_rate_changed), 0, this);
+	_best_dcp_frame_rate->Connect (wxID_ANY, wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler (FilmEditor::best_dcp_frame_rate_clicked), 0, this);
+	_ab->Connect (wxID_ANY, wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler (FilmEditor::ab_toggled), 0, this);
+	_trim_start->Connect (wxID_ANY, wxEVT_COMMAND_SPINCTRL_UPDATED, wxCommandEventHandler (FilmEditor::trim_start_changed), 0, this);
+	_trim_end->Connect (wxID_ANY, wxEVT_COMMAND_SPINCTRL_UPDATED, wxCommandEventHandler (FilmEditor::trim_end_changed), 0, this);
 	_with_subtitles->Connect (wxID_ANY, wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler (FilmEditor::with_subtitles_toggled), 0, this);
 	_subtitle_offset->Connect (wxID_ANY, wxEVT_COMMAND_SPINCTRL_UPDATED, wxCommandEventHandler (FilmEditor::subtitle_offset_changed), 0, this);
 	_subtitle_scale->Connect (wxID_ANY, wxEVT_COMMAND_SPINCTRL_UPDATED, wxCommandEventHandler (FilmEditor::subtitle_scale_changed), 0, this);
-	_subtitle_stream->Connect (wxID_ANY, wxEVT_COMMAND_COMBOBOX_SELECTED, wxCommandEventHandler (FilmEditor::subtitle_stream_changed), 0, this);
-	_audio_stream->Connect (wxID_ANY, wxEVT_COMMAND_COMBOBOX_SELECTED, wxCommandEventHandler (FilmEditor::audio_stream_changed), 0, this);
+	_colour_lut->Connect (wxID_ANY, wxEVT_COMMAND_CHOICE_SELECTED, wxCommandEventHandler (FilmEditor::colour_lut_changed), 0, this);
+	_j2k_bandwidth->Connect (wxID_ANY, wxEVT_COMMAND_SPINCTRL_UPDATED, wxCommandEventHandler (FilmEditor::j2k_bandwidth_changed), 0, this);
+	_ffmpeg_subtitle_stream->Connect (wxID_ANY, wxEVT_COMMAND_CHOICE_SELECTED, wxCommandEventHandler (FilmEditor::ffmpeg_subtitle_stream_changed), 0, this);
+	_ffmpeg_audio_stream->Connect (wxID_ANY, wxEVT_COMMAND_CHOICE_SELECTED, wxCommandEventHandler (FilmEditor::ffmpeg_audio_stream_changed), 0, this);
 	_audio_gain->Connect (wxID_ANY, wxEVT_COMMAND_SPINCTRL_UPDATED, wxCommandEventHandler (FilmEditor::audio_gain_changed), 0, this);
 	_audio_gain_calculate_button->Connect (
 		wxID_ANY, wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler (FilmEditor::audio_gain_calculate_button_clicked), 0, this
 		);
+	_show_audio->Connect (wxID_ANY, wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler (FilmEditor::show_audio_clicked), 0, this);
 	_audio_delay->Connect (wxID_ANY, wxEVT_COMMAND_SPINCTRL_UPDATED, wxCommandEventHandler (FilmEditor::audio_delay_changed), 0, this);
-	_use_content_audio->Connect (wxID_ANY, wxEVT_COMMAND_RADIOBUTTON_SELECTED, wxCommandEventHandler (FilmEditor::use_audio_changed), 0, this);
-	_use_external_audio->Connect (wxID_ANY, wxEVT_COMMAND_RADIOBUTTON_SELECTED, wxCommandEventHandler (FilmEditor::use_audio_changed), 0, this);
-	for (int i = 0; i < MAX_AUDIO_CHANNELS; ++i) {
-		_external_audio[i]->Connect (
-			wxID_ANY, wxEVT_COMMAND_FILEPICKER_CHANGED, wxCommandEventHandler (FilmEditor::external_audio_changed), 0, this
-			);
-	}
 }
 
 void
 FilmEditor::make_video_panel ()
 {
 	_video_panel = new wxPanel (_notebook);
-	_video_sizer = new wxFlexGridSizer (2, 4, 4);
-	wxBoxSizer* pad = new wxBoxSizer (wxVERTICAL);
-	pad->Add (_video_sizer, 0, wxALL, 8);
-	_video_panel->SetSizer (pad);
-
-	add_label_to_sizer (_video_sizer, _video_panel, "Format");
-	_format = new wxComboBox (_video_panel, wxID_ANY, wxT (""), wxDefaultPosition, wxDefaultSize, 0, 0, wxCB_READONLY);
-	_video_sizer->Add (_format);
-
-	{
-		add_label_to_sizer (_video_sizer, _video_panel, "Crop");
-		wxBoxSizer* s = new wxBoxSizer (wxHORIZONTAL);
-
-		add_label_to_sizer (s, _video_panel, "L");
-		_left_crop = new wxSpinCtrl (_video_panel, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize (64, -1));
-		s->Add (_left_crop, 0);
-		add_label_to_sizer (s, _video_panel, "R");
-		_right_crop = new wxSpinCtrl (_video_panel, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize (64, -1));
-		s->Add (_right_crop, 0);
-		add_label_to_sizer (s, _video_panel, "T");
-		_top_crop = new wxSpinCtrl (_video_panel, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize (64, -1));
-		s->Add (_top_crop, 0);
-		add_label_to_sizer (s, _video_panel, "B");
-		_bottom_crop = new wxSpinCtrl (_video_panel, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize (64, -1));
-		s->Add (_bottom_crop, 0);
-
-		_video_sizer->Add (s);
-	}
+	_video_sizer = new wxBoxSizer (wxVERTICAL);
+	_video_panel->SetSizer (_video_sizer);
+	
+	wxGridBagSizer* grid = new wxGridBagSizer (4, 4);
+	_video_sizer->Add (grid, 0, wxALL, 8);
+
+	int r = 0;
+	add_label_to_grid_bag_sizer (grid, _video_panel, _("Format"), wxGBPosition (r, 0));
+	_format = new wxChoice (_video_panel, wxID_ANY);
+	grid->Add (_format, wxGBPosition (r, 1));
+	++r;
+
+	add_label_to_grid_bag_sizer (grid, _video_panel, _("Left crop"), wxGBPosition (r, 0));
+	_left_crop = new wxSpinCtrl (_video_panel, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize (64, -1));
+	grid->Add (_left_crop, wxGBPosition (r, 1));
+	++r;
+
+	add_label_to_grid_bag_sizer (grid, _video_panel, _("Right crop"), wxGBPosition (r, 0));
+	_right_crop = new wxSpinCtrl (_video_panel, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize (64, -1));
+	grid->Add (_right_crop, wxGBPosition (r, 1));
+	++r;
+	
+	add_label_to_grid_bag_sizer (grid, _video_panel, _("Top crop"), wxGBPosition (r, 0));
+	_top_crop = new wxSpinCtrl (_video_panel, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize (64, -1));
+	grid->Add (_top_crop, wxGBPosition (r, 1));
+	++r;
+	
+	add_label_to_grid_bag_sizer (grid, _video_panel, _("Bottom crop"), wxGBPosition (r, 0));
+	_bottom_crop = new wxSpinCtrl (_video_panel, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize (64, -1));
+	grid->Add (_bottom_crop, wxGBPosition (r, 1));
+	++r;
+
+	_scaling_description = new wxStaticText (_video_panel, wxID_ANY, wxT ("\n \n \n \n"), wxDefaultPosition, wxDefaultSize);
+	grid->Add (_scaling_description, wxGBPosition (r, 0), wxGBSpan (1, 2), wxEXPAND | wxALIGN_CENTER_VERTICAL | wxALL, 6);
+	wxFont font = _scaling_description->GetFont();
+	font.SetStyle(wxFONTSTYLE_ITALIC);
+	font.SetPointSize(font.GetPointSize() - 1);
+	_scaling_description->SetFont(font);
+	++r;
 
 	/* VIDEO-only stuff */
 	{
-		video_control (add_label_to_sizer (_video_sizer, _video_panel, "Filters"));
+		add_label_to_grid_bag_sizer (grid, _video_panel, _("Filters"), wxGBPosition (r, 0));
 		wxSizer* s = new wxBoxSizer (wxHORIZONTAL);
-		_filters = new wxStaticText (_video_panel, wxID_ANY, wxT ("None"));
-		video_control (_filters);
+		_filters = new wxStaticText (_video_panel, wxID_ANY, _("None"));
 		s->Add (_filters, 1, wxEXPAND | wxALIGN_CENTER_VERTICAL | wxTOP | wxBOTTOM | wxRIGHT, 6);
-		_filters_button = new wxButton (_video_panel, wxID_ANY, wxT ("Edit..."));
-		video_control (_filters_button);
+		_filters_button = new wxButton (_video_panel, wxID_ANY, _("Edit..."));
 		s->Add (_filters_button, 0);
-		_video_sizer->Add (s, 1);
+		grid->Add (s, wxGBPosition (r, 1), wxDefaultSpan, wxALIGN_CENTER_VERTICAL);
 	}
+	++r;
 
-	video_control (add_label_to_sizer (_video_sizer, _video_panel, "Scaler"));
-	_scaler = new wxComboBox (_video_panel, wxID_ANY, wxT (""), wxDefaultPosition, wxDefaultSize, 0, 0, wxCB_READONLY);
-	_video_sizer->Add (video_control (_scaler), 1);
+	add_label_to_grid_bag_sizer (grid, _video_panel, _("Scaler"), wxGBPosition (r, 0));
+	_scaler = new wxChoice (_video_panel, wxID_ANY);
+	grid->Add (_scaler, wxGBPosition (r, 1));
+	++r;
 
 	vector<Scaler const *> const sc = Scaler::all ();
 	for (vector<Scaler const *>::const_iterator i = sc.begin(); i != sc.end(); ++i) {
 		_scaler->Append (std_to_wx ((*i)->name()));
 	}
 
+	add_label_to_grid_bag_sizer (grid, _video_panel, _("Colour look-up table"), wxGBPosition (r, 0));
+	_colour_lut = new wxChoice (_video_panel, wxID_ANY);
+	for (int i = 0; i < 2; ++i) {
+		_colour_lut->Append (std_to_wx (colour_lut_index_to_name (i)));
+	}
+	_colour_lut->SetSelection (0);
+	grid->Add (_colour_lut, wxGBPosition (r, 1), wxDefaultSpan, wxEXPAND);
+	++r;
+
+	{
+		add_label_to_grid_bag_sizer (grid, _video_panel, _("JPEG2000 bandwidth"), wxGBPosition (r, 0));
+		wxSizer* s = new wxBoxSizer (wxHORIZONTAL);
+		_j2k_bandwidth = new wxSpinCtrl (_video_panel, wxID_ANY);
+		s->Add (_j2k_bandwidth, 1);
+		add_label_to_sizer (s, _video_panel, _("MBps"));
+		grid->Add (s, wxGBPosition (r, 1));
+	}
+	++r;
+
 	_left_crop->SetRange (0, 1024);
 	_top_crop->SetRange (0, 1024);
 	_right_crop->SetRange (0, 1024);
 	_bottom_crop->SetRange (0, 1024);
-	_still_duration->SetRange (1, 60 * 60);
-	_dcp_trim_start->SetRange (0, 100);
-	_dcp_trim_end->SetRange (0, 100);
+	_trim_start->SetRange (0, 100);
+	_trim_end->SetRange (0, 100);
+	_j2k_bandwidth->SetRange (50, 250);
+}
+
+void
+FilmEditor::make_content_panel ()
+{
+	_content_panel = new wxPanel (_notebook);
+	_content_sizer = new wxBoxSizer (wxVERTICAL);
+	_content_panel->SetSizer (_content_sizer);
+	
+        {
+                wxBoxSizer* s = new wxBoxSizer (wxHORIZONTAL);
+                
+                _content = new wxListCtrl (_content_panel, wxID_ANY, wxDefaultPosition, wxSize (320, 160), wxLC_REPORT | wxLC_NO_HEADER | wxLC_SINGLE_SEL);
+                s->Add (_content, 1, wxEXPAND | wxTOP | wxBOTTOM, 6);
+
+                _content->InsertColumn (0, wxT(""));
+		_content->SetColumnWidth (0, 512);
+
+                wxBoxSizer* b = new wxBoxSizer (wxVERTICAL);
+                _content_add = new wxButton (_content_panel, wxID_ANY, _("Add..."));
+                b->Add (_content_add);
+                _content_remove = new wxButton (_content_panel, wxID_ANY, _("Remove"));
+                b->Add (_content_remove);
+                _content_edit = new wxButton (_content_panel, wxID_ANY, _("Edit..."));
+                b->Add (_content_edit);
+                _content_earlier = new wxButton (_content_panel, wxID_ANY, _("Earlier"));
+                b->Add (_content_earlier);
+                _content_later = new wxButton (_content_panel, wxID_ANY, _("Later"));
+                b->Add (_content_later);
+
+                s->Add (b, 0, wxALL, 4);
+
+                _content_sizer->Add (s, 1, wxEXPAND | wxALL, 6);
+        }
+
+	_content_information = new wxTextCtrl (_content_panel, wxID_ANY, wxT ("\n\n\n\n"), wxDefaultPosition, wxDefaultSize, wxTE_READONLY | wxTE_MULTILINE);
+	_content_sizer->Add (_content_information, 1, wxEXPAND | wxALL, 6);
 }
 
 void
 FilmEditor::make_audio_panel ()
 {
 	_audio_panel = new wxPanel (_notebook);
-	_audio_sizer = new wxFlexGridSizer (2, 4, 4);
-	wxBoxSizer* pad = new wxBoxSizer (wxVERTICAL);
-	pad->Add (_audio_sizer, 0, wxALL, 8);
-	_audio_panel->SetSizer (pad);
+	_audio_sizer = new wxBoxSizer (wxVERTICAL);
+	_audio_panel->SetSizer (_audio_sizer);
+	
+	wxFlexGridSizer* grid = new wxFlexGridSizer (2, 4, 4);
+	_audio_sizer->Add (grid, 0, wxALL, 8);
+
+	_show_audio = new wxButton (_audio_panel, wxID_ANY, _("Show Audio..."));
+	grid->Add (_show_audio, 1);
+	grid->AddSpacer (0);
 
 	{
-		video_control (add_label_to_sizer (_audio_sizer, _audio_panel, "Audio Gain"));
+		add_label_to_sizer (grid, _audio_panel, _("Audio Gain"));
 		wxBoxSizer* s = new wxBoxSizer (wxHORIZONTAL);
 		_audio_gain = new wxSpinCtrl (_audio_panel);
-		s->Add (video_control (_audio_gain), 1);
-		video_control (add_label_to_sizer (s, _audio_panel, "dB"));
+		s->Add (_audio_gain, 1);
+		add_label_to_sizer (s, _audio_panel, _("dB"));
 		_audio_gain_calculate_button = new wxButton (_audio_panel, wxID_ANY, _("Calculate..."));
-		video_control (_audio_gain_calculate_button);
 		s->Add (_audio_gain_calculate_button, 1, wxEXPAND);
-		_audio_sizer->Add (s);
+		grid->Add (s);
 	}
 
 	{
-		video_control (add_label_to_sizer (_audio_sizer, _audio_panel, "Audio Delay"));
+		add_label_to_sizer (grid, _audio_panel, _("Audio Delay"));
 		wxBoxSizer* s = new wxBoxSizer (wxHORIZONTAL);
 		_audio_delay = new wxSpinCtrl (_audio_panel);
-		s->Add (video_control (_audio_delay), 1);
-		video_control (add_label_to_sizer (s, _audio_panel, "ms"));
-		_audio_sizer->Add (s);
-	}
-
-	{
-		_use_content_audio = new wxRadioButton (_audio_panel, wxID_ANY, _("Use content's audio"), wxDefaultPosition, wxDefaultSize, wxRB_GROUP);
-		_audio_sizer->Add (video_control (_use_content_audio));
-		wxBoxSizer* s = new wxBoxSizer (wxHORIZONTAL);
-		_audio_stream = new wxComboBox (_audio_panel, wxID_ANY, wxT (""), wxDefaultPosition, wxDefaultSize, 0, 0, wxCB_READONLY);
-		s->Add (video_control (_audio_stream), 1);
-		_audio = new wxStaticText (_audio_panel, wxID_ANY, wxT (""));
-		s->Add (video_control (_audio), 1, wxALIGN_CENTER_VERTICAL | wxLEFT, 8);
-		_audio_sizer->Add (s, 1, wxEXPAND);
-	}
-
-	_use_external_audio = new wxRadioButton (_audio_panel, wxID_ANY, _("Use external audio"));
-	_audio_sizer->Add (_use_external_audio);
-	_audio_sizer->AddSpacer (0);
-
-	assert (MAX_AUDIO_CHANNELS == 6);
-
-	char const * channels[] = {
-		"Left",
-		"Right",
-		"Centre",
-		"Lfe (sub)",
-		"Left surround",
-		"Right surround"
-	};
-
-	for (int i = 0; i < MAX_AUDIO_CHANNELS; ++i) {
-		add_label_to_sizer (_audio_sizer, _audio_panel, channels[i]);
-		_external_audio[i] = new wxFilePickerCtrl (_audio_panel, wxID_ANY, wxT (""), wxT ("Select Audio File"), wxT ("*.wav"));
-		_audio_sizer->Add (_external_audio[i], 1, wxEXPAND);
+		s->Add (_audio_delay, 1);
+		/// TRANSLATORS: this is an abbreviation for milliseconds, the unit of time
+		add_label_to_sizer (s, _audio_panel, _("ms"));
+		grid->Add (s);
 	}
 
+        {
+                add_label_to_sizer (grid, _audio_panel, _("Audio Stream"));
+                wxBoxSizer* s = new wxBoxSizer (wxHORIZONTAL);
+                _ffmpeg_audio_stream = new wxChoice (_audio_panel, wxID_ANY);
+                s->Add (_ffmpeg_audio_stream, 1);
+                _audio = new wxStaticText (_audio_panel, wxID_ANY, wxT (""));
+                s->Add (_audio, 1, wxALIGN_CENTER_VERTICAL | wxLEFT, 8);
+                grid->Add (s, 1, wxEXPAND);
+        }
+
+	_audio_mapping = new AudioMappingView (_audio_panel);
+	_audio_sizer->Add (_audio_mapping, 1, wxEXPAND | wxALL, 6);
+	
 	_audio_gain->SetRange (-60, 60);
 	_audio_delay->SetRange (-1000, 1000);
 }
@@ -344,29 +419,33 @@ void
 FilmEditor::make_subtitle_panel ()
 {
 	_subtitle_panel = new wxPanel (_notebook);
-	_subtitle_sizer = new wxFlexGridSizer (2, 4, 4);
-	wxBoxSizer* pad = new wxBoxSizer (wxVERTICAL);
-	pad->Add (_subtitle_sizer, 0, wxALL, 8);
-	_subtitle_panel->SetSizer (pad);
-
-	_with_subtitles = new wxCheckBox (_subtitle_panel, wxID_ANY, wxT("With Subtitles"));
-	video_control (_with_subtitles);
-	_subtitle_sizer->Add (_with_subtitles, 1);
+	_subtitle_sizer = new wxBoxSizer (wxVERTICAL);
+	_subtitle_panel->SetSizer (_subtitle_sizer);
+	wxFlexGridSizer* grid = new wxFlexGridSizer (2, 4, 4);
+	_subtitle_sizer->Add (grid, 0, wxALL, 8);
+
+	_with_subtitles = new wxCheckBox (_subtitle_panel, wxID_ANY, _("With Subtitles"));
+	grid->Add (_with_subtitles, 1);
 	
-	_subtitle_stream = new wxComboBox (_subtitle_panel, wxID_ANY, wxT (""), wxDefaultPosition, wxDefaultSize, 0, 0, wxCB_READONLY);
-	_subtitle_sizer->Add (video_control (_subtitle_stream));
+	_ffmpeg_subtitle_stream = new wxChoice (_subtitle_panel, wxID_ANY);
+	grid->Add (_ffmpeg_subtitle_stream);
 
-	video_control (add_label_to_sizer (_subtitle_sizer, _subtitle_panel, "Subtitle Offset"));
-	_subtitle_offset = new wxSpinCtrl (_subtitle_panel);
-	_subtitle_sizer->Add (video_control (_subtitle_offset), 1);
+	{
+		add_label_to_sizer (grid, _subtitle_panel, _("Subtitle Offset"));
+		wxBoxSizer* s = new wxBoxSizer (wxHORIZONTAL);
+		_subtitle_offset = new wxSpinCtrl (_subtitle_panel);
+		s->Add (_subtitle_offset);
+		add_label_to_sizer (s, _subtitle_panel, _("pixels"));
+		grid->Add (s);
+	}
 
 	{
-		video_control (add_label_to_sizer (_subtitle_sizer, _subtitle_panel, "Subtitle Scale"));
+		add_label_to_sizer (grid, _subtitle_panel, _("Subtitle Scale"));
 		wxBoxSizer* s = new wxBoxSizer (wxHORIZONTAL);
 		_subtitle_scale = new wxSpinCtrl (_subtitle_panel);
-		s->Add (video_control (_subtitle_scale));
-		video_control (add_label_to_sizer (s, _subtitle_panel, "%"));
-		_subtitle_sizer->Add (s);
+		s->Add (_subtitle_scale);
+		add_label_to_sizer (s, _subtitle_panel, _("%"));
+		grid->Add (s);
 	}
 
 	_subtitle_offset->SetRange (-1024, 1024);
@@ -417,41 +496,25 @@ FilmEditor::bottom_crop_changed (wxCommandEvent &)
 	_film->set_bottom_crop (_bottom_crop->GetValue ());
 }
 
-/** Called when the content filename has been changed */
 void
-FilmEditor::content_changed (wxCommandEvent &)
+FilmEditor::trust_content_headers_changed (wxCommandEvent &)
 {
 	if (!_film) {
 		return;
 	}
 
-	try {
-		_film->set_content (wx_to_std (_content->GetPath ()));
-	} catch (std::exception& e) {
-		_content->SetPath (std_to_wx (_film->directory ()));
-		error_dialog (this, String::compose ("Could not set content: %1", e.what ()));
-	}
-}
-
-void
-FilmEditor::trust_content_header_changed (wxCommandEvent &)
-{
-	if (!_film) {
-		return;
-	}
-
-	_film->set_trust_content_header (_trust_content_header->GetValue ());
+	_film->set_trust_content_headers (_trust_content_headers->GetValue ());
 }
 
 /** Called when the DCP A/B switch has been toggled */
 void
-FilmEditor::dcp_ab_toggled (wxCommandEvent &)
+FilmEditor::ab_toggled (wxCommandEvent &)
 {
 	if (!_film) {
 		return;
 	}
 	
-	_film->set_dcp_ab (_dcp_ab->GetValue ());
+	_film->set_ab (_ab->GetValue ());
 }
 
 /** Called when the name widget has been changed */
@@ -485,6 +548,40 @@ FilmEditor::subtitle_scale_changed (wxCommandEvent &)
 	_film->set_subtitle_scale (_subtitle_scale->GetValue() / 100.0);
 }
 
+void
+FilmEditor::colour_lut_changed (wxCommandEvent &)
+{
+	if (!_film) {
+		return;
+	}
+	
+	_film->set_colour_lut (_colour_lut->GetSelection ());
+}
+
+void
+FilmEditor::j2k_bandwidth_changed (wxCommandEvent &)
+{
+	if (!_film) {
+		return;
+	}
+	
+	_film->set_j2k_bandwidth (_j2k_bandwidth->GetValue() * 1e6);
+}
+
+void
+FilmEditor::dcp_frame_rate_changed (wxCommandEvent &)
+{
+	if (!_film) {
+		return;
+	}
+
+	_film->set_dcp_frame_rate (
+		boost::lexical_cast<int> (
+			wx_to_std (_dcp_frame_rate->GetString (_dcp_frame_rate->GetSelection ()))
+			)
+		);
+}
+
 
 /** Called when the metadata stored in the Film object has changed;
  *  so that we can update the GUI.
@@ -505,43 +602,25 @@ FilmEditor::film_changed (Film::Property p)
 	case Film::NONE:
 		break;
 	case Film::CONTENT:
-		checked_set (_content, _film->content ());
-		setup_visibility ();
+		setup_content ();
 		setup_formats ();
+		setup_format ();
 		setup_subtitle_control_sensitivity ();
 		setup_streams ();
+		setup_show_audio_sensitivity ();
 		break;
-	case Film::TRUST_CONTENT_HEADER:
-		checked_set (_trust_content_header, _film->trust_content_header ());
-		break;
-	case Film::SUBTITLE_STREAMS:
-		setup_subtitle_control_sensitivity ();
-		setup_streams ();
-		break;
-	case Film::CONTENT_AUDIO_STREAMS:
-		setup_streams ();
+	case Film::TRUST_CONTENT_HEADERS:
+		checked_set (_trust_content_headers, _film->trust_content_headers ());
 		break;
 	case Film::FORMAT:
-	{
-		int n = 0;
-		vector<Format const *>::iterator i = _formats.begin ();
-		while (i != _formats.end() && *i != _film->format ()) {
-			++i;
-			++n;
-		}
-		if (i == _formats.end()) {
-			checked_set (_format, -1);
-		} else {
-			checked_set (_format, n);
-		}
-		_dcp_name->SetLabel (std_to_wx (_film->dcp_name ()));
+		setup_format ();
 		break;
-	}
 	case Film::CROP:
 		checked_set (_left_crop, _film->crop().left);
 		checked_set (_right_crop, _film->crop().right);
 		checked_set (_top_crop, _film->crop().top);
 		checked_set (_bottom_crop, _film->crop().bottom);
+		setup_scaling_description ();
 		break;
 	case Film::FILTERS:
 	{
@@ -557,48 +636,23 @@ FilmEditor::film_changed (Film::Property p)
 	}
 	case Film::NAME:
 		checked_set (_name, _film->name());
-		_film->set_dci_date_today ();
-		_dcp_name->SetLabel (std_to_wx (_film->dcp_name ()));
-		break;
-	case Film::FRAMES_PER_SECOND:
-		s << fixed << setprecision(2) << _film->frames_per_second();
-		_frames_per_second->SetLabel (std_to_wx (s.str ()));
-		break;
-	case Film::SIZE:
-		if (_film->size().width == 0 && _film->size().height == 0) {
-			_original_size->SetLabel (wxT (""));
-		} else {
-			s << _film->size().width << " x " << _film->size().height;
-			_original_size->SetLabel (std_to_wx (s.str ()));
-		}
-		break;
-	case Film::LENGTH:
-		if (_film->frames_per_second() > 0 && _film->length()) {
-			s << _film->length().get() << " frames; " << seconds_to_hms (_film->length().get() / _film->frames_per_second());
-		} else if (_film->length()) {
-			s << _film->length().get() << " frames";
-		} 
-		_length->SetLabel (std_to_wx (s.str ()));
-		if (_film->length()) {
-			_dcp_trim_start->SetRange (0, _film->length().get());
-			_dcp_trim_end->SetRange (0, _film->length().get());
-		}
+		setup_dcp_name ();
 		break;
 	case Film::DCP_CONTENT_TYPE:
 		checked_set (_dcp_content_type, DCPContentType::as_index (_film->dcp_content_type ()));
-		_dcp_name->SetLabel (std_to_wx (_film->dcp_name ()));
+		setup_dcp_name ();
 		break;
-	case Film::DCP_AB:
-		checked_set (_dcp_ab, _film->dcp_ab ());
+	case Film::AB:
+		checked_set (_ab, _film->ab ());
 		break;
 	case Film::SCALER:
 		checked_set (_scaler, Scaler::as_index (_film->scaler ()));
 		break;
-	case Film::DCP_TRIM_START:
-		checked_set (_dcp_trim_start, _film->dcp_trim_start());
+	case Film::TRIM_START:
+		checked_set (_trim_start, _film->trim_start());
 		break;
-	case Film::DCP_TRIM_END:
-		checked_set (_dcp_trim_end, _film->dcp_trim_end());
+	case Film::TRIM_END:
+		checked_set (_trim_end, _film->trim_end());
 		break;
 	case Film::AUDIO_GAIN:
 		checked_set (_audio_gain, _film->audio_gain ());
@@ -606,15 +660,10 @@ FilmEditor::film_changed (Film::Property p)
 	case Film::AUDIO_DELAY:
 		checked_set (_audio_delay, _film->audio_delay ());
 		break;
-	case Film::STILL_DURATION:
-		checked_set (_still_duration, _film->still_duration ());
-		break;
 	case Film::WITH_SUBTITLES:
 		checked_set (_with_subtitles, _film->with_subtitles ());
-		_subtitle_stream->Enable (_film->with_subtitles ());
-		_subtitle_scale->Enable (_film->with_subtitles ());
-		_subtitle_offset->Enable (_film->with_subtitles ());
-		_dcp_name->SetLabel (std_to_wx (_film->dcp_name ()));
+		setup_subtitle_control_sensitivity ();
+		setup_dcp_name ();
 		break;
 	case Film::SUBTITLE_OFFSET:
 		checked_set (_subtitle_offset, _film->subtitle_offset ());
@@ -622,43 +671,138 @@ FilmEditor::film_changed (Film::Property p)
 	case Film::SUBTITLE_SCALE:
 		checked_set (_subtitle_scale, _film->subtitle_scale() * 100);
 		break;
+	case Film::COLOUR_LUT:
+		checked_set (_colour_lut, _film->colour_lut ());
+		break;
+	case Film::J2K_BANDWIDTH:
+		checked_set (_j2k_bandwidth, double (_film->j2k_bandwidth()) / 1e6);
+		break;
 	case Film::USE_DCI_NAME:
 		checked_set (_use_dci_name, _film->use_dci_name ());
-		_dcp_name->SetLabel (std_to_wx (_film->dcp_name ()));
+		setup_dcp_name ();
 		break;
 	case Film::DCI_METADATA:
-		_dcp_name->SetLabel (std_to_wx (_film->dcp_name ()));
+		setup_dcp_name ();
 		break;
-	case Film::CONTENT_AUDIO_STREAM:
-		if (_film->content_audio_stream()) {
-			checked_set (_audio_stream, _film->content_audio_stream()->to_string());
+	case Film::DCP_FRAME_RATE:
+		for (unsigned int i = 0; i < _dcp_frame_rate->GetCount(); ++i) {
+			if (wx_to_std (_dcp_frame_rate->GetString(i)) == boost::lexical_cast<string> (_film->dcp_frame_rate())) {
+				if (_dcp_frame_rate->GetSelection() != int(i)) {
+					_dcp_frame_rate->SetSelection (i);
+					break;
+				}
+			}
 		}
-		_dcp_name->SetLabel (std_to_wx (_film->dcp_name ()));
-		setup_audio_details ();
-		setup_audio_control_sensitivity ();
+
+		if (_film->video_frame_rate()) {
+			_best_dcp_frame_rate->Enable (best_dcp_frame_rate (_film->video_frame_rate ()) != _film->dcp_frame_rate ());
+		} else {
+			_best_dcp_frame_rate->Disable ();
+		}
+		setup_frame_rate_description ();
 		break;
-	case Film::USE_CONTENT_AUDIO:
-		checked_set (_use_content_audio, _film->use_content_audio());
-		checked_set (_use_external_audio, !_film->use_content_audio());
-		_dcp_name->SetLabel (std_to_wx (_film->dcp_name ()));
-		setup_audio_details ();
-		setup_audio_control_sensitivity ();
+	case Film::AUDIO_MAPPING:
+		_audio_mapping->set_mapping (_film->audio_mapping ());
 		break;
-	case Film::SUBTITLE_STREAM:
-		if (_film->subtitle_stream()) {
-			checked_set (_subtitle_stream, _film->subtitle_stream()->to_string());
+	}
+}
+
+void
+FilmEditor::film_content_changed (weak_ptr<Content> content, int property)
+{
+	if (!_film) {
+		/* We call this method ourselves (as well as using it as a signal handler)
+		   so _film can be 0.
+		*/
+		return;
+	}
+		
+	if (property == FFmpegContentProperty::SUBTITLE_STREAMS) {
+		setup_subtitle_control_sensitivity ();
+		setup_streams ();
+	} else if (property == FFmpegContentProperty::AUDIO_STREAMS) {
+		setup_streams ();
+		setup_show_audio_sensitivity ();
+	} else if (property == VideoContentProperty::VIDEO_LENGTH) {
+		setup_length ();
+		boost::shared_ptr<Content> c = content.lock ();
+		if (c && c == selected_content()) {
+			setup_content_information ();
 		}
-		break;
-	case Film::EXTERNAL_AUDIO:
-	{
-		vector<string> a = _film->external_audio ();
-		for (size_t i = 0; i < a.size() && i < MAX_AUDIO_CHANNELS; ++i) {
-			checked_set (_external_audio[i], a[i]);
+	} else if (property == FFmpegContentProperty::AUDIO_STREAM) {
+		if (_film->ffmpeg_audio_stream()) {
+			checked_set (_ffmpeg_audio_stream, boost::lexical_cast<string> (_film->ffmpeg_audio_stream()->id));
 		}
+		setup_dcp_name ();
 		setup_audio_details ();
-		break;
+		setup_show_audio_sensitivity ();
+	} else if (property == FFmpegContentProperty::SUBTITLE_STREAM) {
+		if (_film->ffmpeg_subtitle_stream()) {
+			checked_set (_ffmpeg_subtitle_stream, boost::lexical_cast<string> (_film->ffmpeg_subtitle_stream()->id));
+		}
 	}
+}
+
+void
+FilmEditor::setup_format ()
+{
+	int n = 0;
+	vector<Format const *>::iterator i = _formats.begin ();
+	while (i != _formats.end() && *i != _film->format ()) {
+		++i;
+		++n;
+	}
+	
+	if (i == _formats.end()) {
+		checked_set (_format, -1);
+	} else {
+		checked_set (_format, n);
+	}
+	
+	setup_dcp_name ();
+	setup_scaling_description ();
+}	
+
+void
+FilmEditor::setup_length ()
+{
+	stringstream s;
+	if (_film->video_frame_rate() > 0 && _film->video_length()) {
+		s << _film->video_length() << " "
+		  << wx_to_std (_("frames")) << "; " << seconds_to_hms (_film->video_length() / _film->video_frame_rate());
+	} else if (_film->video_length()) {
+		s << _film->video_length() << " "
+		  << wx_to_std (_("frames"));
+	} 
+	_length->SetLabel (std_to_wx (s.str ()));
+	if (_film->video_length()) {
+		_trim_start->SetRange (0, _film->video_length());
+		_trim_end->SetRange (0, _film->video_length());
 	}
+}	
+
+void
+FilmEditor::setup_frame_rate_description ()
+{
+	wxString d;
+	if (_film->video_frame_rate()) {
+		d << std_to_wx (FrameRateConversion (_film->video_frame_rate(), _film->dcp_frame_rate()).description);
+#ifdef HAVE_SWRESAMPLE
+		if (_film->audio_frame_rate() != _film->target_audio_sample_rate ()) {
+			d << wxString::Format (
+				_("Audio will be resampled from %dHz to %dHz\n"),
+				_film->audio_frame_rate(),
+				_film->target_audio_sample_rate()
+				);
+		} else {
+			d << "\n";
+		}
+#else
+		d << "\n";
+#endif		
+	}
+
+	_frame_rate_description->SetLabel (d);
 }
 
 /** Called when the format widget has been changed */
@@ -694,12 +838,17 @@ FilmEditor::dcp_content_type_changed (wxCommandEvent &)
 void
 FilmEditor::set_film (shared_ptr<Film> f)
 {
-	_film = f;
-
 	set_things_sensitive (_film != 0);
 
+	if (_film == f) {
+		return;
+	}
+	
+	_film = f;
+
 	if (_film) {
 		_film->Changed.connect (bind (&FilmEditor::film_changed, this, _1));
+		_film->ContentChanged.connect (bind (&FilmEditor::film_content_changed, this, _1, _2));
 	}
 
 	if (_film) {
@@ -707,34 +856,38 @@ FilmEditor::set_film (shared_ptr<Film> f)
 	} else {
 		FileChanged ("");
 	}
+
+	if (_audio_dialog) {
+		_audio_dialog->set_film (_film);
+	}
 	
 	film_changed (Film::NAME);
 	film_changed (Film::USE_DCI_NAME);
 	film_changed (Film::CONTENT);
-	film_changed (Film::TRUST_CONTENT_HEADER);
+	film_changed (Film::TRUST_CONTENT_HEADERS);
 	film_changed (Film::DCP_CONTENT_TYPE);
 	film_changed (Film::FORMAT);
 	film_changed (Film::CROP);
 	film_changed (Film::FILTERS);
 	film_changed (Film::SCALER);
-	film_changed (Film::DCP_TRIM_START);
-	film_changed (Film::DCP_TRIM_END);
-	film_changed (Film::DCP_AB);
-	film_changed (Film::CONTENT_AUDIO_STREAM);
-	film_changed (Film::EXTERNAL_AUDIO);
-	film_changed (Film::USE_CONTENT_AUDIO);
+	film_changed (Film::TRIM_START);
+	film_changed (Film::TRIM_END);
+	film_changed (Film::AB);
 	film_changed (Film::AUDIO_GAIN);
 	film_changed (Film::AUDIO_DELAY);
-	film_changed (Film::STILL_DURATION);
 	film_changed (Film::WITH_SUBTITLES);
 	film_changed (Film::SUBTITLE_OFFSET);
 	film_changed (Film::SUBTITLE_SCALE);
+	film_changed (Film::COLOUR_LUT);
+	film_changed (Film::J2K_BANDWIDTH);
 	film_changed (Film::DCI_METADATA);
-	film_changed (Film::SIZE);
-	film_changed (Film::LENGTH);
-	film_changed (Film::CONTENT_AUDIO_STREAMS);
-	film_changed (Film::SUBTITLE_STREAMS);
-	film_changed (Film::FRAMES_PER_SECOND);
+	film_changed (Film::DCP_FRAME_RATE);
+	film_changed (Film::AUDIO_MAPPING);
+
+	film_content_changed (boost::shared_ptr<Content> (), FFmpegContentProperty::SUBTITLE_STREAMS);
+	film_content_changed (boost::shared_ptr<Content> (), FFmpegContentProperty::SUBTITLE_STREAM);
+	film_content_changed (boost::shared_ptr<Content> (), FFmpegContentProperty::AUDIO_STREAMS);
+	film_content_changed (boost::shared_ptr<Content> (), FFmpegContentProperty::AUDIO_STREAM);
 }
 
 /** Updates the sensitivity of lots of widgets to a given value.
@@ -750,25 +903,30 @@ FilmEditor::set_things_sensitive (bool s)
 	_edit_dci_button->Enable (s);
 	_format->Enable (s);
 	_content->Enable (s);
-	_trust_content_header->Enable (s);
+	_trust_content_headers->Enable (s);
+	_content->Enable (s);
 	_left_crop->Enable (s);
 	_right_crop->Enable (s);
 	_top_crop->Enable (s);
 	_bottom_crop->Enable (s);
 	_filters_button->Enable (s);
 	_scaler->Enable (s);
-	_audio_stream->Enable (s);
+	_ffmpeg_audio_stream->Enable (s);
 	_dcp_content_type->Enable (s);
-	_dcp_trim_start->Enable (s);
-	_dcp_trim_end->Enable (s);
-	_dcp_ab->Enable (s);
+	_dcp_frame_rate->Enable (s);
+	_trim_start->Enable (s);
+	_trim_end->Enable (s);
+	_ab->Enable (s);
+	_colour_lut->Enable (s);
+	_j2k_bandwidth->Enable (s);
 	_audio_gain->Enable (s);
 	_audio_gain_calculate_button->Enable (s);
+	_show_audio->Enable (s);
 	_audio_delay->Enable (s);
-	_still_duration->Enable (s);
 
 	setup_subtitle_control_sensitivity ();
-	setup_audio_control_sensitivity ();
+	setup_show_audio_sensitivity ();
+	setup_content_button_sensitivity ();
 }
 
 /** Called when the `Edit filters' button has been clicked */
@@ -815,37 +973,9 @@ FilmEditor::audio_delay_changed (wxCommandEvent &)
 	_film->set_audio_delay (_audio_delay->GetValue ());
 }
 
-wxControl *
-FilmEditor::video_control (wxControl* c)
-{
-	_video_controls.push_back (c);
-	return c;
-}
-
-wxControl *
-FilmEditor::still_control (wxControl* c)
-{
-	_still_controls.push_back (c);
-	return c;
-}
-
 void
-FilmEditor::setup_visibility ()
+FilmEditor::setup_notebook_size ()
 {
-	ContentType c = VIDEO;
-
-	if (_film) {
-		c = _film->content_type ();
-	}
-
-	for (list<wxControl*>::iterator i = _video_controls.begin(); i != _video_controls.end(); ++i) {
-		(*i)->Show (c == VIDEO);
-	}
-
-	for (list<wxControl*>::iterator i = _still_controls.begin(); i != _still_controls.end(); ++i) {
-		(*i)->Show (c == STILL);
-	}
-
 	_notebook->InvalidateBestSize ();
 	
 	_film_sizer->Layout ();
@@ -862,33 +992,23 @@ FilmEditor::setup_visibility ()
 }
 
 void
-FilmEditor::still_duration_changed (wxCommandEvent &)
-{
-	if (!_film) {
-		return;
-	}
-
-	_film->set_still_duration (_still_duration->GetValue ());
-}
-
-void
-FilmEditor::dcp_trim_start_changed (wxCommandEvent &)
+FilmEditor::trim_start_changed (wxCommandEvent &)
 {
 	if (!_film) {
 		return;
 	}
 
-	_film->set_dcp_trim_start (_dcp_trim_start->GetValue ());
+	_film->set_trim_start (_trim_start->GetValue ());
 }
 
 void
-FilmEditor::dcp_trim_end_changed (wxCommandEvent &)
+FilmEditor::trim_end_changed (wxCommandEvent &)
 {
 	if (!_film) {
 		return;
 	}
 
-	_film->set_dcp_trim_end (_dcp_trim_end->GetValue ());
+	_film->set_trim_end (_trim_end->GetValue ());
 }
 
 void
@@ -921,22 +1041,7 @@ FilmEditor::audio_gain_calculate_button_clicked (wxCommandEvent &)
 void
 FilmEditor::setup_formats ()
 {
-	ContentType c = VIDEO;
-
-	if (_film) {
-		c = _film->content_type ();
-	}
-	
-	_formats.clear ();
-
-	vector<Format const *> fmt = Format::all ();
-	for (vector<Format const *>::iterator i = fmt.begin(); i != fmt.end(); ++i) {
-		if (c == VIDEO && dynamic_cast<FixedFormat const *> (*i)) {
-			_formats.push_back (*i);
-		} else if (c == STILL && dynamic_cast<VariableFormat const *> (*i)) {
-			_formats.push_back (*i);
-		}
-	}
+	_formats = Format::all ();
 
 	_format->Clear ();
 	for (vector<Format const *>::iterator i = _formats.begin(); i != _formats.end(); ++i) {
@@ -961,28 +1066,19 @@ FilmEditor::setup_subtitle_control_sensitivity ()
 {
 	bool h = false;
 	if (_generally_sensitive && _film) {
-		h = !_film->subtitle_streams().empty();
+		h = !_film->ffmpeg_subtitle_streams().empty();
 	}
 	
 	_with_subtitles->Enable (h);
-	_subtitle_stream->Enable (h);
-	_subtitle_offset->Enable (h);
-	_subtitle_scale->Enable (h);
-}
-
-void
-FilmEditor::setup_audio_control_sensitivity ()
-{
-	_use_content_audio->Enable (_generally_sensitive);
-	_use_external_audio->Enable (_generally_sensitive);
-	
-	bool const source = _generally_sensitive && _use_content_audio->GetValue();
-	bool const external = _generally_sensitive && _use_external_audio->GetValue();
 
-	_audio_stream->Enable (source);
-	for (int i = 0; i < MAX_AUDIO_CHANNELS; ++i) {
-		_external_audio[i]->Enable (external);
+	bool j = false;
+	if (_film) {
+		j = _film->with_subtitles ();
 	}
+	
+	_ffmpeg_subtitle_stream->Enable (j);
+	_subtitle_offset->Enable (j);
+	_subtitle_scale->Enable (j);
 }
 
 void
@@ -1002,78 +1098,97 @@ FilmEditor::edit_dci_button_clicked (wxCommandEvent &)
 		return;
 	}
 
-	DCINameDialog* d = new DCINameDialog (this, _film);
+	DCIMetadataDialog* d = new DCIMetadataDialog (this, _film->dci_metadata ());
 	d->ShowModal ();
+	_film->set_dci_metadata (d->dci_metadata ());
 	d->Destroy ();
 }
 
 void
 FilmEditor::setup_streams ()
 {
-	_audio_stream->Clear ();
-	vector<shared_ptr<AudioStream> > a = _film->content_audio_streams ();
-	for (vector<shared_ptr<AudioStream> >::iterator i = a.begin(); i != a.end(); ++i) {
-		shared_ptr<FFmpegAudioStream> ffa = dynamic_pointer_cast<FFmpegAudioStream> (*i);
-		assert (ffa);
-		_audio_stream->Append (std_to_wx (ffa->name()), new wxStringClientData (std_to_wx (ffa->to_string ())));
+	if (!_film) {
+		return;
+	}
+	
+	_ffmpeg_audio_stream->Clear ();
+	vector<FFmpegAudioStream> a = _film->ffmpeg_audio_streams ();
+	for (vector<FFmpegAudioStream>::iterator i = a.begin(); i != a.end(); ++i) {
+		_ffmpeg_audio_stream->Append (std_to_wx (i->name), new wxStringClientData (std_to_wx (boost::lexical_cast<string> (i->id))));
 	}
 	
-	if (_film->use_content_audio() && _film->audio_stream()) {
-		checked_set (_audio_stream, _film->audio_stream()->to_string());
+	if (_film->ffmpeg_audio_stream()) {
+		checked_set (_ffmpeg_audio_stream, boost::lexical_cast<string> (_film->ffmpeg_audio_stream()->id));
 	}
 
-	_subtitle_stream->Clear ();
-	vector<shared_ptr<SubtitleStream> > s = _film->subtitle_streams ();
-	for (vector<shared_ptr<SubtitleStream> >::iterator i = s.begin(); i != s.end(); ++i) {
-		_subtitle_stream->Append (std_to_wx ((*i)->name()), new wxStringClientData (std_to_wx ((*i)->to_string ())));
+	_ffmpeg_subtitle_stream->Clear ();
+	vector<FFmpegSubtitleStream> s = _film->ffmpeg_subtitle_streams ();
+	for (vector<FFmpegSubtitleStream>::iterator i = s.begin(); i != s.end(); ++i) {
+		_ffmpeg_subtitle_stream->Append (std_to_wx (i->name), new wxStringClientData (std_to_wx (boost::lexical_cast<string> (i->id))));
 	}
-	if (_film->subtitle_stream()) {
-		checked_set (_subtitle_stream, _film->subtitle_stream()->to_string());
+	
+	if (_film->ffmpeg_subtitle_stream()) {
+		checked_set (_ffmpeg_subtitle_stream, boost::lexical_cast<string> (_film->ffmpeg_subtitle_stream()->id));
 	} else {
-		_subtitle_stream->SetValue (wxT (""));
+		_ffmpeg_subtitle_stream->SetSelection (wxNOT_FOUND);
 	}
 }
 
 void
-FilmEditor::audio_stream_changed (wxCommandEvent &)
+FilmEditor::ffmpeg_audio_stream_changed (wxCommandEvent &)
 {
 	if (!_film) {
 		return;
 	}
 
-	_film->set_content_audio_stream (
-		audio_stream_factory (
-			string_client_data (_audio_stream->GetClientObject (_audio_stream->GetSelection ())),
-			Film::state_version
-			)
-		);
+	vector<FFmpegAudioStream> a = _film->ffmpeg_audio_streams ();
+	vector<FFmpegAudioStream>::iterator i = a.begin ();
+	string const s = string_client_data (_ffmpeg_audio_stream->GetClientObject (_ffmpeg_audio_stream->GetSelection ()));
+	while (i != a.end() && lexical_cast<string> (i->id) != s) {
+		++i;
+	}
+
+	if (i != a.end ()) {
+		_film->set_ffmpeg_audio_stream (*i);
+	}
 }
 
 void
-FilmEditor::subtitle_stream_changed (wxCommandEvent &)
+FilmEditor::ffmpeg_subtitle_stream_changed (wxCommandEvent &)
 {
 	if (!_film) {
 		return;
 	}
 
-	_film->set_subtitle_stream (
-		subtitle_stream_factory (
-			string_client_data (_subtitle_stream->GetClientObject (_subtitle_stream->GetSelection ())),
-			Film::state_version
-			)
-		);
+	vector<FFmpegSubtitleStream> a = _film->ffmpeg_subtitle_streams ();
+	vector<FFmpegSubtitleStream>::iterator i = a.begin ();
+	string const s = string_client_data (_ffmpeg_subtitle_stream->GetClientObject (_ffmpeg_subtitle_stream->GetSelection ()));
+	while (i != a.end() && lexical_cast<string> (i->id) != s) {
+		++i;
+	}
+
+	if (i != a.end ()) {
+		_film->set_ffmpeg_subtitle_stream (*i);
+	}
 }
 
 void
 FilmEditor::setup_audio_details ()
 {
-	if (!_film->audio_stream()) {
+	if (!_film->ffmpeg_audio_stream()) {
 		_audio->SetLabel (wxT (""));
 	} else {
-		stringstream s;
-		s << _film->audio_stream()->channels () << " channels, " << _film->audio_stream()->sample_rate() << "Hz";
-		_audio->SetLabel (std_to_wx (s.str ()));
+		wxString s;
+		if (_film->audio_channels() == 1) {
+			s << _("1 channel");
+		} else {
+			s << _film->audio_channels() << " " << _("channels");
+		}
+		s << ", " << _film->audio_frame_rate() << _("Hz");
+		_audio->SetLabel (s);
 	}
+
+	setup_notebook_size ();
 }
 
 void
@@ -1083,18 +1198,254 @@ FilmEditor::active_jobs_changed (bool a)
 }
 
 void
-FilmEditor::use_audio_changed (wxCommandEvent &)
+FilmEditor::setup_dcp_name ()
+{
+	string s = _film->dcp_name (true);
+	if (s.length() > 28) {
+		_dcp_name->SetLabel (std_to_wx (s.substr (0, 28)) + N_("..."));
+		_dcp_name->SetToolTip (std_to_wx (s));
+	} else {
+		_dcp_name->SetLabel (std_to_wx (s));
+	}
+}
+
+void
+FilmEditor::show_audio_clicked (wxCommandEvent &)
+{
+	if (_audio_dialog) {
+		_audio_dialog->Destroy ();
+		_audio_dialog = 0;
+	}
+	
+	_audio_dialog = new AudioDialog (this);
+	_audio_dialog->Show ();
+	_audio_dialog->set_film (_film);
+}
+
+void
+FilmEditor::best_dcp_frame_rate_clicked (wxCommandEvent &)
+{
+	if (!_film) {
+		return;
+	}
+	
+	_film->set_dcp_frame_rate (best_dcp_frame_rate (_film->video_frame_rate ()));
+}
+
+void
+FilmEditor::setup_show_audio_sensitivity ()
+{
+	_show_audio->Enable (_film && _film->has_audio ());
+}
+
+void
+FilmEditor::setup_content ()
+{
+	string selected_summary;
+	int const s = _content->GetNextItem (-1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
+	if (s != -1) {
+		selected_summary = wx_to_std (_content->GetItemText (s));
+	}
+	
+	_content->DeleteAllItems ();
+
+	ContentList content = _film->content ();
+	for (ContentList::iterator i = content.begin(); i != content.end(); ++i) {
+		int const t = _content->GetItemCount ();
+		_content->InsertItem (t, std_to_wx ((*i)->summary ()));
+		if ((*i)->summary() == selected_summary) {
+			_content->SetItemState (t, wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED);
+		}
+	}
+
+	if (selected_summary.empty () && !content.empty ()) {
+		/* Select the first item of content if non was selected before */
+		_content->SetItemState (0, wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED);
+	}
+}
+
+void
+FilmEditor::content_add_clicked (wxCommandEvent &)
+{
+	wxFileDialog* d = new wxFileDialog (this);
+	int const r = d->ShowModal ();
+	d->Destroy ();
+
+	if (r != wxID_OK) {
+		return;
+	}
+
+	boost::filesystem::path p (wx_to_std (d->GetPath()));
+
+	if (ImageMagickContent::valid_file (p)) {
+		_film->add_content (shared_ptr<ImageMagickContent> (new ImageMagickContent (p)));
+	} else if (SndfileContent::valid_file (p)) {
+		_film->add_content (shared_ptr<SndfileContent> (new SndfileContent (p)));
+	} else {
+		_film->add_content (shared_ptr<FFmpegContent> (new FFmpegContent (p)));
+	}
+	
+}
+
+void
+FilmEditor::content_remove_clicked (wxCommandEvent &)
+{
+	shared_ptr<Content> c = selected_content ();
+	if (c) {
+		_film->remove_content (c);
+	}
+}
+
+void
+FilmEditor::content_activated (wxListEvent& ev)
+{
+	ContentList c = _film->content ();
+	assert (ev.GetIndex() >= 0 && size_t (ev.GetIndex()) < c.size ());
+
+	edit_content (c[ev.GetIndex()]);
+}
+
+void
+FilmEditor::content_edit_clicked (wxCommandEvent &)
+{
+	shared_ptr<Content> c = selected_content ();
+	if (!c) {
+		return;
+	}
+
+	edit_content (c);
+}
+
+void
+FilmEditor::edit_content (shared_ptr<Content> c)
+{
+	shared_ptr<ImageMagickContent> im = dynamic_pointer_cast<ImageMagickContent> (c);
+	if (im) {
+		ImageMagickContentDialog* d = new ImageMagickContentDialog (this, im);
+		d->ShowModal ();
+		d->Destroy ();
+
+		im->set_video_length (d->video_length() * 24);
+	}
+}
+
+void
+FilmEditor::content_earlier_clicked (wxCommandEvent &)
+{
+	shared_ptr<Content> c = selected_content ();
+	if (c) {
+		_film->move_content_earlier (c);
+	}
+}
+
+void
+FilmEditor::content_later_clicked (wxCommandEvent &)
 {
-	_film->set_use_content_audio (_use_content_audio->GetValue());
+	shared_ptr<Content> c = selected_content ();
+	if (c) {
+		_film->move_content_later (c);
+	}
 }
 
 void
-FilmEditor::external_audio_changed (wxCommandEvent &)
+FilmEditor::content_selection_changed (wxListEvent &)
+{
+        setup_content_button_sensitivity ();
+	setup_content_information ();
+}
+
+void
+FilmEditor::setup_content_information ()
+{
+	shared_ptr<Content> c = selected_content ();
+	if (!c) {
+		_content_information->SetValue (wxT (""));
+		return;
+	}
+
+	_content_information->SetValue (std_to_wx (c->information ()));
+}
+
+void
+FilmEditor::setup_content_button_sensitivity ()
+{
+        _content_add->Enable (_generally_sensitive);
+
+	shared_ptr<Content> selection = selected_content ();
+
+        _content_edit->Enable (selection && _generally_sensitive && dynamic_pointer_cast<ImageMagickContent> (selection));
+        _content_remove->Enable (selection && _generally_sensitive);
+        _content_earlier->Enable (selection && _generally_sensitive);
+        _content_later->Enable (selection && _generally_sensitive);
+}
+
+shared_ptr<Content>
+FilmEditor::selected_content ()
 {
-	vector<string> a;
-	for (int i = 0; i < MAX_AUDIO_CHANNELS; ++i) {
-		a.push_back (wx_to_std (_external_audio[i]->GetPath()));
+	int const s = _content->GetNextItem (-1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
+	if (s == -1) {
+		return shared_ptr<Content> ();
+	}
+
+	ContentList c = _film->content ();
+	if (s < 0 || size_t (s) >= c.size ()) {
+		return shared_ptr<Content> ();
+	}
+	
+	return c[s];
+}
+
+void
+FilmEditor::setup_scaling_description ()
+{
+	wxString d;
+
+	int lines = 0;
+
+	d << wxString::Format (
+		_("Original video is %dx%d (%.2f:1)\n"),
+		_film->video_size().width, _film->video_size().height,
+		float (_film->video_size().width) / _film->video_size().height
+		);
+
+	++lines;
+
+	Crop const crop = _film->crop ();
+	if (crop.left || crop.right || crop.top || crop.bottom) {
+		libdcp::Size const cropped = _film->cropped_size (_film->video_size ());
+		d << wxString::Format (
+			_("Cropped to %dx%d (%.2f:1)\n"),
+			cropped.width, cropped.height,
+			float (cropped.width) / cropped.height
+			);
+		++lines;
+	}
+
+	Format const * format = _film->format ();
+	if (format) {
+		int const padding = format->dcp_padding (_film);
+		libdcp::Size scaled = format->dcp_size ();
+		scaled.width -= padding * 2;
+		d << wxString::Format (
+			_("Scaled to %dx%d (%.2f:1)\n"),
+			scaled.width, scaled.height,
+			float (scaled.width) / scaled.height
+			);
+		++lines;
+
+		if (padding) {
+			d << wxString::Format (
+				_("Padded with black to %dx%d (%.2f:1)\n"),
+				format->dcp_size().width, format->dcp_size().height,
+				float (format->dcp_size().width) / format->dcp_size().height
+				);
+			++lines;
+		}
+	}
+
+	for (int i = lines; i < 4; ++i) {
+		d << " \n";
 	}
 
-	_film->set_external_audio (a);
+	_scaling_description->SetLabel (d);
 }