ui/gtkmm/table.draw.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 "table.h"
#include "poverty.h"
#include "party_points.h"
#include "party_finished.h"
#include "last_trick.h"
#include "cards_distribution.h"
#include "trick.h"
#include "hand.h"
#include "trickpile.h"
#include "icongroup.h"
#include "name.h"
#include "reservation.h"

#include "ui.h"
#include "cards.h"
#include "gameinfo_dialog.h"
#include "full_trick.h"
#include "game_finished.h"

#include "../../party/party.h"
#include "../../party/rule.h"
#include "../../game/game.h"
#include "../../player/player.h"
#include "../../card/trick.h"
#include "../../misc/preferences.h"
#include "../../utils/string.h"

#include <gtkmm/drawingarea.h>
#include <gdkmm/general.h>
#include <cmath>
using std::pow;

namespace UI_GTKMM_NS {

/** updates the table from the buffer (the surface)
 **/
void
Table::update_from_buffer()
{
  auto cr = this->get_window()->create_cairo_context();
  cr->set_source(this->surface_, 0, 0);
  cr->paint();
} // void Table::update_from_buffer()

/** draw all
 **/
void
Table::draw_all()
{
  if (!this->get_realized())
    return ;

  auto cr = this->create_cairo_context();

  cr->push_group();


  this->draw_background(cr);

  if (::game_status & GameStatus::game) {
    for (auto& p : this->part_) {
      auto const outline = p->outline();
      cr->set_source(p->surface(), outline.x(), outline.y());
      cr->paint();
    }
  } else { // if (::game_status)
    this->draw_logo(cr);
  } // if (::game_status)
  cr->pop_group_to_source();
  cr->paint();

  this->update_from_buffer();

#ifdef WINDOWS
#ifdef WORKAROUND
  // Sometimes the window is not updated
  this->queue_draw();
#endif
#endif

  this->mouse_cursor_update();
} // void Table::draw_all()

/** Force the redrawing of all elements
 **/
void
Table::force_redraw_all()
{
  for (auto p : this->part_)
    p->force_redraw();
  this->draw_all();
} // void Table::force_redraw_all()

/** draw the background
 ** According to the size of the background as pattern or as image
 **/
void
Table::draw_background(Cairo::RefPtr<::Cairo::Context> cr)
{
  cr->save();
  if (   this->width() < 2 * this->background_pixbuf->get_width()
      && this->height() < 2  * this->background_pixbuf->get_height()) {
    cr->scale(static_cast<double>(this->width()) / this->background_pixbuf->get_width(),
              static_cast<double>(this->height()) / this->background_pixbuf->get_height());
    Gdk::Cairo::set_source_pixbuf(cr, this->background_pixbuf, 0, 0);
    cr->paint();
  } else {
    cr->set_source(this->background_pattern);
    cr->rectangle(0, 0, this->width(), this->height());
    cr->fill();
  }
  cr->restore();
}

/** draw the logo
 **
 ** @param    cr     drawing context
 **
 ** @bug   clip mask does not work (GTK-bug?)
 **/
void
Table::draw_logo(Cairo::RefPtr<::Cairo::Context> cr)
{
  if (!this->get_realized())
    return ;
  if (!this->ui->logo)
    return ;

  cr->push_group();
  draw_pixbuf(cr, this->ui->logo,
              (this->width() - this->ui->logo->get_width()) / 2,
              (this->height() - this->ui->logo->get_height()) / 2);
  { // draw a border with the cards
    auto const card_width = this->ui->cards->width();
    auto const card_height = this->ui->cards->height();

    auto surface_top = Cairo::ImageSurface::create(Cairo::FORMAT_ARGB32,
                                                   this->width(),
                                                   this->height());
    auto surface_right = Cairo::ImageSurface::create(Cairo::FORMAT_ARGB32,
                                                     this->width(),
                                                     this->height());
    auto surface_bottom = Cairo::ImageSurface::create(Cairo::FORMAT_ARGB32,
                                                      this->width(),
                                                      this->height());
    auto surface_left = Cairo::ImageSurface::create(Cairo::FORMAT_ARGB32,
                                                    this->width(),
                                                    this->height());

    { // top
      auto cr = Cairo::Context::create(surface_top);
      vector<Card> const border_card =  {
        {Card::heart_ten},
        {Card::club_queen},
        {Card::spade_queen},
        {Card::heart_queen},
        {Card::diamond_queen},
        {Card::club_jack},
        {Card::spade_jack}};

      auto const border_top_x
        = (card_width
           + ( (static_cast<int>(border_card.size()) * card_height
                + card_width >= this->width())
              ? 0
              : ((this->width() - (border_card.size() * card_height
                                   + card_width)
                 ) / border_card.size())
             )
          );

      for (size_t n = 0; n < border_card.size(); n++) {
        draw_pixbuf(cr,
                    this->ui->cards->card(border_card[n], Rotation::left),
                    border_top_x +
                    n * (this->width() - 2 * border_top_x
                         - card_height)
                    / (border_card.size() - 1),
                    card_width / 2);
      } // for (n < border_card.size())
    } // top
    { // right
      auto cr = Cairo::Context::create(surface_right);
      vector<Card> const border_card = {
        {Card::heart_jack},
        {Card::diamond_jack},
        {Card::diamond_ace},
        {Card::diamond_ten},
        {Card::diamond_king}};

      auto const border_right_y
        = (card_width
           + ( (static_cast<int>(border_card.size()) * card_height
                + card_width >= this->height())
              ? 0
              : ((this->height() - (border_card.size() * card_height
                                    + card_width)
                 ) / border_card.size())
             )
          );

      for (size_t n = 0; n < border_card.size(); n++) {
        draw_pixbuf(cr,
                    this->ui->cards->card(border_card[n], Rotation::up),
                    this->width() - 3 * card_width / 2,
                    border_right_y +
                    n * (this->height() - 2 * border_right_y
                         - card_height)
                    / (border_card.size() - 1)
                   );
        cr->paint();
      }
    } // right
    { // bottom
      auto cr = Cairo::Context::create(surface_bottom);
      vector<Card> const border_card = {
        {Card::diamond_nine},
        {Card::club_ace},
        {Card::club_ten},
        {Card::club_king},
        {Card::club_nine},
        {Card::heart_ace},
        {Card::heart_king}};

      auto const border_bottom_x
        = (card_width
           + ( (static_cast<int>(border_card.size()) * card_height
                + card_width >= this->width())
              ? 0
              : ((this->width() - (border_card.size() * card_height
                                   + card_width)
                 ) / border_card.size())
             )
          );

      for (size_t n = 0; n < border_card.size(); n++) {
        draw_pixbuf(cr,
                    this->ui->cards->card(border_card[n], Rotation::right),
                    border_bottom_x +
                    (border_card.size() - 1 - n)
                    * (this->width() - 2 * border_bottom_x
                       - card_height)
                    / (border_card.size() - 1),
                    this->height()
                    - 3 * card_width / 2
                   );
      }
    } // bottom
    int border_left_y = 0;
    { // left
      auto cr = Cairo::Context::create(surface_left);
      vector<Card> const border_card = {
        {Card::heart_nine},
        {Card::spade_ace},
        {Card::spade_ten},
        {Card::spade_king},
        {Card::spade_nine}};

      border_left_y
        = (card_width
           + ( (static_cast<int>(border_card.size()) * card_height
                + card_width >= this->height())
              ? 0
              : ((this->height() - (border_card.size() * card_height
                                    + card_width)
                 ) / border_card.size())
             )
          );

      for (size_t n = 0; n < border_card.size(); n++) {
        int const pos_x = card_width / 2;
        int const pos_y = (border_left_y +
                           (border_card.size() - 1 - n)
                           * (this->height() - 2 * border_left_y
                              - card_height)
                           / (border_card.size() - 1));

        draw_pixbuf(cr,
                    this->ui->cards->card(border_card[n], Rotation::down),
                    pos_x, pos_y);
      }
    } // left

    cr->set_source(surface_top, 0, 0);
    cr->paint();
    cr->set_source(surface_right, 0, 0);
    cr->paint();
    cr->set_source(surface_bottom, 0, 0);
    cr->paint();
    cr->set_source(surface_left, 0, 0);
    cr->paint();
    {
      cr->save();
      cr->rectangle(0, 0,
                    border_left_y + max(this->ui->cards->width(), this->ui->cards->height()),
                    this->height());
      cr->clip();
      cr->set_source(surface_top, 0, 0);
      cr->paint();
      cr->restore();
    }
  } // draw a border with the cards
  cr->pop_group_to_source();
  cr->paint();

  this->update_from_buffer();
} // void Table::draw_logo(Cairo::RefPtr<::Cairo::Context> cr)

/** update the cards distribution
 **/
void
Table::update_cards_distribution()
{
  this->cards_distribution_->force_redraw();
}

/** update all hands
 **/
void
Table::update_hands()
{
  for (auto& h : this->hand_)
    h.second->force_redraw();
}

/** update all cards
 **/
void
Table::update_cards()
{
  for (auto& h : this->hand_)
    h.second->force_redraw();
  for (auto& t : this->trickpile_)
    t.second->force_redraw();
  this->trick_->force_redraw();
  this->poverty_->force_redraw();
}

/** update all cards back
 **/
void
Table::update_cards_back()
{
  for (auto& h : this->hand_)
    h.second->force_redraw();
  for (auto& t : this->trickpile_)
    t.second->force_redraw();
} // void Table::update_cards_back()

/** update all icons
 **/
void
Table::update_icons()
{
  for (auto& i : this->icongroup_)
    i.second->force_redraw();
} // void Table::update_icons()

/** loads the background
 **/
void
Table::load_background()
{
  try {
    auto back_new = Gdk::Pixbuf::create_from_file(::preferences.path(::Preferences::Type::background));
    if (!back_new)
      throw Glib::FileError(Glib::FileError::FAILED,
                            "error loading pixmap from '"
                            + ::preferences.path(::Preferences::Type::background) + "'");
    this->background_pixbuf = back_new;

    auto surface = Cairo::ImageSurface::create(Cairo::FORMAT_RGB24,
                                               back_new->get_width(),
                                               back_new->get_height());
    auto cr = Cairo::Context::create(surface);
    Gdk::Cairo::set_source_pixbuf(cr, back_new, 0, 0);
    cr->paint();
    this->background_pattern = Cairo::SurfacePattern::create(surface);
    this->background_pattern->set_extend(Cairo::EXTEND_REPEAT);

    this->draw_all();
  } catch (Glib::FileError const& file_error) {
    this->ui->error(_("Error::loading the background %s",
                      ::preferences.value(::Preferences::Type::background)
                     ));
  } // try
} // void Table::load_background()

/** update the cards
 **/
void
Table::cards_update()
{ this->force_redraw_all(); }

/** update the cards back
 **/
void
Table::cards_back_update()
{ this->force_redraw_all(); }

/** the name of 'player' has changed
 **
 ** @param    player   the player with the changed name
 **/
void
Table::name_changed(Player const& player)
{
  if (this->party_points_)
    this->party_points_->name_changed(player);

  if (this->party_finished_)
    this->party_finished_->name_changed(player);

  if (::game_status < GameStatus::game_init)
    return ;
  this->force_redraw_all();
  this->force_redraw_all(); // two times, for widescreen layout to get all positions right

  this->gameinfo_->name_changed(player);

  if (this->last_trick_)
    this->last_trick_->name_changed(player);

  if (this->game_finished_)
    this->game_finished_->name_changed(player);

  if (!this->name_.empty())
    this->name(player).force_redraw();
} // void Table::name_changed(Player const& player)

/** updates the font
 **
 ** @param    fontname   the name of the new font
 ** @param    type        the type of the font
 **/
void
Table::new_font(string const& fontname, ::Preferences::Type::String const type)
{
  switch (type) {
  case ::Preferences::Type::name_font:
    for (auto& n : this->name_)
      n.second->force_redraw();
    this->draw_all();
    break;

  case ::Preferences::Type::trickpile_points_font:
    for (auto& t : this->trickpile_)
      t.second->force_redraw();
    this->draw_all();
    break;
  default:
    break;
  } // switch (type)
} // void Table::new_font(string fontname, ::Preferences::Type::String type)

/** updates the  color
 **
 ** @param    colorname   the name of the new color
 ** @param    type      the type of the font
 **
 ** @todo   using 'set_foreground'
 **/
void
Table::new_color(string const& colorname, ::Preferences::Type::String const type)
{
  auto cr = this->create_cairo_context();
  cr->push_group();
  switch (type) {
  case ::Preferences::Type::name_font_color:
  case ::Preferences::Type::name_active_font_color:
  case ::Preferences::Type::name_reservation_font_color: {

    for (auto& n : this->name_)
      n.second->force_redraw();
    this->draw_all();

  } break;

  case ::Preferences::Type::trickpile_points_font_color:
    for (auto& t : this->trickpile_)
      t.second->force_redraw();
    this->draw_all();
    break;

  case ::Preferences::Type::poverty_shift_arrow_color:
    if ((::game_status == GameStatus::game_poverty_shift)
        && this->poverty_)
      this->poverty().force_redraw();
    this->draw_all();

    break;

  default:
    break;
  } // switch(type)
} // void Table::new_color(string colorname, ::Preferences::Type::String type)

/** the setting has changed
 **
 ** @param    type   the type that has changed
 **/
void
Table::preference_update(int const type)
{
  switch(type) {
  case ::Preferences::Type::show_all_hands:
    this->force_redraw_all();
    break;
  case ::Preferences::Type::emphasize_valid_cards:
    if ( (::game_status == GameStatus::game_play)
        && (this->ui->game().players().current_player().type() == Player::Type::human) ) {
      this->force_redraw_all();
    }
    break ;
  case ::Preferences::Type::automatic_card_suggestion:
    if (::preferences(::Preferences::Type::automatic_card_suggestion))
      if (   (::game_status == GameStatus::game_play)
          && !this->ui->game().tricks().current().isfull()
          && (this->ui->game().players().current_player().type() == Player::Type::human))
        this->show_card_suggestion(false);
    break;
  case ::Preferences::Type::show_trickpiles_points:
    for (auto& t : this->trickpile_)
      t.second->force_redraw();
    this->draw_all();
    break;
  case ::Preferences::Type::announce_swines_automatically:
    if (::game_status == GameStatus::game_reservation) {
      for (auto& r : this->reservation_)
        r.second->sensitivity_update();
    } // if (::game_status == GameStatus::game_reservation)
  case ::Preferences::Type::background:
    this->load_background();
    break;
  case ::Preferences::Type::rotate_trick_cards:
    this->trick_->force_redraw();
    this->draw_all();
    break;
  case ::Preferences::Type::name_font:
  case ::Preferences::Type::trickpile_points_font:
    this->new_font(::preferences(static_cast<::Preferences::Type::String const>(type)),
                   static_cast<::Preferences::Type::String const>(type));
    break;
  case ::Preferences::Type::name_font_color:
  case ::Preferences::Type::name_active_font_color:
  case ::Preferences::Type::trickpile_points_font_color:
  case ::Preferences::Type::poverty_shift_arrow_color:
    this->new_color(::preferences(static_cast<::Preferences::Type::String const>(type)),
                    static_cast<::Preferences::Type::String const>(type));
    break;
  case ::Preferences::Type::own_hand_on_table_bottom:
  case ::Preferences::Type::table_rotation:
    this->draw_all();
    break;

  default:
    break;
  } // switch(type)
} // void Table::preference_update(int type)

/** update the mouse cursor
 **/
void
Table::mouse_cursor_update()
{
  if (!this->get_realized())
    return ;
  int x, y;
  this->get_pointer(x, y);

  CursorType new_cursor_type = CursorType::standard;
  if (this->ui->busy())
    new_cursor_type = CursorType::busy;

  switch (::game_status) {
  case GameStatus::game_poverty_shift:
    DEBUG_ASSERTION(this->poverty_,
                    "Table::mouse_cursor_update():\n"
                    "  'this->poverty_' == nullptr");
    switch (this->poverty().possible_action(x, y)) {
    case Poverty::Action::none:
      break;
    case Poverty::Action::shift_cards:
      new_cursor_type = CursorType::poverty_shift;
      break;
    case Poverty::Action::accept_cards:
      new_cursor_type = CursorType::poverty_accept;
      break;
    case Poverty::Action::take_card:
      new_cursor_type = CursorType::poverty_get_card;
      break;
    case Poverty::Action::put_card:
      new_cursor_type = CursorType::poverty_put_card;
      break;
    case Poverty::Action::fill_up:
      new_cursor_type = CursorType::poverty_fill_up;
      break;
    case Poverty::Action::return_cards:
      new_cursor_type = CursorType::poverty_shift_back;
      break;
    case Poverty::Action::get_cards_back:
      new_cursor_type = CursorType::poverty_getting_back;
      break;

    } // switch (this->poverty().possible_action(x, y))
    break;

  case GameStatus::game_play: {
    // the human player has to play a card
    Player& player = this->ui->game().players().current_player();
    if (this->get_card()) {
      DEBUG_ASSERTION((player.type() == Player::Type::human),
                      "UI_GTKMM::Table::mouse_cursor_update():\n"
                      "  a card should be get, but the player '"
                      << player.no() << "' is not human but '"
                      << player.type() << "'");
      auto const card = this->hand(player).card_at_position(x, y);
      if (!card.is_empty()) {
        if (::preferences(::Preferences::Type::show_if_valid)) {
          if (player.game().tricks().current().isvalid(card, player.hand()))
            new_cursor_type = CursorType::card_valid;
          else
            new_cursor_type = CursorType::card_invalid;
        } else { // if !(show_if_valid)
          new_cursor_type = CursorType::play_card;
        } // if !(show_if_valid)

      } // if (card)
    } // if (player.type() == Player::Type::human)
    break;
  } // case GameStatus::game_play:
  default:
    if (   ::in_running_game()
        && this->ui->game().tricks().current().isfull()
        && this->full_trick_
        && this->trick().mouse_over_cards()) {
      new_cursor_type = CursorType::close_full_trick;
    } // if (::game_status == ...)
    break;
  } // switch(::game_type)

  if (::in_running_game()) {
    auto const& game = this->ui->game();
    for (auto const& p : game.players()) {
      if (this->trickpile(p).over_trick(x, y))
        new_cursor_type = CursorType::show_last_trick;
      if (p.type() == Player::Type::human) {
        if (this->icongroup(p).mouse_over_next_announcement())
          new_cursor_type = CursorType::next_announcement;
      } // if (p->type() == Player::Type::human)
    } // for (p : game.player)
  } // if (::game_status in game)


  if (this->in_game_review())
    new_cursor_type = CursorType::game_review;

  if (this->cursor_type != new_cursor_type) {
    if (   (this->cursor_type == CursorType::next_announcement)
        || (new_cursor_type == CursorType::next_announcement) ) {
      this->cursor_type = new_cursor_type;
      this->draw_all();
    }
    this->cursor_type = new_cursor_type;
    this->get_window()->set_cursor(Table::cursor(this->cursor_type));
  } // if (this->cursor_type != new_cursor_type)
} // void Table::mouse_cursor_update()

/** event: draw the table
 **
 ** @param    c   the graphic context
 **
 ** @return   true
 **/
bool
Table::on_draw(::Cairo::RefPtr<::Cairo::Context> const& c)
{
  c->set_source(this->surface_, 0, 0);
  c->paint();
  return true;
} // bool Table::on_draw(::Cairo::RefPtr<::Cairo::Context> c)

/** event: the size has changed
 **
 ** @param    event   the event
 **
 ** @return   true
 **/
bool
Table::on_configure_event(GdkEventConfigure* const event)
{
  if (   (this->get_width() != this->surface_->get_width())
      || (this->get_height() != this->surface_->get_height()) ) {
    this->surface_ = Cairo::ImageSurface::create(Cairo::FORMAT_ARGB32,
                                                 this->get_width(),
                                                 this->get_height());
    // update the layout
    if (this->width() / 3 < this->height() / 2)
      this->layout_ = Layout::standard;
    else
      this->layout_ = Layout::widescreen;

    this->force_redraw_all();
  }
  //this->update_from_buffer() wird von on_draw() aufgerufen

  return true;
} // bool Table::on_configure_event(GdkEventConfigure* event)

/** event: mouse motion
 **
 ** @param    event   the event
 **
 ** @return   whether there was a reaction
 **/
bool
Table::on_motion_notify_event(GdkEventMotion* const event)
{
  this->mouse_cursor_update();

  return false;
} // bool Table::on_motion_notify_event(GdkEventMotion* event)

/** -> result
 **
 ** @param    type   the cursor type
 **
 ** @return   the cursor for 'type'
 **/
Glib::RefPtr<Gdk::Cursor>
Table::cursor(CursorType const type)
{
  switch (type) {
  case CursorType::none:
    DEBUG_ASSERTION(false,
                    "Table::cursor(type):\n"
                    "  'type' == NONE");
    break;
  case CursorType::standard: {
    static auto const cursor = Gdk::Cursor::create(this->get_display(), "default");
    return cursor;
  }
    break;
  case CursorType::busy: {
#ifdef POSTPONED
    Glib::RefPtr<Gdk::Pixbuf> pixbuf = Gdk::Pixbuf::create_from_file("ui/gtkmm/cursor/busy.png");
    {
      GdkCursor* cursor = gdk_cursor_new_from_pixbuf(Gdk::Cursor(Gdk::X_CURSOR).get_display()->gobj(), pixbuf->gobj(), 0, 0);
      //Gdk::Cursor(Gdk::Pixbuf::create_from_file("ui/gtkmm/cursor/busy.png"),);
      return cursor;
    }
#endif
  }
    {
      static auto const cursor = Gdk::Cursor::create(Gdk::WATCH);
      return cursor;
    }
    //return Gdk::Cursor(Gdk::EXCHANGE);
    //return Gdk::Cursor(Gdk::CLOCK);
  case CursorType::poverty_shift: {
    static auto const cursor_left = Gdk::Cursor::create(Gdk::SB_LEFT_ARROW);
    static auto const cursor_right = Gdk::Cursor::create(Gdk::SB_RIGHT_ARROW);
    static auto const cursor_up = Gdk::Cursor::create(Gdk::SB_UP_ARROW);
    static auto const cursor_down = Gdk::Cursor::create(Gdk::SB_DOWN_ARROW);
    switch (this->position(this->ui->game().players().current_player())) {
    case Position::south:
      return cursor_left;
    case Position::north:
      return cursor_right;
    case Position::west:
      return cursor_up;
    case Position::east:
      return cursor_down;
    default:
      return cursor_left;
    }
  }
  case CursorType::poverty_shift_back: {
    static auto const cursor_left = Gdk::Cursor::create(Gdk::SB_LEFT_ARROW);
    static auto const cursor_right = Gdk::Cursor::create(Gdk::SB_RIGHT_ARROW);
    static auto const cursor_up = Gdk::Cursor::create(Gdk::SB_UP_ARROW);
    static auto const cursor_down = Gdk::Cursor::create(Gdk::SB_DOWN_ARROW);
    switch (this->position(this->ui->game().players().current_player())) {
    case Position::south:
      return cursor_right;
    case Position::north:
      return cursor_left;
    case Position::west:
      return cursor_down;
    case Position::east:
      return cursor_up;
    default:
      return cursor_right;
    }
  }
  case CursorType::poverty_get_card:
  case CursorType::poverty_put_card:
  case CursorType::poverty_fill_up: {
    static auto const cursor = Gdk::Cursor::create(Gdk::HAND1);
    return cursor;
  }
  case CursorType::poverty_accept:
  case CursorType::poverty_getting_back: {
    static auto const cursor = Gdk::Cursor::create(Gdk::HAND2);
    return cursor;
  }
  case CursorType::next_announcement: {
    static auto const cursor = Gdk::Cursor::create(Gdk::HAND2);
    return cursor;
  }
  case CursorType::play_card: {
    static auto const cursor = Gdk::Cursor::create(Gdk::HAND1);
    return cursor;
  }
  case CursorType::card_valid: {
    static auto const cursor = Gdk::Cursor::create(Gdk::HAND1);
    return cursor;
  }
  case CursorType::card_invalid: {
    static auto const cursor = Gdk::Cursor::create(Gdk::PIRATE);
    return cursor;
  }
  case CursorType::close_full_trick: {
    static auto const cursor = Gdk::Cursor::create(Gdk::HAND1);
    return cursor;
  }
  case CursorType::show_last_trick: {
    static auto const cursor = Gdk::Cursor::create(Gdk::HAND2);
    return cursor;
  }
  case CursorType::game_review: {
    static auto const cursor = Gdk::Cursor::create(Gdk::SB_H_DOUBLE_ARROW);
    return cursor;
  }
  } // switch (type)

  return {};
} // static Gdk::Cursor const& Table::cursor(CursorType type)

/** the progress has changed -- redraw the name of the active player
 **
 ** @param    progress   new progress
 **/
void
Table::progress_changed(double const progress)
{
  this->draw_all();
} // void Table::progress_changed(double progress)

/** the progress has finished -- redraw the name of the active player
 **/
void
Table::progress_finished()
{
  this->draw_all();
} // void Table::progress_finished()

/** draw a pixbuf
 **
 ** @param    cr       drawing context
 ** @param    pixbuf   pixbuf to draw
 ** @param    x        x position
 ** @param    y        y position
 **/
void
draw_pixbuf(Cairo::RefPtr<::Cairo::Context> cr,
            Glib::RefPtr<Gdk::Pixbuf> pixbuf,
            int const x, int const y)
{
  if (!pixbuf)
    return ;
  Gdk::Cairo::set_source_pixbuf(cr, pixbuf, x, y);
  cr->paint();
} // void draw_pixbuf(Cairo::RefPtr<::Cairo::Context> cr, Glib::RefPtr<Gdk::Pixbuf> pixbuf, int x, int y)

/** draw a pixbuf
 **
 ** @param    cr       drawing context
 ** @param    pixbuf   pixbuf to draw
 ** @param    pos      position
 **/
void
draw_pixbuf(Cairo::RefPtr<::Cairo::Context> cr,
            Glib::RefPtr<Gdk::Pixbuf> pixbuf,
            Gdk::Point const& pos)
{
  if (!pixbuf)
    return ;
  Gdk::Cairo::set_source_pixbuf(cr, pixbuf, pos.get_x(), pos.get_y());
  cr->paint();
} // void draw_pixbuf(Cairo::RefPtr<::Cairo::Context> cr, Glib::RefPtr<Gdk::Pixbuf> pixbuf, Gdk::Point pos)

} // namespace UI_GTKMM_NS

#endif // #ifdef USE_UI_GTKMM