ui: graph showing neighbours

The graph view can now display the n1 neighbours of the active node, including connections between neighbours.

src/app/qt/view/QtGraphView.cpp

@@ -12,6 +12,7 @@
 #include "qt/QtWidgetWrapper.h"
 #include "qt/view/graphElements/QtGraphEdge.h"
 #include "qt/view/graphElements/QtGraphNode.h"
+#include "qt/view/graphElements/QtGraphNodeMovable.h"
 
 QtGraphView::QtGraphView(ViewLayout* viewLayout)
 	: GraphView(viewLayout)
@@ -70,15 +71,41 @@ QGraphicsView* QtGraphView::getView()
 
 void QtGraphView::doRebuildGraph(const std::vector<DummyNode>& nodes, const std::vector<DummyEdge>& edges)
 {
-	doClear();
-
 	QGraphicsView* view = getView();
 
 	if (view != NULL)
 	{
+		std::map<Id, std::weak_ptr<GraphNode>> weakNodes; // used when creating the edges
+		std::list<std::shared_ptr<GraphNode>> newNodes; // temporary stores all nodes (existing and newly created) needed in the new graph
+														// this is a relatively easy and cheap way to save existing nodes that are still needed
+
+		// create nodes (or find existing nodes for re-use)
 		for(unsigned int i = 0; i < nodes.size(); i++)
 		{
 			std::shared_ptr<GraphNode> newNode = findOrCreateNode(view, nodes[i]);
+			newNodes.push_back(newNode);
+			weakNodes[nodes[i].tokenId] = newNode;
+		}
+
+		doClear();
+		m_nodes = newNodes;
+
+		// create edges
+		for(unsigned int i = 0; i < edges.size(); i++)
+		{
+			if (weakNodes.find(edges[i].ownerId) != weakNodes.end() && weakNodes.find(edges[i].targetId) != weakNodes.end())
+			{
+				if (weakNodes[edges[i].ownerId].expired() == false && weakNodes[edges[i].targetId].expired() == false)
+				{
+					std::shared_ptr<QtGraphEdge> newEdge = std::make_shared<QtGraphEdge>(weakNodes[edges[i].ownerId], weakNodes[edges[i].targetId]);
+					view->scene()->addItem(newEdge.get());
+					if(weakNodes[edges[i].ownerId].lock()->addOutEdge(newEdge))
+					{
+						weakNodes[edges[i].targetId].lock()->addInEdge(newEdge);
+						m_edges.push_back(newEdge);
+					}
+				}
+			}
 		}
 	}
 	else
@@ -126,10 +153,18 @@ std::shared_ptr<GraphNode> QtGraphView::createNode(QGraphicsView* view, const Du
 {
 	if(view != NULL)
 	{
-		std::shared_ptr<QtGraphNode> newNode = std::make_shared<QtGraphNode>(node.position, node.name, node.tokenId);
+		std::shared_ptr<QtGraphNodeMovable> newNode = std::make_shared<QtGraphNodeMovable>(node.position, node.name, node.tokenId);
 		view->scene()->addItem(newNode.get());
 		m_nodes.push_back(newNode);
 
+		// create debug sub node
+		std::shared_ptr<QtGraphNode> subNode = std::make_shared<QtGraphNode>(Vec2i(10, 30), node.name + " member", 666);
+		subNode->setParentItem(newNode.get());
+		view->scene()->addItem(subNode.get());
+		newNode->addSubNode(subNode);
+
+		subNode->setRect(0, 0, 80, 20);
+
 		return newNode;
 	}
 	else

src/app/qt/view/graphElements/QtGraphEdge.cpp

@@ -17,7 +17,7 @@ QtGraphEdge::QtGraphEdge(const std::weak_ptr<GraphNode>& owner, const std::weak_
 	}
 	else
 	{
-		LOG_WARNING("Either the owner or the target node could is null.");
+		LOG_WARNING("Either the owner or the target node is null.");
 	}
 
 	QPen blackPen(Qt::black);
@@ -57,3 +57,27 @@ void QtGraphEdge::targetMoved()
 		LOG_WARNING("Target node is null.");
 	}
 }
+
+void QtGraphEdge::removeEdgeFromScene()
+{
+	std::shared_ptr<GraphNode> node = m_owner.lock();
+
+	if(node != NULL)
+	{
+		node->removeOutEdge(this);
+	}
+	else
+	{
+		LOG_WARNING("Target node is null.");
+	}
+}
+
+std::weak_ptr<GraphNode> QtGraphEdge::getOwner()
+{
+	return m_owner;
+}
+
+std::weak_ptr<GraphNode> QtGraphEdge::getTarget()
+{
+	return m_target;
+}

src/app/qt/view/graphElements/QtGraphEdge.h

@@ -20,6 +20,11 @@ public:
 	virtual void ownerMoved();
 	virtual void targetMoved();
 
+	virtual void removeEdgeFromScene();
+
+	virtual std::weak_ptr<GraphNode> getOwner();
+	virtual std::weak_ptr<GraphNode> getTarget();
+
 private:
 	std::weak_ptr<GraphNode> m_owner;
 	std::weak_ptr<GraphNode> m_target;

src/app/qt/view/graphElements/QtGraphNode.cpp

@@ -20,6 +20,15 @@ QtGraphNode::QtGraphNode(const Vec2i& position, const std::string& name, const I
 
 QtGraphNode::~QtGraphNode()
 {
+	std::list<std::weak_ptr<GraphEdge> >::iterator it = m_inEdges.begin();
+	for(it; it != m_inEdges.end(); it++)
+	{
+		std::shared_ptr<GraphEdge> edge = it->lock();
+		if(edge != NULL)
+		{
+			edge->removeEdgeFromScene();
+		}
+	}
 }
 
 std::string QtGraphNode::getName()
@@ -32,61 +41,63 @@ Vec2i QtGraphNode::getPosition()
 	return Vec2i(this->scenePos().x(), this->scenePos().y());
 }
 
-void QtGraphNode::addOutEdge(const std::shared_ptr<GraphEdge>& edge)
-{
-	m_outEdges.push_back(edge);
-}
-
-void QtGraphNode::addInEdge(const std::weak_ptr<GraphEdge>& edge)
-{
-	m_inEdges.push_back(edge);
-}
-
-void QtGraphNode::removeOutEdge(const std::shared_ptr<GraphEdge>& edge)
+bool QtGraphNode::addOutEdge(const std::shared_ptr<GraphEdge>& edge)
 {
 	std::list<std::shared_ptr<GraphEdge> >::iterator it = m_outEdges.begin();
 	for(it; it != m_outEdges.end(); it++)
 	{
-		if(*it == edge)
+		if ((*it)->getOwner().lock() == edge->getOwner().lock() && (*it)->getTarget().lock() == edge->getTarget().lock())
 		{
-			m_outEdges.erase(it, it);
+			return false;
+		}
+	}
+
+	m_outEdges.push_back(edge);
+	return true;
+}
+
+bool QtGraphNode::addInEdge(const std::weak_ptr<GraphEdge>& edge)
+{
+	std::list<std::weak_ptr<GraphEdge> >::iterator it = m_inEdges.begin();
+	for(it; it != m_inEdges.end(); it++)
+	{
+		std::shared_ptr<GraphEdge> existingEdge = it->lock();
+		if(existingEdge != NULL)
+		{
+			if (existingEdge->getOwner().lock() == edge.lock()->getOwner().lock() &&
+				existingEdge->getTarget().lock() == edge.lock()->getTarget().lock())
+			{
+				return false;
+			}
+		}
+	}
+
+	m_inEdges.push_back(edge);
+	return true;
+}
+
+void QtGraphNode::removeOutEdge(GraphEdge* edge)
+{
+	std::list<std::shared_ptr<GraphEdge> >::iterator it = m_outEdges.begin();
+	while(it != m_outEdges.end())
+	{
+		if((*it).get() == edge)
+		{
+			m_outEdges.erase(it);
 			break;
 		}
+
+		++it;
 	}
 }
 
-void QtGraphNode::mousePressEvent(QGraphicsSceneMouseEvent *event)
+void QtGraphNode::addSubNode(const std::shared_ptr<GraphNode>& node)
 {
-	m_mouseOffset.x = event->pos().x();
-	m_mouseOffset.y = event->pos().y();
+	m_subNodes.push_back(node);
+}
 
+void QtGraphNode::mouseDoubleClickEvent(QGraphicsSceneMouseEvent* event)
+{
 	MessageActivateToken message(m_tokenId);
 	message.dispatch();
 }
-
-void QtGraphNode::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
-{
-	this->setPos(event->scenePos().x() - m_mouseOffset.x, event->scenePos().y() - m_mouseOffset.y);
-
-	Vec2i p(event->scenePos().x(), event->scenePos().y());
-
-	std::list<std::shared_ptr<GraphEdge> >::iterator it = m_outEdges.begin();
-	for(it; it != m_outEdges.end(); it++)
-	{
-		(*it)->ownerMoved();
-	}
-
-	std::list<std::weak_ptr<GraphEdge> >::iterator it2 = m_inEdges.begin();
-	for(it2; it2 != m_inEdges.end(); it2++)
-	{
-		 std::shared_ptr<GraphEdge> edge = it2->lock();
-		 if(edge.get() != NULL)
-		 {
-			 edge->targetMoved();
-		 }
-		 else
-		 {
-			 m_inEdges.erase(it2, it2);
-		 }
-	}
-}

src/app/qt/view/graphElements/QtGraphNode.h

@@ -21,21 +21,23 @@ public:
 	virtual std::string getName();
 	virtual Vec2i getPosition();
 
-	virtual void addOutEdge(const std::shared_ptr<GraphEdge>& edge);
-	virtual void addInEdge(const std::weak_ptr<GraphEdge>& edge);
+	virtual bool addOutEdge(const std::shared_ptr<GraphEdge>& edge);
+	virtual bool addInEdge(const std::weak_ptr<GraphEdge>& edge);
 
-	virtual void removeOutEdge(const std::shared_ptr<GraphEdge>& edge);
+	virtual void removeOutEdge(GraphEdge* edge);
 
-	void mousePressEvent(QGraphicsSceneMouseEvent *event);
-	void mouseMoveEvent(QGraphicsSceneMouseEvent *event);
+	virtual void addSubNode(const std::shared_ptr<GraphNode>& node);
+
+	void mouseDoubleClickEvent(QGraphicsSceneMouseEvent* event);
+
+protected:
+	std::list<std::shared_ptr<GraphEdge> > m_outEdges;
+	std::list<std::weak_ptr<GraphEdge> > m_inEdges;
 
 private:
 	QGraphicsTextItem* m_text;
 
-	std::list<std::shared_ptr<GraphEdge> > m_outEdges;
-	std::list<std::weak_ptr<GraphEdge> > m_inEdges;
-
-	Vec2i m_mouseOffset;
+	std::list<std::shared_ptr<GraphNode> > m_subNodes;
 };
 
 #endif // QT_GRAPH_NODE_H

