ui/gtkmm/preferences.cpp

/**********************************************************************
 *
 *   FreeDoko a Doppelkopf-Game
 *
 *   Copyright (C) 2001 – 2018 by Diether Knof and Borg Enders
 *
 *   This program 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.
 *
 *   This program 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 can find this license in the file 'gpl.txt'.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 *   MA  02111-1307  USA
 *
 *  Contact:
 *    Diether Knof dknof@posteo.de
 *
 *********************************************************************/

#include "constants.h"

#ifdef USE_UI_GTKMM

#include "preferences.h"
#include "preferences/cards_order.h"
#include "preferences/cardset.h"
#include "preferences/cards_back.h"
#include "preferences/iconset.h"
#include "preferences/background.h"

#include "ui.h"
#include "cards.h"
#include "main_window.h"
#include "menu.h"

#include "../../misc/preferences.h"
#ifdef WINDOWS
#include "../../utils/string.h"
#endif

#include "widgets/labelspinbutton.h"
#include "widgets/filemenu_extension.h"
#include "widgets/filemenu_file.h"
#include <gtkmm/notebook.h>
#include <gtkmm/label.h>
#include <gtkmm/entry.h>
#include <gtkmm/checkbutton.h>
#include <gtkmm/checkmenuitem.h>
#include <gtkmm/separatormenuitem.h>
#include <gtkmm/fontchooserdialog.h>
#include <gtkmm/colorchooserdialog.h>
namespace UI_GTKMM_NS {

/** constructor
 **
 ** @param    parent   the parent object
 **/
Preferences::Preferences(Base* const parent) :
  Base(parent),
  StickyDialog("FreeDoko – " + _("Window::preferences"), false)
{
  this->ui->add_window(*this);

#ifdef WORKAROUND
  { // name: change to utf8
    auto const name = UI_GTKMM::to_utf8(::preferences(::Preferences::Type::name));
    ::preferences.set(::Preferences::Type::name, name);
  } // name: change to utf8
#endif

  this->group_notebook = Gtk::manage(new Gtk::Notebook());
  this->group_notebook->set_tab_pos(Gtk::POS_LEFT);

  this->create_backup();

  this->signal_realize().connect(sigc::mem_fun(*this, &Preferences::init));
  this->signal_show().connect(sigc::mem_fun(*this, &Preferences::update_all));

#ifndef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
  this->signal_key_press_event().connect(sigc::mem_fun(*this, &Preferences::on_key_press_event));
#endif
} // Preferences::Preferences(Base* parent)

/** destruktor
 **/
Preferences::~Preferences()
{
  for (auto widget : this->type_bool)
    delete static_cast<::Preferences::Type::Bool*>(widget.second->steal_data("type"));

  delete this->language_menu;
  for (auto selector : this->font_chooser) {
    delete static_cast<int*>(selector.second->steal_data("type"));
    delete selector.second;
  } // for (selector : this->font_chooser)
  for (auto selector : this->color_chooser) {
    delete static_cast<int*>(selector.second->steal_data("type"));
    delete selector.second;
  } // for (selector : this->color_chooser)
} // Preferences::~Preferences()

/** creates all subelements
 **/
void
Preferences::init()
{
  this->set_icon(this->ui->icon);

  this->reset_button = Gtk::manage(new Gtk::Button(_("Button::reset")));
  this->reset_button->set_image_from_icon_name("edit-undo");
  this->reset_button->set_always_show_image();
  this->add_action_widget(*this->reset_button, Gtk::RESPONSE_REJECT);
  this->reset_button->show();
  this->reset_button->signal_clicked().connect(sigc::mem_fun(*this,
                                                             &Preferences::reset)
                                              );

  auto close_button = add_close_button(*this);
  close_button->signal_clicked().connect(sigc::mem_fun(*this,
                                                       &Preferences::save)
                                        );


  this->language_menu = new Gtk::Menu();

  { // create the buttons
    for (auto t : ::Preferences::Type::bool_list) {
      this->type_bool[t] = Gtk::manage(new Gtk::CheckButton(_(t)));
      //this->type_bool.back()->set_halign(Gtk::ALIGN_CENTER);
      this->type_bool[t]->set_data("type", new ::Preferences::Type::Bool(t));
      this->type_bool[t]->signal_toggled().connect(sigc::bind<int>(sigc::mem_fun(*this, &Preferences::changed),
                                                                       t)
                                                      );
    } // for (t : ::Preferences::Type::bool_list)
    for (auto t : ::Preferences::Type::unsigned_list) {
      this->type_unsigned[t] = Gtk::manage(new Gtk::LabelSpinButton(_(t)));
      //this->type_unsigned.back()->set_halign(Gtk::ALIGN_CENTER);
      this->type_unsigned[t]->set_data("type", new ::Preferences::Type::Unsigned(t));
      this->type_unsigned[t]->signal_value_changed().connect(sigc::bind<int>(sigc::mem_fun(*this, &Preferences::changed),
                                                                                 t)
                                                                );
      switch (t) {
      case ::Preferences::Type::card_play_delay:
      case ::Preferences::Type::full_trick_close_delay:
      case ::Preferences::Type::gametype_window_close_delay:
      case ::Preferences::Type::marriage_window_close_delay:
      case ::Preferences::Type::genscher_window_close_delay:
      case ::Preferences::Type::announcement_window_close_delay:
      case ::Preferences::Type::swines_window_close_delay:
        // make the precision 1/1000 seconds
        this->type_unsigned[t]->get_spin_button()->set_digits(1);
        this->type_unsigned[t]->get_spin_button()->set_increments(0.1, 1);
        break;
#ifdef USE_THREADS
      case ::Preferences::Type::threads_max:
#endif
      case ::Preferences::Type::table_rotation:
      case ::Preferences::Type::cards_height:
      case ::Preferences::Type::ui_main_window_pos_x:
      case ::Preferences::Type::ui_main_window_pos_y:
      case ::Preferences::Type::ui_main_window_width:
      case ::Preferences::Type::ui_main_window_height:
        break;
      } // switch(t)
    } // for (t : ::Preferences::Type::unsigned_list)
    for (auto t : ::Preferences::Type::string_list) {
      this->type_string_label[t] = Gtk::manage(new Gtk::Label(_(t) + ":"));

      this->type_string_label[t]->set_data("type", new ::Preferences::Type::String(t));

      switch (t) {
      case ::Preferences::Type::name:
        this->type_string[t] = Gtk::manage(new Gtk::Entry());
        dynamic_cast<Gtk::Entry*>(this->type_string[t])->signal_focus_out_event().connect(sigc::bind<int>(sigc::mem_fun(*this, &Preferences::focus_out_event), t));
        break;

      case ::Preferences::Type::language:
        this->type_string[t] = Gtk::manage(new Gtk::Button(_(t)));
        dynamic_cast<Gtk::Button*>(this->type_string[t])->signal_clicked().connect(sigc::mem_fun(*this->language_menu, &Widget::show_all));
        //	  dynamic_cast<Gtk::Button*>(this->type_string[t])->signal_clicked().connect(sigc::mem_fun(*this, &Preferences::language_menu_create));
        dynamic_cast<Gtk::Button*>(this->type_string[t])->signal_clicked().connect(sigc::bind<bool>(sigc::mem_fun(*this, &Preferences::language_menu_create), true));
        // a direct signal for popping up the menu does not work
        //dynamic_cast<Gtk::Button*>(this->type_string[t])->signal_clicked().connect(sigc::bind<guint, guint32>(sigc::mem_fun(*this->language_menu, &Gtk::Menu::popup), 0, 0));
        break;

      case ::Preferences::Type::cardset:
      case ::Preferences::Type::cards_back:
      case ::Preferences::Type::iconset:
      case ::Preferences::Type::background:
        break;

      case ::Preferences::Type::name_font:
      case ::Preferences::Type::trickpile_points_font: {
        auto button = Gtk::manage(new Gtk::Button(_(t)));
        this->type_string[t] = button;
        this->font_chooser[t] = new Gtk::FontChooserDialog(_("font selector"));
        this->font_chooser[t]->set_data("type", new int(t));
        button->set_data("font selector", this->font_chooser[t]);
        button->signal_clicked().connect(sigc::mem_fun0(*this->font_chooser[t], &Gtk::Window::present));
        break;
      }

      case ::Preferences::Type::name_font_color:
      case ::Preferences::Type::name_active_font_color:
      case ::Preferences::Type::name_reservation_font_color:
      case ::Preferences::Type::trickpile_points_font_color:
      case ::Preferences::Type::poverty_shift_arrow_color: {
        auto button = Gtk::manage(new Gtk::Button(_(t)));
        this->type_string[t] = button;
        this->color_chooser[t] = new Gtk::ColorChooserDialog(_("color selector"));
        this->color_chooser[t]->set_data("type", new int(t));
        button->set_data("color selector", this->color_chooser[t]);
        button->signal_clicked().connect(sigc::mem_fun0(*this->color_chooser[t], &Gtk::Window::present));
        break;
      }

#ifdef USE_SOUND_COMMAND
      case ::Preferences::Type::play_sound_command:
#endif
      case ::Preferences::Type::browser_command:
        this->type_string[t] = Gtk::manage(new Gtk::Entry());
        dynamic_cast<Gtk::Entry*>(this->type_string[t])->signal_focus_out_event().connect(sigc::bind<int>(sigc::mem_fun(*this, &Preferences::focus_out_event), t));
        break;

      } // switch(t)
      if (this->type_string[t]) {
        this->type_string[t]->set_data("type", new ::Preferences::Type::String(t));
      }
    } // for (t : ::Preferences::Type::string_list)
  } // create the buttons

  { // set the pages of the notebook
    { // General
      auto vbox = this->add_group_box("general");
      (void)_("Preferences::Group::general");

      { // name
        auto hbox = Gtk::manage(new Gtk::Box());
        hbox->set_spacing(1 EX);
        hbox->set_halign(Gtk::ALIGN_CENTER);
        hbox->add(*this->type_string_label[::Preferences::Type::name]);
        hbox->add(*this->type_string[::Preferences::Type::name]);
        vbox->add(*hbox);
      } // name
      { // language
        auto hbox = Gtk::manage(new Gtk::Box());
        hbox->set_spacing(1 EX);
        hbox->set_halign(Gtk::ALIGN_CENTER);
        hbox->add(*this->type_string_label[::Preferences::Type::language]);
        hbox->add(*this->type_string[::Preferences::Type::language]);
        vbox->add(*hbox);
      } // language
      vbox->add(*this->type_bool[::Preferences::Type::sound]);
#ifdef USE_THREADS
      vbox->add(*this->type_unsigned[::Preferences::Type::threads_max]);
#endif
      vbox->add(*this->type_bool[::Preferences::Type::show_bug_report_button_in_game_finished_window]);
      vbox->add(*this->type_bool[::Preferences::Type::save_bug_reports_on_desktop]);
      vbox->add(*this->type_bool[::Preferences::Type::save_party_changes]);
      vbox->add(*this->type_bool[::Preferences::Type::additional_party_settings]);
#ifdef USE_SOUND_COMMAND
      { // play sound command
        auto hbox = Gtk::manage(new Gtk::Box());
        hbox->set_spacing(1 EX);
        hbox->set_halign(Gtk::ALIGN_CENTER);
        hbox->add(*this->type_string_label[::Preferences::Type::play_sound_command]);
        hbox->add(*this->type_string[::Preferences::Type::play_sound_command]);
        vbox->add(*hbox);
      } // play sound command
#endif
      { // browser
        auto hbox = Gtk::manage(new Gtk::Box());
        hbox->set_spacing(1 EX);
        hbox->set_halign(Gtk::ALIGN_CENTER);
        hbox->add(*this->type_string_label[::Preferences::Type::browser_command]);
        hbox->add(*this->type_string[::Preferences::Type::browser_command]);
        vbox->add(*hbox);
      } // browser
    } // General

    { // Behaviour
      auto vbox = this->add_group_box("behaviour");
      (void)_("Preferences::Group::behaviour");

      vbox->add(*this->type_bool[::Preferences::Type::announce_in_table]);
      vbox->add(*this->type_unsigned[::Preferences::Type::card_play_delay]);
    } // Behaviour
    { // Assistance
      auto vbox = this->add_group_box("assistance");
      (void)_("Preferences::Group::assistance");

      vbox->add(*this->type_bool[::Preferences::Type::show_soloplayer_in_game]);
      vbox->add(*this->type_bool[::Preferences::Type::announce_swines_automatically]);
      vbox->add(*this->type_bool[::Preferences::Type::show_if_valid]);
      vbox->add(*this->type_bool[::Preferences::Type::emphasize_valid_cards]);
    } // Assistance
    { // Help
      auto vbox = this->add_group_box("help");
      (void)_("Preferences::Group::help");

      vbox->add(*this->type_bool[::Preferences::Type::show_all_hands]);
      vbox->add(*this->type_bool[::Preferences::Type::show_ai_information_hands]);
      vbox->add(*this->type_bool[::Preferences::Type::show_known_teams_in_game]);
      vbox->add(*this->type_bool[::Preferences::Type::show_ai_information_teams]);
      vbox->add(*this->type_bool[::Preferences::Type::show_trickpiles_points]);
      vbox->add(*this->type_bool[::Preferences::Type::automatic_card_suggestion]);
    } // Help
    { // information windows
      auto subnotebook
        = this->add_group_notebook("information windows");
      (void)_("Preferences::Group::information windows");

      { // gametype window
        auto vbox = this->add_subgroup_box(*subnotebook,
                                           "gametype");
        (void)_("Preferences::Subgroup::gametype");

        vbox->add(*this->type_bool[::Preferences::Type::show_gametype_window]);
        vbox->add(*this->type_bool[::Preferences::Type::close_gametype_window_automatically]);
        vbox->add(*this->type_unsigned[::Preferences::Type::gametype_window_close_delay]);
      } // gametype window
      { // full trick window
        auto vbox = this->add_subgroup_box(*subnotebook,
                                           "full trick");
        (void)_("Preferences::Subgroup::full trick");

        vbox->add(*this->type_bool[::Preferences::Type::show_full_trick_window]);
        vbox->add(*this->type_bool[::Preferences::Type::show_full_trick_window_if_special_points]);
        vbox->add(*this->type_bool[::Preferences::Type::close_full_trick_automatically]);
        vbox->add(*this->type_unsigned[::Preferences::Type::full_trick_close_delay]);
      } // full trick window
      { // marriage finding window
        auto vbox = this->add_subgroup_box(*subnotebook,
                                           "marriage");
        (void)_("Preferences::Subgroup::marriage");

        vbox->add(*this->type_bool[::Preferences::Type::show_marriage_window]);
        vbox->add(*this->type_bool[::Preferences::Type::close_marriage_window_automatically]);
        vbox->add(*this->type_unsigned[::Preferences::Type::marriage_window_close_delay]);
      } // marriage finding window
      { // genscher window
        auto vbox = this->add_subgroup_box(*subnotebook,
                                           "genscher");
        (void)_("Preferences::Subgroup::genscher");

        vbox->add(*this->type_bool[::Preferences::Type::show_genscher_window]);
        vbox->add(*this->type_bool[::Preferences::Type::close_genscher_window_automatically]);
        vbox->add(*this->type_unsigned[::Preferences::Type::genscher_window_close_delay]);
      } // genscher window
      { // announcement window
        auto vbox = this->add_subgroup_box(*subnotebook,
                                           "announcement");
        (void)_("Preferences::Subgroup::announcement");

        vbox->add(*this->type_bool[::Preferences::Type::show_announcement_window]);
        vbox->add(*this->type_bool[::Preferences::Type::close_announcement_window_automatically]);
        vbox->add(*this->type_unsigned[::Preferences::Type::announcement_window_close_delay]);
      } // announcement window
      { // swines window
        auto vbox = this->add_subgroup_box(*subnotebook,
                                           "swines");
        (void)_("Preferences::Subgroup::swines");

        vbox->add(*this->type_bool[::Preferences::Type::show_swines_window]);
        vbox->add(*this->type_bool[::Preferences::Type::close_swines_window_automatically]);
        vbox->add(*this->type_unsigned[::Preferences::Type::swines_window_close_delay]);
      } // swines window
    } // Information windows
    {
      auto vbox = this->add_group_box("cards order");
      (void)_("Preferences::Group::cards order");
      this->cards_order = make_unique<CardsOrder>(*this);
      vbox->add(*this->cards_order);
    }
    { // Appearance
      auto subnotebook = this->add_group_notebook("appearance");
      (void)_("Preferences::Group::appearance");

      { // cardset
        auto vbox = this->add_subgroup_box(*subnotebook,
                                           "cardset");
        (void)_("Preferences::Subgroup::cardset");
        this->cardset = make_unique<Cardset>(*this);
        vbox->set_valign(Gtk::ALIGN_FILL);
        vbox->set_halign(Gtk::ALIGN_FILL);
        vbox->pack_start(*this->cardset);
      } // cardset
      { // cards back
        auto vbox = this->add_subgroup_box(*subnotebook,
                                           "cards back");
        (void)_("Preferences::Subgroup::cards back");
        this->cards_back = make_unique<CardsBack>(*this);
        vbox->set_valign(Gtk::ALIGN_FILL);
        vbox->set_halign(Gtk::ALIGN_FILL);
        vbox->pack_start(*this->cards_back);
      } // cards back
      { // iconset
        auto vbox = this->add_subgroup_box(*subnotebook,
                                           "iconset");
        (void)_("Preferences::Subgroup::iconset");
        this->iconset = make_unique<Iconset>(*this);
        vbox->set_valign(Gtk::ALIGN_FILL);
        vbox->set_halign(Gtk::ALIGN_FILL);
        vbox->pack_start(*this->iconset);
      } // iconset
      { // background
        auto vbox = this->add_subgroup_box(*subnotebook,
                                           "background");
        (void)_("Preferences::Subgroup::background");
        this->background = make_unique<Background>(*this);
        vbox->set_valign(Gtk::ALIGN_FILL);
        vbox->set_halign(Gtk::ALIGN_FILL);
        vbox->pack_start(*this->background);
      } // background
      { // table
        auto vbox = this->add_subgroup_box(*subnotebook,
                                           "table");
        (void)_("Preferences::Subgroup::table");

        vbox->add(*this->type_bool[::Preferences::Type::own_hand_on_table_bottom]);
        vbox->add(*this->type_unsigned[::Preferences::Type::table_rotation]);
        vbox->add(*this->type_bool[::Preferences::Type::rotate_trick_cards]);
        vbox->add(*this->type_bool[::Preferences::Type::original_cards_size]);
        vbox->add(*this->type_unsigned[::Preferences::Type::cards_height]);
      } // table
      { // Fonts and colors
        auto vbox = this->add_subgroup_box(*subnotebook,
                                           "fonts and colors");
        (void)_("Preferences::Subgroup::fonts and colors");

        { // the name
          auto vbox2 = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL));
          vbox->set_halign(Gtk::ALIGN_CENTER);

          vbox2->add(*this->type_string[::Preferences::Type::name_font]);
          vbox2->add(*this->type_string[::Preferences::Type::name_font_color]);
          vbox2->add(*this->type_string[::Preferences::Type::name_active_font_color]);
          vbox2->add(*this->type_string[::Preferences::Type::name_reservation_font_color]);
          vbox->add(*vbox2);
        } // the name

        { // the trickpile points
          auto vbox2 = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL));
          vbox->set_halign(Gtk::ALIGN_CENTER);


          vbox2->add(*this->type_string[::Preferences::Type::trickpile_points_font]);
          vbox2->add(*this->type_string[::Preferences::Type::trickpile_points_font_color]);

          vbox->add(*vbox2);
        } // the trickpile points

