minsky::Canvas Class Reference

#include <canvas.h>

Inheritance diagram for minsky::Canvas:

Collaboration diagram for minsky::Canvas:

Classes
struct	LassoMode
	lasso mode support More...
struct	Model
struct	ZoomCrop

Public Types
typedef std::chrono::time_point< std::chrono::high_resolution_clock >	Timestamp

Public Member Functions
void	rotateItem (float x, float y)
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	zoom (double x, double y, double z) override
double	zoomFactor () const override
	Canvas ()
	Canvas (const GroupPtr &m)
ecolab::cairo::SurfacePtr &	surface ()
void	mouseDown (float x, float y) override
	event handling for the canvas More...
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
	handle key press over current itemFocus, More...
void	displayDelayedTooltip (float x, float y)
std::shared_ptr< Port >	closestInPort (float x, float y) const
	return closest visible port to (x,y). nullptr is nothing suitable More...
void	select (const LassoBox &)
	select all items in a given region More...
int	ravelsSelected () const
	number of ravels in selection More...
void	setItemFocus (const ItemPtr &x)
	sets itemFocus, and resets mouse offset for placement More...
Public Member Functions inherited from minsky::RenderNativeWindow
const RenderFrameArgs &	frameArgs () const
	~RenderNativeWindow () override
virtual void	init ()
	perform any initialisation of any subclasses of this More...
void	renderFrame (const RenderFrameArgs &args)
void	destroyFrame ()
void	draw ()
void	requestRedraw ()
RenderNativeWindow &	operator= (const RenderNativeWindow &x)
	RenderNativeWindow ()=default
	RenderNativeWindow (const RenderNativeWindow &)=default
Public Member Functions inherited from minsky::EventInterface

Public Attributes
Model	model
Selection	selection
ItemPtr	itemFocus
	item selected by clicking More...
WirePtr	wireFocus
	wire that mouse is hovering over More...
int	handleSelected
	selected handle for handle moves, -ve = invalid More...
Exclude< shared_ptr< Port > >	fromPort
	from port when creating a new wire More...
double	termX
double	termY
	terminal of wire when extending More...
float	moveOffsX
float	moveOffsY
bool	rotatingItem =false
	set true when rotating an item More...
Exclude< Point >	rotateOrigin
	starting mouse position when rotating More...
ClickType::Type	clickType
ItemPtr	itemIndicator
	for drawing error indicator on the canvas More...
LassoMode::type	lassoMode =LassoMode::none
LassoBox	lasso {0,0,0,0}
bool	redrawAll =true
	if false, then only redraw graphs More...
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
	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)

Private Attributes
bool	m_redrawRequested =false
	flag indicating that a redraw is requested, but not yet redrawn More...
PlotOptions	defaultPlotOptions
	options to apply to a new plot widget More...
ItemPtr	item
	item or wire obtained by get*At() calls More...
WirePtr	wire
	item or wire obtained by get*At() calls More...
double	defaultRotation =0
	item or wire obtained by get*At() calls More...
LassoBox	updateRegion {0,0,0,0}
	region to be updated More...
ItemPtr	itemAt (float x, float y)
	item or wire obtained by get*At() calls More...
bool	getItemAt (float x, float y) override
	item or wire obtained by get*At() calls More...
bool	getWireAt (float x, float y) override
	item or wire obtained by get*At() calls More...
void	addOperation (OperationType::Type op)
	item or wire obtained by get*At() calls More...
void	addVariable (const std::string &name, VariableType::Type type)
	item or wire obtained by get*At() calls More...
void	addNote (const std::string &text)
	item or wire obtained by get*At() calls More...
void	addPlot ()
	item or wire obtained by get*At() calls More...
void	addGodley ()
	item or wire obtained by get*At() calls More...
void	addGroup ()
	item or wire obtained by get*At() calls More...
void	addSwitch ()
	item or wire obtained by get*At() calls More...
void	addRavel ()
	item or wire obtained by get*At() calls More...
void	addLock ()
	item or wire obtained by get*At() calls More...
void	addSheet ()
	item or wire obtained by get*At() calls More...
void	groupSelection ()
	create a group from items found in the current selection More...
void	lockRavelsInSelection ()
	lock all ravels in the selection together. If ravels already belong to more than one group, then a completely new group is set up. More...
void	unlockRavelsInSelection ()
	item or wire obtained by get*At() calls More...
void	deleteItem ()
	delete item referenced by item More...
void	deleteWire ()
	delete wire referenced by wire More...
void	delHandle (float x, float y)
	delete wire handle referenced by wire More...
void	removeItemFromItsGroup ()
	remove item from its group, leaving in itemFocus for later placement More...
void	selectAllVariables ()
	select all variables referring to same variableValue as item More...
void	renameAllInstances (const std::string &newName)
	rename all instances of variable as item to newName More...
void	renameItem (const std::string &newName)
	rename variable as item to newName More...
void	ungroupItem ()
	if item is a Group, move its contents to its parent and delete the group More...
void	copyItem ()
	create a copy of item, and leave it focused More...
void	zoomToFit ()
	zooms canvas to fit available window More...
void	openGroupInCanvas (const ItemPtr &item)
	reinitialises canvas to the group located in item More...
void	copyAllFlowVars ()
	copy all flowVars of a GodleyIcon in item More...
void	copyAllStockVars ()
	copy all stockVars of a GodleyIcon in item More...
void	zoomToDisplay ()
	zooms canvas such that group indexed by item is displayed More...
bool	selectVar (float x, float y)
	populates item with a variable if (x,y) is over a variable part More...
bool	findVariableDefinition ()
	populates item with the defining variable if there is one. Leave item unchanged if it is not a variable, or variable is undefined. NB may be a Godley table or integral More...
bool	redraw ()
	draw a red circle around item More...
bool	redrawUpdateRegion ()
	update region given by updateRegion More...
void	renderToPNGCropped (const std::string &filename, const ZoomCrop &)
	Render to a PNG file filename, scaling the canvas temporarily by zoom, shifts it to left, top, and crops to width, height. More...
void	recentre ()
	adjust canvas so that -ve coordinates appear on canvas More...
bool	redrawRequested () const
	flag indicating that a redraw is requested, but not yet redrawn More...
void	requestRedraw ()
	request a redraw on the screen More...
bool	hasScrollBars () const override
	item or wire obtained by get*At() calls More...
void	setDefaultPlotOptions ()
	item or wire obtained by get*At() calls More...
void	applyDefaultPlotOptions ()
	item or wire obtained by get*At() calls More...
void	setItemFromItemFocus ()
	item or wire obtained by get*At() calls 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 52 of file canvas.h.

Member Typedef Documentation

Timestamp

