Index: demo/eps_demo.cc
===================================================================
--- demo/eps_demo.cc	(revision 2391)
+++ demo/eps_demo.cc	(revision 2476)
@@ -19,10 +19,10 @@
 /// \ingroup demos
 /// \file
-/// \brief Demo of the EPS grawing class \ref EpsDrawer()
+/// \brief Demo of the EPS grawing class \ref lemon::EpsDrawer "EpsDrawer".
 ///
 /// This demo program shows examples how to use the class \ref
-/// EpsDrawer(). It takes no input but simply creates a file
-/// <tt>eps_demo.eps</tt> demonstrating the capability of \ref
-/// EpsDrawer().
+/// lemon::EpsDrawer "EpsDrawer". It takes no input but simply creates
+/// a file <tt>eps_demo.eps</tt> demonstrating the capability of \ref
+/// lemon::EpsDrawer "EpsDrawer".
 ///
 /// \include eps_demo.cc
Index: doc/algorithms.dox
===================================================================
--- doc/algorithms.dox	(revision 2470)
+++ doc/algorithms.dox	(revision 2476)
@@ -115,5 +115,5 @@
 \skip MyOrdererMap
 \until };
-The class meets the \ref lemon::WriteMap "WriteMap" concept. In it's \c set() method the only thing
+The class meets the \ref concepts::WriteMap "WriteMap" concept. In it's \c set() method the only thing
 we need to do is insert the key - that is the node whose processing just finished - into the beginning
 of the list.<br>
Index: doc/basic_concepts.dox
===================================================================
--- doc/basic_concepts.dox	(revision 2391)
+++ doc/basic_concepts.dox	(revision 2476)
@@ -30,5 +30,5 @@
 have to satisfy one or more \ref concept "graph concepts" which are standardized
 interfaces to work with the rest of the library. The most basic concept is the
-\ref Graph.<br>
+\ref concepts::Graph "Graph".<br>
 A good example is the \ref ListGraph which we already know from Hello World and
 will be used in our examples as well.
@@ -48,5 +48,5 @@
 to the graph with the addNode() member function. It returns the newly added node
 (as value). So if you need the new node to do something useful with, for example
-create an edge, assign a value to it through \ref map1 maps.
+create an edge, assign a value to it through \ref maps1 maps.
 \code lemon::ListGraph::Node  new_node = graph.addNode(); \endcode
 
@@ -115,6 +115,8 @@
 the next page.)
 
-The \ref EdgeIt works exactly the same - nothing more to say. But there are \ref InEdgeIt
-and \ref OutEdgeIt by directed graphs and \ref IncEdgeIt by undirected graphs.
+The \ref concepts::Graph::EdgeIt "EdgeIt" works exactly the same - nothing more to say.
+But there are \ref concepts::Graph::InEdgeIt "InEdgeIt" and
+\ref concepts::Graph::OutEdgeIt "OutEdgeIt" by directed graphs and
+\ref concepts::UGraph::IncEdgeIt "IncEdgeIt" by undirected graphs.
 They take two arguments. The first is a graph, the second is certain node of the
 graph. InEdgeIt iterates on the incoming edges of that node and OutEdgeIt does it
Index: doc/graphs.dox
===================================================================
--- doc/graphs.dox	(revision 2391)
+++ doc/graphs.dox	(revision 2476)
@@ -17,6 +17,7 @@
  */
 
