ui/gtkmm/party_settings.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 "party_settings.h"
#include "players.h"
#include "rules.h"

#include "ui.h"
#include "main_window.h"
#include "bug_report.h"
#include "first_run.h"
#include "program_updated.h"

#include "../../party/party.h"
#include "../../player/player.h"
#include "../../player/aiconfig.h"
#include "../../os/bug_report_replay.h"
#include "../../misc/preferences.h"
#include "../../utils/random.h"

#include <gtkmm/radiobutton.h>
#include <gtkmm/spinbutton.h>
#include <gtkmm/frame.h>
#include <gtkmm/main.h>
#include <gtkmm/grid.h>
#include <gtkmm/filechooserdialog.h>
namespace UI_GTKMM_NS {

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

  this->init();

  this->signal_show().connect(sigc::mem_fun(*this, &PartySettings::update));
  this->signal_key_press_event().connect(sigc::mem_fun(*this,
                                                       &PartySettings::key_press));

  this->ui->bug_report->set_dnd_destination(*this);
} // PartySettings::PartySettings(Base* parent)

/** destruktor
 **/
PartySettings::~PartySettings() = default;

/** create all subelements
 **/
void
PartySettings::init()
{
#ifdef POSTPONED
  auto& party = this->ui->party();
#else
  auto& party = *::party;
#endif

  this->set_icon(this->ui->icon);

  this->set_position(Gtk::WIN_POS_CENTER_ON_PARENT);

  this->players = make_unique<Players>(this);
  this->rules = make_unique<Rules>(this);

  this->load_bug_report_button
    = Gtk::manage(new Gtk::Button(_("Button::load bug report")));
  this->load_bug_report_button->set_image_from_icon_name("document-open");
  this->load_bug_report_button->set_always_show_image();
#ifndef RELEASE
  this->add_action_widget(*this->load_bug_report_button,
                          Gtk::RESPONSE_NONE);
#endif
  this->start_party_button
    = Gtk::manage(new Gtk::Button(_("Button::start party")));
  this->add_action_widget(*this->start_party_button, Gtk::RESPONSE_CLOSE);
  this->start_party_button->set_can_default();

  this->close_button = add_close_button(*this);

  { // seed
    this->seed_value = Gtk::manage(new Gtk::SpinButton(1, 0));
    this->seed_value->set_value(0);
    this->seed_value->set_range(0, Random::max_seed());
    this->seed_value->set_increments(1, 1000);
    this->seed_random = Gtk::manage(new Gtk::CheckButton(_("Button::random")));
  } // seed
  { // duration
    this->rule_number_of_rounds_limited
      = Gtk::manage(new Gtk::CheckButton(_(Rule::Type::number_of_rounds) + ":"));
    this->rule_number_of_rounds
      = Gtk::manage(new Gtk::SpinButton());
    this->rule_number_of_rounds->set_increments(1, 10);
    this->rule_points_limited
      = Gtk::manage(new Gtk::CheckButton(_(Rule::Type::points) + ":"));
    this->rule_points
      = Gtk::manage(new Gtk::SpinButton());
    this->rule_points->set_increments(1, 10);
  } // duration
  { // startplayer
    this->startplayer_random = Gtk::manage(new Gtk::RadioButton(_("Button::random")));
  } // startplayer

  this->configure_players
    = Gtk::manage(new Gtk::Button(_("Button::configure players")));
  this->configure_players->set_image_from_icon_name("face-smile");
  this->configure_players->set_always_show_image();
  this->configure_rules
    = Gtk::manage(new Gtk::Button(_("Button::configure rules")));
  this->configure_rules->set_image_from_icon_name("preferences-other");
  this->configure_rules->set_always_show_image();


  { // create the startplayer buttons
    auto startplayer_group
      = this->startplayer_random->get_group();
    for (auto const& p : party.players()) {
      this->startplayer.push_back(Gtk::manage(new Gtk::RadioButton(startplayer_group, p.name())));
    }
    { // the swap buttons
#ifdef WORKAROUND
      // MS-Windows does not show the arrows
#include "arrows/arrow_lu.xpm"
#include "arrows/arrow_ur.xpm"
#include "arrows/arrow_rd.xpm"
#include "arrows/arrow_dl.xpm"
      this->swap_players_buttons.push_back(Gtk::manage(new Gtk::Button()));
      this->swap_players_buttons.back()->add(*Gtk::manage(new Gtk::Image(Gdk::Pixbuf::create_from_xpm_data(arrow_lu_xpm))));
      this->swap_players_buttons.push_back(Gtk::manage(new Gtk::Button()));
      this->swap_players_buttons.back()->add(*Gtk::manage(new Gtk::Image(Gdk::Pixbuf::create_from_xpm_data(arrow_ur_xpm))));
      this->swap_players_buttons.push_back(Gtk::manage(new Gtk::Button()));
      this->swap_players_buttons.back()->add(*Gtk::manage(new Gtk::Image(Gdk::Pixbuf::create_from_xpm_data(arrow_rd_xpm))));
      this->swap_players_buttons.push_back(Gtk::manage(new Gtk::Button()));
      this->swap_players_buttons.back()->add(*Gtk::manage(new Gtk::Image(Gdk::Pixbuf::create_from_xpm_data(arrow_dl_xpm))));

      for (auto& b : this->swap_players_buttons)
        b->set_relief(Gtk::RELIEF_NONE);
#else
      this->swap_players_buttons.push_back(Gtk::manage(new Gtk::Button(Glib::ustring(1, static_cast<gunichar>(0x2196))))); // up left
      this->swap_players_buttons.push_back(Gtk::manage(new Gtk::Button(Glib::ustring(1, static_cast<gunichar>(0x2197))))); // up right
      this->swap_players_buttons.push_back(Gtk::manage(new Gtk::Button(Glib::ustring(1, static_cast<gunichar>(0x2199))))); // down right
      this->swap_players_buttons.push_back(Gtk::manage(new Gtk::Button(Glib::ustring(1, static_cast<gunichar>(0x2198))))); // down left
#endif
    } // the swap buttons
  } // create the startplayer buttons
  { // Layout
    auto hbox = Gtk::manage(new Gtk::Box());
    hbox->set_spacing(1 EM);
    hbox->set_border_width(1 EM);
    this->get_content_area()->add(*hbox);
    { // actions
      { // configure
        auto vbox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL, 1 EX));
        vbox->set_homogeneous();
        vbox->set_halign(Gtk::ALIGN_CENTER);
        vbox->set_valign(Gtk::ALIGN_CENTER);

        vbox->add(*this->configure_rules);
        vbox->add(*this->configure_players);
        hbox->pack_end(*vbox, false, true);
      } // configure

    } // actions

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

      { // seed
        this->seed_frame = Gtk::manage(new Gtk::Frame(_("card distribution")));
        auto grid = Gtk::manage(new Gtk::Grid());

        grid->set_halign(Gtk::ALIGN_CENTER);
        grid->set_border_width(2 EX);
        grid->set_row_spacing(1 EX);
        grid->set_column_spacing(1 EM);

        auto label = Gtk::manage(new Gtk::Label(_("Label::seed") + ":"));
        grid->attach(*label, 0, 0, 1, 1);
        grid->attach(*this->seed_random, 1, 0, 1, 1);
        grid->attach(*this->seed_value, 1, 1, 1, 1);
        seed_frame->add(*grid);
        vbox->add(*this->seed_frame);
      } // seed

      { // duration
        auto duration_frame = Gtk::manage(new Gtk::Frame(_("party duration")));

        auto grid = Gtk::manage(new Gtk::Grid());
        grid->set_halign(Gtk::ALIGN_CENTER);
        grid->set_border_width(2 EX);
        grid->set_row_spacing(1 EX);
        grid->set_column_spacing(1 EM);

        grid->attach(*this->rule_number_of_rounds_limited, 0, 0, 1, 1);
        grid->attach(*this->rule_number_of_rounds, 1, 0, 1, 1);
        grid->attach(*this->rule_points_limited, 0, 1, 1, 1);
        grid->attach(*this->rule_points, 1, 1, 1, 1);
        duration_frame->add(*grid);
        vbox->add(*duration_frame);
      } // duration

      { // startplayer
        this->startplayer_frame
          = Gtk::manage(new Gtk::Frame(_("startplayer")));
        vbox->add(*this->startplayer_frame);

        auto grid = Gtk::manage(new Gtk::Grid());
        grid->set_halign(Gtk::ALIGN_CENTER);
        grid->set_row_homogeneous(true);
        grid->set_column_homogeneous(true);
        grid->set_border_width(2 EX);
        grid->set_row_spacing(1 EX);
        grid->set_column_spacing(1 EM);

        grid->attach(*this->startplayer_random, 1, 1, 1, 1);
        grid->attach(*this->startplayer[0], 1, 2, 1, 1);
        grid->attach(*this->startplayer[1], 0, 1, 1, 1);
        grid->attach(*this->startplayer[2], 1, 0, 1, 1);
        grid->attach(*this->startplayer[3], 2, 1, 1, 1);
        grid->attach(*this->swap_players_buttons[0], 0, 2, 1, 1);
        grid->attach(*this->swap_players_buttons[1], 0, 0, 1, 1);
        grid->attach(*this->swap_players_buttons[2], 2, 0, 1, 1);
        grid->attach(*this->swap_players_buttons[3], 2, 2, 1, 1);
        this->startplayer_frame->add(*grid);
      } // startplayer
      hbox->pack_start(*vbox, true, true);
    } // settings

  } // Layout

  { // signals
    this->load_bug_report_button->signal_clicked().connect(sigc::mem_fun(*this,
                                                                         &PartySettings::load_bug_report)
                                                          );
    this->start_party_button->signal_clicked().connect(sigc::mem_fun(*this,
                                                                     &PartySettings::start_party_event)
                                                      );

    this->seed_value->signal_value_changed().connect(sigc::mem_fun(*this, &PartySettings::seed_change_event));
    this->seed_random->signal_toggled().connect(sigc::mem_fun(*this, &PartySettings::seed_change_event));
    this->seed_random->signal_toggled().connect(sigc::mem_fun(*this,
                                                              &PartySettings::seed_value_sensitivity_update)
                                               );

    this->rule_number_of_rounds_limited->signal_toggled().connect(sigc::bind<int const>(sigc::mem_fun(*this, &PartySettings::rule_change), Rule::Type::number_of_rounds_limited));
    this->rule_number_of_rounds->signal_value_changed().connect(sigc::bind<int const>(sigc::mem_fun(*this, &PartySettings::rule_change), Rule::Type::number_of_rounds));
    this->rule_points_limited->signal_toggled().connect(sigc::bind<int const>(sigc::mem_fun(*this, &PartySettings::rule_change), Rule::Type::points_limited));
    this->rule_points->signal_value_changed().connect(sigc::bind<int const>(sigc::mem_fun(*this, &PartySettings::rule_change), Rule::Type::points));

    this->startplayer_random->signal_toggled().connect(sigc::mem_fun(*this, &PartySettings::startplayer_change_event));
    for (auto& p : this->startplayer)
      p->signal_toggled().connect(sigc::mem_fun(*this, &PartySettings::startplayer_change_event));

    for (unsigned p = 0; p < this->swap_players_buttons.size(); ++p)
      this->swap_players_buttons[p]->signal_clicked().connect(sigc::bind<unsigned const>(sigc::mem_fun(*this, &PartySettings::swap_players_event), p));

    this->configure_players->signal_clicked().connect(sigc::mem_fun0(*this->players,
                                                                     &Gtk::Window::present)
                                                     );
    this->configure_rules->signal_clicked().connect(sigc::mem_fun0(*this->rules,
                                                                   &Gtk::Window::present)
                                                   );
  } // signals

  this->show_all_children();
  this->sensitivity_update();
  this->update();

  party.signal_seed_changed().connect_back(*this, &PartySettings::update, this->disconnector_);
  party.signal_startplayer_changed().connect_back(*this, &PartySettings::update, this->disconnector_);
  party.rule().signal_changed().connect_back([this](auto type, auto old_value)
                                             { this->rules_update();
                                             this->rules->update(type); });
} // void PartySettings::init()