typedef std::chrono::time_point<std::chrono::high_resolution_clock> minsky::Canvas::Timestamp

Definition at line 68 of file canvas.h.

Constructor & Destructor Documentation

Canvas() [1/2]

minsky::Canvas::Canvas ( )

inline

Definition at line 145 of file canvas.h.

{}

Canvas() [2/2]

minsky::Canvas::Canvas ( const GroupPtr &  m )

inline

Definition at line 146 of file canvas.h.

: model(m) {}

Member Function Documentation

addGodley()

void minsky::Canvas::addGodley ( )

inline

item or wire obtained by get*At() calls

Definition at line 200 of file canvas.h.

{setItemFocus(model->addItem(new GodleyIcon));}

addGroup()

void minsky::Canvas::addGroup ( )

inline

item or wire obtained by get*At() calls

Definition at line 201 of file canvas.h.

{setItemFocus(model->addItem(new Group));}

addLock()

void minsky::Canvas::addLock ( )

inline

item or wire obtained by get*At() calls

Definition at line 204 of file canvas.h.

{setItemFocus(model->addItem(new Lock));}

addNote()

void minsky::Canvas::addNote ( const std::string &  text )

inline

item or wire obtained by get*At() calls

Definition at line 192 of file canvas.h.

                                        {
      setItemFocus(model->addItem(new Item));
      itemFocus->detailedText(text);
    }

addOperation()

void minsky::Canvas::addOperation ( OperationType::Type  op )

inline

item or wire obtained by get*At() calls

Definition at line 182 of file canvas.h.

References minsky::OperationBase::create(), minsky::OperationType::numOps, and minsky::op.

                                            {
      if (op==OperationType::numOps) return;
      setItemFocus(model->addItem(OperationBase::create(op)));
      itemFocus->rotation(defaultRotation);
    }

Here is the call graph for this function:

addPlot()

void minsky::Canvas::addPlot ( )

inline

item or wire obtained by get*At() calls

Definition at line 196 of file canvas.h.

References minsky::PlotOptions< Base >::applyPlotOptions().

                   {
      setItemFocus(model->addItem(new PlotWidget));
      defaultPlotOptions.applyPlotOptions(*itemFocus->plotWidgetCast());
    }

Here is the call graph for this function:

addRavel()

void minsky::Canvas::addRavel ( )

inline

item or wire obtained by get*At() calls

Definition at line 203 of file canvas.h.

{setItemFocus(model->addItem(new Ravel));}

addSheet()

void minsky::Canvas::addSheet ( )

inline

item or wire obtained by get*At() calls

Definition at line 205 of file canvas.h.

{setItemFocus(model->addItem(new Sheet));}

addSwitch()

void minsky::Canvas::addSwitch ( )

inline

item or wire obtained by get*At() calls

Definition at line 202 of file canvas.h.

{setItemFocus(model->addItem(new SwitchIcon));}

addVariable()

void minsky::Canvas::addVariable ( const std::string &  name, VariableType::Type  type  )

inline

item or wire obtained by get*At() calls

Definition at line 187 of file canvas.h.

References minsky::VariableType::numVarTypes, and minsky::VariableType::undefined.

Referenced by minsky::VariablePaneCell::emplace().

                                                                   {
      if (type==VariableType::undefined || type==VariableType::numVarTypes) return;
      setItemFocus(model->addItem(VariablePtr(type,name)));
      itemFocus->rotation(defaultRotation);
    }

Here is the caller graph for this function:

applyDefaultPlotOptions()

void minsky::Canvas::applyDefaultPlotOptions

(

)

item or wire obtained by get*At() calls

Definition at line 960 of file canvas.cc.

                                       {
      if (auto p=item->plotWidgetCast()) {
        // stash titles to restore later
        const string title(p->title), xlabel(p->xlabel()),
          ylabel(p->ylabel()), y1label(p->y1label());
        defaultPlotOptions.applyPlotOptions(*p);
        p->title=title, p->xlabel(xlabel),
          p->ylabel(ylabel), p->y1label(y1label);
      }
    }

CLASSDESC_ACCESS()

minsky::Canvas::CLASSDESC_ACCESS ( Canvas  )

private

closestInPort()

shared_ptr< Port > minsky::Canvas::closestInPort	(	float	x,
		float	y
	)		const

return closest visible port to (x,y). nullptr is nothing suitable

Definition at line 120 of file canvas.cc.

References minsky::anonymous_namespace{autoLayout.cc}::minD(), and minsky::sqr().

  {
    shared_ptr<Port> closestPort;
    auto minD=numeric_limits<float>::max();
    model->recursiveDo(&GroupItems::items,
                       [&](const Items&, Items::const_iterator i)
                       {
                         if ((*i)->group.lock()->displayContents())
                           for (size_t pi=0; pi<(*i)->portsSize(); ++pi)
                             {
                               auto p=(*i)->ports(pi).lock();
                               const float d=sqr(p->x()-x)+sqr(p->y()-y);
                               if (d<minD)
                                 {
                                   minD=d;
                                   closestPort=p;
                                 }
                             }
                         return false;
                       });
    return closestPort;
  }

Here is the call graph for this function:

controlMouseDown()

void minsky::Canvas::controlMouseDown ( float  x, float  y  )

overridevirtual

Reimplemented from minsky::EventInterface.

Definition at line 42 of file canvas.cc.

  {
    mouseDownCommon(x,y);
    if (itemFocus && itemFocus->group.lock() == model)
      selection.toggleItemMembership(itemFocus);
  }

copyAllFlowVars()

void minsky::Canvas::copyAllFlowVars ( )

inline

copy all flowVars of a GodleyIcon in item

Definition at line 244 of file canvas.h.

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

copyAllStockVars()

void minsky::Canvas::copyAllStockVars ( )

inline

copy all stockVars of a GodleyIcon in item

Definition at line 249 of file canvas.h.

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

copyItem()

void minsky::Canvas::copyItem

(

)

create a copy of item, and leave it focused

Definition at line 617 of file canvas.cc.

References minsky::Minsky::canvas, minsky::group, pyminsky::minsky, minsky::Minsky::pushHistory(), renameAllInstances(), and minsky::Minsky::undo().

  {
    if (item)
      {
        ItemPtr newItem;
        // cannot duplicate an integral, just its variable
        if (auto intop=dynamic_cast<IntOp*>(item.get()))
          newItem.reset(intop->intVar->clone());
        else if (auto group=dynamic_cast<Group*>(item.get()))
          newItem=group->copy();
        else
          {                         
            if (item->ioVar())
              if (auto v=item->variableCast())
                if (v->rawName()[0]!=':')
                  try
                    {
                      minsky().pushHistory(); // save current state in case of failure
                      // attempt to make variable outer scoped. For #1100
                      minsky().canvas.renameAllInstances(":"+v->rawName());
                    }
                  catch (...)
                    {
                      minsky().undo(); // back out of change
                      throw;
                    }
            
            newItem.reset(item->clone());
            // if copied from a Godley table or I/O var, set orientation to default
            if (auto v=item->variableCast())
              if (v->controller.lock())
                newItem->rotation(defaultRotation);
                    
          }
        setItemFocus(model->addItem(newItem));
        model->normaliseGroupRefs(model);
      }
  }

