Index: doc/graphs.dox
===================================================================
--- doc/graphs.dox	(revision 880)
+++ doc/graphs.dox	(revision 911)
@@ -29,5 +29,5 @@
 The implemented graph structures are the following.
 \li \ref hugo::ListGraph "ListGraph" is the most versatile graph class. It meets
-the hugo::skeleton::ErasableGraph "ErasableGraph" concept
+the \ref hugo::skeleton::ErasableGraph "ErasableGraph" concept
 and it also have some convenience features.
 \li \ref hugo::SmartGraph "SmartGraph" is a more memory
@@ -46,5 +46,5 @@
 are shared by the edge pairs. 
 \li \ref hugo::FullGraph "FullGraph"
-implements a full graph. It is a \ref ConstGraph, so you cannot
+implements a full graph. It is a \ref hugo::skeleton::StaticGraph, 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
Index: src/hugo/bfs.h
===================================================================
--- src/hugo/bfs.h	(revision 906)
+++ src/hugo/bfs.h	(revision 911)
@@ -50,11 +50,11 @@
     ///The type of the underlying graph.
     typedef GR Graph;
-    ///.
+    ///\e
     typedef typename Graph::Node Node;
-    ///.
+    ///\e
     typedef typename Graph::NodeIt NodeIt;
-    ///.
+    ///\e
     typedef typename Graph::Edge Edge;
-    ///.
+    ///\e
     typedef typename Graph::OutEdgeIt OutEdgeIt;
     
@@ -109,4 +109,5 @@
     
     ///\param _G the graph the algorithm will run on.
+    ///
     Bfs(const Graph& _G) :
       G(&_G),
Index: src/hugo/dfs.h
===================================================================
--- src/hugo/dfs.h	(revision 906)
+++ src/hugo/dfs.h	(revision 911)
@@ -49,11 +49,11 @@
     ///The type of the underlying graph.
     typedef GR Graph;
-    /// .
+    ///\e
     typedef typename Graph::Node Node;
-    /// .
+    ///\e
     typedef typename Graph::NodeIt NodeIt;
-    /// .
+    ///\e
     typedef typename Graph::Edge Edge;
-    /// .
+    ///\e
     typedef typename Graph::OutEdgeIt OutEdgeIt;
     
@@ -108,4 +108,5 @@
     
     ///\param _G the graph the algorithm will run on.
+    ///
     Dfs(const Graph& _G) :
       G(&_G),
Index: src/hugo/dijkstra.h
===================================================================
--- src/hugo/dijkstra.h	(revision 906)
+++ src/hugo/dijkstra.h	(revision 911)
@@ -72,11 +72,11 @@
     ///The type of the underlying graph.
     typedef GR Graph;
-    ///.
+    ///\e
     typedef typename Graph::Node Node;
-    ///.
+    ///\e
     typedef typename Graph::NodeIt NodeIt;
-    ///.
+    ///\e
     typedef typename Graph::Edge Edge;
-    ///.
+    ///\e
     typedef typename Graph::OutEdgeIt OutEdgeIt;
     
Index: src/hugo/fib_heap.h
===================================================================
--- src/hugo/fib_heap.h	(revision 906)
+++ src/hugo/fib_heap.h	(revision 911)
@@ -36,5 +36,5 @@
   ///is a data structure for storing items with specified values called \e
   ///priorities in such a way that finding the item with minimum priority is
-  ///efficient. \ref Compare specifies the ordering of the priorities. In a heap
+  ///efficient. \c Compare specifies the ordering of the priorities. In a heap
   ///one can change the priority of an item, add or erase an item, etc.
   ///
@@ -118,8 +118,8 @@
     void push (Item const item, PrioType const value);
     
-    ///Returns the item with minimum priority relative to \ref Compare.
-    
-    /**
-       This method returns the item with minimum priority relative to \ref
+    ///Returns the item with minimum priority relative to \c Compare.
+    
+    /**
+       This method returns the item with minimum priority relative to \c
        Compare.  
        \pre The heap must be nonempty.  
@@ -127,8 +127,8 @@
     Item top() const { return container[minimum].name; }
 
-    ///Returns the minimum priority relative to \ref Compare.
-
-    /**
-       It returns the minimum priority relative to \ref Compare.
+    ///Returns the minimum priority relative to \c Compare.
+
+    /**
+       It returns the minimum priority relative to \c Compare.
        \pre The heap must be nonempty.
     */
