canvas.h

Go to the documentation of this file.

/*
  @copyright Steve Keen 2017
  @author Russell Standish
  This file is part of Minsky.

  Minsky 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 3 of the License, or
  (at your option) any later version.

  Minsky 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 Minsky.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef CANVAS_H
#define CANVAS_H

#include "group.h"
#include "godleyIcon.h"
#include "operation.h"
#include "plotOptions.h"
#include "plotWidget.h"
#include "selection.h"
#include "switchIcon.h"
#include "wire.h"
#include "ravelWrap.h"
#include "lasso.h"
#include "lock.h"
#include "sheet.h"
#include "renderNativeWindow.h"

#include <chrono>

namespace minsky
{
  using namespace classdesc;
  template <class T>
  struct NoAssign: public T
  {
    // disable assignment for objects wrapped in this class, but allow
    // assignment otherwise
    NoAssign& operator=(const NoAssign&) {return *this;}
    template <class U>
    NoAssign& operator=(const U& x) {T::operator=(x); return *this;}
  };
  
  class Canvas: public RenderNativeWindow
  {
    CLASSDESC_ACCESS(Canvas);
    void copyVars(const std::vector<VariablePtr>&);
    void reportDrawTime(double) override;
    void mouseDownCommon(float x, float y);
    bool redraw(int x0, int y0, int width, int height) override;
    void mouseMoveOnItem(float x, float y);

    bool m_redrawRequested=false;
    
    PlotOptions<> defaultPlotOptions;
    
  public:
    typedef std::chrono::time_point<std::chrono::high_resolution_clock> Timestamp;
    struct Model: public GroupPtr
    {
      Exclude<Timestamp> timestamp{Timestamp::clock::now()};
      void updateTimestamp() {timestamp=Timestamp::clock::now();}
      GroupPtr parent; // stash a ref to this groups parent for later restore
      float px=0,py=0,pz=1;
      Model() {}
      Model(const GroupPtr& g) {operator=(g);}
      Model& operator=(const GroupPtr& model) {
        updateTimestamp();
        if (this->get())
          {
            // restore previous stuff
            (*this)->group=parent;
            (*this)->m_x=px;
            (*this)->m_y=py;
            (*this)->relZoom=pz;
          }
        parent=model->group.lock();
        model->group.reset();
        px=model->m_x;
        py=model->m_y;
        pz=model->relZoom;
        model->group.reset(); // disassociate model from it's parent
        GroupPtr::operator=(model);
        return *this;
      }
      void zoom(double x, double y, double z) {
        if (fabs(x-(*this)->x())>1e-5 || fabs(y-(*this)->y())>1e-5)
          updateTimestamp(); // Why is this needed??
        (*this)->zoom(x,y,z);
      }
    };

    Model model;
    
    Selection selection;
    ItemPtr itemFocus; 
    WirePtr wireFocus; 
    int handleSelected; 
    Exclude<shared_ptr<Port>> fromPort; 
    double termX,termY; 
    float moveOffsX, moveOffsY;
    bool rotatingItem=false; 
    Exclude<Point> rotateOrigin; 
    void rotateItem(float x, float y) {
      rotateOrigin=Point(x,y);
      rotatingItem=true;
    }
    ClickType::Type clickType;
    ItemPtr itemIndicator;

    struct LassoMode {enum type  {none, lasso, itemResize};};
    LassoMode::type lassoMode=LassoMode::none;
    LassoBox lasso{0,0,0,0};

    bool redrawAll=true; 

    void moveTo(float x, float y) override {
      model->moveTo(x,y);
      requestRedraw();
    }

    std::vector<float> position() const override {
      return {model->x(), model->y()};
    }

    void zoom(double x, double y, double z) override {
      model->zoom(x,y,z);
      requestRedraw();
    }

    double zoomFactor() const override {return model->zoomFactor();}
    
    Canvas() {}
    Canvas(const GroupPtr& m): model(m) {}

    ecolab::cairo::SurfacePtr& surface() {return ecolab::CairoSurface::surface;}
    
    void mouseDown(float x, float y) override;
    void controlMouseDown(float x, float y) override;
    void mouseUp(float x, float y) override;
    void mouseMove(float x, float y) override;
    bool keyPress(const EventInterface::KeyPressArgs&) override;
    void displayDelayedTooltip(float x, float y);
    
    std::shared_ptr<Port> closestInPort(float x, float y) const;

    void select(const LassoBox&);

    int ravelsSelected() const; 
    
    void setItemFocus(const ItemPtr& x) {
      itemFocus=x;
      moveOffsX=moveOffsY=0;
      clickType=ClickType::onItem;
    }

    
    ItemPtr item;
    WirePtr wire;
    ItemPtr itemAt(float x, float y);
    bool getItemAt(float x, float y) override {return (item=itemAt(x,y)).get();}
    bool getWireAt(float x, float y) override;

    double defaultRotation=0;
    void addOperation(OperationType::Type op) {
      if (op==OperationType::numOps) return;
      setItemFocus(model->addItem(OperationBase::create(op)));
      itemFocus->rotation(defaultRotation);
    }
    void addVariable(const std::string& name, VariableType::Type type) {
      if (type==VariableType::undefined || type==VariableType::numVarTypes) return;
      setItemFocus(model->addItem(VariablePtr(type,name)));
      itemFocus->rotation(defaultRotation);
    }
    void addNote(const std::string& text) {
      setItemFocus(model->addItem(new Item));
      itemFocus->detailedText(text);
    }
    void addPlot() {
      setItemFocus(model->addItem(new PlotWidget));
      defaultPlotOptions.applyPlotOptions(*itemFocus->plotWidgetCast());
    }
    void addGodley() {setItemFocus(model->addItem(new GodleyIcon));}
    void addGroup() {setItemFocus(model->addItem(new Group));}
    void addSwitch() {setItemFocus(model->addItem(new SwitchIcon));}
    void addRavel() {setItemFocus(model->addItem(new Ravel));}
    void addLock() {setItemFocus(model->addItem(new Lock));}
    void addSheet() {setItemFocus(model->addItem(new Sheet));}
    
    void groupSelection();
    void lockRavelsInSelection();
    void unlockRavelsInSelection();
    
    void deleteItem();
    void deleteWire();
    void delHandle(float x, float y);    
    void removeItemFromItsGroup();

    void selectAllVariables();
    void renameAllInstances(const std::string& newName);
    void renameItem(const std::string& newName);

    void ungroupItem();
    
    void copyItem();

    void zoomToFit();
    
    void openGroupInCanvas(const ItemPtr& item);

    void copyAllFlowVars() {
      if (auto g=dynamic_cast<GodleyIcon*>(item.get()))
        copyVars(g->flowVars());
    }
    void copyAllStockVars(){
      if (auto g=dynamic_cast<GodleyIcon*>(item.get()))
        copyVars(g->stockVars());
    }

    void zoomToDisplay();

    bool selectVar(float x, float y);
    
    bool findVariableDefinition();

    //    void indicateItem() {itemIndicator=true;}

    bool redraw();
    LassoBox updateRegion{0,0,0,0};
    bool redrawUpdateRegion();

    struct ZoomCrop
    {
      double zoom=1, left=0, top=0, width=1000, height=1000;
    };

    void renderToPNGCropped(const std::string& filename, const ZoomCrop&);

    
    void recentre();

    bool redrawRequested() const {return m_redrawRequested;}
    void requestRedraw() {m_redrawRequested=true; if (surface().get()) surface()->requestRedraw();}
    bool hasScrollBars() const override {return true;}

    void setDefaultPlotOptions() {
      if (auto p=item->plotWidgetCast())
        defaultPlotOptions=*p;
    }

    void applyDefaultPlotOptions();

    void setItemFromItemFocus();
  };
}

namespace classdesc
{
  template <> struct is_smart_ptr<minsky::Canvas::Model>: public true_type {};
}

#include "canvas.cd"

#endif