Here is the call graph for this function:

copyVars()

void minsky::Canvas::copyVars ( const std::vector< VariablePtr > &  v )

private

Definition at line 713 of file canvas.cc.

References minsky::RenderVariable::height(), and minsky::RenderVariable::width().

  {
    float maxWidth=0, totalHeight=0;
    vector<float> widths, heights;
    // Throw error if no stock/flow vars on Godley icon. For ticket 1039 
    if (!v.empty()) {    
          selection.clear();    
      for (auto& i: v)
        {
          const RenderVariable rv(*i);
          widths.push_back(rv.width());
          heights.push_back(rv.height());
          maxWidth=max(maxWidth, widths.back());
          totalHeight+=heights.back();
        }
      float y=v[0]->y() - totalHeight;
      for (size_t i=0; i<v.size(); ++i)
        {
                  // Stock and flow variables on Godley icons should not be copied as groups. For ticket 1039   
          const ItemPtr ni(v[i]->clone());
          (ni->variableCast())->rotation(0);
          ni->moveTo(v[0]->x()+maxWidth-v[i]->zoomFactor()*widths[i],
                     y+heights[i]);
          // variables need to refer to outer scope
          if ((ni->variableCast())->name()[0]!=':')
            (ni->variableCast())->name(':'+(ni->variableCast())->name());
          y+=2*v[i]->zoomFactor()*heights[i];
          selection.insertItem(model->addItem(ni));              
        }
        // Item focus put on one of the copied vars that are still in selection. For ticket 1039
        if (!selection.empty()) setItemFocus(selection.items[0]);
        else setItemFocus(nullptr);  
    } else throw error("no flow or stock variables to copy");    
  }

Here is the call graph for this function:

deleteItem()

void minsky::Canvas::deleteItem

(

)

delete item referenced by item

Definition at line 487 of file canvas.cc.

References pyminsky::minsky, and minsky::Minsky::requestReset().

  {
    if (item)
    {
      model->deleteItem(*item);
      minsky().requestReset();
    }
  }

Here is the call graph for this function:

deleteWire()

void minsky::Canvas::deleteWire

(

)

delete wire referenced by wire

Definition at line 496 of file canvas.cc.

References pyminsky::minsky, minsky::Minsky::requestReset(), and minsky::wire.

  {
    if (wire)
    {
      model->removeWire(*wire);
      wire.reset();
      minsky().requestReset();
    }
  }

Here is the call graph for this function:

delHandle()

void minsky::Canvas::delHandle	(	float	x,
		float	y
	)

delete wire handle referenced by wire

Definition at line 507 of file canvas.cc.

  {
    wireFocus=model->findAny(&Group::wires,
                   [&](const WirePtr& i){return i->near(x,y);});
    if (wireFocus)
      {
        wireFocus->deleteHandle(x,y);
        wireFocus.reset(); // prevent accidental moves of handle
      }
    requestRedraw();
  }  

displayDelayedTooltip()

void minsky::Canvas::displayDelayedTooltip	(	float	x,
		float	y
	)

Definition at line 370 of file canvas.cc.

  {
    if (auto item=itemAt(x,y))
      {
        item->displayDelayedTooltip(x,y);
        requestRedraw();
      }
  }

findVariableDefinition()

bool minsky::Canvas::findVariableDefinition

(

)

populates item with the defining variable if there is one. Leave item unchanged if it is not a variable, or variable is undefined. NB may be a Godley table or integral

Returns

true if definition found.

Definition at line 770 of file canvas.cc.

  {
    if (auto iv=item->variableCast())
      {
        if (iv->type()==VariableType::constant ||
            iv->type()==VariableType::parameter || iv->inputWired())
          return (itemIndicator=item).get();
        
        itemIndicator=model->findAny
          (&GroupItems::items, [&](const ItemPtr& i) {
            if (auto v=i->variableCast())
              return v->inputWired() && v->valueId()==iv->valueId();
            if (auto g=dynamic_cast<GodleyIcon*>(i.get()))
              for (auto& v: g->stockVars())
                {
                  if (v->valueId()==iv->valueId())
                    return true;
                }
            else if (auto o=dynamic_cast<IntOp*>(i.get()))
              return o->intVar->valueId()==iv->valueId();
            return false;
          });
        return itemIndicator.get();
      }
    return false;
  }

getItemAt()

bool minsky::Canvas::getItemAt ( float  x, float  y  )

inlineoverridevirtual

item or wire obtained by get*At() calls

Reimplemented from minsky::EventInterface.

Definition at line 178 of file canvas.h.

{return (item=itemAt(x,y)).get();}

getWireAt()

bool minsky::Canvas::getWireAt ( float  x, float  y  )

overridevirtual

item or wire obtained by get*At() calls

Reimplemented from minsky::EventInterface.

Definition at line 434 of file canvas.cc.

References minsky::wire.

  {
    wire=model->findAny(&Group::wires,
                        [&](const WirePtr& i){return i->near(x,y);});
    return wire.get();
  }

groupSelection()

void minsky::Canvas::groupSelection

(

)

create a group from items found in the current selection

Definition at line 441 of file canvas.cc.

  {
    const GroupPtr r=model->addGroup(new Group);
    for (auto& i: selection.items)
      r->addItem(i);
    for (auto& i: selection.groups)
      r->addItem(i);
    r->splitBoundaryCrossingWires();
    r->resizeOnContents();
  }

hasScrollBars()

bool minsky::Canvas::hasScrollBars ( ) const

inlineoverridevirtual

item or wire obtained by get*At() calls

Reimplemented from minsky::RenderNativeWindow.

Definition at line 293 of file canvas.h.

{return true;}

itemAt()

ItemPtr minsky::Canvas::itemAt	(	float	x,
		float	y
	)

item or wire obtained by get*At() calls

Definition at line 411 of file canvas.cc.

