Index: lemon/bits/alteration_notifier.h
===================================================================
--- lemon/bits/alteration_notifier.h	(revision 236)
+++ lemon/bits/alteration_notifier.h	(revision 230)
@@ -42,5 +42,5 @@
   ///
   /// The graph's node and edge sets can be changed as we add or erase
-  /// nodes and edges in the graph. LEMON would like to handle easily
+  /// nodes and edges in the graph. Lemon would like to handle easily
   /// that the node and edge maps should contain values for all nodes or
   /// edges. If we want to check on every indicing if the map contains
Index: lemon/concepts/path.h
===================================================================
--- lemon/concepts/path.h	(revision 236)
+++ lemon/concepts/path.h	(revision 220)
@@ -78,5 +78,5 @@
       void clear() {}
 
-      /// \brief LEMON style iterator for path arcs
+      /// \brief Lemon style iterator for path arcs
       ///
       /// This class is used to iterate on the arcs of the paths.
@@ -201,5 +201,5 @@
     /// If we would like to give back a real path from these
     /// algorithms then we should create a temporarly path object. In
-    /// LEMON such algorithms gives back a path dumper what can
+    /// Lemon such algorithms gives back a path dumper what can
     /// assigned to a real path and the dumpers can be implemented as
     /// an adaptor class to the predecessor map.
@@ -233,5 +233,5 @@
       typedef False RevPathTag;
 
-      /// \brief LEMON style iterator for path arcs
+      /// \brief Lemon style iterator for path arcs
       ///
       /// This class is used to iterate on the arcs of the paths.
@@ -260,5 +260,5 @@
       };
 
-      /// \brief LEMON style iterator for path arcs
+      /// \brief Lemon style iterator for path arcs
       ///
       /// This class is used to iterate on the arcs of the paths in
Index: lemon/dim2.h
===================================================================
--- lemon/dim2.h	(revision 220)
+++ lemon/dim2.h	(revision 241)
@@ -21,5 +21,4 @@
 
 #include <iostream>
-#include <lemon/core.h>
 
 ///\ingroup misc
@@ -46,7 +45,7 @@
   /// @{
 
-  /// A simple two dimensional vector (plainvector) implementation
-
-  /// A simple two dimensional vector (plainvector) implementation
+  /// A simple two dimensional vector (plain vector) implementation
+
+  /// A simple two dimensional vector (plain vector) implementation
   /// with the usual vector operations.
   template<typename T>
@@ -187,7 +186,7 @@
   }
 
-  ///Read a plainvector from a stream
-
-  ///Read a plainvector from a stream.
+  ///Read a plain vector from a stream
+
+  ///Read a plain vector from a stream.
   ///\relates Point
   ///
@@ -215,7 +214,7 @@
   }
 
-  ///Write a plainvector to a stream
-
-  ///Write a plainvector to a stream.
+  ///Write a plain vector to a stream
+
+  ///Write a plain vector to a stream.
   ///\relates Point
   ///
