Index: doc/graph_io.dox
===================================================================
--- doc/graph_io.dox	(revision 1540)
+++ doc/graph_io.dox	(revision 1631)
@@ -123,5 +123,6 @@
 \subsection write Writing a graph
 
-The \c GraphWriter class provides the graph output. To write a graph
+The \ref lemon::GraphWriter "GraphWriter" template class
+provides the graph output. To write a graph
 you should first give writing commands to the writer. You can declare
 writing command as \c NodeMap or \c EdgeMap writing and labeled Node and
@@ -132,6 +133,8 @@
 \endcode
 
-The \c writeNodeMap() function declares a \c NodeMap writing command in the
-\c GraphWriter. You should give a name to the map and the map
+The \ref lemon::GraphWriter::writeNodeMap() "writeNodeMap()"
+function declares a \c NodeMap writing command in the
+\ref lemon::GraphWriter "GraphWriter".
+You should give a name to the map and the map
 object as parameters. The NodeMap writing command with name "id" should write a 
 unique map because it will be regarded as an ID map.
@@ -148,5 +151,6 @@
 \endcode
 
-With the \c writeEdgeMap() member function you can give an edge map
+With the \ref lemon::GraphWriter::writeEdgeMap() "writeEdgeMap()"
+member function you can give an edge map
 writing command similar to the NodeMaps.
 
@@ -161,5 +165,7 @@
 \endcode
 
-With \c writeNode() and \c writeEdge() functions you can designate Nodes and
+With \ref lemon::GraphWriter::writeNode() "writeNode()"
+and \ref lemon::GraphWriter::writeEdge() "writeEdge()"
+functions you can designate Nodes and
 Edges in the graph. For example, you can write out the source and target node
 of a maximum flow instance.
@@ -172,5 +178,6 @@
 \endcode
 
-With \c writeAttribute() function you can write an attribute to the file.
+With \ref lemon::GraphWriter::writeAttribute() "writeAttribute()"
+function you can write an attribute to the file.
 
 \code
@@ -179,5 +186,6 @@
 \endcode
 
-After you give all write commands you must call the \c run() member
+After you give all write commands you must call the
+\ref lemon::GraphWriter::run() "run()" member
 function, which executes all the writing commands.
 
@@ -190,6 +198,8 @@
 The file to be read may contain several maps and labeled nodes or edges.
 If you read a graph you need not read all the maps and items just those
-that you need. The interface of the \c GraphReader is very similar to
-the GraphWriter but the reading method does not depend on the order of the
+that you need. The interface of the \ref lemon::GraphReader "GraphReader"
+is very similar to
+the \ref lemon::GraphWriter "GraphWriter"
+but the reading method does not depend on the order of the
 given commands.
 
@@ -202,8 +212,10 @@
 \endcode
 
-The \c readNodeMap() function reads a map from the \c nodeset section.
+The \ref lemon::GraphReader::readNodeMap() "readNodeMap()"
+function reads a map from the \c nodeset section.
 If there is a map that you do not want to read from the file and there are
 whitespaces in the string represenation of the values then you should
-call the \c skipNodeMap() template member function with proper parameters.
+call the \ref lemon::GraphReader::skipNodeMap() "skipNodeMap()"
+template member function with proper parameters.
 
 \see QuotedStringReader
@@ -219,5 +231,6 @@
 \endcode
 
-With the \c readEdgeMap() member function you can give an edge map
+With the \ref lemon::GraphReader::readEdgeMap() "readEdgeMap()"
+member function you can give an edge map
 reading command similar to the NodeMaps. 
 
@@ -227,5 +240,7 @@
 \endcode
 
-With \c readNode() and \c readEdge() functions you can read labeled Nodes and
+With \ref lemon::GraphReader::readNode() "readNode()"
+and \ref lemon::GraphReader::readEdge() "readEdge()"
+functions you can read labeled Nodes and
 Edges.
 
@@ -237,5 +252,6 @@
 \endcode
 
-With \c readAttribute() function you can read an attribute from the file.
+With \ref lemon::GraphReader::readAttribute() "readAttribute()"
+function you can read an attribute from the file.
 
 \code
@@ -246,5 +262,6 @@
 \endcode
 
-After you give all read commands you must call the \c run() member
+After you give all read commands you must call the
+\ref lemon::GraphReader::run() "run()" member
 function, which executes all the commands.
 
@@ -258,5 +275,6 @@
 
 To read a map (on the nodes or edges)
-the \c GraphReader should know how to read a Value from the given map.
+the \ref lemon::GraphReader "GraphReader"
+should know how to read a Value from the given map.
 By the default implementation the input operator reads a value from
 the stream and the type of the readed value is the value type of the given map.