References minsky::anonymous_namespace{autoLayout.cc}::minD(), and minsky::sqr().

  {
    // Fix for library dependency problem with items during Travis build     
    ItemPtr item;                    
    auto minD=numeric_limits<float>::max();
    model->recursiveDo(&GroupItems::items,
                       [&](const Items&, Items::const_iterator i)
                       {
                          const float d=sqr((*i)->x()-x)+sqr((*i)->y()-y);
                          if (d<minD && (*i)->visible() && (*i)->contains(x,y))
                            {
                              minD=d;
                              item=*i;
                            }
                          return false;  
                       });
    if (!item)
      item=model->findAny
        (&Group::groups, [&](const GroupPtr& i)
                         {return i->visible() && i->clickType(x,y)!=ClickType::outside;});
    return item;
  }

Here is the call graph for this function:

keyPress()

bool minsky::Canvas::keyPress ( const EventInterface::KeyPressArgs &  )

overridevirtual

handle key press over current itemFocus,

Parameters

keySym	the X key sym code
utf8	utf8 encoded character
state	modifer state 1=shift, 2=caps lock, 4=ctrl, 8=alt
x	& y contain mouse coordinates

Returns

true if event handled

Reimplemented from minsky::EventInterface.

Definition at line 357 of file canvas.cc.

References minsky::EventInterface::KeyPressArgs::keySym, minsky::Minsky::markEdited(), pyminsky::minsky, minsky::EventInterface::KeyPressArgs::state, minsky::EventInterface::KeyPressArgs::utf8, minsky::EventInterface::KeyPressArgs::x, and minsky::EventInterface::KeyPressArgs::y.

  {
    if (auto item=itemAt(args.x,args.y))
      if (item->onKeyPress(args.keySym, args.utf8, args.state))
        {
          minsky().markEdited(); // keyPresses don't set the dirty flag by default
          requestRedraw();
          return true;
        }
    return false;
  }

Here is the call graph for this function:

lockRavelsInSelection()

void minsky::Canvas::lockRavelsInSelection

(

)

lock all ravels in the selection together. If ravels already belong to more than one group, then a completely new group is set up.

Definition at line 452 of file canvas.cc.

  {
    vector<shared_ptr<Ravel> > ravelsToLock;
    shared_ptr<RavelLockGroup> lockGroup;
    bool conflictingLockGroups=false;
    for (auto& i: selection.items)
      if (auto r=dynamic_pointer_cast<Ravel>(i))
        {
          ravelsToLock.push_back(r);
          if (!lockGroup)
            lockGroup=r->lockGroup;
          if (lockGroup!=r->lockGroup)
            conflictingLockGroups=true;
        }
    if (ravelsToLock.size()<2)
      return;
    if (!lockGroup || conflictingLockGroups)
      lockGroup.reset(new RavelLockGroup);
    for (auto& r: ravelsToLock)
      {
        lockGroup->addRavel(r);
        r->leaveLockGroup();
        r->lockGroup=lockGroup;
      }
    if (lockGroup) lockGroup->initialBroadcast();
    selection.clear();
  }

mouseDown()

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

overridevirtual

event handling for the canvas

Reimplemented from minsky::EventInterface.

Definition at line 49 of file canvas.cc.

  {
    mouseDownCommon(x,y);
    if (!itemFocus || !selection.contains(itemFocus))
      selection.clear(); // clicking outside a selection clears it
  }

mouseDownCommon()

void minsky::Canvas::mouseDownCommon ( float  x, float  y  )

private

Definition at line 57 of file canvas.cc.

  {
    wireFocus.reset();
    // firstly, see if the user is selecting an item
    if ((itemFocus=itemAt(x,y)))
      {
        clickType=itemFocus->clickType(x,y);
        switch (clickType)
          {
          case ClickType::onPort:
            // items all have their output port first, if they have an output port at all.
            if ((fromPort=itemFocus->closestOutPort(x,y)))
              {
                termX=x;
                termY=y;
                itemFocus.reset();
              }
            break;
          case ClickType::onItem:
            moveOffsX=x-itemFocus->x();
            moveOffsY=y-itemFocus->y();
            break;
          case ClickType::outside:
            itemFocus.reset();
            if (lassoMode==LassoMode::none)
              lassoMode=LassoMode::lasso;
            break;
          case ClickType::inItem:
            itemFocus->onMouseDown(x,y);
            break;
          case ClickType::onResize:
            lassoMode=LassoMode::itemResize;
            // set x0,y0 to the opposite corner of (x,y)
            lasso.x0 = x>itemFocus->x()? itemFocus->left(): itemFocus->right();
            lasso.y0 = y>itemFocus->y()? itemFocus->top(): itemFocus->bottom();
            lasso.x1=x;
            lasso.y1=y;
            item=itemFocus;
            break;
          case ClickType::legendMove: case ClickType::legendResize:
            if (auto p=itemFocus->plotWidgetCast())
              p->mouseDown(x,y);
            break;
          }
      }
    else
      {
        wireFocus=model->findAny(&Group::wires,
                       [&](const WirePtr& i){return i->near(x,y);});
        if (wireFocus)
          handleSelected=wireFocus->nearestHandle(x,y);
        else
          if (lassoMode==LassoMode::none)
            lassoMode=LassoMode::lasso;
     }

    if (lassoMode==LassoMode::lasso)
      {
        lasso.x0=x;
        lasso.y0=y;
      }
  }

mouseMove()

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

overridevirtual

Reimplemented from minsky::EventInterface.

Definition at line 241 of file canvas.cc.

