sgplotcontroller.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 SGPLOTCONTROLLER_HPP
#define SGPLOTCONTROLLER_HPP
 
#include <QObject>
#include <QComboBox>
#include <QScrollBar>
#include <QDebug>
#include "sgsolution_maxminmax.hpp"
 
 
class SGPlotController : public QObject
{
  Q_OBJECT
 
public:
 
  enum PlotMode
    {
      Directions, 
      Generation 
    };
 
  enum SolutionMode
    {
      Progress, 
      Final 
    };
  
private:
  int state;
  int action;
  int actionIndex;
  int iteration;
 
  SGSolution_MaxMinMax * soln;
  
  PlotMode plotMode;
  
  SolutionMode mode;
  
  list<SGIteration_MaxMinMax>::const_iterator currentIter;
  list< SGStep >::const_iterator currentStep;
 
  bool solnLoaded;
 
  QComboBox * stateCombo;
  QComboBox * actionCombo;
  QComboBox * solutionModeCombo;
  QScrollBar * iterSlider;
  QScrollBar * stepSlider;
public:
  SGPlotController(QComboBox * _stateCombo,
           QComboBox *_actionCombo,
           QScrollBar * _iterSlider,
           QScrollBar * _stepSlider,
           QComboBox * _solutionModeCombo);
 
  int getState() const { return state; }
  int getAction() const { return action; }
  int getActionIndex() const { return actionIndex; }
  int getIteration() const { return iteration; }
  PlotMode getPlotMode() const { return plotMode; }
  SolutionMode getMode () const { return mode; }
  list<SGIteration_MaxMinMax>::const_iterator getCurrentIter() const { return currentIter; }
  int getCurrentIterIndex() const { return iteration; }
  const SGStep & getCurrentStep() const { return *currentStep; }
  int getStepSliderPosition() const { return stepSlider->sliderPosition(); }
  bool hasSolution() const { return solnLoaded; }
  const SGSolution_MaxMinMax * getSolution() const { return soln; }
  void setSolution(SGSolution_MaxMinMax * newSoln);
  bool setState(int newState);
  void setPlotMode(PlotMode newMode) { plotMode = newMode; }
  bool setActionIndex(int newActionIndex);
  bool setAction(int newAction);
  bool setIteration(int newIter);
  void moveForwards()
  {
    if (!solnLoaded)
      return;
      
    iterSlider->setSliderPosition(std::max(iterSlider->minimum(),
                       iterSlider->value()-1));
    // iterSliderUpdate(iterSlider->value());
  }
  void moveBackwards()
  {
    if (!solnLoaded)
      return;
      
    iterSlider->setSliderPosition(std::min(iterSlider->maximum(),
                       iterSlider->value()+1));
    // iterSliderUpdate(iterSlider->value());
  }
  void setCurrentDirection(SGPoint point, int state);
 
  void synchronizeSliders();
 
  void synchronizeIterSlider();
  void synchronizeStepSlider();
 
signals:
  void solutionChanged();
  void actionChanged();
  void stateChanged();
  void iterationChanged();
 
    
public slots:
  void iterSliderUpdate(int value);
  void prevAction();
  void nextAction();
  void changeAction(int newAction);
 
  void changeMode(int newMode);
 
  // //! Slot used to set up the sliders when changing between Progress
  // //! and Final modes.
  // void setSliderRanges(int start, int end);
  
 
 
}; // SGPlotController
 
 
 
#endif