#include <SceneComposedNodeItem.hxx>

Inheritance diagram for YACS::HMI::SceneComposedNodeItem:

[legend]

Collaboration diagram for YACS::HMI::SceneComposedNodeItem:

[legend]

Public Member Functions
	SceneComposedNodeItem (QGraphicsScene scene, SceneItem parent, QString label, Subject *subject)

virtual	~SceneComposedNodeItem ()

virtual QRectF	childrenBoundingRect () const

virtual void	paint (QPainter painter, const QStyleOptionGraphicsItem option, QWidget *widget)

virtual void	update (GuiEvent event, int type, Subject *son)

virtual void	autoPosNewChild (AbstractSceneItem item, const std::list< AbstractSceneItem > alreadySet, bool isNew=false)

virtual void	popupMenu (QWidget *caller, const QPoint &globalPos)

virtual std::list< AbstractSceneItem * >	getChildren ()

virtual void	removeChildFromList (AbstractSceneItem *child)

virtual void	reorganize ()

virtual void	reorganizeShrinkExpand (ShrinkMode theShrinkMode)

virtual void	shrinkExpandRecursive (bool isExpanding, bool fromHere, ShrinkMode theShrinkMode)

virtual void	shrinkExpandLink (bool se)

virtual void	collisionResolv (SceneItem *child, QPointF oldPos)

virtual void	rebuildLinks ()

virtual void	updateChildItems ()

virtual void	arrangeNodes (bool isRecursive)
	generic method to compute a graph for child nodes. implemented in some derived classes More...

virtual void	arrangeChildNodes ()

virtual void	adjustColors ()

virtual void	setShownState (shownState ss)

virtual bool	hasExpandedChildren (bool recursively)

Public Member Functions inherited from YACS::HMI::SceneNodeItem
	SceneNodeItem (QGraphicsScene scene, SceneItem parent, QString label, Subject *subject)

virtual	~SceneNodeItem ()

virtual void	setWidth (qreal width)
	AbstractSceneItem cannot be resized (only ComposedNodeItem can) More...

virtual void	setHeight (qreal height)
	AbstractSceneItem cannot be resized (only ComposedNodeItem can) More...

virtual void	addHeader ()

virtual SceneHeaderItem *	getHeader ()

virtual void	addProgressItem ()

virtual SceneProgressItem *	getProgressItem ()

virtual void	paint (QPainter painter, const QStyleOptionGraphicsItem option, QWidget *widget)

virtual void	update (GuiEvent event, int type, Subject *son)

virtual qreal	getHeaderBottom ()

virtual void	autoPosNewPort (AbstractSceneItem *item, int nbPorts)

virtual void	popupMenu (QWidget *caller, const QPoint &globalPos)

virtual SceneComposedNodeItem *	getParent ()

virtual void	removeInPortFromList (AbstractSceneItem *inPort)

virtual void	removeOutPortFromList (AbstractSceneItem *outPort)

virtual void	setMoving (bool moving)

virtual void	setTopLeft (QPointF topLeft)

virtual void	adjustHeader ()

virtual ScenePortItem *	getCtrlInPortItem ()

virtual ScenePortItem *	getCtrlOutPortItem ()

virtual void	updateName ()

virtual void	arrangeNodes (bool isRecursive)
	generic method to compute a graph for child nodes. implemented in some derived classes More...

virtual void	arrangeChildNodes ()

virtual void	reorganizeShrinkExpand (ShrinkMode theShrinkMode)

virtual void	updateChildItems ()

virtual void	shrinkExpandLink (bool se)

virtual void	showOutScopeLinks ()

virtual void	updateLinks ()

virtual void	setShownState (shownState ss)

bool	isExpanded ()

void	setExpanded (bool e)

void	setExpandedPos (QPointF epos)

qreal	getExpandedX ()

qreal	getExpandedY ()

void	setExpandedWH ()

void	setExpandedWH (qreal w, qreal h)

qreal	getExpandedWidth ()

qreal	getExpandedHeight ()

shownState	getShownState ()

bool	hasProgressBar () const

Public Member Functions inherited from YACS::HMI::SceneObserverItem
	SceneObserverItem (QGraphicsScene scene, SceneItem parent, QString label, Subject *subject)

virtual	~SceneObserverItem ()

virtual void	update (GuiEvent event, int type, Subject *son)

virtual void	select (bool isSelected)

virtual void	activateSelection (bool selected)

virtual Subject *	getSubject ()

virtual QString	getToolTip ()

Public Member Functions inherited from YACS::HMI::SceneItem
	SceneItem (QGraphicsScene scene, SceneItem parent, QString label)

virtual	~SceneItem ()

virtual QRectF	boundingRect () const

virtual QRectF	childrenBoundingRect () const

virtual void	paint (QPainter painter, const QStyleOptionGraphicsItem option, QWidget *widget)

virtual void	setTopLeft (QPointF topLeft)

virtual void	checkGeometryChange ()

virtual void	popupMenu (QWidget *caller, const QPoint &globalPos)

void	setParent (SceneItem *parent)

virtual QString	getToolTip ()

void	setEventPos (QPointF point)

virtual void	updateChildItems ()

virtual void	updateLinks ()

virtual void	shrinkExpandLink (bool se)

virtual void	shrinkExpandRecursive (bool isExpanding, bool fromHere, ShrinkMode theShrinkMode)

bool	isAncestorShrinked ()

Public Member Functions inherited from YACS::HMI::AbstractSceneItem
	AbstractSceneItem (QGraphicsScene scene, SceneItem parent, QString label)

virtual	~AbstractSceneItem ()

virtual QRectF	boundingRect () const =0

virtual void	paint (QPainter painter, const QStyleOptionGraphicsItem option, QWidget *widget)=0

virtual void	setTopLeft (QPointF topLeft)=0

int	getLevel ()

void	setLevel ()

virtual void	checkGeometryChange ()=0

virtual void	reorganize ()

virtual QString	getLabel ()

virtual void	addHeader ()

virtual void	addProgressItem ()

virtual qreal	getHeaderBottom ()

qreal	getWidth ()

qreal	getHeight ()

virtual void	setWidth (qreal width)
	AbstractSceneItem cannot be resized (only ComposedNodeItem can) More...

virtual void	setHeight (qreal height)
	AbstractSceneItem cannot be resized (only ComposedNodeItem can) More...

virtual void	popupMenu (QWidget *caller, const QPoint &globalPos)=0

virtual void	activateSelection (bool selected)

virtual void	setGeometryOptimization (bool optimize)

SceneItem *	getParent ()

Public Member Functions inherited from YACS::HMI::GuiObserver
	GuiObserver ()

virtual	~GuiObserver ()

virtual void	select (bool isSelected)

virtual void	update (GuiEvent event, int type, Subject *son)

virtual void	incrementSubjects (Subject *subject)

virtual void	decrementSubjects (Subject *subject)

int	getNbSubjects ()

bool	isDestructible ()

Protected Member Functions
void	dragEnterEvent (QGraphicsSceneDragDropEvent *event)

void	dragLeaveEvent (QGraphicsSceneDragDropEvent *event)

void	dropEvent (QGraphicsSceneDragDropEvent *event)

void	updateControlLinks (bool toExpand)

virtual QColor	getPenColor ()

virtual QColor	getBrushColor ()

Protected Member Functions inherited from YACS::HMI::SceneNodeItem
virtual QString	getMimeFormat ()

