ui/gtkmm/bug_report_replay.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 "bug_report_replay.h"
#include "gameplay_actions.h"

#include "ui.h"
#include "thrower.h"
#include "bug_report.h"
#include "main_window.h"
#include "cards.h"

#include "../../os/bug_report_replay.h"
#include "../../game/game.h"
#include "../../player/player.h"
#include "../../player/aiconfig.h"

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

#include "game_summary.h"
#include <gtkmm/notebook.h>
#include <gtkmm/label.h>
#include <gtkmm/textview.h>
#include <gtkmm/scrolledwindow.h>

namespace UI_GTKMM_NS {

/** Constructor
 **
 ** @param    parent   the parent widget
 **/
BugReportReplay::BugReportReplay(Base* const parent) :
  Base(parent),
  StickyDialog("FreeDoko – " + _("Window::Bug report replay"), false)
{
  this->ui->add_window(*this);

  this->actions       = Gtk::manage(new GameplayActions(this));
  this->human_actions = Gtk::manage(new GameplayActions(this));
  this->game_summary  = Gtk::manage(new GameSummary(this));

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

  this->ui->bug_report->set_dnd_destination(*this);

  Party::signal_open().connect_back([this](Party& party) {
                                    party.signal_get_settings().connect_back(*this, &BugReportReplay::update_info, this->disconnector_);
                                    },
                                    this->disconnector_);
  Game::signal_open().connect_back([this](Game& game) {
                                   this->update_info();
                                   game.signal_redistribute().connect_back(*this, &BugReportReplay::update_info, this->disconnector_);
                                   game.signal_gameplay_action().connect_back(*this, &BugReportReplay::gameplay_action, this->disconnector_);
                                   },
                                   this->disconnector_);
  OS_NS::BugReportReplay::signal_open().connect_back(*this,
                                                     &UI_GTKMM_NS::BugReportReplay::bug_report_replay_open,
                                                     this->disconnector_);
} // BugReportReplay::BugReportReplay(Base* parent)

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

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

  { // action area
    auto end_button
      = Gtk::manage(new Gtk::Button(_("Button::end bug report")));

    end_button->signal_clicked().connect(sigc::mem_fun(*this,
                                                       &BugReportReplay::end_bug_report));

    add_close_button(*this);
  } // action area

  { // informations
    this->version = Gtk::manage(new Gtk::Label(""));
    this->version->set_justify(Gtk::JUSTIFY_LEFT);
    this->compiled = Gtk::manage(new Gtk::Label(""));
    this->compiled->set_justify(Gtk::JUSTIFY_LEFT);
    this->system = Gtk::manage(new Gtk::Label(""));
    this->system->set_justify(Gtk::JUSTIFY_LEFT);
    this->time = Gtk::manage(new Gtk::Label(""));
    this->time->set_justify(Gtk::JUSTIFY_LEFT);
    this->language = Gtk::manage(new Gtk::Label(""));
    this->language->set_justify(Gtk::JUSTIFY_LEFT);
    this->trick = Gtk::manage(new Gtk::Label(""));
    this->trick->set_justify(Gtk::JUSTIFY_LEFT);
    this->reset_ais_button = Gtk::manage(new Gtk::Button(_("Button::reset ais")));
    this->reset_ais_button->set_image_from_icon_name("edit-clear-all");
    this->reset_ais_button->set_always_show_image();
    this->message = Gtk::manage(new Gtk::TextView());
    this->message->get_buffer()->set_text("");
    this->message->set_wrap_mode(Gtk::WRAP_WORD);
#ifdef RELEASE
    this->message->set_editable(false);
    this->message->set_cursor_visible(false);
#else
    // Note: the changes in the message box are not saved.
#endif

    this->seed = Gtk::manage(new Gtk::Label(""));
    this->seed->set_justify(Gtk::JUSTIFY_LEFT);

    this->startplayer = Gtk::manage(new Gtk::Label(""));
    this->startplayer->set_justify(Gtk::JUSTIFY_LEFT);

    this->soloplayer = Gtk::manage(new Gtk::Label(""));
    this->soloplayer->set_justify(Gtk::JUSTIFY_LEFT);

    // hide the 'player' column
    this->human_actions->get_column(1)->set_visible(false);
  } // informations
  { // vbox
    this->notebook = Gtk::manage(new Gtk::Notebook());
    { // general
      auto label = Gtk::manage(new Gtk::Label(_("BugReportReplay::Group::general")));

      auto general_box = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL, 1 EM));
      general_box->set_border_width(1 EM);