/** get the party settings
 **/
void
PartySettings::get()
{
  if (::fast_play & FastPlay::party_start) {
    ::fast_play.remove(FastPlay::party_start);
    return ;
  }

  auto& party = this->ui->party();
  this->update();

  this->players->create_backup();
  this->rules->create_backup();

  this->start_party_button->show();
  this->start_party_button->grab_default();
  this->start_party_button->grab_focus();

  this->present();
  this->start_party_button->grab_focus();

  while (   !this->ui->thrower
         && this->is_visible()
         && (::game_status == GameStatus::party_new)) {
    ::ui->wait();
    if (::bug_report_replay
        && ::bug_report_replay->auto_start_party())
      break;
  }

  if (::game_status == GameStatus::party_new) {
    // set the seed
    if (this->seed_random->get_active()) {
      party.set_random_seed();
    } else {
      party.set_seed(this->seed_value->get_value());
    }

    // set the startplayer
    if (this->startplayer_random->get_active())
      party.set_random_startplayer();
    else
      for (unsigned p = 0; p < party.players().size(); ++p)
        if (this->startplayer[p]->get_active()) {
          party.set_startplayer(p);
          break;
        }

    this->players->create_backup();
    this->rules->create_backup();
  } // if (::game_status == GameStatus::party_new)

  this->hide();
} // void PartySettings::get()