virtual void	mousePressEvent (QGraphicsSceneMouseEvent *event)

virtual void	mouseReleaseEvent (QGraphicsSceneMouseEvent *event)

virtual void	mouseMoveEvent (QGraphicsSceneMouseEvent *event)

virtual void	mouseDoubleClickEvent (QGraphicsSceneMouseEvent *event)

virtual void	updateState ()

virtual void	setExecState (int execState)

QString	getHeaderLabel ()

virtual void	mousePressEvent (QGraphicsSceneMouseEvent *event)

virtual void	mouseMoveEvent (QGraphicsSceneMouseEvent *event)

virtual void	mouseReleaseEvent (QGraphicsSceneMouseEvent *event)

virtual QColor	getBrushColor ()

virtual QString	getMimeFormat ()

Protected Member Functions inherited from YACS::HMI::SceneItem
virtual void	mousePressEvent (QGraphicsSceneMouseEvent *event)

virtual void	hoverEnterEvent (QGraphicsSceneHoverEvent *event)

virtual void	hoverMoveEvent (QGraphicsSceneHoverEvent *event)

virtual void	hoverLeaveEvent (QGraphicsSceneHoverEvent *event)

virtual QColor	getPenColor ()

virtual QColor	getBrushColor ()

QColor	hoverColor (QColor origColor)

Protected Member Functions inherited from YACS::HMI::AbstractSceneItem
virtual QRectF	childBoundingRect (AbstractSceneItem *child) const

Protected Attributes
std::list< AbstractSceneItem * >	_children

bool	_dragOver

Protected Attributes inherited from YACS::HMI::SceneNodeItem
std::list< AbstractSceneItem * >	_inPorts

std::list< AbstractSceneItem * >	_outPorts

SceneHeaderNodeItem *	_header

SceneProgressItem *	_progressItem

int	_execState

bool	_moving

bool	_moved

bool	_expanded

QPointF	_prevPos

QPointF	_expandedPos

qreal	_expandedWidth

qreal	_expandedHeight

shownState	_shownState

Protected Attributes inherited from YACS::HMI::SceneObserverItem
Subject *	_subject

bool	_draging

bool	_dragModifier

bool	_emphasized

Protected Attributes inherited from YACS::HMI::SceneItem
bool	_hover

bool	_ancestorShrinked

QPointF	_eventPos

Protected Attributes inherited from YACS::HMI::AbstractSceneItem
SceneItem *	_parent

YACS::HMI::Scene *	_scene

QString	_label

int	_level

qreal	_width

qreal	_height

qreal	_incHeight

QColor	_penColor

QColor	_brushColor

QColor	_hiPenColor

QColor	_hiBrushColor

bool	_hasHeader

bool	_optimize

bool	_dragable

enum Qt::MouseButton	_dragButton

Protected Attributes inherited from YACS::HMI::GuiObserver
std::set< Subject * >	_subjectSet

bool	_destructible

Additional Inherited Members
Static Public Member Functions inherited from YACS::HMI::GuiObserver
static std::string	eventName (GuiEvent event)

static void	setEventMap ()

Public Attributes inherited from YACS::HMI::SceneItem
bool	_blocX

bool	_blocY

Static Protected Attributes inherited from YACS::HMI::GuiObserver
static std::map< int, std::string >	_eventNameMap

Detailed Description

Definition at line 29 of file SceneComposedNodeItem.hxx.

Constructor & Destructor Documentation

◆ SceneComposedNodeItem()

SceneComposedNodeItem::SceneComposedNodeItem	(	QGraphicsScene *	scene,
		SceneItem *	parent,
		QString	label,
		Subject *	subject
	)

Definition at line 59 of file SceneComposedNodeItem.cxx.

  : SceneNodeItem(scene, parent, label, subject)
{
  DEBTRACE("SceneComposedNodeItem::SceneComposedNodeItem " <<label.toStdString());
 
  _width  = 2*Resource::Corner_Margin + 2*Resource::DataPort_Width + Resource::Space_Margin;
  _height = Resource::Header_Height + Resource::DataPort_Height + Resource::Corner_Margin;
 
  _hiBrushColor = Resource::ComposedNode_hiBrush;
  _penColor     = Resource::ComposedNode_pen;
  _hiPenColor   = Resource::ComposedNode_hiPen;
  adjustColors();
  _dragOver = false;
  setAcceptDrops(true);
}

References _dragOver, YACS::HMI::AbstractSceneItem::_height, YACS::HMI::AbstractSceneItem::_hiBrushColor, YACS::HMI::AbstractSceneItem::_hiPenColor, YACS::HMI::AbstractSceneItem::_penColor, YACS::HMI::AbstractSceneItem::_width, adjustColors(), YACS::HMI::Resource::ComposedNode_hiBrush, YACS::HMI::Resource::ComposedNode_hiPen, YACS::HMI::Resource::ComposedNode_pen, YACS::HMI::Resource::Corner_Margin, YACS::HMI::Resource::DataPort_Height, YACS::HMI::Resource::DataPort_Width, DEBTRACE, YACS::HMI::Resource::Header_Height, and YACS::HMI::Resource::Space_Margin.

Referenced by update().

◆ ~SceneComposedNodeItem()

SceneComposedNodeItem::~SceneComposedNodeItem ( )

virtual

Definition at line 76 of file SceneComposedNodeItem.cxx.

77{

78}

Member Function Documentation

◆ adjustColors()

void SceneComposedNodeItem::adjustColors ( )

virtual

Definition at line 80 of file SceneComposedNodeItem.cxx.

{
  _brushColor = Resource::ComposedNode_brush.darker(100 +5*_level);
  for (list<AbstractSceneItem*>::const_iterator it=_children.begin(); it!=_children.end(); ++it)
    {
      if (SceneComposedNodeItem *scnode = dynamic_cast<SceneComposedNodeItem*>(*it))
        scnode->adjustColors();
    }
 }

References YACS::HMI::AbstractSceneItem::_brushColor, _children, YACS::HMI::AbstractSceneItem::_level, and YACS::HMI::Resource::ComposedNode_brush.

Referenced by SceneComposedNodeItem().

◆ arrangeChildNodes()

void SceneComposedNodeItem::arrangeChildNodes ( )

virtual

Reimplemented from YACS::HMI::SceneNodeItem.

Reimplemented in YACS::HMI::SceneBlocItem.

Definition at line 829 of file SceneComposedNodeItem.cxx.

{
  reorganize();
}

References reorganize().

Referenced by arrangeNodes().

◆ arrangeNodes()

void SceneComposedNodeItem::arrangeNodes ( bool isRecursive )

virtual

generic method to compute a graph for child nodes. implemented in some derived classes

Reimplemented from YACS::HMI::SceneNodeItem.

Definition at line 784 of file SceneComposedNodeItem.cxx.