      { // game box
        auto game_box = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL, 1 EX));

        game_box->pack_start(*this->version, Gtk::PACK_EXPAND_WIDGET);
        game_box->pack_start(*this->system, Gtk::PACK_EXPAND_WIDGET);
        game_box->pack_start(*this->seed, Gtk::PACK_EXPAND_WIDGET);
        game_box->pack_start(*this->startplayer, Gtk::PACK_EXPAND_WIDGET);
        game_box->pack_start(*this->soloplayer, Gtk::PACK_EXPAND_WIDGET);
        game_box->pack_start(*this->trick, Gtk::PACK_EXPAND_WIDGET);
        this->reset_ais_button->set_halign(Gtk::ALIGN_CENTER);
        game_box->pack_start(*this->reset_ais_button, Gtk::PACK_EXPAND_WIDGET);

        general_box->pack_start(*game_box, false, true);
      } // game box
      { // message
        general_box->add(*this->message);
      } // message

      this->notebook->append_page(*general_box, *label);
    } // general
    { // actions
      auto label = Gtk::manage(new Gtk::Label(_("BugReportReplay::Group::actions")));

      auto vbox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL, 1 EX));

      auto scrolled_window = Gtk::manage(new Gtk::ScrolledWindow);
      scrolled_window->set_policy(Gtk::POLICY_AUTOMATIC,
                                  Gtk::POLICY_AUTOMATIC);

      this->actions->get_selection()->set_mode(Gtk::SELECTION_SINGLE);
      scrolled_window->add(*this->actions);

      vbox->pack_start(*scrolled_window, Gtk::PACK_EXPAND_WIDGET);

      this->auto_actions_button
        = Gtk::manage(new Gtk::Button(_("Button::auto actions")));
      vbox->pack_end(*this->auto_actions_button, Gtk::PACK_SHRINK);

      this->notebook->append_page(*vbox, *label);
    } // actions
    { // human actions
      auto label = Gtk::manage(new Gtk::Label(_("BugReportReplay::Group::human actions")));
      auto scrolled_window = Gtk::manage(new Gtk::ScrolledWindow);
      scrolled_window->set_policy(Gtk::POLICY_AUTOMATIC,
                                  Gtk::POLICY_AUTOMATIC);

      scrolled_window->add(*this->human_actions);

      this->notebook->append_page(*scrolled_window, *label);
    } // human actions
    { // game summary
      auto label = Gtk::manage(new Gtk::Label(_("BugReportReplay::Group::game summary")));

      this->notebook->append_page(*this->game_summary, *label);
    } // game summary

    this->get_content_area()->pack_start(*this->notebook, true, true);
  } // vbox

  { // signals
    reset_ais_button->signal_clicked().connect(sigc::mem_fun(*this, &BugReportReplay::reset_ais));
    this->actions->get_selection()->signal_changed().connect(sigc::mem_fun(*this, &BugReportReplay::update_auto_actions_button));
    this->auto_actions_button->signal_clicked().connect(sigc::mem_fun(*this, &BugReportReplay::set_auto_actions));
    this->update_auto_actions_button();
  } // signals

  this->show_all_children();


  {
    Gdk::Geometry geometry;
    geometry.min_width = 3 * this->ui->cards->height();
    geometry.min_height = 4 * this->ui->cards->height();

    this->set_geometry_hints(*this, geometry, Gdk::HINT_MIN_SIZE);
  }
} // void BugReportReplay::init()

/** a bug report replay is opened
 **
 ** @param    bug_report_replay   the bug report replay that is opened
 **/
