Give player its own configuration dialogue.

1 files changed, 346 insertions, 0 deletions

diff --git a/src/wx/config_dialog.h b/src/wx/config_dialog.h
new file mode 100644
index 000000000..a72879407
--- /dev/null
+++ b/src/wx/config_dialog.h
@@ -0,0 +1,346 @@
+/*
+    Copyright (C) 2012-2017 Carl Hetherington <cth@carlh.net>
+
+    This file is part of DCP-o-matic.
+
+    DCP-o-matic is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    DCP-o-matic is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with DCP-o-matic.  If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#ifndef DCPOMATIC_CONFIG_DIALOG_H
+#define DCPOMATIC_CONFIG_DIALOG_H
+
+#include "wx_util.h"
+#include "editable_list.h"
+#include "lib/config.h"
+#include "lib/ratio.h"
+#include "lib/filter.h"
+#include "lib/dcp_content_type.h"
+#include "lib/log.h"
+#include "lib/util.h"
+#include "lib/cross.h"
+#include "lib/exceptions.h"
+#include <dcp/locale_convert.h>
+#include <dcp/exceptions.h>
+#include <dcp/certificate_chain.h>
+#include <wx/stdpaths.h>
+#include <wx/preferences.h>
+#include <wx/spinctrl.h>
+#include <wx/filepicker.h>
+#include <RtAudio.h>
+#include <boost/filesystem.hpp>
+#include <boost/foreach.hpp>
+#include <iostream>
+
+class Page
+{
+public:
+	Page (wxSize panel_size, int border)
+		: _border (border)
+		, _panel (0)
+		, _panel_size (panel_size)
+		, _window_exists (false)
+	{
+		_config_connection = Config::instance()->Changed.connect (boost::bind (&Page::config_changed_wrapper, this));
+	}
+
+	virtual ~Page () {}
+
+protected:
+	wxWindow* create_window (wxWindow* parent)
+	{
+		_panel = new wxPanel (parent, wxID_ANY, wxDefaultPosition, _panel_size);
+		wxBoxSizer* s = new wxBoxSizer (wxVERTICAL);
+		_panel->SetSizer (s);
+
+		setup ();
+		_window_exists = true;
+		config_changed ();
+
+		_panel->Bind (wxEVT_DESTROY, boost::bind (&Page::window_destroyed, this));
+
+		return _panel;
+	}
+
+	int _border;
+	wxPanel* _panel;
+
+private:
+	virtual void config_changed () = 0;
+	virtual void setup () = 0;
+
+	void config_changed_wrapper ()
+	{
+		if (_window_exists) {
+			config_changed ();
+		}
+	}
+
+	void window_destroyed ()
+	{
+		_window_exists = false;
+	}
+
+	wxSize _panel_size;
+	boost::signals2::scoped_connection _config_connection;
+	bool _window_exists;
+};
+
+class StockPage : public wxStockPreferencesPage, public Page
+{
+public:
+	StockPage (Kind kind, wxSize panel_size, int border)
+		: wxStockPreferencesPage (kind)
+		, Page (panel_size, border)
+	{}
+
+	wxWindow* CreateWindow (wxWindow* parent)
+	{
+		return create_window (parent);
+	}
+};
+
+class StandardPage : public wxPreferencesPage, public Page
+{
+public:
+	StandardPage (wxSize panel_size, int border)
+		: Page (panel_size, border)
+	{}
+
+	wxWindow* CreateWindow (wxWindow* parent)
+	{
+		return create_window (parent);
+	}
+};
+
+class GeneralPage : public StockPage
+{
+public:
+	GeneralPage (wxSize panel_size, int border)
+		: StockPage (Kind_General, panel_size, border)
+	{}
+
+protected:
+	void add_language_controls (wxGridBagSizer* table, int& r)
+	{
+		_set_language = new wxCheckBox (_panel, wxID_ANY, _("Set language"));
+		table->Add (_set_language, wxGBPosition (r, 0));
+		_language = new wxChoice (_panel, wxID_ANY);
+		std::vector<std::pair<std::string, std::string> > languages;
+		languages.push_back (std::make_pair ("Čeština", "cs_CZ"));
+		languages.push_back (std::make_pair ("汉语/漢語", "zh_CN"));
+		languages.push_back (std::make_pair ("Dansk", "da_DK"));
+		languages.push_back (std::make_pair ("Deutsch", "de_DE"));
+		languages.push_back (std::make_pair ("English", "en_GB"));
+		languages.push_back (std::make_pair ("Español", "es_ES"));
+		languages.push_back (std::make_pair ("Français", "fr_FR"));
+		languages.push_back (std::make_pair ("Italiano", "it_IT"));
+		languages.push_back (std::make_pair ("Nederlands", "nl_NL"));
+		languages.push_back (std::make_pair ("Русский", "ru_RU"));
+		languages.push_back (std::make_pair ("Polski", "pl_PL"));
+		languages.push_back (std::make_pair ("Português europeu", "pt_PT"));
+		languages.push_back (std::make_pair ("Português do Brasil", "pt_BR"));
+		languages.push_back (std::make_pair ("Svenska", "sv_SE"));
+		languages.push_back (std::make_pair ("Slovenský jazyk", "sk_SK"));
+		languages.push_back (std::make_pair ("українська мова", "uk_UA"));
+		checked_set (_language, languages);
+		table->Add (_language, wxGBPosition (r, 1));
+		++r;
+
+		wxStaticText* restart = add_label_to_sizer (
+			table, _panel, _("(restart DCP-o-matic to see language changes)"), false, wxGBPosition (r, 0), wxGBSpan (1, 2)
+			);
+		wxFont font = restart->GetFont();
+		font.SetStyle (wxFONTSTYLE_ITALIC);
+		font.SetPointSize (font.GetPointSize() - 1);
+		restart->SetFont (font);
+		++r;
+
+		_set_language->Bind (wxEVT_CHECKBOX, boost::bind (&GeneralPage::set_language_changed, this));
+		_language->Bind     (wxEVT_CHOICE,   boost::bind (&GeneralPage::language_changed,     this));
+	}
+
+	void add_play_sound_controls (wxGridBagSizer* table, int& r)
+	{
+		_sound = new wxCheckBox (_panel, wxID_ANY, _("Play sound via"));
+		table->Add (_sound, wxGBPosition (r, 0));
+                _sound_output = new wxChoice (_panel, wxID_ANY);
+                table->Add (_sound_output, wxGBPosition (r, 1));
+                ++r;
+
+                RtAudio audio (DCPOMATIC_RTAUDIO_API);
+                for (unsigned int i = 0; i < audio.getDeviceCount(); ++i) {
+                        RtAudio::DeviceInfo dev = audio.getDeviceInfo (i);
+                        if (dev.probed && dev.outputChannels > 0) {
+                                _sound_output->Append (std_to_wx (dev.name));
+                        }
+                }
+
+		_sound->Bind        (wxEVT_CHECKBOX, boost::bind (&GeneralPage::sound_changed, this));
+		_sound_output->Bind (wxEVT_CHOICE,   boost::bind (&GeneralPage::sound_output_changed, this));
+	}
+
+	void add_update_controls (wxGridBagSizer* table, int& r)
+	{
+		_check_for_updates = new wxCheckBox (_panel, wxID_ANY, _("Check for updates on startup"));
+		table->Add (_check_for_updates, wxGBPosition (r, 0), wxGBSpan (1, 2));
+		++r;
+
+		_check_for_test_updates = new wxCheckBox (_panel, wxID_ANY, _("Check for testing updates on startup"));
+		table->Add (_check_for_test_updates, wxGBPosition (r, 0), wxGBSpan (1, 2));
+		++r;
+
+		_check_for_updates->Bind (wxEVT_CHECKBOX, boost::bind (&GeneralPage::check_for_updates_changed, this));
+		_check_for_test_updates->Bind (wxEVT_CHECKBOX, boost::bind (&GeneralPage::check_for_test_updates_changed, this));
+	}
+
+	virtual void config_changed ()
+	{
+		Config* config = Config::instance ();
+
+		checked_set (_set_language, static_cast<bool>(config->language()));
+
+		/* Backwards compatibility of config file */
+
+		std::map<std::string, std::string> compat_map;
+		compat_map["fr"] = "fr_FR";
+		compat_map["it"] = "it_IT";
+		compat_map["es"] = "es_ES";
+		compat_map["sv"] = "sv_SE";
+		compat_map["de"] = "de_DE";
+		compat_map["nl"] = "nl_NL";
+		compat_map["ru"] = "ru_RU";
+		compat_map["pl"] = "pl_PL";
+		compat_map["da"] = "da_DK";
+		compat_map["pt"] = "pt_PT";
+		compat_map["sk"] = "sk_SK";
+		compat_map["cs"] = "cs_CZ";
+		compat_map["uk"] = "uk_UA";
+
+		std::string lang = config->language().get_value_or ("en_GB");
+		if (compat_map.find (lang) != compat_map.end ()) {
+			lang = compat_map[lang];
+		}
+
+		checked_set (_language, lang);
+
+		checked_set (_check_for_updates, config->check_for_updates ());
+		checked_set (_check_for_test_updates, config->check_for_test_updates ());
+
+		checked_set (_sound, config->sound ());
+
+		boost::optional<std::string> const current_so = get_sound_output ();
+                boost::optional<std::string> configured_so;
+
+                if (config->sound_output()) {
+                        configured_so = config->sound_output().get();
+                } else {
+                        /* No configured output means we should use the default */
+                        RtAudio audio (DCPOMATIC_RTAUDIO_API);
+			try {
+				configured_so = audio.getDeviceInfo(audio.getDefaultOutputDevice()).name;
+			} catch (RtAudioError& e) {
+				/* Probably no audio devices at all */
+			}
+                }
+
+                if (configured_so && current_so != configured_so) {
+                        /* Update _sound_output with the configured value */
+                        unsigned int i = 0;
+                        while (i < _sound_output->GetCount()) {
+                                if (_sound_output->GetString(i) == std_to_wx(*configured_so)) {
+                                        _sound_output->SetSelection (i);
+                                        break;
+                                }
+                                ++i;
+                        }
+                }
+
+		setup_sensitivity ();
+	}
+
+private:
+	void setup_sensitivity ()
+	{
+		_language->Enable (_set_language->GetValue ());
+		_check_for_test_updates->Enable (_check_for_updates->GetValue ());
+		_sound_output->Enable (_sound->GetValue ());
+	}
+
+        /** @return Currently-selected preview sound output in the dialogue */
+        boost::optional<std::string> get_sound_output ()
+        {
+                int const sel = _sound_output->GetSelection ();
+                if (sel == wxNOT_FOUND) {
+                        return boost::optional<std::string> ();
+                }
+
+                return wx_to_std (_sound_output->GetString (sel));
+        }
+
+	void set_language_changed ()
+	{
+		setup_sensitivity ();
+		if (_set_language->GetValue ()) {
+			language_changed ();
+		} else {
+			Config::instance()->unset_language ();
+		}
+	}
+
+	void language_changed ()
+	{
+		int const sel = _language->GetSelection ();
+		if (sel != -1) {
+			Config::instance()->set_language (string_client_data (_language->GetClientObject (sel)));
+		} else {
+			Config::instance()->unset_language ();
+		}
+	}
+
+	void check_for_updates_changed ()
+	{
+		Config::instance()->set_check_for_updates (_check_for_updates->GetValue ());
+	}
+
+	void check_for_test_updates_changed ()
+	{
+		Config::instance()->set_check_for_test_updates (_check_for_test_updates->GetValue ());
+	}
+
+	void sound_changed ()
+	{
+		Config::instance()->set_sound (_sound->GetValue ());
+	}
+
+        void sound_output_changed ()
+        {
+                RtAudio audio (DCPOMATIC_RTAUDIO_API);
+		boost::optional<std::string> const so = get_sound_output();
+                if (!so || *so == audio.getDeviceInfo(audio.getDefaultOutputDevice()).name) {
+                        Config::instance()->unset_sound_output ();
+                } else {
+                        Config::instance()->set_sound_output (*so);
+                }
+        }
+
+	wxCheckBox* _set_language;
+	wxChoice* _language;
+	wxCheckBox* _sound;
+	wxChoice* _sound_output;
+	wxCheckBox* _check_for_updates;
+	wxCheckBox* _check_for_test_updates;
+};
+
+#endif