minsky::PhillipsDiagram Class Reference

#include <phillipsDiagram.h>

Inheritance diagram for minsky::PhillipsDiagram:

Collaboration diagram for minsky::PhillipsDiagram:

Public Member Functions
void	requestRedraw ()
void	init () override
	populate phillips diagram from Godley tables in model More...
void	clear ()
void	mouseDown (float x, float y) override
void	mouseUp (float x, float y) override
void	mouseMove (float x, float y) override
void	moveTo (float x, float y) override
	move this so that (x,y) is centred More...
std::vector< float >	position () const override
	current centre coordinates More...
void	startRotatingItem (float x, float y)
bool	hasScrollBars () const override
	return whether this window has scrollbars (needed for MacOSX). More...
Public Member Functions inherited from minsky::RenderNativeWindow
const RenderFrameArgs &	frameArgs () const
	~RenderNativeWindow () override
void	renderFrame (const RenderFrameArgs &args)
void	destroyFrame ()
void	draw ()
void	requestRedraw ()
void	macOSXRedraw ()
RenderNativeWindow &	operator= (const RenderNativeWindow &x)
	RenderNativeWindow ()=default
	RenderNativeWindow (const RenderNativeWindow &)=default
Public Member Functions inherited from minsky::EventInterface
virtual void	controlMouseDown (float x, float y)
virtual void	zoom (double x, double y, double z)
virtual double	zoomFactor () const
virtual bool	keyPress (const KeyPressArgs &)
	handle key press over current itemFocus, More...
virtual bool	getItemAt (float x, float y)
	item or wire obtained by get*At() calls More...
virtual bool	getWireAt (float x, float y)
	item or wire obtained by get*At() calls More...

Public Attributes
std::map< std::string, PhillipsStock >	stocks
std::map< std::pair< std::string, std::string >, PhillipsFlow >	flows
Public Attributes inherited from minsky::EventInterface
ItemPtr	item
	item or wire obtained by get*At() calls More...
WirePtr	wire
	item or wire obtained by get*At() calls More...

Private Member Functions
bool	redraw (int, int, int width, int height) override
	CLASSDESC_ACCESS (PhillipsDiagram)

Private Attributes
PhillipsStock *	stockBeingMoved =nullptr
PhillipsStock *	stockBeingRotated =nullptr
Exclude< Point >	rotateOrigin
PhillipsFlow *	flowBeingEdited =nullptr
int	handleSelected =0
float	x =0
float	y =0
	position for panning More...

Additional Inherited Members
Static Public Member Functions inherited from minsky::RenderNativeWindow
static double	scaleFactor ()
Static Public Attributes inherited from minsky::RenderNativeWindow
static ecolab::cairo::Colour	backgroundColour {0.8,0.8,0.8,1}

Detailed Description

Definition at line 75 of file phillipsDiagram.h.

Member Function Documentation

CLASSDESC_ACCESS()

minsky::PhillipsDiagram::CLASSDESC_ACCESS ( PhillipsDiagram  )

private

clear()

void minsky::PhillipsDiagram::clear ( )

inline

Definition at line 91 of file phillipsDiagram.h.

References flows, and stocks.

                 {
      stocks.clear();
      flows.clear();
    }

hasScrollBars()

bool minsky::PhillipsDiagram::hasScrollBars ( ) const

inlineoverridevirtual

return whether this window has scrollbars (needed for MacOSX).

Reimplemented from minsky::RenderNativeWindow.

Definition at line 102 of file phillipsDiagram.h.

{return true;}

init()

void minsky::PhillipsDiagram::init ( )

overridevirtual

populate phillips diagram from Godley tables in model

Reimplemented from minsky::RenderNativeWindow.

Definition at line 97 of file phillipsDiagram.cc.

