ui/gtkmm/reservation.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 "reservation.h"
#include "table.h"
#include "cards_distribution.h"
#include "name.h"
#include "icongroup.h"
#include "ui.h"
#include "main_window.h"

#include "../../party/rule.h"
#include "../../game/game.h"
#include "../../player/player.h"
#include "../../basetypes.h"

#include "../../os/bug_report_replay.h"

#include "../../utils/string.h"

#include <gtkmm/notebook.h>
#include <gtkmm/radiobutton.h>
#include <gtkmm/grid.h>
#include <gtkmm/main.h>
namespace UI_GTKMM_NS {

/** constructor
 **
 ** @param    table      the table
 ** @param    position   the corresponding position
 **/
Reservation::Reservation(Table& table, Position const position) :
  HTIN(table, position),
  Gtk::StickyDialog("Window::reservation", *parent->ui->main_window, false)
{
  this->ui->add_window(*this);

  this->signal_realize().connect(sigc::mem_fun(*this,
                                               &Reservation::init));
}

/** destructor
 **/
Reservation::~Reservation() = default;

/** @return   the corresponding player
 **/
Player&
Reservation::player()
{
  return this->ui->game().player(this->table().player(this->position()).no());
} // Player& Reservation::player()

/** @return   the corresponding game
 **/
Game&
Reservation::game()
{
  return this->ui->game();
} // Game& Reservation::game()

/** create all subelements
 **/
void
Reservation::init()
{
  this->set_icon(this->ui->icon);
  if (this->game().players().count_humans() <= 1)
    this->set_title(_("Window::reservation"));
  else
    this->set_title(_("Window::reservation (%s)",
                      this->player().name()));

  this->set_position(Gtk::WIN_POS_CENTER_ON_PARENT);

  this->announce_button = Gtk::manage(new Gtk::Button(_("Button::reservation announce")));
  this->add_action_widget(*this->announce_button, Gtk::RESPONSE_ACCEPT);

  this->bock_label = Gtk::manage(new Gtk::Label(_("bock: %u", 1u)));
#ifdef POSTPONED
  // does not work reliable
  {
    Pango::AttrList attributes;
    auto attribute
      = Pango::AttrShape::create_attr_weight(Pango::WEIGHT_BOLD);
    attributes.insert(attribute);
    this->bock_label->set_attributes(attributes);
  }
#endif

  this->notebook = Gtk::manage(new Gtk::Notebook());
  this->notebook->set_tab_pos(Gtk::POS_LEFT);
  this->notebook->signal_switch_page().connect(sigc::mem_fun(*this,
                                                             &Reservation::switch_page_event));

  this->swines_button = Gtk::manage(new Gtk::CheckButton(_("swines")));
  this->hyperswines_button = Gtk::manage(new Gtk::CheckButton(_("hyperswines")));
  this->solo_swines_button = Gtk::manage(new Gtk::CheckButton(_("swines")));
  this->solo_hyperswines_button = Gtk::manage(new Gtk::CheckButton(_("hyperswines")));

  this->announce_button->set_can_default();
  this->announce_button->grab_default();
  this->announce_button->grab_focus();

  { // bock information
    this->get_content_area()->pack_start(*this->bock_label, false, true);
  } // bock information
  { // the notebook
    this->get_content_area()->pack_start(*this->notebook, true, true);

    { // create the buttons
      Gtk::RadioButton::Group gametype_group;
      for (auto gt : game_type_list) {
        auto& button = this->gametype_buttons[gt];
        button = Gtk::manage(new Gtk::RadioButton(gametype_group, _(gt)));
        button->set_data("gametype", new GameType(gt));
        button->signal_toggled().connect(sigc::bind<GameType>(sigc::mem_fun(*this, &Reservation::gametype_changed), gt));
      } // for (gt : game_type_list)

      Gtk::RadioButton::Group marriage_selector_group;
      for (auto m : marriage_selector_list) {
        auto& button = this->marriage_selector_buttons[m];
        button = Gtk::manage(new Gtk::RadioButton(marriage_selector_group, _(m)));
        button->set_data("selector", new MarriageSelector(MarriageSelector(m)));
        button->signal_toggled().connect(sigc::bind<MarriageSelector>(sigc::mem_fun(*this, &Reservation::marriage_selector_changed), m));
      } // for (m : marriage_selector_list)
    } // create the buttons

    { // set the pages of the notebook
      { // General
        auto label = Gtk::manage(new Gtk::Label(_("GameType::Group::general")));
        auto hbox = Gtk::manage(new Gtk::Box());
        hbox->set_spacing(1 EX);
        hbox->set_border_width(1 EX);

        { // gametypes
          auto vbox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL, 1 EX));
          vbox->set_valign(Gtk::ALIGN_START);
          vbox->add(*this->gametype_buttons[GameType::normal]);
          vbox->add(*this->gametype_buttons[GameType::thrown_nines]);
          vbox->add(*this->gametype_buttons[GameType::thrown_kings]);
          vbox->add(*this->gametype_buttons[GameType::thrown_nines_and_kings]);
          vbox->add(*this->gametype_buttons[GameType::thrown_richness]);
          vbox->add(*this->gametype_buttons[GameType::fox_highest_trump]);
          vbox->add(*this->gametype_buttons[GameType::poverty]);
          //vbox->add(*this->gametype_buttons[GameType::redistribute]);
          hbox->add(*vbox);
        } // gametypes
        { // marriage selectors
          auto vbox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL));
          vbox->set_valign(Gtk::ALIGN_START);
          vbox->add(*this->gametype_buttons[GameType::marriage]);
          this->marriage_selector_buttons[MarriageSelector::first_foreign]->set_margin_left(1 EM);
          vbox->add(*this->marriage_selector_buttons[MarriageSelector::first_foreign]);
          this->marriage_selector_buttons[MarriageSelector::first_trump]->set_margin_left(1 EM);
          vbox->add(*this->marriage_selector_buttons[MarriageSelector::first_trump]);
          this->marriage_selector_buttons[MarriageSelector::first_color]->set_margin_left(1 EM);
          vbox->add(*this->marriage_selector_buttons[MarriageSelector::first_color]);
          this->marriage_selector_buttons[MarriageSelector::first_club]->set_margin_left(1 EM);
          vbox->add(*this->marriage_selector_buttons[MarriageSelector::first_club]);
          this->marriage_selector_buttons[MarriageSelector::first_spade]->set_margin_left(1 EM);
          vbox->add(*this->marriage_selector_buttons[MarriageSelector::first_spade]);
          this->marriage_selector_buttons[MarriageSelector::first_heart]->set_margin_left(1 EM);
          vbox->add(*this->marriage_selector_buttons[MarriageSelector::first_heart]);
          hbox->add(*vbox);
        } // marriage selectors
        { // the swines
          auto vbox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL, 1 EX));
          vbox->set_valign(Gtk::ALIGN_START);
          vbox->add(*this->swines_button);
          vbox->add(*this->hyperswines_button);
          hbox->add(*vbox);
        } // the swines
        this->notebook->append_page(*hbox, *label);
      } // General
      { // Solo
        auto label = Gtk::manage(new Gtk::Label(_("GameType::Group::solo")));

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

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

          grid->attach(*this->gametype_buttons[GameType::solo_club],
                       0, 0, 1, 1);
          grid->attach(*this->gametype_buttons[GameType::solo_spade],
                       0, 1, 1, 1);
          grid->attach(*this->gametype_buttons[GameType::solo_heart],
                       0, 2, 1, 1);
          grid->attach(*this->gametype_buttons[GameType::solo_diamond],
                       0, 3, 1, 1);
          grid->attach(*this->gametype_buttons[GameType::solo_meatless],
                       1, 0, 1, 1);
          grid->attach(*this->gametype_buttons[GameType::solo_jack],
                       1, 1, 1, 1);
          grid->attach(*this->gametype_buttons[GameType::solo_queen],
                       1, 2, 1, 1);
          grid->attach(*this->gametype_buttons[GameType::solo_king],
                       1, 3, 1, 1);
          grid->attach(*this->gametype_buttons[GameType::solo_queen_jack],
                       2, 0, 1, 1);
          grid->attach(*this->gametype_buttons[GameType::solo_king_jack],
                       2, 1, 1, 1);
          grid->attach(*this->gametype_buttons[GameType::solo_king_queen],
                       2, 2, 1, 1);
          grid->attach(*this->gametype_buttons[GameType::solo_koehler],
                       2, 3, 1, 1);
          vbox->add(*grid);
        }
        {
          auto hbox = Gtk::manage(new Gtk::Box());
          hbox->set_homogeneous();
          hbox->set_spacing(1 EM);
          hbox->set_halign(Gtk::ALIGN_CENTER);
          hbox->add(*this->solo_swines_button);
          hbox->add(*this->solo_hyperswines_button);
          vbox->add(*hbox);
        }

        {
          this->offer_duty_solo_button
            = Gtk::manage(new Gtk::CheckButton(_("offer duty solo")));

          vbox->add(*this->offer_duty_solo_button);
        }

        this->notebook->append_page(*vbox, *label);
      } // Solo
    } // set the pages of the notebook
  } // the notebook
  {
    auto box = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_HORIZONTAL, 5 EM));
    box->set_halign(Gtk::ALIGN_CENTER);
    box->set_margin_top(1 EX);
    box->set_margin_bottom(1 EX);
    {
      auto manual_distribution = Gtk::manage(new Gtk::Button(_("distribute manually")));
      auto manual_distribution_actions =
        [this]() {
          if (this->position() == Position::south) {
            this->ui->table->cards_distribution().save_hand_of_human_player(this->player().hand());
          }
          this->ui->thrower(GameStatus::game_manual_cards_distribution,
                            __FILE__, __LINE__);
        };
      manual_distribution->signal_clicked().connect(manual_distribution_actions);
      box->add(*manual_distribution);
    }
    {
      auto& redistribute = *this->gametype_buttons[GameType::redistribute];
      box->add(redistribute);
    }
    this->get_content_area()->add(*box);
  }
  { // tournament info
    auto grid = Gtk::manage(new Gtk::Grid());
    grid->set_column_spacing(2 EM);
    { // remaining games/rounds/points
      auto grid2 = Gtk::manage(new Gtk::Grid());

      this->remaining_rounds_label
        = Gtk::manage(new Gtk::Label(_("remaining rounds") + ":"s));
      this->remaining_rounds_number
        = Gtk::manage(new Gtk::Label);
      this->remaining_rounds_number->set_label("0");
      this->remaining_games_label
        = Gtk::manage(new Gtk::Label(_("remaining games") + ":"s));
      this->remaining_games_number
        = Gtk::manage(new Gtk::Label);
      this->remaining_games_number->set_label("0");
      this->remaining_points_label
        = Gtk::manage(new Gtk::Label(_("remaining points") + ":"s));
      this->remaining_points_number
        = Gtk::manage(new Gtk::Label);
      this->remaining_points_number->set_label("0");

      this->remaining_rounds_label->set_halign(Gtk::ALIGN_START);
      this->remaining_rounds_number->set_halign(Gtk::ALIGN_END);
      this->remaining_games_label->set_halign(Gtk::ALIGN_START);
      this->remaining_games_number->set_halign(Gtk::ALIGN_END);
      this->remaining_points_label->set_halign(Gtk::ALIGN_START);
      this->remaining_points_number->set_halign(Gtk::ALIGN_END);
      grid2->attach(*this->remaining_rounds_label,
                    0, 0, 1, 1);
      grid2->attach(*this->remaining_rounds_number,
                    1, 0, 1, 1);
      grid2->attach(*this->remaining_games_label,
                    0, 1, 1, 1);
      grid2->attach(*this->remaining_games_number,
                    1, 1, 1, 1);
      grid2->attach(*this->remaining_points_label,
                    0, 2, 1, 1);
      grid2->attach(*this->remaining_points_number,
                    1, 2, 1, 1);

      grid2->set_row_spacing(1 EX);
      grid2->set_column_spacing(static_cast<int>(0.5 EM));

      grid->add(*grid2);
    } // remaining games/rounds/points
    { // duty soli
      auto grid2 = Gtk::manage(new Gtk::Grid());

      this->duty_free_soli_label
        = Gtk::manage(new Gtk::Label(_("duty free soli") + ":"s));
      this->duty_free_soli_number
        = Gtk::manage(new Gtk::Label);
      this->duty_free_soli_number->set_label("0");
      this->duty_color_soli_label
        = Gtk::manage(new Gtk::Label(_("duty color soli") + ":"s));
      this->duty_color_soli_number
        = Gtk::manage(new Gtk::Label);
      this->duty_color_soli_number->set_label("0");
      this->duty_picture_soli_label
        = Gtk::manage(new Gtk::Label(_("duty picture soli") + ":"s));
      this->duty_picture_soli_number
        = Gtk::manage(new Gtk::Label);
      this->duty_picture_soli_number->set_label("0");

      this->duty_free_soli_label->set_halign(Gtk::ALIGN_START);
      this->duty_free_soli_number->set_halign(Gtk::ALIGN_END);
      this->duty_color_soli_label->set_halign(Gtk::ALIGN_START);
      this->duty_color_soli_number->set_halign(Gtk::ALIGN_END);
      this->duty_picture_soli_label->set_halign(Gtk::ALIGN_START);
      this->duty_picture_soli_number->set_halign(Gtk::ALIGN_END);
      grid2->attach(*this->duty_free_soli_label,
                    0, 0, 1, 1);
      grid2->attach(*this->duty_free_soli_number,
                    1, 0, 1, 1);
      grid2->attach(*this->duty_color_soli_label,
                    0, 1, 1, 1);
      grid2->attach(*this->duty_color_soli_number,
                    1, 1, 1, 1);
      grid2->attach(*this->duty_picture_soli_label,
                    0, 2, 1, 1);
      grid2->attach(*this->duty_picture_soli_number,
                    1, 2, 1, 1);

      grid2->set_row_spacing(1 EX);
      grid2->set_column_spacing(static_cast<int>(0.5 EM));

      grid->add(*grid2);
    } // duty soli
    grid->set_border_width(1 EX);
    grid->set_halign(Gtk::ALIGN_CENTER);
    this->get_content_area()->add(*grid);
  } // tournament info

  { // signals
    this->announce_button->signal_clicked().connect(sigc::mem_fun(*this,
                                                                  &Reservation::announce)
                                                   );
    this->swines_button->signal_toggled().connect(sigc::mem_fun(*this, &Reservation::swines_changed));
    this->solo_swines_button->signal_toggled().connect(sigc::mem_fun(*this, &Reservation::swines_changed));
    this->hyperswines_button->signal_toggled().connect(sigc::mem_fun(*this, &Reservation::swines_changed));
    this->solo_hyperswines_button->signal_toggled().connect(sigc::mem_fun(*this, &Reservation::swines_changed));
  } // signals

  this->show_all_children();
} // void Reservation::init()