References pyminsky::minsky, and minsky::Minsky::reset_flag().

      {
        if (rotatingItem && item)
          {
            item->rotate(Point{x,y},rotateOrigin);
            requestRedraw();
            return;
          }
        
        if (itemFocus)
          {
            switch (clickType)
              {
              case ClickType::onItem:
                mouseMoveOnItem(x,y);
                return;
              case ClickType::inItem:
                if (itemFocus->onMouseMotion(x,y))
                  requestRedraw();
                return;
              case ClickType::legendMove: case ClickType::legendResize:
                if (auto p=itemFocus->plotWidgetCast())
                  {
                    p->mouseMove(x,y);
                    requestRedraw();
                  }
                return;
              case ClickType::onResize:
                lasso.x1=x;
                lasso.y1=y;
                requestRedraw();
                break;
              default:
                break;
              }
          }
        else if (fromPort.get())
          {
            termX=x;
            termY=y;
            requestRedraw();
          }
        else if (wireFocus)
          {
            wireFocus->editHandle(handleSelected,x,y);
            requestRedraw();
          }
        else if (lassoMode==LassoMode::lasso || (lassoMode==LassoMode::itemResize && item.get()))
          {
            lasso.x1=x;
            lasso.y1=y;
            requestRedraw();
          }
        else
          {
            auto setFlagAndRequestRedraw=[&](bool& flag, bool cond) {
              if (flag==cond) return;
              flag=cond;
              requestRedraw();
            };
            // set mouse focus to display ports etc.
            bool mouseFocusSet=false; // ensure only one item is focused by mouse.
            model->recursiveDo(&Group::items, [&](Items&,Items::iterator& i)
                                              {
                                                (*i)->disableDelayedTooltip();
                                                // with coupled integration variables, we
                                                // do not want to set mousefocus, as this
                                                // draws unnecessary port circles on the
                                                // variable
                                                if (!(*i)->visible() && 
                                                    dynamic_cast<Variable<VariableBase::integral>*>(i->get()))
                                                  (*i)->mouseFocus=false;
                                                else
                                                  {
                                                    auto ct=(*i)->clickType(x,y);
                                                    setFlagAndRequestRedraw((*i)->mouseFocus, !mouseFocusSet && ct!=ClickType::outside);
                                                    if ((*i)->mouseFocus) mouseFocusSet=true;
                                                    setFlagAndRequestRedraw((*i)->onResizeHandles, ct==ClickType::onResize);
                                                    setFlagAndRequestRedraw((*i)->onBorder, ct==ClickType::onItem);
                                                    if (ct==ClickType::outside)
                                                        (*i)->onMouseLeave();
                                                    else if ((*i)->onMouseOver(x,y))
                                                      requestRedraw();
                                                  }
                                                return false;
                                              });
            model->recursiveDo(&Group::groups, [&](Groups&,Groups::iterator& i)
                                               {
                                                 auto ct=(*i)->clickType(x,y);
                                                 setFlagAndRequestRedraw((*i)->mouseFocus, !mouseFocusSet && ct!=ClickType::outside);
                                                 if ((*i)->mouseFocus) mouseFocusSet=true;
                                                 const bool onResize = ct==ClickType::onResize;
                                                 if (onResize!=(*i)->onResizeHandles)
                                                   {
                                                     (*i)->onResizeHandles=onResize;
                                                     requestRedraw();
                                                   }
                                                 return false;
                                               });
            model->recursiveDo(&Group::wires, [&](Wires&,Wires::iterator& i)
                                              {
                                                const bool mf=(*i)->near(x,y);
                                                if (mf!=(*i)->mouseFocus)
                                                  {
                                                    (*i)->mouseFocus=mf;
                                                    requestRedraw();
                                                  }        
                                                return false;
                                              });
          }
        if (minsky().reset_flag())
          minsky().resetAt=std::chrono::system_clock::now()+std::chrono::milliseconds(1500); // postpone reset whilst mousing
      }
    catch (...) {/* absorb any exceptions, as they're not useful here */}

Here is the call graph for this function:

mouseMoveOnItem()

void minsky::Canvas::mouseMoveOnItem ( float  x, float  y  )

private

Definition at line 195 of file canvas.cc.

  {
    updateRegion=LassoBox(itemFocus->x(),itemFocus->y(),x,y);
    // move item relatively to avoid accidental moves on double click
    if (selection.empty() || !selection.contains(itemFocus))
      itemFocus->moveTo(x-moveOffsX, y-moveOffsY);
    else
      {
        // move the whole selection
        auto deltaX=x-moveOffsX-itemFocus->x(), deltaY=y-moveOffsY-itemFocus->y();
        for (auto& i: selection.items)
          i->moveTo(i->x()+deltaX, i->y()+deltaY);
        for (auto& i: selection.groups)
          i->moveTo(i->x()+deltaX, i->y()+deltaY);
      }
    requestRedraw();
    // check if the move has moved outside or into a group
    if (auto g=itemFocus->group.lock())
      if (g==model || !g->contains(itemFocus->x(),itemFocus->y()))
        {
          if (auto toGroup=model->minimalEnclosingGroup
              (itemFocus->x(),itemFocus->y(),itemFocus->x(),itemFocus->y(),itemFocus.get()))
            {
              if (g.get()==toGroup) return;
              // prevent moving a group inside itself
              if (auto g=dynamic_cast<Group*>(itemFocus.get()))
                if (g->higher(*toGroup))
                  return;
              selection.clear(); // prevent old wires from being held onto
              toGroup->addItem(itemFocus);
              toGroup->splitBoundaryCrossingWires();
              g->splitBoundaryCrossingWires();
            }
          else if (g!=model)
            {
              selection.clear(); // prevent old wires from being held onto
              model->addItem(itemFocus);
              model->splitBoundaryCrossingWires();
              g->splitBoundaryCrossingWires();
            }
        }
    if (auto g=itemFocus->group.lock())
      if (g!=model)
        g->checkAddIORegion(itemFocus);
  }

mouseUp()

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

overridevirtual

Reimplemented from minsky::EventInterface.

Definition at line 143 of file canvas.cc.

References pyminsky::minsky, and minsky::Minsky::requestReset().

  {
    mouseMove(x,y);
    
    if (itemFocus && clickType==ClickType::inItem)
      {
        itemFocus->onMouseUp(x,y);
        itemFocus.reset(); // prevent spurious mousemove events being processed
        minsky().requestReset();
      }
    if (fromPort.get())
      {
          if (auto to=closestInPort(x,y)) {
            model->addWire(static_cast<shared_ptr<Port>&>(fromPort),to);

            // populate the destination tooltip if a Ravel
            if (to->item().tooltip().empty() && to->item().ravelCast())
              if (auto v=fromPort->item().variableCast())
                to->item().tooltip(v->name());
            
            minsky().requestReset(); 
          } 
          fromPort.reset();
      }
    
    if (wireFocus)
      wireFocus->editHandle(handleSelected,x,y);
    
    switch (lassoMode)
      {
      case LassoMode::lasso:
        select({lasso.x0,lasso.y0,x,y});
        requestRedraw();
        break;
      case LassoMode::itemResize:
        if (item)
          {
            item->resize(lasso);  
            requestRedraw();
          }
        break;
      default: break;
      }
    lassoMode=LassoMode::none;

    
    itemIndicator.reset();
    rotatingItem=false;
    itemFocus.reset();
    wireFocus.reset();
  }

Here is the call graph for this function:

moveTo()

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

inlineoverridevirtual

move this so that (x,y) is centred

Reimplemented from minsky::EventInterface.

Definition at line 129 of file canvas.h.

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

openGroupInCanvas()

void minsky::Canvas::openGroupInCanvas

(

const ItemPtr &

item

)

reinitialises canvas to the group located in item

Definition at line 694 of file canvas.cc.

References minsky::Minsky::bookmarkRefresh(), pyminsky::minsky, and minsky::wire.

  {
    if (auto g=dynamic_pointer_cast<Group>(item))
      {
        if (auto parent=model->group.lock())
          model->setZoom(parent->zoomFactor());
        model=g;
        zoomToFit();

        minsky().bookmarkRefresh();
        this->item.reset();
        itemFocus.reset();
        wire.reset();
        selection.clear();
        fromPort.reset();
        requestRedraw();
      }
  }