src/app/qt/view/graphElements/QtGraphNodeMovable.cpp

@@ -0,0 +1,48 @@
+#include "qt/view/graphElements/QtGraphNodeMovable.h"
+
+#include "qgraphicssceneevent.h"
+
+#include "qt/view/graphElements/QtGraphEdge.h"
+
+QtGraphNodeMovable::QtGraphNodeMovable(const Vec2i& position, const std::string& name, const Id tokenId)
+	: QtGraphNode(position, name, tokenId)
+{
+}
+
+QtGraphNodeMovable::~QtGraphNodeMovable()
+{
+}
+
+void QtGraphNodeMovable::mousePressEvent(QGraphicsSceneMouseEvent* event)
+{
+	m_mouseOffset.x = event->pos().x();
+	m_mouseOffset.y = event->pos().y();
+}
+
+void QtGraphNodeMovable::mouseMoveEvent(QGraphicsSceneMouseEvent* event)
+{
+	this->setPos(event->scenePos().x() - m_mouseOffset.x, event->scenePos().y() - m_mouseOffset.y);
+
+	Vec2i p(event->scenePos().x(), event->scenePos().y());
+
+	std::list<std::shared_ptr<GraphEdge> >::iterator it = m_outEdges.begin();
+	for(it; it != m_outEdges.end(); it++)
+	{
+		(*it)->ownerMoved();
+	}
+
+	std::list<std::weak_ptr<GraphEdge> >::iterator it2 = m_inEdges.begin();
+	while(it2 != m_inEdges.end())
+	{
+		 std::shared_ptr<GraphEdge> edge = it2->lock();
+		 if(edge.get() != NULL)
+		 {
+			 edge->targetMoved();
+			 ++it2;
+		 }
+		 else
+		 {
+			 m_inEdges.erase(it2++);
+		 }
+	}
+}

src/app/qt/view/graphElements/QtGraphNodeMovable.h

@@ -0,0 +1,19 @@
+#ifndef QT_GRAPH_NODE_MOVABLE_H
+#define QT_GRAPH_NODE_MOVABLE_H
+
+#include "qt/view/graphElements/QtGraphNode.h"
+
+class QtGraphNodeMovable : public QtGraphNode
+{
+public:
+	QtGraphNodeMovable(const Vec2i& position, const std::string& name, const Id tokenId);
+	virtual ~QtGraphNodeMovable();
+
+	void mousePressEvent(QGraphicsSceneMouseEvent* event);
+	void mouseMoveEvent(QGraphicsSceneMouseEvent* event);
+
+private:
+	Vec2i m_mouseOffset;
+};
+
+#endif // QT_GRAPH_NODE_MOVABLE_H