{
  DEBTRACE("SceneComposedItem::arrangeNodes " << isRecursive);
 
  bool isExtern = !QtGuiContext::_delayCalc;
  QtGuiContext::_delayCalc = true; // avoid rebuildLinks
 
  SubjectComposedNode *scnode = dynamic_cast<SubjectComposedNode*>(getSubject());
  YASSERT(scnode);
  ComposedNode *cnode = dynamic_cast<ComposedNode*>(scnode->getNode());
  YASSERT(cnode);
 
  if (isRecursive)
    {
      list<Node*> children = cnode->edGetDirectDescendants();
      for (list<Node*>::iterator it = children.begin(); it != children.end(); ++it)
        {
          DEBTRACE("child " << (*it)->getName());
          SceneComposedNodeItem *scni = 0;
          ComposedNode *cchild = dynamic_cast<ComposedNode*>(*it);
          if (cchild)
            {
              SubjectNode* sn = GuiContext::getCurrent()->_mapOfSubjectNode[cchild];
              SceneItem* sci = QtGuiContext::getQtCurrent()->_mapOfSceneItem[sn];
              if (sci) scni = dynamic_cast<SceneComposedNodeItem*>(sci);
            }
          if (scni && (scni->getShownState() == expandShown))
            {
              DEBTRACE("call arrangeNode on child " << (*it)->getName());
              scni->arrangeNodes(isRecursive);
            }
        }
      arrangeChildNodes();
    }
  else
    arrangeChildNodes();
 
  if (isExtern)
    {
      QtGuiContext::_delayCalc = false; // allow rebuildLinks
      if (Scene::_autoComputeLinks)
        rebuildLinks();
    }
}

References YACS::HMI::Scene::_autoComputeLinks, YACS::HMI::QtGuiContext::_delayCalc, YACS::HMI::QtGuiContext::_mapOfSceneItem, YACS::HMI::GuiContext::_mapOfSubjectNode, arrangeChildNodes(), arrangeNodes(), DEBTRACE, YACS::ENGINE::ComposedNode::edGetDirectDescendants(), YACS::HMI::expandShown, YACS::HMI::GuiContext::getCurrent(), YACS::HMI::SubjectNode::getNode(), YACS::HMI::QtGuiContext::getQtCurrent(), YACS::HMI::SceneNodeItem::getShownState(), YACS::HMI::SceneObserverItem::getSubject(), rebuildLinks(), and YASSERT.

Referenced by YACS::HMI::GuiEditor::arrangeNodes(), arrangeNodes(), and YACS::HMI::GuiEditor::arrangeProc().

◆ autoPosNewChild()

void SceneComposedNodeItem::autoPosNewChild	(	AbstractSceneItem *	item,
		const std::list< AbstractSceneItem * >	alreadySet,
		bool	isNew = `false`
	)

virtual

Definition at line 340 of file SceneComposedNodeItem.cxx.

{
  SceneItem *it = dynamic_cast<SceneItem*>(item);
  YASSERT(it);
 
  QRectF childrenBox;
  qreal xLeft = Resource::Corner_Margin;
  qreal yTop  = getHeaderBottom() + Resource::Space_Margin;
  for (list<AbstractSceneItem*>::const_iterator it=alreadySet.begin(); it!=alreadySet.end(); ++it)
    {
      childrenBox = childrenBox.united(childBoundingRect(*it));
      DEBTRACE((*it)->getLabel().toStdString());
      DEBTRACE("childrenBox valid " << childrenBox.right() << " " << childrenBox.bottom());
    }
  if (childrenBox.isValid())
    yTop = childrenBox.bottom() + 1.; // +1. to avoid collision with bottom (penwidth)
  //xLeft += childrenBox.right();
  DEBTRACE("left, top " << xLeft  << " " << yTop);
  QPointF topLeft(xLeft, yTop);
  if (isNew) _children.push_back(item);
  if (_eventPos.isNull())
    {
      //DEBTRACE("_eventPos.isNull");
      item->setTopLeft(topLeft);
    }
  else
    {
      //DEBTRACE("_eventPos " << _eventPos.x() << " " << _eventPos.y());
      item->setTopLeft(_eventPos);
    }
  collisionResolv(it, -it->boundingRect().bottomRight()); // as if the new item was coming from top left (previous position outside)
  if (Scene::_autoComputeLinks && !QtGuiContext::getQtCurrent()->isLoading()) rebuildLinks();
  _eventPos.setX(0);
  _eventPos.setY(0);
}

References YACS::HMI::Scene::_autoComputeLinks, _children, YACS::HMI::SceneItem::_eventPos, YACS::HMI::SceneItem::boundingRect(), YACS::HMI::AbstractSceneItem::childBoundingRect(), collisionResolv(), YACS::HMI::Resource::Corner_Margin, DEBTRACE, YACS::HMI::SceneNodeItem::getHeaderBottom(), YACS::HMI::QtGuiContext::getQtCurrent(), rebuildLinks(), YACS::HMI::AbstractSceneItem::setTopLeft(), YACS::HMI::Resource::Space_Margin, and YASSERT.

Referenced by reorganize(), and update().

◆ childrenBoundingRect()

QRectF SceneComposedNodeItem::childrenBoundingRect ( ) const

virtual

Reimplemented from YACS::HMI::SceneItem.

Definition at line 90 of file SceneComposedNodeItem.cxx.

{
  QRectF ChildrenBRect =QRectF(x(), y(), 5, 5);
  if (_header) ChildrenBRect = _header->getMinimalBoundingRect();
  for (list<AbstractSceneItem*>::const_iterator it=_children.begin(); it!=_children.end(); ++it)
    ChildrenBRect = ChildrenBRect.united(childBoundingRect(*it));
  ChildrenBRect.setWidth (ChildrenBRect.width()  + Resource::Border_Margin);
  ChildrenBRect.setHeight(ChildrenBRect.height() + Resource::Border_Margin);
  return ChildrenBRect;
}

References _children, YACS::HMI::SceneNodeItem::_header, YACS::HMI::Resource::Border_Margin, YACS::HMI::AbstractSceneItem::childBoundingRect(), and YACS::HMI::SceneHeaderNodeItem::getMinimalBoundingRect().

◆ collisionResolv()

void SceneComposedNodeItem::collisionResolv	(	SceneItem *	child,
		QPointF	oldPos
	)

virtual

Definition at line 637 of file SceneComposedNodeItem.cxx.