Here is the call graph for this function:

position()

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

inlineoverridevirtual

current centre coordinates

Reimplemented from minsky::EventInterface.

Definition at line 134 of file canvas.h.

                                               {
      return {model->x(), model->y()};
    }

ravelsSelected()

int minsky::Canvas::ravelsSelected

(

)

const

number of ravels in selection

Definition at line 399 of file canvas.cc.

  {
    int ravelsSelected = 0;
    for (auto& i: selection.items) {
      if (dynamic_pointer_cast<Ravel>(i))
      {
        ravelsSelected++;
      }
    }
    return ravelsSelected;
  }

recentre()

void minsky::Canvas::recentre

(

)

adjust canvas so that -ve coordinates appear on canvas

Definition at line 929 of file canvas.cc.

  {
    const SurfacePtr tmp(surface());
    surface().reset(new Surface(cairo_recording_surface_create(CAIRO_CONTENT_COLOR,nullptr)));
    redraw();
    model->moveTo(model->x()-surface()->left(), model->y()-surface()->top());
    surface()=tmp;
    requestRedraw();
  }

redraw() [1/2]

bool minsky::Canvas::redraw ( int  x0, int  y0, int  width, int  height  )

overrideprivate

Definition at line 797 of file canvas.cc.

  {
    updateRegion.x0=x0;
    updateRegion.y0=y0;
    updateRegion.x1=x0+width;
    updateRegion.y1=y0+height;
    // redraw of canvas may throw if called during a reset operation
    try
      {
        return redrawUpdateRegion();
      }
#ifndef NDEBUG
    catch (std::exception& ex)
      {
        cerr << ex.what() << endl;
      }
#endif
    catch (...)
      {
        // consume exception and try redrawing
        // this leads to an endless loop...
        //requestRedraw();
      }
    return false;
  }

redraw() [2/2]

bool minsky::Canvas::redraw

(

)

draw a red circle around item

redraw whole model

Definition at line 823 of file canvas.cc.

  {
    // nb using maxint here doesn't seem to work
    return redraw(-1e9,-1e9,2e9,2e9);
  }

redrawRequested()

bool minsky::Canvas::redrawRequested ( ) const

inline

flag indicating that a redraw is requested, but not yet redrawn

Definition at line 290 of file canvas.h.

{return m_redrawRequested;}

redrawUpdateRegion()

bool minsky::Canvas::redrawUpdateRegion

(

)

update region given by updateRegion

Definition at line 829 of file canvas.cc.

References M_PI.

  {
    bool didDrawSomething = false;
    if (!surface().get()) {
      return didDrawSomething;
    }
    m_redrawRequested=false;
    auto cairo=surface()->cairo();
    const CairoSave cs(cairo);
    cairo_rectangle(cairo,updateRegion.x0,updateRegion.y0,updateRegion.x1-updateRegion.x0,updateRegion.y1-updateRegion.y0);
    cairo_clip(cairo);
    cairo_set_line_width(cairo, 1);
    // items
    model->recursiveDo
      (&GroupItems::items, [&](const Items&, Items::const_iterator i)
       {
         auto& it=**i;
         if (it.visible() && updateRegion.intersects(it))
           {
             didDrawSomething = true;
             const CairoSave cs(cairo);
             cairo_identity_matrix(cairo);
             cairo_translate(cairo,it.x(), it.y());
             try
               {
                 it.draw(cairo);
               }
             catch (const std::exception& ex)
               {
                 cerr << ex.what() << endl;
               }
           }
         return false;
       });

    // groups
    model->recursiveDo
      (&GroupItems::groups, [&](const Groups&, Groups::const_iterator i)
       {
         auto& it=**i;
         if (it.visible() && updateRegion.intersects(it))
           {
             didDrawSomething = true;
             const CairoSave cs(cairo);
             cairo_identity_matrix(cairo);
             cairo_translate(cairo,it.x(), it.y());
             it.draw(cairo);
           }
         return false;
       });

    // draw all wires - wires will go over the top of any icons. TODO
    // introduce an ordering concept if needed
    model->recursiveDo
      (&GroupItems::wires, [&](const Wires&, Wires::const_iterator i)
       {
         const Wire& w=**i;
         if (w.visible()) {
           w.draw(cairo);
         }
         return false;
       });

    if (fromPort.get()) // we're in process of creating a wire
      {
        didDrawSomething = true;
        cairo_move_to(cairo,fromPort->x(),fromPort->y());
        cairo_line_to(cairo,termX,termY);
        cairo_stroke(cairo);
        // draw arrow
        const CairoSave cs(cairo);
        cairo_translate(cairo, termX,termY);
        cairo_rotate(cairo,atan2(termY-fromPort->y(), termX-fromPort->x()));
        cairo_move_to(cairo,0,0);
        cairo_line_to(cairo,-5,-3); 
        cairo_line_to(cairo,-3,0); 
        cairo_line_to(cairo,-5,3);
        cairo_close_path(cairo);
        cairo_fill(cairo);
      }

    if (lassoMode!=LassoMode::none)
      {
        didDrawSomething = true;
        cairo_rectangle(cairo,lasso.x0,lasso.y0,lasso.x1-lasso.x0,lasso.y1-lasso.y0);
        cairo_stroke(cairo);
      }

    if (itemIndicator) // draw a red circle to indicate an error or other marker
      {
        const CairoSave cs(surface()->cairo());
        cairo_set_source_rgb(surface()->cairo(),1,0,0);
        cairo_arc(surface()->cairo(),itemIndicator->x(),itemIndicator->y(),15,0,2*M_PI);
        cairo_stroke(surface()->cairo());
      }

    surface()->blit();
    return didDrawSomething;
  }

removeItemFromItsGroup()

void minsky::Canvas::removeItemFromItsGroup

(

)

remove item from its group, leaving in itemFocus for later placement

Definition at line 519 of file canvas.cc.

  {
    if (item)
      if (auto g=item->group.lock())
        {
          if (auto parent=g->group.lock())
            {
              itemFocus=parent->addItem(item);
              if (auto v=itemFocus->variableCast())
                v->controller.reset();
              g->splitBoundaryCrossingWires();
            }
          // else item already at toplevel
        }
  }

renameAllInstances()

void minsky::Canvas::renameAllInstances

(

const std::string &

newName

)

rename all instances of variable as item to newName

Definition at line 557 of file canvas.cc.

References minsky::valueId(), and minsky::var.