/** show the reservation for selecting before it is the turn of the player
 **/
void
Reservation::show_for_selection()
{
  if (this->announced)
    return ;

  this->realize();

  this->notebook->set_current_page(0);

  this->set_default();
  this->sensitivity_update();

  { // adjust some texts because of changed points
    this->remaining_rounds_number->set_label(std::to_string(this->ui->party().remaining_rounds()));
    this->remaining_games_number->set_label(std::to_string(this->ui->party().remaining_games()));
    this->remaining_points_number->set_label(std::to_string(this->ui->party().remaining_points()));

    this->duty_free_soli_number->set_label(std::to_string(this->player().remaining_duty_free_soli()));
    this->duty_color_soli_number->set_label(std::to_string(this->player().remaining_duty_color_soli()));
    this->duty_picture_soli_number->set_label(std::to_string(this->player().remaining_duty_picture_soli()));


    this->bock_label->set_label(_("bock: %u",
                                  this->ui->party().current_bock_multiplier()));
    this->gametype_buttons[GameType::thrown_nines]->set_label(_("GameType::%u nines",
                                                                this->game().rule()(Rule::Type::min_number_of_throwing_nines)));
    this->gametype_buttons[GameType::thrown_kings]->set_label(_("GameType::%u kings",
                                                                this->game().rule()(Rule::Type::min_number_of_throwing_kings)));
    this->gametype_buttons[GameType::thrown_nines_and_kings]->set_label(_("GameType::%u nines and kings",
                                                                          this->game().rule()(Rule::Type::min_number_of_throwing_nines_and_kings)));
    this->gametype_buttons[GameType::thrown_richness]->set_label(_("GameType::%u richness",
                                                                   this->game().rule()(Rule::Type::min_richness_for_throwing)));

    if (this->player().hand().count_club_queens()
        == this->game().rule()(Rule::Type::number_of_same_cards)) {
      this->gametype_buttons[GameType::normal]->set_label(_(::GameType::marriage_silent));
    } else {
      this->gametype_buttons[GameType::normal]->set_label(_(::GameType::normal));
    }
  } // adjust some texts
  if (this->ui->party().current_bock_multiplier() != 1)
    this->bock_label->show();
  else
    this->bock_label->hide();

  this->show();
} // void Reservation::show_for_selection()