/** show the window.
 ** Shows/hides the action buttons
 **/
void
PartySettings::on_show()
{
#ifdef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
  this->Dialog::on_show();
#endif

  if (this->ui->first_run_window)
    this->ui->first_run_window->raise();
  if (this->ui->program_updated_window)
    this->ui->program_updated_window->raise();

  this->update();
} // void PartySettings::show()

/** load the bug report
 **/
void
PartySettings::load_bug_report()
{
  this->ui->bug_report->load_file_chooser->present();
} // void PartySettings::load_bug_report()

/** update the sensitivity of all elements
 **/
void
PartySettings::sensitivity_update()
{
  auto sensitive = (::game_status == GameStatus::party_new);
  if (sensitive)
    this->seed_value_sensitivity_update();
  else
    this->seed_value->set_sensitive(false);

  this->seed_random->set_sensitive(sensitive);

  this->rule_number_of_rounds_limited->set_sensitive(sensitive);
  this->rule_number_of_rounds->set_sensitive(sensitive);
  this->rule_points_limited->set_sensitive(sensitive);
  this->rule_points->set_sensitive(sensitive);

  for (auto& p : this->startplayer)
    p->set_sensitive(sensitive);
  this->startplayer_random->set_sensitive(sensitive);
  for (auto p : this->swap_players_buttons)
    p->set_sensitive(sensitive);

  this->players->sensitivity_update();
  this->rules->sensitivity_update();

  this->load_bug_report_button->set_sensitive(sensitive);
  this->start_party_button->set_sensitive(sensitive);

  if (::preferences(::Preferences::Type::additional_party_settings)) {
    this->seed_frame->show();
    this->startplayer_frame->show();
  } else {
    this->seed_frame->hide();
    this->startplayer_frame->hide();
  }
} // void PartySettings::sensitivity_update()

