src/tools/dcpomatic.cc

   1 /*
   2     Copyright (C) 2012-2021 Carl Hetherington <cth@carlh.net>
   3
   4     This file is part of DCP-o-matic.
   5
   6     DCP-o-matic is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     DCP-o-matic is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with DCP-o-matic.  If not, see <http://www.gnu.org/licenses/>.
  18
  19 */
  20
  21
  22 /** @file  src/tools/dcpomatic.cc
  23  *  @brief The main DCP-o-matic GUI.
  24  */
  25
  26
  27 #include "wx/about_dialog.h"
  28 #include "wx/content_panel.h"
  29 #include "wx/dcp_referencing_dialog.h"
  30 #include "wx/dkdm_dialog.h"
  31 #include "wx/export_subtitles_dialog.h"
  32 #include "wx/export_video_file_dialog.h"
  33 #include "wx/film_editor.h"
  34 #include "wx/film_name_location_dialog.h"
  35 #include "wx/film_viewer.h"
  36 #include "wx/focus_manager.h"
  37 #include "wx/full_config_dialog.h"
  38 #include "wx/hints_dialog.h"
  39 #include "wx/html_dialog.h"
  40 #include "wx/file_dialog.h"
  41 #include "wx/i18n_hook.h"
  42 #include "wx/id.h"
  43 #include "wx/job_manager_view.h"
  44 #include "wx/kdm_dialog.h"
  45 #include "wx/load_config_from_zip_dialog.h"
  46 #include "wx/nag_dialog.h"
  47 #include "wx/paste_dialog.h"
  48 #include "wx/recreate_chain_dialog.h"
  49 #include "wx/report_problem_dialog.h"
  50 #include "wx/save_template_dialog.h"
  51 #include "wx/self_dkdm_dialog.h"
  52 #include "wx/send_i18n_dialog.h"
  53 #include "wx/servers_list_dialog.h"
  54 #include "wx/standard_controls.h"
  55 #include "wx/system_information_dialog.h"
  56 #include "wx/templates_dialog.h"
  57 #include "wx/update_dialog.h"
  58 #include "wx/video_waveform_dialog.h"
  59 #include "wx/wx_signal_manager.h"
  60 #include "wx/wx_util.h"
  61 #include "wx/wx_variant.h"
  62 #include "lib/analytics.h"
  63 #include "lib/audio_content.h"
  64 #include "lib/check_content_job.h"
  65 #include "lib/cinema.h"
  66 #include "lib/compose.hpp"
  67 #include "lib/config.h"
  68 #include "lib/constants.h"
  69 #include "lib/content.h"
  70 #include "lib/content_factory.h"
  71 #include "lib/cross.h"
  72 #include "lib/cross.h"
  73 #include "lib/dcp_content.h"
  74 #include "lib/dcpomatic_log.h"
  75 #include "lib/dcpomatic_socket.h"
  76 #include "lib/dkdm_wrapper.h"
  77 #include "lib/email.h"
  78 #include "lib/encode_server_finder.h"
  79 #include "lib/exceptions.h"
  80 #include "lib/ffmpeg_film_encoder.h"
  81 #include "lib/film.h"
  82 #include "lib/font_config.h"
  83 #ifdef DCPOMATIC_GROK
  84 #include "lib/grok/context.h"
  85 #endif
  86 #include "lib/hints.h"
  87 #include "lib/job_manager.h"
  88 #include "lib/kdm_with_metadata.h"
  89 #include "lib/log.h"
  90 #include "lib/make_dcp.h"
  91 #include "lib/release_notes.h"
  92 #include "lib/screen.h"
  93 #include "lib/send_kdm_email_job.h"
  94 #include "lib/signal_manager.h"
  95 #include "lib/subtitle_film_encoder.h"
  96 #include "lib/text_content.h"
  97 #include "lib/transcode_job.h"
  98 #include "lib/unzipper.h"
  99 #include "lib/update_checker.h"
 100 #include "lib/variant.h"
 101 #include "lib/version.h"
 102 #include "lib/video_content.h"
 103 #include <dcp/exceptions.h>
 104 #include <dcp/filesystem.h>
 105 #include <dcp/raw_convert.h>
 106 #include <dcp/warnings.h>
 107 LIBDCP_DISABLE_WARNINGS
 108 #include <wx/cmdline.h>
 109 #include <wx/generic/aboutdlgg.h>
 110 #include <wx/preferences.h>
 111 #include <wx/splash.h>
 112 #include <wx/stdpaths.h>
 113 #include <wx/wxhtml.h>
 114 LIBDCP_ENABLE_WARNINGS
 115 #ifdef __WXGTK__
 116 #include <X11/Xlib.h>
 117 #endif
 118 #ifdef __WXMSW__
 119 #include <shellapi.h>
 120 #endif
 121 #include <boost/algorithm/string.hpp>
 122 #include <boost/filesystem.hpp>
 123 #include <iostream>
 124 #include <fstream>
 125 /* This is OK as it's only used with DCPOMATIC_WINDOWS */
 126 #include <sstream>
 127
 128 #ifdef check
 129 #undef check
 130 #endif
 131
 132
 133 using std::cout;
 134 using std::dynamic_pointer_cast;
 135 using std::exception;
 136 using std::function;
 137 using std::list;
 138 using std::make_pair;
 139 using std::make_shared;
 140 using std::map;
 141 using std::shared_ptr;
 142 using std::string;
 143 using std::vector;
 144 using std::wcout;
 145 using boost::optional;
 146 using boost::is_any_of;
 147 using boost::algorithm::find;
 148 #if BOOST_VERSION >= 106100
 149 using namespace boost::placeholders;
 150 #endif
 151 using dcp::raw_convert;
 152
 153
 154 class FilmChangedClosingDialog
 155 {
 156 public:
 157         explicit FilmChangedClosingDialog (string name)
 158                 : _dialog(
 159                         nullptr,
 160                         wxString::Format(_("Save changes to film \"%s\" before closing?"), std_to_wx (name).data()),
 161                         /// TRANSLATORS: this is the heading for a dialog box, which tells the user that the current
 162                         /// project (Film) has been changed since it was last saved.
 163                         _("Film changed"),
 164                         wxYES_NO | wxCANCEL | wxYES_DEFAULT | wxICON_QUESTION
 165                         )
 166         {
 167                 _dialog.SetYesNoCancelLabels(
 168                         _("Save film and close"), _("Close without saving film"), _("Don't close")
 169                         );
 170         }
 171
 172         int run ()
 173         {
 174                 return _dialog.ShowModal();
 175         }
 176
 177 private:
 178         wxMessageDialog _dialog;
 179 };
 180
 181
 182 class FilmChangedDuplicatingDialog
 183 {
 184 public:
 185         explicit FilmChangedDuplicatingDialog (string name)
 186                 : _dialog(
 187                         nullptr,
 188                         wxString::Format(_("Save changes to film \"%s\" before duplicating?"), std_to_wx (name).data()),
 189                         /// TRANSLATORS: this is the heading for a dialog box, which tells the user that the current
 190                         /// project (Film) has been changed since it was last saved.
 191                         _("Film changed"),
 192                         wxYES_NO | wxCANCEL | wxYES_DEFAULT | wxICON_QUESTION
 193                         )
 194         {
 195                 _dialog.SetYesNoCancelLabels(
 196                         _("Save film and duplicate"), _("Duplicate without saving film"), _("Don't duplicate")
 197                         );
 198         }
 199
 200         int run ()
 201         {
 202                 return _dialog.ShowModal();
 203         }
 204
 205 private:
 206         wxMessageDialog _dialog;
 207 };
 208
 209
 210 #define ALWAYS                        0x0
 211 #define NEEDS_FILM                    0x1
 212 #define NOT_DURING_DCP_CREATION       0x2
 213 #define NEEDS_CPL                     0x4
 214 #define NEEDS_SINGLE_SELECTED_CONTENT 0x8
 215 #define NEEDS_SELECTED_CONTENT        0x10
 216 #define NEEDS_SELECTED_VIDEO_CONTENT  0x20
 217 #define NEEDS_CLIPBOARD               0x40
 218 #define NEEDS_ENCRYPTION              0x80
 219 #define NEEDS_DCP_CONTENT             0x100
 220
 221
 222 map<wxMenuItem*, int> menu_items;
 223
 224 enum {
 225         ID_file_new = DCPOMATIC_MAIN_MENU,
 226         ID_file_open,
 227         ID_file_save,
 228         ID_file_save_as_template,
 229         ID_file_duplicate,
 230         ID_file_duplicate_and_open,
 231         ID_file_history,
 232         /* Allow spare IDs after _history for the recent files list */
 233         ID_file_close = DCPOMATIC_MAIN_MENU + 100,
 234         ID_edit_copy,
 235         ID_edit_paste,
 236         ID_edit_select_all,
 237         ID_jobs_make_dcp,
 238         ID_jobs_make_dcp_batch,
 239         ID_jobs_make_kdms,
 240         ID_jobs_make_dkdms,
 241         ID_jobs_make_self_dkdm,
 242         ID_jobs_export_video_file,
 243         ID_jobs_export_subtitles,
 244         ID_jobs_send_dcp_to_tms,
 245         ID_jobs_show_dcp,
 246         ID_jobs_open_dcp_in_player,
 247         ID_view_closed_captions,
 248         ID_view_video_waveform,
 249         ID_tools_version_file,
 250         ID_tools_hints,
 251         ID_tools_encoding_servers,
 252         ID_tools_manage_templates,
 253         ID_tools_check_for_updates,
 254         ID_tools_send_translations,
 255         ID_tools_system_information,
 256         ID_tools_restore_default_preferences,
 257         ID_tools_export_preferences,
 258         ID_tools_import_preferences,
 259         ID_help_report_a_problem,
 260         /* IDs for shortcuts (with no associated menu item) */
 261         ID_add_file,
 262         ID_remove,
 263         ID_start_stop,
 264         ID_timeline,
 265         ID_back_frame,
 266         ID_forward_frame
 267 };
 268
 269
 270 class LimitedFrameSplitter : public wxSplitterWindow
 271 {
 272 public:
 273         LimitedFrameSplitter(wxWindow* parent)
 274                 : wxSplitterWindow(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxSP_NOBORDER | wxSP_3DSASH | wxSP_LIVE_UPDATE)
 275         {
 276                 /* This value doesn't really mean much but we just want to stop double-click on the
 277                    divider from shrinking the left panel.
 278                    */
 279                 SetMinimumPaneSize(64);
 280
 281                 Bind(wxEVT_SIZE, boost::bind(&LimitedFrameSplitter::sized, this, _1));
 282         }
 283
 284         bool OnSashPositionChange(int new_position) override
 285         {
 286                 /* Try to stop the left bit of the splitter getting too small */
 287                 auto const ok = new_position > _left_panel_minimum_size;
 288                 if (ok) {
 289                         Config::instance()->set_main_divider_sash_position(new_position);
 290                 }
 291                 return ok;
 292         }
 293
 294 private:
 295         void sized(wxSizeEvent& ev)
 296         {
 297                 if (GetSize().GetWidth() > _left_panel_minimum_size && GetSashPosition() < _left_panel_minimum_size) {
 298                         /* The window is now fairly big but the left panel is small; this happens when the DCP-o-matic window
 299                          * is shrunk and then made larger again.  Try to set a sensible left panel size in this case.
 300                          */
 301                         SetSashPosition(Config::instance()->main_divider_sash_position().get_value_or(_left_panel_minimum_size));
 302                 }
 303
 304                 ev.Skip();
 305         }
 306
 307         int const _left_panel_minimum_size = 200;
 308 };
 309
 310
 311 class DOMFrame : public wxFrame
 312 {
 313 public:
 314         explicit DOMFrame (wxString const& title)
 315                 : wxFrame (nullptr, -1, title)
 316                 /* Use a panel as the only child of the Frame so that we avoid
 317                    the dark-grey background on Windows.
 318                 */
 319                 , _splitter(new LimitedFrameSplitter(this))
 320                 , _right_panel(new wxPanel(_splitter, wxID_ANY))
 321                 , _film_viewer(_right_panel)
 322         {
 323
 324                 auto bar = new wxMenuBar;
 325                 setup_menu (bar);
 326                 SetMenuBar (bar);
 327
 328 #ifdef DCPOMATIC_WINDOWS
 329                 SetIcon (wxIcon (std_to_wx ("id")));
 330 #endif
 331
 332                 _config_changed_connection = Config::instance()->Changed.connect(boost::bind(&DOMFrame::config_changed, this, _1));
 333                 config_changed(Config::OTHER);
 334
 335                 _analytics_message_connection = Analytics::instance()->Message.connect(boost::bind(&DOMFrame::analytics_message, this, _1, _2));
 336
 337                 Bind (wxEVT_MENU, boost::bind (&DOMFrame::file_new, this),                ID_file_new);
 338                 Bind (wxEVT_MENU, boost::bind (&DOMFrame::file_open, this),               ID_file_open);
 339                 Bind (wxEVT_MENU, boost::bind (&DOMFrame::file_save, this),               ID_file_save);
 340                 Bind (wxEVT_MENU, boost::bind (&DOMFrame::file_save_as_template, this),   ID_file_save_as_template);
 341                 Bind (wxEVT_MENU, boost::bind (&DOMFrame::file_duplicate, this),          ID_file_duplicate);
 342                 Bind (wxEVT_MENU, boost::bind (&DOMFrame::file_duplicate_and_open, this), ID_file_duplicate_and_open);
 343                 Bind (wxEVT_MENU, boost::bind (&DOMFrame::file_close, this),              ID_file_close);
 344                 Bind (wxEVT_MENU, boost::bind (&DOMFrame::file_history, this, _1),        ID_file_history, ID_file_history + HISTORY_SIZE);
 345                 Bind (wxEVT_MENU, boost::bind (&DOMFrame::file_exit, this),               wxID_EXIT);
 346                 Bind (wxEVT_MENU, boost::bind (&DOMFrame::edit_copy, this),               ID_edit_copy);
 347                 Bind (wxEVT_MENU, boost::bind (&DOMFrame::edit_paste, this),              ID_edit_paste);
 348                 Bind (wxEVT_MENU, boost::bind (&DOMFrame::edit_select_all, this),         ID_edit_select_all);
 349                 Bind (wxEVT_MENU, boost::bind (&DOMFrame::edit_preferences, this),        wxID_PREFERENCES);
 350                 Bind (wxEVT_MENU, boost::bind (&DOMFrame::jobs_make_dcp, this),           ID_jobs_make_dcp);
 351                 Bind (wxEVT_MENU, boost::bind (&DOMFrame::jobs_make_kdms, this),          ID_jobs_make_kdms);
 352                 Bind (wxEVT_MENU, boost::bind (&DOMFrame::jobs_make_dkdms, this),         ID_jobs_make_dkdms);
 353                 Bind (wxEVT_MENU, boost::bind (&DOMFrame::jobs_make_dcp_batch, this),     ID_jobs_make_dcp_batch);
 354                 Bind (wxEVT_MENU, boost::bind (&DOMFrame::jobs_make_self_dkdm, this),     ID_jobs_make_self_dkdm);
 355                 Bind (wxEVT_MENU, boost::bind (&DOMFrame::jobs_export_video_file, this),  ID_jobs_export_video_file);
 356                 Bind (wxEVT_MENU, boost::bind (&DOMFrame::jobs_export_subtitles, this),   ID_jobs_export_subtitles);
 357                 Bind (wxEVT_MENU, boost::bind (&DOMFrame::jobs_send_dcp_to_tms, this),    ID_jobs_send_dcp_to_tms);
 358                 Bind (wxEVT_MENU, boost::bind (&DOMFrame::jobs_show_dcp, this),           ID_jobs_show_dcp);
 359                 Bind (wxEVT_MENU, boost::bind (&DOMFrame::jobs_open_dcp_in_player, this), ID_jobs_open_dcp_in_player);
 360                 Bind (wxEVT_MENU, boost::bind (&DOMFrame::view_closed_captions, this),    ID_view_closed_captions);
 361                 Bind (wxEVT_MENU, boost::bind (&DOMFrame::view_video_waveform, this),     ID_view_video_waveform);
 362                 Bind (wxEVT_MENU, boost::bind (&DOMFrame::tools_version_file, this),      ID_tools_version_file);
 363                 Bind (wxEVT_MENU, boost::bind (&DOMFrame::tools_hints, this),             ID_tools_hints);
 364                 Bind (wxEVT_MENU, boost::bind (&DOMFrame::tools_encoding_servers, this),  ID_tools_encoding_servers);
 365                 Bind (wxEVT_MENU, boost::bind (&DOMFrame::tools_manage_templates, this),  ID_tools_manage_templates);
 366                 Bind (wxEVT_MENU, boost::bind (&DOMFrame::tools_check_for_updates, this), ID_tools_check_for_updates);
 367                 Bind (wxEVT_MENU, boost::bind (&DOMFrame::tools_send_translations, this), ID_tools_send_translations);
 368                 Bind (wxEVT_MENU, boost::bind (&DOMFrame::tools_system_information, this),ID_tools_system_information);
 369                 Bind (wxEVT_MENU, boost::bind (&DOMFrame::tools_restore_default_preferences, this), ID_tools_restore_default_preferences);
 370                 Bind (wxEVT_MENU, boost::bind (&DOMFrame::tools_export_preferences, this), ID_tools_export_preferences);
 371                 Bind (wxEVT_MENU, boost::bind (&DOMFrame::tools_import_preferences, this), ID_tools_import_preferences);
 372                 Bind (wxEVT_MENU, boost::bind (&DOMFrame::help_about, this),              wxID_ABOUT);
 373                 Bind (wxEVT_MENU, boost::bind (&DOMFrame::help_report_a_problem, this),   ID_help_report_a_problem);
 374
 375                 Bind (wxEVT_CLOSE_WINDOW, boost::bind (&DOMFrame::close, this, _1));
 376                 Bind (wxEVT_SHOW, boost::bind (&DOMFrame::show, this, _1));
 377
 378                 auto left_panel = new wxPanel(_splitter, wxID_ANY);
 379
 380                 _film_editor = new FilmEditor(left_panel, _film_viewer);
 381
 382                 auto left_sizer = new wxBoxSizer(wxHORIZONTAL);
 383                 left_sizer->Add(_film_editor, 1, wxEXPAND);
 384
 385                 left_panel->SetSizerAndFit(left_sizer);
 386
 387                 _controls = new StandardControls(_right_panel, _film_viewer, true);
 388                 _controls->set_film(_film_viewer.film());
 389                 auto job_manager_view = new JobManagerView(_right_panel, false);
 390
 391                 auto right_sizer = new wxBoxSizer (wxVERTICAL);
 392                 right_sizer->Add(_film_viewer.panel(), 2, wxEXPAND | wxALL, 6);
 393                 right_sizer->Add (_controls, 0, wxEXPAND | wxALL, 6);
 394                 right_sizer->Add (job_manager_view, 1, wxEXPAND | wxALL, 6);
 395
 396                 _right_panel->SetSizer(right_sizer);
 397
 398                 _splitter->SplitVertically(left_panel, _right_panel, Config::instance()->main_divider_sash_position().get_value_or(left_panel->GetSize().GetWidth() + 8));
 399
 400                 set_menu_sensitivity ();
 401
 402                 _film_editor->content_panel()->SelectionChanged.connect (boost::bind (&DOMFrame::set_menu_sensitivity, this));
 403                 set_title ();
 404
 405                 JobManager::instance()->ActiveJobsChanged.connect(boost::bind(&DOMFrame::active_jobs_changed, this));
 406
 407                 UpdateChecker::instance()->StateChanged.connect(boost::bind(&DOMFrame::update_checker_state_changed, this));
 408
 409                 FocusManager::instance()->SetFocus.connect (boost::bind (&DOMFrame::remove_accelerators, this));
 410                 FocusManager::instance()->KillFocus.connect (boost::bind (&DOMFrame::add_accelerators, this));
 411                 add_accelerators ();
 412         }
 413
 414         void add_accelerators ()
 415         {
 416 #ifdef __WXOSX__
 417                 int accelerators = 7;
 418 #else
 419                 int accelerators = 6;
 420 #endif
 421                 std::vector<wxAcceleratorEntry> accel(accelerators);
 422                 /* [Shortcut] Ctrl+A:Add file(s) to the film */
 423                 accel[0].Set (wxACCEL_CTRL, static_cast<int>('A'), ID_add_file);
 424                 /* [Shortcut] Delete:Remove selected content from film */
 425                 accel[1].Set (wxACCEL_NORMAL, WXK_DELETE, ID_remove);
 426                 /* [Shortcut] Space:Start/stop playback */
 427                 accel[2].Set (wxACCEL_NORMAL, WXK_SPACE, ID_start_stop);
 428                 /* [Shortcut] Ctrl+T:Open timeline window */
 429                 accel[3].Set (wxACCEL_CTRL, static_cast<int>('T'), ID_timeline);
 430                 /* [Shortcut] Left arrow:Move back one frame */
 431                 accel[4].Set (wxACCEL_NORMAL, WXK_LEFT, ID_back_frame);
 432                 /* [Shortcut] Right arrow:Move forward one frame */
 433                 accel[5].Set (wxACCEL_NORMAL, WXK_RIGHT, ID_forward_frame);
 434 #ifdef __WXOSX__
 435                 accel[6].Set (wxACCEL_CTRL, static_cast<int>('W'), ID_file_close);
 436 #endif
 437                 Bind (wxEVT_MENU, boost::bind (&ContentPanel::add_file_clicked, _film_editor->content_panel()), ID_add_file);
 438                 Bind (wxEVT_MENU, boost::bind (&DOMFrame::remove_clicked, this, _1), ID_remove);
 439                 Bind (wxEVT_MENU, boost::bind (&DOMFrame::start_stop_pressed, this), ID_start_stop);
 440                 Bind (wxEVT_MENU, boost::bind (&DOMFrame::timeline_pressed, this), ID_timeline);
 441                 Bind (wxEVT_MENU, boost::bind (&DOMFrame::back_frame, this), ID_back_frame);
 442                 Bind (wxEVT_MENU, boost::bind (&DOMFrame::forward_frame, this), ID_forward_frame);
 443                 wxAcceleratorTable accel_table (accelerators, accel.data());
 444                 SetAcceleratorTable (accel_table);
 445         }
 446
 447         void remove_accelerators ()
 448         {
 449                 SetAcceleratorTable (wxAcceleratorTable ());
 450         }
 451
 452         void remove_clicked (wxCommandEvent& ev)
 453         {
 454                 if (_film_editor->content_panel()->remove_clicked (true)) {
 455                         ev.Skip ();
 456                 }
 457         }
 458
 459         void new_film (boost::filesystem::path path, optional<string> template_name)
 460         {
 461                 auto film = make_shared<Film>(path);
 462                 if (template_name) {
 463                         film->use_template (template_name.get());
 464                 }
 465                 film->set_name (path.filename().generic_string());
 466                 film->write_metadata ();
 467                 set_film (film);
 468         }
 469
 470         void load_film (boost::filesystem::path file)
 471         try
 472         {
 473                 auto film = make_shared<Film>(file);
 474                 auto const notes = film->read_metadata ();
 475                 film->read_ui_state();
 476
 477                 if (film->state_version() == 4) {
 478                         error_dialog (
 479                                 0,
 480                                 _("This film was created with an old version of DVD-o-matic and may not load correctly "
 481                                   "in this version.  Please check the film's settings carefully.")
 482                                 );
 483                 }
 484
 485                 for (auto i: notes) {
 486                         error_dialog (0, std_to_wx(i));
 487                 }
 488
 489                 set_film (film);
 490
 491                 JobManager::instance()->add(make_shared<CheckContentJob>(film));
 492         }
 493         catch (FileNotFoundError& e) {
 494                 auto const dir = e.file().parent_path();
 495                 if (dcp::filesystem::exists(dir / "ASSETMAP") || dcp::filesystem::exists(dir / "ASSETMAP.xml")) {
 496                         error_dialog (
 497                                 this, variant::wx::insert_dcpomatic(_("Could not open this folder as a %s project.")),
 498                                 variant::wx::insert_dcpomatic(
 499                                         _("It looks like you are trying to open a DCP.  File -> Open is for loading %s projects, not DCPs.  "
 500                                           "To import a DCP, create a new project with File -> New and then click the \"Add DCP...\" button."))
 501                                 );
 502                 } else {
 503                         auto const p = std_to_wx(file.string ());
 504                         error_dialog (this, wxString::Format(_("Could not open film at %s"), p.data()), std_to_wx(e.what()));
 505                 }
 506
 507         } catch (std::exception& e) {
 508                 auto const p = std_to_wx (file.string());
 509                 error_dialog (this, wxString::Format(_("Could not open film at %s"), p.data()), std_to_wx(e.what()));
 510         }
 511
 512         void set_film (shared_ptr<Film> film)
 513         {
 514                 _film = film;
 515                 _film_viewer.set_film(_film);
 516                 _film_editor->set_film(_film);
 517                 _controls->set_film (_film);
 518                 _video_waveform_dialog.reset();
 519                 set_menu_sensitivity ();
 520                 if (_film && _film->directory()) {
 521                         Config::instance()->add_to_history (_film->directory().get());
 522                 }
 523                 if (_film) {
 524                         _film->Change.connect (boost::bind (&DOMFrame::film_change, this, _1));
 525                         _film->Message.connect (boost::bind(&DOMFrame::film_message, this, _1));
 526                         _film->DirtyChange.connect (boost::bind(&DOMFrame::set_title, this));
 527                         dcpomatic_log = _film->log ();
 528                 }
 529                 set_title ();
 530         }
 531
 532         shared_ptr<Film> film () const {
 533                 return _film;
 534         }
 535
 536 private:
 537
 538         void show (wxShowEvent& ev)
 539         {
 540                 if (ev.IsShown() && !_first_shown_called) {
 541                         _film_editor->first_shown ();
 542                         _first_shown_called = true;
 543                 }
 544         }
 545
 546         void film_message (string m)
 547         {
 548                 message_dialog (this, std_to_wx(m));
 549         }
 550
 551         void film_change (ChangeType type)
 552         {
 553                 if (type == ChangeType::DONE) {
 554                         set_menu_sensitivity ();
 555                 }
 556         }
 557
 558         void file_new ()
 559         {
 560                 FilmNameLocationDialog dialog(this, _("New Film"), true);
 561                 int const r = dialog.ShowModal();
 562
 563                 if (r != wxID_OK || !dialog.check_path() || !maybe_save_then_delete_film<FilmChangedClosingDialog>()) {
 564                         return;
 565                 }
 566
 567                 try {
 568                         new_film(dialog.path(), dialog.template_name());
 569                 } catch (boost::filesystem::filesystem_error& e) {
 570 #ifdef DCPOMATIC_WINDOWS
 571                         string bad_chars = "<>:\"/|?*";
 572                         string const filename = dialog.path().filename().string();
 573                         string found_bad_chars;
 574                         for (size_t i = 0; i < bad_chars.length(); ++i) {
 575                                 if (filename.find(bad_chars[i]) != string::npos && found_bad_chars.find(bad_chars[i]) == string::npos) {
 576                                         found_bad_chars += bad_chars[i];
 577                                 }
 578                         }
 579                         wxString message = _("Could not create folder to store film.");
 580                         message += "  ";
 581                         if (!found_bad_chars.empty()) {
 582                                 message += wxString::Format (_("Try removing the %s characters from your folder name."), std_to_wx(found_bad_chars).data());
 583                         } else {
 584                                 message += variant::wx::insert_dcpomatic(_("Please check that you do not have Windows controlled folder access enabled for %s."));
 585                         }
 586                         error_dialog (this, message, std_to_wx(e.what()));
 587 #else
 588                         error_dialog (this, _("Could not create folder to store film."), std_to_wx(e.what()));
 589 #endif
 590                 }
 591         }
 592
 593         void file_open ()
 594         {
 595                 wxDirDialog dialog(
 596                         this,
 597                         _("Select film to open"),
 598                         std_to_wx (Config::instance()->default_directory_or (wx_to_std (wxStandardPaths::Get().GetDocumentsDir())).string ()),
 599                         wxDEFAULT_DIALOG_STYLE | wxDD_DIR_MUST_EXIST
 600                         );
 601
 602                 int r;
 603                 while (true) {
 604                         r = dialog.ShowModal();
 605                         if (r == wxID_OK && dialog.GetPath() == wxStandardPaths::Get().GetDocumentsDir()) {
 606                                 error_dialog (this, _("You did not select a folder.  Make sure that you select a folder before clicking Open."));
 607                         } else {
 608                                 break;
 609                         }
 610                 }
 611
 612                 if (r == wxID_OK && maybe_save_then_delete_film<FilmChangedClosingDialog>()) {
 613                         load_film(wx_to_std(dialog.GetPath()));
 614                 }
 615         }
 616
 617         void file_save ()
 618         {
 619                 try {
 620                         _film->write_metadata ();
 621                 } catch (exception& e) {
 622                         error_dialog(this, _("Could not save project."), std_to_wx(e.what()));
 623                 }
 624         }
 625
 626         void file_save_as_template ()
 627         {
 628                 SaveTemplateDialog dialog(this);
 629                 if (dialog.ShowModal() == wxID_OK) {
 630                         try {
 631                                 Config::instance()->save_template(_film, dialog.name());
 632                         } catch (exception& e) {
 633                                 error_dialog(this, _("Could not save template."), std_to_wx(e.what()));
 634                         }
 635                 }
 636         }
 637
 638         void file_duplicate ()
 639         {
 640                 FilmNameLocationDialog dialog(this, _("Duplicate Film"), false);
 641
 642                 if (dialog.ShowModal() == wxID_OK && dialog.check_path() && maybe_save_film<FilmChangedDuplicatingDialog>()) {
 643                         auto film = make_shared<Film>(dialog.path());
 644                         film->copy_from (_film);
 645                         film->set_name(dialog.path().filename().generic_string());
 646                         try {
 647                                 film->write_metadata();
 648                         } catch (exception& e) {
 649                                 error_dialog(this, _("Could not duplicate project."), std_to_wx(e.what()));
 650                         }
 651                 }
 652         }
 653
 654         void file_duplicate_and_open ()
 655         {
 656                 FilmNameLocationDialog dialog(this, _("Duplicate Film"), false);
 657
 658                 if (dialog.ShowModal() == wxID_OK && dialog.check_path() && maybe_save_film<FilmChangedDuplicatingDialog>()) {
 659                         auto film = make_shared<Film>(dialog.path());
 660                         film->copy_from (_film);
 661                         film->set_name(dialog.path().filename().generic_string());
 662                         try {
 663                                 film->write_metadata ();
 664                                 set_film (film);
 665                         } catch (exception& e) {
 666                                 error_dialog(this, _("Could not duplicate project."), std_to_wx(e.what()));
 667                         }
 668                 }
 669         }
 670
 671         void file_close ()
 672         {
 673                 if (_film && _film->dirty ()) {
 674                         FilmChangedClosingDialog dialog(_film->name());
 675                         switch (dialog.run()) {
 676                         case wxID_NO:
 677                                 /* Don't save and carry on to close */
 678                                 break;
 679                         case wxID_YES:
 680                                 /* Save and carry on to close */
 681                                 _film->write_metadata ();
 682                                 break;
 683                         case wxID_CANCEL:
 684                                 /* Stop */
 685                                 return;
 686                         }
 687                 }
 688
 689                 set_film (shared_ptr<Film>());
 690         }
 691
 692         void file_history (wxCommandEvent& event)
 693         {
 694                 auto history = Config::instance()->history ();
 695                 int n = event.GetId() - ID_file_history;
 696                 if (n >= 0 && n < static_cast<int> (history.size ()) && maybe_save_then_delete_film<FilmChangedClosingDialog>()) {
 697                         load_film (history[n]);
 698                 }
 699         }
 700
 701         void file_exit ()
 702         {
 703                 /* false here allows the close handler to veto the close request */
 704                 Close (false);
 705         }
 706
 707         void edit_copy ()
 708         {
 709                 auto const sel = _film_editor->content_panel()->selected();
 710                 if (sel.size() == 1) {
 711                         _clipboard = sel.front()->clone();
 712                 }
 713         }
 714
 715         void edit_paste ()
 716         {
 717                 if (!_clipboard) {
 718                         return;
 719                 }
 720
 721                 PasteDialog dialog(this, static_cast<bool>(_clipboard->video), static_cast<bool>(_clipboard->audio), !_clipboard->text.empty());
 722                 if (dialog.ShowModal() != wxID_OK) {
 723                         return;
 724                 }
 725
 726                 for (auto i: _film_editor->content_panel()->selected()) {
 727                         if (dialog.video() && i->video) {
 728                                 DCPOMATIC_ASSERT (_clipboard->video);
 729                                 i->video->take_settings_from (_clipboard->video);
 730                         }
 731                         if (dialog.audio() && i->audio) {
 732                                 DCPOMATIC_ASSERT (_clipboard->audio);
 733                                 i->audio->take_settings_from (_clipboard->audio);
 734                         }
 735
 736                         if (dialog.text()) {
 737                                 auto j = i->text.begin ();
 738                                 auto k = _clipboard->text.begin ();
 739                                 while (j != i->text.end() && k != _clipboard->text.end()) {
 740                                         (*j)->take_settings_from (*k);
 741                                         ++j;
 742                                         ++k;
 743                                 }
 744                         }
 745                 }
 746         }
 747
 748         void edit_select_all ()
 749         {
 750                 _film_editor->content_panel()->select_all();
 751         }
 752
 753         void edit_preferences ()
 754         {
 755                 if (!_config_dialog) {
 756                         _config_dialog = create_full_config_dialog ();
 757                 }
 758                 _config_dialog->Show (this);
 759         }
 760
 761         void tools_restore_default_preferences ()
 762         {
 763                 wxMessageDialog dialog(
 764                         nullptr,
 765                         _("Are you sure you want to restore preferences to their defaults?  This cannot be undone."),
 766                         _("Restore default preferences"),
 767                         wxYES_NO | wxYES_DEFAULT | wxICON_QUESTION
 768                         );
 769
 770                 if (dialog.ShowModal() == wxID_YES) {
 771                         Config::restore_defaults ();
 772                 }
 773         }
 774
 775         void tools_export_preferences ()
 776         {
 777                 FileDialog dialog(
 778                         this, _("Specify ZIP file"), wxT("ZIP files (*.zip)|*.zip"), wxFD_SAVE | wxFD_OVERWRITE_PROMPT, "Preferences", string("dcpomatic_config.zip")
 779                         );
 780
 781                 if (dialog.ShowModal() == wxID_OK) {
 782                         auto const path = boost::filesystem::path(wx_to_std(dialog.GetPath()));
 783                         if (boost::filesystem::exists(path)) {
 784                                 boost::system::error_code ec;
 785                                 boost::filesystem::remove(path, ec);
 786                                 if (ec) {
 787                                         error_dialog(nullptr, _("Could not remove existing preferences file"), std_to_wx(path.string()));
 788                                         return;
 789                                 }
 790                         }
 791
 792                         save_all_config_as_zip(path);
 793                 }
 794         }
 795
 796         void tools_import_preferences()
 797         {
 798                 FileDialog dialog(this, _("Specify ZIP file"), wxT("ZIP files (*.zip)|*.zip"), wxFD_OPEN, "Preferences");
 799
 800                 if (!dialog.show()) {
 801                         return;
 802                 }
 803
 804                 auto action = Config::CinemasAction::WRITE_TO_CURRENT_PATH;
 805
 806                 if (Config::zip_contains_cinemas(dialog.path()) && Config::cinemas_file_from_zip(dialog.path()) != Config::instance()->cinemas_file()) {
 807                         LoadConfigFromZIPDialog how(this, dialog.path());
 808                         if (how.ShowModal() == wxID_CANCEL) {
 809                                 return;
 810                         }
 811
 812                         action = how.action();
 813                 }
 814
 815                 Config::instance()->load_from_zip(dialog.path(), action);
 816         }
 817
 818         void jobs_make_dcp ()
 819         {
 820                 double required;
 821                 double available;
 822                 bool can_hard_link;
 823
 824                 if (!_film->should_be_enough_disk_space (required, available, can_hard_link)) {
 825                         wxString message;
 826                         if (can_hard_link) {
 827                                 message = wxString::Format (_("The DCP for this film will take up about %.1f GB, and the disk that you are using only has %.1f GB available.  Do you want to continue anyway?"), required, available);
 828                         } else {
 829                                 message = wxString::Format (_("The DCP and intermediate files for this film will take up about %.1f GB, and the disk that you are using only has %.1f GB available.  You would need half as much space if the filesystem supported hard links, but it does not.  Do you want to continue anyway?"), required, available);
 830                         }
 831                         if (!confirm_dialog (this, message)) {
 832                                 return;
 833                         }
 834                 }
 835
 836                 if (Config::instance()->show_hints_before_make_dcp()) {
 837                         HintsDialog hints(this, _film, false);
 838                         if (hints.ShowModal() == wxID_CANCEL) {
 839                                 return;
 840                         }
 841                 }
 842
 843                 if (_film->encrypted ()) {
 844                         NagDialog::maybe_nag (
 845                                 this,
 846                                 Config::NAG_ENCRYPTED_METADATA,
 847                                 _("You are making an encrypted DCP.  It will not be possible to make KDMs for this DCP unless you have copies of "
 848                                   "the <tt>metadata.xml</tt> file within the film and the metadata files within the DCP.\n\n"
 849                                   "You should ensure that these files are <span weight=\"bold\" size=\"larger\">BACKED UP</span> "
 850                                   "if you want to make KDMs for this film.")
 851                                 );
 852                 }
 853
 854                 /* Remove any existing DCP if the user agrees */
 855                 auto const dcp_dir = _film->dir (_film->dcp_name(), false);
 856                 if (dcp::filesystem::exists(dcp_dir)) {
 857                         if (!confirm_dialog (this, wxString::Format (_("Do you want to overwrite the existing DCP %s?"), std_to_wx(dcp_dir.string()).data()))) {
 858                                 return;
 859                         }
 860                         dcp::filesystem::remove_all(dcp_dir);
 861                 }
 862
 863                 try {
 864                         /* It seems to make sense to auto-save metadata here, since the make DCP may last
 865                            a long time, and crashes/power failures are moderately likely.
 866                         */
 867                         _film->write_metadata ();
 868                         make_dcp (_film, TranscodeJob::ChangedBehaviour::EXAMINE_THEN_STOP);
 869                 } catch (BadSettingError& e) {
 870                         error_dialog (this, wxString::Format (_("Bad setting for %s."), std_to_wx(e.setting()).data()), std_to_wx(e.what()));
 871                 } catch (std::exception& e) {
 872                         error_dialog (this, wxString::Format (_("Could not make DCP.")), std_to_wx(e.what()));
 873                 }
 874         }
 875
 876         void jobs_make_kdms ()
 877         {
 878                 if (!_film) {
 879                         return;
 880                 }
 881
 882                 _kdm_dialog.reset(this, _film);
 883                 _kdm_dialog->Show ();
 884         }
 885
 886         void jobs_make_dkdms ()
 887         {
 888                 if (!_film) {
 889                         return;
 890                 }
 891
 892                 _dkdm_dialog.reset(this, _film);
 893                 _dkdm_dialog->Show ();
 894         }
 895
 896         /** @return false if we succeeded, true if not */
 897         bool send_to_other_tool (int port, function<void()> start, string message)
 898         {
 899                 /* i = 0; try to connect via socket
 900                    i = 1; try again, and then try to start the tool
 901                    i = 2 onwards; try again.
 902                 */
 903                 for (int i = 0; i < 8; ++i) {
 904                         try {
 905                                 boost::asio::io_service io_service;
 906                                 boost::asio::ip::tcp::resolver resolver (io_service);
 907                                 boost::asio::ip::tcp::resolver::query query ("127.0.0.1", raw_convert<string> (port));
 908                                 boost::asio::ip::tcp::resolver::iterator endpoint_iterator = resolver.resolve (query);
 909                                 Socket socket (5);
 910                                 socket.connect (*endpoint_iterator);
 911                                 DCPOMATIC_ASSERT (_film->directory ());
 912                                 socket.write (message.length() + 1);
 913                                 socket.write ((uint8_t *) message.c_str(), message.length() + 1);
 914                                 /* OK\0 */
 915                                 uint8_t ok[3];
 916                                 socket.read (ok, 3);
 917                                 return false;
 918                         } catch (exception& e) {
 919
 920                         }
 921
 922                         if (i == 1) {
 923                                 start ();
 924                         }
 925
 926                         dcpomatic_sleep_seconds (1);
 927                 }
 928
 929                 return true;
 930         }
 931
 932         void jobs_make_dcp_batch ()
 933         {
 934                 if (!_film) {
 935                         return;
 936                 }
 937
 938                 if (Config::instance()->show_hints_before_make_dcp()) {
 939                         HintsDialog hints(this, _film, false);
 940                         if (hints.ShowModal() == wxID_CANCEL) {
 941                                 return;
 942                         }
 943                 }
 944
 945                 _film->write_metadata ();
 946
 947                 if (send_to_other_tool (BATCH_JOB_PORT, &start_batch_converter, _film->directory()->string())) {
 948 #ifdef DCPOMATIC_OSX
 949                         error_dialog (this, _("Could not start the batch converter.  You may need to download it from dcpomatic.com."));
 950 #else
 951                         error_dialog (this, _("Could not find batch converter."));
 952 #endif
 953                 }
 954         }
 955
 956         void jobs_open_dcp_in_player ()
 957         {
 958                 if (!_film) {
 959                         return;
 960                 }
 961
 962                 if (send_to_other_tool (PLAYER_PLAY_PORT, &start_player, _film->dir(_film->dcp_name(false)).string())) {
 963 #ifdef DCPOMATIC_OSX
 964                         error_dialog (this, _("Could not start the player.  You may need to download it from dcpomatic.com."));
 965 #else
 966                         error_dialog (this, _("Could not find player."));
 967 #endif
 968                 }
 969         }
 970
 971         void jobs_make_self_dkdm ()
 972         {
 973                 if (!_film) {
 974                         return;
 975                 }
 976
 977                 SelfDKDMDialog dialog(this, _film);
 978                 if (dialog.ShowModal() != wxID_OK) {
 979                         return;
 980                 }
 981
 982                 NagDialog::maybe_nag (
 983                         this,
 984                         Config::NAG_DKDM_CONFIG,
 985                         wxString::Format (
 986                                 _("You are making a DKDM which is encrypted by a private key held in"
 987                                   "\n\n<tt>%s</tt>\n\nIt is <span weight=\"bold\" size=\"larger\">VITALLY IMPORTANT</span> "
 988                                   "that you <span weight=\"bold\" size=\"larger\">BACK UP THIS FILE</span> since if it is lost "
 989                                   "your DKDMs (and the DCPs they protect) will become useless."), std_to_wx(Config::config_read_file().string()).data()
 990                                 )
 991                         );
 992
 993
 994                 dcp::LocalTime from (Config::instance()->signer_chain()->leaf().not_before());
 995                 from.add_days (1);
 996                 dcp::LocalTime to (Config::instance()->signer_chain()->leaf().not_after());
 997                 to.add_days (-1);
 998
 999                 auto signer = Config::instance()->signer_chain();
1000                 if (!signer->valid()) {
1001                         error_dialog(this, _("The certificate chain for signing is invalid"));
1002                         return;
1003                 }
1004
1005                 optional<dcp::EncryptedKDM> kdm;
1006                 try {
1007                         auto const decrypted_kdm = _film->make_kdm(dialog.cpl(), from, to);
1008                         auto const kdm = decrypted_kdm.encrypt(signer, Config::instance()->decryption_chain()->leaf(), {}, dcp::Formulation::MODIFIED_TRANSITIONAL_1, true, 0);
1009                         if (dialog.internal()) {
1010                                 auto dkdms = Config::instance()->dkdms();
1011                                 dkdms->add(make_shared<DKDM>(kdm));
1012                                 Config::instance()->changed ();
1013                         } else {
1014                                 auto path = dialog.directory() / (_film->dcp_name(false) + "_DKDM.xml");
1015                                 kdm.as_xml(path);
1016                         }
1017                 } catch (dcp::NotEncryptedError& e) {
1018                         error_dialog (this, _("CPL's content is not encrypted."));
1019                 } catch (exception& e) {
1020                         error_dialog (this, e.what ());
1021                 } catch (...) {
1022                         error_dialog (this, _("An unknown exception occurred."));
1023                 }
1024         }
1025
1026
1027         void jobs_export_video_file ()
1028         {
1029                 ExportVideoFileDialog dialog(this, _film->isdcf_name(true));
1030                 if (dialog.ShowModal() != wxID_OK) {
1031                         return;
1032                 }
1033
1034                 if (dcp::filesystem::exists(dialog.path())) {
1035                         bool ok = confirm_dialog(
1036                                         this,
1037                                         wxString::Format(_("File %s already exists.  Do you want to overwrite it?"), std_to_wx(dialog.path().string()).data())
1038                                         );
1039
1040                         if (!ok) {
1041                                 return;
1042                         }
1043                 }
1044
1045                 auto job = make_shared<TranscodeJob>(_film, TranscodeJob::ChangedBehaviour::EXAMINE_THEN_STOP);
1046                 job->set_encoder (
1047                         make_shared<FFmpegFilmEncoder>(
1048                                 _film, job, dialog.path(), dialog.format(), dialog.mixdown_to_stereo(), dialog.split_reels(), dialog.split_streams(), dialog.x264_crf())
1049                         );
1050                 JobManager::instance()->add (job);
1051         }
1052
1053
1054         void jobs_export_subtitles ()
1055         {
1056                 ExportSubtitlesDialog dialog(this, _film->reels().size(), _film->interop());
1057                 if (dialog.ShowModal() != wxID_OK) {
1058                         return;
1059                 }
1060                 auto job = make_shared<TranscodeJob>(_film, TranscodeJob::ChangedBehaviour::EXAMINE_THEN_STOP);
1061                 job->set_encoder(
1062                         make_shared<SubtitleFilmEncoder>(_film, job, dialog.path(), _film->isdcf_name(true), dialog.split_reels(), dialog.include_font())
1063                         );
1064                 JobManager::instance()->add(job);
1065         }
1066
1067
1068         void jobs_send_dcp_to_tms ()
1069         {
1070                 _film->send_dcp_to_tms ();
1071         }
1072
1073         void jobs_show_dcp ()
1074         {
1075                 DCPOMATIC_ASSERT (_film->directory ());
1076                 if (show_in_file_manager(_film->directory().get(), _film->dir(_film->dcp_name(false)))) {
1077                         error_dialog (this, _("Could not show DCP."));
1078                 }
1079         }
1080
1081         void view_closed_captions ()
1082         {
1083                 _film_viewer.show_closed_captions ();
1084         }
1085
1086         void view_video_waveform ()
1087         {
1088                 if (!_video_waveform_dialog) {
1089                         _video_waveform_dialog.reset(this, _film, _film_viewer);
1090                 }
1091
1092                 _video_waveform_dialog->Show ();
1093         }
1094
1095         void tools_system_information ()
1096         {
1097                 if (!_system_information_dialog) {
1098                         _system_information_dialog = new SystemInformationDialog (this, _film_viewer);
1099                 }
1100
1101                 _system_information_dialog->Show ();
1102         }
1103
1104         void tools_version_file()
1105         {
1106                 if (_dcp_referencing_dialog) {
1107                         _dcp_referencing_dialog->Destroy();
1108                         _dcp_referencing_dialog = nullptr;
1109                 }
1110
1111                 _dcp_referencing_dialog = new DCPReferencingDialog(this, _film);
1112                 _dcp_referencing_dialog->Show();
1113         }
1114
1115         void tools_hints ()
1116         {
1117                 if (!_hints_dialog) {
1118                         _hints_dialog = new HintsDialog (this, _film, true);
1119                 }
1120
1121                 _hints_dialog->Show ();
1122         }
1123
1124         void tools_encoding_servers ()
1125         {
1126                 if (!_servers_list_dialog) {
1127                         _servers_list_dialog = new ServersListDialog (this);
1128                 }
1129
1130                 _servers_list_dialog->Show ();
1131         }
1132
1133         void tools_manage_templates ()
1134         {
1135                 if (!_templates_dialog) {
1136                         _templates_dialog.reset(this);
1137                 }
1138
1139                 _templates_dialog->Show ();
1140         }
1141
1142         void tools_check_for_updates ()
1143         {
1144                 _update_news_requested = true;
1145                 UpdateChecker::instance()->run();
1146         }
1147
1148         void tools_send_translations ()
1149         {
1150                 SendI18NDialog dialog(this);
1151                 if (dialog.ShowModal() != wxID_OK) {
1152                         return;
1153                 }
1154
1155                 string body;
1156                 body += dialog.name() + "\n";
1157                 body += dialog.language() + "\n";
1158                 body += string(dcpomatic_version) + " " + string(dcpomatic_git_commit) + "\n";
1159                 body += "--\n";
1160                 auto translations = I18NHook::translations ();
1161                 for (auto i: translations) {
1162                         body += i.first + "\n" + i.second + "\n\n";
1163                 }
1164                 if (dialog.email().find("@") == string::npos) {
1165                         error_dialog(
1166                                 this,
1167                                 variant::wx::insert_dcpomatic(
1168                                         _("You must enter a valid email address when sending translations, "
1169                                           "otherwise the %s maintainers cannot credit you or contact you with questions.")
1170                                         )
1171                                 );
1172                 } else {
1173                         Email email(dialog.email(), { "carl@dcpomatic.com" }, variant::insert_dcpomatic("%1 translations"), body);
1174                         try {
1175                                 email.send("main.carlh.net", 2525, EmailProtocol::STARTTLS);
1176                         } catch (NetworkError& e) {
1177                                 error_dialog (this, _("Could not send translations"), std_to_wx(e.what()));
1178                         }
1179                 }
1180         }
1181
1182         void help_about ()
1183         {
1184                 AboutDialog dialog(this);
1185                 dialog.ShowModal();
1186         }
1187
1188         void help_report_a_problem ()
1189         {
1190                 ReportProblemDialog dialog(this, _film);
1191                 if (dialog.ShowModal() == wxID_OK) {
1192                         dialog.report();
1193                 }
1194         }
1195
1196         bool should_close ()
1197         {
1198                 if (!JobManager::instance()->work_to_do ()) {
1199                         return true;
1200                 }
1201
1202                 wxMessageDialog dialog(
1203                         nullptr,
1204                         _("There are unfinished jobs; are you sure you want to quit?"),
1205                         _("Unfinished jobs"),
1206                         wxYES_NO | wxYES_DEFAULT | wxICON_QUESTION
1207                         );
1208
1209                 return dialog.ShowModal() == wxID_YES;
1210         }
1211
1212         void close (wxCloseEvent& ev)
1213         {
1214                 if (!should_close ()) {
1215                         ev.Veto ();
1216                         return;
1217                 }
1218
1219                 if (_film && _film->dirty ()) {
1220                         FilmChangedClosingDialog dialog(_film->name());
1221                         switch (dialog.run()) {
1222                         case wxID_NO:
1223                                 /* Don't save and carry on to close */
1224                                 break;
1225                         case wxID_YES:
1226                                 /* Save and carry on to close */
1227                                 _film->write_metadata ();
1228                                 break;
1229                         case wxID_CANCEL:
1230                                 /* Veto the event and stop */
1231                                 ev.Veto ();
1232                                 return;
1233                         }
1234                 }
1235
1236                 /* We don't want to hear about any more configuration changes, since they
1237                    cause the File menu to be altered, which itself will be deleted around
1238                    now (without, as far as I can see, any way for us to find out).
1239                 */
1240                 _config_changed_connection.disconnect ();
1241
1242                 /* Also stop hearing about analytics-related stuff */
1243                 _analytics_message_connection.disconnect ();
1244
1245                 FontConfig::drop();
1246
1247                 ev.Skip ();
1248                 JobManager::drop ();
1249         }
1250
1251         void active_jobs_changed()
1252         {
1253                 /* ActiveJobsChanged can be called while JobManager holds a lock on its mutex, making
1254                  * the call to JobManager::get() in set_menu_sensitivity() deadlock unless we work around
1255                  * it by using an idle callback.  This feels quite unpleasant.
1256                  */
1257                 signal_manager->when_idle(boost::bind(&DOMFrame::set_menu_sensitivity, this));
1258         }
1259
1260         void set_menu_sensitivity ()
1261         {
1262                 auto jobs = JobManager::instance()->get ();
1263                 auto i = jobs.begin();
1264                 while (i != jobs.end() && (*i)->json_name() != "transcode") {
1265                         ++i;
1266                 }
1267                 bool const dcp_creation = (i != jobs.end ()) && !(*i)->finished ();
1268                 bool const have_cpl = _film && !_film->cpls().empty ();
1269                 bool const have_single_selected_content = _film_editor->content_panel()->selected().size() == 1;
1270                 bool const have_selected_content = !_film_editor->content_panel()->selected().empty();
1271                 bool const have_selected_video_content = !_film_editor->content_panel()->selected_video().empty();
1272                 vector<shared_ptr<Content>> content;
1273                 if (_film) {
1274                         content = _film->content();
1275                 }
1276                 bool const have_dcp_content = std::find_if(content.begin(), content.end(), [](shared_ptr<const Content> content) {
1277                         return static_cast<bool>(dynamic_pointer_cast<const DCPContent>(content));
1278                 }) != content.end();
1279
1280                 for (auto j: menu_items) {
1281
1282                         bool enabled = true;
1283
1284                         if ((j.second & NEEDS_FILM) && !_film) {
1285                                 enabled = false;
1286                         }
1287
1288                         if ((j.second & NOT_DURING_DCP_CREATION) && dcp_creation) {
1289                                 enabled = false;
1290                         }
1291
1292                         if ((j.second & NEEDS_CPL) && !have_cpl) {
1293                                 enabled = false;
1294                         }
1295
1296                         if ((j.second & NEEDS_SELECTED_CONTENT) && !have_selected_content) {
1297                                 enabled = false;
1298                         }
1299
1300                         if ((j.second & NEEDS_SINGLE_SELECTED_CONTENT) && !have_single_selected_content) {
1301                                 enabled = false;
1302                         }
1303
1304                         if ((j.second & NEEDS_SELECTED_VIDEO_CONTENT) && !have_selected_video_content) {
1305                                 enabled = false;
1306                         }
1307
1308                         if ((j.second & NEEDS_CLIPBOARD) && !_clipboard) {
1309                                 enabled = false;
1310                         }
1311
1312                         if ((j.second & NEEDS_ENCRYPTION) && (!_film || !_film->encrypted())) {
1313                                 enabled = false;
1314                         }
1315
1316                         if ((j.second & NEEDS_DCP_CONTENT) && !have_dcp_content) {
1317                                 enabled = false;
1318                         }
1319
1320                         j.first->Enable (enabled);
1321                 }
1322         }
1323
1324         /** @return true if the operation that called this method
1325          *  should continue, false to abort it.
1326          */
1327         template <class T>
1328         bool maybe_save_film ()
1329         {
1330                 if (!_film) {
1331                         return true;
1332                 }
1333
1334                 while (_film->dirty()) {
1335                         T dialog(_film->name());
1336                         switch (dialog.run()) {
1337                         case wxID_NO:
1338                                 return true;
1339                         case wxID_YES:
1340                                 try {
1341                                         _film->write_metadata();
1342                                         return true;
1343                                 } catch (exception& e) {
1344                                         error_dialog(this, _("Could not save project."), std_to_wx(e.what()));
1345                                         /* Go round again for another try */
1346                                 }
1347                                 break;
1348                         case wxID_CANCEL:
1349                                 return false;
1350                         }
1351                 }
1352
1353                 return true;
1354         }
1355
1356         template <class T>
1357         bool maybe_save_then_delete_film ()
1358         {
1359                 bool const r = maybe_save_film<T> ();
1360                 if (r) {
1361                         _film.reset ();
1362                 }
1363                 return r;
1364         }
1365
1366         void add_item (wxMenu* menu, wxString text, int id, int sens)
1367         {
1368                 auto item = menu->Append (id, text);
1369                 menu_items.insert (make_pair (item, sens));
1370         }
1371
1372         void setup_menu (wxMenuBar* m)
1373         {
1374                 _file_menu = new wxMenu;
1375                 /* [Shortcut] Ctrl+N:New film */
1376                 add_item (_file_menu, _("New...\tCtrl-N"), ID_file_new, ALWAYS);
1377                 /* [Shortcut] Ctrl+O:Open existing film */
1378                 add_item (_file_menu, _("&Open...\tCtrl-O"), ID_file_open, ALWAYS);
1379                 _file_menu->AppendSeparator ();
1380                 /* [Shortcut] Ctrl+S:Save current film */
1381                 add_item (_file_menu, _("&Save\tCtrl-S"), ID_file_save, NEEDS_FILM);
1382                 _file_menu->AppendSeparator ();
1383                 add_item (_file_menu, _("Save as &template..."), ID_file_save_as_template, NEEDS_FILM);
1384                 add_item (_file_menu, _("Duplicate..."), ID_file_duplicate, NEEDS_FILM);
1385                 add_item (_file_menu, _("Duplicate and open..."), ID_file_duplicate_and_open, NEEDS_FILM);
1386
1387                 _history_position = _file_menu->GetMenuItems().GetCount();
1388
1389                 _file_menu->AppendSeparator ();
1390                 /* [Shortcut] Ctrl+W:Close current film */
1391                 add_item (_file_menu, _("&Close\tCtrl-W"), ID_file_close, NEEDS_FILM);
1392
1393 #ifndef __WXOSX__
1394                 _file_menu->AppendSeparator ();
1395 #endif
1396
1397 #ifdef __WXOSX__
1398                 add_item (_file_menu, _("&Exit"), wxID_EXIT, ALWAYS);
1399 #else
1400                 add_item (_file_menu, _("&Quit"), wxID_EXIT, ALWAYS);
1401 #endif
1402
1403                 auto edit = new wxMenu;
1404                 /* [Shortcut] Ctrl+C:Copy settings from currently selected content */
1405                 add_item (edit, _("Copy settings\tCtrl-C"), ID_edit_copy, NEEDS_FILM | NOT_DURING_DCP_CREATION | NEEDS_SINGLE_SELECTED_CONTENT);
1406                 /* [Shortcut] Ctrl+V:Paste settings into currently selected content */
1407                 add_item (edit, _("Paste settings...\tCtrl-V"), ID_edit_paste, NEEDS_FILM | NOT_DURING_DCP_CREATION | NEEDS_SELECTED_CONTENT | NEEDS_CLIPBOARD);
1408                 edit->AppendSeparator ();
1409                 /* [Shortcut] Shift+Ctrl+A:Select all content */
1410                 add_item (edit, _("Select all\tShift-Ctrl-A"), ID_edit_select_all, NEEDS_FILM);
1411
1412 #ifdef __WXOSX__
1413                 add_item(_file_menu, _("&Preferences...\tCtrl-,"), wxID_PREFERENCES, ALWAYS);
1414 #else
1415                 edit->AppendSeparator ();
1416                 /* [Shortcut] Ctrl+P:Open preferences window */
1417                 add_item (edit, _("&Preferences...\tCtrl-P"), wxID_PREFERENCES, ALWAYS);
1418 #endif
1419
1420                 auto jobs_menu = new wxMenu;
1421                 /* [Shortcut] Ctrl+M:Make DCP */
1422                 add_item (jobs_menu, _("&Make DCP\tCtrl-M"), ID_jobs_make_dcp, NEEDS_FILM | NOT_DURING_DCP_CREATION);
1423                 /* [Shortcut] Ctrl+B:Make DCP in the batch converter*/
1424                 add_item (jobs_menu, _("Make DCP in &batch converter\tCtrl-B"), ID_jobs_make_dcp_batch, NEEDS_FILM | NOT_DURING_DCP_CREATION);
1425                 jobs_menu->AppendSeparator ();
1426                 /* [Shortcut] Ctrl+K:Make KDMs */
1427                 add_item (jobs_menu, _("Make &KDMs...\tCtrl-K"), ID_jobs_make_kdms, NEEDS_FILM);
1428                 /* [Shortcut] Ctrl+D:Make DKDMs */
1429                 add_item (jobs_menu, _("Make &DKDMs...\tCtrl-D"), ID_jobs_make_dkdms, NEEDS_FILM);
1430                 add_item(jobs_menu, variant::wx::insert_dcpomatic(_("Make DKDM for %s...")), ID_jobs_make_self_dkdm, NEEDS_FILM | NEEDS_ENCRYPTION);
1431                 jobs_menu->AppendSeparator ();
1432                 /* [Shortcut] Ctrl+E:Export video file */
1433                 add_item (jobs_menu, _("Export video file...\tCtrl-E"), ID_jobs_export_video_file, NEEDS_FILM);
1434                 add_item (jobs_menu, _("Export subtitles..."), ID_jobs_export_subtitles, NEEDS_FILM);
1435                 jobs_menu->AppendSeparator ();
1436                 add_item (jobs_menu, _("&Send DCP to TMS"), ID_jobs_send_dcp_to_tms, NEEDS_FILM | NOT_DURING_DCP_CREATION | NEEDS_CPL);
1437
1438 #if defined(DCPOMATIC_OSX)
1439                 add_item (jobs_menu, _("S&how DCP in Finder"), ID_jobs_show_dcp, NEEDS_FILM | NOT_DURING_DCP_CREATION | NEEDS_CPL);
1440 #elif defined(DCPOMATIC_WINDOWS)
1441                 add_item (jobs_menu, _("S&how DCP in Explorer"), ID_jobs_show_dcp, NEEDS_FILM | NOT_DURING_DCP_CREATION | NEEDS_CPL);
1442 #else
1443                 add_item (jobs_menu, _("S&how DCP in Files"), ID_jobs_show_dcp, NEEDS_FILM | NOT_DURING_DCP_CREATION | NEEDS_CPL);
1444 #endif
1445
1446                 add_item (jobs_menu, _("Open DCP in &player"), ID_jobs_open_dcp_in_player, NEEDS_FILM | NOT_DURING_DCP_CREATION | NEEDS_CPL);
1447
1448                 auto view = new wxMenu;
1449                 add_item (view, _("Closed captions..."), ID_view_closed_captions, NEEDS_FILM);
1450                 add_item (view, _("Video waveform..."), ID_view_video_waveform, NEEDS_FILM);
1451
1452                 auto tools = new wxMenu;
1453                 add_item (tools, _("Version File (VF)..."), ID_tools_version_file, NEEDS_FILM | NEEDS_DCP_CONTENT);
1454                 add_item (tools, _("Hints..."), ID_tools_hints, NEEDS_FILM);
1455                 add_item (tools, _("Encoding servers..."), ID_tools_encoding_servers, 0);
1456                 add_item (tools, _("Manage templates..."), ID_tools_manage_templates, 0);
1457                 add_item (tools, _("Check for updates"), ID_tools_check_for_updates, 0);
1458                 add_item (tools, _("Send translations..."), ID_tools_send_translations, 0);
1459                 add_item (tools, _("System information..."), ID_tools_system_information, 0);
1460                 tools->AppendSeparator ();
1461                 add_item (tools, _("Restore default preferences"), ID_tools_restore_default_preferences, ALWAYS);
1462                 tools->AppendSeparator ();
1463                 add_item (tools, _("Export preferences..."), ID_tools_export_preferences, ALWAYS);
1464                 add_item (tools, _("Import preferences..."), ID_tools_import_preferences, ALWAYS);
1465
1466                 wxMenu* help = new wxMenu;
1467 #ifdef __WXOSX__
1468                 add_item(help, variant::wx::insert_dcpomatic(_("About %s")), wxID_ABOUT, ALWAYS);
1469 #else
1470                 add_item (help, _("About"), wxID_ABOUT, ALWAYS);
1471 #endif
1472                 if (variant::show_report_a_problem()) {
1473                         add_item(help, _("Report a problem..."), ID_help_report_a_problem, NEEDS_FILM);
1474                 }
1475
1476                 m->Append (_file_menu, _("&File"));
1477                 m->Append (edit, _("&Edit"));
1478                 m->Append (jobs_menu, _("&Jobs"));
1479                 m->Append (view, _("&View"));
1480                 m->Append (tools, _("&Tools"));
1481                 m->Append (help, _("&Help"));
1482         }
1483
1484         void config_changed(Config::Property what)
1485         {
1486                 /* Instantly save any config changes when using the DCP-o-matic GUI */
1487                 try {
1488                         Config::instance()->write_config();
1489                 } catch (exception& e) {
1490                         error_dialog (
1491                                 this,
1492                                 wxString::Format (
1493                                         _("Could not write to config file at %s.  Your changes have not been saved."),
1494                                         std_to_wx (Config::instance()->cinemas_file().string()).data()
1495                                         )
1496                                 );
1497                 }
1498
1499                 for (int i = 0; i < _history_items; ++i) {
1500                         delete _file_menu->Remove (ID_file_history + i);
1501                 }
1502
1503                 if (_history_separator) {
1504                         _file_menu->Remove (_history_separator);
1505                 }
1506                 delete _history_separator;
1507                 _history_separator = 0;
1508
1509                 int pos = _history_position;
1510
1511                 /* Clear out non-existent history items before we re-build the menu */
1512                 Config::instance()->clean_history ();
1513                 auto history = Config::instance()->history();
1514
1515                 if (!history.empty ()) {
1516                         _history_separator = _file_menu->InsertSeparator (pos++);
1517                 }
1518
1519                 for (size_t i = 0; i < history.size(); ++i) {
1520                         string s;
1521                         if (i < 9) {
1522                                 s = String::compose ("&%1 %2", i + 1, history[i].string());
1523                         } else {
1524                                 s = history[i].string();
1525                         }
1526                         _file_menu->Insert (pos++, ID_file_history + i, std_to_wx (s));
1527                 }
1528
1529                 _history_items = history.size ();
1530
1531                 dcpomatic_log->set_types (Config::instance()->log_types());
1532
1533 #ifdef DCPOMATIC_GROK
1534                 if (what == Config::GROK) {
1535                         setup_grok_library_path();
1536                 }
1537 #else
1538                 LIBDCP_UNUSED(what);
1539 #endif
1540         }
1541
1542         void update_checker_state_changed ()
1543         {
1544                 auto uc = UpdateChecker::instance ();
1545
1546                 bool const announce =
1547                         _update_news_requested ||
1548                         (uc->stable() && Config::instance()->check_for_updates()) ||
1549                         (uc->test() && Config::instance()->check_for_updates() && Config::instance()->check_for_test_updates());
1550
1551                 _update_news_requested = false;
1552
1553                 if (!announce) {
1554                         return;
1555                 }
1556
1557                 if (uc->state() == UpdateChecker::State::YES) {
1558                         UpdateDialog dialog(this, uc->stable(), uc->test());
1559                         dialog.ShowModal();
1560                 } else if (uc->state() == UpdateChecker::State::FAILED) {
1561                         error_dialog(this, variant::wx::insert_dcpomatic(_("The %s download server could not be contacted.")));
1562                 } else {
1563                         error_dialog(this, variant::wx::insert_dcpomatic(_("There are no new versions of %s available.")));
1564                 }
1565
1566                 _update_news_requested = false;
1567         }
1568
1569         void start_stop_pressed ()
1570         {
1571                 if (_film_viewer.playing()) {
1572                         _film_viewer.stop();
1573                 } else {
1574                         _film_viewer.start();
1575                 }
1576         }
1577
1578         void timeline_pressed ()
1579         {
1580                 _film_editor->content_panel()->timeline_clicked ();
1581         }
1582
1583         void back_frame ()
1584         {
1585                 _film_viewer.seek_by(-_film_viewer.one_video_frame(), true);
1586         }
1587
1588         void forward_frame ()
1589         {
1590                 _film_viewer.seek_by(_film_viewer.one_video_frame(), true);
1591         }
1592
1593         void analytics_message (string title, string html)
1594         {
1595                 HTMLDialog dialog(this, std_to_wx(title), std_to_wx(html));
1596                 dialog.ShowModal();
1597         }
1598
1599         void set_title ()
1600         {
1601                 auto s = variant::dcpomatic();
1602                 if (_film) {
1603                         if (_film->directory()) {
1604                                 s += " - " + _film->directory()->string();
1605                         }
1606                         if (_film->dirty()) {
1607                                 s += " *";
1608                         }
1609                 }
1610
1611                 SetTitle (std_to_wx(s));
1612         }
1613
1614         FilmEditor* _film_editor;
1615         LimitedFrameSplitter* _splitter;
1616         wxPanel* _right_panel;
1617         FilmViewer _film_viewer;
1618         StandardControls* _controls;
1619         wx_ptr<VideoWaveformDialog> _video_waveform_dialog;
1620         SystemInformationDialog* _system_information_dialog = nullptr;
1621         DCPReferencingDialog* _dcp_referencing_dialog = nullptr;
1622         HintsDialog* _hints_dialog = nullptr;
1623         ServersListDialog* _servers_list_dialog = nullptr;
1624         wxPreferencesEditor* _config_dialog = nullptr;
1625         wx_ptr<KDMDialog> _kdm_dialog;
1626         wx_ptr<DKDMDialog> _dkdm_dialog;
1627         wx_ptr<TemplatesDialog> _templates_dialog;
1628         wxMenu* _file_menu = nullptr;
1629         shared_ptr<Film> _film;
1630         int _history_items = 0;
1631         int _history_position = 0;
1632         wxMenuItem* _history_separator = nullptr;
1633         boost::signals2::scoped_connection _config_changed_connection;
1634         boost::signals2::scoped_connection _analytics_message_connection;
1635         bool _update_news_requested = false;
1636         shared_ptr<Content> _clipboard;
1637         bool _first_shown_called = false;
1638 };
1639
1640
1641 static const wxCmdLineEntryDesc command_line_description[] = {
1642         { wxCMD_LINE_SWITCH, "n", "new", "create new film", wxCMD_LINE_VAL_NONE, wxCMD_LINE_PARAM_OPTIONAL },
1643         { wxCMD_LINE_OPTION, "c", "content", "add content file / directory", wxCMD_LINE_VAL_STRING, wxCMD_LINE_PARAM_OPTIONAL },
1644         { wxCMD_LINE_OPTION, "d", "dcp", "add content DCP", wxCMD_LINE_VAL_STRING, wxCMD_LINE_PARAM_OPTIONAL },
1645         { wxCMD_LINE_SWITCH, "v", "version", "show version", wxCMD_LINE_VAL_NONE, wxCMD_LINE_PARAM_OPTIONAL },
1646         { wxCMD_LINE_OPTION, "", "config", "directory containing config.xml and cinemas.xml", wxCMD_LINE_VAL_STRING, wxCMD_LINE_PARAM_OPTIONAL },
1647         { wxCMD_LINE_PARAM, 0, 0, "film to load or create", wxCMD_LINE_VAL_STRING, wxCMD_LINE_PARAM_OPTIONAL },
1648         { wxCMD_LINE_NONE, "", "", "", wxCmdLineParamType (0), 0 }
1649 };
1650
1651
1652 /** @class App
1653  *  @brief The magic App class for wxWidgets.
1654  */
1655 class App : public wxApp
1656 {
1657 public:
1658         App ()
1659                 : wxApp ()
1660         {
1661                 dcpomatic_setup_path_encoding ();
1662 #ifdef DCPOMATIC_LINUX
1663                 XInitThreads ();
1664 #endif
1665         }
1666
1667 private:
1668
1669         bool OnInit () override
1670         {
1671                 try {
1672
1673 #if defined(DCPOMATIC_WINDOWS)
1674                 if (Config::instance()->win32_console()) {
1675                         AllocConsole();
1676
1677                         HANDLE handle_out = GetStdHandle(STD_OUTPUT_HANDLE);
1678                         int hCrt = _open_osfhandle((intptr_t) handle_out, _O_TEXT);
1679                         FILE* hf_out = _fdopen(hCrt, "w");
1680                         setvbuf(hf_out, NULL, _IONBF, 1);
1681                         *stdout = *hf_out;
1682
1683                         HANDLE handle_in = GetStdHandle(STD_INPUT_HANDLE);
1684                         hCrt = _open_osfhandle((intptr_t) handle_in, _O_TEXT);
1685                         FILE* hf_in = _fdopen(hCrt, "r");
1686                         setvbuf(hf_in, NULL, _IONBF, 128);
1687                         *stdin = *hf_in;
1688
1689                         cout << variant::insert_dcpomatic("%1 is starting.") << "\n";
1690                 }
1691 #endif
1692                         wxInitAllImageHandlers ();
1693
1694                         Config::FailedToLoad.connect(boost::bind(&App::config_failed_to_load, this, _1));
1695                         Config::Warning.connect (boost::bind (&App::config_warning, this, _1));
1696
1697                         _splash = maybe_show_splash ();
1698
1699                         SetAppName(variant::wx::dcpomatic());
1700
1701                         if (!wxApp::OnInit()) {
1702                                 return false;
1703                         }
1704
1705 #ifdef DCPOMATIC_LINUX
1706                         unsetenv ("UBUNTU_MENUPROXY");
1707 #endif
1708
1709 #ifdef DCPOMATIC_OSX
1710                         dcpomatic_sleep_seconds (1);
1711                         make_foreground_application ();
1712 #endif
1713
1714                         /* Enable i18n; this will create a Config object
1715                            to look for a force-configured language.  This Config
1716                            object will be wrong, however, because dcpomatic_setup
1717                            hasn't yet been called and there aren't any filters etc.
1718                            set up yet.
1719                         */
1720                         dcpomatic_setup_i18n ();
1721
1722                         /* Set things up, including filters etc.
1723                            which will now be internationalised correctly.
1724                         */
1725                         dcpomatic_setup ();
1726
1727                         /* Force the configuration to be re-loaded correctly next
1728                            time it is needed.
1729                         */
1730                         Config::drop ();
1731
1732                         /* We only look out for bad configuration from here on, as before
1733                            dcpomatic_setup() we haven't got OpenSSL ready so there will be
1734                            incorrect certificate chain validity errors.
1735                         */
1736                         Config::Bad.connect (boost::bind(&App::config_bad, this, _1));
1737
1738                         _frame = new DOMFrame(variant::wx::dcpomatic());
1739                         SetTopWindow (_frame);
1740                         _frame->Maximize ();
1741                         close_splash ();
1742
1743                         if (running_32_on_64 ()) {
1744                                 NagDialog::maybe_nag (
1745                                         _frame, Config::NAG_32_ON_64,
1746                                         wxString::Format(
1747                                                 _("You are running the 32-bit version of %s on a 64-bit version of Windows.  "
1748                                                   "This will limit the memory available to %s and may cause errors.  You are "
1749                                                   "strongly advised to install the 64-bit version of %s."),
1750                                                 variant::wx::dcpomatic(),
1751                                                 variant::wx::dcpomatic(),
1752                                                 variant::wx::dcpomatic()
1753                                                 ),
1754                                         false);
1755                         }
1756
1757                         _frame->Show ();
1758
1759                         signal_manager = new wxSignalManager (this);
1760                         Bind (wxEVT_IDLE, boost::bind (&App::idle, this, _1));
1761
1762                         if (!_film_to_load.empty() && dcp::filesystem::is_directory(_film_to_load)) {
1763                                 try {
1764                                         _frame->load_film (_film_to_load);
1765                                 } catch (exception& e) {
1766                                         error_dialog (nullptr, std_to_wx(String::compose(wx_to_std(_("Could not load film %1 (%2)")), _film_to_load)), std_to_wx(e.what()));
1767                                 }
1768                         }
1769
1770                         if (!_film_to_create.empty ()) {
1771                                 _frame->new_film (_film_to_create, optional<string>());
1772                                 if (!_content_to_add.empty()) {
1773                                         for (auto i: content_factory(_content_to_add)) {
1774                                                 _frame->film()->examine_and_add_content(i);
1775                                         }
1776                                 }
1777                                 if (!_dcp_to_add.empty ()) {
1778                                         _frame->film()->examine_and_add_content(make_shared<DCPContent>(_dcp_to_add));
1779                                 }
1780                         }
1781
1782                         Bind (wxEVT_TIMER, boost::bind (&App::check, this));
1783                         _timer.reset (new wxTimer (this));
1784                         _timer->Start (1000);
1785
1786                         if (Config::instance()->check_for_updates ()) {
1787                                 UpdateChecker::instance()->run ();
1788                         }
1789
1790                         auto release_notes = find_release_notes(gui_is_dark());
1791                         if (release_notes) {
1792                                 HTMLDialog notes(nullptr, _("Release notes"), std_to_wx(*release_notes), true);
1793                                 notes.Centre();
1794                                 notes.ShowModal();
1795                         }
1796
1797 #ifdef DCPOMATIC_GROK
1798                         grk_plugin::setMessengerLogger(new grk_plugin::GrokLogger("[GROK] "));
1799                         setup_grok_library_path();
1800 #endif
1801                 }
1802                 catch (exception& e)
1803                 {
1804                         close_splash();
1805                         error_dialog(nullptr, variant::wx::insert_dcpomatic(_("%s could not start.")), std_to_wx(e.what()));
1806                 }
1807
1808                 return true;
1809         }
1810
1811         void OnInitCmdLine (wxCmdLineParser& parser) override
1812         {
1813                 parser.SetDesc (command_line_description);
1814                 parser.SetSwitchChars (wxT ("-"));
1815         }
1816
1817         bool OnCmdLineParsed (wxCmdLineParser& parser) override
1818         {
1819                 if (parser.Found (wxT("version"))) {
1820                         cout << "dcpomatic version " << dcpomatic_version << " " << dcpomatic_git_commit << "\n";
1821                         exit (EXIT_SUCCESS);
1822                 }
1823
1824                 if (parser.GetParamCount() > 0) {
1825                         if (parser.Found (wxT ("new"))) {
1826                                 _film_to_create = wx_to_std (parser.GetParam (0));
1827                         } else {
1828                                 _film_to_load = wx_to_std (parser.GetParam (0));
1829                         }
1830                 }
1831
1832                 wxString content;
1833                 if (parser.Found (wxT ("content"), &content)) {
1834                         _content_to_add = wx_to_std (content);
1835                 }
1836
1837                 wxString dcp;
1838                 if (parser.Found (wxT ("dcp"), &dcp)) {
1839                         _dcp_to_add = wx_to_std (dcp);
1840                 }
1841
1842                 wxString config;
1843                 if (parser.Found (wxT("config"), &config)) {
1844                         State::override_path = wx_to_std (config);
1845                 }
1846
1847                 return true;
1848         }
1849
1850         void report_exception ()
1851         {
1852                 try {
1853                         throw;
1854                 } catch (FileError& e) {
1855                         error_dialog (
1856                                 nullptr,
1857                                 wxString::Format(
1858                                         _("An exception occurred: %s (%s)\n\n%s"),
1859                                         std_to_wx(e.what()),
1860                                         std_to_wx(e.file().string().c_str()),
1861                                         wx::report_problem()
1862                                         )
1863                                 );
1864                 } catch (boost::filesystem::filesystem_error& e) {
1865                         error_dialog (
1866                                 nullptr,
1867                                 wxString::Format(
1868                                         _("An exception occurred: %s (%s) (%s)\n\n%s"),
1869                                         std_to_wx(e.what()),
1870                                         std_to_wx(e.path1().string()),
1871                                         std_to_wx(e.path2().string()),
1872                                         wx::report_problem()
1873                                         )
1874                                 );
1875                 } catch (exception& e) {
1876                         error_dialog (
1877                                 nullptr,
1878                                 wxString::Format(
1879                                         _("An exception occurred: %s.\n\n%s"),
1880                                         std_to_wx(e.what()),
1881                                         wx::report_problem()
1882                                         )
1883                                 );
1884                 } catch (...) {
1885                         error_dialog(nullptr, _("An unknown exception occurred.") + "  " + wx::report_problem());
1886                 }
1887         }
1888
1889         /* An unhandled exception has occurred inside the main event loop */
1890         bool OnExceptionInMainLoop () override
1891         {
1892                 report_exception ();
1893                 /* This will terminate the program */
1894                 return false;
1895         }
1896
1897         void OnUnhandledException () override
1898         {
1899                 report_exception ();
1900         }
1901
1902         void idle (wxIdleEvent& ev)
1903         {
1904                 signal_manager->ui_idle ();
1905                 ev.Skip ();
1906         }
1907
1908         void check ()
1909         {
1910                 try {
1911                         EncodeServerFinder::instance()->rethrow ();
1912                 } catch (exception& e) {
1913                         error_dialog (0, std_to_wx (e.what ()));
1914                 }
1915         }
1916
1917         void close_splash ()
1918         {
1919                 if (_splash) {
1920                         _splash->Destroy();
1921                         _splash = nullptr;
1922                 }
1923         }
1924
1925         void config_failed_to_load (Config::LoadFailure what)
1926         {
1927                 report_config_load_failure(_frame, what);
1928         }
1929
1930         void config_warning (string m)
1931         {
1932                 message_dialog (_frame, std_to_wx(m));
1933         }
1934
1935         bool config_bad (Config::BadReason reason)
1936         {
1937                 /* Destroy the splash screen here, as otherwise bad things seem to happen (for reasons unknown)
1938                    when we open our recreate dialog, close it, *then* try to Destroy the splash (the Destroy fails).
1939                 */
1940                 close_splash();
1941
1942                 auto config = Config::instance();
1943                 switch (reason) {
1944                 case Config::BAD_SIGNER_UTF8_STRINGS:
1945                 {
1946                         if (config->nagged(Config::NAG_BAD_SIGNER_CHAIN_UTF8)) {
1947                                 return false;
1948                         }
1949                         RecreateChainDialog dialog(
1950                                 _frame, _("Recreate signing certificates"),
1951                                 variant::wx::insert_dcpomatic(
1952                                         _("The certificate chain that %s uses for signing DCPs and KDMs contains a small error\n"
1953                                           "which will prevent DCPs from being validated correctly on some systems.  Do you want to re-create\n"
1954                                           "the certificate chain for signing DCPs and KDMs?")
1955                                         ),
1956                                 _("Do nothing"),
1957                                 Config::NAG_BAD_SIGNER_CHAIN_UTF8
1958                                 );
1959                         return dialog.ShowModal() == wxID_OK;
1960                 }
1961                 case Config::BAD_SIGNER_VALIDITY_TOO_LONG:
1962                 {
1963                         if (config->nagged(Config::NAG_BAD_SIGNER_CHAIN_VALIDITY)) {
1964                                 return false;
1965                         }
1966                         RecreateChainDialog dialog(
1967                                 _frame, _("Recreate signing certificates"),
1968                                 variant::wx::insert_dcpomatic(
1969                                         _("The certificate chain that %s uses for signing DCPs and KDMs has a validity period\n"
1970                                           "that is too long.  This will cause problems playing back DCPs on some systems.\n"
1971                                           "Do you want to re-create the certificate chain for signing DCPs and KDMs?")
1972                                         ),
1973                                 _("Do nothing"),
1974                                 Config::NAG_BAD_SIGNER_CHAIN_VALIDITY
1975                                 );
1976                         return dialog.ShowModal() == wxID_OK;
1977                 }
1978                 case Config::BAD_SIGNER_INCONSISTENT:
1979                 {
1980                         RecreateChainDialog dialog(
1981                                 _frame, _("Recreate signing certificates"),
1982                                 wxString::Format(
1983                                         _("The certificate chain that %s uses for signing DCPs and KDMs is inconsistent and\n"
1984                                           "cannot be used.  %s cannot start unless you re-create it.  Do you want to re-create\n"
1985                                           "the certificate chain for signing DCPs and KDMs?"),
1986                                         variant::wx::dcpomatic(),
1987                                         variant::wx::dcpomatic()
1988                                         ),
1989                                 variant::wx::insert_dcpomatic(_("Close %s"))
1990                                 );
1991                         if (dialog.ShowModal() != wxID_OK) {
1992                                 exit (EXIT_FAILURE);
1993                         }
1994                         return true;
1995                 }
1996                 case Config::BAD_DECRYPTION_INCONSISTENT:
1997                 {
1998                         RecreateChainDialog dialog(
1999                                 _frame, _("Recreate KDM decryption chain"),
2000                                 wxString::Format(
2001                                         _("The certificate chain that %s uses for decrypting KDMs is inconsistent and\n"
2002                                           "cannot be used.  %s cannot start unless you re-create it.  Do you want to re-create\n"
2003                                           "the certificate chain for decrypting KDMs?  You may want to say \"No\" here and back up your\n"
2004                                           "configuration before continuing."),
2005                                         variant::wx::dcpomatic(),
2006                                         variant::wx::dcpomatic()
2007                                         ),
2008                                 variant::wx::insert_dcpomatic(_("Close %s"))
2009                                 );
2010                         if (dialog.ShowModal() != wxID_OK) {
2011                                 exit (EXIT_FAILURE);
2012                         }
2013                         return true;
2014                 }
2015                 case Config::BAD_SIGNER_DN_QUALIFIER:
2016                 {
2017                         RecreateChainDialog dialog(
2018                                 _frame, _("Recreate signing certificates"),
2019                                 wxString::Format(
2020                                         _("The certificate chain that %s uses for signing DCPs and KDMs contains a small error\n"
2021                                           "which will prevent DCPs from being validated correctly on some systems.  This error was caused\n"
2022                                           "by a bug in %s which has now been fixed. Do you want to re-create the certificate chain\n"
2023                                           "for signing DCPs and KDMs?"),
2024                                         variant::wx::dcpomatic(),
2025                                         variant::wx::dcpomatic()
2026                                         ),
2027                                 _("Do nothing"),
2028                                 Config::NAG_BAD_SIGNER_DN_QUALIFIER
2029                                 );
2030                         return dialog.ShowModal() == wxID_OK;
2031                 }
2032                 default:
2033                         DCPOMATIC_ASSERT (false);
2034                 }
2035         }
2036
2037         DOMFrame* _frame = nullptr;
2038         wxSplashScreen* _splash = nullptr;
2039         shared_ptr<wxTimer> _timer;
2040         string _film_to_load;
2041         string _film_to_create;
2042         string _content_to_add;
2043         string _dcp_to_add;
2044 };
2045
2046
2047 IMPLEMENT_APP (App)