{
  //DEBTRACE("SceneComposedNodeItem::collisionResolv " << _label.toStdString());
  for (list<AbstractSceneItem*>::const_iterator it=_children.begin(); it!=_children.end(); ++it)
    {
      SceneNodeItem *other = dynamic_cast<SceneNodeItem*>(*it);
      if (other && (other != child))
        {
          if (child->collidesWithItem(other))
            {
              //DEBTRACE("collision detected with " << other->getLabel().toStdString());
              QRectF otherBR = (other->mapToParent(other->boundingRect())).boundingRect();
              qreal oldX = oldPos.x();
              qreal oldY = oldPos.y();
              qreal newX = child->pos().x();
              qreal newY = child->pos().y();
              qreal othX = otherBR.left()+0.5;
              qreal othY = otherBR.top()+0.5;
              //DEBTRACE("oldX=" << oldX << " oldY=" << oldY << " newX=" << newX << " newY=" << newY);
              //DEBTRACE("otherLeft=" << otherBR.left() << " otherRight=" << otherBR.right() <<
              //         " otherTop=" << otherBR.top() << " otherBottom=" << otherBR.bottom());
              //DEBTRACE("width=" << child->boundingRect().width() <<
              //         " height=" << child->boundingRect().height());
              bool fromTop    = (((oldY + child->boundingRect().height()) <= otherBR.top()+1) &&
                                 ((newY + child->boundingRect().height()) >= otherBR.top()));
              bool fromBottom = (( oldY >= otherBR.bottom()) &&
                                 ( newY <= otherBR.bottom()));
              bool fromRight  = (( oldX >= otherBR.right()) &&
                                 ( newX <= otherBR.right()));
              bool fromLeft   = (((oldX+ child->boundingRect().width()) <= otherBR.left()+1) &&
                                 ((newX+ child->boundingRect().width()) >= otherBR.left()));
              //DEBTRACE("fromTop=" << fromTop << " fromBottom=" << fromBottom 
              //         << " fromRight=" << fromRight << " fromLeft=" << fromLeft);
              bool pushOther =false;
              bool blocThis = false;
              if (fromTop)
                {
                  othY = newY + child->boundingRect().height();
                  pushOther = true;
                  other->_blocY = false;
                }
              if (fromLeft)
                {
                  othX = newX+ child->boundingRect().width();
                  pushOther = true;
                  other->_blocX = false;
                }
              if (fromBottom)
                {
                  if (other->_blocY)
                    {
                      newY = otherBR.bottom() + 1;
                      blocThis = true;
                      _blocY = true;
                    }
                  else
                    {
                      othY = newY - otherBR.height();
                      if ( othY < Resource::Space_Margin + getHeaderBottom() )
                        {
                          othY = Resource::Space_Margin + getHeaderBottom();
                          other->_blocY = true;
                          newY = otherBR.bottom() + 1;
                          _blocY = true;
                          blocThis = true;
                        }
                      else
                        pushOther = true;
                    }
                }
              if (fromRight)
                {
                  if (other->_blocX)
                    {
                      newX = otherBR.right()+ 1;
                      blocThis = true;
                      _blocX = true;
                    }
                  else
                    {
                      othX = newX - otherBR.width();
                      if (othX < Resource::Space_Margin)
                        {
                          othX = Resource::Space_Margin;
                          other->_blocX = true;
                          newX = otherBR.right()+ 1;
                          _blocX = true;
                          blocThis = true;
                        }
                      else
                        pushOther = true;
                    }
                }
              //DEBTRACE("newX=" << newX << " newY=" << newY);
              if (blocThis) child->setTopLeft(QPointF(newX, newY));
              if (pushOther)
                {
                  other->setTopLeft(QPointF(othX, othY));
                }
            }
        }
    } 
}

References YACS::HMI::SceneItem::_blocX, YACS::HMI::SceneItem::_blocY, _children, YACS::HMI::SceneItem::boundingRect(), YACS::HMI::SceneNodeItem::getHeaderBottom(), YACS::HMI::SceneItem::setTopLeft(), YACS::HMI::SceneNodeItem::setTopLeft(), and YACS::HMI::Resource::Space_Margin.

Referenced by autoPosNewChild().

◆ dragEnterEvent()

void SceneComposedNodeItem::dragEnterEvent ( QGraphicsSceneDragDropEvent * event )

protected

Definition at line 834 of file SceneComposedNodeItem.cxx.

{
  bool accepted = false;
  const ItemMimeData *myData = dynamic_cast<const ItemMimeData*>(event->mimeData());
  if (myData)
    {
      if (myData->hasFormat("yacs/cataService") ||
          myData->hasFormat("yacs/cataNode")    ||
          myData->hasFormat("yacs/subjectNode"))
        {
          event->setAccepted(true);
          _dragOver = true;
          QGraphicsItem::update();
          return;
        }
    }
  event->setAccepted(accepted);
}

References _dragOver.

◆ dragLeaveEvent()

void SceneComposedNodeItem::dragLeaveEvent ( QGraphicsSceneDragDropEvent * event )

protected

Definition at line 853 of file SceneComposedNodeItem.cxx.

{
    Q_UNUSED(event);
    _dragOver = false;
    QGraphicsItem::update();
}

References _dragOver.

◆ dropEvent()

void SceneComposedNodeItem::dropEvent ( QGraphicsSceneDragDropEvent * event )

protected

Definition at line 860 of file SceneComposedNodeItem.cxx.

{
  Q_UNUSED(event);
  _dragOver = false;
  QGraphicsItem::update();
 
  const ItemMimeData *myData = dynamic_cast<const ItemMimeData*>(event->mimeData());
  if (!myData) return;
  setEventPos(event->scenePos());
  if (myData->hasFormat("yacs/cataService") || myData->hasFormat("yacs/cataNode"))
    {
      SubjectComposedNode *cnode = dynamic_cast<SubjectComposedNode*>(getSubject());
      bool createNewComponentInstance=Resource::COMPONENT_INSTANCE_NEW;
      // by default getControl gives false. In this case we use the user preference COMPONENT_INSTANCE_NEW
      // to create the node. If getControl gives true we invert the user preference
      if(myData->getControl())
        createNewComponentInstance=!Resource::COMPONENT_INSTANCE_NEW;
      QtGuiContext::getQtCurrent()->getGMain()->_guiEditor->CreateNodeFromCatalog(myData, cnode,createNewComponentInstance);
    }
  else if(myData->hasFormat("yacs/subjectNode"))
    {
      Subject *sub = myData->getSubject();
      if (!sub) return;
      SubjectNode *node = dynamic_cast<SubjectNode*>(sub);
      if (!node) return;
      if (dynamic_cast<SubjectProc*>(node)) return; // --- do not reparent proc !
      SubjectComposedNode *cnode = dynamic_cast<SubjectComposedNode*>(getSubject());
      if (cnode)
        if (!node->reparent(cnode))
          Message mess;
    }
}

References _dragOver, YACS::HMI::GenericGui::_guiEditor, YACS::HMI::Resource::COMPONENT_INSTANCE_NEW, YACS::HMI::GuiEditor::CreateNodeFromCatalog(), YACS::HMI::ItemMimeData::getControl(), YACS::HMI::QtGuiContext::getGMain(), YACS::HMI::QtGuiContext::getQtCurrent(), YACS::HMI::SceneObserverItem::getSubject(), YACS::HMI::ItemMimeData::getSubject(), YACS::HMI::SubjectNode::reparent(), and YACS::HMI::SceneItem::setEventPos().

◆ getBrushColor()

QColor SceneComposedNodeItem::getBrushColor ( )

protectedvirtual

Reimplemented from YACS::HMI::SceneObserverItem.

Definition at line 903 of file SceneComposedNodeItem.cxx.

{
  if (_dragOver)
    return _hiBrushColor;
 
  QColor color;
  if (isSelected())
    color = _hiBrushColor;
  else if (_emphasized)
    color = Resource::emphasizeBrushColor;
  else 
    color = _brushColor;
 
  if (_hover)
    color = hoverColor(color);
  return color;
}

References YACS::HMI::AbstractSceneItem::_brushColor, _dragOver, YACS::HMI::SceneObserverItem::_emphasized, YACS::HMI::AbstractSceneItem::_hiBrushColor, YACS::HMI::SceneItem::_hover, YACS::HMI::Resource::emphasizeBrushColor, and YACS::HMI::SceneItem::hoverColor().

Referenced by paint().

◆ getChildren()

std::list< AbstractSceneItem * > SceneComposedNodeItem::getChildren ( )

virtual

Definition at line 384 of file SceneComposedNodeItem.cxx.

{
  return _children;
}

References _children.

Referenced by YACS::HMI::LinkMatrix::explore().

◆ getPenColor()

QColor SceneComposedNodeItem::getPenColor ( )

protectedvirtual