/** dummy function
 **
 ** @return   false
 **/
bool
Reservation::changed() const
{
  return false;
} // bool Reservation::changed() const

/** nothing (dummy function)
 **
 ** @param    cr       drawing context
 **/
void
Reservation::draw(Cairo::RefPtr<::Cairo::Context> cr)
{
  // this function is needed because it is virtual in base class 'HTIN'
} // void Reservation::draw(Cairo::RefPtr<::Cairo::Context> cr)

/** dummy function
 **
 ** @return   the height of the drawing
 **/
Reservation::Outline
Reservation::outline() const
{
  return {};
} // Outline Reservation::outline() const

/** gets a reservation
 **
 ** @return   reservation
 **/
::Reservation
Reservation::get()
{
  if (!this->announced) {

    if (!this->is_visible())
      this->show_for_selection();

    do {
      if (!this->is_visible())
        this->present();

      while (!this->ui->thrower
             && this->is_visible())
        ::ui->wait();
    } while (!this->announce_button->is_sensitive()
             && !this->ui->thrower) ;
  } // if (!this->announced)

  this->game().set_type(GameType::normal);

  if (!this->announced)
    this->announce();

  this->announced = false;

  this->hide();
  return this->player().reservation();
} // ::Reservation Reservation::get()

/** set to default values
 **/