void
BugReportReplay::bug_report_replay_open(OS_NS::BugReportReplay&
                                        bug_report_replay)
{
  DEBUG_ASSERTION((&bug_report_replay == ::bug_report_replay.get()),
                  "BugReportReplay::bug_report_replay_open(bug_report_replay)\n"
                  "  the bug report replay "
                  " = " << &bug_report_replay
                  << " != " << ::bug_report_replay.get()
                  << " = global one");
  this->bug_report_replay_ = &bug_report_replay;
  this->bug_report_replay_->signal_close().connect_back(*this,
                                                        &UI_GTKMM_NS::BugReportReplay::bug_report_replay_close,
                                                        this->disconnector_);

  if (!this->get_realized())
    this->realize();

  this->actions->set_actions(bug_report_replay.actions());
  this->actions->set_discrepancies(bug_report_replay.actions_discrepancies());
  this->human_actions->set_actions(bug_report_replay.human_actions());
  this->human_actions->set_discrepancies(bug_report_replay.human_actions_discrepancies());
  if (bug_report_replay.game_summary()) {
    this->game_summary->set_game_summary(*bug_report_replay.game_summary());
    this->game_summary->show();
  } else {
    this->game_summary->hide();
  }
  // ToDo: hide the last page if there is no game summary in the bug report

  this->update_info();
  this->notebook->set_current_page(0);

  if (!(::fast_play & FastPlay::hide_bug_report_window)) {
    this->show();
  }
} // void BugReportReplay::bug_report_replay_open(OS_NS::BugReportReplay bug_report_replay)

/** the bug report replay is closed
 **/
void
BugReportReplay::bug_report_replay_close()
{
  this->actions->remove_actions();
  this->human_actions->remove_actions();
  if (   this->bug_report_replay_
      && ::bug_report_replay
      && this->bug_report_replay_ == ::bug_report_replay.get()) {
    // 'if' is workaround: first hide then show leaves the window hidden
    this->bug_report_replay_ = nullptr;
    this->hide();
  }
} // BugReportReplay::bug_report_replay_close()

/** there happened a gameplay action
 **
 ** @param    action   gameplay action
 **/
void
BugReportReplay::gameplay_action(GameplayAction const& action)
{
  if (!this->bug_report_replay_)
    return ;

  this->actions->set_current_action_no(this->bug_report_replay_->current_action_no());
  this->human_actions->set_current_action_no(this->bug_report_replay_->current_human_action_no());
  this->update_auto_actions_button();
} // void BugReportReplay::gameplay_action(GameplayAction action)

/** updates the information
 **/
void
BugReportReplay::update_info()
{
  if (!this->bug_report_replay_)
    return ;

  DEBUG_ASSERTION((this->bug_report_replay_ == ::bug_report_replay.get()),
                  "BugReportReplay::update_info():\n"
                  "  this->bug_report_replay_ != ::bug_report_replay:\n"
                  "  " << this->bug_report_replay_
                  << " != " << ::bug_report_replay.get());

  if (::game_status == GameStatus::programstart)
    return ;
#if 0
  if (!&this->party())
    return ;
#endif


#ifdef WORKAROUND
  // This function can be called before this party is set
  // (by ::bug_report_replay). So we take a party here that always exists.
  // An alternitive would be to check, whether this party is set, but
  // 'UI::party_' is private.
  Party const& party = *::party;
#else
  Party const& party = this->ui->party();
#endif

  this->version->set_label(_("Version: %s",
                             static_cast<string const>(this->bug_report_replay_->version())));
  this->compiled->set_label(_("Compiled: %s",
                              this->bug_report_replay_->compiled()));
  this->system->set_label(_("System: %s",
                            this->bug_report_replay_->system()));
  this->time->set_label(_("Time: %s",
                          this->bug_report_replay_->time()));
  this->language->set_label(_("Language: %s",
                              this->bug_report_replay_->language()));
  this->trick->set_label(_("Trick: %u",
                           this->bug_report_replay_->trickno()));

#ifdef WORKAROUND
  // message: change iso to utf8
  this->message->get_buffer()->set_text(UI_GTKMM::to_utf8(this->bug_report_replay_->message()));
#else
  this->message->get_buffer()->set_text(this->bug_report_replay_->message());
#endif


  this->seed->set_label(String::to_string(this->bug_report_replay_->seed()));

  this->startplayer->set_label(String::to_string(this->bug_report_replay_->startplayer_no()));
  this->seed->set_label(_("Seed: %u", this->bug_report_replay_->seed()));

  if (this->bug_report_replay_->startplayer_no() != UINT_MAX)
    this->startplayer->set_label(_("Startplayer: %u",
                                   this->bug_report_replay_->startplayer_no())
                                 + " (" + party.players()[this->bug_report_replay_->startplayer_no()].name() + ")");
  else
    this->startplayer->set_label(_("Startplayer: %u",
                                   this->bug_report_replay_->startplayer_no())
                                 + " (-)"
                                );

  if (this->bug_report_replay_->soloplayer_no() != UINT_MAX)
    this->soloplayer->set_label(_("Soloplayer: %u",
                                  this->bug_report_replay_->soloplayer_no())
                                + " (" + party.players()[this->bug_report_replay_->soloplayer_no()].name() + ")"
                               );
  else
    this->soloplayer->set_label(_("Soloplayer: -"));

  this->actions->update();
  this->human_actions->update();

  if (this->bug_report_replay_->game_summary())
    this->game_summary->update();

  this->update_actions_past();
} // void BugReportReplay::update_info()