        { // poverty arrow
          vbox->add(*this->type_string[::Preferences::Type::poverty_shift_arrow_color]);
        } // poverty arrow
      } // Fonts and colors
      { // Splash screen
        auto vbox = this->add_subgroup_box(*subnotebook,
                                           "splash screen");
        (void)_("Preferences::Subgroup::splash screen");

        vbox->add(*this->type_bool[::Preferences::Type::show_splash_screen]);
        vbox->add(*this->type_bool[::Preferences::Type::splash_screen_transparent]);
      } // Splash screen
    } // Appearance
  } // set the pages of the notebook

#ifndef RELEASE
#ifdef DKNOF
  { // test, whether all preferences-buttons are packed in a container
    for (auto t : ::Preferences::Type::bool_list) {
      if (!this->type_bool[t]->get_parent()
          && (t != ::Preferences::Type::automatic_savings)
          && (t != ::Preferences::Type::ui_main_window_fullscreen)
         ) {
        cerr << "GTKMM_DOKO::Preferences::Type::Preferences():\n"
          << "  preference '" << to_string(t) << "' not packed\n";
      }
    }
    for (auto t : ::Preferences::Type::unsigned_list) {
      if (!this->type_unsigned[t]->get_parent()
          && (t != ::Preferences::Type::ui_main_window_pos_x)
          && (t != ::Preferences::Type::ui_main_window_pos_y)
          && (t != ::Preferences::Type::ui_main_window_width)
          && (t != ::Preferences::Type::ui_main_window_height)
         ) {
        cerr << "GTKMM_DOKO::Preferences::Type::Preferences():\n"
          << "  preference '" << to_string(t)
          << "' not packed\n";
      }
    }
  } // test, whether all preference-buttons are packed in a container