@@ -338,10 +356,14 @@
 \endcode
 
-There are similar classes to the \c GraphReader ans \c GraphWriter
-which handle the undirected graphs. These classes are the 
-\c UndirGraphReader and \UndirGraphWriter.
-
-The \c readUndirMap() function reads an undirected map and the
-\c readUndirEdge() reads an undirected edge from the file, 
+There are similar classes to the \ref lemon::GraphReader "GraphReader" and
+\ref lemon::GraphWriter "GraphWriter" which
+handle the undirected graphs. These classes are
+the \ref lemon::UndirGraphReader "UndirGraphReader"
+and \ref lemon::UndirGraphWriter "UndirGraphWriter".
+
+The \ref lemon::UndirGraphReader::readUndirMap() "readUndirMap()"
+function reads an undirected map and the
+\ref lemon::UndirGraphReader::readUndirEdge() "readUndirEdge()"
+reads an undirected edge from the file, 
 
 \code
@@ -365,7 +387,10 @@
 character. The file may contains comment lines with \c # first character.
 
-The \c LemonReader and \c LemonWriter gives a framework to read and
+The \ref lemon::LemonReader "LemonReader"
+and \ref lemon::LemonWriter "LemonWriter"
+gives a framework to read and
 write sections. There are various section reader and section writer
-classes which can be attached to a \c LemonReader or a \c LemonWriter.
+classes which can be attached to a \ref lemon::LemonReader "LemonReader"
+or a \ref lemon::LemonWriter "LemonWriter".
 
 There are default section readers and writers for reading and writing
@@ -373,5 +398,7 @@
 the format described above. Other type of data can be handled with own
 section reader and writer classes which are inherited from the
-\c LemonReader::SectionReader or the \c LemonWriter::SectionWriter classes.
+\c LemonReader::SectionReader or the
+\ref lemon::LemonWriter::SectionWriter "LemonWriter::SectionWriter"
+classes.
 
 The next example defines a special section reader which reads the
@@ -415,6 +442,6 @@
 In our example there is a network with symmetric links and there are assymetric
 traffic request on the network. This construction can be stored in an
-undirected graph and in a directed NewEdgeSetAdaptor class. The example
-shows the input with the LemonReader class:
+undirected graph and in a directed \c NewEdgeSetAdaptor class. The example
+shows the input with the \ref lemon::LemonReader "LemonReader" class:
 
 \code
@@ -434,7 +461,10 @@
 \endcode
 
-Because the GraphReader and the UndirGraphReader can be converted
-to LemonReader and it can resolve the ID's of the items, the previous
-result can be achived with the UndirGraphReader class, too.
+Because both the \ref lemon::GraphReader "GraphReader"
+and the \ref lemon::UndirGraphReader "UndirGraphReader" can be converted
+to \ref lemon::LemonReader "LemonReader"
+and it can resolve the ID's of the items, the previous
+result can be achived with the \ref lemon::UndirGraphReader "UndirGraphReader"
+class, too.
 
 
Index: doc/graphs.dox
===================================================================
--- doc/graphs.dox	(revision 1200)
+++ doc/graphs.dox	(revision 1631)
@@ -35,13 +35,4 @@
 \ref lemon::concept::ExtendableGraph "ExtendableGraph" concept,
 so you cannot delete individual edges or nodes.
-\li \ref lemon::SymListGraph "SymListGraph" and
-\ref lemon::SymSmartGraph "SymSmartGraph" classes are very similar to
-\ref lemon::ListGraph "ListGraph" and \ref lemon::SmartGraph "SmartGraph".
-The difference is that whenever you add a
-new edge to the graph, it actually adds a pair of oppositely directed edges.
-They are linked together so it is possible to access the counterpart of an
-edge. An even more important feature is that using these classes you can also
-attach data to the edges in such a way that the stored data
-are shared by the edge pairs. 
 \li \ref lemon::FullGraph "FullGraph"
 implements a complete graph. It is a
Index: doc/license.dox
===================================================================
--- doc/license.dox	(revision 1536)
+++ doc/license.dox	(revision 1631)
@@ -3,5 +3,5 @@
 \page license License Terms
 
-\verbinclude ../LICENSE
+\verbinclude LICENSE
 
 */
Index: lemon/bfs.h
===================================================================
--- lemon/bfs.h	(revision 1624)
+++ lemon/bfs.h	(revision 1631)
@@ -699,5 +699,5 @@
     ///if \c v is unreachable from the root(s) or \c v is a root. The
     ///shortest path tree used here is equal to the shortest path tree used in