/** update the sensitivity of 'seed_value'
 **/
void
PartySettings::seed_value_sensitivity_update()
{
  switch (::game_status) {
  case GameStatus::party_new:
  case GameStatus::party_initial_loaded:
    this->seed_value->set_sensitive(!(this->seed_random->get_active()));
    break;
  default:
    this->seed_value->set_sensitive(false);
    break;
  } // switch (::game_status);
} // void PartySettings::seed_value_sensitivity_update()

/** update the widgets
 **/
void
PartySettings::update()
{
  if (!this->is_visible())
    return ;

  auto& party = this->ui->party();
  this->sensitivity_update();

  switch (::game_status) {
  case GameStatus::party_new:
#ifndef RELEASE
    this->load_bug_report_button->show();
#endif
    this->start_party_button->show();
    this->close_button->hide();

    this->start_party_button->grab_default();
    break;
  default:
    this->load_bug_report_button->hide();
    this->start_party_button->hide();
    this->close_button->show();

    this->close_button->grab_default();
    break;
  } // switch (::game_status)

  auto const random_seed = party.random_seed();
  if (!random_seed)
    this->seed_value->set_value(party.seed());
  this->seed_random->set_active(random_seed);

  this->rules_update();

  if (party.random_startplayer())
    this->startplayer_random->set_active(true);
  else
    this->startplayer[party.startplayer()]->set_active(true);

  for (auto& p : party.players()) {
    this->name_update_local(p);
  }
  this->players->update();
  this->rules->update_all();
} // void PartySettings::update()