@@ -262,11 +261,11 @@
 
 
-  /// A class to calculate or store the bounding box of plainvectors.
-
-  /// A class to calculate or store the bounding box of plainvectors.
-  ///
+    /// A class to calculate or store the bounding box of plain vectors.
+
+    /// A class to calculate or store the bounding box of plain vectors.
+    ///
     template<typename T>
     class BoundingBox {
-      Point<T> bottom_left, top_right;
+      Point<T> _bottom_left, _top_right;
       bool _empty;
     public:
@@ -276,5 +275,8 @@
 
       ///Construct an instance from one point
-      BoundingBox(Point<T> a) { bottom_left=top_right=a; _empty = false; }
+      BoundingBox(Point<T> a) {
+        _bottom_left = _top_right = a;
+        _empty = false;
+      }
 
       ///Construct an instance from two points
@@ -287,6 +289,6 @@
       BoundingBox(Point<T> a,Point<T> b)
       {
-        bottom_left=a;
-        top_right=b;
+        _bottom_left = a;
+        _top_right = b;
         _empty = false;
       }
@@ -303,6 +305,6 @@
       BoundingBox(T l,T b,T r,T t)
       {
-        bottom_left=Point<T>(l,b);
-        top_right=Point<T>(r,t);
+        _bottom_left=Point<T>(l,b);
+        _top_right=Point<T>(r,t);
         _empty = false;
       }
@@ -321,5 +323,5 @@
       ///Make the BoundingBox empty
       void clear() {
-        _empty=1;
+        _empty = true;
       }
 
@@ -329,5 +331,5 @@
       ///If the bounding box is empty, then the return value is not defined.
       Point<T> bottomLeft() const {
-        return bottom_left;
+        return _bottom_left;
       }
 
@@ -335,7 +337,7 @@
 
       ///Set the bottom left corner of the box.
-      ///It should only be used for non-empty box.
+      ///\pre The box must not be empty.
       void bottomLeft(Point<T> p) {
-        bottom_left = p;
+        _bottom_left = p;
       }
 
@@ -345,5 +347,5 @@
       ///If the bounding box is empty, then the return value is not defined.
       Point<T> topRight() const {
-        return top_right;
+        return _top_right;
       }
 
@@ -351,7 +353,7 @@
 
       ///Set the top right corner of the box.
-      ///It should only be used for non-empty box.
+      ///\pre The box must not be empty.
       void topRight(Point<T> p) {
-        top_right = p;
+        _top_right = p;
       }
 
@@ -361,5 +363,5 @@
       ///If the bounding box is empty, then the return value is not defined.
       Point<T> bottomRight() const {
-        return Point<T>(top_right.x,bottom_left.y);
+        return Point<T>(_top_right.x,_bottom_left.y);
       }
 
@@ -367,8 +369,8 @@
 
       ///Set the bottom right corner of the box.
-      ///It should only be used for non-empty box.
+      ///\pre The box must not be empty.
       void bottomRight(Point<T> p) {
-        top_right.x = p.x;
-        bottom_left.y = p.y;
+        _top_right.x = p.x;
+        _bottom_left.y = p.y;
       }
 
@@ -378,5 +380,5 @@
       ///If the bounding box is empty, then the return value is not defined.
       Point<T> topLeft() const {
-        return Point<T>(bottom_left.x,top_right.y);
+        return Point<T>(_bottom_left.x,_top_right.y);
       }
 
@@ -384,8 +386,8 @@
 
       ///Set the top left corner of the box.
-      ///It should only be used for non-empty box.
+      ///\pre The box must not be empty.
       void topLeft(Point<T> p) {
-        top_right.y = p.y;
-        bottom_left.x = p.x;
+        _top_right.y = p.y;
+        _bottom_left.x = p.x;
       }
 
@@ -395,5 +397,5 @@
       ///If the bounding box is empty, then the return value is not defined.
       T bottom() const {
-        return bottom_left.y;
+        return _bottom_left.y;
       }
 
@@ -401,7 +403,7 @@
 
       ///Set the bottom of the box.
-      ///It should only be used for non-empty box.
+      ///\pre The box must not be empty.
       void bottom(T t) {
-        bottom_left.y = t;
+        _bottom_left.y = t;
       }
 
@@ -411,5 +413,5 @@
       ///If the bounding box is empty, then the return value is not defined.
       T top() const {
-        return top_right.y;
+        return _top_right.y;
       }
 
@@ -417,7 +419,7 @@
 
       ///Set the top of the box.
-      ///It should only be used for non-empty box.
+      ///\pre The box must not be empty.
       void top(T t) {
-        top_right.y = t;
+        _top_right.y = t;
       }
 
@@ -427,5 +429,5 @@
       ///If the bounding box is empty, then the return value is not defined.
       T left() const {
-        return bottom_left.x;
+        return _bottom_left.x;
       }
 
@@ -433,7 +435,7 @@
 
       ///Set the left side of the box.
-      ///It should only be used for non-empty box.
+      ///\pre The box must not be empty.
       void left(T t) {
-        bottom_left.x = t;
+        _bottom_left.x = t;
       }
 
@@ -443,5 +445,5 @@
       ///If the bounding box is empty, then the return value is not defined.
       T right() const {
-        return top_right.x;
+        return _top_right.x;
       }
 
@@ -449,7 +451,7 @@
 
       ///Set the right side of the box.
-      ///It should only be used for non-empty box.
+      ///\pre The box must not be empty.
       void right(T t) {
-        top_right.x = t;
+        _top_right.x = t;
       }
 
@@ -459,5 +461,5 @@
       ///If the bounding box is empty, then the return value is not defined.
       T height() const {
-        return top_right.y-bottom_left.y;
+        return _top_right.y-_bottom_left.y;
       }
 
@@ -467,5 +469,5 @@
       ///If the bounding box is empty, then the return value is not defined.
       T width() const {
-        return top_right.x-bottom_left.x;
+        return _top_right.x-_bottom_left.x;
       }
 
@@ -474,7 +476,7 @@
         if (_empty)
           return false;
-        else{
-          return ((u.x-bottom_left.x)*(top_right.x-u.x) >= 0 &&
-              (u.y-bottom_left.y)*(top_right.y-u.y) >= 0 );
+        else {
+          return ( (u.x-_bottom_left.x)*(_top_right.x-u.x) >= 0 &&
+                   (u.y-_bottom_left.y)*(_top_right.y-u.y) >= 0 );
         }
       }
@@ -485,13 +487,13 @@
       ///
       BoundingBox& add(const Point<T>& u){
-        if (_empty){
-          bottom_left=top_right=u;
+        if (_empty) {
+          _bottom_left = _top_right = u;
           _empty = false;
         }
-        else{
-          if (bottom_left.x > u.x) bottom_left.x = u.x;
-          if (bottom_left.y > u.y) bottom_left.y = u.y;
-          if (top_right.x < u.x) top_right.x = u.x;
-          if (top_right.y < u.y) top_right.y = u.y;
+        else {
+          if (_bottom_left.x > u.x) _bottom_left.x = u.x;
+          if (_bottom_left.y > u.y) _bottom_left.y = u.y;
+          if (_top_right.x < u.x) _top_right.x = u.x;
+          if (_top_right.y < u.y) _top_right.y = u.y;
         }
         return *this;
@@ -504,6 +506,6 @@
       BoundingBox& add(const BoundingBox &u){
         if ( !u.empty() ){
-          this->add(u.bottomLeft());
-          this->add(u.topRight());
+          add(u._bottom_left);
+          add(u._top_right);
         }
         return *this;
@@ -516,13 +518,13 @@
       BoundingBox operator&(const BoundingBox& u) const {
         BoundingBox b;
-        if (this->_empty || u._empty) {
+        if (_empty || u._empty) {
           b._empty = true;
         } else {
-          b.bottom_left.x = std::max(this->bottom_left.x,u.bottom_left.x);
-          b.bottom_left.y = std::max(this->bottom_left.y,u.bottom_left.y);
-          b.top_right.x = std::min(this->top_right.x,u.top_right.x);
-          b.top_right.y = std::min(this->top_right.y,u.top_right.y);
-          b._empty = b.bottom_left.x > b.top_right.x ||
-                     b.bottom_left.y > b.top_right.y;
+          b._bottom_left.x = std::max(_bottom_left.x, u._bottom_left.x);
+          b._bottom_left.y = std::max(_bottom_left.y, u._bottom_left.y);
+          b._top_right.x = std::min(_top_right.x, u._top_right.x);
+          b._top_right.y = std::min(_top_right.y, u._top_right.y);
+          b._empty = b._bottom_left.x > b._top_right.x ||
+                     b._bottom_left.y > b._top_right.y;
         }
         return b;
Index: lemon/lgf_reader.h
===================================================================
--- lemon/lgf_reader.h	(revision 236)
+++ lemon/lgf_reader.h	(revision 220)
@@ -19,5 +19,5 @@
 ///\ingroup lemon_io
 ///\file
-///\brief \ref lgf-format "LEMON Graph Format" reader.
+///\brief \ref lgf-format "Lemon Graph Format" reader.
 
 
@@ -2302,5 +2302,5 @@
   ///
   /// This class can be used to read the sections, the map names and
-  /// the attributes from a file. Usually, the LEMON programs know
+  /// the attributes from a file. Usually, the Lemon programs know
   /// that, which type of graph, which maps and which attributes
   /// should be read from a file, but in general tools (like glemon)
Index: lemon/lgf_writer.h
===================================================================
--- lemon/lgf_writer.h	(revision 240)
+++ lemon/lgf_writer.h	(revision 220)
@@ -19,5 +19,5 @@
 ///\ingroup lemon_io
 ///\file
-///\brief \ref lgf-format "LEMON Graph Format" writer.
+///\brief \ref lgf-format "Lemon Graph Format" writer.
 
 
@@ -935,5 +935,5 @@
     bool local_os;
 
-    const Graph& _graph;
+    Graph& _graph;
 
     std::string _nodes_caption;
Index: lemon/list_graph.h
===================================================================
--- lemon/list_graph.h	(revision 239)
+++ lemon/list_graph.h	(revision 235)
@@ -843,7 +843,5 @@
 
     public:
-      operator Edge() const { 
-        return id != -1 ? edgeFromId(id / 2) : INVALID; 
-      }
+      operator Edge() const { return edgeFromId(id / 2); }
 
       Arc() {}
Index: lemon/path.h
===================================================================
--- lemon/path.h	(revision 236)
+++ lemon/path.h	(revision 220)
@@ -83,5 +83,5 @@
     }
 
-    /// \brief LEMON style iterator for path arcs
+    /// \brief Lemon style iterator for path arcs
     ///
     /// This class is used to iterate on the arcs of the paths.
Index: lemon/smart_graph.h
===================================================================
--- lemon/smart_graph.h	(revision 238)
+++ lemon/smart_graph.h	(revision 220)
@@ -466,7 +466,5 @@
 
     public:
-      operator Edge() const { 
-        return _id != -1 ? edgeFromId(_id / 2) : INVALID; 
-      }
+      operator Edge() const { return edgeFromId(_id / 2); }
 
       Arc() {}
Index: lemon/unionfind.h
===================================================================
--- lemon/unionfind.h	(revision 236)
+++ lemon/unionfind.h	(revision 220)
@@ -498,5 +498,5 @@
     }
 
-    /// \brief LEMON style iterator for the representant items.
+    /// \brief Lemon style iterator for the representant items.
     ///
     /// ClassIt is a lemon style iterator for the components. It iterates
@@ -550,5 +550,5 @@
     };
 
-    /// \brief LEMON style iterator for the items of a component.
+    /// \brief Lemon style iterator for the items of a component.
     ///
     /// ClassIt is a lemon style iterator for the components. It iterates
@@ -808,5 +808,5 @@
     }
 
-    /// \brief LEMON style iterator for the classes.
+    /// \brief Lemon style iterator for the classes.
     ///
     /// ClassIt is a lemon style iterator for the components. It iterates
@@ -860,5 +860,5 @@
     };
 
-    /// \brief LEMON style iterator for the items of a component.
+    /// \brief Lemon style iterator for the items of a component.
     ///
     /// ClassIt is a lemon style iterator for the components. It iterates
@@ -1656,5 +1656,5 @@
     }
 
-    /// \brief LEMON style iterator for the items of a class.
+    /// \brief Lemon style iterator for the items of a class.
     ///
     /// ClassIt is a lemon style iterator for the components. It iterates
