#include <group.h>

Inheritance diagram for minsky::Group:

Collaboration diagram for minsky::Group:

Classes
struct	IORegion
	returns which I/O region (x,y) is in if any More...

Public Member Functions
std::string	name () const override

double	operator() (const std::vector< double > &p) override
	evaluate function on arbitrary number of arguments (exprtk support) More...

std::string	formula () const
	algebraic formula representing value of first output argument of this group More...

std::string	arguments () const
	argument declaration, to be appended to name() for function declaration More...

	Group ()

bool	nocycles () const override
	tests that groups are arranged heirarchically without any recurrence More...

GroupPtr	copy () const
	Make a copy of this as a sibling group (owned by parent). Attempting to copying minsky.model is a null operation. More...

GroupPtr	copyUnowned () const
	make a copy of this, that is not owned by any group More...

Group *	clone () const override

ItemPtr	addItem (const std::shared_ptr< Item > &it, bool inSchema=false) override

void	makeSubroutine ()
	Make all variables not present in outerscope local to this group. More...

void	draw (cairo_t *) const override
	draw this item into a cairo context More...

void	drawEdgeVariables (cairo_t *) const
	draw representations of edge variables around group icon More...

void	draw1edge (const std::vector< VariablePtr > &vars, cairo_t *cairo, float x) const
	draw the variables of one of the edges More...

void	drawIORegion (cairo_t *) const
	draw notches in the I/O region to indicate dockability of variables there More...

void	moveContents (Group &source)
	move all items from source to this More...

IORegion::type	inIORegion (float x, float y) const

void	checkAddIORegion (const ItemPtr &x)
	check if item is a variable and located in an I/O region, and add it if it is More...

void	addInputVar ()

void	addOutputVar ()

void	deleteItem (const Item &)
	remove item from group, and also all attached wires. More...

void	deleteAttachedWires () override
	delete all attached wires More...

void	resizeOnContents ()
	adjust position and size of icon to just cover contents More...

void	resize (const LassoBox &x) override
	resize this item on the canvas More...

ClickType::Type	clickType (float x, float y) const override
	returns the clicktype given a mouse click at x, y. More...

bool	higher (const Group &) const
	returns true if this is higher in the heirarchy than the argument this->higher(*this) is false More...

unsigned	level () const
	return level in the heirarchy More...

const Group &	globalGroup () const
	top level group More...

Group &	globalGroup ()

bool	uniqueItems (std::set< void *> &idset) const
	returns true if items appear uniquely within the heirarchy. Note the map structure does not guarantee that an item doesn't appear within another group More...

bool	uniqueItems () const

bool	displayContents () const
	returns whether contents should be displayed. Top level group always displayed More...

bool	displayContentsChanged () const
	true if displayContents status changed on this or any contained group last zoom More...

void	margins (float &left, float &right) const
	margin sizes to allow space for edge variables. More...

std::vector< float >	marginsV () const
	for debugging purposes More...

float	computeDisplayZoom ()

void	computeRelZoom ()

float	localZoom () const

void	setZoom (float factor)
	sets the zoom factor to factor. Recursively set the zoomfactor on contained objects to the computed localzoom More...

void	zoom (float xOrigin, float yOrigin, float factor)

float	edgeScale () const
	scale used to render io variables. Smoothly interpolates between the scale at which internal items are displayed, and the outside zoom factor More...

ecolab::array< double >	cBounds () const
	for TCL debugging More...

float	rotFactor () const
	scaling factor to allow a rotated icon to fit on the bitmap More...

ItemPtr	select (float x, float y) const override
	returns the variable if point (x,y) is within a I/O variable icon, null otherwise, indicating that the Group has been selected. More...

void	splitBoundaryCrossingWires ()
	splits any wires that cross group boundaries More...

void	normaliseGroupRefs (const std::shared_ptr< Group > &self)
	fix up subgroup pointers self is a shared pointer ref to this More...

void	flipContents ()
	rotate all conatined items by 180 degrees More...

std::vector< std::string >	accessibleVars () const
	return a list of existing variables a variable in this group could be connected to More...

std::vector< std::string >	bookmarkList ()
	returns list of bookmark names for populating menu More...

void	addBookmarkXY (float dx, float dy, const std::string &name)

void	addBookmark (const std::string &name)

void	deleteBookmark (std::size_t i)

void	gotoBookmark_b (const Bookmark &b)

void	gotoBookmark (std::size_t i)

std::string	defaultExtension () const
	return default extension for this group - .mky if no ravels in group, .rvl otherwise More...

void	autoLayout ()
	automatically lay out items in this group using a graph layout algorithm More...

void	randomLayout ()
	randomly lay out items in this group More...

std::vector< Summary >	summariseGodleys () const
	produce a summary of godley table variables More...

void	renameAllInstances (const std::string &valueId, const std::string &newName)
	rename all instances of a variable matching valueId to newName More...

ItemPtr	addItem (Item *it, bool inSchema=false)
	add item, ownership is passed More...

virtual ItemPtr	addItem (const std::shared_ptr< Item > &, bool inSchema=false)

Public Member Functions inherited from minsky::ItemT< Group >
std::string	classType () const override

ItemT *	clone () const override

void	TCL_obj (classdesc::TCL_obj_t &t, const std::string &d) override

void	RESTProcess (classdesc::RESTProcess_t &rp, const std::string &d) override
	dummy template definition for use with gui executable More...

void	RESTProcess (classdesc::RESTProcess_t &rp, const std::string &d) const override

void	json_pack (classdesc::json_pack_t &j) const override

	ItemT ()=default

	ItemT (const ItemT &)=default

	ItemT (ItemT &&)=delete

ItemT &	operator= (const ItemT &)=default

ItemT &	operator= (ItemT &&)=delete

Public Member Functions inherited from minsky::Item
	Item ()

virtual std::weak_ptr< Port >	ports (std::size_t i) const
	callback to be run when item deleted from group More...

std::size_t	portsSize () const
	number of ports More...

float	portX (std::size_t i)

float	portY (std::size_t i)

virtual bool	contains (float xx, float yy) const

bool	contains (const Point &p) const

void	updateBoundingBox () override

void	throw_error (const std::string &) const
	mark item on canvas, then throw More...

virtual bool	ioVar () const
	indicates this is a group I/O variable More...

virtual double	value () const
	current value of output port More...

double	rotation () const

double	rotation (const double &r)

std::pair< double, bool >	rotationAsRadians () const
	return the rotation as radians, and whether rotation should have additional straight angle added for text that stays upright. More...

float	iWidth () const

float	iWidth (const float &w)

float	iHeight () const

float	iHeight (const float &h)

virtual void	flip ()
	rotate icon though 180∘ More...

std::string	id () const
	return an id uniquely identifying this item More...

virtual float	x () const

virtual float	y () const

virtual float	zoomFactor () const

void	ensureBBValid () const

float	width () const

float	height () const

virtual std::vector< Point >	corners () const

float	left () const

float	right () const

float	top () const

float	bottom () const

std::string	bookmarkId () const
	Id of bookmark associated with this. More...

void	adjustBookmark () const override
	adjust bookmark list to reflect current configuration More...

