sgcustomplot.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 SGCUSTOMPLOT_HPP
#define SGCUSTOMPLOT_HPP
 
#include "qcustomplot.h"
#include "sgpoint.hpp"
 
 
class SGCustomPlot : public QCustomPlot
{
  Q_OBJECT;
private:
  int state;
  bool isDetailPlot;
 
  QCPPlotTitle * title; 
  QCPRange nominalXRange; 
  QCPRange nominalYRange; 
  QCPRange realXRange; 
  QCPRange realYRange; 
 
  QString path; 
 
  QAction * inspectPointAction;
 
  QAction* simulateAction;
 
  QAction * savePNGAction;
  QAction * savePDFAction;
 
  QPoint lastContextPos;
 
public:
  SGCustomPlot(): SGCustomPlot(0,false) {}
 
 
  SGCustomPlot(int _state, bool _isDetailPlot);
 
  QCPPlotTitle * getTitle() {return title;}
 
  void adjustRanges();
 
  void setRanges(const QCPRange & xrange,
         const QCPRange & yrange);
 
  const QCPRange & getNominalXRange() const
  { return nominalXRange; }
 
  const QCPRange & getNominalYRange() const
  { return nominalYRange; }
  
  void equalizeAxesScales();
 
  void setState(int newState)
  { assert(state>=0); state = newState; }
  int getState() const
  { return state; }
 
protected:
 
  void resizeEvent(QResizeEvent * event)
  {
    adjustRanges();
    QCustomPlot::resizeEvent(event);
  }
 
private slots:
 
  void ShowContextMenu(const QPoint & pos)
  {
    lastContextPos = pos;
 
    QPoint globalPos = this->mapToGlobal(pos);
    
    QMenu contextMenu;
    contextMenu.addAction(inspectPointAction);
    contextMenu.addAction(simulateAction);
    contextMenu.addSeparator();
    contextMenu.addAction(savePDFAction);
    contextMenu.addAction(savePNGAction);
    
    contextMenu.exec(globalPos);
  }
 
  void pointInspected()
  {
    emit inspectPoint(SGPoint(xAxis->pixelToCoord(lastContextPos.x()),
                  yAxis->pixelToCoord(lastContextPos.y())),
              state,isDetailPlot);
  }
 
  void simulationRequested()
  {
    emit simulateEquilibrium(SGPoint(xAxis->pixelToCoord(lastContextPos.x()),
                  yAxis->pixelToCoord(lastContextPos.y())),
                 state,isDetailPlot); 
 
  }
 
  void savePDF()
  {
    QString newPath = QFileDialog::getSaveFileName(this, tr("Save PDF"),
                           path, tr("PDF files (*.pdf)"));
  
    if (newPath.isEmpty())
      return;
 
    QFileInfo fi(newPath);
    path = fi.canonicalPath();
 
    savePdf(newPath);
  }
 
  void savePNG()
  {
    QString newPath = QFileDialog::getSaveFileName(this, tr("Save PNG"),
                           path, tr("PNG files (*.png)"));
  
    if (newPath.isEmpty())
      return;
 
    QFileInfo fi(newPath);
    path = fi.canonicalPath();
 
    savePng(newPath);
  }
 
 
private:
 
  virtual int heightForWidth(int w) const {return w;}
 
 
  virtual bool hasHeightForWidth() const {return true;}
 
  virtual QSize minimumSizeHint() const { return QSize(100,100); } 
 
signals:
  void inspectPoint(SGPoint point, 
            int state, 
            bool isDetailPlot);
 
  void simulateEquilibrium(SGPoint point,
               int state,
               bool isDetailPlot); 
 
};
 
#endif