Index: src/work/alpar/dijkstra/bin_heap.hh
===================================================================
--- src/work/alpar/dijkstra/bin_heap.hh	(revision 224)
+++ src/work/alpar/dijkstra/bin_heap.hh	(revision 242)
@@ -59,4 +59,7 @@
 #ifndef BIN_HEAP_HH
 #define BIN_HEAP_HH
+
+///\file
+///\brief Binary Heap implementation.
 
 #include <vector>
Index: src/work/alpar/dijkstra/dijkstra.h
===================================================================
--- src/work/alpar/dijkstra/dijkstra.h	(revision 229)
+++ src/work/alpar/dijkstra/dijkstra.h	(revision 242)
@@ -1,3 +1,4 @@
 // -*- C++ -*-
+
 /* 
  *template <Graph, T, Heap=FibHeap, LengthMap=Graph::EdgeMap<T> >
@@ -26,4 +27,7 @@
 #ifndef HUGO_DIJKSTRA_H
 #define HUGO_DIJKSTRA_H
+
+///\file
+///\brief Dijkstra algorithm.
 
 #include <fib_heap.h>
@@ -44,14 +48,23 @@
   ///The type of the length is determined by the \c ValueType of the length map.
   ///
-  ///It is also posible to change the underlying priority heap.
+  ///It is also possible to change the underlying priority heap.
   ///
   ///\param Graph The graph type the algorithm runs on.
-  ///\param LengthMap This read-only EdgeMap determines the
+  ///\param LengthMap This read-only
+  ///EdgeMap
+  ///determines the
   ///lengths of the edges. It is read once for each edge, so the map
   ///may involve in relatively time consuming process to compute the edge
-  ///length if it is necessary.
+  ///length if it is necessary. The default map type is
+  ///\ref GraphSkeleton::EdgeMap "Graph::EdgeMap<int>"
   ///\param Heap The heap type used by the %Dijkstra
   ///algorithm. The default
   ///is using \ref BinHeap "binary heap".
+  
+#ifdef DOXYGEN
+  template <typename Graph,
+	    typename LengthMap,
+	    typename Heap>
+#else
   template <typename Graph,
 	    typename LengthMap=typename Graph::EdgeMap<int>,
@@ -59,4 +72,5 @@
 				   typename LengthMap::ValueType, 
 				   typename Graph::NodeMap<int> > >
+#endif
   class Dijkstra{
   public:
@@ -136,5 +150,5 @@
     //    bool reached(Node v) { return reach[v]; }
 
-    ///Chechs if a node is reachable from the source.
+    ///Checks if a node is reachable from the source.
 
     ///Returns \c true if \c v is reachable from the source.
Index: src/work/alpar/dijkstra/fib_heap.h
===================================================================
--- src/work/alpar/dijkstra/fib_heap.h	(revision 224)
+++ src/work/alpar/dijkstra/fib_heap.h	(revision 242)
@@ -52,4 +52,7 @@
 #define FIB_HEAP_H
 
+///\file
+///\brief Fibonacci Heap implementation.
+
 #include <vector>
 #include <functional>
@@ -74,5 +77,5 @@
 
     ///\todo It is use nowhere
-    ///\todo It doesn't conforms to the naming conventions.
+    ///\todo It doesn't conform to the naming conventions.
   public:
     enum state_enum {
Index: src/work/alpar/emptygraph.h
===================================================================
--- src/work/alpar/emptygraph.h	(revision 216)
+++ src/work/alpar/emptygraph.h	(revision 242)
@@ -3,4 +3,7 @@
 #define HUGO_EMPTYGRAPH_H
 
+///\file
+///\brief Declaration of GraphSkeleton.
+
 #include <invalid.h>
 
@@ -13,7 +16,4 @@
   /// An empty graph class.
   
-  /// When you read this for the first time,
-  /// please send an e-mail to alpar\@cs.elte.hu.
-  ///
   /// This class provides all the common features of a graph structure,
   /// however completely without implementations and real data structures
@@ -103,7 +103,7 @@
     };
     
-    /// This iterator goes trought the outgoing edges of a node.
-
-    /// This iterator goes trought the \e outgoing edges of a certain node
+    /// This iterator goes trough the outgoing edges of a node.
+
+    /// This iterator goes trough the \e outgoing edges of a certain node
     /// of a graph.
     /// Its usage is quite simple, for example you can count the number
@@ -131,7 +131,7 @@
     };
 
-    /// This iterator goes trought the incoming edges of a node.
-
-    /// This iterator goes trought the \e incoming edges of a certain node
+    /// This iterator goes trough the incoming edges of a node.
+
+    /// This iterator goes trough the \e incoming edges of a certain node
     /// of a graph.
     /// Its usage is quite simple, for example you can count the number
@@ -179,7 +179,7 @@
     NodeIt &first(NodeIt &i) const { return i;}
 
+    /// The first incoming edge.
+    InEdgeIt &first(InEdgeIt &i, Node n) const { return i;}
     /// The first outgoing edge.
-    InEdgeIt &first(InEdgeIt &i, Node n) const { return i;}
-    /// The first incoming edge.
     OutEdgeIt &first(OutEdgeIt &i, Node n) const { return i;}
     //  SymEdgeIt &first(SymEdgeIt &, Node) const { return i;}
@@ -229,10 +229,10 @@
     ///Gives back the \e id of a node.
 
-    ///\warning Not all graph structure provide this feature.
+    ///\warning Not all graph structures provide this feature.
     ///
     int id(const Node) const { return 0;}
     ///Gives back the \e id of an edge.
 
-    ///\warning Not all graph structure provide this feature.
+    ///\warning Not all graph structures provide this feature.
     ///
     int id(const Edge) const { return 0;}
@@ -253,16 +253,5 @@
     Edge addEdge(Node tail, Node head) { return INVALID;}
     
-    /// Deletes a node.
-    
-    ///\warning Not all graph structure provide this feature.
-    ///
-    void erase(Node n) {}
-    /// Deletes an edge.
-
-    ///\warning Not all graph structure provide this feature.
-    ///
-    void erase(Edge e) {}
-
-    /// Reset the graph.
+    /// Resets the graph.
 
     /// This function deletes all edges and nodes of the graph.
@@ -272,9 +261,11 @@
     int nodeNum() const { return 0;}
     int edgeNum() const { return 0;}
-
+ 
+    /// Defalult constructor.
     GraphSkeleton() {}
+    ///Copy consructor.
     GraphSkeleton(const GraphSkeleton &G) {}
   
-  
+ 
 
     ///Read/write/reference map of the nodes to type \c T.
@@ -344,4 +335,38 @@
   };
 
+  /// An empty eraseable graph class.
+  
+  /// This class provides all the common features of an \e eraseable graph
+  /// structure,
+  /// however completely without implementations and real data structures
+  /// behind the interface.
+  /// All graph algorithms should compile with this class, but it will not
+  /// run properly, of course.
+  ///
+  /// \todo This blabla could be replaced by a sepatate description about
+  /// Skeletons.
+  ///
+  /// It can be used for checking the interface compatibility,
+  /// or it can serve as a skeleton of a new graph structure.
+  /// 
+  /// Also, you will find here the full documentation of a certain graph
+  /// feature, the documentation of a real graph imlementation
+  /// like @ref ListGraph or
+  /// @ref SmartGraph will just refer to this structure.
+  class EraseableGraphSkeleton : public GraphSkeleton
+  {
+  public:
+    /// Deletes a node.
+    void erase(Node n) {}
+    /// Deletes an edge.
+    void erase(Edge e) {}
+
+    /// Defalult constructor.
+    GraphSkeleton() {}
+    ///Copy consructor.
+    GraphSkeleton(const GraphSkeleton &G) {}
+  };
+
+  
   // @}
 
Index: src/work/alpar/invalid.h
===================================================================
--- src/work/alpar/invalid.h	(revision 184)
+++ src/work/alpar/invalid.h	(revision 242)
@@ -3,4 +3,7 @@
 #ifndef HUGO_INVALID_H
 #define HUGO_INVALID_H
+
+///\file
+///\brief Definition of INVALID.
 
 namespace hugo {
Index: src/work/alpar/mapskeleton.h
===================================================================
--- src/work/alpar/mapskeleton.h	(revision 209)
+++ src/work/alpar/mapskeleton.h	(revision 242)
@@ -2,4 +2,7 @@
 #ifndef HUGO_MAPSKELETON_H
 #define HUGO_MAPSKELETON_H
+
+///\file
+///\brief Map concepts checking classes for testing and documenting.
 
 namespace hugo {
Index: src/work/alpar/smart_graph.h
===================================================================
--- src/work/alpar/smart_graph.h	(revision 215)
+++ src/work/alpar/smart_graph.h	(revision 242)
@@ -4,4 +4,7 @@
 #define HUGO_SMART_GRAPH_H
 
+///\file
+///\brief SmartGraph and SymSmartGraph classes.
+
 #include <vector>
 #include <limits.h>
@@ -15,11 +18,8 @@
   ///A smart graph class.
 
-  /// When you read this for the first time,
-  /// please send an e-mail to alpar\@cs.elte.hu.
-  ///
   ///This is a simple and fast graph implementation.
   ///It is also quite memory efficient, but at the price
   ///that <b> it does not support node and edge deletion</b>.
-  ///Apart from this it conforms to the graph interface documented under
+  ///It conforms to the graph interface documented under
   ///the description of \ref GraphSkeleton.
   ///\sa \ref GraphSkeleton.
Index: src/work/athos/xy/boundingbox.h
===================================================================
--- src/work/athos/xy/boundingbox.h	(revision 240)
+++ src/work/athos/xy/boundingbox.h	(revision 242)
@@ -1,7 +1,3 @@
 // -*- c++ -*-
-/**
-Implementation of a bounding box of plainvectors.
-
-*/
 #ifndef HUGO_BOUNDINGBOX_H
 #define HUGO_BOUNDINGBOX_H
@@ -12,4 +8,8 @@
 namespace hugo {
 
+  /** \brief
+     Implementation of a bounding box of plainvectors.
+     
+  */
   template<typename T>
     class BoundingBox {
Index: src/work/athos/xy/xy.h
===================================================================
--- src/work/athos/xy/xy.h	(revision 240)
+++ src/work/athos/xy/xy.h	(revision 242)
@@ -1,7 +1,3 @@
 // -*- c++ -*-
-/**
-2 dimensional vector (plainvector) implementation
-
-*/
 #ifndef HUGO_XY_H
 #define HUGO_XY_H
@@ -11,4 +7,8 @@
 namespace hugo {
 
+/** \brief
+2 dimensional vector (plainvector) implementation
+
+*/
   template<typename T>
     class xy {