Reimplemented from YACS::HMI::SceneItem.

Definition at line 893 of file SceneComposedNodeItem.cxx.

{
  if (_dragOver)
    return Resource::dragOver;
  if (isSelected())
    return _hiPenColor;
  else 
    return _penColor;
}

References _dragOver, YACS::HMI::AbstractSceneItem::_hiPenColor, YACS::HMI::AbstractSceneItem::_penColor, and YACS::HMI::Resource::dragOver.

Referenced by paint().

◆ hasExpandedChildren()

bool SceneComposedNodeItem::hasExpandedChildren ( bool recursively )

virtual

Definition at line 467 of file SceneComposedNodeItem.cxx.

{
  bool res = false;
  for (list<AbstractSceneItem*>::const_iterator it=_children.begin(); it!=_children.end() && !res; ++it) {
    SceneItem* item = dynamic_cast<SceneItem*>(*it);
    SceneNodeItem *sni = dynamic_cast<SceneNodeItem*>(item);
    if (sni->isExpanded()) {
      res = true;
      if (recursively)
        if (SceneComposedNodeItem *scni = dynamic_cast<SceneComposedNodeItem*>(sni))
          res = scni->hasExpandedChildren(recursively);
    }
  }
  return res;
}

References _children, and YACS::HMI::SceneNodeItem::isExpanded().

Referenced by reorganizeShrinkExpand().

◆ paint()

void SceneComposedNodeItem::paint	(	QPainter *	painter,
		const QStyleOptionGraphicsItem *	option,
		QWidget *	widget
	)

virtual

Reimplemented from YACS::HMI::SceneNodeItem.

Definition at line 101 of file SceneComposedNodeItem.cxx.

{
  //DEBTRACE("SceneComposedNodeItem::paint " << _label.toStdString());
  // IMN (14/11/2013) below block commented
  // prevent bad resizing of scene in shrink mode
  /*  if (!isExpanded()) {
    _width  = 2*Resource::Corner_Margin + 2*Resource::DataPort_Width + Resource::Space_Margin;
    _height = getHeaderBottom() + Resource::Corner_Margin;
  };*/
 
  painter->save();
  painter->setPen(getPenColor());
  painter->setBrush(getBrushColor());
  painter->drawRect(QRectF(Resource::Border_Margin, Resource::Border_Margin, _width - 2*Resource::Border_Margin, _height - 2*Resource::Border_Margin));
  painter->restore();
}

References YACS::HMI::AbstractSceneItem::_height, YACS::HMI::AbstractSceneItem::_width, YACS::HMI::Resource::Border_Margin, getBrushColor(), and getPenColor().

◆ popupMenu()

void SceneComposedNodeItem::popupMenu	(	QWidget *	caller,
		const QPoint &	globalPos
	)

virtual

Reimplemented from YACS::HMI::SceneNodeItem.

Reimplemented in YACS::HMI::SceneProcItem.

Definition at line 378 of file SceneComposedNodeItem.cxx.

{
  ComposedNodeMenu m;
  m.popupMenu(caller, globalPos);
}

References gui.GraphViewer::m.

◆ rebuildLinks()

void SceneComposedNodeItem::rebuildLinks ( )

virtual

Definition at line 741 of file SceneComposedNodeItem.cxx.

{
  DEBTRACE("SceneComposedNodeItem::rebuildLinks " << QtGuiContext::_delayCalc);
  if (QtGuiContext::_delayCalc)
    return;
  CHRONO(1);
  CHRONO(2);
  LinkMatrix matrix(this);
  matrix.compute();
  CHRONOSTOP(2);
  CHRONO(3);
  list<linkdef> alist = matrix.getListOfDataLinkDef();
  list<linkdef> blist = matrix.getListOfCtrlLinkDef(); // add list operator ?
  for (list<linkdef>::const_iterator ii = blist.begin(); ii != blist.end(); ++ii)
    alist.push_back(*ii);
 
  CHRONOSTOP(3);
  CHRONO(4);
  LinkAStar astar(matrix);
  for (list<linkdef>::const_iterator it = alist.begin(); it != alist.end(); ++it)
    {
      linkdef ali = *it;
      DEBTRACE("from("<<ali.from.first<<","<<ali.from.second
               <<") to ("<<ali.to.first<<","<<ali.to.second
               <<") " << ali.item->getLabel().toStdString());
      if(ali.from.first<0||ali.from.second<0||ali.to.first<0||ali.to.second<0) continue;
      CHRONO(5);
      bool isPath = astar.computePath(LNode(ali.from), LNode(ali.to));
      CHRONOSTOP(5);
      CHRONO(6);
      if (! isPath) DEBTRACE("Link Path not found !");
      if (! isPath) continue;
      LNodePath ijPath = astar.givePath();
      if(Scene::_addRowCols)
        matrix.incrementCost(ijPath);
      LinkPath apath = matrix.getPath(ijPath);
//       DEBTRACE(apath.size());
      CHRONOSTOP(6);
      CHRONO(7);
      ali.item->setPath(apath);
    }
}

References YACS::HMI::Scene::_addRowCols, YACS::HMI::QtGuiContext::_delayCalc, CHRONO, CHRONOSTOP, YACS::HMI::LinkMatrix::compute(), YACS::HMI::LinkAStar::computePath(), DEBTRACE, YACS::HMI::linkdef::from, YACS::HMI::AbstractSceneItem::getLabel(), YACS::HMI::LinkMatrix::getListOfCtrlLinkDef(), YACS::HMI::LinkMatrix::getListOfDataLinkDef(), YACS::HMI::LinkMatrix::getPath(), YACS::HMI::LinkAStar::givePath(), YACS::HMI::LinkMatrix::incrementCost(), YACS::HMI::linkdef::item, YACS::HMI::SceneLinkItem::setPath(), and YACS::HMI::linkdef::to.

Referenced by YACS::HMI::SceneBlocItem::arrangeCanvasNodes(), arrangeNodes(), autoPosNewChild(), YACS::HMI::SceneNodeItem::mouseReleaseEvent(), YACS::HMI::GuiEditor::rebuildLinks(), reorganizeShrinkExpand(), YACS::HMI::SceneElementaryNodeItem::reorganizeShrinkExpand(), update(), YACS::HMI::SceneElementaryNodeItem::update(), and YACS::HMI::TablePortsEdition::upOrDown().

◆ removeChildFromList()

void SceneComposedNodeItem::removeChildFromList ( AbstractSceneItem * child )

virtual

Definition at line 389 of file SceneComposedNodeItem.cxx.

{
  _children.remove(child);
}

References _children.

Referenced by update().

◆ reorganize()

void SceneComposedNodeItem::reorganize ( )

virtual

Reimplemented from YACS::HMI::AbstractSceneItem.

Definition at line 608 of file SceneComposedNodeItem.cxx.

{
  DEBTRACE("SceneComposedNodeItem::reorganize() " << _label.toStdString());
  list<AbstractSceneItem*> alreadySet;
  for (list<AbstractSceneItem*>::const_iterator it=_children.begin(); it!=_children.end(); ++it)
    {
      autoPosNewChild(*it, alreadySet);
      alreadySet.push_back(*it);
    }
}

References _children, YACS::HMI::AbstractSceneItem::_label, autoPosNewChild(), and DEBTRACE.

Referenced by arrangeChildNodes().

◆ reorganizeShrinkExpand()