/** update the showing of the actions already made
 **
 ** @todo      all
 **/
void
BugReportReplay::update_actions_past()
{
  if (!this->get_realized())
    return ;

#if 0
  for (auto& row : this->actions->get_model()->children()) {
    for (auto col : this->actions->get_columns()) {
      // ToDo
    } // for (col \in this->actsion->get_columns())
  } // for (row \in this->actions)
#endif
} // void BugReportReplay::update_actions_past()

/** update the auto actions button
 **/
void
BugReportReplay::update_auto_actions_button()
{
  if (!this->get_realized())
    return ;

  auto selection = this->actions->get_selection();

  if (selection->get_selected()) {
    auto row = *(selection->get_selected());

    unsigned const actionno = row[this->actions->model.no];

    if (actionno > this->bug_report_replay_->current_action_no()) {
      this->auto_actions_button->set_sensitive(true);
    } else {
      this->auto_actions_button->set_sensitive(false);
    }
  } else {	// if !(selection->get_selected())
    this->auto_actions_button->set_sensitive(false);
  }	// if !(selection->get_selected())
} // void BugReportReplay::update_auto_actions_button()

/** automatic execute till the selected action
 **/
void
BugReportReplay::set_auto_actions()
{
  auto selection = this->actions->get_selection();

  DEBUG_ASSERTION(selection->get_selected(),
                  "BugReportReplay::set_auto_actions()\n"
                  "  no action selected");
  auto row = *(selection->get_selected());

  unsigned const actionno = row[this->actions->model.no];

  this->bug_report_replay_->set_auto_action_end(actionno);
  if (   (::game_status == GameStatus::game_play)
      && (this->ui->game().players().current_player().type() == Player::Type::human) ) {
    auto& player = this->ui->game().players().current_player();
    player.hand().request_card(player.card_get());
    this->ui->thrower(player.hand().requested_card(), __FILE__, __LINE__);
  } // if (human has to play a card)
} // void BugReportReplay::set_auto_actions()

/** end the bug report
 **/
void
BugReportReplay::end_bug_report()
{
  this->bug_report_replay_ = nullptr;
} // void BugReportReplay::end_bug_report()

/** reset the ais
 **/
void
BugReportReplay::reset_ais()
{
  int n = 0;
  for (auto& p : this->ui->party().players()) {
    if (dynamic_cast<Aiconfig*>(&p))
      dynamic_cast<Aiconfig&>(p).reset_to_hardcoded(n);
    n += 1;
  }
} // void BugReportReplay::reset_ais()

/** the name of 'player' has changed
 **
 ** @param    player   player whose name has changed
 **/
void
BugReportReplay::name_changed(Player const& player)
{
  if (!this->get_realized())
    return ;

  if (!this->bug_report_replay_)
    return ;

  if (::game_status & GameStatus::game) {
    if (this->bug_report_replay_->startplayer_no()
        == player.no())
      this->startplayer->set_label(_("Startplayer: %u",
                                     player.no())
                                   + " (" + player.name() + ")"
                                  );

    if (this->bug_report_replay_->soloplayer_no() == player.no())
      this->soloplayer->set_label(_("Soloplayer: %u",
                                    player.no())
                                  + " (" + player.name() + ")"
                                 );
  } // if (::game_status & GameStatus::game)

  this->actions->name_changed(player);
  this->human_actions->name_changed(player);
  this->game_summary->name_changed(player);
} // void BugReportReplay::name_changed(Player player)

} // namespace UI_GTKMM_NS

#endif // #ifdef USE_UI_GTKMM