#endif
#endif

  this->get_content_area()->pack_start(*this->group_notebook);


  { // signals
    for (auto i : this->font_chooser) {
      auto selector = i.second;
      selector->signal_response().connect(sigc::bind<Gtk::FontChooserDialog*>(sigc::mem_fun(*this, &Preferences::font_chooser_response), selector));
    } // for (selector : this->font_chooser)

    for (auto i : this->color_chooser) {
      auto selector = i.second;
      auto const type
        = *static_cast<::Preferences::Type::String*>(selector->get_data("type"));

      selector->signal_response().connect(sigc::bind<Gtk::ColorChooserDialog*>(sigc::mem_fun(*this, &Preferences::color_chooser_response), selector));
#ifdef TODO
      selector->signal_color_changed().connect(sigc::bind<int>(sigc::mem_fun(*this, &Preferences::changed), type));
#endif
      (void)type;
    } // for (selector : this->color_chooser)
  } // signals

  this->update_all();

  this->show_all_children();

#ifdef RELEASE
#ifndef WINDOWS
#ifndef LINUX
  this->type_bool[::Preferences::Type::save_bug_reports_on_desktop]->hide();
#endif
#endif
#endif // #ifdef RELEASE
} // void Preferences::init()

/** adds to the group notebook a page with a vbox for group 'name'.
 **
 ** @param    name   name of the group
 **
 ** @return   created vbox for the preferences of the group
 **/