void
Reservation::set_default()
{
  this->in_update = true;

  ::Reservation const& reservation
    = this->player().reservation_get_default();

  this->swines_button->set_active(reservation.swines);
  this->hyperswines_button->set_active(reservation.hyperswines);
  this->solo_swines_button->set_active(false);
  this->solo_hyperswines_button->set_active(false);
  this->offer_duty_solo_button->set_active(false);

  // special case: with swines announced the player does not have a poverty
  if (   (reservation.game_type == GameType::poverty)
      && (this->player().hand().count_poverty_cards()
          > this->game().rule()(Rule::Type::max_number_of_poverty_trumps)) )
    this->swines_button->set_active(false);

  this->marriage_selector_buttons[reservation.marriage_selector]->set_active();
  this->gametype_buttons[reservation.game_type]->set_active();

  this->name().force_redraw();
  this->table().name(this->game().startplayer()).force_redraw();

  this->in_update = false;

  this->gametype_changed(reservation.game_type);

  { // switch to the game type from the bug report replay
    if (   ::bug_report_replay
        && !::bug_report_replay->finished()
        && (::bug_report_replay->soloplayer_no() == this->player().no() )) {

      this->gametype_buttons[::bug_report_replay->game_type()]->set_active();
      if (::bug_report_replay->game_type() == GameType::marriage) {
        this->marriage_selector_buttons[::bug_report_replay->marriage_selector()]->set_active();
      }

      if (is_solo(::bug_report_replay->game_type()))
        this->notebook->set_current_page(1);
    }
  } // switch to the game type from the bug report replay

  this->swines_changed();
} // void Reservation::set_default()

