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 boost::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         wxFileDialog* d = new wxFileDialog (
 842                 _panel, _("Select Certificate File"), wxEmptyString, _("dcpomatic_kdm_decryption_cert.pem"), wxT ("PEM files (*.pem)|*.pem"),
 843                 wxFD_SAVE | wxFD_OVERWRITE_PROMPT
 844                 );
 845
 846         if (d->ShowModal () == wxID_OK) {
 847                 boost::filesystem::path path (wx_to_std(d->GetPath()));
 848                 if (path.extension() != ".pem") {
 849                         path += ".pem";
 850                 }
 851                 auto f = fopen_boost (path, "w");
 852                 if (!f) {
 853                         throw OpenFileError (path, errno, OpenFileError::WRITE);
 854                 }
 855
 856                 auto const s = Config::instance()->decryption_chain()->leaf().certificate (true);
 857                 checked_fwrite (s.c_str(), s.length(), f, path);
 858                 fclose (f);
 859         }
 860
 861         d->Destroy ();
 862 }
 863
 864 wxString
 865 SoundPage::GetName () const
 866 {
 867         return _("Sound");
 868 }
 869
 870 void
 871 SoundPage::setup ()
 872 {
 873         auto table = new wxGridBagSizer (DCPOMATIC_SIZER_X_GAP, DCPOMATIC_SIZER_Y_GAP);
 874         _panel->GetSizer()->Add (table, 1, wxALL | wxEXPAND, _border);
 875
 876         int r = 0;
 877
 878         _sound = new CheckBox (_panel, _("Play sound via"));
 879         table->Add (_sound, wxGBPosition (r, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL);
 880         wxBoxSizer* s = new wxBoxSizer (wxHORIZONTAL);
 881         _sound_output = new wxChoice (_panel, wxID_ANY);
 882         s->Add (_sound_output, 0);
 883         _sound_output_details = new wxStaticText (_panel, wxID_ANY, wxT(""));
 884         s->Add (_sound_output_details, 1, wxALIGN_CENTER_VERTICAL | wxLEFT, DCPOMATIC_SIZER_X_GAP);
 885         table->Add (s, wxGBPosition(r, 1));
 886         ++r;
 887
 888         add_label_to_sizer (table, _panel, _("Mapping"), true, wxGBPosition(r, 0));
 889         _map = new AudioMappingView (_panel, _("DCP"), _("DCP"), _("Output"), _("output"));
 890         _map->SetSize (-1, 600);
 891         table->Add (_map, wxGBPosition(r, 1), wxDefaultSpan, wxEXPAND);
 892         ++r;
 893
 894         _reset_to_default = new Button (_panel, _("Reset to default"));
 895         table->Add (_reset_to_default, wxGBPosition(r, 1));
 896         ++r;
 897
 898         wxFont font = _sound_output_details->GetFont();
 899         font.SetStyle (wxFONTSTYLE_ITALIC);
 900         font.SetPointSize (font.GetPointSize() - 1);
 901         _sound_output_details->SetFont (font);
 902
 903         RtAudio audio (DCPOMATIC_RTAUDIO_API);
 904         for (unsigned int i = 0; i < audio.getDeviceCount(); ++i) {
 905                 try {
 906                         auto dev = audio.getDeviceInfo (i);
 907                         if (dev.probed && dev.outputChannels > 0) {
 908                                 _sound_output->Append (std_to_wx (dev.name));
 909                         }
 910                 } catch (RtAudioError&) {
 911                         /* Something went wrong so let's just ignore that device */
 912                 }
 913         }
 914
 915         _sound->Bind        (wxEVT_CHECKBOX, bind(&SoundPage::sound_changed, this));
 916         _sound_output->Bind (wxEVT_CHOICE,   bind(&SoundPage::sound_output_changed, this));
 917         _map->Changed.connect (bind(&SoundPage::map_changed, this, _1));
 918         _reset_to_default->Bind (wxEVT_BUTTON,   bind(&SoundPage::reset_to_default, this));
 919 }
 920
 921 void
 922 SoundPage::reset_to_default ()
 923 {
 924         Config::instance()->set_audio_mapping_to_default ();
 925 }
 926
 927 void
 928 SoundPage::map_changed (AudioMapping m)
 929 {
 930         Config::instance()->set_audio_mapping (m);
 931 }
 932
 933 void
 934 SoundPage::sound_changed ()
 935 {
 936         Config::instance()->set_sound (_sound->GetValue ());
 937 }
 938
 939 void
 940 SoundPage::sound_output_changed ()
 941 {
 942         RtAudio audio (DCPOMATIC_RTAUDIO_API);
 943         auto const so = get_sound_output();
 944         string default_device;
 945         try {
 946                 default_device = audio.getDeviceInfo(audio.getDefaultOutputDevice()).name;
 947         } catch (RtAudioError&) {
 948                 /* Never mind */
 949         }
 950         if (!so || *so == default_device) {
 951                 Config::instance()->unset_sound_output ();
 952         } else {
 953                 Config::instance()->set_sound_output (*so);
 954         }
 955 }
 956
 957 void
 958 SoundPage::config_changed ()
 959 {
 960         auto config = Config::instance ();
 961
 962         checked_set (_sound, config->sound ());
 963
 964         auto const current_so = get_sound_output ();
 965         optional<string> configured_so;
 966
 967         if (config->sound_output()) {
 968                 configured_so = config->sound_output().get();
 969         } else {
 970                 /* No configured output means we should use the default */
 971                 RtAudio audio (DCPOMATIC_RTAUDIO_API);
 972                 try {
 973                         configured_so = audio.getDeviceInfo(audio.getDefaultOutputDevice()).name;
 974                 } catch (RtAudioError&) {
 975                         /* Probably no audio devices at all */
 976                 }
 977         }
 978
 979         if (configured_so && current_so != configured_so) {
 980                 /* Update _sound_output with the configured value */
 981                 unsigned int i = 0;
 982                 while (i < _sound_output->GetCount()) {
 983                         if (_sound_output->GetString(i) == std_to_wx(*configured_so)) {
 984                                 _sound_output->SetSelection (i);
 985                                 break;
 986                         }
 987                         ++i;
 988                 }
 989         }
 990
 991         RtAudio audio (DCPOMATIC_RTAUDIO_API);
 992
 993         map<int, wxString> apis;
 994         apis[RtAudio::MACOSX_CORE]    = _("CoreAudio");
 995         apis[RtAudio::WINDOWS_ASIO]   = _("ASIO");
 996         apis[RtAudio::WINDOWS_DS]     = _("Direct Sound");
 997         apis[RtAudio::WINDOWS_WASAPI] = _("WASAPI");
 998         apis[RtAudio::UNIX_JACK]      = _("JACK");
 999         apis[RtAudio::LINUX_ALSA]     = _("ALSA");
1000         apis[RtAudio::LINUX_PULSE]    = _("PulseAudio");
1001         apis[RtAudio::LINUX_OSS]      = _("OSS");
1002         apis[RtAudio::RTAUDIO_DUMMY]  = _("Dummy");
1003
1004         int channels = 0;
1005         if (configured_so) {
1006                 for (unsigned int i = 0; i < audio.getDeviceCount(); ++i) {
1007                         try {
1008                                 auto info = audio.getDeviceInfo(i);
1009                                 if (info.name == *configured_so && info.outputChannels > 0) {
1010                                         channels = info.outputChannels;
1011                                 }
1012                         } catch (RtAudioError&) {
1013                                 /* Never mind */
1014                         }
1015                 }
1016         }
1017
1018         _sound_output_details->SetLabel (
1019                 wxString::Format(_("%d channels on %s"), channels, apis[audio.getCurrentApi()])
1020                 );
1021
1022         _map->set (Config::instance()->audio_mapping(channels));
1023
1024         vector<NamedChannel> input;
1025         for (int i = 0; i < MAX_DCP_AUDIO_CHANNELS; ++i) {
1026                 input.push_back (NamedChannel(short_audio_channel_name(i), i));
1027         }
1028         _map->set_input_channels (input);
1029
1030         vector<NamedChannel> output;
1031         for (int i = 0; i < channels; ++i) {
1032                 output.push_back (NamedChannel(dcp::raw_convert<string>(i), i));
1033         }
1034         _map->set_output_channels (output);
1035
1036         setup_sensitivity ();
1037 }
1038
1039 void
1040 SoundPage::setup_sensitivity ()
1041 {
1042         _sound_output->Enable (_sound->GetValue());
1043 }
1044
1045 /** @return Currently-selected preview sound output in the dialogue */
1046 optional<string>
1047 SoundPage::get_sound_output ()
1048 {
1049         int const sel = _sound_output->GetSelection ();
1050         if (sel == wxNOT_FOUND) {
1051                 return optional<string> ();
1052         }
1053
1054         return wx_to_std (_sound_output->GetString (sel));
1055 }
1056
1057
1058 LocationsPage::LocationsPage (wxSize panel_size, int border)
1059         : Page (panel_size, border)
1060 {
1061
1062 }
1063
1064 wxString
1065 LocationsPage::GetName () const
1066 {
1067         return _("Locations");
1068 }
1069
1070 #ifdef DCPOMATIC_OSX
1071 wxBitmap
1072 LocationsPage::GetLargeIcon () const
1073 {
1074         return wxBitmap ("locations", wxBITMAP_TYPE_PNG_RESOURCE);
1075 }
1076 #endif
1077
1078 void
1079 LocationsPage::setup ()
1080 {
1081         int r = 0;
1082
1083         auto table = new wxGridBagSizer (DCPOMATIC_SIZER_X_GAP, DCPOMATIC_SIZER_Y_GAP);
1084         _panel->GetSizer()->Add (table, 1, wxALL | wxEXPAND, _border);
1085
1086         add_label_to_sizer (table, _panel, _("Content directory"), true, wxGBPosition (r, 0));
1087         _content_directory = new wxDirPickerCtrl (_panel, wxID_ANY, wxEmptyString, wxDirSelectorPromptStr, wxDefaultPosition, wxSize (300, -1));
1088         table->Add (_content_directory, wxGBPosition (r, 1));
1089         ++r;
1090
1091         add_label_to_sizer (table, _panel, _("Playlist directory"), true, wxGBPosition (r, 0));
1092         _playlist_directory = new wxDirPickerCtrl (_panel, wxID_ANY, wxEmptyString, wxDirSelectorPromptStr, wxDefaultPosition, wxSize (300, -1));
1093         table->Add (_playlist_directory, wxGBPosition (r, 1));
1094         ++r;
1095
1096         add_label_to_sizer (table, _panel, _("KDM directory"), true, wxGBPosition (r, 0));
1097         _kdm_directory = new wxDirPickerCtrl (_panel, wxID_ANY, wxEmptyString, wxDirSelectorPromptStr, wxDefaultPosition, wxSize (300, -1));
1098         table->Add (_kdm_directory, wxGBPosition (r, 1));
1099         ++r;
1100
1101         _content_directory->Bind (wxEVT_DIRPICKER_CHANGED, bind(&LocationsPage::content_directory_changed, this));
1102         _playlist_directory->Bind (wxEVT_DIRPICKER_CHANGED, bind(&LocationsPage::playlist_directory_changed, this));
1103         _kdm_directory->Bind (wxEVT_DIRPICKER_CHANGED, bind(&LocationsPage::kdm_directory_changed, this));
1104 }
1105
1106 void
1107 LocationsPage::config_changed ()
1108 {
1109         auto config = Config::instance ();
1110
1111         if (config->player_content_directory()) {
1112                 checked_set (_content_directory, *config->player_content_directory());
1113         }
1114         if (config->player_playlist_directory()) {
1115                 checked_set (_playlist_directory, *config->player_playlist_directory());
1116         }
1117         if (config->player_kdm_directory()) {
1118                 checked_set (_kdm_directory, *config->player_kdm_directory());
1119         }
1120 }
1121
1122 void
1123 LocationsPage::content_directory_changed ()
1124 {
1125         Config::instance()->set_player_content_directory(wx_to_std(_content_directory->GetPath()));
1126 }
1127
1128 void
1129 LocationsPage::playlist_directory_changed ()
1130 {
1131         Config::instance()->set_player_playlist_directory(wx_to_std(_playlist_directory->GetPath()));
1132 }
1133
1134 void
1135 LocationsPage::kdm_directory_changed ()
1136 {
1137         Config::instance()->set_player_kdm_directory(wx_to_std(_kdm_directory->GetPath()));
1138 }