Gtk::Box*
Preferences::add_group_box(string const& name)
{
  auto vbox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL, 1 EX));
  vbox->set_halign(Gtk::ALIGN_CENTER);
  vbox->set_valign(Gtk::ALIGN_CENTER);

  this->add_group(name, *vbox);

  return vbox;
} // Gtk::Box* Preferences::add_group_box(string name)

/** adds to the group notebook a subnotebook for group 'name'.
 **
 ** @param    name   name of the group
 **
 ** @return   created notebook for the subgroups
 **/
Gtk::Notebook*
Preferences::add_group_notebook(string const& name)
{
  auto notebook = Gtk::manage(new Gtk::Notebook());
  this->add_group(name, *notebook);
  notebook->set_tab_pos(Gtk::POS_LEFT);

  return notebook;
} // Gtk::Notebook* Preferences::add_group_notebook(string name)

/** adds to the group notebook a page of 'widget' for group 'name'.
 **
 ** @param    name     name of the group
 ** @param    widget   widget contianing the group
 **/
void
Preferences::add_group(string const& name, Gtk::Widget& widget)
{
  widget.show();

  auto label = Gtk::manage(new Gtk::Label(_("Preferences::Group::" + name)));
  label->show();

  this->group_notebook->append_page(widget, *label);
  this->group_notebook->child_property_tab_expand(widget).set_value(true);
} // void Preferences::add_group(string name, Gtk::Widget& widget)