float	resizeHandleSize () const
	resize handles should be at least a percentage if the icon size (#1025) More...

virtual bool	onResizeHandle (float x, float y) const

virtual bool	inItem (float x, float y) const

virtual bool	onItem (float x, float y) const
	returns true if (x,y) is on the icon More...

virtual void	onMouseDown (float x, float y)
	respond to mouse down events More...

virtual void	onMouseUp (float x, float y)
	respond to mouse up events More...

virtual bool	onMouseMotion (float x, float y)
	respond to mouse motion events with button pressed More...

virtual bool	onMouseOver (float x, float y)
	respond to mouse motion events (hover) without button pressed More...

virtual void	onMouseLeave ()
	respond to mouse leave events (when mouse leaves item) More...

virtual bool	onKeyPress (int keySym, const std::string &utf8, int state)
	respond to key press events More...

virtual bool	visible () const
	whether this item is visible on the canvas. More...

void	moveTo (float x, float y)

virtual float	scaleFactor () const
	factor by which item has been resized More...

virtual float	scaleFactor (const float &sf)

void	dummyDraw () const
	draw into a dummy cairo context, for purposes of calculating port positions More...

virtual void	displayTooltip (cairo_t *, const std::string &) const
	display tooltip text, eg on mouseover More...

virtual void	updateIcon (double t)
	update display after a step() More...

	Item (const Item &)=default

Item &	operator= (const Item &)=default

virtual	~Item ()

void	drawPorts (cairo_t *cairo) const

virtual void	drawResizeHandles (cairo_t *cairo) const

virtual std::shared_ptr< Port >	closestOutPort (float x, float y) const
	returns closest output port to x,y More...

virtual std::shared_ptr< Port >	closestInPort (float x, float y) const

void	RESTProcess (classdesc::RESTProcess_t &rp, const std::string &d) override
	runs the RESTProcess descriptor suitable for this type More...

void	RESTProcess (classdesc::RESTProcess_t &rp, const std::string &d) const override

virtual void	displayDelayedTooltip (float x, float y)
	enable extended tooltip help message appropriate for mouse at (x,y) More...

virtual void	disableDelayedTooltip ()

virtual bool	editorMode () const
	some items have an editor mode attribute More...

virtual void	toggleEditorMode ()

virtual Units	units (bool check=false) const
	compute the dimensional units More...

Units	checkUnits () const
	perform units consistency checks More...

ItemPtr	itemPtrFromThis () const
	return a shared_ptr to this More...

virtual void	destroyFrame ()
	destroy any popup windows associated with this More...

Public Member Functions inherited from minsky::NoteBase
virtual std::string const &	detailedText () const

virtual std::string const &	detailedText (const std::string &x)

virtual std::string const &	tooltip () const

virtual std::string const &	tooltip (const std::string &x)

virtual	~NoteBase ()=default

Public Member Functions inherited from minsky::GroupItems
	GroupItems ()

virtual	~GroupItems ()

	GroupItems (const GroupItems &x)

GroupItems &	operator= (const GroupItems &)

void	clear ()

bool	empty () const

template<class M , class C >
const M::value_type	findAny (M GroupItems::*map, C c) const
	search for the first item in the heirarchy of map for which c is true. M::value_type must evaluate in a boolean environment to false if not valid C is of signature bool(M::value_type) More...

template<class R , class M , class C , class X >
std::vector< R >	findAll (C c, M(GroupItems::*m), X xfm) const
	finds all items/wires matching criterion c. Found items are transformed by xfm More...

WirePtr	removeWire (const Wire &)

GroupPtr	removeGroup (const Group &)

ItemPtr	findItem (const Item &it) const
	finds item within this group or subgroups. Returns null if not found More...

GroupPtr	findGroup (const Group &it) const
	finds group within this group or subgroups. Returns null if not found More...

WirePtr	findWire (const Wire &it) const
	finds wire within this group or subgroups. Returns null if not found More...

template<class C >
std::vector< ItemPtr >	findItems (C c) const
	returns list of items matching criterion c More...

template<class C >
std::vector< WirePtr >	findWires (C c) const
	returns list of wires matching criterion c More...

template<class C >
std::vector< GroupPtr >	findGroups (C c) const
	returns list of groups matching criterion c More...

ItemPtr	addItem (Item *it, bool inSchema=false)
	add item, ownership is passed More...

ItemPtr	removeItem (const Item &)

GroupPtr	addGroup (const std::shared_ptr< Group > &)

GroupPtr	addGroup (Group *g)

WirePtr	addWire (const Item &from, const Item &to, unsigned toPortIdx)
	add a wire from item from, to item to, connecting to the toIdx port of to More...

WirePtr	addWire (const std::shared_ptr< Wire > &)

WirePtr	addWire (Wire *w)

WirePtr	addWire (const std::weak_ptr< Port > &from, const std::weak_ptr< Port > &to)

std::size_t	numItems () const
	total number of items in this and child groups More...

std::size_t	numWires () const
	total number of wires in this and child groups More...

std::size_t	numGroups () const
	total number of groups in this and child groups More...

void	removeDisplayPlot ()
	remove the display plot More...

template<class M , class O >
bool	recursiveDo (M GroupItems::*map, O op) const
	Perform action heirarchically on elements of map map. If op returns true, the operation terminates. returns true if operation terminates early, false if every element processed. O has signature bool(M, M::const_iterator) More...

template<class M , class O >
bool	recursiveDo (M GroupItems::*map, O op)
	O has signature bool(M&, M::iterator) More...

Public Attributes
std::string	title

float	displayZoom {1}
	computes the zoom at which to show contents, given current contentBounds and width More...

float	relZoom {1}
	relative zoom contents of this group are displayed at More...

Public Attributes inherited from minsky::Item
float	m_x =0

float	m_y =0
	position in canvas, or within group More...

float	m_sf =1
	scale factor of item on canvas, or within group More...

bool	onResizeHandles =false
	set to true to indicate mouse is ovcaler resize handles More...

bool	onBorder =false
	true to indicate mouse hovering over border More...

std::string	deleteCallback

BoundingBox	bb
	canvas bounding box. More...

Public Attributes inherited from minsky::NoteBase
bool	mouseFocus =false
	true if target of a mouseover More...

bool	selected =false
	true if selected for cut, copy or group operation More...

bool	bookmark =false
	Is this item also a bookmark? More...

Public Attributes inherited from minsky::GroupItems
Items	items

Groups	groups

Wires	wires

std::set< Bookmark >	bookmarks

std::vector< VariablePtr >	inVariables

std::vector< VariablePtr >	outVariables

std::vector< VariablePtr >	createdIOvariables

classdesc::Exclude< std::weak_ptr< Group > >	self
	weak ref to this More...

classdesc::Exclude< std::shared_ptr< PlotWidget > >	displayPlot
	plot widget used for group icon More...

Static Public Attributes
static SVGRenderer	svgRenderer

Protected Member Functions
const Group *	minimalEnclosingGroup (float x0, float y0, float x1, float y1, const Item *ignore=nullptr) const
	returns the smallest group whose icon completely encloses the rectangle given by the argument. If no candidate group found, returns nullptr. Weak reference returned, no ownership. More...

Group *	minimalEnclosingGroup (float x0, float y0, float x1, float y1, const Item *ignore=nullptr)

float	contentBounds (double &x0, double &y0, double &x1, double &y1) const
	return bounding box coordinates for all variables, operators etc in this group. Returns the zoom scale (aka local zoom) of the contained items, or 1 if the group is empty. More...

Protected Member Functions inherited from minsky::GroupItems
WirePtr	addWire (const Item &from, const Item &to, unsigned toPortIdx, const std::vector< float > &coords)
	add a wire from item from, to item to, connecting to the toIdx port of to, with coordinates More...

WirePtr	addWire (const std::weak_ptr< Port > &from, const std::weak_ptr< Port > &to, const std::vector< float > &coords)

void	renameVar (const GroupPtr &origGroup, VariableBase &v)
	rename variable so that it maintains most general scope possible More...

	CLASSDESC_ACCESS (GroupItems)

Private Member Functions
VariablePtr	addIOVar (const char *)

Private Attributes
bool	m_displayContentsChanged =true

Friends
class	Canvas

Additional Inherited Members
Static Public Member Functions inherited from minsky::Item
static void	drawSelected (cairo_t *cairo)

Static Public Member Functions inherited from minsky::GroupItems
static void	adjustWiresGroup (Wire &w)
	adjust wire's group to be the least common ancestor of its ports More...

Static Protected Member Functions inherited from minsky::Item
static void	drawResizeHandle (cairo_t *cairo, double x, double y, double sf, double angle)

Protected Attributes inherited from minsky::Item
double	m_width =10

double	m_height =10

ItemPortVector	m_ports

minsky::Item::MemoisedRotator	memoisedRotator

Detailed Description

Definition at line 220 of file group.h.

Constructor & Destructor Documentation

◆ Group()

minsky::Group::Group ( )

inline

Definition at line 249 of file group.h.

References minsky::Item::iHeight(), and minsky::Item::iWidth().

249 {iWidth(100); iHeight(100);}

minsky::Item::iHeight

float iHeight() const

Definition: item.h:224

minsky::Item::iWidth

float iWidth() const

Definition: item.h:217

Here is the call graph for this function:

Member Function Documentation

◆ accessibleVars()

vector< string > minsky::Group::accessibleVars ( ) const

return a list of existing variables a variable in this group could be connected to

Definition at line 1221 of file group.cc.

 {
   set<string> r;
   // first add local variables
   for (auto& i: items)
     if (auto v=i->variableCast())
       r.insert(v->name());
   // now add variables in outer scopes, ensuring they qualified
   auto g=this;
   for (g=g->group.lock().get(); g;  g=g->group.lock().get())
     for (auto& i: g->items)
       if (auto v=i->variableCast())
         {
           auto n=v->name();
           if (n[0]==':')
             r.insert(n);
           else
             r.insert(':'+n);
         }
 
   return vector<string>(r.begin(),r.end());
 }

◆ addBookmark()

void minsky::Group::addBookmark ( const std::string & name )

inline

Definition at line 407 of file group.h.

References addBookmarkXY(), and name().

407 {addBookmarkXY(0,0,name);}

minsky::Group::name

std::string name() const override

Definition: group.h:241

minsky::Group::addBookmarkXY

void addBookmarkXY(float dx, float dy, const std::string &name)

Definition: group.h:403

Here is the call graph for this function:

◆ addBookmarkXY()

void minsky::Group::addBookmarkXY	(	float	dx,
		float	dy,
		const std::string &	name
	)

inline

Definition at line 403 of file group.h.

References minsky::GroupItems::bookmarks, name(), relZoom, minsky::Item::x(), minsky::Item::y(), and minsky::Item::zoomFactor().

Referenced by addBookmark(), and addItem().

                                                                   {
       bookmarks.erase(Bookmark{0,0,0,name});
       bookmarks.emplace(x()-dx, y()-dy, relZoom*zoomFactor(), name);
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addInputVar()

void minsky::Group::addInputVar ( )

inline

Definition at line 294 of file group.h.

References addIOVar(), and minsky::GroupItems::inVariables.

294 {inVariables.push_back(addIOVar("input"));}

minsky::GroupItems::inVariables

std::vector< VariablePtr > inVariables

Definition: group.h:82

minsky::Group::addIOVar

VariablePtr addIOVar(const char *)

Definition: group.cc:519

Here is the call graph for this function:

◆ addIOVar()

VariablePtr minsky::Group::addIOVar ( const char * prefix )

private

Definition at line 519 of file group.cc.

References minsky::cminsky(), minsky::to_string(), and minsky::uqName().

Referenced by addInputVar(), and addOutputVar().

   {
     const VariablePtr v(VariableType::flow,
                   uqName(cminsky().variableValues.newName(to_string(size_t(this))+":"+prefix)));
     addItem(v,true);
     createdIOvariables.push_back(v);
     v->rotation(rotation());
     v->controller=self;
     bb.update(*this);
     return v;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addItem() [1/3]

ItemPtr minsky::GroupItems::addItem

add item.

Parameters

inSchema - if building a group from schema processing, rather than generally. Does not adjust item position within group if true.

Definition at line 331 of file group.cc.

   {
     if (!it) return it;
     minsky().bookmarkRefresh();
     if (auto x=dynamic_pointer_cast<Group>(it))
       return addGroup(x);
    
     // stash position
     const float x=it->x(), y=it->y();
     auto origGroup=it->group.lock();
 
     if (origGroup.get()==this) return it; // nothing to do.
     if (origGroup)
       origGroup->removeItem(*it);
 
     // stash init value to initialise new variableValue
     string init;
     string units;
     if (auto v=it->variableCast())
       {
         init=v->init();
         units=v->unitsStr();
       }
     
     it->group=self;
     if (!inSchema) it->moveTo(x,y);
 
     // take into account new scope
     if (auto v=it->variableCast())
       {
         if (!inSchema && origGroup)
           renameVar(origGroup, *v);
         v->init(init); //NB calls ensureValueExists()
         // if value didn't exist before, units will be empty. Do not overwrite any previous units set. For #1461.
         if (units.length()) v->setUnits(units);
       }
      
     // move wire to highest common group
     for (size_t i=0; i<it->portsSize(); ++i)
       {
         auto p=it->ports(i).lock();
         assert(p);
         for (auto& w: p->wires())
           {
             assert(w);
             adjustWiresGroup(*w);
           }
       }
 
     // need to deal with integrals especially because of the attached variable
     if (auto intOp=dynamic_cast<IntOp*>(it.get()))
       if (intOp->intVar)
         {
           if (!inSchema && origGroup)
             renameVar(origGroup, *intOp->intVar);
           if (auto oldG=intOp->intVar->group.lock())
            {
                  
              if (oldG.get()!=this)
                addItem(oldG->removeItem(*intOp->intVar),inSchema);
            }
           else
             addItem(intOp->intVar,inSchema);
           if (intOp->coupled())
             intOp->intVar->controller=it;
           else
             intOp->intVar->controller.reset();
         }
          
     items.push_back(it);
     return items.back();
   }

◆ addItem() [2/3]

ItemPtr minsky::GroupItems::addItem

inline

add item, ownership is passed

Definition at line 165 of file group.h.

165 {return addItem(std::shared_ptr<Item>(it),inSchema);}

minsky::Group::addItem

ItemPtr addItem(const std::shared_ptr< Item > &it, bool inSchema=false) override

Definition: group.h:262

◆ addItem() [3/3]

ItemPtr minsky::Group::addItem	(	const std::shared_ptr< Item > &	it,
		bool	inSchema = `false`
	)

inlineoverridevirtual

add item.

Parameters

inSchema - if building a group from schema processing, rather than generally. Does not adjust item position within group if true.

Reimplemented from minsky::GroupItems.

Definition at line 262 of file group.h.

References addBookmarkXY(), and minsky::GroupItems::addItem().

Referenced by schema3::Minsky::populateGroup().

     {
       if (it && it->bookmark)
         addBookmarkXY(it->left(),it->top(),it->bookmarkId());
       return GroupItems::addItem(it,inSchema);
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addOutputVar()

void minsky::Group::addOutputVar ( )

inline

Definition at line 295 of file group.h.

References addIOVar(), and minsky::GroupItems::outVariables.

295 {outVariables.push_back(addIOVar("output"));}

minsky::GroupItems::outVariables

std::vector< VariablePtr > outVariables

Definition: group.h:82

minsky::Group::addIOVar

VariablePtr addIOVar(const char *)

Definition: group.cc:519

Here is the call graph for this function:

◆ arguments()

string minsky::Group::arguments ( ) const

argument declaration, to be appended to name() for function declaration

Definition at line 88 of file group.cc.

References MathDAG::SystemOfEquations::getNodeFromVar(), and pyminsky::minsky.

   {
     MathDAG::SystemOfEquations system(minsky(), *this);
     ostringstream r;
     r<<"(";
     for (auto& i: inVariables)
       if (!i->inputWired())
         {
           if (r.str().size()>1) r<<",";
           if (auto node=system.getNodeFromVar(*i))
             node->matlab(r);
         }
     r<<")";
     return r.str();
   }

Here is the call graph for this function:

◆ autoLayout()

void minsky::Group::autoLayout ( )

automatically lay out items in this group using a graph layout algorithm

Definition at line 1259 of file group.cc.

References minsky::layoutGroup(), and pyminsky::minsky.

   {
     const BusyCursor busy(minsky());
     layoutGroup(*this);
   }

Here is the call graph for this function:

◆ bookmarkList()

std::vector<std::string> minsky::Group::bookmarkList ( )

inline

returns list of bookmark names for populating menu

Definition at line 398 of file group.h.

References minsky::GroupItems::bookmarks.

                                         {
       std::vector<std::string> r;
       for (auto& b: bookmarks) r.push_back(b.name);
       return r;
     }

◆ cBounds()

ecolab::array<double> minsky::Group::cBounds ( ) const

inline

for TCL debugging

Definition at line 369 of file group.h.

References contentBounds().

                                         {
       ecolab::array<double> r(4);
       contentBounds(r[0],r[1],r[2],r[3]);
       return r;
     }

Here is the call graph for this function:

◆ checkAddIORegion()

void minsky::Group::checkAddIORegion ( const ItemPtr & x )

check if item is a variable and located in an I/O region, and add it if it is

Definition at line 550 of file group.cc.

   {
     if (auto v=dynamic_pointer_cast<VariableBase>(x))
       {
         remove(inVariables, v);
         remove(outVariables, v);
         switch (inIORegion(v->x(),v->y()))
           {
           case IORegion::input:
             inVariables.push_back(v);
             v->controller=self;
             break;
           case IORegion::output:
             outVariables.push_back(v);
             v->controller=self;
             break;
           default:
             v->controller.reset();
             break;
           }
       }
   }

◆ clickType()

ClickType::Type minsky::Group::clickType	(	float	x,
		float	y
	)		const

overridevirtual

returns the clicktype given a mouse click at x, y.

Reimplemented from minsky::Item.

Definition at line 910 of file group.cc.

References topMargin.

   {
     auto z=zoomFactor();
     const double w=0.5*iWidth()*z, h=0.5*iHeight()*z;
     if (onResizeHandle(x,y)) return ClickType::onResize;         
     if (displayContents() && inIORegion(x,y)==IORegion::none)
       return ClickType::outside;
     if (auto item=select(x,y))
       return item->clickType(x,y);
     if ((abs(x-this->x())<w && abs(y-this->y())<h+topMargin*z)) // check also if (x,y) is within top and bottom margins of group. for feature 88
       return ClickType::onItem;
     return ClickType::outside;
   }

◆ clone()

Group* minsky::Group::clone ( ) const

inlineoverridevirtual

Reimplemented from minsky::Item.

Definition at line 258 of file group.h.

258 {throw error("Groups cannot be cloned");}

◆ computeDisplayZoom()

float minsky::Group::computeDisplayZoom ( )

Definition at line 824 of file group.cc.

References f.

   {
     double x0, x1, y0, y1;
     const float z=zoomFactor();    
     const float lz=contentBounds(x0,y0,x1,y1);
     x0=min(x0,double(x()));
     x1=max(x1,double(x()));
     y0=min(y0,double(y()));
     y1=max(y1,double(y()));
     // first compute the value assuming margins are of zero width
     displayZoom = 2*max( max(x1-x(), x()-x0)/(iWidth()*z), max(y1-y(), y()-y0)/(iHeight()*z));
 
     // account for shrinking margins
     const float readjust=zoomFactor()/edgeScale() / (displayZoom>1? displayZoom:1);
     float l, r;    
     margins(l,r);
     l*=readjust; r*=readjust;    
     displayZoom = max(displayZoom, 
                   float(max((x1-x())/(0.5f*iWidth()*z-r), (x()-x0)/(0.5f*iWidth()*z-l))));
   
     displayZoom*=1.1*rotFactor()/lz;
 
     // displayZoom should never be less than 1
     displayZoom=max(displayZoom, 1.0f);
     return displayZoom;
   }

◆ computeRelZoom()

void minsky::Group::computeRelZoom ( )

Definition at line 851 of file group.cc.

   {
     double x0, x1, y0, y1;
     const double z=zoomFactor();
     relZoom=1;
     contentBounds(x0,y0,x1,y1);
     float l, r;
     margins(l,r);    
     const double dx=x1-x0, dy=y1-y0;
     if (width()-l-r>0 && dx>0 && dy>0)
       relZoom=std::min(1.0, std::min((width()-l-r)/(dx), (height()-20*z)/(dy))); 
   }

◆ contentBounds()

float minsky::Group::contentBounds	(	double &	x0,
		double &	y0,
		double &	x1,
		double &	y1
	)		const

protected

return bounding box coordinates for all variables, operators etc in this group. Returns the zoom scale (aka local zoom) of the contained items, or 1 if the group is empty.

Definition at line 759 of file group.cc.

Referenced by cBounds().

   {
     const float localZoom=1;
     x0=numeric_limits<float>::max();
     x1=-numeric_limits<float>::max();
     y0=numeric_limits<float>::max();
     y1=-numeric_limits<float>::max();
 
     for (auto& i: items)
       if (!i->ioVar())
         {
           if (i->left()<x0) x0=i->left();
           if (i->right()>x1) x1=i->right();
           if (i->top()<y0) y0=i->top();
           if (i->bottom()>y1) y1=i->bottom();
         }               
                           
     for (auto& i: groups)
       if (i->displayContents())
         {
           double left, top, right, bottom;
           i->contentBounds(left,top,right,bottom);
           if (left<x0) x0=left;
           if (right>x1) x1=right;
           if (top<y0) y0=top;
           if (bottom>y1) y1=bottom;
         }
       else
         {
           if (i->left()<x0) x0=i->left();
           if (i->right()>x1) x1=i->right();
           if (i->top()<y0) y0=i->top();
           if (i->bottom()>y1) y1=i->bottom();
         }
    
     // if there are no contents, result is not finite. In this case,
     // set the content bounds to a 10x10 sized box around the centroid of the I/O variables.
     if (x0==numeric_limits<float>::max())
       {
         float cx=0, cy=0;
         for (auto& i: inVariables)
           {
             cx+=i->x();
             cy+=i->y();
           }
         for (auto& i: outVariables)
           {
             cx+=i->x();
             cy+=i->y();
           }
         const int n=inVariables.size()+outVariables.size();
         if (n>0)
           {
             cx/=n;
             cy/=n;
           }
         x0=cx-10;
         x1=cx+10;
         y0=cy-10;
         y1=cy+10;
       }
 
     return localZoom;
   }

Here is the caller graph for this function:

◆ copy()

GroupPtr minsky::Group::copy ( ) const

Make a copy of this as a sibling group (owned by parent). Attempting to copying minsky.model is a null operation.

Definition at line 121 of file group.cc.

   {
     // make new group owned by the top level group to prevent
     if (auto g=group.lock())
       return g->addGroup(copyUnowned());
     return GroupPtr(); // do nothing if we attempt to clone the entire model
   }

◆ copyUnowned()

GroupPtr minsky::Group::copyUnowned ( ) const

make a copy of this, that is not owned by any group

Definition at line 129 of file group.cc.

References minsky::asgClonedPort(), and f.

   {
     auto r=make_shared<Group>();
     r->self=r;
     r->moveTo(x(),y());
     // make new group owned by the top level group to prevent snarlups when called recursively
     if (group.lock())
       const_cast<Group*>(this)->globalGroup().addGroup(r);
     else
       return GroupPtr(); // do nothing if we attempt to clone the entire model
   
     // a map of original to cloned items (weak references)
     map<Item*,ItemPtr> cloneMap;
     map<IntOp*,bool> integrals;
     // cloning IntOps mutates items, as intVars get inserted and removed
     auto itemsCopy=items;
     for (auto& i: itemsCopy)
       if (auto integ=dynamic_cast<IntOp*>(i.get()))
         integrals.emplace(integ, integ->coupled());
     for (auto& i: itemsCopy)
       cloneMap[i.get()]=r->addItem(i->clone(),true);
     for (auto& i: groups)
       cloneMap[i.get()]=r->addGroup(i->copyUnowned());
     for (auto& w: wires) 
       {
         auto f=w->from(), t=w->to();
         asgClonedPort(f,cloneMap);
         asgClonedPort(t,cloneMap);
         r->addWire(new Wire(f,t,w->coords()));
       }
   
     for (auto& v: inVariables)
       {
         assert(cloneMap.count(v.get()));
         r->inVariables.push_back(dynamic_pointer_cast<VariableBase>(cloneMap[v.get()]));
         r->inVariables.back()->controller=self;
       }
     for (auto& v: outVariables)
       {
         assert(cloneMap.count(v.get()));
         r->outVariables.push_back(dynamic_pointer_cast<VariableBase>(cloneMap[v.get()]));
         r->outVariables.back()->controller=self;
       }
     // reattach integral variables to their cloned counterparts
     for (auto i: integrals)
       {
         if (auto newIntegral=dynamic_cast<IntOp*>(cloneMap[i.first].get()))
           {
             auto newIntVar=dynamic_pointer_cast<VariableBase>(cloneMap[i.first->intVar.get()]);
             if (newIntVar && newIntegral->intVar != newIntVar)
               {
                 r->removeItem(*newIntegral->intVar);
                 newIntegral->intVar=newIntVar;
               }
             if (i.second != newIntegral->coupled())
               newIntegral->toggleCoupled();
           }
       }
     r->computeRelZoom();
     return r;
   }

Here is the call graph for this function:

◆ defaultExtension()

std::string minsky::Group::defaultExtension ( ) const

return default extension for this group - .mky if no ravels in group, .rvl otherwise

Definition at line 1252 of file group.cc.

   {
     if (findAny(&GroupItems::items, [](const ItemPtr& i){return dynamic_cast<Ravel*>(i.get());}))
       return ".rvl";
     return ".mky";
   }

◆ deleteAttachedWires()

void minsky::Group::deleteAttachedWires ( )

inlineoverridevirtual

delete all attached wires

Reimplemented from minsky::Item.

Definition at line 300 of file group.h.

References minsky::GroupItems::inVariables, and minsky::GroupItems::outVariables.

                                         {
       for (auto& i: inVariables) i->deleteAttachedWires();
       for (auto& i: outVariables) i->deleteAttachedWires();
     }

◆ deleteBookmark()

void minsky::Group::deleteBookmark ( std::size_t i )

inline

Definition at line 408 of file group.h.

References minsky::GroupItems::bookmarks.

                                      {
       if (i<bookmarks.size())
         {
           auto j=bookmarks.begin();
           std::advance(j, i);
           bookmarks.erase(j);
         }
     }

◆ deleteItem()

void minsky::Group::deleteItem ( const Item & i )

remove item from group, and also all attached wires.

Definition at line 247 of file group.cc.

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

   {
     if (auto r=removeItem(i))
       {
         r->deleteAttachedWires();
         r->removeControlledItems();
         minsky().runItemDeletedCallback(*r);
         minsky().bookmarkRefresh();
       }
   }

Here is the call graph for this function:

◆ displayContents()

bool minsky::Group::displayContents ( ) const

inline

returns whether contents should be displayed. Top level group always displayed

Definition at line 332 of file group.h.

References relZoom, and minsky::Item::zoomFactor().

Referenced by localZoom().

332 {return !group.lock() || zoomFactor()*relZoom>1;}

minsky::Group::relZoom

float relZoom

relative zoom contents of this group are displayed at

Definition: group.h:348

minsky::Item::zoomFactor

virtual float zoomFactor() const

Definition: item.cc:121

group

Definition: group.tcl:84

Here is the call graph for this function:

Here is the caller graph for this function:

◆ displayContentsChanged()

bool minsky::Group::displayContentsChanged ( ) const

inline

true if displayContents status changed on this or any contained group last zoom

Definition at line 335 of file group.h.

References m_displayContentsChanged.

335 {return m_displayContentsChanged;}

minsky::Group::m_displayContentsChanged

bool m_displayContentsChanged

Definition: group.h:222

◆ draw()

void minsky::Group::draw ( cairo_t * cairo ) const

overridevirtual

draw this item into a cairo context

Reimplemented from minsky::Item.

Definition at line 924 of file group.cc.

References minsky::flipped(), M_PI, and topMargin.

   {
     auto [angle,flipped]=rotationAsRadians();
 
     // determine how big the group icon should be to allow
     // sufficient space around the side for the edge variables
     float leftMargin, rightMargin;
     margins(leftMargin, rightMargin);    
     const float z=zoomFactor();
 
     const unsigned width=z*this->iWidth(), height=z*this->iHeight();
     const cairo::CairoSave cs(cairo);
     cairo_rotate(cairo,angle);
 
     // In docker environments, something invisible gets drawn outside
     // the horizontal dimensions, stuffing up the bb.width()
     // calculation, and then causing the groupResize test to
     // fail. This extra clip path fixes the problem.
     cairo_rectangle(cairo,-0.5*width,-0.5*height-topMargin*z, width, height+2*topMargin*z);
     cairo_clip(cairo);
 
     // draw default group icon
 
     // display I/O region in grey
     drawIORegion(cairo);
 
     {
       const cairo::CairoSave cs(cairo);
       cairo_translate(cairo, -0.5*width+leftMargin, -0.5*height);
 
               
       const double scalex=double(width-leftMargin-rightMargin)/width;
       cairo_scale(cairo, scalex, 1);
       
       // draw a simple frame 
       cairo_rectangle(cairo,0,0,width,height);
       {
         const cairo::CairoSave cs(cairo);
         cairo_identity_matrix(cairo);
         cairo_set_line_width(cairo,1);
         cairo_stroke(cairo);
       }
 
       if (!displayContents())
         {
           if (displayPlot)
             {
               const cairo::CairoSave cs(cairo);
               if (flipped)
                 {
                   cairo_translate(cairo,width,height);
                   cairo_rotate(cairo,M_PI);  // rotate plot to keep it right way up.
                 }
               // propagate plot type to underling ecolab::Plot
               auto& pt=const_cast<Plot*>(static_cast<const Plot*>(displayPlot.get()))->plotType;
               switch (displayPlot->plotType)
                 {
                 case PlotWidget::line: pt=Plot::line; break;
                 case PlotWidget::bar:  pt=Plot::bar;  break;
                 default: break;
                 }
               displayPlot->Plot::draw(cairo, width, height);
             }
           else
             {
               cairo_scale(cairo,width/svgRenderer.width(),height/svgRenderer.height());
               cairo_rectangle(cairo,0, 0,svgRenderer.width(), svgRenderer.height());
               cairo_clip(cairo);
               svgRenderer.render(cairo);
             }
         }
     }
 
     drawEdgeVariables(cairo);
 
 
     // display text label
     if (!title.empty())
       {
         const cairo::CairoSave cs(cairo);
         cairo_scale(cairo, z, z);
         cairo_select_font_face
           (cairo, "sans-serif", CAIRO_FONT_SLANT_ITALIC, 
            CAIRO_FONT_WEIGHT_NORMAL);
         cairo_set_font_size(cairo,12);
               
         // extract the bounding box of the text
         cairo_text_extents_t bbox;
         cairo_text_extents(cairo,title.c_str(),&bbox);       
         const double w=0.5*bbox.width+2; 
         const double h=0.5*bbox.height+5;
 
         // if rotation is in 1st or 3rd quadrant, rotate as
         // normal, otherwise flip the text so it reads L->R
         if (flipped)
           cairo_rotate(cairo, M_PI);
 
         // prepare a background for the text, partially obscuring graphic
         const double transparency=displayContents()? 0.25: 1;
 
         // display text
         cairo_move_to(cairo, -w+1, h-12-0.5*(height)/z);
         cairo_set_source_rgba(cairo,0,0,0,transparency);
         cairo_show_text(cairo,title.c_str());
       }
 
     if (mouseFocus)
       {
         displayTooltip(cairo,tooltip());
         // Resize handles always visible on mousefocus. For ticket 92.
         drawResizeHandles(cairo);
       }
 
     cairo_rectangle(cairo,-0.5*width,-0.5*height,width,height);
     cairo_clip(cairo);
     if (selected)
       drawSelected(cairo);
     
   }

Here is the call graph for this function:

◆ draw1edge()

void minsky::Group::draw1edge	(	const std::vector< VariablePtr > &	vars,
		cairo_t *	cairo,
		float	x
	)		const

draw the variables of one of the edges

Definition at line 1044 of file group.cc.

References M_PI, minsky::Rotate::x(), and minsky::Rotate::y().

   {
     float top=0, bottom=0;
     const double angle=rotation() * M_PI / 180.0;
     for (size_t i=0; i<vars.size(); ++i)
       {
         const Rotate r(rotation(),0,0);
         auto& v=vars[i];
         float y=0;
         auto z=v->zoomFactor();
         auto t=v->bb.top()*z, b=v->bb.bottom()*z;
         if (i>0) y = i%2? top-b: bottom-t;
         v->moveTo(r.x(x,y)+this->x(), r.y(x,y)+this->y());
         const cairo::CairoSave cs(cairo);
         cairo_translate(cairo,x,y);
         // cairo context is already rotated, so antirotate
         cairo_rotate(cairo,-angle);
         v->rotation(rotation()); 
         v->draw(cairo);
         if (i==0)
           {
             bottom=b;
             top=t;
           }
         else if (i%2)
           top-=v->height();
         else
           bottom+=v->height();
       }
   }

Here is the call graph for this function:

◆ drawEdgeVariables()

void minsky::Group::drawEdgeVariables ( cairo_t * cairo ) const

draw representations of edge variables around group icon

Definition at line 1076 of file group.cc.

   {
     float left, right; margins(left,right);    
     const cairo::CairoSave cs(cairo);
     const float z=zoomFactor();
     draw1edge(inVariables, cairo, -0.5*(iWidth()*z-left));
     draw1edge(outVariables, cairo, 0.5*(iWidth()*z-right));
   }

◆ drawIORegion()

void minsky::Group::drawIORegion ( cairo_t * cairo ) const

draw notches in the I/O region to indicate dockability of variables there

Definition at line 1105 of file group.cc.

References minsky::anonymous_namespace{group.cc}::notchY(), and topMargin.

   {
     const cairo::CairoSave cs(cairo);
     float left, right; 
     margins(left,right);
     const float z=zoomFactor();
     float y=notchY(inVariables), dy=topMargin*edgeScale();
     cairo_set_source_rgba(cairo,0,1,1,0.5);
     const float w=0.5*z*iWidth(), h=0.5*z*iHeight();
     
     cairo_move_to(cairo,-w,-h);
     // create notch in input region
     cairo_line_to(cairo,-w,y-dy);
     cairo_line_to(cairo,left-w-4*z,y-dy);
     cairo_line_to(cairo,left-w,y);
     cairo_line_to(cairo,left-w-4*z,y+dy);
     cairo_line_to(cairo,-w,y+dy);
     cairo_line_to(cairo,-w,h);
     cairo_line_to(cairo,left-w,h);
     cairo_line_to(cairo,left-w,-h);
     cairo_close_path(cairo);
     cairo_fill(cairo);
 
     y=notchY(outVariables);
     cairo_move_to(cairo,w,-h);
     // create notch in output region
     cairo_line_to(cairo,w,y-dy);
     cairo_line_to(cairo,w-right-2*z,y-dy);
     cairo_line_to(cairo,w-right+2*z,y);
     cairo_line_to(cairo,w-right-2*z,y+dy);
     cairo_line_to(cairo,w,y+dy);
     cairo_line_to(cairo,w,h);
     cairo_line_to(cairo,w-right,h);
     cairo_line_to(cairo,w-right,-h);
     cairo_close_path(cairo);
     cairo_fill(cairo);
     
     // draw top margin. for feature 88
     cairo_rectangle(cairo,-w,-h,2*w,-topMargin*z);
     cairo_fill(cairo);    
     
     // draw bottom margin. for feature 88
     cairo_rectangle(cairo,-w,h,2*w,topMargin*z);
     cairo_fill(cairo);    
   }

Here is the call graph for this function:

◆ edgeScale()

float minsky::Group::edgeScale ( ) const

inline

scale used to render io variables. Smoothly interpolates between the scale at which internal items are displayed, and the outside zoom factor

Definition at line 363 of file group.h.

References relZoom, and minsky::Item::zoomFactor().

                             {
       float z=zoomFactor();
       return z*relZoom>1? z*relZoom: z>1? 1: z;
     }

Here is the call graph for this function:

◆ flipContents()

void minsky::Group::flipContents ( )

rotate all conatined items by 180 degrees

Definition at line 1207 of file group.cc.

   {
     for (auto& i: items)
       {
         i->moveTo(x()-i->m_x,i->y());
         i->flip();
       }
     for (auto& i: groups)
       {
         i->moveTo(x()-i->m_x,i->y());
         i->flip();
       }
   }

◆ formula()

std::string minsky::Group::formula ( ) const

algebraic formula representing value of first output argument of this group

Definition at line 74 of file group.cc.

References MathDAG::SystemOfEquations::getNodeFromVar(), and pyminsky::minsky.

   {
     if (outVariables.empty()) return "0";
     MathDAG::SystemOfEquations system(minsky(), *this);
     ostringstream o;
     auto node=system.getNodeFromVar(*outVariables[0]);
     if (!node) return "0";
     if (node->rhs)
       node->rhs->matlab(o);
     else
       node->matlab(o);
     return o.str();
   }

Here is the call graph for this function:

◆ globalGroup() [1/2]

const Group & minsky::Group::globalGroup ( ) const

top level group

Definition at line 739 of file group.cc.

References minsky::anonymous_namespace{group.cc}::globalGroup().

Referenced by minsky::Wire::moveIntoGroup().

740 {return minsky::globalGroup(*this);}

minsky::anonymous_namespace{group.cc}::globalGroup

G & globalGroup(G &start)

Definition: group.cc:730

Here is the call graph for this function:

Here is the caller graph for this function:

◆ globalGroup() [2/2]

Group & minsky::Group::globalGroup ( )

Definition at line 741 of file group.cc.

References minsky::anonymous_namespace{group.cc}::globalGroup().

742 {return minsky::globalGroup(*this);}

minsky::anonymous_namespace{group.cc}::globalGroup

G & globalGroup(G &start)

Definition: group.cc:730

Here is the call graph for this function:

◆ gotoBookmark()

void minsky::Group::gotoBookmark ( std::size_t i )

inline

Definition at line 417 of file group.h.

References minsky::GroupItems::bookmarks, and gotoBookmark_b().

                                    {
       if (i<bookmarks.size()) {
           auto j=bookmarks.begin();
           std::advance(j, i);
           gotoBookmark_b(*j);
       }
     }

Here is the call graph for this function:

◆ gotoBookmark_b()

void minsky::Group::gotoBookmark_b ( const Bookmark & b )

Definition at line 1244 of file group.cc.

References minsky::Minsky::canvas, minsky::cminsky(), pyminsky::minsky, minsky::Minsky::model, minsky::Canvas::requestRedraw(), minsky::Bookmark::x, minsky::Bookmark::y, minsky::Bookmark::zoom, and zoom().

Referenced by gotoBookmark(), and minsky::VariableInstanceList::gotoInstance().

   {
     moveTo(b.x, b.y);
     zoom(x(),y(),b.zoom/(relZoom*zoomFactor()));
     // TODO add canvas::gotoBookmark to avoid dependency inversion
     if (this==cminsky().canvas.model.get()) minsky().canvas.requestRedraw();
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ higher()

bool minsky::Group::higher ( const Group & x ) const

returns true if this is higher in the heirarchy than the argument this->higher(*this) is false

Definition at line 712 of file group.cc.

Referenced by moveContents().

   {
     for (auto& i: groups)
       if (i.get()==&x) return true;
     return any_of(groups.begin(), groups.end(), [&](const GroupPtr& i){return i->higher(x);});
   }

Here is the caller graph for this function:

◆ inIORegion()

Group::IORegion::type minsky::Group::inIORegion	(	float	x,
		float	y
	)		const

Definition at line 531 of file group.cc.

References MathDAG::cos(), M_PI, MathDAG::sin(), and topMargin.

   {
     float left, right;
     const float z=zoomFactor();
     margins(left,right);    
     const float dx=(x-this->x())*cos(rotation()*M_PI/180)-
       (y-this->y())*sin(rotation()*M_PI/180);
     const float dy=(x-this->x())*sin(rotation()*M_PI/180)+
       (y-this->y())*cos(rotation()*M_PI/180);      
     const float w=0.5*iWidth()*z,h=0.5*iHeight()*z;
     if (w-right<dx)
       return IORegion::output;
     if (-w+left>dx)
       return IORegion::input;
     if ((-h+topMargin*z>dy && dy<0) || (h-topMargin*z<dy && dy>0))     
       return IORegion::topBottom;  
     return IORegion::none;
   }

Here is the call graph for this function:

◆ level()

unsigned minsky::Group::level ( ) const

return level in the heirarchy

Definition at line 719 of file group.cc.

   {
     assert(nocycles());
     unsigned l=0;
     for (auto i=group.lock(); i; i=i->group.lock()) l++;
     return l;
   }

◆ localZoom()

float minsky::Group::localZoom ( ) const

inline

Definition at line 351 of file group.h.

References displayContents(), displayZoom, and minsky::Item::zoomFactor().

                             {
       return (displayZoom>0 && displayContents())
         ? zoomFactor()/displayZoom: 1;
     }

Here is the call graph for this function:

◆ makeSubroutine()

void minsky::Group::makeSubroutine ( )

Make all variables not present in outerscope local to this group.

Definition at line 191 of file group.cc.

   {
     recursiveDo(&GroupItems::items, [this](Items&,Items::iterator i)
     {
       if (auto v=(*i)->variableCast())
         if (v->rawName()[0]==':')
           {
             // walk up parent groups to see if this variable is mentioned
             for (auto g=group.lock(); g; g=g->group.lock())
               for (auto& item: g->items)
                 if (auto vi=item->variableCast())
                   if (vi->valueId()==v->valueId())
                     goto outer_scope_variable_found;
             v->name(v->rawName().substr(1)); // make variable local
           }
     outer_scope_variable_found:
       return false;
     });
   }

◆ margins()

void minsky::Group::margins	(	float &	left,
		float &	right
	)		const

margin sizes to allow space for edge variables.

Definition at line 1152 of file group.cc.

Referenced by marginsV().

   {
     left=right=10;
     auto tmpMouseFocus=mouseFocus;
     mouseFocus=false; // disable mouseFocus for this calculation
     for (auto& i: inVariables)
       {
         assert(i->type()!=VariableType::undefined);
         i->bb.update(*i);
         if (i->width()>left) left=i->width();
       }
     for (auto& i: outVariables)
       {
         assert(i->type()!=VariableType::undefined);
         i->bb.update(*i);
         if (i->width()>right) right=i->width();
       }
     mouseFocus=tmpMouseFocus;
   }  

Here is the caller graph for this function:

◆ marginsV()

std::vector<float> minsky::Group::marginsV ( ) const

inline

for debugging purposes

Definition at line 341 of file group.h.

References margins().

                                       {
       float l, r; margins(l,r);  return {l,r};
     }    

Here is the call graph for this function:

◆ minimalEnclosingGroup() [1/2]

const Group * minsky::Group::minimalEnclosingGroup	(	float	x0,
		float	y0,
		float	x1,
		float	y1,
		const Item *	ignore = `nullptr`
	)		const

protected

returns the smallest group whose icon completely encloses the rectangle given by the argument. If no candidate group found, returns nullptr. Weak reference returned, no ownership.

Parameters

ignore - do not return group ignore, even if it encloses the rectangle

Definition at line 864 of file group.cc.

Referenced by minimalEnclosingGroup().

   {
     const float z=zoomFactor();
     if (x0<x()-0.5*z*iWidth() || x1>x()+0.5*z*iWidth() ||
         y0<y()-0.5*z*iHeight() || y1>y()+0.5*z*iHeight())
       return nullptr;
     // at this point, this is a candidate. Check if any child groups are also
     for (auto& g: groups)
       if (auto mg=g->minimalEnclosingGroup(x0,y0,x1,y1, ignore))
         if (mg->visible())
           return mg;
     return this!=ignore? this: nullptr;
   }

Here is the caller graph for this function:

◆ minimalEnclosingGroup() [2/2]

Group* minsky::Group::minimalEnclosingGroup	(	float	x0,
		float	y0,
		float	x1,
		float	y1,
		const Item *	ignore = `nullptr`
	)

inlineprotected

Definition at line 230 of file group.h.

References minimalEnclosingGroup().

231 {return const_cast<Group*>(const_cast<const Group*>(this)->minimalEnclosingGroup(x0,y0,x1,y1,ignore));}

minsky::Group::minimalEnclosingGroup

const Group * minimalEnclosingGroup(float x0, float y0, float x1, float y1, const Item *ignore=nullptr) const

returns the smallest group whose icon completely encloses the rectangle given by the argument...

Definition: group.cc:864

minsky::Group::Group

Group()

Definition: group.h:249

Here is the call graph for this function:

◆ moveContents()

void minsky::Group::moveContents ( Group & source )

move all items from source to this

no need to move wires, as these are handled above

Definition at line 499 of file group.cc.

References minsky::GroupItems::clear(), minsky::GroupItems::groups, higher(), and minsky::GroupItems::items.

                                         {
      if (&source!=this)
        {
          if (source.higher(*this))
              throw error("attempt to move a group into itself");
          // make temporary copies as addItem removes originals
          auto copyOfItems=source.items;
          for (auto& i: copyOfItems)
            {
              addItem(i);
              assert(!i->ioVar());
            }
          auto copyOfGroups=source.groups;
          for (auto& i: copyOfGroups)
            addGroup(i);
          source.clear();
        }
   }

Here is the call graph for this function:

◆ name()

std:: string minsky::Group::name ( ) const

inlineoverridevirtual

Implements minsky::CallableFunction.

Definition at line 241 of file group.h.

References title.

Referenced by addBookmark(), and addBookmarkXY().

241 {return title;}

minsky::Group::title

std::string title

Definition: group.h:240

Here is the caller graph for this function:

◆ nocycles()

bool minsky::Group::nocycles ( ) const

overridevirtual

tests that groups are arranged heirarchically without any recurrence

Implements minsky::GroupItems.

Definition at line 649 of file group.cc.

   {
     set<const Group*> sg;
     sg.insert(this);
     for (auto i=group.lock(); i; i=i->group.lock())
       if (!sg.insert(i.get()).second)
         return false;
     return true;
   }

◆ normaliseGroupRefs()

void minsky::Group::normaliseGroupRefs ( const std::shared_ptr< Group > & self )

fix up subgroup pointers self is a shared pointer ref to this

Definition at line 1195 of file group.cc.

   {
     for (auto& i: items)
         i->group=self;
     for (auto& g: groups)
       {
         g->group=self;
         g->normaliseGroupRefs(g);
       }
   }

◆ operator()()

double minsky::Group::operator() ( const std::vector< double > & p )

overridevirtual

evaluate function on arbitrary number of arguments (exprtk support)

Implements minsky::CallableFunction.

Definition at line 50 of file group.cc.

References pyminsky::minsky, and MathDAG::SystemOfEquations::populateEvalOpVector().

   {
     if (outVariables.empty()) return nan("");
 
     MathDAG::SystemOfEquations system(minsky(), *this);
     EvalOpVector equations;
     vector<Integral> integrals;
     system.populateEvalOpVector(equations, integrals);
     auto flow(ValueVector::flowVars);
 
     // assign values to unattached input variables
     auto iVar=inVariables.begin();
     for (auto v: p)
       {
         while (iVar!=inVariables.end() && (*iVar)->inputWired()) ++iVar;
         if (iVar==inVariables.end()) break;
         flow[(*iVar)->vValue()->idx()]=v;
       }
 
     for (auto& i: equations)
       i->eval(flow.data(), flow.size(),ValueVector::stockVars.data());
     return flow[outVariables[0]->vValue()->idx()];
   }

Here is the call graph for this function:

◆ randomLayout()

void minsky::Group::randomLayout ( )

randomly lay out items in this group

Definition at line 1265 of file group.cc.

References pyminsky::minsky, and minsky::randomizeLayout().

   {
     const BusyCursor busy(minsky());
     randomizeLayout(*this);
   }

Here is the call graph for this function:

◆ renameAllInstances()

void minsky::Group::renameAllInstances	(	const std::string &	valueId,
		const std::string &	newName
	)

rename all instances of a variable matching valueId to newName

Definition at line 1285 of file group.cc.

References minsky::cminsky(), minsky::anonymous_namespace{group.cc}::isGlobal(), pyminsky::minsky, minsky::Minsky::model, minsky::Minsky::requestReset(), minsky::scope(), and minsky::valueId().

     {
       // unqualified versions of the names
       auto p=valueId.find(':');
       string uqFromName=(p!=string::npos)? valueId.substr(p+1): valueId;
       string uqNewName = newName.substr(newName[0]==':'? 1: 0);
       set<GodleyIcon*> godleysToUpdate;
 #ifndef NDEBUG
       auto numItems=this->numItems();
 #endif
       recursiveDo
           (&GroupItems::items, [&](Items&,Items::iterator i)
            {
              if (auto v=(*i)->variableCast())
                if (v->valueId()==valueId)
                  {                       
                    auto varScope=scope(v->group.lock(), valueId);
                    if (auto g=dynamic_cast<GodleyIcon*>(v->controller.lock().get()))
                      {
                        if (varScope==g->group.lock() ||
                            (!varScope && g->group.lock()==cminsky().model)) // fix local variables
                          g->table.rename(uqFromName, uqNewName);
                        
                        // scope of an external ref in the Godley Table
                        auto externalVarScope=scope(g->group.lock(), ':'+uqNewName);
                        // if we didn't find it, perhaps the outerscope variable hasn't been changed
                        if (!externalVarScope)
                          externalVarScope=scope(g->group.lock(), ':'+uqFromName);
 
                        if (varScope==externalVarScope ||  (isGlobal(varScope) && isGlobal(externalVarScope)))
                          // fix external variable references
                          g->table.rename(':'+uqFromName, ':'+uqNewName);
                        // GodleyIcon::update invalidates the iterator, so postpone update
                        godleysToUpdate.insert(g);
                      }
                    else
                      {
                        // ensure locality is preserved across the rename
                        v->name(varScope==v->group.lock()? uqNewName: (':'+uqNewName));
                        if (auto vv=v->vValue()) 
                          v->retype(vv->type()); // ensure correct type. Note this invalidates v.
                      }
                  }
              return false;
            });
         assert(this->numItems()==numItems);
         for (auto g: godleysToUpdate)
           {
             g->update();
             assert(this->numItems()==numItems);
           }
       minsky().requestReset();   // Updates model after variables rename. For ticket 1109.    
     }

Here is the call graph for this function:

◆ resize()

void minsky::Group::resize ( const LassoBox & b )

overridevirtual

resize this item on the canvas

Reimplemented from minsky::Item.

Definition at line 624 of file group.cc.

References minsky::anonymous_namespace{group.cc}::recentreItems(), minsky::anonymous_namespace{group.cc}::resizeItems(), topMargin, minsky::LassoBox::x0, minsky::LassoBox::x1, minsky::LassoBox::y0, and minsky::LassoBox::y1.

   {
     float z=zoomFactor();
     // account for margins
     float l, r;
     margins(l,r);
     if (fabs(b.x0-b.x1) < l+r || fabs(b.y0-b.y1)<2*z*topMargin) return;
     iWidth(fabs(b.x0-b.x1)/z);
     iHeight((fabs(b.y0-b.y1)-2*topMargin)/z);
     // TODO - it is wasteful to call contentBounds within computeRelZoom, then again a few lines later
     computeRelZoom(); // needed to ensure grouped items scale properly with resize operation. for ticket 1243    
     z=zoomFactor();     // recalculate zoomFactor because relZoom changed above. for ticket 1243
     double x0, x1, y0, y1;
     contentBounds(x0,y0,x1,y1);
     recentreItems(items,0.5*(x0+x1)-x(),0.5*(y0+y1)-y());
     recentreItems(groups,0.5*(x0+x1)-x(),0.5*(y0+y1)-y());
     double sx=(fabs(b.x0-b.x1)-z*(l+r))/(x1-x0), sy=(fabs(b.y0-b.y1)-2*z*topMargin)/(y1-y0);
     sx=std::min(sx,sy);
     resizeItems(items,sx,sx);
     resizeItems(groups,sx,sx);
     
     moveTo(0.5*(b.x0+b.x1), 0.5*(b.y0+b.y1));
     bb.update(*this);
   }

Here is the call graph for this function:

◆ resizeOnContents()

void minsky::Group::resizeOnContents ( )

adjust position and size of icon to just cover contents

Definition at line 574 of file group.cc.

   {
     double x0, x1, y0, y1;
     contentBounds(x0,y0,x1,y1);
     const double xx=0.5*(x0+x1), yy=0.5*(y0+y1);
     const double dx=xx-x(), dy=yy-y();
     float l,r; margins(l,r);    
     const float z=zoomFactor();
     m_width=((x1-x0)+l+r)/z;
     m_height=((y1-y0)+20*z)/z;
 
     // adjust contents by the offset
     for (auto& i: items)
       i->moveTo(i->x()-dx, i->y()-dy);
     for (auto& i: groups)
       i->moveTo(i->x()-dx, i->y()-dy);
 
     moveTo(xx,yy);
     bb.update(*this);
   }

◆ rotFactor()

float minsky::Group::rotFactor ( ) const

scaling factor to allow a rotated icon to fit on the bitmap

Definition at line 1172 of file group.cc.

References MathDAG::cos(), M_PI, and MathDAG::sqrt().

   {
     float rotFactor;
     const float ac=abs(cos(rotation()*M_PI/180));
     static const float invSqrt2=1/sqrt(2);
     if (ac>=invSqrt2) 
       rotFactor=1.15/ac; //use |1/cos(angle)| as rotation factor
     else
       rotFactor=1.15/sqrt(1-ac*ac);//use |1/sin(angle)| as rotation factor
     return rotFactor;
   }

Here is the call graph for this function:

◆ select()

ItemPtr minsky::Group::select	(	float	x,
		float	y
	)		const

overridevirtual

returns the variable if point (x,y) is within a I/O variable icon, null otherwise, indicating that the Group has been selected.

Reimplemented from minsky::Item.

Definition at line 1184 of file group.cc.

References minsky::RenderVariable::inImage().

   {
     for (auto& v: inVariables)
       if (RenderVariable(*v).inImage(x,y)) 
         return v;
     for (auto& v: outVariables)
       if (RenderVariable(*v).inImage(x,y)) 
         return v;
     return nullptr;
   }

Here is the call graph for this function:

◆ setZoom()

void minsky::Group::setZoom ( float factor )

sets the zoom factor to factor. Recursively set the zoomfactor on contained objects to the computed localzoom

Definition at line 878 of file group.cc.

   {
     const bool dpc=displayContents();
     if (!group.lock())
       relZoom=factor;
     else
       computeRelZoom();
     const float lzoom=localZoom();
     m_displayContentsChanged = dpc!=displayContents();
     for (auto& i: groups)
       {
         i->setZoom(lzoom);
         m_displayContentsChanged|=i->displayContentsChanged();
       }
   }

◆ splitBoundaryCrossingWires()

void minsky::Group::splitBoundaryCrossingWires ( )

splits any wires that cross group boundaries

Definition at line 424 of file group.cc.

References minsky::anonymous_namespace{group.cc}::globalGroup().

   {
     // Wire::split will invalidate the Items::iterator, so collect
     // wires to split first
     set<Wire*> wiresToSplit;
     for (auto& i: items)
       for (size_t p=0; p<i->portsSize(); ++p)
         for (auto w: i->ports(p).lock()->wires())
           wiresToSplit.insert(w);
 
     for (auto w: wiresToSplit)
       w->split();
 
     // check if any created I/O variables can be removed
     auto varsToCheck=createdIOvariables;
     for (auto& iv: varsToCheck)
       {
         assert(iv->ports(1).lock()->input() && !iv->ports(1).lock()->multiWireAllowed());
         // firstly join wires that don't cross boundaries
         // determine if this is input or output var
         if (!iv->ports(1).lock()->wires().empty())
           {
             auto fromGroup=iv->ports(1).lock()->wires()[0]->from()->item().group.lock();
             if (fromGroup.get() == this)
               {
                 // not an input var
                 for (auto& w: iv->ports(0).lock()->wires())
                   if (w->to()->item().group.lock().get() == this)
                     // join wires, as not crossing boundary
                     {
                       auto to=w->to();
                       iv->ports(0).lock()->eraseWire(w);
                       removeWire(*w);
                       addWire(iv->ports(1).lock()->wires()[0]->from(), to);
                     }
               }
             else
               for (auto& w: iv->ports(0).lock()->wires())
                 if (w->to()->item().group.lock() == fromGroup)
                   // join wires, as not crossing boundary
                   {
                     auto to=w->to();
                     iv->ports(0).lock()->eraseWire(w);
                     globalGroup().removeWire(*w);
                     adjustWiresGroup(*addWire(iv->ports(1).lock()->wires()[0]->from(), to));
                   }
           }
         
         if (iv->ports(0).lock()->wires().empty() || iv->ports(1).lock()->wires().empty())
           removeItem(*iv);
       }
   }

Here is the call graph for this function:

◆ summariseGodleys()

vector< Summary > minsky::Group::summariseGodleys ( ) const

produce a summary of godley table variables

Definition at line 1271 of file group.cc.

   {
     vector<Summary> r;
     recursiveDo(&GroupItems::items, [&](const Items&,Items::const_iterator i) {
       if (auto g=dynamic_cast<GodleyIcon*>(i->get()))
         {
           auto summary=g->summarise();
           r.insert(r.end(),summary.begin(), summary.end());
         }
       return false;
     });
     return r;
   }

◆ uniqueItems() [1/2]

bool minsky::Group::uniqueItems ( std::set< void *> & idset ) const

returns true if items appear uniquely within the heirarchy. Note the map structure does not guarantee that an item doesn't appear within another group

Definition at line 747 of file group.cc.

   {
     for (auto& i: items)
       if (!idset.insert(i.get()).second) return false;
     for (auto& i: wires)
       if (!idset.insert(i.get()).second) return false;
     for (auto& i: groups)
       if (!idset.insert(i.get()).second || !i->uniqueItems(idset)) 
         return false;
     return true;
   }

◆ uniqueItems() [2/2]

bool minsky::Group::uniqueItems ( ) const

inline

Definition at line 326 of file group.h.

                              {
       std::set<void*> idset;
       return uniqueItems(idset);
     }

◆ zoom()

void minsky::Group::zoom	(	float	xOrigin,
		float	yOrigin,
		float	factor
	)

Definition at line 894 of file group.cc.

References minsky::zoom().

   {
     const bool dpc=displayContents();
     minsky::zoom(m_x,xOrigin+m_x-x(),factor);
     minsky::zoom(m_y,yOrigin+m_y-y(),factor);
     m_displayContentsChanged = dpc!=displayContents();
     if (!group.lock())
       relZoom*=factor;
     for (auto& i: groups)
       {
         if (displayContents() && !m_displayContentsChanged)
           i->zoom(i->x(), i->y(), factor);
         m_displayContentsChanged|=i->displayContentsChanged();
       }
   }

Here is the call graph for this function:

Friends And Related Function Documentation

◆ Canvas

friend class Canvas

friend

Definition at line 232 of file group.h.

Member Data Documentation

◆ displayZoom

float minsky::Group::displayZoom {1}

computes the zoom at which to show contents, given current contentBounds and width

extra zoom at which contents are displayed

Definition at line 347 of file group.h.

Referenced by localZoom().

◆ m_displayContentsChanged

bool minsky::Group::m_displayContentsChanged =true

private

Definition at line 222 of file group.h.

Referenced by displayContentsChanged().

◆ relZoom

float minsky::Group::relZoom {1}

relative zoom contents of this group are displayed at

Definition at line 348 of file group.h.

Referenced by addBookmarkXY(), displayContents(), and edgeScale().

◆ svgRenderer

SVGRenderer minsky::Group::svgRenderer

static

Definition at line 259 of file group.h.

Referenced by minsky::Minsky::setGroupIconResource().

◆ title

std::string minsky::Group::title

Definition at line 240 of file group.h.

Referenced by schema3::Item::Item(), and name().

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

model/group.h
model/group.cc

Classes

Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Private Member Functions

Private Attributes

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ Group()

Member Function Documentation

◆ accessibleVars()

◆ addBookmark()

◆ addBookmarkXY()

◆ addInputVar()

◆ addIOVar()

◆ addItem() [1/3]

◆ addItem() [2/3]

◆ addItem() [3/3]

◆ addOutputVar()

◆ arguments()

◆ autoLayout()

◆ bookmarkList()

◆ cBounds()

◆ checkAddIORegion()

◆ clickType()

◆ clone()

◆ computeDisplayZoom()

◆ computeRelZoom()

◆ contentBounds()

◆ copy()

◆ copyUnowned()

◆ defaultExtension()

◆ deleteAttachedWires()

◆ deleteBookmark()

◆ deleteItem()

◆ displayContents()

◆ displayContentsChanged()

◆ draw()

◆ draw1edge()

◆ drawEdgeVariables()

◆ drawIORegion()

◆ edgeScale()

◆ flipContents()

◆ formula()

◆ globalGroup() [1/2]

◆ globalGroup() [2/2]

◆ gotoBookmark()

◆ gotoBookmark_b()

◆ higher()

◆ inIORegion()

◆ level()

◆ localZoom()

◆ makeSubroutine()

◆ margins()

◆ marginsV()

◆ minimalEnclosingGroup() [1/2]

◆ minimalEnclosingGroup() [2/2]

◆ moveContents()

◆ name()

◆ nocycles()

◆ normaliseGroupRefs()

◆ operator()()

◆ randomLayout()

◆ renameAllInstances()

◆ resize()

◆ resizeOnContents()

◆ rotFactor()

◆ select()

◆ setZoom()

◆ splitBoundaryCrossingWires()

◆ summariseGodleys()

◆ uniqueItems() [1/2]

◆ uniqueItems() [2/2]

◆ zoom()

Friends And Related Function Documentation

◆ Canvas

Member Data Documentation