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, wxT("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         if (_nag_alter()) {
 540                 /* Cancel was clicked */
 541                 return;
 542         }
 543
 544         auto d = new MakeChainDialog (this, _get());
 545
 546         if (d->ShowModal () == wxID_OK) {
 547                 _set (d->get());
 548                 update_certificate_list ();
 549                 update_private_key ();
 550         }
 551
 552         d->Destroy ();
 553 }
 554
 555 void
 556 CertificateChainEditor::update_sensitivity ()
 557 {
 558         /* We can only remove the leaf certificate */
 559         _remove_certificate->Enable (_certificates->GetNextItem(-1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED) == (_certificates->GetItemCount() - 1));
 560         _export_certificate->Enable (_certificates->GetNextItem(-1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED) != -1);
 561 }
 562
 563 void
 564 CertificateChainEditor::update_private_key ()
 565 {
 566         checked_set (_private_key, dcp::private_key_fingerprint (_get()->key().get()));
 567         _sizer->Layout ();
 568 }
 569
 570 void
 571 CertificateChainEditor::import_private_key ()
 572 {
 573         auto d = new wxFileDialog (this, _("Select Key File"));
 574
 575         if (d->ShowModal() == wxID_OK) {
 576                 try {
 577                         boost::filesystem::path p (wx_to_std (d->GetPath ()));
 578                         if (boost::filesystem::file_size (p) > 8192) {
 579                                 error_dialog (
 580                                         this,
 581                                         wxString::Format (_("Could not read key file; file is too long (%s)"), std_to_wx (p.string ()))
 582                                         );
 583                                 return;
 584                         }
 585
 586                         auto chain = make_shared<dcp::CertificateChain>(*_get().get());
 587                         chain->set_key (dcp::file_to_string (p));
 588                         _set (chain);
 589                         update_private_key ();
 590                 } catch (std::exception& e) {
 591                         error_dialog (this, _("Could not read certificate file."), std_to_wx(e.what()));
 592                 }
 593         }
 594
 595         d->Destroy ();
 596
 597         update_sensitivity ();
 598 }
 599
 600 void
 601 CertificateChainEditor::export_private_key ()
 602 {
 603         auto key = _get()->key();
 604         if (!key) {
 605                 return;
 606         }
 607
 608         auto d = new wxFileDialog (
 609                 this, _("Select Key File"), wxEmptyString, wxT("private_key.pem"), wxT("PEM files (*.pem)|*.pem"),
 610                 wxFD_SAVE | wxFD_OVERWRITE_PROMPT
 611                 );
 612
 613         if (d->ShowModal () == wxID_OK) {
 614                 boost::filesystem::path path (wx_to_std(d->GetPath()));
 615                 if (path.extension() != ".pem") {
 616                         path += ".pem";
 617                 }
 618                 auto f = fopen_boost (path, "w");
 619                 if (!f) {
 620                         throw OpenFileError (path, errno, OpenFileError::WRITE);
 621                 }
 622
 623                 auto const s = _get()->key().get ();
 624                 checked_fwrite (s.c_str(), s.length(), f, path);
 625                 fclose (f);
 626         }
 627         d->Destroy ();
 628 }
 629
 630 wxString
 631 KeysPage::GetName () const
 632 {
 633         return _("Keys");
 634 }
 635
 636 void
 637 KeysPage::setup ()
 638 {
 639         wxFont subheading_font (*wxNORMAL_FONT);
 640         subheading_font.SetWeight (wxFONTWEIGHT_BOLD);
 641
 642         auto sizer = _panel->GetSizer();
 643
 644         {
 645                 auto m = new StaticText (_panel, _("Decrypting KDMs"));
 646                 m->SetFont (subheading_font);
 647                 sizer->Add (m, 0, wxALL | wxEXPAND, _border);
 648         }
 649
 650         auto buttons = new wxBoxSizer (wxVERTICAL);
 651
 652         auto export_decryption_certificate = new Button (_panel, _("Export KDM decryption leaf certificate..."));
 653         buttons->Add (export_decryption_certificate, 0, wxBOTTOM, DCPOMATIC_BUTTON_STACK_GAP);
 654         auto export_settings = new Button (_panel, _("Export all KDM decryption settings..."));
 655         buttons->Add (export_settings, 0, wxBOTTOM, DCPOMATIC_BUTTON_STACK_GAP);
 656         auto import_settings = new Button (_panel, _("Import all KDM decryption settings..."));
 657         buttons->Add (import_settings, 0, wxBOTTOM, DCPOMATIC_BUTTON_STACK_GAP);
 658         auto decryption_advanced = new Button (_panel, _("Advanced..."));
 659         buttons->Add (decryption_advanced, 0);
 660
 661         sizer->Add (buttons, 0, wxLEFT, _border);
 662
 663         export_decryption_certificate->Bind (wxEVT_BUTTON, bind (&KeysPage::export_decryption_certificate, this));
 664         export_settings->Bind (wxEVT_BUTTON, bind (&KeysPage::export_decryption_chain_and_key, this));
 665         import_settings->Bind (wxEVT_BUTTON, bind (&KeysPage::import_decryption_chain_and_key, this));
 666         decryption_advanced->Bind (wxEVT_BUTTON, bind (&KeysPage::decryption_advanced, this));
 667
 668         {
 669                 auto m = new StaticText (_panel, _("Signing DCPs and KDMs"));
 670                 m->SetFont (subheading_font);
 671                 sizer->Add (m, 0, wxALL | wxEXPAND, _border);
 672         }
 673
 674         auto signing_advanced = new Button (_panel, _("Advanced..."));
 675         sizer->Add (signing_advanced, 0, wxLEFT | wxBOTTOM, _border);
 676         signing_advanced->Bind (wxEVT_BUTTON, bind (&KeysPage::signing_advanced, this));
 677 }
 678
 679 void
 680 KeysPage::decryption_advanced ()
 681 {
 682         auto c = new CertificateChainEditor (
 683                 _panel, _("Decrypting KDMs"), _border,
 684                 bind(&Config::set_decryption_chain, Config::instance(), _1),
 685                 bind(&Config::decryption_chain, Config::instance()),
 686                 bind(&KeysPage::nag_alter_decryption_chain, this)
 687                 );
 688
 689         c->ShowModal();
 690 }
 691
 692 void
 693 KeysPage::signing_advanced ()
 694 {
 695         auto c = new CertificateChainEditor (
 696                 _panel, _("Signing DCPs and KDMs"), _border,
 697                 bind(&Config::set_signer_chain, Config::instance(), _1),
 698                 bind(&Config::signer_chain, Config::instance()),
 699                 bind(&do_nothing)
 700                 );
 701
 702         c->ShowModal();
 703 }
 704
 705 void
 706 KeysPage::export_decryption_chain_and_key ()
 707 {
 708         auto d = new wxFileDialog (
 709                 _panel, _("Select Export File"), wxEmptyString, wxEmptyString, wxT ("DOM files (*.dom)|*.dom"),
 710                 wxFD_SAVE | wxFD_OVERWRITE_PROMPT
 711                 );
 712
 713         if (d->ShowModal () == wxID_OK) {
 714                 boost::filesystem::path path (wx_to_std(d->GetPath()));
 715                 auto f = fopen_boost (path, "w");
 716                 if (!f) {
 717                         throw OpenFileError (path, errno, OpenFileError::WRITE);
 718                 }
 719
 720                 auto const chain = Config::instance()->decryption_chain()->chain();
 721                 checked_fwrite (chain.c_str(), chain.length(), f, path);
 722                 optional<string> const key = Config::instance()->decryption_chain()->key();
 723                 DCPOMATIC_ASSERT (key);
 724                 checked_fwrite (key->c_str(), key->length(), f, path);
 725                 fclose (f);
 726         }
 727         d->Destroy ();
 728
 729 }
 730
 731 void
 732 KeysPage::import_decryption_chain_and_key ()
 733 {
 734         if (NagDialog::maybe_nag (
 735                     _panel,
 736                     Config::NAG_IMPORT_DECRYPTION_CHAIN,
 737                     _("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!"),
 738                     true
 739                     )) {
 740                 return;
 741         }
 742
 743         auto d = new wxFileDialog (
 744                 _panel, _("Select File To Import"), wxEmptyString, wxEmptyString, wxT ("DOM files (*.dom)|*.dom")
 745                 );
 746
 747         if (d->ShowModal () == wxID_OK) {
 748                 auto new_chain = make_shared<dcp::CertificateChain>();
 749
 750                 FILE* f = fopen_boost (wx_to_std (d->GetPath ()), "r");
 751                 if (!f) {
 752                         throw OpenFileError (wx_to_std (d->GetPath ()), errno, OpenFileError::WRITE);
 753                 }
 754
 755                 string current;
 756                 while (!feof (f)) {
 757                         char buffer[128];
 758                         if (fgets (buffer, 128, f) == 0) {
 759                                 break;
 760                         }
 761                         current += buffer;
 762                         if (strncmp (buffer, "-----END CERTIFICATE-----", 25) == 0) {
 763                                 new_chain->add (dcp::Certificate (current));
 764                                 current = "";
 765                         } else if (strncmp (buffer, "-----END RSA PRIVATE KEY-----", 29) == 0) {
 766                                 new_chain->set_key (current);
 767                                 current = "";
 768                         }
 769                 }
 770                 fclose (f);
 771
 772                 if (new_chain->chain_valid() && new_chain->private_key_valid()) {
 773                         Config::instance()->set_decryption_chain (new_chain);
 774                 } else {
 775                         error_dialog (_panel, _("Invalid DCP-o-matic export file"));
 776                 }
 777         }
 778         d->Destroy ();
 779 }
 780
 781 bool
 782 KeysPage::nag_alter_decryption_chain ()
 783 {
 784         return NagDialog::maybe_nag (
 785                 _panel,
 786                 Config::NAG_ALTER_DECRYPTION_CHAIN,
 787                 _("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!"),
 788                 true
 789                 );
 790 }
 791
 792 void
 793 KeysPage::export_decryption_certificate ()
 794 {
 795         auto config = Config::instance();
 796         wxString default_name = "dcpomatic";
 797         if (!config->dcp_creator().empty()) {
 798                 default_name += "_" + std_to_wx(careful_string_filter(config->dcp_creator()));
 799         }
 800         if (!config->dcp_issuer().empty()) {
 801                 default_name += "_" + std_to_wx(careful_string_filter(config->dcp_issuer()));
 802         }
 803         default_name += wxT("_kdm_decryption_cert.pem");
 804
 805         auto d = new wxFileDialog (
 806                 _panel, _("Select Certificate File"), wxEmptyString, default_name, wxT("PEM files (*.pem)|*.pem"),
 807                 wxFD_SAVE | wxFD_OVERWRITE_PROMPT
 808                 );
 809
 810         if (d->ShowModal () == wxID_OK) {
 811                 boost::filesystem::path path (wx_to_std(d->GetPath()));
 812                 if (path.extension() != ".pem") {
 813                         path += ".pem";
 814                 }
 815                 auto f = fopen_boost (path, "w");
 816                 if (!f) {
 817                         throw OpenFileError (path, errno, OpenFileError::WRITE);
 818                 }
 819
 820                 auto const s = Config::instance()->decryption_chain()->leaf().certificate (true);
 821                 checked_fwrite (s.c_str(), s.length(), f, path);
 822                 fclose (f);
 823         }
 824
 825         d->Destroy ();
 826 }
 827
 828 wxString
 829 SoundPage::GetName () const
 830 {
 831         return _("Sound");
 832 }
 833
 834 void
 835 SoundPage::setup ()
 836 {
 837         auto table = new wxGridBagSizer (DCPOMATIC_SIZER_X_GAP, DCPOMATIC_SIZER_Y_GAP);
 838         _panel->GetSizer()->Add (table, 1, wxALL | wxEXPAND, _border);
 839
 840         int r = 0;
 841
 842         _sound = new CheckBox (_panel, _("Play sound via"));
 843         table->Add (_sound, wxGBPosition (r, 0), wxDefaultSpan, wxALIGN_CENTER_VERTICAL);
 844         wxBoxSizer* s = new wxBoxSizer (wxHORIZONTAL);
 845         _sound_output = new wxChoice (_panel, wxID_ANY);
 846         s->Add (_sound_output, 0);
 847         _sound_output_details = new wxStaticText (_panel, wxID_ANY, wxT(""));
 848         s->Add (_sound_output_details, 1, wxALIGN_CENTER_VERTICAL | wxLEFT, DCPOMATIC_SIZER_X_GAP);
 849         table->Add (s, wxGBPosition(r, 1));
 850         ++r;
 851
 852         add_label_to_sizer (table, _panel, _("Mapping"), true, wxGBPosition(r, 0));
 853         _map = new AudioMappingView (_panel, _("DCP"), _("DCP"), _("Output"), _("output"));
 854         _map->SetSize (-1, 400);
 855         table->Add (_map, wxGBPosition(r, 1), wxDefaultSpan, wxEXPAND);
 856         ++r;
 857
 858         _reset_to_default = new Button (_panel, _("Reset to default"));
 859         table->Add (_reset_to_default, wxGBPosition(r, 1));
 860         ++r;
 861
 862         wxFont font = _sound_output_details->GetFont();
 863         font.SetStyle (wxFONTSTYLE_ITALIC);
 864         font.SetPointSize (font.GetPointSize() - 1);
 865         _sound_output_details->SetFont (font);
 866
 867         RtAudio audio (DCPOMATIC_RTAUDIO_API);
 868         for (unsigned int i = 0; i < audio.getDeviceCount(); ++i) {
 869                 try {
 870                         auto dev = audio.getDeviceInfo (i);
 871                         if (dev.probed && dev.outputChannels > 0) {
 872                                 _sound_output->Append (std_to_wx (dev.name));
 873                         }
 874                 } catch (RtAudioError&) {
 875                         /* Something went wrong so let's just ignore that device */
 876                 }
 877         }
 878
 879         _sound->Bind        (wxEVT_CHECKBOX, bind(&SoundPage::sound_changed, this));
 880         _sound_output->Bind (wxEVT_CHOICE,   bind(&SoundPage::sound_output_changed, this));
 881         _map->Changed.connect (bind(&SoundPage::map_changed, this, _1));
 882         _reset_to_default->Bind (wxEVT_BUTTON,   bind(&SoundPage::reset_to_default, this));
 883 }
 884
 885 void
 886 SoundPage::reset_to_default ()
 887 {
 888         Config::instance()->set_audio_mapping_to_default ();
 889 }
 890
 891 void
 892 SoundPage::map_changed (AudioMapping m)
 893 {
 894         Config::instance()->set_audio_mapping (m);
 895 }
 896
 897 void
 898 SoundPage::sound_changed ()
 899 {
 900         Config::instance()->set_sound (_sound->GetValue ());
 901 }
 902
 903 void
 904 SoundPage::sound_output_changed ()
 905 {
 906         RtAudio audio (DCPOMATIC_RTAUDIO_API);
 907         auto const so = get_sound_output();
 908         string default_device;
 909         try {
 910                 default_device = audio.getDeviceInfo(audio.getDefaultOutputDevice()).name;
 911         } catch (RtAudioError&) {
 912                 /* Never mind */
 913         }
 914         if (!so || *so == default_device) {
 915                 Config::instance()->unset_sound_output ();
 916         } else {
 917                 Config::instance()->set_sound_output (*so);
 918         }
 919 }
 920
 921 void
 922 SoundPage::config_changed ()
 923 {
 924         auto config = Config::instance ();
 925
 926         checked_set (_sound, config->sound ());
 927
 928         auto const current_so = get_sound_output ();
 929         optional<string> configured_so;
 930
 931         if (config->sound_output()) {
 932                 configured_so = config->sound_output().get();
 933         } else {
 934                 /* No configured output means we should use the default */
 935                 RtAudio audio (DCPOMATIC_RTAUDIO_API);
 936                 try {
 937                         configured_so = audio.getDeviceInfo(audio.getDefaultOutputDevice()).name;
 938                 } catch (RtAudioError&) {
 939                         /* Probably no audio devices at all */
 940                 }
 941         }
 942
 943         if (configured_so && current_so != configured_so) {
 944                 /* Update _sound_output with the configured value */
 945                 unsigned int i = 0;
 946                 while (i < _sound_output->GetCount()) {
 947                         if (_sound_output->GetString(i) == std_to_wx(*configured_so)) {
 948                                 _sound_output->SetSelection (i);
 949                                 break;
 950                         }
 951                         ++i;
 952                 }
 953         }
 954
 955         RtAudio audio (DCPOMATIC_RTAUDIO_API);
 956
 957         map<int, wxString> apis;
 958         apis[RtAudio::MACOSX_CORE]    = _("CoreAudio");
 959         apis[RtAudio::WINDOWS_ASIO]   = _("ASIO");
 960         apis[RtAudio::WINDOWS_DS]     = _("Direct Sound");
 961         apis[RtAudio::WINDOWS_WASAPI] = _("WASAPI");
 962         apis[RtAudio::UNIX_JACK]      = _("JACK");
 963         apis[RtAudio::LINUX_ALSA]     = _("ALSA");
 964         apis[RtAudio::LINUX_PULSE]    = _("PulseAudio");
 965         apis[RtAudio::LINUX_OSS]      = _("OSS");
 966         apis[RtAudio::RTAUDIO_DUMMY]  = _("Dummy");
 967
 968         int channels = 0;
 969         if (configured_so) {
 970                 for (unsigned int i = 0; i < audio.getDeviceCount(); ++i) {
 971                         try {
 972                                 auto info = audio.getDeviceInfo(i);
 973                                 if (info.name == *configured_so && info.outputChannels > 0) {
 974                                         channels = info.outputChannels;
 975                                 }
 976                         } catch (RtAudioError&) {
 977                                 /* Never mind */
 978                         }
 979                 }
 980         }
 981
 982         _sound_output_details->SetLabel (
 983                 wxString::Format(_("%d channels on %s"), channels, apis[audio.getCurrentApi()])
 984                 );
 985
 986         _map->set (Config::instance()->audio_mapping(channels));
 987
 988         vector<NamedChannel> input;
 989         for (int i = 0; i < MAX_DCP_AUDIO_CHANNELS; ++i) {
 990                 input.push_back (NamedChannel(short_audio_channel_name(i), i));
 991         }
 992         _map->set_input_channels (input);
 993
 994         vector<NamedChannel> output;
 995         for (int i = 0; i < channels; ++i) {
 996                 output.push_back (NamedChannel(dcp::raw_convert<string>(i), i));
 997         }
 998         _map->set_output_channels (output);
 999
1000         setup_sensitivity ();
1001 }
1002
1003 void
1004 SoundPage::setup_sensitivity ()
1005 {
1006         _sound_output->Enable (_sound->GetValue());
1007 }
1008
1009 /** @return Currently-selected preview sound output in the dialogue */
1010 optional<string>
1011 SoundPage::get_sound_output ()
1012 {
1013         int const sel = _sound_output->GetSelection ();
1014         if (sel == wxNOT_FOUND) {
1015                 return optional<string> ();
1016         }
1017
1018         return wx_to_std (_sound_output->GetString (sel));
1019 }
1020
1021
1022 LocationsPage::LocationsPage (wxSize panel_size, int border)
1023         : Page (panel_size, border)
1024 {
1025
1026 }
1027
1028 wxString
1029 LocationsPage::GetName () const
1030 {
1031         return _("Locations");
1032 }
1033
1034 #ifdef DCPOMATIC_OSX
1035 wxBitmap
1036 LocationsPage::GetLargeIcon () const
1037 {
1038         return wxBitmap(bitmap_path("locations"), wxBITMAP_TYPE_PNG);
1039 }
1040 #endif
1041
1042 void
1043 LocationsPage::setup ()
1044 {
1045         int r = 0;
1046
1047         auto table = new wxGridBagSizer (DCPOMATIC_SIZER_X_GAP, DCPOMATIC_SIZER_Y_GAP);
1048         _panel->GetSizer()->Add (table, 1, wxALL | wxEXPAND, _border);
1049
1050         add_label_to_sizer (table, _panel, _("Content directory"), true, wxGBPosition (r, 0));
1051         _content_directory = new wxDirPickerCtrl (_panel, wxID_ANY, wxEmptyString, wxDirSelectorPromptStr, wxDefaultPosition, wxSize (300, -1));
1052         table->Add (_content_directory, wxGBPosition (r, 1));
1053         ++r;
1054
1055         add_label_to_sizer (table, _panel, _("Playlist directory"), true, wxGBPosition (r, 0));
1056         _playlist_directory = new wxDirPickerCtrl (_panel, wxID_ANY, wxEmptyString, wxDirSelectorPromptStr, wxDefaultPosition, wxSize (300, -1));
1057         table->Add (_playlist_directory, wxGBPosition (r, 1));
1058         ++r;
1059
1060         add_label_to_sizer (table, _panel, _("KDM directory"), true, wxGBPosition (r, 0));
1061         _kdm_directory = new wxDirPickerCtrl (_panel, wxID_ANY, wxEmptyString, wxDirSelectorPromptStr, wxDefaultPosition, wxSize (300, -1));
1062         table->Add (_kdm_directory, wxGBPosition (r, 1));
1063         ++r;
1064
1065         _content_directory->Bind (wxEVT_DIRPICKER_CHANGED, bind(&LocationsPage::content_directory_changed, this));
1066         _playlist_directory->Bind (wxEVT_DIRPICKER_CHANGED, bind(&LocationsPage::playlist_directory_changed, this));
1067         _kdm_directory->Bind (wxEVT_DIRPICKER_CHANGED, bind(&LocationsPage::kdm_directory_changed, this));
1068 }
1069
1070 void
1071 LocationsPage::config_changed ()
1072 {
1073         auto config = Config::instance ();
1074
1075         if (config->player_content_directory()) {
1076                 checked_set (_content_directory, *config->player_content_directory());
1077         }
1078         if (config->player_playlist_directory()) {
1079                 checked_set (_playlist_directory, *config->player_playlist_directory());
1080         }
1081         if (config->player_kdm_directory()) {
1082                 checked_set (_kdm_directory, *config->player_kdm_directory());
1083         }
1084 }
1085
1086 void
1087 LocationsPage::content_directory_changed ()
1088 {
1089         Config::instance()->set_player_content_directory(wx_to_std(_content_directory->GetPath()));
1090 }
1091
1092 void
1093 LocationsPage::playlist_directory_changed ()
1094 {
1095         Config::instance()->set_player_playlist_directory(wx_to_std(_playlist_directory->GetPath()));
1096 }
1097
1098 void
1099 LocationsPage::kdm_directory_changed ()
1100 {
1101         Config::instance()->set_player_kdm_directory(wx_to_std(_kdm_directory->GetPath()));
1102 }