@@ -156,8 +156,8 @@
 
 
-    ///Deletes the item with minimum priority relative to \ref Compare.
-
-    /**
-    This method deletes the item with minimum priority relative to \ref
+    ///Deletes the item with minimum priority relative to \c Compare.
+
+    /**
+    This method deletes the item with minimum priority relative to \c
     Compare from the heap.  
     \pre The heap must be non-empty.  
@@ -178,5 +178,5 @@
        This method decreases the priority of \c item to \c value.
        \pre \c item must be stored in the heap with priority at least \c
-       value relative to \ref Compare.
+       value relative to \c Compare.
     */
     void decrease (Item item, PrioType const value); 
@@ -188,5 +188,5 @@
        there is no precondition on the priority of \c item, this
        method should be used only if it is indeed necessary to increase
-       (relative to \ref Compare) the priority of \c item, because this
+       (relative to \c Compare) the priority of \c item, because this
        method is inefficient.
     */
Index: src/hugo/graph_wrapper.h
===================================================================
--- src/hugo/graph_wrapper.h	(revision 910)
+++ src/hugo/graph_wrapper.h	(revision 911)
@@ -606,4 +606,7 @@
   /// bidirected graph made from a directed one. 
   ///
+  /// A wrapper for composing a subgraph of a 
+  /// bidirected graph made from a directed one. 
+  ///
   ///\warning Graph wrappers are in even more experimental state than the other
   ///parts of the lib. Use them at you own risk.
Index: src/hugo/list_graph.h
===================================================================
--- src/hugo/list_graph.h	(revision 909)
+++ src/hugo/list_graph.h	(revision 911)
@@ -422,14 +422,14 @@
   ///of oppositely directed edges.
   ///There is a new edge map type called
-  ///\ref SymListGraph::SymEdgeMap "SymEdgeMap"
+  ///\ref hugo::SymListGraph::SymEdgeMap "SymEdgeMap"
   ///that complements this
   ///feature by
   ///storing shared values for the edge pairs. The usual
-  ///\ref Graph::EdgeMap "EdgeMap"
+  ///\ref hugo::skeleton::StaticGraph::EdgeMap "EdgeMap"
   ///can be used
   ///as well.
   ///
   ///The oppositely directed edge can also be obtained easily
-  ///using \ref opposite.
+  ///using \ref hugo::SymListGraph::opposite() "opposite()" member function.
   ///
   ///Here erase(Edge) deletes a pair of edges.
Index: src/hugo/maps.h
===================================================================
--- src/hugo/maps.h	(revision 906)
+++ src/hugo/maps.h	(revision 911)
@@ -36,7 +36,7 @@
   {
   public:
-    /// .
+    ///\e
     typedef K KeyType;
-    /// .
+    ///\e
     typedef T ValueType;
   };
@@ -75,7 +75,8 @@
     /// (More exactly it will be default constructed.)
     ConstMap() {}
-    /// .
+    ///\e
 
     /// \param _v The initial value of the map.
+    ///
     ConstMap(const T &_v) : v(_v) {}
 
Index: src/hugo/preflow.h
===================================================================
--- src/hugo/preflow.h	(revision 906)
+++ src/hugo/preflow.h	(revision 911)
@@ -45,5 +45,6 @@
   ///setFlow.
   ///
-  ///After running \ref phase1() or \ref preflow(), the actual flow
+  ///After running \ref hugo::Preflow::phase1() "phase1()"
+  ///or \ref hugo::Preflow::run() "run()", the actual flow
   ///value can be obtained by calling \ref flowValue(). The minimum
   ///value cut can be written into a <tt>bool</tt> node map by
@@ -97,6 +98,7 @@
     ///- \c PRE_FLOW: any preflow, i.e. the sum of the in-flows is at 
     ///least the sum of the out-flows in every node except the \e source.