/** adds to the subgroup notebook a page with a vbox for group 'name'.
 **
 ** @param    subnotebook   notebook to add the group
 ** @param    name      name of the group
 **
 ** @return   created vbox for the preferences of the group
 **/
Gtk::Box*
Preferences::add_subgroup_box(Gtk::Notebook& subnotebook,
                              string const& name)
{
  auto label = Gtk::manage(new Gtk::Label(_("Preferences::Subgroup::" + name)));
  label->show();

  auto vbox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL, 1 EX));
  vbox->set_halign(Gtk::ALIGN_CENTER);
  vbox->set_valign(Gtk::ALIGN_CENTER);

  subnotebook.append_page(*vbox, *label);
  this->group_notebook->child_property_tab_expand(*vbox).set_value(true);
  return vbox;
} // Gtk::Box* Preferences::add_subgroup_box(Gtk::Notebook& subnotebook, string name)

/** creates a backup
 **/
void
Preferences::create_backup()
{
  this->backup_ = make_unique<::Preferences>(::preferences);
} // void Preferences::create_backup()

/** @return   the backup
 **/
::Preferences const&
Preferences::backup() const
{
  DEBUG_ASSERTION(this->backup_,
                  "Preferences::Type::backup():\n"
                  "  'this->backup_' == nullptr");

  return *this->backup_;
} // Preferences const& Preferences::backup() const

/** save the preferences
 **/
void
Preferences::save()
{
  if (::preferences(::Preferences::Type::automatic_savings))
    ::preferences.save();
} // void Preferences::save()

/** resets the preferences
 **/
void
Preferences::reset()
{
  if (this->backup_)
    ::preferences = *this->backup_;
} // void Preferences::reset()