/** update the sensitivity
 **/
void
Reservation::sensitivity_update()
{
  if (!this->get_realized())
    return ;

  if (::game_status != GameStatus::game_reservation)
    return ;

  if (this->in_update)
    return ;

  auto const& player = this->player();
  auto const& game = player.game();
  auto const& rule = game.rule();
  auto const& hand = player.hand();

  if (   rule(Rule::Type::swines)
      && !rule(Rule::Type::swine_only_second)) {
    this->swines_button->show();
    this->solo_swines_button->show();
  } else {
    this->swines_button->hide();
    this->solo_swines_button->hide();
  }
  if (!rule(Rule::Type::swines_in_solo))
    this->solo_swines_button->hide();
  this->swines_button->set_sensitive(game.swines().swines_announcement_valid(player));
  this->solo_swines_button->set_sensitive(is_color_solo(game.type())
                                          && game.swines().swines_announcement_valid(player));

  if (rule(Rule::Type::hyperswines)) {
    this->hyperswines_button->show();
    this->solo_hyperswines_button->show();
  } else {
    this->hyperswines_button->hide();
    this->solo_hyperswines_button->hide();
  }
  if (!rule(Rule::Type::hyperswines_in_solo))
    this->solo_hyperswines_button->hide();
  this->hyperswines_button->set_sensitive(game.swines().hyperswines_announcement_valid(player)
                                          && this->swines_button->get_active());
  this->solo_hyperswines_button->set_sensitive(is_color_solo(game.type())
                                               && game.swines().hyperswines_announcement_valid(player)
                                               && this->solo_swines_button->get_active());
  if (::preferences(::Preferences::Type::announce_swines_automatically)) {
    this->swines_button->set_sensitive(false);
    this->hyperswines_button->set_sensitive(false);
    this->solo_swines_button->set_sensitive(false);
    this->solo_hyperswines_button->set_sensitive(false);
  } // if (::preferences(::Preferences::Type::announce_swines_automatically))

  for (auto& widget : this->gametype_buttons) {
    if (rule(widget.first))
      widget.second->show();
    else
      widget.second->hide();
  } // for (widget)

  if (rule(Rule::Type::solo))
    this->notebook->get_nth_page(1)->show();
  else
    this->notebook->get_nth_page(1)->hide();

  for (auto& widget : this->marriage_selector_buttons) {
    if (rule(widget.first))
      widget.second->show();
    else
      widget.second->hide();
  } // for (widget)

  this->gametype_buttons[GameType::thrown_richness]->set_sensitive((hand.points() >= rule(Rule::Type::min_richness_for_throwing))
                                                                   && rule(GameType::thrown_richness));
  this->gametype_buttons[GameType::thrown_nines_and_kings]->set_sensitive((hand.count_nines() + hand.count_kings() >= rule(Rule::Type::min_number_of_throwing_nines_and_kings))
                                                                          && rule(GameType::thrown_nines_and_kings));
  this->gametype_buttons[GameType::thrown_kings]->set_sensitive((hand.count_kings() >= rule(Rule::Type::min_number_of_throwing_kings))
                                                                && rule(GameType::thrown_kings));
  this->gametype_buttons[GameType::thrown_nines]->set_sensitive((hand.count_nines() >= rule(Rule::Type::min_number_of_throwing_nines))
                                                                && rule(GameType::thrown_nines));
  this->gametype_buttons[GameType::poverty]->set_sensitive(hand.has_poverty());
  this->gametype_buttons[GameType::redistribute]->set_sensitive(rule(GameType::redistribute));

  { // look, whether there is a card that is higher than the fox
    unsigned c;
    for (c = 0; c < player.hand().cardsnumber(); c++)
      // check with diamond ten because of swines!
      if (   Card::diamond_ten.less(player.hand().card(c))
          && !player.hand().card(c).istrumpace())
        break;
    this->gametype_buttons[GameType::fox_highest_trump]->set_sensitive((c == player.hand().cardsnumber())
                                                                       && rule(GameType::poverty));
  } // look, whether there is a card that is higher than the fox
  this->gametype_buttons[GameType::marriage]->set_sensitive((hand.count_club_queens() == rule(Rule::Type::number_of_same_cards)));

  for (auto widget : this->marriage_selector_buttons) {
    auto const selected = this->gametype_buttons[GameType::marriage]->get_active();
    widget.second->set_sensitive(selected);
    //this->gametype_buttons[GameType::marriage]->sensitive());
  }

  { // duty soli
    if (   game.is_duty_solo()
        && (game.startplayer() == player)) {
      this->announce_button->set_sensitive(false);
      this->notebook->set_current_page(1);
      this->notebook->get_nth_page(0)->set_sensitive(false);
      for (auto widget : this->gametype_buttons) {
        auto const game_type = widget.first;
        widget.second->set_sensitive(   (   is_solo(game_type)
                                         && player.remaining_duty_free_soli())
                                     || (   is_color_solo(game_type)
                                         && player.remaining_duty_color_soli())
                                     || (   is_picture_solo(game_type)
                                         && player.remaining_duty_picture_soli())
                                     || (game_type == GameType::redistribute)
                                    );
        if (   widget.second->is_sensitive()
            && widget.second->get_active())
          this->announce_button->set_sensitive(true);

      } // for (widget)
    } // if (duty solo)

    if (rule(Rule::Type::offer_duty_solo)
        && game.is_duty_solo()
        && (game.startplayer() == player)) {
      this->offer_duty_solo_button->show();
    } else {
      this->offer_duty_solo_button->hide();
    }

    if (rule(Rule::Type::number_of_rounds_limited)) {
      this->remaining_rounds_label->show();
      this->remaining_rounds_number->show();
      this->remaining_games_label->show();
      this->remaining_games_number->show();
    } else {
      this->remaining_rounds_label->hide();
      this->remaining_rounds_number->hide();
      this->remaining_games_label->hide();
      this->remaining_games_number->hide();
    }
    if (rule(Rule::Type::points_limited)) {
      this->remaining_points_label->show();
      this->remaining_points_number->show();
    } else {
      this->remaining_points_label->hide();
      this->remaining_points_number->hide();
    }
    if (  rule(Rule::Type::number_of_duty_soli)
        - rule(Rule::Type::number_of_duty_color_soli)
        - rule(Rule::Type::number_of_duty_picture_soli)
        > 0) {
      this->duty_free_soli_label->show();
      this->duty_free_soli_number->show();
    } else {
      this->duty_free_soli_label->hide();
      this->duty_free_soli_number->hide();
    }
    if (rule(Rule::Type::number_of_duty_color_soli)) {
      this->duty_color_soli_label->show();
      this->duty_color_soli_number->show();
    } else {
      this->duty_color_soli_label->hide();
      this->duty_color_soli_number->hide();
    }
    if (rule(Rule::Type::number_of_duty_picture_soli)) {
      this->duty_picture_soli_label->show();
      this->duty_picture_soli_number->show();
    } else {
      this->duty_picture_soli_label->hide();
      this->duty_picture_soli_number->hide();
    }
  } // duty soli
} // void Reservation::sensitivity_update()

