sgsolutionhandler.hpp

// This file is part of the SGSolve library for stochastic games
// Copyright (C) 2019 Benjamin A. Brooks
// 
// SGSolve 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 3 of the License, or
// (at your option) any later version.
// 
// SGSolve 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 should have received a copy of the GNU General Public License
// along with this program.  If not, see
// <http://www.gnu.org/licenses/>.
// 
// Benjamin A. Brooks
// ben@benjaminbrooks.net
// Chicago, IL
 
#ifndef SGSOLUTIONHANDLER_V2_HPP
#define SGSOLUTIONHANDLER_V2_HPP
 
#include "sgplotsettings.hpp"
#include "sgsolution_maxminmax.hpp"
#include "sgcustomplot.hpp"
#include "sgsimulationhandler.hpp"
#include "sgplotcontroller.hpp"
#include "sgstatecombomodel.hpp"
#include "sgactioncombomodel.hpp"
 
 
class SGSolutionHandler : public QObject
{
  Q_OBJECT
 
private:
 
  SGSolution_MaxMinMax soln;
  SGPlotController * controller;
 
  QWidget * parent;
 
  double payoffBound;
 
  bool solnLoaded;
 
  // Plots
  SGCustomPlot * detailPlot;
 
  vector<SGCustomPlot *> statePlots;
 
  SGPlotSettings plotSettings;
 
  QVBoxLayout * layout;
  
  QGridLayout * statePlotsLayout;
 
  QAction * detailedTitlesAction;
 
  QAction* equalizeAxesAction;
 
  SGSimulationHandler * simHandler;
 
  QPen defaultGridLinePen;
 
  QPen defaultZeroLinePen;
 
  // Methods
  void plotSolution();
  void plotSolution(SGCustomPlot * plot, int state,
            bool addSquares);
  void configureGridLines(SGCustomPlot * plot);
  QString generatePlotTitle(int state, int action,bool addIterRev);
  QCPRange getBounds(const QVector<double> & x) const;
  void addPoint(const SGPoint & point,QCustomPlot* plot,
        const QCPScatterStyle & style);
  QCPCurve * vectorToQCPCurve(SGCustomPlot * plot,
                  const SGPoint & point,
                  const SGPoint & dir);
  QCPItemLine * sgToQCPItemLine(SGCustomPlot * plot,
                const SGPoint & point,
                const SGPoint & dir);
public:
 
  SGSolutionHandler(QWidget * parent = 0);
 
  void setSolution(const SGSolution_MaxMinMax & newSoln);
  const SGSolution_MaxMinMax & getSolution() const
  {return soln;}
 
  QVBoxLayout * getLayout() const
  { return layout; }
  
  QAction * getDetailedTitlesAction() const
  { return detailedTitlesAction; }
 
  SGPlotSettings * getPlotSettingsPtr()
  { return & plotSettings; }
  
  QAction * getEqualizeAxesAction() const
  { return equalizeAxesAction; }
 
  void moveBackwards() { controller->moveBackwards(); }
  void moveForwards() { controller->moveForwards(); }
 
  void prevAction() { emit prevActionSignal(); }
  void nextAction() { emit nextActionSignal(); }
 
signals:
  void nextActionSignal();
  void prevActionSignal();
             
public slots:
  void inspectPoint(SGPoint point,
            int state, bool isDetailPlot);
  
  void simulateEquilibrium(SGPoint point,
               int state, bool isDetailPlot);
  void replotSlot() { plotSolution(); }
 
};
 
#endif