/** update the rules (value, sensitivity)
 **/
void
PartySettings::rules_update()
{
  auto const& rule = this->ui->party().rule();

  this->rule_number_of_rounds_limited->set_active(rule(Rule::Type::number_of_rounds_limited));
  this->rule_number_of_rounds_limited->set_sensitive(rule.dependencies(Rule::Type::number_of_rounds_limited));
  this->rule_number_of_rounds->set_value(rule(Rule::Type::number_of_rounds));
  this->rule_number_of_rounds->set_sensitive(rule(Rule::Type::number_of_rounds_limited));
  this->rule_number_of_rounds->set_value(rule(Rule::Type::number_of_rounds));
  {
    auto const value = rule(Rule::Type::number_of_rounds);
    this->rule_number_of_rounds->set_range(rule.min(Rule::Type::number_of_rounds),
                                           rule.max(Rule::Type::number_of_rounds));
    this->rule_number_of_rounds->set_value(value);
  }

  this->rule_points_limited->set_active(rule(Rule::Type::points_limited));
  this->rule_points_limited->set_sensitive(rule.dependencies(Rule::Type::points_limited));
  this->rule_points->set_sensitive(true);
  this->rule_points->set_value(rule(Rule::Type::points));
  this->rule_points->set_sensitive(rule(Rule::Type::points_limited));
  {
    auto const value = rule(Rule::Type::points);
    this->rule_points->set_range(rule.min(Rule::Type::points),
                                 rule.max(Rule::Type::points));
    this->rule_points->set_value(value);
  }
} // void PartySettings::rules_update()

/** the rules have been changed
 **
 ** @param    type        the type of the rule that has changed
 **/
void
PartySettings::rule_change(int const type)
{
  auto& rule = this->ui->party().rule();
  switch(type) {
  case Rule::Type::number_of_rounds_limited:
    rule.set(Rule::Type::number_of_rounds_limited,
             this->rule_number_of_rounds_limited->get_active());
    break;
  case Rule::Type::number_of_rounds:
    rule.set(Rule::Type::number_of_rounds,
             this->rule_number_of_rounds->get_value_as_int());
    break;
  case Rule::Type::points_limited:
    rule.set(Rule::Type::points_limited,
             this->rule_points_limited->get_active());
    break;
  case Rule::Type::points:
    rule.set(Rule::Type::points,
             this->rule_points->get_value_as_int());
    break;
  default:
    break;
  } // switch(type)
} // void PartySettings::rule_change(int type)

/** the players 'player_a' and 'player_b' have been swapped
 **
 ** @param    player_a   first player
 ** @param    player_b   second player
 **/
void
PartySettings::players_swapped(Player const& player_a,
                               Player const& player_b)
{
  this->name_update_local(player_a);
  this->name_update_local(player_b);

  this->players->players_swapped(player_a, player_b);
} // void PartySettings::players_swapped(Player player_a, Player player_b)