-    ///\ref predNode(Node v).
+    ///\ref predNode().
     ///\pre Either \ref run() or \ref start() must be called before using
     ///this function.
@@ -714,5 +714,5 @@
     ///if \c v itself a root.
     ///The shortest path tree used here is equal to the shortest path
-    ///tree used in \ref pred(Node v).
+    ///tree used in \ref pred().
     ///\pre Either \ref run() or \ref start() must be called before
     ///using this function.
Index: lemon/concept/graph.h
===================================================================
--- lemon/concept/graph.h	(revision 1630)
+++ lemon/concept/graph.h	(revision 1631)
@@ -405,5 +405,5 @@
         /// This constructor sets the iterator to the first edge of \c g.
         ///@param g the graph
-        EdgeIt(const StaticGraph&) { }
+        EdgeIt(const StaticGraph& g) { }
         /// Edge -> EdgeIt conversion
 
Index: lemon/concept/graph_component.h
===================================================================
--- lemon/concept/graph_component.h	(revision 1627)
+++ lemon/concept/graph_component.h	(revision 1631)
@@ -764,5 +764,5 @@
 
     /// This class describes the common interface of the graph maps
-    /// (NodeMap, EdgeMap), that is \ref maps-pages "maps" which can be used to
+    /// (NodeMap, EdgeMap), that is \ref maps-page "maps" which can be used to
     /// associate data to graph descriptors (nodes or edges).
     template <typename Graph, typename Item, typename _Value>
Index: lemon/concept/undir_graph.h
===================================================================
--- lemon/concept/undir_graph.h	(revision 1630)
+++ lemon/concept/undir_graph.h	(revision 1631)
@@ -233,5 +233,5 @@
     ///
     /// In LEMON undirected graphs also fulfill the concept of directed
-    /// graphs (\ref lemon::concept::Graph "Graph Concept"). For
+    /// graphs (\ref lemon::concept::StaticGraph "Graph Concept"). For
     /// explanation of this and more see also the page \ref undir_graphs,
     /// a tutorial about undirected graphs.
@@ -558,5 +558,5 @@
         /// This constructor sets the iterator to the first edge of \c g.
         ///@param g the graph
-        EdgeIt(const UndirGraph&) { }
+        EdgeIt(const UndirGraph &g) { }
         /// Edge -> EdgeIt conversion
 
@@ -606,5 +606,5 @@
         ///@param n the node
         ///@param g the graph
-        OutEdgeIt(const UndirGraph&, const Node&) { }
+        OutEdgeIt(const UndirGraph& n, const Node& g) { }
         /// Edge -> OutEdgeIt conversion
 
@@ -655,5 +655,5 @@
         ///@param n the node
         ///@param g the graph
-        InEdgeIt(const UndirGraph&, const Node&) { }
+        InEdgeIt(const UndirGraph& g, const Node& n) { }
         /// Edge -> InEdgeIt conversion
 
Index: lemon/dfs.h
===================================================================
--- lemon/dfs.h	(revision 1540)
+++ lemon/dfs.h	(revision 1631)
@@ -709,5 +709,5 @@
     ///if \c v is unreachable from the root(s) or \c v is a root. The
     ///%DFS tree used here is equal to the %DFS tree used in
-    ///\ref predNode(Node v).
+    ///\ref predNode().
     ///\pre Either \ref run() or \ref start() must be called before using
     ///this function.
@@ -724,5 +724,5 @@
     ///if \c v itself a root.
     ///The %DFS tree used here is equal to the %DFS
-    ///tree used in \ref pred(Node v).
+    ///tree used in \ref pred().
     ///\pre Either \ref run() or \ref start() must be called before
     ///using this function.
Index: lemon/dijkstra.h
===================================================================
--- lemon/dijkstra.h	(revision 1536)
+++ lemon/dijkstra.h	(revision 1631)
@@ -703,5 +703,5 @@
     ///if \c v is unreachable from the root or if \c v=s. The
     ///shortest path tree used here is equal to the shortest path tree used in
-    ///\ref predNode(Node v).  \pre \ref run() must be called before using
+    ///\ref predNode().  \pre \ref run() must be called before using
     ///this function.
     ///\todo predEdge could be a better name.
@@ -714,5 +714,5 @@
     ///root to \c /v. It is INVALID if \c v is unreachable from the root or if
     ///\c v=s. The shortest path tree used here is equal to the shortest path