/** update the sensitivity of all widgets
 **/
void
Preferences::sensitivity_update()
{
  for (auto i : this->type_bool) {
    auto widget = i.second;
    widget->set_sensitive(::preferences.dependencies(*static_cast<::Preferences::Type::Bool*>(widget->get_data("type"))));
  }
  for (auto i : this->type_unsigned) {
    auto widget = i.second;
    auto const type
      = *static_cast<::Preferences::Type::Unsigned*>(widget->get_data("type"));

    widget->set_sensitive(::preferences.dependencies(type));
    if (type == ::Preferences::Type::cards_height) {
      // make such a limit, so that a right-click (maximum) does not lead
      // to a limit problem
      widget->set_range(::preferences.min(type),
                        10 * this->ui->cards->height_original());
    } else {
      widget->set_range(::preferences.min(type), ::preferences.max(type));
    }
  } // for (widget : this->type_unsigned)
} // void Preferences::sensitivity_update()

/** update all
 **/
void
Preferences::update_all()
{
  for (auto t : ::Preferences::Type::bool_list)
    this->update(t, false);
  for (auto t : ::Preferences::Type::unsigned_list)
    this->update(t, false);
  for (auto t : ::Preferences::Type::string_list)
    this->update(t, false);
  this->update(::Preferences::Type::cards_order, false);

  this->sensitivity_update();

  this->reset_button->set_sensitive(this->backup() != ::preferences);
} // void Preferences::update_all()

/** update the preferences 'type'
 **
 ** @param    type   the type of the preference
 **/
void
Preferences::preference_update(int const type)
{
  this->update(type);
  this->sensitivity_update();
} // void Preferences::preference_update(int type)

/** update the preference 'type'
 **
 ** @param    type      the type of the preference
 ** @param    update_sensitivity   whether the sensitivity shall be updated
 **    (default: true)
 **
 ** @todo   style of the font and color buttons
 **/
void
Preferences::update(int const typex, bool const update_sensitivity)
{
  if (!this->is_visible())
    return ;

  if (update_sensitivity)
    this->sensitivity_update();

  if (contains(::Preferences::Type::bool_list, typex)) {
    auto const type = static_cast<::Preferences::Type::Bool>(typex);
    this->type_bool[type]->set_active(::preferences.value(type));
    switch (type) {
    case ::Preferences::Type::emphasize_valid_cards:
      this->ui->main_window->menu->emphasize_valid_cards->set_active(::preferences.value(type));
      break;
    case ::Preferences::Type::show_all_hands:
      this->ui->main_window->menu->show_all_hands->set_active(::preferences.value(type));
      break;
    default:
      break;
    } // switch(type)
  } else if (contains(::Preferences::Type::unsigned_list, typex)) {
    auto const type = static_cast<::Preferences::Type::Unsigned>(typex);
    switch (type) {
    case ::Preferences::Type::card_play_delay:
    case ::Preferences::Type::full_trick_close_delay:
    case ::Preferences::Type::gametype_window_close_delay:
    case ::Preferences::Type::marriage_window_close_delay:
    case ::Preferences::Type::genscher_window_close_delay:
    case ::Preferences::Type::announcement_window_close_delay:
    case ::Preferences::Type::swines_window_close_delay:
      // make one second to correspond with '1.0'
      this->type_unsigned[type]->set_value((1.0 / 1000) * ::preferences.value(type));
      break;
#ifdef USE_THREADS
    case ::Preferences::Type::threads_max:
#endif
    case ::Preferences::Type::table_rotation:
    case ::Preferences::Type::cards_height:
      this->type_unsigned[type]->set_value(::preferences.value(type));
      break;
    case ::Preferences::Type::ui_main_window_pos_x:
    case ::Preferences::Type::ui_main_window_pos_y:
    case ::Preferences::Type::ui_main_window_width:
    case ::Preferences::Type::ui_main_window_height:
      break;
    } // switch(type)
  } else if (contains(::Preferences::Type::string_list, typex)) {
    auto const type = static_cast<::Preferences::Type::String>(typex);
    switch (type) {
    case ::Preferences::Type::name:
      dynamic_cast<Gtk::Entry*>(this->type_string[type])->set_text(::preferences(type));
      break;
    case ::Preferences::Type::language: {
      this->language_menu_create(false);
      auto button = dynamic_cast<Gtk::Button*>(this->type_string[type]);
      if (::preferences.value(type) == "") {
        button->set_label(_("default"));
      } else if (::preferences.value(type) == "de") {
        button->set_label("deutsch");
      } else if (::preferences.value(type) == "de-alt") {
        button->set_label("deutsch – alt");
      } else if (::preferences.value(type) == "en") {
        button->set_label("english");
      } else  {
        button->set_label(::preferences.value(type));
      }
      break;
    }
    case ::Preferences::Type::cardset:
    case ::Preferences::Type::cards_back:
    case ::Preferences::Type::iconset:
    case ::Preferences::Type::background:
      break;
    case ::Preferences::Type::name_font:
    case ::Preferences::Type::trickpile_points_font:
      static_cast<Gtk::FontChooserDialog*>(this->type_string[type]->get_data("font selector"))->set_font(::preferences(type));
#ifdef POSTPONED
      // ToDo
      // don't work :-(
      { // change the style
        auto style
          = this->type_string[type]->get_style();

        style->set_font(Pango::FontDescription(::preferences(type)));

        this->type_string[type]->set_style(style);
      } // change the style
#endif // #ifdef POSTPONED
      break;

    case ::Preferences::Type::name_font_color:
    case ::Preferences::Type::name_active_font_color:
    case ::Preferences::Type::name_reservation_font_color:
    case ::Preferences::Type::trickpile_points_font_color:
    case ::Preferences::Type::poverty_shift_arrow_color:
      static_cast<Gtk::ColorChooserDialog*>(this->type_string[type]->get_data("color selector"))->set_rgba(Gdk::RGBA(::preferences(type)));
#ifdef POSTPONED
      // change the color of the text in the buttons
      auto style
        = this->type_string[type]->get_style();
      // = static_cast<Gtk::Button*>(this->type_string[type])->get_child()->get_style();

      Gdk::RGBA color(::preferences(type));
      this->ui->colormap->alloc_color(color);
      style->set_fg(Gtk::STATE_normal, color);
      style->set_text(Gtk::STATE_normal, color);
      style->set_text_aa(Gtk::STATE_normal, color);
      style->set_base(Gtk::STATE_normal, color);

      this->type_string[type]->set_style(style);
      static_cast<Gtk::Button*>(this->type_string[type])->get_child()->set_style(style);
#endif // #ifdef POSTPONED
      break;

#ifdef USE_SOUND_COMMAND
    case ::Preferences::Type::play_sound_command:
#endif
    case ::Preferences::Type::browser_command:
      dynamic_cast<Gtk::Entry*>(this->type_string[type])->set_text(::preferences(type));
      break;
    } // switch(type)

  } else if (typex == ::Preferences::Type::cards_order) {
    this->cards_order->update();
  } else {
    DEBUG_ASSERTION(false,
                    "Preferences::update(type, update_sensitivity):\n"
                    "  type '" << typex << "' unknown.");
  }

  if (update_sensitivity)
    this->reset_button->set_sensitive(this->backup() != ::preferences);
} // void Preferences::update(int type, bool update_sensitivity = true)