void SceneComposedNodeItem::reorganizeShrinkExpand ( ShrinkMode theShrinkMode )

virtual

Reimplemented from YACS::HMI::SceneNodeItem.

Definition at line 429 of file SceneComposedNodeItem.cxx.

                                                                           {
  DEBTRACE("SceneComposedNodeItem::reorganizeShrinkExpand " << _expanded << " " << _label.toStdString());
 
  bool toExpand = true;
  if (theShrinkMode == CurrentNode) {
    // shrink/expand current node only
    toExpand = !isExpanded();
 
    updateControlLinks(toExpand);
    shrinkExpandRecursive(toExpand, true, theShrinkMode);
 
  } else {
    if (!isExpanded())
      return;
    // shrink/expand child nodes
    toExpand = !hasExpandedChildren(theShrinkMode == ElementaryNodes);
    for (list<AbstractSceneItem*>::const_iterator it=_children.begin(); it!=_children.end(); ++it) {
      SceneItem* item = dynamic_cast<SceneItem*>(*it);
      SceneNodeItem *sni = dynamic_cast<SceneNodeItem*>(item);
      item->shrinkExpandRecursive(toExpand, true, theShrinkMode);
    }
    _ancestorShrinked = !toExpand;
    _width = _expandedWidth;
    _height = _expandedHeight;
    _shownState = expandShown;
    adjustHeader();
    rebuildLinks();
  }
 
  if (Scene::_autoComputeLinks)
    {
      SubjectProc* subproc = QtGuiContext::getQtCurrent()->getSubjectProc();
      SceneItem *item = QtGuiContext::getQtCurrent()->_mapOfSceneItem[subproc];
      SceneComposedNodeItem *proc = dynamic_cast<SceneComposedNodeItem*>(item);
      proc->rebuildLinks();
    }
}

References YACS::HMI::SceneItem::_ancestorShrinked, YACS::HMI::Scene::_autoComputeLinks, _children, YACS::HMI::SceneNodeItem::_expanded, YACS::HMI::SceneNodeItem::_expandedHeight, YACS::HMI::SceneNodeItem::_expandedWidth, YACS::HMI::AbstractSceneItem::_height, YACS::HMI::AbstractSceneItem::_label, YACS::HMI::QtGuiContext::_mapOfSceneItem, YACS::HMI::SceneNodeItem::_shownState, YACS::HMI::AbstractSceneItem::_width, YACS::HMI::SceneNodeItem::adjustHeader(), YACS::HMI::CurrentNode, DEBTRACE, YACS::HMI::ElementaryNodes, YACS::HMI::expandShown, YACS::HMI::QtGuiContext::getQtCurrent(), YACS::HMI::GuiContext::getSubjectProc(), hasExpandedChildren(), YACS::HMI::SceneNodeItem::isExpanded(), rebuildLinks(), shrinkExpandRecursive(), YACS::HMI::SceneItem::shrinkExpandRecursive(), and updateControlLinks().

◆ setShownState()

void SceneComposedNodeItem::setShownState ( shownState ss )

virtual

Reimplemented from YACS::HMI::SceneNodeItem.

Definition at line 619 of file SceneComposedNodeItem.cxx.

{
  _shownState = ss;
  if (_shownState == shrinkHidden)
    {
      _ancestorShrinked = true;
      hide();
    }
  else
    {
      _ancestorShrinked = false;
      show();
    }
  adjustHeader();
  if (_progressItem)
    _progressItem->adjustGeometry();
}

References YACS::HMI::SceneItem::_ancestorShrinked, YACS::HMI::SceneNodeItem::_progressItem, YACS::HMI::SceneNodeItem::_shownState, YACS::HMI::SceneProgressItem::adjustGeometry(), YACS::HMI::SceneNodeItem::adjustHeader(), and YACS::HMI::shrinkHidden.

◆ shrinkExpandLink()

void SceneComposedNodeItem::shrinkExpandLink ( bool se )

virtual

Reimplemented from YACS::HMI::SceneNodeItem.

Definition at line 598 of file SceneComposedNodeItem.cxx.

                                                    {
  DEBTRACE("SceneComposedNodeItem::shrinkExpandLink " << se << " "  << _label.toStdString());
  se = se && isExpanded();
  foreach (QGraphicsItem *child, childItems()) {
    if (SceneItem *sci = dynamic_cast<SceneItem*>(child)) {
      sci->shrinkExpandLink(se);
    };
  };
}

References YACS::HMI::AbstractSceneItem::_label, DEBTRACE, and YACS::HMI::SceneNodeItem::isExpanded().

◆ shrinkExpandRecursive()

void SceneComposedNodeItem::shrinkExpandRecursive	(	bool	isExpanding,
		bool	fromHere,
		ShrinkMode	theShrinkMode
	)

virtual

Reimplemented from YACS::HMI::SceneItem.

Definition at line 483 of file SceneComposedNodeItem.cxx.

{
  DEBTRACE("SceneComposedNodeItem::shrinkExpandRecursive " << toExpand << " " << fromHere << " " << isExpanded() << " " << _label.toStdString());
  
  bool toChangeShrinkState = false;
  switch (theShrinkMode) {
  case CurrentNode:
    if (fromHere)
      toChangeShrinkState = true;
    break;
  case ChildrenNodes:
    if (fromHere)
      toChangeShrinkState = true;
    break;
  case ElementaryNodes:
    toChangeShrinkState = false;
    break;
  }
  if (toChangeShrinkState) {
    if (toExpand != isExpanded())
      setExpanded(toExpand);
  } else if (!isExpanded() && theShrinkMode == ElementaryNodes) {
    return;
  }
 
  updateControlLinks(toExpand);
 
  if (!toExpand)
    { // ---collapsing: hide first children , then resize
      for (list<AbstractSceneItem*>::const_iterator it=_children.begin(); it!=_children.end(); ++it)
        {
          SceneItem* item = dynamic_cast<SceneItem*>(*it);
          item->shrinkExpandRecursive(toExpand, false, theShrinkMode);
          if (theShrinkMode != ElementaryNodes) {
            item->hide();  
            DEBTRACE("------------------------------- Hide " << item->getLabel().toStdString());
            item->shrinkExpandLink(false);  
          }
        }
 
      if (toChangeShrinkState || theShrinkMode != ElementaryNodes) {
        if (_shownState == expandShown)
          {
             _expandedWidth = _width;
             _expandedHeight = _height;
          }
 
        if (fromHere)
          {
            _shownState = shrinkShown;
          }
        else
          {
            _ancestorShrinked = true;
            _shownState = shrinkHidden;
          }
 
        _width  = 2*Resource::Corner_Margin + 2*Resource::DataPort_Width + Resource::Space_Margin;
        if (_shownState == shrinkShown)
          _height = getHeaderBottom() + Resource::Corner_Margin;
        else
          _height = Resource::Header_Height + Resource::Corner_Margin;
      
        if (_shownState == shrinkHidden) // shrink of ancestor
          setPos(0 ,0);
        else
          setPos(_expandedPos);
        adjustHeader();
        if (_progressItem)
          _progressItem->adjustGeometry();
      }
    }
  else
    { // --- expanding: resize, then show children
      if (toChangeShrinkState)
        _ancestorShrinked = false;
 
      for (list<AbstractSceneItem*>::const_iterator it=_children.begin(); it!=_children.end(); ++it)
        {
          SceneItem* item = dynamic_cast<SceneItem*>(*it);
          item->shrinkExpandRecursive(isExpanded(), false, theShrinkMode); 
          if (theShrinkMode != ElementaryNodes) {
            if (isExpanded())
              {
                item->show();  
                DEBTRACE("------------------------------- Show " << item->getLabel().toStdString());
              }
            else
              {
                item->hide();  
                DEBTRACE("------------------------------- Hide " << item->getLabel().toStdString());
              }
            item->shrinkExpandLink(fromHere);  
          }
        }
 
      if (isExpanded())
        {
          _width = _expandedWidth;
          _height = _expandedHeight;
          _shownState = expandShown;
        }
      else
        {
          _shownState = shrinkShown;
          _width  = 2*Resource::Corner_Margin + 2*Resource::DataPort_Width + Resource::Space_Margin;
          _height = getHeaderBottom() + Resource::Corner_Margin;
        }
      setPos(_expandedPos);
      adjustHeader();
      if (_progressItem)
        _progressItem->adjustGeometry();
    }
}

