Index: src/lemon/concept/graph_component.h
===================================================================
--- src/lemon/concept/graph_component.h	(revision 1136)
+++ src/lemon/concept/graph_component.h	(revision 1158)
@@ -626,9 +626,17 @@
 	  Edge e = it1;
 	  e = it2;
-	}
-
-	Edge& edge;
-	Node& node;
-	Graph& graph;
+
+	  const_constraits();
+	}
+
+	void const_constraits() {
+	  Node n = graph.baseNode(it);
+	  n = graph.runningNode(it);
+	}
+
+	Edge edge;
+	Node node;
+	Graph graph;
+	_GraphIncIterator it;
       };
     };
Index: src/lemon/concept/undir_graph.h
===================================================================
--- src/lemon/concept/undir_graph.h	(revision 1030)
+++ src/lemon/concept/undir_graph.h	(revision 1158)
@@ -37,6 +37,8 @@
     /// Skeleton class which describes an edge with direction in \ref
     /// UndirGraph "undirected graph".
-    template <typename UndirEdge>
-    class UndirGraphEdge : public UndirEdge {
+    template <typename UndirGraph>
+    class UndirGraphEdge : public UndirGraph::UndirEdge {
+      typedef typename UndirGraph::UndirEdge UndirEdge;
+      typedef typename UndirGraph::Node Node;
     public:
 
@@ -50,12 +52,14 @@
       UndirGraphEdge(Invalid) {}
 
-      /// \brief Constructs a directed version of an undirected edge
-      ///
-      /// \param forward If \c true the direction of the contructed edge
-      /// is the same as the inherent direction of the \c undir_edge; if
-      /// \c false --- the opposite.
-      UndirGraphEdge(UndirEdge undir_edge, bool forward) {
+      /// \brief Directed edge from undirected edge and a source node.
+      ///
+      /// Constructs a directed edge from undirected edge and a source node.
+      ///
+      /// \note You have to specify the graph for this constructor.
+      UndirGraphEdge(const UndirGraph &g,
+		     UndirEdge undir_edge, Node n) {
 	ignore_unused_variable_warning(undir_edge);
-	ignore_unused_variable_warning(forward);
+	ignore_unused_variable_warning(g);
+	ignore_unused_variable_warning(n);
       }
 
@@ -74,14 +78,18 @@
       struct Constraints {
 	void constraints() {
+	  const_constraints();
+	}
+	void const_constraints() const {
 	  /// \bug This should be is_base_and_derived ...
 	  UndirEdge ue = e;
 	  ue = e;
-	  Edge forward(ue, true);
-	  Edge backward(ue, false);
-
-	  ignore_unused_variable_warning(forward);
-	  ignore_unused_variable_warning(backward);
+
+	  Edge e_with_source(graph,ue,n);
+	  ignore_unused_variable_warning(e_with_source);
 	}
 	Edge e;
+	UndirEdge ue;
+	UndirGraph graph;
+	Node n;
       };
     };
@@ -100,5 +108,5 @@
 	  checkConcept<BaseIterableGraphComponent, Graph>();
 	  checkConcept<GraphItem<>, UndirEdge>();
-	  checkConcept<UndirGraphEdge<UndirEdge>, Edge>();
+	  checkConcept<UndirGraphEdge<Graph>, Edge>();
 
 	  graph.first(ue);
@@ -235,5 +243,5 @@
       /// Type describing an UndirEdge with direction
 #ifndef DOXYGEN
-      typedef UndirGraphEdge<UndirEdge> Edge;
+      typedef UndirGraphEdge<UndirGraph> Edge;
 #else
       typedef UndirGraphEdge Edge;
@@ -431,4 +439,46 @@
 
 
+      /// Base node of the iterator
+      ///
+      /// Returns the base node (the source in this case) of the iterator
+      Node baseNode(OutEdgeIt e) const {
+	return source(e);
+      }
+      /// Running node of the iterator
+      ///
+      /// Returns the running node (the target in this case) of the
+      /// iterator
+      Node runningNode(OutEdgeIt e) const {
+	return target(e);
+      }
+
+      /// Base node of the iterator
+      ///
+      /// Returns the base node (the target in this case) of the iterator
+      Node baseNode(InEdgeIt e) const {
+	return target(e);
+      }
+      /// Running node of the iterator
+      ///
+      /// Returns the running node (the source in this case) of the
+      /// iterator
+      Node runningNode(InEdgeIt e) const {
+	return source(e);
+      }
+
+      /// Base node of the iterator
+      ///
+      /// Returns the base node of the iterator
+      Node baseNode(IncEdgeIt e) const {
+	return INVALID;
+      }
+      /// Running node of the iterator
+      ///
+      /// Returns the running node of the iterator
+      Node runningNode(IncEdgeIt e) const {
+	return INVALID;
+      }
+
+
       template <typename Graph>
       struct Constraints {
Index: src/lemon/iterable_graph_extender.h
===================================================================
--- src/lemon/iterable_graph_extender.h	(revision 1030)
+++ src/lemon/iterable_graph_extender.h	(revision 1158)
@@ -111,4 +111,40 @@
     };
 
+    /// Base node of the iterator
+    ///
+    /// Returns the base node (ie. the source in this case) of the iterator
+    ///
+    /// \todo Document in the concept!
+    Node baseNode(const OutEdgeIt &e) const {
+      return source(e);
+    }
+    /// Running node of the iterator
+    ///
+    /// Returns the running node (ie. the target in this case) of the
+    /// iterator
+    ///
+    /// \todo Document in the concept!
+    Node runningNode(const OutEdgeIt &e) const {
+      return target(e);
+    }
+
+    /// Base node of the iterator
+    ///
+    /// Returns the base node (ie. the target in this case) of the iterator
+    ///
+    /// \todo Document in the concept!
+    Node baseNode(const InEdgeIt &e) const {
+      return target(e);
+    }
+    /// Running node of the iterator
+    ///
+    /// Returns the running node (ie. the source in this case) of the
+    /// iterator
+    ///
+    /// \todo Document in the concept!
+    Node runningNode(const InEdgeIt &e) const {
+      return source(e);
+    }
+
     using Parent::first;
 
@@ -125,4 +161,9 @@
 
   };
+
+
+
+
+
   
   template <typename _Base>
@@ -170,5 +211,5 @@
       IncEdgeIt(Invalid i) : UndirEdge(i), forward(false) { }
 
-      explicit IncEdgeIt(const Graph& _graph, const Node &n)
+      IncEdgeIt(const Graph& _graph, const Node &n)
 	: graph(&_graph)
       {
@@ -176,10 +217,9 @@
       }
 
-      // FIXME: Do we need this type of constructor here?
-      // IncEdgeIt(const Graph& _graph, const Edge& e) : 
-      //   UndirEdge(e), graph(&_graph), forward(_graph.forward(e)) { }
-      // or
-      // IncEdgeIt(const Graph& _graph, const Node& n,
-      //    Const UndirEdge &e) ... ?
+      IncEdgeIt(const Graph& _graph, const UndirEdge &ue, const Node &n)
+	: graph(&_graph), UndirEdge(ue)
+      {
+	forward = (_graph.source(ue) == n);
+      }
 
       IncEdgeIt& operator++() {
@@ -189,20 +229,19 @@
     };
 
-    Node source(const IncEdgeIt &e) const {
+    using Parent::baseNode;
+    using Parent::runningNode;
+
+    /// Base node of the iterator
+    ///
+    /// Returns the base node of the iterator
+    Node baseNode(const IncEdgeIt &e) const {
       return _dirSource(e);
     }
-
-    /// \todo Shouldn't the "source" of an undirected edge be called "aNode"
-    /// or something???
-    using Parent::source;
-
-    /// Target of the given Edge.
-    Node target(const IncEdgeIt &e) const {
+    /// Running node of the iterator
+    ///
+    /// Returns the running node of the iterator
+    Node runningNode(const IncEdgeIt &e) const {
       return _dirTarget(e);
     }
-
-    /// \todo Shouldn't the "target" of an undirected edge be called "bNode"
-    /// or something???
-    using Parent::target;
 
   };
Index: src/lemon/max_matching.h
===================================================================
--- src/lemon/max_matching.h	(revision 1093)
+++ src/lemon/max_matching.h	(revision 1158)
@@ -181,5 +181,5 @@
 	  Node u=_mate[v];
 	  for(IncEdgeIt e(g,v); e!=INVALID; ++e) {
-	    if ( g.target(e) == u ) {
+	    if ( g.runningNode(e) == u ) {
 	      map.set(u,e);
 	      map.set(v,e);
@@ -228,5 +228,5 @@
 	  Node u=_mate[v];
 	  for(IncEdgeIt e(g,v); e!=INVALID; ++e) {
-	    if ( g.target(e) == u ) {
+	    if ( g.runningNode(e) == u ) {
 	      map.set(e,true);
 	      todo.set(u,false);
@@ -333,5 +333,5 @@
 	
       for( IncEdgeIt e(g,x); e!=INVALID ; ++e ) {
-	Node y=g.target(e);
+	Node y=g.runningNode(e);
 
 	if ( position[y] == D && blossom.find(x) != blossom.find(y) ) { 
@@ -389,5 +389,5 @@
 	
       for( IncEdgeIt e(g,x); e!=INVALID; ++e ) {
-	Node y=g.target(e);
+	Node y=g.runningNode(e);
 	      
 	switch ( position[y] ) {
@@ -454,5 +454,5 @@
       if ( _mate[v]==INVALID ) {
 	for( IncEdgeIt e(g,v); e!=INVALID ; ++e ) {
-	  Node y=g.target(e);
+	  Node y=g.runningNode(e);
 	  if ( _mate[y]==INVALID && y!=v ) {
 	    _mate.set(v,y);
@@ -485,5 +485,5 @@
 					UFE& blossom, UFE& tree, std::queue<Node>& Q) {
     for( IncEdgeIt e(g,x); e!= INVALID; ++e ) {
-      Node y=g.target(e);
+      Node y=g.runningNode(e);
 	
       if ( position[y]==C ) {
Index: src/lemon/undir_graph_extender.h
===================================================================
--- src/lemon/undir_graph_extender.h	(revision 1060)
+++ src/lemon/undir_graph_extender.h	(revision 1158)
@@ -45,7 +45,20 @@
     public:
       Edge() {}
-      /// Construct a direct edge from undirect edge and a direction.
+
+      /// \brief Directed edge from undirected edge and a direction.
+      ///
+      /// This constructor is not a part of the concept interface of
+      /// undirected graph, so please avoid using it if possible!
       Edge(const UndirEdge &ue, bool _forward) :
-	UndirEdge(ue), forward(_forward) {}
+        UndirEdge(ue), forward(_forward) {}
+
+      /// \brief Directed edge from undirected edge and a source node.
+      ///
+      /// Constructs a directed edge from undirected edge and a source node.
+      ///
+      /// \note You have to specify the graph for this constructor.
+      Edge(const Graph &g, const UndirEdge &ue, const Node &n) :
+	UndirEdge(ue) { forward = (g.source(ue) == n); }
+
       /// Invalid edge constructor
       Edge(Invalid i) : UndirEdge(i), forward(true) {}
@@ -64,7 +77,7 @@
 
 
-    /// \brief Returns the Edge of opposite direction.
-    ///
-    /// \bug Is this a good name for this? Or "reverse" is better?
+    /// \brief Edge of opposite direction.
+    ///
+    /// Returns the Edge of opposite direction.
     Edge opposite(const Edge &e) const {
       return Edge(e,!e.forward);
@@ -118,4 +131,15 @@
     }
 
+    /// Directed edge from an undirected edge and a source node.
+    ///
+    /// Returns a (directed) Edge corresponding to the specified UndirEdge
+    /// and source Node.
+    ///
+    ///\todo Do we need this?
+    ///
+    ///\todo Better name...
+    Edge edgeWithSource(const UndirEdge &ue, const Node &s) const {
+      return Edge(*this, eu, s);
+    }
 
     using Parent::first;
Index: src/test/max_matching_test.cc
===================================================================
--- src/test/max_matching_test.cc	(revision 1101)
+++ src/test/max_matching_test.cc	(revision 1158)
@@ -160,5 +160,5 @@
 	Q.pop();
 	for(IncEdgeIt e(g,w); e!=INVALID; ++e) {
-	  Node u=g.target(e);
+	  Node u=g.runningNode(e);
 	  if ( pos[u]==max_matching.D && todo[u] ) {
 	    ++comp_size;