/** the gametype has changed
 **
 ** @param    gametype_   changed game type
 **/
void
Reservation::gametype_changed(GameType const gametype)
{
  if (!this->get_realized())
    return ;

  if (!this->gametype_buttons[gametype]->get_active())
    return ;
  if (this->in_update)
    return ;

  this->in_update = true;

  auto const& player = this->player();
  auto const& game = player.game();
  auto const& rule = game.rule();

  if (gametype == GameType::marriage) {
    auto const selected = this->gametype_buttons[gametype]->get_active();
    for (auto widget : this->marriage_selector_buttons)
      widget.second->set_sensitive(selected);
  } // if (gametype == GameType::marriage)

  // '::party.game()' here, because the game has to be changed,
  // 'this->game()' is a const game
  //GameType const old_gametype = this->>game().type();
  this->game().set_type(static_cast<GameType>(gametype));

  { // update the swines
    auto const& hand = player.hand();

    this->swines_button->set_sensitive(game.swines().swines_announcement_valid(player));
    this->swines_button->set_active(this->swines_button->is_sensitive()
                                    && rule(Rule::Type::swines_announcement_begin)
                                    && ((game.type() != GameType::poverty)
                                        || (hand.count_trumps() <= rule(Rule::Type::max_number_of_poverty_trumps)))
                                   );
    this->hyperswines_button->set_sensitive(game.swines().hyperswines_announcement_valid(player)
                                            && this->swines_button->get_active());
    this->hyperswines_button->set_active(this->hyperswines_button->is_sensitive()
                                         && rule(Rule::Type::hyperswines_announcement_begin));
    this->solo_swines_button->set_sensitive(game.swines().swines_announcement_valid(player));
    this->solo_swines_button->set_active(this->solo_swines_button->is_sensitive()
                                         && rule(Rule::Type::swines_announcement_begin)
                                         && ((game.type() != GameType::poverty)
                                             || (hand.count_trumps() <= rule(Rule::Type::max_number_of_poverty_trumps)))
                                        );
    this->solo_hyperswines_button->set_sensitive(game.swines().hyperswines_announcement_valid(player)
                                                 && this->solo_swines_button->get_active());
    this->solo_hyperswines_button->set_active(this->solo_hyperswines_button->is_sensitive()
                                              && rule(Rule::Type::hyperswines_announcement_begin));

    if (::preferences(::Preferences::Type::announce_swines_automatically)) {
      this->swines_button->set_sensitive(false);
      this->hyperswines_button->set_sensitive(false);
      this->solo_swines_button->set_sensitive(false);
      this->solo_hyperswines_button->set_sensitive(false);
    } // if (::preferences(::Preferences::Type::announce_swines_automatically))
  } // update the swines

  { // update the reservation of the player
    ::Reservation& reservation = this->player().reservation();

    reservation.game_type = static_cast<GameType>(gametype);
    if (   (player.hand().count_club_queens()
            == game.rule()(Rule::Type::number_of_same_cards))
        && (gametype == GameType::normal)) {
      reservation.game_type = GameType::marriage_silent;
    }
    for (auto const& widget : this->marriage_selector_buttons) {
      if (widget.second->get_active()) {
        reservation.marriage_selector = widget.first;
      }
    }
    // swines are updated in the following 'this->swines_changed()'
  } // update the reservation of the player

  this->name().force_redraw();
  this->table().name(game.startplayer()).force_redraw();

  if (    game.is_duty_solo()
      && (game.startplayer() == player)) {
    this->announce_button->set_sensitive(is_real_solo(gametype)
                                         || (gametype == GameType::redistribute));
  }

  this->in_update = false;

  this->table().update_hands();
  this->table().draw_all();
  this->swines_changed();
} // void Reservation::gametype_changed(int gametype)

