#include <SceneComposedNodeItem.hxx>

Inheritance diagram for YACS::HMI::SceneComposedNodeItem:

Collaboration diagram for YACS::HMI::SceneComposedNodeItem:

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 qreal	getHeaderBottom ()

virtual void	autoPosNewPort (AbstractSceneItem *item, int nbPorts)

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	showOutScopeLinks ()

virtual void	updateLinks ()

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	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 void	checkGeometryChange ()

void	setParent (SceneItem *parent)

void	setEventPos (QPointF point)

bool	isAncestorShrinked ()

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

virtual	~AbstractSceneItem ()

int	getLevel ()

void	setLevel ()

virtual QString	getLabel ()

qreal	getWidth ()

qreal	getHeight ()

virtual void	setGeometryOptimization (bool optimize)

SceneItem *	getParent ()

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

virtual	~GuiObserver ()

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 ()

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	(	QGraphicsScene *	scene,
		SceneItem *	parent,
		QString	label,
		Subject *	subject
	)

Definition at line 59 of file SceneComposedNodeItem.cxx.

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().

   : 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);
 }

SceneComposedNodeItem::~SceneComposedNodeItem ( )

virtual

Definition at line 76 of file SceneComposedNodeItem.cxx.

77 {

78 }

Member Function Documentation

void SceneComposedNodeItem::adjustColors ( )

virtual

Definition at line 80 of file SceneComposedNodeItem.cxx.

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

Referenced by SceneComposedNodeItem().

 {
   _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();
     }
  }

void SceneComposedNodeItem::arrangeChildNodes ( )

virtual

Reimplemented from YACS::HMI::SceneNodeItem.

Reimplemented in YACS::HMI::SceneBlocItem.

Definition at line 829 of file SceneComposedNodeItem.cxx.

References reorganize().

Referenced by arrangeNodes().

 {
   reorganize();
 }

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.

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

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

 {
   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();
     }
 }

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

virtual

Definition at line 340 of file SceneComposedNodeItem.cxx.

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(), YACS::HMI::GuiContext::isLoading(), rebuildLinks(), YACS::HMI::AbstractSceneItem::setTopLeft(), YACS::HMI::Resource::Space_Margin, and YASSERT.

Referenced by reorganize(), and update().

 {
   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);
 }

QRectF SceneComposedNodeItem::childrenBoundingRect ( ) const

virtual

Reimplemented from YACS::HMI::SceneItem.

Definition at line 90 of file SceneComposedNodeItem.cxx.

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

 {
   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;
 }

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

virtual

Definition at line 637 of file SceneComposedNodeItem.cxx.

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

Referenced by autoPosNewChild().

 {
   //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));
                 }
             }
         }
     } 
 }

void SceneComposedNodeItem::dragEnterEvent ( QGraphicsSceneDragDropEvent * event )

protected

Definition at line 834 of file SceneComposedNodeItem.cxx.

References _dragOver.

 {
   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);
 }

void SceneComposedNodeItem::dragLeaveEvent ( QGraphicsSceneDragDropEvent * event )

protected

Definition at line 853 of file SceneComposedNodeItem.cxx.

References _dragOver.

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

void SceneComposedNodeItem::dropEvent ( QGraphicsSceneDragDropEvent * event )

protected

Definition at line 860 of file SceneComposedNodeItem.cxx.

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().

 {
   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;
     }
 }

QColor SceneComposedNodeItem::getBrushColor ( )

protectedvirtual

Reimplemented from YACS::HMI::SceneObserverItem.

Definition at line 903 of file SceneComposedNodeItem.cxx.

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().

 {
   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;
 }

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

virtual

Definition at line 384 of file SceneComposedNodeItem.cxx.

References _children.

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

 {
   return _children;
 }

QColor SceneComposedNodeItem::getPenColor ( )

protectedvirtual

Reimplemented from YACS::HMI::SceneItem.

Definition at line 893 of file SceneComposedNodeItem.cxx.

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

Referenced by paint().

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

bool SceneComposedNodeItem::hasExpandedChildren ( bool recursively )

virtual

Definition at line 467 of file SceneComposedNodeItem.cxx.

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

Referenced by reorganizeShrinkExpand().

 {
   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;
 }

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

virtual

Reimplemented from YACS::HMI::SceneNodeItem.

Definition at line 101 of file SceneComposedNodeItem.cxx.

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

 {
   //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();
 }

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.

References gui.GraphViewer::m, and YACS::HMI::ComposedNodeMenu::popupMenu().

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

void SceneComposedNodeItem::rebuildLinks ( )

virtual

Definition at line 741 of file SceneComposedNodeItem.cxx.

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(), YACS::HMI::SceneElementaryNodeItem::reorganizeShrinkExpand(), reorganizeShrinkExpand(), update(), YACS::HMI::SceneElementaryNodeItem::update(), and YACS::HMI::TablePortsEdition::upOrDown().

 {
   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);
     }
 }

void SceneComposedNodeItem::removeChildFromList ( AbstractSceneItem * child )

virtual

Definition at line 389 of file SceneComposedNodeItem.cxx.

References _children.

Referenced by update().

 {
   _children.remove(child);
 }

void SceneComposedNodeItem::reorganize ( )

virtual

Reimplemented from YACS::HMI::AbstractSceneItem.

Definition at line 608 of file SceneComposedNodeItem.cxx.

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

Referenced by arrangeChildNodes().

 {
   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);
     }
 }

void SceneComposedNodeItem::reorganizeShrinkExpand ( ShrinkMode theShrinkMode )

virtual

Reimplemented from YACS::HMI::SceneNodeItem.

Definition at line 429 of file SceneComposedNodeItem.cxx.

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().

                                                                            {
   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();
     }
 }

void SceneComposedNodeItem::setShownState ( shownState ss )

virtual

Reimplemented from YACS::HMI::SceneNodeItem.

Definition at line 619 of file SceneComposedNodeItem.cxx.

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.

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

void SceneComposedNodeItem::shrinkExpandLink ( bool se )

virtual

Reimplemented from YACS::HMI::SceneNodeItem.

Definition at line 598 of file SceneComposedNodeItem.cxx.

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

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

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

virtual

Reimplemented from YACS::HMI::SceneItem.

Definition at line 483 of file SceneComposedNodeItem.cxx.

Referenced by reorganizeShrinkExpand().

 {
   DEBTRACE("SceneComposedNodeItem::shrinkExpandRecursive " << isExpanding << " " << 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();
     }
 }

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

virtual

Reimplemented from YACS::HMI::SceneNodeItem.

Definition at line 120 of file SceneComposedNodeItem.cxx.

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

 {
   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));
     }
 }

void SceneComposedNodeItem::updateChildItems ( )

virtual

Reimplemented from YACS::HMI::SceneNodeItem.

Definition at line 921 of file SceneComposedNodeItem.cxx.

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

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

void SceneComposedNodeItem::updateControlLinks ( bool toExpand )

protected

Definition at line 394 of file SceneComposedNodeItem.cxx.

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().

 {
   //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();
       };
     };
   };
 }

Member Data Documentation

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().

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

Member Function Documentation

Member Data Documentation