Referenced by reorganizeShrinkExpand().

◆ update()

void SceneComposedNodeItem::update	(	GuiEvent	event,
		int	type,
		Subject *	son
	)

virtual

Reimplemented from YACS::HMI::SceneNodeItem.

Definition at line 120 of file SceneComposedNodeItem.cxx.

{
  DEBTRACE("SceneComposedNodeItem::update "<< eventName(event)<<" "<<type<<" "<<son);
  SceneNodeItem::update(event, type, son);
  AbstractSceneItem *item;
  switch (event)
    {
    case YACS::HMI::ADD:
      switch (type)
        {
        case YACS::HMI::BLOC:
          item =  new SceneBlocItem(_scene,
                                    this,
                                    son->getName().c_str(),
                                    son);
          item->addHeader();
          autoPosNewChild(item, _children, true);
          break;
        case YACS::HMI::FORLOOP:
        case YACS::HMI::WHILELOOP:
        case YACS::HMI::SWITCH:
        case YACS::HMI::FOREACHLOOP:
        case YACS::HMI::OPTIMIZERLOOP:
          item =  new SceneComposedNodeItem(_scene,
                                            this,
                                            son->getName().c_str(),
                                            son);
          item->addHeader();
          if ( !QtGuiContext::getQtCurrent()->isEdition()
            && (type == YACS::HMI::FORLOOP || type == YACS::HMI::FOREACHLOOP) )
            {
              item->addProgressItem();
            }
          autoPosNewChild(item, _children, true);
          break;
        case YACS::HMI::PYTHONNODE:
        case YACS::HMI::PYFUNCNODE:
        case YACS::HMI::CORBANODE:
        case YACS::HMI::CPPNODE:
        case YACS::HMI::SALOMENODE:
        case YACS::HMI::SALOMEPYTHONNODE:
        case YACS::HMI::XMLNODE:
        case YACS::HMI::PRESETNODE:
        case YACS::HMI::OUTNODE:
        case YACS::HMI::STUDYINNODE:
        case YACS::HMI::STUDYOUTNODE:
          item =  new SceneElementaryNodeItem(_scene,
                                              this,
                                              son->getName().c_str(),
                                              son);
          item->addHeader();
          autoPosNewChild(item, _children, true);
          break;
        case YACS::HMI::INPUTPORT:
        case YACS::HMI::INPUTDATASTREAMPORT:
          item =  new SceneInPortItem(_scene,
                                      _header,
                                      son->getName().c_str(),
                                      son);
          _header->autoPosNewPort(item);
          _inPorts.push_back(item);
          if (Scene::_autoComputeLinks && !QtGuiContext::getQtCurrent()->isLoading())
            {
              YACS::HMI::SubjectProc* subproc = QtGuiContext::getQtCurrent()->getSubjectProc();
              SceneItem *item = QtGuiContext::getQtCurrent()->_mapOfSceneItem[subproc];
              SceneComposedNodeItem *proc = dynamic_cast<SceneComposedNodeItem*>(item);
              proc->rebuildLinks();
            }
          break;
        case YACS::HMI::OUTPUTPORT:
        case YACS::HMI::OUTPUTDATASTREAMPORT:
          item =  new SceneOutPortItem(_scene,
                                       _header,
                                       son->getName().c_str(),
                                       son);
          _header->autoPosNewPort(item);
          _outPorts.push_back(item);
          if (Scene::_autoComputeLinks && !QtGuiContext::getQtCurrent()->isLoading())
            {
              YACS::HMI::SubjectProc* subproc = QtGuiContext::getQtCurrent()->getSubjectProc();
              SceneItem *item = QtGuiContext::getQtCurrent()->_mapOfSceneItem[subproc];
              SceneComposedNodeItem *proc = dynamic_cast<SceneComposedNodeItem*>(item);
              proc->rebuildLinks();
            }
          break;
        default:
          DEBTRACE("SceneComposedNodeItem::update() ADD, type not handled:" << type);
        }
      break;
    case YACS::HMI::ADDLINK:
      switch (type)
        {
        case YACS::HMI::DATALINK:
          if (SubjectLink* slink = dynamic_cast<SubjectLink*>(son))
            {
              SubjectDataPort* soutp = slink->getSubjectOutPort();
              SubjectDataPort* sinp  = slink->getSubjectInPort();
              SceneItem * scout = QtGuiContext::getQtCurrent()->_mapOfSceneItem[soutp];
              SceneItem * scin  = QtGuiContext::getQtCurrent()->_mapOfSceneItem[sinp];
              ScenePortItem* from = dynamic_cast<ScenePortItem*>(scout);
              ScenePortItem* to  = dynamic_cast<ScenePortItem*>(scin);
              if (dynamic_cast<SubjectInputDataStreamPort*>(sinp))
                {
                  SceneDSLinkItem* item = new SceneDSLinkItem(_scene,
                                             this,
                                             from, to,
                                             son->getName().c_str(),
                                             son);
                  item->updateShape();
                }
              else
                {
                  SceneLinkItem* item = new SceneLinkItem(_scene,
                                           this,
                                           from, to,
                                           son->getName().c_str(),
                                           son);
                  item->updateShape();
                }
              if (Scene::_autoComputeLinks && !QtGuiContext::getQtCurrent()->isLoading())
                {
                  YACS::HMI::SubjectProc* subproc = QtGuiContext::getQtCurrent()->getSubjectProc();
                  SceneItem *item = QtGuiContext::getQtCurrent()->_mapOfSceneItem[subproc];
                  SceneComposedNodeItem *proc = dynamic_cast<SceneComposedNodeItem*>(item);
                  proc->rebuildLinks();
                }
            }
          break;
        }
      break;
    case YACS::HMI::ADDCONTROLLINK:
      switch (type)
        {
        case YACS::HMI::CONTROLLINK:
          if (SubjectControlLink* slink = dynamic_cast<SubjectControlLink*>(son))
            {
              SubjectNode* soutn = slink->getSubjectOutNode();
              SubjectNode* sinn  = slink->getSubjectInNode();
              SceneItem * scout = QtGuiContext::getQtCurrent()->_mapOfSceneItem[soutn];
              SceneItem * scin  = QtGuiContext::getQtCurrent()->_mapOfSceneItem[sinn];
              SceneNodeItem* nodefrom = dynamic_cast<SceneNodeItem*>(scout);
              SceneNodeItem* nodeto  = dynamic_cast<SceneNodeItem*>(scin);
              if (!nodeto || !nodefrom) DEBTRACE("CONTROLLINK problem -----------------");
              ScenePortItem* from = nodefrom->getCtrlOutPortItem();
              ScenePortItem* to = nodeto->getCtrlInPortItem();
              if (!to || !from) DEBTRACE("CONTROLLINK problem -----------------");
              SceneCtrlLinkItem* item = new SceneCtrlLinkItem(_scene,
                                           this,
                                           from, to,
                                           son->getName().c_str(),
                                           son);
              item->updateShape();
              if (Scene::_autoComputeLinks && !QtGuiContext::getQtCurrent()->isLoading())
                {
                  YACS::HMI::SubjectProc* subproc = QtGuiContext::getQtCurrent()->getSubjectProc();
                  SceneItem *item = QtGuiContext::getQtCurrent()->_mapOfSceneItem[subproc];
                  SceneComposedNodeItem *proc = dynamic_cast<SceneComposedNodeItem*>(item);
                  proc->rebuildLinks();
                }
            }
          break;
        }
      break;
    case YACS::HMI::REMOVE:
      //SceneObserverItem::update(event, type, son);
      break;
    case YACS::HMI::SETCASE:
      {
        SubjectSwitch *sSwitch = dynamic_cast<SubjectSwitch*>(_subject);
        if (sSwitch)
          {
            Switch *aSwitch = dynamic_cast<Switch*>(sSwitch->getNode());
            Node *node = aSwitch->edGetNode(type);
            if (node)
              {
                if (GuiContext::getCurrent()->_mapOfSubjectNode.count(node))
                  {
                    Subject* sub = GuiContext::getCurrent()->_mapOfSubjectNode[node];
                    if (QtGuiContext::getQtCurrent()->_mapOfSceneItem.count(sub))
                      {
                        SceneItem* item = QtGuiContext::getQtCurrent()->_mapOfSceneItem[sub];
                        SceneNodeItem *scnode = dynamic_cast<SceneNodeItem*>(item);
                        if (scnode) scnode->updateName();
                      }
                  }
              }
          }
      }
      break;
    case YACS::HMI::CUT:
      {
        SceneItem * sinode  = QtGuiContext::getQtCurrent()->_mapOfSceneItem[son];
        removeChildFromList(sinode);
      }
      break;
    case YACS::HMI::PASTE:
      {
        SceneItem * sinode  = QtGuiContext::getQtCurrent()->_mapOfSceneItem[son];
        sinode->setParent(this);
        sinode->setLevel();
        if (SceneComposedNodeItem *scnode = dynamic_cast<SceneComposedNodeItem*>(sinode))
          scnode->adjustColors();
        autoPosNewChild(sinode, _children, true);
      }
      break;
    case PROGRESS:
      {
        if (dynamic_cast<SubjectForLoop*>(son) || dynamic_cast<SubjectForEachLoop*>(son))
        {
          if (SceneProgressItem* spitem = getProgressItem())
            spitem->setProgress(son->getProgress().c_str());
        }
      }
      break;
    default:
       ;
//       DEBTRACE("SceneComposedNodeItem::update(), event not handled: "<< eventName(event));
    }
}