/** a preference has been changed by the user
 **
 ** @param    type   the type of the preference
 **/
void
Preferences::changed(int const typex)
{
  if (contains(::Preferences::Type::bool_list, typex)) {
    auto const type = static_cast<::Preferences::Type::Bool>(typex);
    ::preferences.set(type,
                      this->type_bool[type]->get_active());
  } else if (contains(::Preferences::Type::unsigned_list, typex)) {
    auto const type = static_cast<::Preferences::Type::Unsigned>(typex);
    if (this->type_unsigned[type]->get_realized()) {
      switch (type) {
      case ::Preferences::Type::card_play_delay:
      case ::Preferences::Type::full_trick_close_delay:
      case ::Preferences::Type::gametype_window_close_delay:
      case ::Preferences::Type::marriage_window_close_delay:
      case ::Preferences::Type::genscher_window_close_delay:
      case ::Preferences::Type::announcement_window_close_delay:
      case ::Preferences::Type::swines_window_close_delay:
        // make one second to correspond with '1.0'
        ::preferences.set(type,
                          static_cast<int>(1000 * this->type_unsigned[type]->get_value()));
        break;
#ifdef USE_THREADS
      case ::Preferences::Type::threads_max:
#endif
      case ::Preferences::Type::table_rotation:
      case ::Preferences::Type::cards_height:
        ::preferences.set(type,
                          this->type_unsigned[type]->get_value_as_int());
        break;
      case ::Preferences::Type::ui_main_window_pos_x:
      case ::Preferences::Type::ui_main_window_pos_y:
      case ::Preferences::Type::ui_main_window_width:
      case ::Preferences::Type::ui_main_window_height:
        DEBUG_ASSERTION(false,
                        "Preferences type '" + to_string(type) + " cannot be changed manually\n");
        break;
      } // switch(type)
    } // if (type is realized)
  } else if (contains(::Preferences::Type::string_list, typex)) {
    auto const type = static_cast<::Preferences::Type::String>(typex);
    switch (type) {
    case ::Preferences::Type::name:
      ::preferences.set(type,
                        dynamic_cast<Gtk::Entry*>(this->type_string[type])->get_text());
      break;
    case ::Preferences::Type::language:
      break;
    case ::Preferences::Type::cardset:
      // -> Cardset
      break;
    case ::Preferences::Type::cards_back:
      // -> CardsBack
      break;
    case ::Preferences::Type::iconset:
      // -> Iconset
      break;
    case ::Preferences::Type::background:
      // -> Background
      break;
    case ::Preferences::Type::name_font:
    case ::Preferences::Type::trickpile_points_font:
      ::preferences.set(type,
                        static_cast<Gtk::FontChooserDialog*>(this->type_string[type]->get_data("font selector"))->get_font());
      break;
    case ::Preferences::Type::name_font_color:
    case ::Preferences::Type::name_active_font_color:
    case ::Preferences::Type::name_reservation_font_color:
    case ::Preferences::Type::trickpile_points_font_color:
    case ::Preferences::Type::poverty_shift_arrow_color:
      ::preferences.set(type,
                        colorname(static_cast<Gtk::ColorChooserDialog*>(this->type_string[type]->get_data("color selector"))->get_rgba()));
      break;

#ifdef USE_SOUND_COMMAND
    case ::Preferences::Type::play_sound_command:
#endif
    case ::Preferences::Type::browser_command:
      ::preferences.set(type,
                        dynamic_cast<Gtk::Entry*>(this->type_string[type])->get_text());
      break;
    } // switch(type)
  } // if (type == ())
  // cards order is managed in 'preferences/cards_order.cpp'
} // void Preferences::changed(int type)