/** update 'player'
 **
 ** @param    player   player to update
 **/
void
PartySettings::player_update(Player const& player)
{
  if (::game_status <= GameStatus::party_new)
    return ;

  this->name_update_local(player);
  this->players->player_update(player);
} // void PartySettings::player_update(Player player)

/** update the name of 'player'
 **
 ** @param    player   player with the new name
 **/
void
PartySettings::name_update(Player const& player)
{
  this->name_update_local(player);
  this->players->name_update(player);
} // void PartySettings::name_update(Player const& player)

/** update the name of 'player'
 **
 ** @param    player   player with the new name
 **/
void
PartySettings::name_update_local(Player const& player)
{
  Pango::FontDescription fd;
  fd.set_weight(player.type() == Player::Type::human
                ? Pango::WEIGHT_BOLD
                : Pango::WEIGHT_NORMAL);
  auto const playerno = this->ui->party().players().no(player);
  DEBUG_ASSERTION((playerno < UINT_MAX),
                  "PlayerSettings::name_update_local(player)\n"
                  "  player '" << player.name() << "' not found in the party");
  if (playerno >= 4)
    return ;

  this->startplayer[playerno]->get_child()->override_font(fd);

  this->startplayer[playerno]->set_label(player.name());
} // void PartySettings::name_update_local(Player player)

/** update the voice of 'player'
 **
 ** @param    player   player with the new voice
 **/
void
PartySettings::voice_update(Player const& player)
{
  this->players->voice_update(player);
} // void PartySettings::voice_update(Player player)

/** update the aiconfig
 **
 ** @param    aiconfig   changed aiconfig
 **/
void
PartySettings::aiconfig_update(Aiconfig const& aiconfig)
{
  this->players->aiconfig_update(aiconfig);
} // void PartySettings::aiconfig_update(Aiconfig aiconfig)

/** a new party is started
 **/
void
PartySettings::start_party_event()
{
  this->hide();
  ::game_status = GameStatus::party_new;
} // void PartySettings::start_party_event()

/** the seed has changed
 **/
void
PartySettings::seed_change_event()
{
  auto& party = this->ui->party();
  // set the seed
  if (this->seed_random->get_active())
    party.set_random_seed();
  else
    party.set_seed(this->seed_value->get_value());
} // void PartySettings::seed_change_event()

/** the startplayer has changed
 **/
void
PartySettings::startplayer_change_event()
{
  auto& party = this->ui->party();
  // set the startplayer
  if (this->startplayer_random->get_active())
    party.set_random_startplayer();
  else
    for (unsigned p = 0; p < party.players().size(); ++p)
      if (this->startplayer[p]->get_active()) {
        party.set_startplayer(p);
        break;
      }
} // void PartySettings::startplayer_change_event()

/** players shall be swapped
 **
 ** @param    p   player to swap with the following
 **/
void
PartySettings::swap_players_event(unsigned const p)
{
  auto& party = this->ui->party();
  party.players().swap(p, (p + 1) % party.players().size());
} // void PartySettings::swap_players_event(unsigned p)

/** a key has been pressed
 **
 ** @param    key   the key
 **
 ** @return   whether the key was used
 **/
bool
PartySettings::key_press(GdkEventKey* const key)
{
  bool used = false;

  if ((key->state & ~GDK_SHIFT_MASK) == 0) {
    switch (key->keyval) {
    case GDK_KEY_p: // show the players
      this->players->present();
      used = true;
      break;
    case GDK_KEY_r: // show the rules
      this->rules->present();
      used = true;
      break;
    } // switch (key->keyval)
  } // if ((key->state & ~GDK_SHIFT_MASK) == 0)

  return (used || this->ui->key_press(key));
} // bool PartySettings::key_press(GdkEventKey* key)

} // namespace UI_GTKMM_NS

#endif // #ifdef USE_UI_GTKMM