References minsky::cminsky(), MathDAG::cos(), flows, minsky::GroupItems::items, M_PI, minsky::minsky(), minsky::Minsky::model, minsky::Minsky::pushHistory(), MathDAG::sin(), and stocks.

  {
    decltype(stocks) newStocks;
    decltype(flows) newFlows;
    cminsky().model->recursiveDo
      (&GroupItems::items, [&](const Items&,Items::const_iterator it) {
        if (auto g=dynamic_cast<GodleyIcon*>(it->get())) {
          for (auto& v: g->stockVars())
            {
              auto newStock=newStocks.emplace(v->valueId(), static_cast<Variable<VariableType::stock>&>(*v)).first;
              auto oldStock=stocks.find(v->valueId());
              if (oldStock!=stocks.end())
                {
                  newStock->second.moveTo(oldStock->second.x(), oldStock->second.y());
                  newStock->second.rotation(oldStock->second.rotation());
                }
            }
          for (unsigned r=1; r<g->table.rows(); ++r) {
            if (g->table.initialConditionRow(r)) continue;
            map<string, vector<pair<FlowCoef, string>>> sources, destinations; 
            for (size_t c=1; c<g->table.cols(); c++)
              {
                const FlowCoef fc(g->table.cell(r,c));
                if (fc.coef)
                  {
                    auto payload=make_pair(FlowCoef(fc.coef,g->table.cell(0,c)),g->table.cell(r,0));
                    if ((fc.coef>0 && !g->table.signConventionReversed(c))
                        || (fc.coef<0 && g->table.signConventionReversed(c)))
                      sources[fc.name].emplace_back(payload);
                    else 
                      destinations[fc.name].emplace_back(payload);
                  }
              }
            for (auto& i: sources)
              for (auto& [s,sd]: i.second)
                for (auto& [d,description]: destinations[i.first])
                  {
                    auto ss=s, dd=d;
                    if (s.coef*d.coef<0) swap(ss,dd);
                    auto& source=newStocks[g->valueId(ss.name)];
                    auto& dest=newStocks[g->valueId(dd.name)];
                    auto flow=newFlows.emplace(make_pair(g->valueId(dd.name),g->valueId(ss.name)), PhillipsFlow(dest.ports(0), source.ports(1))).first;
                    flow->second.addTerm(abs(s.coef*d.coef), i.first);
                    flow->second.tooltip((!flow->second.tooltip().empty()?";":"")+description);
                    if (auto oldFlow=flows.find(flow->first); oldFlow!=flows.end())
                      flow->second.coords(oldFlow->second.coords());
                  }
          }
        }
        return false;
      });

    // now layout the diagram
    if (newStocks.empty())
      {
        stocks.clear();
        flows.clear();
        minsky().pushHistory();
        return;
      }

    double angle=0, delta=2*M_PI/newStocks.size();


    auto h=newStocks.begin()->second.height();
    auto maxW=newStocks.begin()->second.width();
    for (auto& i: newStocks) maxW=max(maxW,i.second.width());
    // calculate radius to ensure vars do not overlap
    auto r=h/delta + 0.5*maxW;
    
    for (auto& i: newStocks)
      {
        if (!stocks.contains(i.first))
          {
            i.second.moveTo(r*(cos(angle)+1)+maxW+50,r*(sin(angle)+1)+maxW+50);
            i.second.rotation(angle*180.0/M_PI);
          }
        angle+=delta;
      }

    flows.swap(newFlows);
    stocks.swap(newStocks);
    minsky().pushHistory();
  }

Here is the call graph for this function:

mouseDown()

void minsky::PhillipsDiagram::mouseDown ( float  x, float  y  )

overridevirtual

Reimplemented from minsky::EventInterface.

Definition at line 182 of file phillipsDiagram.cc.

References flowBeingEdited, flows, handleSelected, minsky::NoteBase::mouseFocus, stockBeingMoved, stockBeingRotated, stocks, x, and y.

  {
    if (stockBeingRotated) return;
    x-=this->x; y-=this->y;
    for (auto& i: stocks)
      if (i.second.contains(x,y))
        {
          stockBeingMoved=&i.second;
          return;
        }

    for (auto& i: flows)
      if (i.second.near(x,y))
        {
          flowBeingEdited=&i.second;
          i.second.mouseFocus=true;
          handleSelected=i.second.nearestHandle(x,y);
          return;
        }
  }

mouseMove()

void minsky::PhillipsDiagram::mouseMove ( float  x, float  y  )

overridevirtual

Reimplemented from minsky::EventInterface.

Definition at line 212 of file phillipsDiagram.cc.

References minsky::Wire::editHandle(), flowBeingEdited, flows, handleSelected, minsky::Item::moveTo(), requestRedraw(), rotateOrigin, stockBeingMoved, stockBeingRotated, x, and y.