/** a preference has been changed by the user
 **
 ** @param    focus   ignored
 ** @param    type    the type of the preference
 **/
bool
Preferences::focus_out_event(GdkEventFocus* event, int const type)
{
  this->changed(type);

  return true;
} // bool Preferences::focus_out_event(GdkEventFocus* event, int type)

/** open the cards order
 **/
void
Preferences::open_cards_order()
{
  this->realize();
  this->group_notebook->set_current_page(5);
  this->present();
} // void Preferences::open_cards_order()

/** create and show the language menu
 **
 ** @param    popup   whether to popup the menu (default: true)
 **/
void
Preferences::language_menu_create(bool const popup)
{
#if 0
  if (this->language_menu == NULL)
    return ;
#endif

  { // remove all children
    auto children = this->language_menu->get_children();

    if (!children.empty()) {
      for (auto child : children)
        this->language_menu->remove(*child);
    } // if (!children.empty())
  } // remove all children

  // the language menu consists of the default button, a separator and
  // the languages (taken from '::language'
  Gtk::MenuItem* item = nullptr;

  // memory leak: the translation created in 'Ui::->translations->add' is not removed
  item = Gtk::manage(new Gtk::MenuItem(_("default")));
  item->signal_activate().connect(sigc::bind<string>(sigc::mem_fun(*this, &Preferences::language_selected), ""));
  this->language_menu->add(*item);
  item = Gtk::manage(new Gtk::SeparatorMenuItem());
  this->language_menu->add(*item);

  vector<std::pair<string, string>> const names
    = {{"deutsch", "de"},
      {"deutsch - alt", "de-alt"},
      {"english", "en"}};
  for (auto name : names) {
    item = Gtk::manage(new Gtk::MenuItem(name.first));
    item->signal_activate().connect(sigc::bind<string>(sigc::mem_fun(*this, &Preferences::language_selected), name.second));
    this->language_menu->add(*item);
  } // for (name : names)

  if (popup)
    this->language_menu->popup(0, 0);

  this->language_menu->show_all();
} // void Preferences::language_menu_create(bool popup = true)

/** change of the language
 **
 ** @param    language   new language
 **/
void
Preferences::language_selected(string const language)
{
  ::preferences.set(::Preferences::Type::language, language);
} // void Preferences::language_selected(string language)

/** change of the cardset
 **
 ** @param    cardset   new cardset
 **/
void
Preferences::cardset_selected(string const cardset)
{
  ::preferences.set(::Preferences::Type::cardset, cardset);
} // void Preferences::cardset_selected(string cardset)

/** the font chooser has emmited a response
 **
 ** @param    response_id     id of the response
 ** @param    font_chooser   the font selector
 **/
void
Preferences::font_chooser_response(int const response_id,
                                   Gtk::FontChooserDialog* const font_chooser)
{
  if (response_id == Gtk::RESPONSE_OK) {
    auto const type
      = *static_cast<::Preferences::Type::String*>(font_chooser->get_data("type"));
    font_chooser->hide();
    this->changed(type);
  } else {
    font_chooser->hide();
  }
} // void Preferences::font_chooser_response(int response_id, Gtk::FontChooserDialog* font_chooser)

/** the color of the preference 'type' has emmited a response
 **
 ** @param    response_id     id of the response
 ** @param    color_chooser   the color selector
 **/
void
Preferences::color_chooser_response(int const response_id,
                                    Gtk::ColorChooserDialog* const color_chooser)
{
  if (response_id == Gtk::RESPONSE_OK) {
    auto const type
      = *static_cast<::Preferences::Type::String*>(color_chooser->get_data("type"));
    //color_chooser->set_rgba(Gdk::RGBA(::preferences(type)));
    //::preferences.set(type, color_chooser->get_rgba().to_string());
    color_chooser->hide();
    this->changed(type);
  } else {
    color_chooser->hide();
  }
} // void Preferences::color_chooser_response(int response_id, Gtk::ColorChooserDialog* color_chooser)

/** a key has been pressed
 ** C-o: output of the preferences on 'stdout'
 **
 ** @param    key   the key
 **
 ** @return   whether the key was managed
 **/
bool
Preferences::on_key_press_event(GdkEventKey* key)
{
  bool managed = false;

  if ((key->state & ~GDK_SHIFT_MASK) == GDK_CONTROL_MASK) {
    switch (key->keyval) {
    case GDK_KEY_o: // ouput of the preferences
      cout << ::preferences;
      managed = true;
      break;
    } // switch (key->keyval)
  } // if (key->state == GDK_CONTROL_MASK)

  return (managed
          || this->StickyDialog::on_key_press_event(key)
          || this->ui->key_press(key));
} // bool Preferences::on_key_press_event(GdkEventKey* key)

} // namespace UI_GTKMM_NS

#endif // #ifdef USE_UI_GTKMM