src/wx/config_dialog.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 #include "config_dialog.h"
  22 #include "static_text.h"
  23 #include "check_box.h"
  24 #include "nag_dialog.h"
  25 #include "dcpomatic_button.h"
  26 #include "audio_mapping_view.h"
  27 #include <dcp/raw_convert.h>
  28 #include <iostream>
  29
  30 using std::string;
  31 using std::vector;
  32 using std::pair;
  33 using std::make_pair;
  34 using std::map;
  35 using std::make_shared;
  36 using boost::bind;
  37 using boost::optional;
  38 using std::shared_ptr;
  39 using std::function;
  40 #if BOOST_VERSION >= 106100
  41 using namespace boost::placeholders;
  42 #endif
  43
  44 static
  45 bool
  46 do_nothing ()
  47 {
  48         return false;
  49 }
  50
  51 Page::Page (wxSize panel_size, int border)
  52         : _border (border)
  53         , _panel (0)
  54         , _panel_size (panel_size)
  55         , _window_exists (false)
  56 {
  57         _config_connection = Config::instance()->Changed.connect (bind (&Page::config_changed_wrapper, this));
  58 }
  59
  60
  61 wxWindow*
  62 Page::CreateWindow (wxWindow* parent)
  63 {
  64         return create_window (parent);
  65 }
  66
  67
  68 wxWindow*
  69 Page::create_window (wxWindow* parent)
  70 {
  71         _panel = new wxPanel (parent, wxID_ANY, wxDefaultPosition, _panel_size);
  72         auto s = new wxBoxSizer (wxVERTICAL);
  73         _panel->SetSizer (s);
  74
  75         setup ();
  76         _window_exists = true;
  77         config_changed ();
  78
  79         _panel->Bind (wxEVT_DESTROY, bind (&Page::window_destroyed, this));
  80
  81         return _panel;
  82 }
  83
  84 void
  85 Page::config_changed_wrapper ()
  86 {
  87         if (_window_exists) {
  88                 config_changed ();
  89         }
  90 }
  91
  92 void
  93 Page::window_destroyed ()
  94 {
  95         _window_exists = false;
  96 }
  97
  98
  99 GeneralPage::GeneralPage (wxSize panel_size, int border)
 100         : Page (panel_size, border)
 101 {
 102
 103 }
 104
 105
 106 wxString
 107 GeneralPage::GetName () const
 108 {
 109         return _("General");
 110 }
 111
 112
 113 void
 114 GeneralPage::add_language_controls (wxGridBagSizer* table, int& r)
 115 {
 116         _set_language = new CheckBox (_panel, _("Set language"));
 117         table->Add (_set_language, wxGBPosition (r, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL);
 118         _language = new wxChoice (_panel, wxID_ANY);
 119         vector<pair<string, string>> languages;
 120         languages.push_back (make_pair("Čeština", "cs_CZ"));
 121         languages.push_back (make_pair("汉语/漢語", "zh_CN"));
 122         languages.push_back (make_pair("Dansk", "da_DK"));
 123         languages.push_back (make_pair("Deutsch", "de_DE"));
 124         languages.push_back (make_pair("English", "en_GB"));
 125         languages.push_back (make_pair("Español", "es_ES"));
 126         languages.push_back (make_pair("Français", "fr_FR"));
 127         languages.push_back (make_pair("Italiano", "it_IT"));
 128         languages.push_back (make_pair("Nederlands", "nl_NL"));
 129         languages.push_back (make_pair("Русский", "ru_RU"));
 130         languages.push_back (make_pair("Polski", "pl_PL"));
 131         languages.push_back (make_pair("Português europeu", "pt_PT"));
 132         languages.push_back (make_pair("Português do Brasil", "pt_BR"));
 133         languages.push_back (make_pair("Svenska", "sv_SE"));
 134         languages.push_back (make_pair("Slovenský jazyk", "sk_SK"));
 135         languages.push_back (make_pair("Türkçe", "tr_TR"));
 136         languages.push_back (make_pair("українська мова", "uk_UA"));
 137         checked_set (_language, languages);
 138         table->Add (_language, wxGBPosition (r, 1));
 139         ++r;
 140
 141         auto restart = add_label_to_sizer (
 142                 table, _panel, _("(restart DCP-o-matic to see language changes)"), false, wxGBPosition (r, 0), wxGBSpan (1, 2)
 143                 );
 144         wxFont font = restart->GetFont();
 145         font.SetStyle (wxFONTSTYLE_ITALIC);
 146         font.SetPointSize (font.GetPointSize() - 1);
 147         restart->SetFont (font);
 148         ++r;
 149
 150         _set_language->Bind (wxEVT_CHECKBOX, bind (&GeneralPage::set_language_changed, this));
 151         _language->Bind     (wxEVT_CHOICE,   bind (&GeneralPage::language_changed,     this));
 152 }
 153
 154 void
 155 GeneralPage::add_update_controls (wxGridBagSizer* table, int& r)
 156 {
 157         _check_for_updates = new CheckBox (_panel, _("Check for updates on startup"));
 158         table->Add (_check_for_updates, wxGBPosition (r, 0), wxGBSpan (1, 2));
 159         ++r;
 160
 161         _check_for_test_updates = new CheckBox (_panel, _("Check for testing updates on startup"));
 162         table->Add (_check_for_test_updates, wxGBPosition (r, 0), wxGBSpan (1, 2));
 163         ++r;
 164
 165         _check_for_updates->Bind (wxEVT_CHECKBOX, bind (&GeneralPage::check_for_updates_changed, this));
 166         _check_for_test_updates->Bind (wxEVT_CHECKBOX, bind (&GeneralPage::check_for_test_updates_changed, this));
 167 }
 168
 169 void
 170 GeneralPage::config_changed ()
 171 {
 172         auto config = Config::instance ();
 173
 174         checked_set (_set_language, static_cast<bool>(config->language()));
 175
 176         /* Backwards compatibility of config file */
 177
 178         map<string, string> compat_map;
 179         compat_map["fr"] = "fr_FR";
 180         compat_map["it"] = "it_IT";
 181         compat_map["es"] = "es_ES";
 182         compat_map["sv"] = "sv_SE";
 183         compat_map["de"] = "de_DE";
 184         compat_map["nl"] = "nl_NL";
 185         compat_map["ru"] = "ru_RU";
 186         compat_map["pl"] = "pl_PL";
 187         compat_map["da"] = "da_DK";
 188         compat_map["pt"] = "pt_PT";
 189         compat_map["sk"] = "sk_SK";
 190         compat_map["cs"] = "cs_CZ";
 191         compat_map["uk"] = "uk_UA";
 192
 193         auto lang = config->language().get_value_or("en_GB");
 194         if (compat_map.find(lang) != compat_map.end ()) {
 195                 lang = compat_map[lang];
 196         }
 197
 198         checked_set (_language, lang);
 199
 200         checked_set (_check_for_updates, config->check_for_updates ());
 201         checked_set (_check_for_test_updates, config->check_for_test_updates ());
 202
 203         setup_sensitivity ();
 204 }
 205
 206 void
 207 GeneralPage::setup_sensitivity ()
 208 {
 209         _language->Enable (_set_language->GetValue ());
 210         _check_for_test_updates->Enable (_check_for_updates->GetValue ());
 211 }
 212
 213 void
 214 GeneralPage::set_language_changed ()
 215 {
 216         setup_sensitivity ();
 217         if (_set_language->GetValue ()) {
 218                 language_changed ();
 219         } else {
 220                 Config::instance()->unset_language ();
 221         }
 222 }
 223
 224 void
 225 GeneralPage::language_changed ()
 226 {
 227         int const sel = _language->GetSelection ();
 228         if (sel != -1) {
 229                 Config::instance()->set_language (string_client_data (_language->GetClientObject (sel)));
 230         } else {
 231                 Config::instance()->unset_language ();
 232         }
 233 }
 234
 235 void
 236 GeneralPage::check_for_updates_changed ()
 237 {
 238         Config::instance()->set_check_for_updates (_check_for_updates->GetValue ());
 239 }
 240
 241 void
 242 GeneralPage::check_for_test_updates_changed ()
 243 {
 244         Config::instance()->set_check_for_test_updates (_check_for_test_updates->GetValue ());
 245 }
 246
 247 CertificateChainEditor::CertificateChainEditor (
 248         wxWindow* parent,
 249         wxString title,
 250         int border,
 251         function<void (shared_ptr<dcp::CertificateChain>)> set,
 252         function<shared_ptr<const dcp::CertificateChain> (void)> get,
 253         function<bool (void)> nag_alter
 254         )
 255         : wxDialog (parent, wxID_ANY, title)
 256         , _set (set)
 257         , _get (get)
 258         , _nag_alter (nag_alter)
 259 {
 260         _sizer = new wxBoxSizer (wxVERTICAL);
 261
 262         auto certificates_sizer = new wxBoxSizer (wxHORIZONTAL);
 263         _sizer->Add (certificates_sizer, 0, wxALL, border);
 264
 265         _certificates = new wxListCtrl (this, wxID_ANY, wxDefaultPosition, wxSize (440, 150), wxLC_REPORT | wxLC_SINGLE_SEL);
 266
 267         {
 268                 wxListItem ip;
 269                 ip.SetId (0);
 270                 ip.SetText (_("Type"));
 271                 ip.SetWidth (100);
 272                 _certificates->InsertColumn (0, ip);
 273         }
 274
 275         {
 276                 wxListItem ip;
 277                 ip.SetId (1);
 278                 ip.SetText (_("Thumbprint"));
 279                 ip.SetWidth (340);
 280
 281                 wxFont font = ip.GetFont ();
 282                 font.SetFamily (wxFONTFAMILY_TELETYPE);
 283                 ip.SetFont (font);
 284
 285                 _certificates->InsertColumn (1, ip);
 286         }
 287
 288         certificates_sizer->Add (_certificates, 1, wxEXPAND);
 289
 290         {
 291                 auto s = new wxBoxSizer (wxVERTICAL);
 292                 _add_certificate = new Button (this, _("Add..."));
 293                 s->Add (_add_certificate, 1, wxTOP | wxBOTTOM | wxEXPAND, DCPOMATIC_BUTTON_STACK_GAP);
 294                 _remove_certificate = new Button (this, _("Remove"));
 295                 s->Add (_remove_certificate, 1, wxTOP | wxBOTTOM | wxEXPAND, DCPOMATIC_BUTTON_STACK_GAP);
 296                 _export_certificate = new Button (this, _("Export certificate..."));
 297                 s->Add (_export_certificate, 1, wxTOP | wxBOTTOM | wxEXPAND, DCPOMATIC_BUTTON_STACK_GAP);
 298                 _export_chain = new Button (this, _("Export chain..."));
 299                 s->Add (_export_chain, 1, wxTOP | wxBOTTOM | wxEXPAND, DCPOMATIC_BUTTON_STACK_GAP);
 300                 certificates_sizer->Add (s, 0, wxLEFT, DCPOMATIC_SIZER_X_GAP);
 301         }
 302
 303         auto table = new wxGridBagSizer (DCPOMATIC_SIZER_X_GAP, DCPOMATIC_SIZER_Y_GAP);
 304         _sizer->Add (table, 1, wxALL | wxEXPAND, border);
 305         int r = 0;
 306
 307         add_label_to_sizer (table, this, _("Leaf private key"), true, wxGBPosition (r, 0));
 308         _private_key = new StaticText (this, wxT(""));
 309         wxFont font = _private_key->GetFont ();
 310         font.SetFamily (wxFONTFAMILY_TELETYPE);
 311         _private_key->SetFont (font);
 312         table->Add (_private_key, wxGBPosition (r, 1), wxDefaultSpan, wxALIGN_CENTER_VERTICAL);
 313         _import_private_key = new Button (this, _("Import..."));
 314         table->Add (_import_private_key, wxGBPosition (r, 2));
 315         _export_private_key = new Button (this, _("Export..."));
 316         table->Add (_export_private_key, wxGBPosition (r, 3));
 317         ++r;
 318
 319         _button_sizer = new wxBoxSizer (wxHORIZONTAL);
 320         _remake_certificates = new Button (this, _("Re-make certificates and key..."));
 321         _button_sizer->Add (_remake_certificates, 1, wxRIGHT, border);
 322         table->Add (_button_sizer, wxGBPosition (r, 0), wxGBSpan (1, 4));
 323         ++r;
 324
 325         _private_key_bad = new StaticText (this, _("Leaf private key does not match leaf certificate!"));
 326         font = *wxSMALL_FONT;
 327         font.SetWeight (wxFONTWEIGHT_BOLD);
 328         _private_key_bad->SetFont (font);
 329         table->Add (_private_key_bad, wxGBPosition (r, 0), wxGBSpan (1, 3));
 330         ++r;
 331
 332         _add_certificate->Bind     (wxEVT_BUTTON,       bind (&CertificateChainEditor::add_certificate, this));
 333         _remove_certificate->Bind  (wxEVT_BUTTON,       bind (&CertificateChainEditor::remove_certificate, this));
 334         _export_certificate->Bind  (wxEVT_BUTTON,       bind (&CertificateChainEditor::export_certificate, this));
 335         _certificates->Bind        (wxEVT_LIST_ITEM_SELECTED,   bind (&CertificateChainEditor::update_sensitivity, this));
 336         _certificates->Bind        (wxEVT_LIST_ITEM_DESELECTED, bind (&CertificateChainEditor::update_sensitivity, this));
 337         _remake_certificates->Bind (wxEVT_BUTTON,       bind (&CertificateChainEditor::remake_certificates, this));
 338         _export_chain->Bind        (wxEVT_BUTTON,       bind (&CertificateChainEditor::export_chain, this));
 339         _import_private_key->Bind  (wxEVT_BUTTON,       bind (&CertificateChainEditor::import_private_key, this));
 340         _export_private_key->Bind  (wxEVT_BUTTON,       bind (&CertificateChainEditor::export_private_key, this));
 341
 342         auto buttons = CreateSeparatedButtonSizer (wxCLOSE);
 343         if (buttons) {
 344                 _sizer->Add (buttons, wxSizerFlags().Expand().DoubleBorder());
 345         }
 346
 347         SetSizerAndFit (_sizer);
 348
 349         update_certificate_list ();
 350         update_private_key ();
 351         update_sensitivity ();
 352 }
 353
 354 void
 355 CertificateChainEditor::add_button (wxWindow* button)
 356 {
 357         _button_sizer->Add (button, 0, wxLEFT | wxRIGHT, DCPOMATIC_SIZER_X_GAP);
 358         _sizer->Layout ();
 359 }
 360
 361 void
 362 CertificateChainEditor::add_certificate ()
 363 {
 364         auto d = new wxFileDialog (this, _("Select Certificate File"));
 365
 366         if (d->ShowModal() == wxID_OK) {
 367                 try {
 368                         dcp::Certificate c;
 369                         string extra;
 370                         try {
 371                                 extra = c.read_string (dcp::file_to_string (wx_to_std (d->GetPath ())));
 372                         } catch (boost::filesystem::filesystem_error& e) {
 373                                 error_dialog (this, _("Could not import certificate (%s)"), d->GetPath());
 374                                 d->Destroy ();
 375                                 return;
 376                         }
 377
 378                         if (!extra.empty ()) {
 379                                 message_dialog (
 380                                         this,
 381                                         _("This file contains other certificates (or other data) after its first certificate. "
 382                                           "Only the first certificate will be used.")
 383                                         );
 384                         }
 385                         auto chain = make_shared<dcp::CertificateChain>(*_get().get());
 386                         chain->add (c);
 387                         if (!chain->chain_valid ()) {
 388                                 error_dialog (
 389                                         this,
 390                                         _("Adding this certificate would make the chain inconsistent, so it will not be added. "
 391                                           "Add certificates in order from root to intermediate to leaf.")
 392                                         );
 393                                 chain->remove (c);
 394                         } else {
 395                                 _set (chain);
 396                                 update_certificate_list ();
 397                         }
 398                 } catch (dcp::MiscError& e) {
 399                         error_dialog (this, _("Could not read certificate file."), std_to_wx(e.what()));
 400                 }
 401         }
 402
 403         d->Destroy ();
 404
 405         update_sensitivity ();
 406 }
 407
 408 void
 409 CertificateChainEditor::remove_certificate ()
 410 {
 411         if (_nag_alter()) {
 412                 /* Cancel was clicked */
 413                 return;
 414         }
 415
 416         int i = _certificates->GetNextItem (-1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
 417         if (i == -1) {
 418                 return;
 419         }
 420
 421         _certificates->DeleteItem (i);
 422         auto chain = make_shared<dcp::CertificateChain>(*_get().get());
 423         chain->remove (i);
 424         _set (chain);
 425
 426         update_sensitivity ();
 427         update_certificate_list ();
 428 }
 429
 430 void
 431 CertificateChainEditor::export_certificate ()
 432 {
 433         int i = _certificates->GetNextItem (-1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
 434         if (i == -1) {
 435                 return;
 436         }
 437
 438         auto all = _get()->root_to_leaf();
 439
 440         wxString default_name;
 441         if (i == 0) {
 442                 default_name = "root.pem";
 443         } else if (i == static_cast<int>(all.size() - 1)) {
 444                 default_name = "leaf.pem";
 445         } else {
 446                 default_name = "intermediate.pem";
 447         }
 448
 449         auto d = new wxFileDialog(
 450                 this, _("Select Certificate File"), wxEmptyString, default_name, wxT ("PEM files (*.pem)|*.pem"),
 451                 wxFD_SAVE | wxFD_OVERWRITE_PROMPT
 452                 );
 453
 454         auto j = all.begin ();
 455         for (int k = 0; k < i; ++k) {
 456                 ++j;
 457         }
 458
 459         if (d->ShowModal () == wxID_OK) {
 460                 boost::filesystem::path path (wx_to_std(d->GetPath()));
 461                 if (path.extension() != ".pem") {
 462                         path += ".pem";
 463                 }
 464                 auto f = fopen_boost (path, "w");
 465                 if (!f) {
 466                         throw OpenFileError (path, errno, OpenFileError::WRITE);
 467                 }
 468
 469                 string const s = j->certificate (true);
 470                 checked_fwrite (s.c_str(), s.length(), f, path);
 471                 fclose (f);
 472         }
 473         d->Destroy ();
 474 }
 475
 476 void
 477 CertificateChainEditor::export_chain ()
 478 {
 479         auto d = new wxFileDialog (
 480                 this, _("Select Chain File"), wxEmptyString, _("certificate_chain.pem"), wxT("PEM files (*.pem)|*.pem"),
 481                 wxFD_SAVE | wxFD_OVERWRITE_PROMPT
 482                 );
 483
 484         if (d->ShowModal () == wxID_OK) {
 485                 boost::filesystem::path path (wx_to_std(d->GetPath()));
 486                 if (path.extension() != ".pem") {
 487                         path += ".pem";
 488                 }
 489                 auto f = fopen_boost (path, "w");
 490                 if (!f) {
 491                         throw OpenFileError (path, errno, OpenFileError::WRITE);
 492                 }
 493
 494                 auto const s = _get()->chain();
 495                 checked_fwrite (s.c_str(), s.length(), f, path);
 496                 fclose (f);
 497         }
 498
 499         d->Destroy ();
 500 }
 501
 502 void
 503 CertificateChainEditor::update_certificate_list ()
 504 {
 505         _certificates->DeleteAllItems ();
 506         size_t n = 0;
 507         auto certs = _get()->root_to_leaf();
 508         for (auto const& i: certs) {
 509                 wxListItem item;
 510                 item.SetId (n);
 511                 _certificates->InsertItem (item);
 512                 _certificates->SetItem (n, 1, std_to_wx (i.thumbprint ()));
 513
 514                 if (n == 0) {
 515                         _certificates->SetItem (n, 0, _("Root"));
 516                 } else if (n == (certs.size() - 1)) {
 517                         _certificates->SetItem (n, 0, _("Leaf"));
 518                 } else {
 519                         _certificates->SetItem (n, 0, _("Intermediate"));
 520                 }
 521
 522                 ++n;
 523         }
 524
 525         static wxColour normal = _private_key_bad->GetForegroundColour ();
 526
 527         if (_get()->private_key_valid()) {
 528                 _private_key_bad->Hide ();
 529                 _private_key_bad->SetForegroundColour (normal);
 530         } else {
 531                 _private_key_bad->Show ();
 532                 _private_key_bad->SetForegroundColour (wxColour (255, 0, 0));
 533         }
 534 }
 535
 536 void
 537 CertificateChainEditor::remake_certificates ()
 538 {
 539         auto chain = _get();
 540
 541         string subject_organization_name;
 542         string subject_organizational_unit_name;
 543         string root_common_name;
 544         string intermediate_common_name;
 545         string leaf_common_name;
 546
 547         auto all = chain->root_to_leaf ();
 548
 549         if (all.size() >= 1) {
 550                 /* Have a root */
 551                 subject_organization_name = chain->root().subject_organization_name ();
 552                 subject_organizational_unit_name = chain->root().subject_organizational_unit_name ();
 553                 root_common_name = chain->root().subject_common_name ();
 554         }
 555
 556         if (all.size() >= 2) {
 557                 /* Have a leaf */
 558                 leaf_common_name = chain->leaf().subject_common_name ();
 559         }
 560
 561         if (all.size() >= 3) {
 562                 /* Have an intermediate */
 563                 dcp::CertificateChain::List::iterator i = all.begin ();
 564                 ++i;
 565                 intermediate_common_name = i->subject_common_name ();
 566         }
 567
 568         if (_nag_alter()) {
 569                 /* Cancel was clicked */
 570                 return;
 571         }
 572
 573         auto d = new MakeChainDialog (
 574                 this,
 575                 subject_organization_name,
 576                 subject_organizational_unit_name,
 577                 root_common_name,
 578                 intermediate_common_name,
 579                 leaf_common_name
 580                 );
 581
 582         if (d->ShowModal () == wxID_OK) {
 583                 _set (
 584                         make_shared<dcp::CertificateChain> (
 585                                 openssl_path (),
 586                                 d->organisation (),
 587                                 d->organisational_unit (),
 588                                 d->root_common_name (),
 589                                 d->intermediate_common_name (),
 590                                 d->leaf_common_name ()
 591                                 )
 592                         );
 593
 594                 update_certificate_list ();
 595                 update_private_key ();
 596         }
 597
 598         d->Destroy ();
 599 }
 600
 601 void
 602 CertificateChainEditor::update_sensitivity ()
 603 {
 604         /* We can only remove the leaf certificate */
 605         _remove_certificate->Enable (_certificates->GetNextItem(-1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED) == (_certificates->GetItemCount() - 1));
 606         _export_certificate->Enable (_certificates->GetNextItem(-1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED) != -1);
 607 }
 608
 609 void
 610 CertificateChainEditor::update_private_key ()
 611 {
 612         checked_set (_private_key, dcp::private_key_fingerprint (_get()->key().get()));
 613         _sizer->Layout ();
 614 }
 615
 616 void
 617 CertificateChainEditor::import_private_key ()
 618 {
 619         auto d = new wxFileDialog (this, _("Select Key File"));
 620
 621         if (d->ShowModal() == wxID_OK) {
 622                 try {
 623                         boost::filesystem::path p (wx_to_std (d->GetPath ()));
 624                         if (boost::filesystem::file_size (p) > 8192) {
 625                                 error_dialog (
 626                                         this,
 627                                         wxString::Format (_("Could not read key file; file is too long (%s)"), std_to_wx (p.string ()))
 628                                         );
 629                                 return;
 630                         }
 631
 632                         auto chain = make_shared<dcp::CertificateChain>(*_get().get());
 633                         chain->set_key (dcp::file_to_string (p));
 634                         _set (chain);
 635                         update_private_key ();
 636                 } catch (dcp::MiscError& e) {
 637                         error_dialog (this, _("Could not read certificate file."), std_to_wx(e.what()));
 638                 }
 639         }
 640
 641         d->Destroy ();
 642
 643         update_sensitivity ();
 644 }
 645
 646 void
 647 CertificateChainEditor::export_private_key ()
 648 {
 649         auto key = _get()->key();
 650         if (!key) {
 651                 return;
 652         }
 653
 654         auto d = new wxFileDialog (
 655                 this, _("Select Key File"), wxEmptyString, _("private_key.pem"), wxT ("PEM files (*.pem)|*.pem"),
 656                 wxFD_SAVE | wxFD_OVERWRITE_PROMPT
 657                 );
 658
 659         if (d->ShowModal () == wxID_OK) {
 660                 boost::filesystem::path path (wx_to_std(d->GetPath()));
 661                 if (path.extension() != ".pem") {
 662                         path += ".pem";
 663                 }
 664                 auto f = fopen_boost (path, "w");
 665                 if (!f) {
 666                         throw OpenFileError (path, errno, OpenFileError::WRITE);
 667                 }
 668
 669                 auto const s = _get()->key().get ();
 670                 checked_fwrite (s.c_str(), s.length(), f, path);
 671                 fclose (f);
 672         }
 673         d->Destroy ();
 674 }
 675
 676 wxString
 677 KeysPage::GetName () const
 678 {
 679         return _("Keys");
 680 }
 681
 682 void
 683 KeysPage::setup ()
 684 {
 685         wxFont subheading_font (*wxNORMAL_FONT);
 686         subheading_font.SetWeight (wxFONTWEIGHT_BOLD);
 687
 688         auto sizer = _panel->GetSizer();
 689
 690         {
 691                 auto m = new StaticText (_panel, _("Decrypting KDMs"));
 692                 m->SetFont (subheading_font);
 693                 sizer->Add (m, 0, wxALL, _border);
 694         }
 695
 696         auto buttons = new wxBoxSizer (wxVERTICAL);
 697
 698         auto export_decryption_certificate = new Button (_panel, _("Export KDM decryption leaf certificate..."));
 699         buttons->Add (export_decryption_certificate, 0, wxBOTTOM, DCPOMATIC_BUTTON_STACK_GAP);
 700         auto export_settings = new Button (_panel, _("Export all KDM decryption settings..."));
 701         buttons->Add (export_settings, 0, wxBOTTOM, DCPOMATIC_BUTTON_STACK_GAP);
 702         auto import_settings = new Button (_panel, _("Import all KDM decryption settings..."));
 703         buttons->Add (import_settings, 0, wxBOTTOM, DCPOMATIC_BUTTON_STACK_GAP);
 704         auto decryption_advanced = new Button (_panel, _("Advanced..."));
 705         buttons->Add (decryption_advanced, 0);
 706
 707         sizer->Add (buttons, 0, wxLEFT, _border);
 708
 709         export_decryption_certificate->Bind (wxEVT_BUTTON, bind (&KeysPage::export_decryption_certificate, this));
 710         export_settings->Bind (wxEVT_BUTTON, bind (&KeysPage::export_decryption_chain_and_key, this));
 711         import_settings->Bind (wxEVT_BUTTON, bind (&KeysPage::import_decryption_chain_and_key, this));
 712         decryption_advanced->Bind (wxEVT_BUTTON, bind (&KeysPage::decryption_advanced, this));
 713
 714         {
 715                 auto m = new StaticText (_panel, _("Signing DCPs and KDMs"));
 716                 m->SetFont (subheading_font);
 717                 sizer->Add (m, 0, wxALL, _border);
 718         }
 719
 720         auto signing_advanced = new Button (_panel, _("Advanced..."));
 721         sizer->Add (signing_advanced, 0, wxLEFT | wxBOTTOM, _border);
 722         signing_advanced->Bind (wxEVT_BUTTON, bind (&KeysPage::signing_advanced, this));
 723 }
 724
 725 void
 726 KeysPage::decryption_advanced ()
 727 {
 728         auto c = new CertificateChainEditor (
 729                 _panel, _("Decrypting KDMs"), _border,
 730                 bind(&Config::set_decryption_chain, Config::instance(), _1),
 731                 bind(&Config::decryption_chain, Config::instance()),
 732                 bind(&KeysPage::nag_alter_decryption_chain, this)
 733                 );
 734
 735         c->ShowModal();
 736 }
 737
 738 void
 739 KeysPage::signing_advanced ()
 740 {
 741         auto c = new CertificateChainEditor (
 742                 _panel, _("Signing DCPs and KDMs"), _border,
 743                 bind(&Config::set_signer_chain, Config::instance(), _1),
 744                 bind(&Config::signer_chain, Config::instance()),
 745                 bind(&do_nothing)
 746                 );
 747
 748         c->ShowModal();
 749 }
 750
 751 void
 752 KeysPage::export_decryption_chain_and_key ()
 753 {
 754         auto d = new wxFileDialog (
 755                 _panel, _("Select Export File"), wxEmptyString, wxEmptyString, wxT ("DOM files (*.dom)|*.dom"),
 756                 wxFD_SAVE | wxFD_OVERWRITE_PROMPT
 757                 );
 758
 759         if (d->ShowModal () == wxID_OK) {
 760                 boost::filesystem::path path (wx_to_std(d->GetPath()));
 761                 auto f = fopen_boost (path, "w");
 762                 if (!f) {
 763                         throw OpenFileError (path, errno, OpenFileError::WRITE);
 764                 }
 765
 766                 auto const chain = Config::instance()->decryption_chain()->chain();
 767                 checked_fwrite (chain.c_str(), chain.length(), f, path);
 768                 optional<string> const key = Config::instance()->decryption_chain()->key();
 769                 DCPOMATIC_ASSERT (key);
 770                 checked_fwrite (key->c_str(), key->length(), f, path);
 771                 fclose (f);
 772         }
 773         d->Destroy ();
 774
 775 }
 776
 777 void
 778 KeysPage::import_decryption_chain_and_key ()
 779 {
 780         if (NagDialog::maybe_nag (
 781                     _panel,
 782                     Config::NAG_IMPORT_DECRYPTION_CHAIN,
 783                     _("If you continue with this operation you will no longer be able to use any DKDMs that you have created with the current certificates and key.  Also, any KDMs that have been sent to you for those certificates will become useless.  Proceed with caution!"),
 784                     true
 785                     )) {
 786                 return;
 787         }
 788
 789         auto d = new wxFileDialog (
 790                 _panel, _("Select File To Import"), wxEmptyString, wxEmptyString, wxT ("DOM files (*.dom)|*.dom")
 791                 );
 792
 793         if (d->ShowModal () == wxID_OK) {
 794                 auto new_chain = make_shared<dcp::CertificateChain>();
 795
 796                 FILE* f = fopen_boost (wx_to_std (d->GetPath ()), "r");
 797                 if (!f) {
 798                         throw OpenFileError (wx_to_std (d->GetPath ()), errno, OpenFileError::WRITE);
 799                 }
 800
 801                 string current;
 802                 while (!feof (f)) {
 803                         char buffer[128];
 804                         if (fgets (buffer, 128, f) == 0) {
 805                                 break;
 806                         }
 807                         current += buffer;
 808                         if (strncmp (buffer, "-----END CERTIFICATE-----", 25) == 0) {
 809                                 new_chain->add (dcp::Certificate (current));
 810                                 current = "";
 811                         } else if (strncmp (buffer, "-----END RSA PRIVATE KEY-----", 29) == 0) {
 812                                 new_chain->set_key (current);
 813                                 current = "";
 814                         }
 815                 }
 816                 fclose (f);
 817
 818                 if (new_chain->chain_valid() && new_chain->private_key_valid()) {
 819                         Config::instance()->set_decryption_chain (new_chain);
 820                 } else {
 821                         error_dialog (_panel, _("Invalid DCP-o-matic export file"));
 822                 }
 823         }
 824         d->Destroy ();
 825 }
 826
 827 bool
 828 KeysPage::nag_alter_decryption_chain ()
 829 {
 830         return NagDialog::maybe_nag (
 831                 _panel,
 832                 Config::NAG_ALTER_DECRYPTION_CHAIN,
 833                 _("If you continue with this operation you will no longer be able to use any DKDMs that you have created.  Also, any KDMs that have been sent to you will become useless.  Proceed with caution!"),
 834                 true
 835                 );
 836 }
 837
 838 void
 839 KeysPage::export_decryption_certificate ()
 840 {
 841         auto config = Config::instance();
 842         wxString default_name = "dcpomatic";
 843         if (!config->dcp_creator().empty()) {
 844                 default_name += "_" + std_to_wx(careful_string_filter(config->dcp_creator()));
 845         }
 846         if (!config->dcp_issuer().empty()) {
 847                 default_name += "_" + std_to_wx(careful_string_filter(config->dcp_issuer()));
 848         }
 849         /// TRANSLATORS: this is the suffix of the defautl filename used when exporting KDM decryption leaf certificates
 850         default_name += _("_kdm_decryption_cert.pem");
 851
 852         auto d = new wxFileDialog (
 853                 _panel, _("Select Certificate File"), wxEmptyString, default_name, wxT("PEM files (*.pem)|*.pem"),
 854                 wxFD_SAVE | wxFD_OVERWRITE_PROMPT
 855                 );
 856
 857         if (d->ShowModal () == wxID_OK) {
 858                 boost::filesystem::path path (wx_to_std(d->GetPath()));
 859                 if (path.extension() != ".pem") {
 860                         path += ".pem";
 861                 }
 862                 auto f = fopen_boost (path, "w");
 863                 if (!f) {
 864                         throw OpenFileError (path, errno, OpenFileError::WRITE);
 865                 }
 866
 867                 auto const s = Config::instance()->decryption_chain()->leaf().certificate (true);
 868                 checked_fwrite (s.c_str(), s.length(), f, path);
 869                 fclose (f);
 870         }
 871
 872         d->Destroy ();
 873 }
 874
 875 wxString
 876 SoundPage::GetName () const
 877 {
 878         return _("Sound");
 879 }
 880
 881 void
 882 SoundPage::setup ()
 883 {
 884         auto table = new wxGridBagSizer (DCPOMATIC_SIZER_X_GAP, DCPOMATIC_SIZER_Y_GAP);
 885         _panel->GetSizer()->Add (table, 1, wxALL | wxEXPAND, _border);
 886
 887         int r = 0;
 888
 889         _sound = new CheckBox (_panel, _("Play sound via"));
 890         table->Add (_sound, wxGBPosition (r, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL);
 891         wxBoxSizer* s = new wxBoxSizer (wxHORIZONTAL);
 892         _sound_output = new wxChoice (_panel, wxID_ANY);
 893         s->Add (_sound_output, 0);
 894         _sound_output_details = new wxStaticText (_panel, wxID_ANY, wxT(""));
 895         s->Add (_sound_output_details, 1, wxALIGN_CENTER_VERTICAL | wxLEFT, DCPOMATIC_SIZER_X_GAP);
 896         table->Add (s, wxGBPosition(r, 1));
 897         ++r;
 898
 899         add_label_to_sizer (table, _panel, _("Mapping"), true, wxGBPosition(r, 0));
 900         _map = new AudioMappingView (_panel, _("DCP"), _("DCP"), _("Output"), _("output"));
 901         _map->SetSize (-1, 600);
 902         table->Add (_map, wxGBPosition(r, 1), wxDefaultSpan, wxEXPAND);
 903         ++r;
 904
 905         _reset_to_default = new Button (_panel, _("Reset to default"));
 906         table->Add (_reset_to_default, wxGBPosition(r, 1));
 907         ++r;
 908
 909         wxFont font = _sound_output_details->GetFont();
 910         font.SetStyle (wxFONTSTYLE_ITALIC);
 911         font.SetPointSize (font.GetPointSize() - 1);
 912         _sound_output_details->SetFont (font);
 913
 914         RtAudio audio (DCPOMATIC_RTAUDIO_API);
 915         for (unsigned int i = 0; i < audio.getDeviceCount(); ++i) {
 916                 try {
 917                         auto dev = audio.getDeviceInfo (i);
 918                         if (dev.probed && dev.outputChannels > 0) {
 919                                 _sound_output->Append (std_to_wx (dev.name));
 920                         }
 921                 } catch (RtAudioError&) {
 922                         /* Something went wrong so let's just ignore that device */
 923                 }
 924         }
 925
 926         _sound->Bind        (wxEVT_CHECKBOX, bind(&SoundPage::sound_changed, this));
 927         _sound_output->Bind (wxEVT_CHOICE,   bind(&SoundPage::sound_output_changed, this));
 928         _map->Changed.connect (bind(&SoundPage::map_changed, this, _1));
 929         _reset_to_default->Bind (wxEVT_BUTTON,   bind(&SoundPage::reset_to_default, this));
 930 }
 931
 932 void
 933 SoundPage::reset_to_default ()
 934 {
 935         Config::instance()->set_audio_mapping_to_default ();
 936 }
 937
 938 void
 939 SoundPage::map_changed (AudioMapping m)
 940 {
 941         Config::instance()->set_audio_mapping (m);
 942 }
 943
 944 void
 945 SoundPage::sound_changed ()
 946 {
 947         Config::instance()->set_sound (_sound->GetValue ());
 948 }
 949
 950 void
 951 SoundPage::sound_output_changed ()
 952 {
 953         RtAudio audio (DCPOMATIC_RTAUDIO_API);
 954         auto const so = get_sound_output();
 955         string default_device;
 956         try {
 957                 default_device = audio.getDeviceInfo(audio.getDefaultOutputDevice()).name;
 958         } catch (RtAudioError&) {
 959                 /* Never mind */
 960         }
 961         if (!so || *so == default_device) {
 962                 Config::instance()->unset_sound_output ();
 963         } else {
 964                 Config::instance()->set_sound_output (*so);
 965         }
 966 }
 967
 968 void
 969 SoundPage::config_changed ()
 970 {
 971         auto config = Config::instance ();
 972
 973         checked_set (_sound, config->sound ());
 974
 975         auto const current_so = get_sound_output ();
 976         optional<string> configured_so;
 977
 978         if (config->sound_output()) {
 979                 configured_so = config->sound_output().get();
 980         } else {
 981                 /* No configured output means we should use the default */
 982                 RtAudio audio (DCPOMATIC_RTAUDIO_API);
 983                 try {
 984                         configured_so = audio.getDeviceInfo(audio.getDefaultOutputDevice()).name;
 985                 } catch (RtAudioError&) {
 986                         /* Probably no audio devices at all */
 987                 }
 988         }
 989
 990         if (configured_so && current_so != configured_so) {
 991                 /* Update _sound_output with the configured value */
 992                 unsigned int i = 0;
 993                 while (i < _sound_output->GetCount()) {
 994                         if (_sound_output->GetString(i) == std_to_wx(*configured_so)) {
 995                                 _sound_output->SetSelection (i);
 996                                 break;
 997                         }
 998                         ++i;
 999                 }
1000         }
1001
1002         RtAudio audio (DCPOMATIC_RTAUDIO_API);
1003
1004         map<int, wxString> apis;
1005         apis[RtAudio::MACOSX_CORE]    = _("CoreAudio");
1006         apis[RtAudio::WINDOWS_ASIO]   = _("ASIO");
1007         apis[RtAudio::WINDOWS_DS]     = _("Direct Sound");
1008         apis[RtAudio::WINDOWS_WASAPI] = _("WASAPI");
1009         apis[RtAudio::UNIX_JACK]      = _("JACK");
1010         apis[RtAudio::LINUX_ALSA]     = _("ALSA");
1011         apis[RtAudio::LINUX_PULSE]    = _("PulseAudio");
1012         apis[RtAudio::LINUX_OSS]      = _("OSS");
1013         apis[RtAudio::RTAUDIO_DUMMY]  = _("Dummy");
1014
1015         int channels = 0;
1016         if (configured_so) {
1017                 for (unsigned int i = 0; i < audio.getDeviceCount(); ++i) {
1018                         try {
1019                                 auto info = audio.getDeviceInfo(i);
1020                                 if (info.name == *configured_so && info.outputChannels > 0) {
1021                                         channels = info.outputChannels;
1022                                 }
1023                         } catch (RtAudioError&) {
1024                                 /* Never mind */
1025                         }
1026                 }
1027         }
1028
1029         _sound_output_details->SetLabel (
1030                 wxString::Format(_("%d channels on %s"), channels, apis[audio.getCurrentApi()])
1031                 );
1032
1033         _map->set (Config::instance()->audio_mapping(channels));
1034
1035         vector<NamedChannel> input;
1036         for (int i = 0; i < MAX_DCP_AUDIO_CHANNELS; ++i) {
1037                 input.push_back (NamedChannel(short_audio_channel_name(i), i));
1038         }
1039         _map->set_input_channels (input);
1040
1041         vector<NamedChannel> output;
1042         for (int i = 0; i < channels; ++i) {
1043                 output.push_back (NamedChannel(dcp::raw_convert<string>(i), i));
1044         }
1045         _map->set_output_channels (output);
1046
1047         setup_sensitivity ();
1048 }
1049
1050 void
1051 SoundPage::setup_sensitivity ()
1052 {
1053         _sound_output->Enable (_sound->GetValue());
1054 }
1055
1056 /** @return Currently-selected preview sound output in the dialogue */
1057 optional<string>
1058 SoundPage::get_sound_output ()
1059 {
1060         int const sel = _sound_output->GetSelection ();
1061         if (sel == wxNOT_FOUND) {
1062                 return optional<string> ();
1063         }
1064
1065         return wx_to_std (_sound_output->GetString (sel));
1066 }
1067
1068
1069 LocationsPage::LocationsPage (wxSize panel_size, int border)
1070         : Page (panel_size, border)
1071 {
1072
1073 }
1074
1075 wxString
1076 LocationsPage::GetName () const
1077 {
1078         return _("Locations");
1079 }
1080
1081 #ifdef DCPOMATIC_OSX
1082 wxBitmap
1083 LocationsPage::GetLargeIcon () const
1084 {
1085         return wxBitmap ("locations", wxBITMAP_TYPE_PNG_RESOURCE);
1086 }
1087 #endif
1088
1089 void
1090 LocationsPage::setup ()
1091 {
1092         int r = 0;
1093
1094         auto table = new wxGridBagSizer (DCPOMATIC_SIZER_X_GAP, DCPOMATIC_SIZER_Y_GAP);
1095         _panel->GetSizer()->Add (table, 1, wxALL | wxEXPAND, _border);
1096
1097         add_label_to_sizer (table, _panel, _("Content directory"), true, wxGBPosition (r, 0));
1098         _content_directory = new wxDirPickerCtrl (_panel, wxID_ANY, wxEmptyString, wxDirSelectorPromptStr, wxDefaultPosition, wxSize (300, -1));
1099         table->Add (_content_directory, wxGBPosition (r, 1));
1100         ++r;
1101
1102         add_label_to_sizer (table, _panel, _("Playlist directory"), true, wxGBPosition (r, 0));
1103         _playlist_directory = new wxDirPickerCtrl (_panel, wxID_ANY, wxEmptyString, wxDirSelectorPromptStr, wxDefaultPosition, wxSize (300, -1));
1104         table->Add (_playlist_directory, wxGBPosition (r, 1));
1105         ++r;
1106
1107         add_label_to_sizer (table, _panel, _("KDM directory"), true, wxGBPosition (r, 0));
1108         _kdm_directory = new wxDirPickerCtrl (_panel, wxID_ANY, wxEmptyString, wxDirSelectorPromptStr, wxDefaultPosition, wxSize (300, -1));
1109         table->Add (_kdm_directory, wxGBPosition (r, 1));
1110         ++r;
1111
1112         _content_directory->Bind (wxEVT_DIRPICKER_CHANGED, bind(&LocationsPage::content_directory_changed, this));
1113         _playlist_directory->Bind (wxEVT_DIRPICKER_CHANGED, bind(&LocationsPage::playlist_directory_changed, this));
1114         _kdm_directory->Bind (wxEVT_DIRPICKER_CHANGED, bind(&LocationsPage::kdm_directory_changed, this));
1115 }
1116
1117 void
1118 LocationsPage::config_changed ()
1119 {
1120         auto config = Config::instance ();
1121
1122         if (config->player_content_directory()) {
1123                 checked_set (_content_directory, *config->player_content_directory());
1124         }
1125         if (config->player_playlist_directory()) {
1126                 checked_set (_playlist_directory, *config->player_playlist_directory());
1127         }
1128         if (config->player_kdm_directory()) {
1129                 checked_set (_kdm_directory, *config->player_kdm_directory());
1130         }
1131 }
1132
1133 void
1134 LocationsPage::content_directory_changed ()
1135 {
1136         Config::instance()->set_player_content_directory(wx_to_std(_content_directory->GetPath()));
1137 }
1138
1139 void
1140 LocationsPage::playlist_directory_changed ()
1141 {
1142         Config::instance()->set_player_playlist_directory(wx_to_std(_playlist_directory->GetPath()));
1143 }
1144
1145 void
1146 LocationsPage::kdm_directory_changed ()
1147 {
1148         Config::instance()->set_player_kdm_directory(wx_to_std(_kdm_directory->GetPath()));
1149 }