/** the marriage selector has changed
 **
 ** @param    marriage_selector   changed marriage selector
 **/
void
Reservation::marriage_selector_changed(MarriageSelector const marriage_selector)
{
  if (!this->get_realized())
    return ;

  this->player().reservation().marriage_selector
    = marriage_selector;
  this->table().draw_all();
} // void Reservation::marriage_selector_changed(int marriage_selector_)

/** the selection of swines/hyperswines has changed
 **
 ** @bug       the cards order is not updated (problem: information flow)
 **/
void
Reservation::swines_changed()
{
  if (!this->get_realized())
    return ;

  if (this->in_update)
    return ;

  ::Reservation& reservation = this->player().reservation();

  bool differ = (   (reservation.swines
                     != (is_solo(this->game().type())
                         ? this->solo_swines_button->get_active()
                         : this->swines_button->get_active()))
                 || (reservation.hyperswines
                     != (is_solo(this->game().type())
                         ? this->solo_hyperswines_button->get_active()
                         : this->hyperswines_button->get_active())));
  if (!differ)
    return ;

  reservation.swines
    = (is_solo(this->game().type())
       ? this->solo_swines_button->get_active()
       : this->swines_button->get_active());
  reservation.hyperswines
    = (is_solo(this->game().type())
       ? this->solo_hyperswines_button->get_active()
       : this->hyperswines_button->get_active());

  this->sensitivity_update();
  this->table().update_hands();
  this->table().draw_all();
} // void Reservation::swines_changed()