-    ///tree used in \ref pred(Node v).  \pre \ref run() must be called before
+    ///tree used in \ref pred().  \pre \ref run() must be called before
     ///using this function.
     Node predNode(Node v) const { return (*_pred)[v]==INVALID ? INVALID:
Index: lemon/graph_adaptor.h
===================================================================
--- lemon/graph_adaptor.h	(revision 1627)
+++ lemon/graph_adaptor.h	(revision 1631)
@@ -1421,9 +1421,9 @@
   ///
   /// \param _Graph The type of the graph which shares its node set with 
-  /// this class. Its interface must conform to the \ref skeleton::StaticGraph
+  /// this class. Its interface must conform to the \ref concept::StaticGraph
   /// "StaticGraph" concept.
   ///
   /// In the edge extension and removing it conforms to the 
-  /// \ref skeleton::ExtendableGraph "ExtendableGraph" concept.
+  /// \ref concept::ExtendableGraph "ExtendableGraph" concept.
   template <typename _Graph>
   class NewEdgeSetAdaptor :
@@ -1513,9 +1513,9 @@
   ///
   /// \param _Graph The type of the graph which shares its node set with 
-  /// this class. Its interface must conform to the \ref skeleton::StaticGraph
+  /// this class. Its interface must conform to the \ref concept::StaticGraph
   /// "StaticGraph" concept.
   ///
   /// In the edge extension and removing it conforms to the 
-  /// \ref skeleton::ExtendableGraph "ExtendableGraph" concept.
+  /// \ref concept::ExtendableGraph "ExtendableGraph" concept.
   template <typename _Graph>
   class NewUndirEdgeSetAdaptor :
Index: lemon/kruskal.h
===================================================================
--- lemon/kruskal.h	(revision 1603)
+++ lemon/kruskal.h	(revision 1631)
@@ -52,5 +52,5 @@
   /// \param g The graph the algorithm runs on.
   /// It can be either \ref concept::StaticGraph "directed" or 
-  /// \ref concept::UndirStaticGraph "undirected".
+  /// \ref concept::UndirGraph "undirected".
   /// If the graph is directed, the algorithm consider it to be 
   /// undirected by disregarding the direction of the edges.
@@ -89,5 +89,6 @@
   /// \return The cost of the found tree.
   ///
-  /// \warning If kruskal is run on an \ref undirected graph, be sure that the
+  /// \warning If kruskal is run on an
+  /// \ref lemon::concept::UndirGraph "undirected graph", be sure that the
   /// map storing the tree is also undirected
   /// (e.g. UndirListGraph::UndirEdgeMap<bool>, otherwise the values of the
Index: lemon/preflow.h
===================================================================
--- lemon/preflow.h	(revision 1435)
+++ lemon/preflow.h	(revision 1631)
@@ -284,6 +284,7 @@
 
     ///The preflow algorithm consists of two phases, this method runs
-    ///the second phase. After calling \ref phase1 and then \ref
-    ///phase2, \ref flow contains a maximum flow, \ref flowValue
+    ///the second phase. After calling \ref phase1() and then
+    ///\ref phase2(),
+    /// \ref flowMap() return a maximum flow, \ref flowValue
     ///returns the value of a maximum flow, \ref minCut returns a
     ///minimum cut, while the methods \ref minMinCut and \ref
Index: lemon/smart_graph.h
===================================================================
--- lemon/smart_graph.h	(revision 1537)
+++ lemon/smart_graph.h	(revision 1631)
@@ -90,10 +90,10 @@
     /// Maximum node ID.
     ///\sa id(Node)
-    int maxId(Node = INVALID) const { return nodes.size()-1; }
+    int maxId(Node) const { return nodes.size()-1; }
     /// Maximum edge ID.
     
     /// Maximum edge ID.
     ///\sa id(Edge)
-    int maxId(Edge = INVALID) const { return edges.size()-1; }
+    int maxId(Edge) const { return edges.size()-1; }
 
     Node source(Edge e) const { return edges[e.n].source; }
@@ -103,6 +103,6 @@
     
     /// The ID of a valid Node is a nonnegative integer not greater than
-    /// \ref maxNodeId(). The range of the ID's is not surely continuous
-    /// and the greatest node ID can be actually less then \ref maxNodeId().
+    /// \ref maxId(Node). The range of the ID's is not surely continuous
+    /// and the greatest node ID can be actually less then \ref maxId(Node).
     ///
     /// The ID of the \ref INVALID node is -1.
@@ -112,6 +112,6 @@
     
     /// The ID of a valid Edge is a nonnegative integer not greater than
-    /// \ref maxEdgeId(). The range of the ID's is not surely continuous
-    /// and the greatest edge ID can be actually less then \ref maxEdgeId().
+    /// \ref maxId(Edge). The range of the ID's is not surely continuous
+    /// and the greatest edge ID can be actually less then \ref maxId(Edge).
     ///
     /// The ID of the \ref INVALID edge is -1.