Referenced by gui.graph.MyCanvas::customEvent().

◆ updateChildItems()

void SceneComposedNodeItem::updateChildItems ( )

virtual

Reimplemented from YACS::HMI::SceneNodeItem.

Definition at line 921 of file SceneComposedNodeItem.cxx.

{
  SceneNodeItem::updateChildItems();
  if(!_header)
    return;
  foreach (QGraphicsItem *child, _header->childItems())
    {
      if (SceneItem *sci = dynamic_cast<SceneItem*>(child))
        {
           sci->updateLinks();
        }
    }
}

References YACS::HMI::SceneNodeItem::_header, and YACS::HMI::SceneNodeItem::updateChildItems().

◆ updateControlLinks()

void SceneComposedNodeItem::updateControlLinks ( bool toExpand )

protected

Definition at line 394 of file SceneComposedNodeItem.cxx.

{
  //update control links
  std::list<SubjectControlLink*> lscl=dynamic_cast<SubjectNode*>(getSubject())->getSubjectControlLinks();
  for (std::list<SubjectControlLink*>::const_iterator it = lscl.begin(); it != lscl.end(); ++it) {
    SceneLinkItem* lk = dynamic_cast<SceneLinkItem*>(QtGuiContext::getQtCurrent()->_mapOfSceneItem[*it]);
 
    bool b1 = true, b2 = true;
 
    SceneNodeItem* no = lk->getFromNode();
    if (no) {
      SceneComposedNodeItem* scni = dynamic_cast<SceneComposedNodeItem*>(no);
      if (scni) {
        b1 = scni!=this;
      };
    };
 
    no = lk->getToNode();
    if (no) {
      SceneComposedNodeItem* scni = dynamic_cast<SceneComposedNodeItem*>(no);
      if (scni) {
        b2 = scni!=this;
      };
    };
 
    if (b1 && b2) {
      if (toExpand) {
        lk->show();
      } else {
        lk->hide();
      };
    };
  };
}

References YACS::HMI::QtGuiContext::_mapOfSceneItem, YACS::HMI::SceneLinkItem::getFromNode(), YACS::HMI::QtGuiContext::getQtCurrent(), YACS::HMI::SceneObserverItem::getSubject(), and YACS::HMI::SceneLinkItem::getToNode().

Referenced by reorganizeShrinkExpand(), and shrinkExpandRecursive().

Member Data Documentation

◆ _children

std::list<AbstractSceneItem*> YACS::HMI::SceneComposedNodeItem::_children

protected

Definition at line 67 of file SceneComposedNodeItem.hxx.

Referenced by adjustColors(), autoPosNewChild(), childrenBoundingRect(), collisionResolv(), getChildren(), hasExpandedChildren(), removeChildFromList(), reorganize(), reorganizeShrinkExpand(), shrinkExpandRecursive(), and update().

◆ _dragOver

bool YACS::HMI::SceneComposedNodeItem::_dragOver

protected

Definition at line 68 of file SceneComposedNodeItem.hxx.

Referenced by dragEnterEvent(), dragLeaveEvent(), dropEvent(), getBrushColor(), getPenColor(), and SceneComposedNodeItem().

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

src/genericgui/SceneComposedNodeItem.hxx
src/genericgui/SceneComposedNodeItem.cxx

Public Member Functions

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ SceneComposedNodeItem()

◆ ~SceneComposedNodeItem()

Member Function Documentation

◆ adjustColors()

◆ arrangeChildNodes()

◆ arrangeNodes()

◆ autoPosNewChild()

◆ childrenBoundingRect()

◆ collisionResolv()

◆ dragEnterEvent()

◆ dragLeaveEvent()

◆ dropEvent()

◆ getBrushColor()

◆ getChildren()

◆ getPenColor()

◆ hasExpandedChildren()

◆ paint()

◆ popupMenu()

◆ rebuildLinks()

◆ removeChildFromList()

◆ reorganize()

◆ reorganizeShrinkExpand()

◆ setShownState()

◆ shrinkExpandLink()

◆ shrinkExpandRecursive()

◆ update()

◆ updateChildItems()

◆ updateControlLinks()

Member Data Documentation

◆ _children

◆ _dragOver