Referenced by copyItem(), and minsky::GodleyTableEditor::update().

  {
    auto var=item->variableCast();
    if (!var)
      if (auto i=dynamic_cast<IntOp*>(item.get()))
        var=i->intVar.get();
    if (var)
      {
        // cache name and valueId for later use as var gets invalidated in the recursiveDo
        auto valueId=var->valueId();
        model->renameAllInstances(valueId, newName);
      }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

renameItem()

void minsky::Canvas::renameItem

(

const std::string &

newName

)

rename variable as item to newName

Definition at line 605 of file canvas.cc.

References minsky::cminsky(), minsky::Minsky::definingVar(), and minsky::var.

  {
    if (!item) return;
    if (auto var=item->variableCast())
      {
        var->name(newName);
        // check stock variables are defined, convert to flow if not
        if (var->isStock() && !cminsky().definingVar(var->valueId()))
          var->retype(VariableType::flow);
      }
  }

Here is the call graph for this function:

renderToPNGCropped()

void minsky::Canvas::renderToPNGCropped	(	const std::string &	filename,
		const ZoomCrop &	z
	)

Render to a PNG file filename, scaling the canvas temporarily by zoom, shifts it to left, top, and crops to width, height.

Definition at line 945 of file canvas.cc.

References minsky::Canvas::ZoomCrop::height, minsky::Canvas::ZoomCrop::left, minsky::Canvas::ZoomCrop::top, minsky::Canvas::ZoomCrop::width, and minsky::Canvas::ZoomCrop::zoom.

  {
    model->zoom(model->x(),model->y(),z.zoom);
    model->moveTo(model->x()-z.left,model->y()-z.top);
    cairo::SurfacePtr tmp(new cairo::Surface(cairo_image_surface_create(CAIRO_FORMAT_ARGB32,z.width,z.height)));
    tmp.swap(surface());
    redraw(0,0,z.width,z.height);
    tmp.swap(surface());
    cairo_surface_write_to_png(tmp->surface(),filename.c_str());
    model->moveTo(model->x()+z.left,model->y()+z.top);
    model->zoom(model->x(),model->y(),1/z.zoom);
  }

reportDrawTime()

void minsky::Canvas::reportDrawTime ( double  t )

overrideprivate

Definition at line 939 of file canvas.cc.

References minsky::Minsky::maxWaitMS, and pyminsky::minsky.

  {
    // ensure screen refresh time is less than a third
    minsky().maxWaitMS=(t>0.03)? 3000*t: 100.0;
  }

requestRedraw()

void minsky::Canvas::requestRedraw ( )

inline

request a redraw on the screen

Definition at line 292 of file canvas.h.

Referenced by minsky::Group::gotoBookmark_b(), and minsky::GodleyTableEditor::update().

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

Here is the caller graph for this function:

rotateItem()

void minsky::Canvas::rotateItem ( float  x, float  y  )

inline

Definition at line 114 of file canvas.h.

                                      {
      rotateOrigin=Point(x,y);
      rotatingItem=true;
    }

select()

void minsky::Canvas::select

(

const LassoBox &

lasso

)

select all items in a given region

Definition at line 379 of file canvas.cc.

References minsky::Minsky::copy(), minsky::LassoBox::intersects(), pyminsky::minsky, minsky::LassoBox::x0, minsky::LassoBox::x1, minsky::LassoBox::y0, and minsky::LassoBox::y1.

  {
    selection.clear();

    auto topLevel = model->minimalEnclosingGroup(lasso.x0,lasso.y0,lasso.x1,lasso.y1);

    if (!topLevel) topLevel=&*model;

    for (auto& i: topLevel->items)
      if (i->visible() && lasso.intersects(*i))
        selection.ensureItemInserted(i);

    for (auto& i: topLevel->groups)
      if (i->visible() && lasso.intersects(*i))
        selection.ensureGroupInserted(i);

    // X11 behaviour, selecting automatically copies.
    minsky().copy();
  }

Here is the call graph for this function:

selectAllVariables()

void minsky::Canvas::selectAllVariables

(

)

select all variables referring to same variableValue as item

Definition at line 535 of file canvas.cc.

References minsky::var.

  {
    selection.clear();
    auto var=item->variableCast();
    if (!var)
      if (auto i=dynamic_cast<IntOp*>(item.get()))
        var=i->intVar.get();
    if (var)
      {
        model->recursiveDo
          (&GroupItems::items, [&](const Items&,Items::const_iterator i)
           {
             if (auto v=(*i)->variableCast())
               if (v->valueId()==var->valueId())
                 {
                   selection.ensureItemInserted(*i);
                 }
             return false;
           });
       }
  }

selectVar()

bool minsky::Canvas::selectVar	(	float	x,
		float	y
	)

populates item with a variable if (x,y) is over a variable part

Returns

true if item is updated

Definition at line 757 of file canvas.cc.

  {
    if (item)
      {
        if (auto v=item->select(x,y))
          {
            item=v;
            return true;
          }
      }
    return false;
  }

setDefaultPlotOptions()

void minsky::Canvas::setDefaultPlotOptions ( )

inline

item or wire obtained by get*At() calls

Definition at line 295 of file canvas.h.

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

setItemFocus()

void minsky::Canvas::setItemFocus ( const ItemPtr &  x )

inline

sets itemFocus, and resets mouse offset for placement

Definition at line 167 of file canvas.h.

References minsky::ClickType::onItem.

                                        {
      itemFocus=x;
      moveOffsX=moveOffsY=0;
      clickType=ClickType::onItem;
    }

setItemFromItemFocus()

void minsky::Canvas::setItemFromItemFocus

(

)

item or wire obtained by get*At() calls

Definition at line 971 of file canvas.cc.

  {
    item = itemFocus;
  }

surface()

ecolab::cairo::SurfacePtr& minsky::Canvas::surface ( )

inline

Definition at line 148 of file canvas.h.

{return ecolab::CairoSurface::surface;}

ungroupItem()

void minsky::Canvas::ungroupItem

(

)

if item is a Group, move its contents to its parent and delete the group

Definition at line 571 of file canvas.cc.

  {
    if (auto g=dynamic_cast<Group*>(item.get()))
      {           
        if (auto p=g->group.lock())
          {
            if (!g->empty()) // minskly crashes if group empty and ungrouped subsequently. for ticket 1243
              {                                          
                // stash values of parameters in copied group, as they are reset for some unknown reason later on. for tickets 1243/1258
                map<string,string> existingParms; 
                for (auto& i: g->items) {
                  auto v=i->variableCast(); 
                  if (v && v->type()==VariableType::parameter) 
                    existingParms.emplace(v->valueId(),v->init());
                }

                // blow up containe items so they appear in same relative locationsat parent scalefactor
                auto scaleFactor=1/g->relZoom;
                for (auto& i: g->items)
                  i->moveTo((i->x()-g->x())*scaleFactor+g->x(), (i->y()-g->y())*scaleFactor+g->y());
                for (auto& i: g->groups)
                  i->moveTo((i->x()-g->x())*scaleFactor+g->x(), (i->y()-g->y())*scaleFactor+g->y());
                p->moveContents(*g);
                deleteItem();
                    
                existingParms.clear();    
                 
              } else deleteItem();
          }       
        
        // else item is toplevel which can't be ungrouped
      }
  }

unlockRavelsInSelection()

void minsky::Canvas::unlockRavelsInSelection

(

)

item or wire obtained by get*At() calls

Definition at line 480 of file canvas.cc.

  {
    for (auto& i: selection.items)
      if (auto r=dynamic_cast<Ravel*>(i.get()))
        r->leaveLockGroup();
  }

zoom()

void minsky::Canvas::zoom ( double  x, double  y, double  z  )

inlineoverridevirtual

Reimplemented from minsky::EventInterface.

Definition at line 138 of file canvas.h.

References minsky::Canvas::Model::zoom().

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

Here is the call graph for this function:

zoomFactor()

double minsky::Canvas::zoomFactor ( ) const

inlineoverridevirtual

Reimplemented from minsky::EventInterface.

Definition at line 143 of file canvas.h.

{return model->zoomFactor();}

zoomToDisplay()

void minsky::Canvas::zoomToDisplay

(

)

zooms canvas such that group indexed by item is displayed

Definition at line 748 of file canvas.cc.

References pyminsky::minsky, and minsky::Minsky::resetScroll().

  {
    if (auto g=dynamic_cast<Group*>(item.get()))
      {
        model->zoom(g->x(),g->y(),1.1/(g->relZoom*g->zoomFactor()));
        minsky().resetScroll();
      }
  }

Here is the call graph for this function:

zoomToFit()

void minsky::Canvas::zoomToFit

(

)

zooms canvas to fit available window

Definition at line 656 of file canvas.cc.

References minsky::flipped().

  {
    if (frameArgs().parentWindowId.empty()) return; // no window to fit to, so do nothing
    // recompute all bounding boxes - why is this needed?
    for (auto& i: model->items) i->updateBoundingBox();
    
    double x0,x1,y0,y1;
    model->contentBounds(x0,y0,x1,y1);
    float inOffset=0, outOffset=0;
    const bool notFlipped=!flipped(model->rotation());
    const float flip=notFlipped? 1: -1;
                                                         
    // we need to move the io variables
    for (auto& v: model->inVariables)
      inOffset=std::max(inOffset, v->width());
    for (auto& v: model->outVariables)
      outOffset=std::max(outOffset, v->width());
        
    const float zoomFactor=std::min(frameArgs().childWidth/(x1-x0+inOffset+outOffset),
                              frameArgs().childHeight/(y1-y0));
        
    model->zoom(model->x(),model->y(),zoomFactor);

        
    model->contentBounds(x0,y0,x1,y1);
    float ioOffset=notFlipped? x0: x1;
                                                          
    // we need to move the io variables
    for (auto& v: model->inVariables)
      v->moveTo(ioOffset-flip*v->width(),v->y());
    ioOffset=notFlipped? x1: x0;                                               
    for (auto& v: model->outVariables)
      v->moveTo(ioOffset+flip*v->width(),v->y());
       
    recentre();
    requestRedraw();
  }

Here is the call graph for this function:

Member Data Documentation

clickType

ClickType::Type minsky::Canvas::clickType

Definition at line 118 of file canvas.h.

defaultPlotOptions

PlotOptions minsky::Canvas::defaultPlotOptions

private

options to apply to a new plot widget

Definition at line 65 of file canvas.h.

defaultRotation

double minsky::Canvas::defaultRotation =0

item or wire obtained by get*At() calls

Definition at line 181 of file canvas.h.

fromPort

Exclude<shared_ptr<Port> > minsky::Canvas::fromPort

from port when creating a new wire

Definition at line 109 of file canvas.h.

handleSelected

int minsky::Canvas::handleSelected

selected handle for handle moves, -ve = invalid

Definition at line 108 of file canvas.h.

item

ItemPtr minsky::Canvas::item

item or wire obtained by get*At() calls

Definition at line 175 of file canvas.h.

Referenced by minsky::GodleyTableEditor::update().

itemFocus

ItemPtr minsky::Canvas::itemFocus

item selected by clicking

Definition at line 106 of file canvas.h.

itemIndicator

ItemPtr minsky::Canvas::itemIndicator

for drawing error indicator on the canvas

Definition at line 120 of file canvas.h.

Referenced by minsky::Minsky::displayErrorItem(), and MathDAG::SystemOfEquations::SystemOfEquations().

lasso

LassoBox minsky::Canvas::lasso {0,0,0,0}

Definition at line 125 of file canvas.h.

lassoMode

LassoMode::type minsky::Canvas::lassoMode =LassoMode::none

Definition at line 124 of file canvas.h.

m_redrawRequested

bool minsky::Canvas::m_redrawRequested =false

private

flag indicating that a redraw is requested, but not yet redrawn

Definition at line 62 of file canvas.h.

model

Model minsky::Canvas::model

Definition at line 103 of file canvas.h.

Referenced by minsky::VariableBase::local(), and schema3::Minsky::populateMinsky().

moveOffsX

float minsky::Canvas::moveOffsX

Definition at line 111 of file canvas.h.

moveOffsY

float minsky::Canvas::moveOffsY

Definition at line 111 of file canvas.h.

redrawAll

bool minsky::Canvas::redrawAll =true

if false, then only redraw graphs

Definition at line 127 of file canvas.h.

rotateOrigin

Exclude<Point> minsky::Canvas::rotateOrigin

starting mouse position when rotating

Definition at line 113 of file canvas.h.

rotatingItem

bool minsky::Canvas::rotatingItem =false

set true when rotating an item

Definition at line 112 of file canvas.h.

selection

Selection minsky::Canvas::selection

Definition at line 105 of file canvas.h.

Referenced by minsky::VariableInstanceList::gotoInstance().

termX

double minsky::Canvas::termX

Definition at line 110 of file canvas.h.

termY

double minsky::Canvas::termY

terminal of wire when extending

Definition at line 110 of file canvas.h.

updateRegion

LassoBox minsky::Canvas::updateRegion {0,0,0,0}

region to be updated

Definition at line 273 of file canvas.h.

wire

WirePtr minsky::Canvas::wire

item or wire obtained by get*At() calls

Definition at line 176 of file canvas.h.

wireFocus

WirePtr minsky::Canvas::wireFocus

wire that mouse is hovering over

Definition at line 107 of file canvas.h.

---

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

• model/canvas.h
• model/canvas.cc