/** update in game: gametype, swines, hyperswines according to the selected reservation
 ** Used for the 'early' reservation, when the human can select a reservation before it is his turn. When a player before has announced, the game is resetted (gametype normal, no swines). So we have to adjust here, in order to have the cards order not changed.
 **/
void
Reservation::update_for_reservation()
{
  this->game().set_type(this->player().reservation().game_type);
  this->swines_changed();
} // void Reservation::update_for_reservation()

/** update the reservation of the player
 **/
void
Reservation::update_player_reservation()
{
  if (!this->get_realized())
    return ;

  ::Reservation& reservation = this->player().reservation();

  for (auto const& widget : this->gametype_buttons)
    if (widget.second->get_active())
      reservation.game_type = widget.first;

  //reservation.game_type = static_cast<GameType>(gametype);
  for (auto const& widget : this->marriage_selector_buttons)
    if (widget.second->get_active())
      reservation.marriage_selector = widget.first;

  reservation.swines
    = (is_solo(this->game().type())
       ? this->solo_swines_button->get_active()
       : this->swines_button->get_active());
  reservation.hyperswines
    = (is_solo(this->game().type())
       ? this->solo_hyperswines_button->get_active()
       : this->hyperswines_button->get_active());

  reservation.offer_duty_solo
    = this->offer_duty_solo_button->get_active();
} // void Reservation::update_player_reservation()


/** page change
 ** if the user switches to the first page, activate the default reservation
 **
 ** @param    page     the new page
 ** @param    pageno   the number of the page
 **/
void
Reservation::switch_page_event(Widget* widget, guint const pageno)
{
#ifdef WORKAROUND
  // else the 'this->is_visible()' segfaults when starting a new tournament
  if (::game_status != GameStatus::game_reservation)
    return ;
#endif
  if (!this->is_visible())
    return ;

  if (::bug_report_replay) {
    if (   (pageno == 0)
        && is_solo(this->game().type())
        && !is_solo(::bug_report_replay->game_type()))
      this->set_default();
    if (   (pageno == 1)
        && !is_solo(this->game().type())
        && is_solo(::bug_report_replay->game_type()))
      this->set_default();
  } // if (::bug_report_replay)

  if (!::bug_report_replay) {
    if (pageno == 0) {
      if (is_solo(this->game().type())) {
        // reset the reservation
        this->game().set_type(GameType::normal);
        if (!is_solo(this->player().reservation_get_default().game_type))
          this->set_default();
      }
    } // if (pageno == 0)
  } // if (!::bug_report_replay)
} // void Reservation::switch_page_event(Widget*, guint pageno)

/** announce the reservation
 **/
void
Reservation::announce()
{
  if (!this->announce_button->is_sensitive())
    return ;

  this->update_player_reservation();

  this->hide();
#ifdef WINDOWS
#ifdef WORKAROUND
  this->ui->main_window->raise();
#endif
#endif

  this->announced = true;
} // void Reservation::announce()

} // namespace UI_GTKMM_NS

#endif // #ifdef USE_UI_GTKMM