+namespace lemon {
+
 /*!
-
 \page graphs Graphs
 
@@ -30,5 +31,5 @@
 as  incoming and outgoing edges of a given node. 
 
-Each graph should meet the \ref lemon::concepts::Graph "Graph" concept.
+Each graph should meet the \ref concepts::Graph "Graph" concept.
 This concept does not make it possible to change the graph (i.e. it is
 not possible to add or delete edges or nodes). Most of the graph
@@ -37,20 +38,18 @@
 
 In case of graphs meeting the full feature
-\ref lemon::concepts::ErasableGraph "ErasableGraph"
-concept
+\ref concepts::ErasableGraph "ErasableGraph" concept
 you can also erase individual edges and nodes in arbitrary order.
 
 The implemented graph structures are the following.
-\li \ref lemon::ListGraph "ListGraph" is the most versatile graph class. It meets
-the \ref lemon::concepts::ErasableGraph "ErasableGraph" concept
+\li \ref ListGraph is the most versatile graph class. It meets
+the \ref concepts::ErasableGraph "ErasableGraph" concept
 and it also has some convenient extra features.
-\li \ref lemon::SmartGraph "SmartGraph" is a more memory
-efficient version of \ref lemon::ListGraph "ListGraph". The
-price of this is that it only meets the
-\ref lemon::concepts::ExtendableGraph "ExtendableGraph" concept,
+\li \ref SmartGraph is a more memory efficient version of \ref ListGraph.
+The price of this is that it only meets the
+\ref concepts::ExtendableGraph "ExtendableGraph" concept,
 so you cannot delete individual edges or nodes.
-\li \ref lemon::FullGraph "FullGraph"
+\li \ref FullGraph "FullGraph"
 implements a complete graph. It is a
-\ref lemon::concepts::Graph "Graph", so you cannot
+\ref concepts::Graph "Graph", so you cannot
 change the number of nodes once it is constructed. It is extremely memory
 efficient: it uses constant amount of memory independently from the number of
@@ -58,9 +57,9 @@
 \ref maps-page "EdgeMap"'s will depend on the number of nodes.
 
-\li \ref lemon::NodeSet "NodeSet" implements a graph with no edges. This class
+\li \ref NodeSet "NodeSet" implements a graph with no edges. This class
 can be used as a base class of \ref lemon::EdgeSet "EdgeSet".
-\li \ref lemon::EdgeSet "EdgeSet" can be used to create a new graph on
+\li \ref EdgeSet "EdgeSet" can be used to create a new graph on
 the node set of another graph. The base graph can be an arbitrary graph and it
-is possible to attach several \ref lemon::EdgeSet "EdgeSet"'s to a base graph.
+is possible to attach several \ref EdgeSet "EdgeSet"'s to a base graph.
 
 \todo Don't we need SmartNodeSet and SmartEdgeSet?
@@ -121,5 +120,5 @@
 step to the next node. Using operator++ on the iterator pointing to the last
 node invalidates the iterator i.e. sets its value to
-\ref lemon::INVALID "INVALID". This is what we exploit in the stop condition.
+\ref INVALID. This is what we exploit in the stop condition.
 
 The previous code fragment prints out the following:
@@ -201,2 +200,5 @@
 
 */
+
+}
+
Index: doc/maps1.dox
===================================================================
--- doc/maps1.dox	(revision 2408)
+++ doc/maps1.dox	(revision 2476)
@@ -16,4 +16,6 @@
  *
  */
+
+namespace lemon {
 
 /**
@@ -35,14 +37,14 @@
 To make easy to use them - especially as template parameters - there are <i>map concepts</i> like by graph classes.
 <ul>
-<li>\ref ReadMap - values can be read out with the \c operator[].
+<li>\ref concepts::ReadMap "ReadMap" - values can be read out with the \c operator[].
 \code value_typed_variable = map_instance[key_value]; \endcode
 </li>
-<li>\ref WriteMap - values can be set with the \c set() member function.
+<li>\ref concepts::WriteMap "WriteMap" - values can be set with the \c set() member function.
 \code map_instance.set(key_value, value_typed_expression); \endcode
 </li>
-<li>\ref ReadWriteMap - it's just a shortcut to indicate that the map is both
+<li>\ref concepts::ReadWriteMap "ReadWriteMap" - it's just a shortcut to indicate that the map is both
 readable and writable. It is delivered from them.
 </li>
-<li>\ref ReferenceMap - a subclass of ReadWriteMap. It has two additional typedefs
+<li>\ref concepts::ReferenceMap "ReferenceMap" - a subclass of ReadWriteMap. It has two additional typedefs
 <i>Reference</i> and <i>ConstReference</i> and two overloads of \c operator[] to
 providing you constant or non-constant reference to the value belonging to a key,
@@ -50,5 +52,7 @@
 </li>
 <li>And there are the Matrix version of these maps, where the values are assigned to a pair of keys.
-The keys can be different types. (\ref ReadMatrixMap, \ref WriteMatrixMap, \ref ReadWriteMatrixMap, \ref ReferenceMatrixMap)
+The keys can be different types. (\ref concepts::ReadMatrixMap "ReadMatrixMap", 
+\ref concepts::WriteMatrixMap "WriteMatrixMap", \ref concepts::ReadWriteMatrixMap "ReadWriteMatrixMap",
+\ref concepts::ReferenceMatrixMap "ReferenceMatrixMap")
 </li>
 </ul>
@@ -89,2 +93,4 @@
 Or if you want to know more about maps read these \ref maps2 "advanced map techniques".
 */
+
+}
Index: lemon/bellman_ford.h
===================================================================
--- lemon/bellman_ford.h	(revision 2408)
+++ lemon/bellman_ford.h	(revision 2476)
@@ -433,5 +433,5 @@
     /// easily with \ref path() or \ref predEdge() functions. If you
     /// need the shortest path and not just the distance you should store
-    /// after each iteration the \ref predEdgeMap() map and manually build
+    /// after each iteration the \ref predMap() map and manually build
     /// the path.
     ///
@@ -546,5 +546,5 @@
     /// easily with \ref path() or \ref predEdge() functions. If you
     /// need the shortest path and not just the distance you should store
-    /// after each iteration the \ref predEdgeMap() map and manually build
+    /// after each iteration the \ref predMap() map and manually build
     /// the path.
     ///
@@ -952,5 +952,5 @@
     ///
     /// Runs BellmanFord algorithm from the given node.