Referenced by mouseUp().

  {
    x-=this->x; y-=this->y;
    if (stockBeingRotated)
      {
        stockBeingRotated->rotate(Point{x,y}, rotateOrigin);
        requestRedraw();
        return;
      }
    if (stockBeingMoved)
      {
        stockBeingMoved->moveTo(x,y);
        requestRedraw();
        return;
      }
    if (flowBeingEdited)
      {
        flowBeingEdited->editHandle(handleSelected,x,y);
        requestRedraw();
        return;
      }
    for (auto& i: flows)
      {
        const bool mf=i.second.near(x,y);
        if (mf!=i.second.mouseFocus)
        {
          i.second.mouseFocus=mf;
          requestRedraw();
        }
      }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

mouseUp()

void minsky::PhillipsDiagram::mouseUp ( float  x, float  y  )

overridevirtual

Reimplemented from minsky::EventInterface.

Definition at line 203 of file phillipsDiagram.cc.

References flowBeingEdited, minsky::minsky(), mouseMove(), minsky::Minsky::pushHistory(), stockBeingMoved, stockBeingRotated, x, and y.

  {
    mouseMove(x,y);
    minsky().pushHistory();
    stockBeingMoved=nullptr;
    stockBeingRotated=nullptr;
    flowBeingEdited=nullptr;
  }

Here is the call graph for this function:

moveTo()

void minsky::PhillipsDiagram::moveTo ( float  x, float  y  )

inlineoverridevirtual

move this so that (x,y) is centred

Reimplemented from minsky::EventInterface.

Definition at line 99 of file phillipsDiagram.h.

References requestRedraw(), x, and y.

{this->x=x; this->y=y; requestRedraw();}

Here is the call graph for this function:

position()

std::vector<float> minsky::PhillipsDiagram::position ( ) const

inlineoverridevirtual

current centre coordinates

Reimplemented from minsky::EventInterface.

Definition at line 100 of file phillipsDiagram.h.

References x, and y.

{return {x,y};}

redraw()

bool minsky::PhillipsDiagram::redraw ( int  , int  , int  width, int  height  )

overrideprivate

Definition at line 79 of file phillipsDiagram.cc.

References flows, stocks, x, and y.

  {
    if  (!surface.get()) return false;
    auto cairo=surface->cairo();
    const CairoSave cs(cairo);
    cairo_translate(cairo,x,y);
    for (auto& i: stocks)
      {
        const CairoSave cs(cairo);
        cairo_identity_matrix(cairo);
        cairo_translate(cairo,i.second.x()+x, i.second.y()+y);
        i.second.draw(cairo);
      }
    for (auto& i: flows)
      i.second.draw(cairo);
    return true;
  }

requestRedraw()

void minsky::PhillipsDiagram::requestRedraw ( )

inline

Definition at line 88 of file phillipsDiagram.h.

Referenced by mouseMove(), moveTo(), and startRotatingItem().

{if (surface.get()) surface->requestRedraw();}

Here is the caller graph for this function:

startRotatingItem()

void minsky::PhillipsDiagram::startRotatingItem	(	float	x,
		float	y
	)

Definition at line 244 of file phillipsDiagram.cc.

References requestRedraw(), rotateOrigin, stockBeingRotated, stocks, x, and y.

  {
    x-=this->x; y-=this->y;
      for (auto& i: stocks)
        if (i.second.contains(x,y))
          {
            stockBeingRotated=&i.second;
            rotateOrigin=Point(x,y);
            requestRedraw();
            return;
          }
  }

Here is the call graph for this function:

Member Data Documentation

flowBeingEdited

PhillipsFlow* minsky::PhillipsDiagram::flowBeingEdited =nullptr

private

Definition at line 82 of file phillipsDiagram.h.

Referenced by mouseDown(), mouseMove(), and mouseUp().

flows

std::map<std::pair<std::string,std::string>, PhillipsFlow> minsky::PhillipsDiagram::flows

Definition at line 87 of file phillipsDiagram.h.

Referenced by clear(), init(), mouseDown(), mouseMove(), schema3::PhillipsDiagram::PhillipsDiagram(), schema3::PhillipsDiagram::populatePhillipsDiagram(), and redraw().

handleSelected

int minsky::PhillipsDiagram::handleSelected =0

private

Definition at line 83 of file phillipsDiagram.h.

Referenced by mouseDown(), and mouseMove().

rotateOrigin

Exclude<Point> minsky::PhillipsDiagram::rotateOrigin

private

Definition at line 81 of file phillipsDiagram.h.

Referenced by mouseMove(), and startRotatingItem().

stockBeingMoved

PhillipsStock* minsky::PhillipsDiagram::stockBeingMoved =nullptr

private

Definition at line 79 of file phillipsDiagram.h.

Referenced by mouseDown(), mouseMove(), and mouseUp().

stockBeingRotated

PhillipsStock* minsky::PhillipsDiagram::stockBeingRotated =nullptr

private

Definition at line 80 of file phillipsDiagram.h.

Referenced by mouseDown(), mouseMove(), mouseUp(), and startRotatingItem().

stocks

std::map<std::string, PhillipsStock> minsky::PhillipsDiagram::stocks

Definition at line 86 of file phillipsDiagram.h.

Referenced by clear(), init(), mouseDown(), schema3::PhillipsDiagram::PhillipsDiagram(), schema3::PhillipsDiagram::populatePhillipsDiagram(), redraw(), and startRotatingItem().

x

float minsky::PhillipsDiagram::x =0

private

Definition at line 84 of file phillipsDiagram.h.

Referenced by mouseDown(), mouseMove(), mouseUp(), moveTo(), position(), redraw(), and startRotatingItem().

y

float minsky::PhillipsDiagram::y =0

private

position for panning

Definition at line 84 of file phillipsDiagram.h.

Referenced by mouseDown(), mouseMove(), mouseUp(), moveTo(), position(), redraw(), and startRotatingItem().

---

The documentation for this class was generated from the following files:

• model/phillipsDiagram.h
• model/phillipsDiagram.cc