-    ///- \c NO_FLOW: indicates an unspecified edge map. \ref flow will be 
-    ///set to the constant zero flow in the beginning of the algorithm in this case.
+    ///- \c NO_FLOW: indicates an unspecified edge map. \c flow will be 
+    ///set to the constant zero flow in the beginning of
+    ///the algorithm in this case.
     ///
     enum FlowEnum{
@@ -195,7 +197,7 @@
     ///minimum value cut can already be computed, though a maximum flow
     ///is not yet obtained. So after calling this method \ref flowValue
-    ///and \ref actMinCut gives proper results.
-    ///\warning \ref minCut, \ref minMinCut and \ref maxMinCut do not
-    ///give minimum value cuts unless calling \ref phase2.
+    ///and \ref MinCut() gives proper results.
+    ///\warning \ref minCut(), \ref minMinCut() and \ref maxMinCut() do not
+    ///give minimum value cuts unless calling \ref phase2().
     void phase1()
     {
@@ -350,5 +352,5 @@
 
     /// Returns the value of the maximum flow by returning the excess
-    /// of the target node \ref t. This value equals to the value of
+    /// of the target node \c t. This value equals to the value of
     /// the maximum flow already after running \ref phase1.
     Num flowValue() const {
@@ -363,5 +365,5 @@
     ///phase1 and \ref phase2. It is much faster after
     ///\ref phase1.  \pre M should be a bool-valued node-map. \pre
-    ///If \ref mincut is called after \ref phase2 then M should
+    ///If \ref minCut() is called after \ref phase2() then M should
     ///be initialized to false.
     template<typename _CutMap>
@@ -426,5 +428,5 @@
     ///which is inclusionwise maximum. It is computed by processing a
     ///backward bfs from the target node \c t in the residual graph.
-    ///\pre \ref phase2() or preflow() should already be run.
+    ///\pre \ref phase2() or run() should already be run.
     template<typename _CutMap>
     void maxMinCut(_CutMap& M) const {
Index: src/hugo/skeletons/graph.h
===================================================================
--- src/hugo/skeletons/graph.h	(revision 906)
+++ src/hugo/skeletons/graph.h	(revision 911)
@@ -93,5 +93,5 @@
 	/// Inequality operator
 	
-	/// \sa \ref operator==(Node n)
+	/// \sa operator==(Node n)
 	///
 	bool operator!=(Node) const { return true; }
@@ -181,5 +181,5 @@
 	/// Inequality operator
 
-	/// \sa \ref operator==(Node n)
+	/// \sa operator==(Node n)
 	///
 	bool operator!=(Edge) const { return true; }
@@ -383,10 +383,10 @@
       int id(const Edge&) const { return 0; }
 
-      /// .
+      ///\e
       
       ///\todo Should it be in the concept?
       ///
       int nodeNum() const { return 0; }
-      /// .
+      ///\e
 
       ///\todo Should it be in the concept?
@@ -406,7 +406,7 @@
       public:
 
-	/// .
+	///\e
 	NodeMap(const StaticGraph&) { }
-	/// .
+	///\e
 	NodeMap(const StaticGraph&, T) { }
 
@@ -430,7 +430,7 @@
       public:
 
-	/// .
+	///\e
 	EdgeMap(const StaticGraph&) { }
-	/// .
+	///\e
 	EdgeMap(const StaticGraph&, T) { }
     
Index: src/hugo/skeletons/sym_graph.h
===================================================================
--- src/hugo/skeletons/sym_graph.h	(revision 909)
+++ src/hugo/skeletons/sym_graph.h	(revision 911)
@@ -46,5 +46,5 @@
     /// feature, the documentation of a real symmetric graph imlementation
     /// like @ref SymListGraph or
-    /// @ref SymSmartGraph will just refer to this structure.
+    /// @ref hugo::SymSmartGraph will just refer to this structure.
     class StaticSymGraph
     {
@@ -94,5 +94,5 @@
 	/// Inequality operator
 	
-	/// \sa \ref operator==(Node n)
+	/// \sa operator==(Node n)
 	///
 	bool operator!=(Node) const { return true; }
@@ -182,5 +182,5 @@
 	/// Inequality operator
 
-	/// \sa \ref operator==(Node n)
+	/// \sa operator==(Node n)
 	///
 	bool operator!=(SymEdge) const { return true; }
@@ -224,5 +224,5 @@
 	/// Inequality operator
 
-	/// \sa \ref operator==(Node n)
+	/// \sa operator==(Node n)
 	///
 	bool operator!=(Edge) const { return true; }
@@ -490,10 +490,10 @@
       int id(const SymEdge&) const { return 0; }
 
-      /// .
+      ///\e
       
       ///\todo Should it be in the concept?
       ///
       int nodeNum() const { return 0; }
-      /// .
+      ///\e
 
       ///\todo Should it be in the concept?
@@ -525,7 +525,7 @@
       public:
 
-	/// .
+	///\e
 	NodeMap(const StaticSymGraph&) { }
-	/// .
+	///\e
 	NodeMap(const StaticSymGraph&, T) { }
 
@@ -549,7 +549,7 @@
       public:
 
-	/// .
+	///\e
 	EdgeMap(const StaticSymGraph&) { }
-	/// .
+	///\e
 	EdgeMap(const StaticSymGraph&, T) { }
     
@@ -573,7 +573,7 @@
       public:
 
-	/// .
+	///\e
 	SymEdgeMap(const StaticSymGraph&) { }
-	/// .
+	///\e
 	SymEdgeMap(const StaticSymGraph&, T) { }
     