-    /// \param source is the given source.
+    /// \param src is the given source.
     void run(Node src) {
       Base::_source = src;
@@ -1017,5 +1017,5 @@
     ///
     /// Sets the source node, from which the BellmanFord algorithm runs.
-    /// \param source is the source node.
+    /// \param src is the source node.
     BellmanFordWizard<_Traits>& source(Node src) {
       Base::_source = src;
Index: lemon/bfs.h
===================================================================
--- lemon/bfs.h	(revision 2443)
+++ lemon/bfs.h	(revision 2476)
@@ -594,7 +594,6 @@
     ///
     ///This method runs the %BFS algorithm from the root node(s)
-    ///in order to
-    ///compute the
-    ///shortest path to \c dest. The algorithm computes
+    ///in order to compute the shortest path to \c dest.
+    ///The algorithm computes
     ///- The shortest path to \c  dest.
     ///- The distance of \c dest from the root(s).
@@ -616,5 +615,5 @@
     /// <tt>nm[v]</tt> true.
     ///
-    ///\return The reached node \c v with <tt>nm[v]<\tt> true or
+    ///\return The reached node \c v with <tt>nm[v]</tt> true or
     ///\c INVALID if no such node was found.
     template<class NM>
@@ -1518,5 +1517,5 @@
     /// <tt>nm[v]</tt> true.
     ///
-    ///\return The reached node \c v with <tt>nm[v]<\tt> true or
+    ///\return The reached node \c v with <tt>nm[v]</tt> true or
     ///\c INVALID if no such node was found.
     template <typename NM>
Index: lemon/dfs.h
===================================================================
--- lemon/dfs.h	(revision 2443)
+++ lemon/dfs.h	(revision 2476)
@@ -565,7 +565,7 @@
     ///
     ///\param em must be a bool (or convertible) edge map. The algorithm
-    ///will stop when it reaches an edge \c e with <tt>em[e]<\tt> true.
-    ///
-    ///\return The reached edge \c e with <tt>em[e]<\tt> true or
+    ///will stop when it reaches an edge \c e with <tt>em[e]</tt> true.
+    ///
+    ///\return The reached edge \c e with <tt>em[e]</tt> true or
     ///\c INVALID if no such edge was found.
     ///
@@ -1459,7 +1459,7 @@
     ///
     /// \param em must be a bool (or convertible) edge map. The algorithm
-    /// will stop when it reaches an edge \c e with <tt>em[e]<\tt> true.
-    ///
-    ///\return The reached edge \c e with <tt>em[e]<\tt> true or
+    /// will stop when it reaches an edge \c e with <tt>em[e]</tt> true.
+    ///
+    ///\return The reached edge \c e with <tt>em[e]</tt> true or
     ///\c INVALID if no such edge was found.
     ///
Index: lemon/dijkstra.h
===================================================================
--- lemon/dijkstra.h	(revision 2443)
+++ lemon/dijkstra.h	(revision 2476)
@@ -666,5 +666,5 @@
     ///will stop when it reaches a node \c v with <tt>nm[v]</tt> true.
     ///
-    ///\return The reached node \c v with <tt>nm[v]<\tt> true or
+    ///\return The reached node \c v with <tt>nm[v]</tt> true or
     ///\c INVALID if no such node was found.
     template<class NodeBoolMap>
Index: lemon/error.h
===================================================================
--- lemon/error.h	(revision 2410)
+++ lemon/error.h	(revision 2476)
@@ -635,5 +635,5 @@
 /// behaviour will be activated. The \c msg should be either a const
 /// char* message or an exception. When the \c msg is an exception the
-/// \ref "Exception::what" what() function is called to retrieve and
+/// \ref lemon::Exception::what() "what()" function is called to retrieve and
 /// display the error message.
 ///
Index: lemon/graph_utils.h
===================================================================
--- lemon/graph_utils.h	(revision 2474)
+++ lemon/graph_utils.h	(revision 2476)
@@ -373,5 +373,5 @@
   ///
   ///\sa EdgeLookUp
-  ///\se AllEdgeLookUp
+  ///\sa AllEdgeLookUp
   ///\sa ConEdgeIt
   template <typename Graph>
Index: lemon/lemon_reader.h
===================================================================
--- lemon/lemon_reader.h	(revision 2467)
+++ lemon/lemon_reader.h	(revision 2476)
@@ -1129,5 +1129,5 @@
     /// It gives back true when the header line starts with \c \@edgeset,
     /// and the header line's name and the edgeset's name are the same.
-    /// The sections with @uedgeset head line could be read with this
+    /// The sections with \@uedgeset head line could be read with this
     /// section reader too.
     virtual bool header(const std::string& line) {
@@ -1438,5 +1438,5 @@
     /// It gives back true when the header line starts with \c \@uedgeset,
     /// and the header line's name and the edgeset's name are the same.
-    /// The sections with @edgeset head line could be read with this
+    /// The sections with \@edgeset head line could be read with this
     /// section reader too.
     virtual bool header(const std::string& line) {
