xref: /dports/games/freedoko/FreeDoko_0.7.19/src/ui/gtkmm/poverty.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 "poverty.h"

#include "table.h"
#include "hand.h"
#include "icongroup.h"
#include "name.h"
#include "ui.h"
#include "cards.h"

#include "../../game/game.h"
#include "../../party/rule.h"
#include "../../player/player.h"
#include "../../card/hand.h"
#include "../../os/bug_report_replay.h"

#include <gtkmm/main.h>
#include <gdkmm/general.h>

namespace Gdk {
ostream& operator<<(ostream& ostr, Rectangle const& rectangle);
ostream& operator<<(ostream& ostr, Point const& point);
} // namespace Gdk

namespace UI_GTKMM_NS {
/** constructor
 **
 ** @param    table   parent object
 **/
Poverty::Poverty(Table& table) :
  Table::Part(table)
{ }

/** Destructor
 **/
Poverty::~Poverty() = default;

/** @return   the position of the poverty
 **/
Position
Poverty::position() const
{
  if (!this->player)
    return Position::center;
  return this->table().position(*this->player);
} // Position Poverty::position() const

/** @return   the corresponding hand
 **/
Hand const&
Poverty::hand() const
{
  return this->table().hand(this->position());
} // Hand Poverty::hand() const

/** @return   the corresponding hand
 **/
Hand&
Poverty::hand()
{
  return this->table().hand(this->position());
} // Hand& Poverty::hand()

/** @return   the corresponding icongroup
 **/
Icongroup const&
Poverty::icongroup() const
{
  return this->table().icongroup(this->position());
} // Icongroup Poverty::icongroup() const

/** @return   the corresponding name
 **/
Name const&
Poverty::name() const
{
  return this->table().name(this->position());
} // Icongroup Poverty::name() const

/** @return   whether the active player can shift
 **/
bool
Poverty::middle_full() const
{
  return !contains(this->cards, Card());
} // bool Poverty::middle_full() const

/** @return   whether the active player can shift
 **/
bool
Poverty::shifting_valid() const
{
  if (this->player->type() != Player::Type::human)
    return false;

  switch (this->status) {
  case Status::invalid:
    return false;
  case Status::asking:
    return true;
  case Status::shifting:
  case Status::shifting_back:
    return this->middle_full();
  case Status::getting_back:
    return false;
  case Status::accepted:
  case Status::denied_by_all:
  case Status::finished:
    return false;
  } // switch (this->status)

  return false;
} // bool Poverty::shifting_valid() const

/** 'player' shifts 'cardno' cards
 **
 ** @param    player   the player who shifts the cards
 ** @param    cardno   the number of cards that are shifted
 **/
void
Poverty::shift(Player const& player, unsigned const cardno)
{
  this->status = Status::shifting;

  if (   (player.type() != Player::Type::human)
      //&& (player.game().humanno() > 0)
      && !(::fast_play & FastPlay::pause)
      && !(::bug_report_replay && ::bug_report_replay->auto_action()) ) {
    this->shift_cards = false;
    this->cards = player.game().poverty().shifted_cards();
    this->player = &player;

    this->table().draw_all();

    while (!this->ui->thrower
           && (::game_status == GameStatus::game_poverty_shift)
           && (this->shift_cards == false))
      ::ui->wait();
    if (this->ui->thrower)
      return ;
  } // if (player.type() != Player::Type::human)

  this->status = Status::asking;
} // void Poverty::shift(Player player, unsigned cardno)

/** 'player' denied to take the shifted cards
 **
 ** @param    player   the player who has denied to take the cards
 **/
void
Poverty::take_denied(Player const& player)
{ }

/** all players have denied to take the cards
 **/
void
Poverty::take_denied_by_all()
{
  this->player = &this->player->game().players().soloplayer();
  this->status = Status::denied_by_all;
} // void Poverty::take_denied_by_all()

/** 'player' accepts to take the shifted cards
 ** and returns 'cardno' cards with 'trumpno' trumps
 ** show the cards and wait for a click
 **
 ** @param    player   the player who has denied to take the cards
 ** @param    cardno   number of cards that are given back
 ** @param    trumpno   number of trumps of the cards
 **/
void
Poverty::take_accepted(Player const& player,
                       unsigned const cardno, unsigned const trumpno)
{
  this->status = Status::accepted;
  this->force_redraw();
  this->table().draw_all();
} // void Poverty::take_accepted(Player player, unsigned cardno, unsigned trumpno)

/** returns which cards the player shifts
 **
 ** @param    player   the player who shifts the cards (the soloplayer)
 **
 ** @return   the cards that are to be shifted
 **/
HandCards
Poverty::shift(Player& player)
{
  this->status = Status::shifting;

  this->cards = HandCards(player.hand().count_poverty_cards());
  this->player = &player;
  auto hand = player.hand().sorted();

  this->shift_cards = false;

  // put all trump in the middle
  unsigned j = 0;
  for (unsigned i = 0; i < hand.cardsnumber_all(); i++)
    if (hand.card_all(i).istrump()) {
      this->cards[j] = hand.card_all(i);
      hand.playcard(i - j);
      j += 1;
    }

  this->table().draw_all();

  while (!this->ui->thrower
         && (::game_status == GameStatus::game_poverty_shift)
         && (this->shift_cards == false))
    ::ui->wait();
  if (this->ui->thrower)
    return {};

  if (::game_status != GameStatus::game_poverty_shift)
    return this->cards;

  hand.remove(this->cards);

  return this->cards;
} // HandCards Poverty::shift(Player& player)

/** ask 'player' whether to accept the poverty
 **
 ** @param    player   the player who is asked
 ** @param    cardno   the number of shifted cards
 **/
void
Poverty::ask(Player const& player, unsigned const cardno)
{
  //this->cards = HandCards(cardno);
  this->cards = player.game().poverty().shifted_cards();
  this->player = &player;

  this->table().draw_all();
} // void Poverty::ask(Player player, unsigned cardno)

/** returns whether 'player' accepts the shifted cards
 **
 ** @param    player   the player who shifts the cards
 ** @param    cardno   the number of shifted cards
 **
 ** @return   whether to accept the cards
 **/
bool
Poverty::take_accept(Player const& player, unsigned const cardno)
{
  this->status = Status::asking;

  //this->cards = HandCards(cardno);
  this->cards = player.game().poverty().shifted_cards();
  this->player = &player;

  this->accept_cards = false;
  this->shift_cards = false;

  this->table().draw_all();

  while (!this->ui->thrower
         && (::game_status == GameStatus::game_poverty_shift)
         && (this->accept_cards == false)
         && (this->shift_cards == false))
    ::ui->wait();
  if (this->ui->thrower)
    return false;

  return this->accept_cards;
} // bool Poverty::take_accept(Player const& player, unsigned cardno)

/** changes the cards from the poverty-player
 **
 ** @param    player          the player who has accepted the cards
 ** @param    cards_shifted   the cards that are given to the player
 **
 ** @return   the cards that are returned to the poverty-player
 **/
HandCards
Poverty::cards_change(Player& player, HandCards const& cards_shifted)
{
  this->status = Status::shifting_back;

  this->player = &player;
  auto hand = player.hand().sorted();

  this->accept_cards = false;
  this->shift_cards = false;

  // add the cards to the hand, but mark all cards in the middle as played
  hand.add(cards_shifted);
  for (auto const&  c : cards_shifted)
    player.hand().playcard(c);
  this->cards.clear();
  for (unsigned c = 0; c < hand.cardsnumber_all(); ++c)
    if (hand.played(c))
      this->cards.push_back(hand.card_all(c));

  this->table().draw_all();

  while (!this->ui->thrower
         && (::game_status == GameStatus::game_poverty_shift)
         && (this->shift_cards == false))
    ::ui->wait();
  if (this->ui->thrower)
    return HandCards();

  // remove the cards to shift from the hand of the player
  hand.remove(this->cards);

  return this->cards;
} // HandCards Poverty::cards_change(Player& player, HandCards cards_shifted)

/** changes the cards from the poverty-player
 **
 ** @param    player           the player who has accepted the cards
 ** @param    cards_returned   the cards that are given to the player
 **
 ** @return   the cards that are returned to the poverty-player
 **/
void
Poverty::cards_get_back(Player const& player_,
                        HandCards const& cards_returned)
{
  Player& player = this->ui->game().player(player_.no());
  auto hand = player.hand().sorted();
  if (player.type() != Player::Type::human)
    return ;

  this->status = Status::getting_back;

  this->player = &player;

  this->accept_cards = false;

  // add the cards to the hand, but mark all cards in the middle as played
  hand.add(cards_returned);
  for (auto const& c : cards_returned)
    player.hand().playcard(c);
  this->cards.clear();
  for (unsigned c = 0; c < hand.cardsnumber_all(); ++c)
    if (hand.played(c))
      this->cards.push_back(hand.card_all(c));

  this->table().draw_all();

  while (!this->ui->thrower
         && (::game_status == GameStatus::game_poverty_shift)
         && (this->accept_cards == false))
    ::ui->wait();
  if (this->ui->thrower)
    return ;

  for (auto const& c : this->cards)
    hand.unplaycard(c);

  this->status = Status::finished;
} // void Poverty::cards_get_back(Player& player, HandCards cards_returned)

/** -> result
 **
 ** @param    cardno   number of card
 **
 ** @return   position of the cards (relative)
 **/
vector<Gdk::Point>
Poverty::cards_pos() const
{
  if (!this->player)
    return {};
  int const card_width = this->ui->cards->width();
  int const card_height = this->ui->cards->height();
  int const width = this->geometry_cards().width();
  int const height = this->geometry_cards().height();
  int const max_pos_y = -max(0, height - card_height);
  int const cardsnumber = this->cards.size();

  auto const gap = min(card_width / 2,
                       (width - cardsnumber * card_width)
                       / max(1, cardsnumber - 1));
  switch (cardsnumber) {
  case 0:
  case 1:
    return {{-card_width / 2, 0}};
  case 2:
    return {{-card_width - gap / 2, 0},
      {gap / 2, 0},
    };
  case 3:
    return {{-card_width - gap - card_width / 2, 0},
      {-card_width / 2, max(-card_height / 4, max_pos_y)},
      {card_width / 2 + gap, 0},
    };
  case 4:
    return {{-card_width - gap - card_width - gap / 2, 0},
      {-card_width - gap / 2, max(-card_height / 4, max_pos_y)},
      {gap / 2, max(-card_height / 4, max_pos_y)},
      {gap / 2 + card_width + gap, 0},
    };
  case 5:
    return {{-card_width - gap - card_width - gap - card_width / 2, 0},
      {-card_width - gap - card_width / 2, max(-card_height / 4, max_pos_y)},
      {-card_width / 2, max(-card_height / 3, max_pos_y)},
      {card_width / 2 + gap, max(-card_height / 4, max_pos_y)},
      {card_width / 2 + gap + card_width + gap, 0},
    };
  }; // switch (cardsnumber)
  return {};
} // vector<Gdk::Point> Poverty::cards_pos() const

/** @return   whether the drawing has changed
 **/
bool
Poverty::changed() const
{
  return true;
} // bool Poverty::changed() const

/** draws the poverty elements in the table
 **
 ** @param    cr       cairo context
 **/
void
Poverty::draw(Cairo::RefPtr<::Cairo::Context> cr)
{
  if (!this->is_drawn())
    return ;

  this->draw_arrow(cr);
  this->draw_cards(cr);
} // void Poverty::draw(Cairo::RefPtr<::Cairo::Context> cr)

/** Draw the cards
 **
 ** @param    cr   graphic context
 **/
void
Poverty::draw_cards(Cairo::RefPtr<::Cairo::Context> cr)
{
  auto const cardno = this->cards.size();
  auto const positions = this->cards_pos();

  cr->push_group();
  this->geometry_cards().transform(cr);
  cr->translate(0, -this->ui->cards->height());

  if (cardno == 0) {
    auto card = this->ui->cards->back();
    draw_pixbuf(cr, card, positions[0]);
  } else { // if !(cardno == 0)
    DEBUG_ASSERTION(cardno == positions.size(),
                    "Poverty::draw()\n"
                    "  cardno = " << cardno << " != " << positions.size() << " = position.size()");
    for (unsigned i = 0; i < cardno; i++) {
      auto card = this->ui->cards->card(Card());
      if (   (   (this->status != Status::asking)
              && !(   (this->status == Status::shifting)
                   && (this->player->type() != Player::Type::human)) )
          || ::preferences(::Preferences::Type::show_all_hands)
          || (   this->game().rule()(Rule::Type::poverty_fox_shift_open)
#ifdef WORKAROUND
              // Bug:
              // 'isfox' needs a corresponding hand,
              // but 'cards' does not belong anymore to the hand of
              // the poverty player.
              // The only problem exists, if the card is a swine, but
              // then the swines are already announced
              && this->cards[i].istrumpace()
              && !this->game().swines().swines_announced()
#else
              && this->cards[i].isfox()
#endif
             ) )
        card = this->ui->cards->card(this->cards[i]);
      draw_pixbuf(cr, card, positions[i]);
    } // for (i < cardno)
  } // if !(cardno == 0)
  cr->pop_group_to_source();
  cr->paint();
} // void Poverty::draw_cards(Cairo::RefPtr<::Cairo::Context> cr)

/** Draw the arrow
 **
 ** @param    cr   graphic context
 **/
void
Poverty::draw_arrow(Cairo::RefPtr<::Cairo::Context> cr)
{
  if (this->player->type() != Player::Type::human)
    return ;
  if (!this->shifting_valid())
    return ;

  cr->save();
  auto const geometry = this->geometry_arrow();
  geometry.transform(cr);

  bool const mirror = (this->status == Status::shifting_back);

  int const width = geometry.width();
  int const height = geometry.height();

  cr->scale(width, height / 2);
  if (mirror) {
    cr->scale(-1, 1);
  }
  cr->translate(-0.5, 0);
  cr->move_to(0, -1);
  cr->scale(1, 1 / 1.25);
  cr->rel_line_to(1.0 / 6, -1.25); // Obere Ecke
  cr->rel_line_to(0, 0.75);
  cr->rel_line_to(5.0 / 6, 0);
  cr->rel_line_to(0, 1);
  cr->rel_line_to(-5.0 / 6, 0);
  cr->rel_line_to(0, 0.75);
  cr->close_path();
  cr->set_source_rgb(0, 0, 0);
  cr->fill();
  cr->restore();
} // void Poverty::draw_arrow(Cairo::RefPtr<::Cairo::Context> cr)

/** @return   the outline of the trick
 **/
Poverty::Outline
Poverty::outline() const
{
  if (!this->is_drawn())
    return {0, 0, 1, 1};

  return (this->geometry_arrow().outline()
          + this->geometry_cards().outline());
} // Outline Poverty::outline() const

/** @return   the geometry for the arrow
 **/
Poverty::GeometryArrow
Poverty::geometry_arrow() const
{
  GeometryArrow geometry;
  auto const hand_geometry = this->hand().geometry();
  auto const icongroup_geometry = this->icongroup().geometry();
  auto table = &this->table();
  geometry.width = [=](){
    return min(hand_geometry.width() * 3 / 4,
               max(2 * this->ui->cards->width(),
                   hand_geometry.width() * 1 / 2));
  };
  geometry.height = [=](){
    return this->ui->cards->height() * 2 / 10;
  };
  switch (this->table().layout()) {
  case Table::Layout::standard:
    switch (this->position()) {
    case Position::south:
      geometry.rotation = Rotation::up;
      geometry.pos_x = [=](){
        return (hand_geometry.pos_x()
                + hand_geometry.width() / 2);
      };
      geometry.pos_y = [=](){
        return (hand_geometry.pos_y()
                - hand_geometry.height()
                - hand_geometry.margin_y()
                - icongroup_geometry.height()
                - 2 * hand_geometry.margin_y());
      };
      break;

    case Position::north:
      geometry.rotation = Rotation::down;
      geometry.pos_x = [=](){
        return (hand_geometry.pos_x()
                - hand_geometry.width() / 2);
      };
      geometry.pos_y = [=](){
        return (hand_geometry.pos_y()
                + hand_geometry.height()
                + hand_geometry.margin_y()
                + icongroup_geometry.height()
                + 2 * hand_geometry.margin_y());
      };
      break;

    case Position::west:
      geometry.rotation = Rotation::right;
      geometry.pos_x = [=](){
        return (hand_geometry.pos_x()
                + hand_geometry.height()
                + hand_geometry.margin_y()
                + icongroup_geometry.height()
                + 2 * hand_geometry.margin_y());
      };
      geometry.pos_y = [=](){
        return (hand_geometry.pos_y()
                + hand_geometry.width() / 2);
      };
      break;

    case Position::east:
      geometry.rotation = Rotation::left;
      geometry.pos_x = [=](){
        return (hand_geometry.pos_x()
                - hand_geometry.height()
                - hand_geometry.margin_y()
                - icongroup_geometry.height()
                - 2 * hand_geometry.margin_y());
      };
      geometry.pos_y = [=](){
        return (hand_geometry.pos_y()
                - hand_geometry.width() / 2);
      };
      break;

    case Position::center:
      DEBUG_ASSERTION(false,
                      "Poverty::geometry()\n"
                      "  wrong position 'center' "
                      << "(" << this->position() << ")");
    } // switch (this->position())
    break;

  case Table::Layout::widescreen:
    switch (this->position()) {
    case Position::south:
      geometry.rotation = Rotation::up;
      geometry.pos_x = [=](){
        return (hand_geometry.pos_x()
                + hand_geometry.width() / 2);
      };
      geometry.pos_y = [=](){
        return (hand_geometry.pos_y()
                - hand_geometry.height()
                - hand_geometry.margin_y()
                - icongroup_geometry.height()
                - 2 * hand_geometry.margin_y());
      };
      break;

    case Position::north: {
      geometry.rotation = Rotation::down;
      auto const hand_geometry = this->hand().geometry();
      auto const hand_south_geometry = table->hand(Position::south).geometry();
      geometry.pos_x = [=](){
        return (hand_south_geometry.pos_x()
                + hand_south_geometry.width() / 2);
      };
      geometry.pos_y = [=](){
        return (hand_geometry.pos_y()
                + hand_geometry.height()
                + hand_geometry.margin_y());
      };
      break;
    }

    case Position::west: {
      geometry.rotation = Rotation::right;
      auto const hand_south_geometry = table->hand(Position::south).geometry();
      auto const icongroup_south_geometry = table->icongroup(Position::south).geometry();
      auto const hand_north_geometry = table->hand(Position::north).geometry();
      auto const icongroup_north_geometry = table->icongroup(Position::north).geometry();
      geometry.pos_x = [=](){
        return hand_south_geometry.pos_x();
      };
      geometry.pos_y = [=](){
        auto const y = (icongroup_north_geometry.pos_y()
                      + icongroup_north_geometry.height()
                      + hand_south_geometry.margin_y());
        return (y
                + (icongroup_south_geometry.pos_y()
                   - icongroup_south_geometry.height()
                   - hand_south_geometry.margin_y()
                   - y
                  ) / 2);
      };
      geometry.width = [=](){
        auto const y = (icongroup_north_geometry.pos_y()
                      + icongroup_north_geometry.height()
                      + hand_north_geometry.margin_y()
                      + hand_south_geometry.margin_y());
        return min(this->geometry_cards().width() * 2 / 3,
                   icongroup_south_geometry.pos_y()
                   - icongroup_south_geometry.height()
                   - hand_south_geometry.margin_y()
                   - y
                  );
      };
      break;
    }

    case Position::east:
      geometry.rotation = Rotation::left;
      geometry.pos_x = [=](){
        return (hand_geometry.pos_x()
                - hand_geometry.height()
                - hand_geometry.margin_y()
                - icongroup_geometry.height()
                - 2 * hand_geometry.margin_y());
      };
      geometry.pos_y = [=](){
        return (hand_geometry.pos_y()
                - hand_geometry.width() / 2);
      };
      break;

    case Position::center:
      DEBUG_ASSERTION(false,
                      "Poverty::geometry()\n"
                      "  wrong position 'center' "
                      << "(" << this->position() << ")");
    } // switch (this->position())
    break;
  } // switch (this->table().layout())
  return geometry;
} // GeometryArrow Poverty::geometry_arrow() const

/** @return   the outline of the arrow
 **/
Table::Part::Outline
Poverty::GeometryArrow::outline() const
{
  return this->transform({-this->width() / 2, -this->height(),
                         this->width(), this->height()});
} // Table::Part::Outline Poverty::GeometryArrow::outline() const

/** @return   the geometry for the cards
 **/
Poverty::GeometryCards
Poverty::geometry_cards() const
{
  GeometryCards geometry;
  auto const geometry_arrow = this->geometry_arrow();
  auto const hand_geometry = this->hand().geometry();
  auto table = &this->table();
  geometry.width = [=](){
    return hand_geometry.width() * 3 / 4;
  };
  switch (this->table().layout()) {
  case Table::Layout::standard:
    switch (this->position()) {
    case Position::south:
      geometry.rotation = Rotation::up;
      geometry.pos_x = [=](){
        return (hand_geometry.pos_x()
                + hand_geometry.width() / 2);
      };
      geometry.pos_y = [=](){
        return (geometry_arrow.pos_y()
                - geometry_arrow.height()
                - 2 * hand_geometry.margin_y());
      };
      geometry.height = [=](){
        return min(this->ui->cards->height() * 3 / 2,
                   geometry.pos_y()
                   - table->icongroup(Position::north).geometry().pos_y()
                   - table->icongroup(Position::north).geometry().height()
                   - table->hand(Position::north).geometry().margin_y()
                  );
      };
      break;

    case Position::north:
      geometry.rotation = Rotation::down;
      geometry.pos_x = [=](){
        return (hand_geometry.pos_x()
                - hand_geometry.width() / 2);
      };
      geometry.pos_y = [=](){
        return (geometry_arrow.pos_y()
                + geometry_arrow.height()
                + 2 * hand_geometry.margin_y());
      };
      geometry.height = [=](){
        return min(this->ui->cards->height() * 3 / 2,
                   table->icongroup(Position::south).geometry().pos_y()
                   - table->icongroup(Position::south).geometry().height()
                   - table->hand(Position::south).geometry().margin_y()
                   - geometry.pos_y()
                  );
      };
      break;

    case Position::west:
      geometry.rotation = Rotation::right;
      geometry.pos_x = [=](){
        return (geometry_arrow.pos_x()
                + geometry_arrow.height()
                + 2 * hand_geometry.margin_y());
      };
      geometry.pos_y = [=](){
        return (hand_geometry.pos_y()
                + hand_geometry.width() / 2);
      };
      geometry.height = [=](){
        return this->ui->cards->height() * 3 / 2;
      };
      break;

    case Position::east:
      geometry.rotation = Rotation::left;
      geometry.pos_x = [=](){
        return (geometry_arrow.pos_x()
                - geometry_arrow.height()
                - 2 * hand_geometry.margin_y());
      };
      geometry.pos_y = [=](){
        return (hand_geometry.pos_y()
                - hand_geometry.width() / 2);
      };
      geometry.height = [=](){
        return this->ui->cards->height() * 3 / 2;
      };
      break;

    case Position::center:
      DEBUG_ASSERTION(false,
                      "Poverty::geometry()\n"
                      "  wrong position 'center' "
                      << "(" << this->position() << ")");
    } // switch (this->position())
    break;

  case Table::Layout::widescreen:
    switch (this->position()) {
    case Position::south:
      geometry.rotation = Rotation::up;
      geometry.pos_x = [=](){
        return geometry_arrow.pos_x();
      };
      geometry.pos_y = [=](){
        return (geometry_arrow.pos_y()
                - geometry_arrow.height()
                - 2 * hand_geometry.margin_y());
      };
      geometry.height = [=](){
        return min(this->ui->cards->height() * 3 / 2,
                   geometry.pos_y()
                   - table->border_y());
      };
      break;

    case Position::north: {
      geometry.rotation = Rotation::down;
      auto const hand_south_geometry = table->hand(Position::south).geometry();
      auto const name_geometry = this->name().geometry();
      geometry.pos_x = [=](){
        return geometry_arrow.pos_x();
      };
      geometry.pos_y = [=](){
        return (geometry_arrow.pos_y()
                + geometry_arrow.height()
                + 2 * hand_south_geometry.margin_y());
      };
      geometry.height = [=](){
        return min(this->ui->cards->height() * 3 / 2,
                   hand_south_geometry.pos_y()
                   - name_geometry.pos_y()
                   - name_geometry.height()
                   - hand_geometry.margin_y());
      };
      geometry.width = [=](){
        return hand_south_geometry.width() * 3 / 4;
      };
    }
      break;

    case Position::west:
      geometry.rotation = Rotation::right;
      geometry.pos_x = [=](){
        return (geometry_arrow.pos_x()
                + geometry_arrow.height()
                + 2 * hand_geometry.margin_y());
      };
      geometry.pos_y = [=](){
        return geometry_arrow.pos_y();
      };
      geometry.height = [=](){
        return this->ui->cards->height() * 3 / 2;
      };
      break;

    case Position::east:
      geometry.rotation = Rotation::left;
      geometry.pos_x = [=](){
        return (geometry_arrow.pos_x()
                - geometry_arrow.height()
                - 2 * hand_geometry.margin_y());
      };
      geometry.pos_y = [=](){
        return geometry_arrow.pos_y();
      };
      geometry.height = [=](){
        return this->ui->cards->height() * 3 / 2;
      };
      break;

    case Position::center:
      DEBUG_ASSERTION(false,
                      "Poverty::geometry()\n"
                      "  wrong position 'center' "
                      << "(" << this->position() << ")");
    } // switch (this->position())
    break;
  } // switch (this->table().layout())

  return geometry;
} // GeometryCards Poverty::geometry_cards() const

/** @return   the outline of the arrow
 **/
Table::Part::Outline
Poverty::GeometryCards::outline() const
{
  return this->transform({-this->width() / 2, -this->height(),
                         this->width(), this->height()});
} // Table::Part::Outline Poverty::GeometryCards::outline() const

/** if the arrow is clicked, shift the cards
 ** if a card in the hand is clicked, move it in the cards-to-be-shifted
 ** if a card in the middle is clicked, move it in the hand
 ** no release: if the right button is clicked on an empty card, add cards
 **             according to the bug report
 **
 ** @param    button_event   data of the button event
 **
 ** @return   whether the click has been accepted
 **/
bool
Poverty::button_press_event(GdkEventButton* const button_event)
{
  // whether the mouse click leads to an action
  bool accepted = false;

  switch (this->possible_action(static_cast<int>(button_event->x),
                                static_cast<int>(button_event->y))) {
  case Action::none:
    accepted = false;
    break;
  case Action::shift_cards:
    switch (button_event->button) {
    case 1: // left mouse button
      this->shift_cards = true;
      accepted = true;
      break;
    default:
      break;
    } // switch (button_event->button)
    break;
  case Action::accept_cards:
    switch (button_event->button) {
    case 1: // left mouse button
      this->accept_cards = true;
      accepted = true;
      break;
    default:
      break;
    } // switch (button_event->button)
    break;
  case Action::take_card:
    {
      Player& player = const_cast<Player&>(*this->player);
      auto hand = player.hand().sorted();

      // test whether a card in the middle is clicked
      auto const cardno
        = this->cardno_at_position(static_cast<int>(button_event->x), static_cast<int>(button_event->y));
      DEBUG_ASSERTION(cardno,
                      "Poverty::button_press_event():\n"
                      "  no card under the mouse");

      // move a card in the hand
      switch (button_event->button) {
      case 1: // left mouse button
        if (this->cards[*cardno].is_empty())
          break;
        hand.unplaycard(this->cards[*cardno]);
        this->cards[*cardno] = Card();
        this->force_redraw();
        this->table().draw_all();
        accepted = true;
        break;
      case 3: // right mouse button

        // put all cards in the hand
        for (auto& c : this->cards) {
          if (!c.is_empty()) {
            if (   (this->status != Status::shifting)
                || (!c.istrump())) {
              hand.unplaycard(c);
              c = Card();
            } // if (card not trump when soloplayer)
          }
        }
        this->force_redraw();
        this->table().draw_all();
        accepted = true;
      default:
        break;
      } // switch (button_event->button)
    }
    break;

  case Action::put_card:
    switch (button_event->button) {
    case 1: // left mouse button
      {
        auto const cardno
          = this->hand().cardno_at_position(static_cast<int>(button_event->x), static_cast<int>(button_event->y));
        DEBUG_ASSERTION(cardno,
                        "Poverty::button_press_event():\n"
                        "  no card under the mouse");
        this->add_card_to_shift(*cardno);
        this->force_redraw();
        this->table().draw_all();
        accepted = true;
      }
      break;
    default:
      break;
    } // switch (button_event->button)
    break;

  case Action::fill_up:
    // for a bug report: fill up according to the bug report
    switch (button_event->button) {
    case 3: { // right mouse button
      Player& player = const_cast<Player&>(*this->player);
      auto hand = player.hand().sorted();

      // test whether a card in the middle is clicked
      auto const cardno
        = this->cardno_at_position(static_cast<int>(button_event->x), static_cast<int>(button_event->y));
      if (!cardno)
        break;

      if (!(   ::bug_report_replay
            && this->cards[*cardno].is_empty()) )
        break;

      accepted = true;
      // fill up according to the bug report
      for (auto& c : this->cards) {
        if (!c.is_empty()) {
          hand.unplaycard(c);
          c = Card();
        }
      }

      switch (status) {
      case Status::shifting:
        DEBUG_ASSERTION(!::bug_report_replay->poverty_cards_shifted().empty(),
                        "UI_GTKMM:Poverty::on_mouse_click_event()\n"
                        "  the bug report does not contain shifted cards");
        this->cards.clear();
        for (auto const& c: ::bug_report_replay->poverty_cards_shifted())
          this->cards.push_back({player.hand(), c});
        break;

      case Status::shifting_back:
        DEBUG_ASSERTION(!::bug_report_replay->poverty_cards_returned().empty(),
                        "UI_GTKMM:Poverty::on_mouse_click_event()\n"
                        "  the bug report does not contain returned cards");
        this->cards.clear();
        for (auto const& c : ::bug_report_replay->poverty_cards_returned())
          this->cards.push_back({player.hand(), c});
        break;
      default:
        break;
      } // switch(status)

      for (auto const& c : this->cards)
        hand.playcard(c);

      this->force_redraw();
      this->table().draw_all();
      break;
    }

    default:
      break;
    } // switch (button_event->button)
    break;

  case Action::return_cards:
    switch (button_event->button) {
    case 1: // left mouse button
      this->shift_cards = true;
      accepted = true;
      break;
    default:
      break;
    } // switch (button_event->button)
    break;
  case Action::get_cards_back:
    switch (button_event->button) {
    case 1: // left mouse button
      this->accept_cards = true;
      accepted = true;
      break;
    default:
      break;
    } // switch (button_event->button)
    break;
  }; // switch (this->possible_actions(button_event->x, button_event->y)) {

  return accepted;
} // bool Poverty::button_press_event(GdkEventButton* button_event)

/** -> result
 **
 ** @param    x   x position
 ** @param    y   y position
 **
 ** @return   what action a can be made at the position (for the mouse)
 **/
Poverty::Action
Poverty::possible_action(int const x, int const y) const
{
  if (   (this->status == Status::invalid)
      || (this->status == Status::finished))
    return Action::none;

  if (!this->player)
    return Action::none;

  if (   (this->player->type() != Player::Type::human)
      && (this->status == Status::shifting))
    return Action::shift_cards;

  if (this->player->type() != Player::Type::human)
    return Action::none;

  if (this->shifting_valid()) {
    // test whether mouse is over the arrow
    auto const outline = this->geometry_arrow().outline();
    if (   (x >= outline.x())
        && (x <= outline.x() + outline.width())
        && (y >= outline.y())
        && (y <= outline.y() + outline.height())
       ) {
      switch(this->status) {
      case Status::invalid:
        return Action::none;
      case Status::shifting:
        return Action::shift_cards;
      case Status::shifting_back:
        return Action::return_cards;
      case Status::asking:
        return Action::shift_cards;
      case Status::getting_back:
      case Status::accepted:
      case Status::denied_by_all:
      case Status::finished:
        return Action::none;
      } // switch(this->status)
    } // if (arrow clicked)
  } // test whether the mouse is over the arrow

  { // test whether the mouse is over a card in the middle
    auto const cardno = this->cardno_at_position(x, y);

    if (cardno) {
      auto const& card = this->cards[*cardno];
      // special case: fill up the cards in the middle
      if (   ::bug_report_replay
          && (   (this->status == Status::shifting)
              || (this->status == Status::shifting_back) )
          && card.is_empty() )
        return Action::fill_up;

      switch(this->status) {
      case Status::invalid:
        DEBUG_ASSERTION(false,
                        "Poverty::possible_action():\n"
                        "  'this->status' == invalid");
        break;
      case Status::shifting:
        // move a non-trump card in the hand
        if (card.is_empty())
          return Action::none;

        if (card.istrump())
          return Action::none;

        return Action::take_card;

      case Status::asking:
        return Action::accept_cards;

      case Status::shifting_back:
        // move a card in the hand
        if (card.is_empty())
          return Action::none;

        return Action::take_card;

      case Status::getting_back:
        return Action::get_cards_back;

      case Status::accepted:
      case Status::denied_by_all:
      case Status::finished:
        break;
      } // switch(this->status)
    } // if (cardno)
  } // test whether the mouse is over a card in the middle

  { // test whether the player can move a card from the hand into the middle
    if ((this->status == Status::shifting)
        || (this->status == Status::shifting_back))
      if (!(this->middle_full())) {
        auto const cardno
          = this->hand().cardno_at_position(x, y);
        if (cardno)
          return Action::put_card;
      } // if (middle has a free place)

    // look, whether there is space
  } // test whether the player can move a card from the hand

  return Action::none;
} // Poverty::Action Poverty::possible_action(int x, int y) const

/** moves the card at 'pos' in the middle
 **
 ** @param    cardno   number of cards to shift
 **/
void
Poverty::add_card_to_shift(unsigned const cardno)
{
  Player& player = const_cast<Player&>(*this->player);
  auto hand = player.hand().sorted();

  // search the first free card in the middle
  auto c = find(this->cards, Card());

  if (c == this->cards.end())
    // no free card found - ignore the taking of the card
    return ;

  DEBUG_ASSERTION((hand.played(cardno) == false),
                  "Poverty::add_card_to_shift(cardno):\n"
                  "  card number '" << cardno << "' is already played:\n"
                  "Hand:\n"
                  << hand);

  // move the card in the middle
  *c = hand.card_all(cardno);
  hand.playcard(hand.pos_all_to_pos(cardno));

#ifdef WORKAROUND
  { // just testing
    unsigned selected_cards = 0;
    for (auto const& c : this->cards)
      if (!c.is_empty())
        selected_cards += 1;

    DEBUG_ASSERTION((hand.cardsnumber() + selected_cards
                     == hand.cardsnumber_all()),
                    "Poverty::add_card_to_shift(cardno = " << cardno
                    << ")\n"
                    "  'hand.cardsnumber() + this->cards.size()' "
                    " = " << hand.cardsnumber() + this->cards.size()
                    << " != " << hand.cardsnumber_all()
                    << " = hand.cardsnumber_all()\n"
                    << "  shifted cards: " << this->cards << '\n'
                    << " Hand: " << hand);
  }
#endif // #ifdef WORKAROUND
} // void Poverty::add_card_to_shift(unsigned cardno)

/** -> result
 **
 ** @param    x   x position
 ** @param    y   y position
 **
 ** @return   the number of the card at the position
 **/
optional<unsigned>
Poverty::cardno_at_position(int x, int y) const
{
  this->geometry_cards().retransform(x, y);
  y += this->ui->cards->height();
  auto const positions = this->cards_pos();
  for (int i = this->cards.size() - 1; i >= 0; --i) {
    auto const& pos = positions[i];
    if (   (x >= pos.get_x())
        && (x < (pos.get_x()
                 + this->ui->cards->card(this->cards[i]).get_width()))
        && (y >= pos.get_y())
        && (y < (pos.get_y()
                 + this->ui->cards->card(this->cards[i]).get_height()))

        // ToDo: check for transparency
#ifdef POSTPONED
        && !(this->ui->cards->card(cards_drawn[i])
             .is_transparent(unsigned(x - pos.get_x()),
                             unsigned(y - pos.get_y())))
#endif
       ) {
      return i;
    }
  } // for (i)

  return {};
} // optional<unsigned> Poverty::cardno_at_position(int x, int y) const

/** @return   whether the cards are drawn
 **/
bool
Poverty::is_drawn() const
{
  if (   (::game_status != GameStatus::game_poverty_shift)
      && (::game_status != GameStatus::game_redistribute) )
    return false;

  if (!this->player)
    return false;

  if (   (this->status == Status::invalid)
      || (this->status == Status::accepted)
      || (this->status == Status::finished))
    return false;

  return true;
} // bool Poverty::is_drawn() const

/** write the status name into the stream
 **
 ** @param    ostr     output stream
 ** @param    status   status to write
 **
 ** @return   output stream
 **/
ostream&
operator<<(ostream& ostr, Poverty::Status const status)
{
  switch (status) {
  case Poverty::Status::invalid:
    return (ostr << "invalid");
  case Poverty::Status::shifting:
    return (ostr << "shifting");
  case Poverty::Status::asking:
    return (ostr << "asking");
  case Poverty::Status::shifting_back:
    return (ostr << "shifting back");
  case Poverty::Status::getting_back:
    return (ostr << "getting back");
  case Poverty::Status::accepted:
    return (ostr << "accepted");
  case Poverty::Status::denied_by_all:
    return (ostr << "denied by all");
  case Poverty::Status::finished:
    return (ostr << "finished");
  } // switch (status)
  return ostr;
} // ostream& operator<<(ostream& ostr, Poverty::Status status);

/** write the action name into the stream
 **
 ** @param    ostr     output stream
 ** @param    action   action to write
 **
 ** @return   output stream
 **/
ostream&
operator<<(ostream& ostr, Poverty::Action const action)
{
  switch (action) {
  case Poverty::Action::none:
    return (ostr << "none");
  case Poverty::Action::shift_cards:
    return (ostr << "shift cards");
  case Poverty::Action::accept_cards:
    return (ostr << "accept cards");
  case Poverty::Action::take_card:
    return (ostr << "take cards");
  case Poverty::Action::put_card:
    return (ostr << "put card");
  case Poverty::Action::fill_up:
    return (ostr << "fill up");
  case Poverty::Action::return_cards:
    return (ostr << "return cards");
  case Poverty::Action::get_cards_back:
    return (ostr << "get cards back");
  } // switch (action)
  return ostr;
} // ostream& operator<<(ostream& ostr, Poverty::Action action)

} // namespace UI_GTKMM_NS

namespace Gdk {
std::ostream&
  operator<<(std::ostream& ostr, Rectangle const& rectangle)
  {
    ostr << rectangle.get_width() << 'x' << rectangle.get_height()
      << '+' << rectangle.get_x() << '+' << rectangle.get_y();
    return ostr;
  }
std::ostream&
  operator<<(std::ostream& ostr, Point const& point)
  {
    ostr << '+' << point.get_x() << '+' << point.get_y();
    return ostr;
  }
} // namespace Gdk

#endif // #ifdef USE_UI_GTKMM