Fix to build with correct two phase name lookup (xcode 4.3 compatibility for OpenMesh). The template base class members are not found otherwise.

git-svn-id: http://www.openmesh.org/svnrepo/OpenMesh/trunk@552 fdac6126-5c0c-442c-9429-916003d36597

src/OpenMesh/Core/Mesh/AttribKernelT.hh

@@ -126,7 +126,7 @@ public:
     refcount_fcolors_(0),
     refcount_ftextureIndex_(0)
   {
-    add_property( points_, "v:points" );
+    this->add_property( points_, "v:points" );
 
     if (VAttribs & Attributes::Normal)
       request_vertex_normals();
@@ -184,10 +184,10 @@ public:
 
     //FIXME: data properties might actually cost storage even
     //if there are no data traits??
-    add_property(data_vpph_);
+    this->add_property(data_vpph_);
-    add_property(data_fpph_);
+    this->add_property(data_fpph_);
-    add_property(data_hpph_);
+    this->add_property(data_hpph_);
-    add_property(data_epph_);
+    this->add_property(data_epph_);
   }
 
   virtual ~AttribKernelT()
@@ -196,55 +196,6 @@ public:
     // BaseKernel's destructor anyway...
   }
 
-// Martin: This below does not make any sense, right?
-  // -------------------------------------------------------- copy & assignment
-//   AttribKernelT(const AttribKernelT& _rhs)
-//     : BaseKernel(_rhs)
-//   { operator=(_rhs); }
-//
-//   AttribKernelT& operator=(const AttribKernelT& _rhs)
-//   {
-//     // remove old properties
-//     remove_property(points_);
-//     remove_property(vertex_normals_);
-//     remove_property(vertex_colors_);
-//     remove_property(vertex_texcoords_);
-//     remove_property(vertex_status_);
-//     remove_property(halfedge_status_);
-//     remove_property(edge_status_);
-//     remove_property(face_normals_);
-//     remove_property(face_colors_);
-//     remove_property(face_status_);
-//
-//     // parent deep-copies properties
-//     BaseKernel::operator=(_rhs);
-//
-//     // copy property handles
-//     points_            = _rhs.points_;
-//     vertex_normals_    = _rhs.vertex_normals_;
-//     vertex_colors_     = _rhs.vertex_colors_;
-//     vertex_texcoords_  = _rhs.vertex_texcoords_;
-//     vertex_status_     = _rhs.vertex_status_;
-//     halfedge_status_   = _rhs.halfedge_status_;
-//     edge_status_       = _rhs.edge_status_;
-//     face_normals_      = _rhs.face_normals_;
-//     face_colors_       = _rhs.face_colors_;
-//     face_status_       = _rhs.face_status_;
-//
-//     // copy ref-counts
-//     refcount_vnormals_   = _rhs.refcount_vnormals_;
-//     refcount_vcolors_    = _rhs.refcount_vcolors_;
-//     refcount_vtexcoords_ = _rhs.refcount_vtexcoords_;
-//     refcount_vstatus_    = _rhs.refcount_vstatus_;
-//     refcount_hstatus_    = _rhs.refcount_hstatus_;
-//     refcount_estatus_    = _rhs.refcount_estatus_;
-//     refcount_fnormals_   = _rhs.refcount_fnormals_;
-//     refcount_fcolors_    = _rhs.refcount_fcolors_;
-//     refcount_fstatus_    = _rhs.refcount_fstatus_;
-//
-//     return *this;
-//   }
-
   /** Assignment from another mesh of \em another type.
       \note All that's copied is connectivity and vertex positions.
       All other information (like e.g. attributes or additional
@@ -267,270 +218,270 @@ public:
   //-------------------------------------------------------------------- points
 
   const Point* points() const
-  { return property(points_).data(); }
+  { return this->property(points_).data(); }
 
   const Point& point(VertexHandle _vh) const
-  { return property(points_, _vh); }
+  { return this->property(points_, _vh); }
 
   Point& point(VertexHandle _vh)
-  { return property(points_, _vh); }
+  { return this->property(points_, _vh); }
 
   void set_point(VertexHandle _vh, const Point& _p)
-  { property(points_, _vh) = _p; }
+  { this->property(points_, _vh) = _p; }
 
 
   //------------------------------------------------------------ vertex normals
 
   const Normal* vertex_normals() const
-  { return property(vertex_normals_).data(); }
+  { return this->property(vertex_normals_).data(); }
 
   const Normal& normal(VertexHandle _vh) const
-  { return property(vertex_normals_, _vh); }
+  { return this->property(vertex_normals_, _vh); }
 
   void set_normal(VertexHandle _vh, const Normal& _n)
-  { property(vertex_normals_, _vh) = _n; }
+  { this->property(vertex_normals_, _vh) = _n; }
 
 
   //------------------------------------------------------------- vertex colors
 
   const Color* vertex_colors() const
-  { return property(vertex_colors_).data(); }
+  { return this->property(vertex_colors_).data(); }
 
   const Color& color(VertexHandle _vh) const
-  { return property(vertex_colors_, _vh); }
+  { return this->property(vertex_colors_, _vh); }
 
   void set_color(VertexHandle _vh, const Color& _c)
-  { property(vertex_colors_, _vh) = _c; }
+  { this->property(vertex_colors_, _vh) = _c; }
 
 
   //------------------------------------------------------- vertex 1D texcoords
 
   const TexCoord1D* texcoords1D() const {
-    return property(vertex_texcoords1D_).data();
+    return this->property(vertex_texcoords1D_).data();
   }
 
   const TexCoord1D& texcoord1D(VertexHandle _vh) const {
-    return property(vertex_texcoords1D_, _vh);
+    return this->property(vertex_texcoords1D_, _vh);
   }
 
   void set_texcoord1D(VertexHandle _vh, const TexCoord1D& _t) {
-    property(vertex_texcoords1D_, _vh) = _t;
+    this->property(vertex_texcoords1D_, _vh) = _t;
   }
 
 
   //------------------------------------------------------- vertex 2D texcoords
 
   const TexCoord2D* texcoords2D() const {
-    return property(vertex_texcoords2D_).data();
+    return this->property(vertex_texcoords2D_).data();
   }
 
   const TexCoord2D& texcoord2D(VertexHandle _vh) const {
-    return property(vertex_texcoords2D_, _vh);
+    return this->property(vertex_texcoords2D_, _vh);
   }
 
   void set_texcoord2D(VertexHandle _vh, const TexCoord2D& _t) {
-    property(vertex_texcoords2D_, _vh) = _t;
+    this->property(vertex_texcoords2D_, _vh) = _t;
   }
 
 
   //------------------------------------------------------- vertex 3D texcoords
 
   const TexCoord3D* texcoords3D() const {
-    return property(vertex_texcoords3D_).data();
+    return this->property(vertex_texcoords3D_).data();
   }
 
   const TexCoord3D& texcoord3D(VertexHandle _vh) const {
-    return property(vertex_texcoords3D_, _vh);
+    return this->property(vertex_texcoords3D_, _vh);
   }
 
   void set_texcoord3D(VertexHandle _vh, const TexCoord3D& _t) {
-    property(vertex_texcoords3D_, _vh) = _t;
+    this->property(vertex_texcoords3D_, _vh) = _t;
   }
 
   //.------------------------------------------------------ halfedge 1D texcoords
 
   const TexCoord1D* htexcoords1D() const {
-    return property(halfedge_texcoords1D_).data();
+    return this->property(halfedge_texcoords1D_).data();
   }
 
   const TexCoord1D& texcoord1D(HalfedgeHandle _heh) const {
-    return property(halfedge_texcoords1D_, _heh);
+    return this->property(halfedge_texcoords1D_, _heh);
   }
 
   void set_texcoord1D(HalfedgeHandle _heh, const TexCoord1D& _t) {
-    property(halfedge_texcoords1D_, _heh) = _t;
+    this->property(halfedge_texcoords1D_, _heh) = _t;
   }
 
 
   //------------------------------------------------------- halfedge 2D texcoords
 
   const TexCoord2D* htexcoords2D() const {
-    return property(halfedge_texcoords2D_).data();
+    return this->property(halfedge_texcoords2D_).data();
   }
 
   const TexCoord2D& texcoord2D(HalfedgeHandle _heh) const {
-    return property(halfedge_texcoords2D_, _heh);
+    return this->property(halfedge_texcoords2D_, _heh);
   }
 
   void set_texcoord2D(HalfedgeHandle _heh, const TexCoord2D& _t) {
-    property(halfedge_texcoords2D_, _heh) = _t;
+    this->property(halfedge_texcoords2D_, _heh) = _t;
   }
 
 
   //------------------------------------------------------- halfedge 3D texcoords
 
   const TexCoord3D* htexcoords3D() const {
-    return property(halfedge_texcoords3D_).data();
+    return this->property(halfedge_texcoords3D_).data();
   }
 
   const TexCoord3D& texcoord3D(HalfedgeHandle _heh) const {
-    return property(halfedge_texcoords3D_, _heh);
+    return this->property(halfedge_texcoords3D_, _heh);
   }
 
   void set_texcoord3D(HalfedgeHandle _heh, const TexCoord3D& _t) {
-    property(halfedge_texcoords3D_, _heh) = _t;
+    this->property(halfedge_texcoords3D_, _heh) = _t;
   }
   
   //------------------------------------------------------------- edge colors
   
   const Color* edge_colors() const
-  { return property(edge_colors_).data(); }
+  { return this->property(edge_colors_).data(); }
   
   const Color& color(EdgeHandle _eh) const
-  { return property(edge_colors_, _eh); }
+  { return this->property(edge_colors_, _eh); }
   
   void set_color(EdgeHandle _eh, const Color& _c)
-  { property(edge_colors_, _eh) = _c; }
+  { this->property(edge_colors_, _eh) = _c; }
 
 
   //------------------------------------------------------------- halfedge normals
 
   const Normal& normal(HalfedgeHandle _heh) const
-  { return property(halfedge_normals_, _heh); }
+  { return this->property(halfedge_normals_, _heh); }
 
   void set_normal(HalfedgeHandle _heh, const Normal& _n)
-  { property(halfedge_normals_, _heh) = _n; }
+  { this->property(halfedge_normals_, _heh) = _n; }
 
 
   //------------------------------------------------------------- halfedge colors
   
   const Color* halfedge_colors() const
-  { return property(halfedge_colors_).data(); }
+  { return this->property(halfedge_colors_).data(); }
   
   const Color& color(HalfedgeHandle _heh) const
-  { return property(halfedge_colors_, _heh); }
+  { return this->property(halfedge_colors_, _heh); }
   
   void set_color(HalfedgeHandle _heh, const Color& _c)
-  { property(halfedge_colors_, _heh) = _c; }
+  { this->property(halfedge_colors_, _heh) = _c; }
 
   //-------------------------------------------------------------- face normals
 
   const Normal& normal(FaceHandle _fh) const
-  { return property(face_normals_, _fh); }
+  { return this->property(face_normals_, _fh); }
 
   void set_normal(FaceHandle _fh, const Normal& _n)
-  { property(face_normals_, _fh) = _n; }
+  { this->property(face_normals_, _fh) = _n; }
 
   //-------------------------------------------------------------- per Face Texture index
 
   const TextureIndex& texture_index(FaceHandle _fh) const
-  { return property(face_texture_index_, _fh); }
+  { return this->property(face_texture_index_, _fh); }
 
   void set_texture_index(FaceHandle _fh, const TextureIndex& _t)
-  { property(face_texture_index_, _fh) = _t; }
+  { this->property(face_texture_index_, _fh) = _t; }
 
   //--------------------------------------------------------------- face colors
 
   const Color& color(FaceHandle _fh) const
-  { return property(face_colors_, _fh); }
+  { return this->property(face_colors_, _fh); }
 
   void set_color(FaceHandle _fh, const Color& _c)
-  { property(face_colors_, _fh) = _c; }
+  { this->property(face_colors_, _fh) = _c; }
 
   //------------------------------------------------ request / alloc properties
 
   void request_vertex_normals()
   {
     if (!refcount_vnormals_++)
-      add_property( vertex_normals_, "v:normals" );
+      this->add_property( vertex_normals_, "v:normals" );
   }
 
   void request_vertex_colors()
   {
     if (!refcount_vcolors_++)
-      add_property( vertex_colors_, "v:colors" );
+      this->add_property( vertex_colors_, "v:colors" );
   }
 
   void request_vertex_texcoords1D()
   {
     if (!refcount_vtexcoords1D_++)
-      add_property( vertex_texcoords1D_, "v:texcoords1D" );
+      this->add_property( vertex_texcoords1D_, "v:texcoords1D" );
   }
 
   void request_vertex_texcoords2D()
   {
     if (!refcount_vtexcoords2D_++)
-      add_property( vertex_texcoords2D_, "v:texcoords2D" );
+      this->add_property( vertex_texcoords2D_, "v:texcoords2D" );
   }
 
   void request_vertex_texcoords3D()
   {
     if (!refcount_vtexcoords3D_++)
-      add_property( vertex_texcoords3D_, "v:texcoords3D" );
+      this->add_property( vertex_texcoords3D_, "v:texcoords3D" );
   }
 
   void request_halfedge_texcoords1D()
   {
     if (!refcount_htexcoords1D_++)
-      add_property( halfedge_texcoords1D_, "h:texcoords1D" );
+      this->add_property( halfedge_texcoords1D_, "h:texcoords1D" );
   }
 
   void request_halfedge_texcoords2D()
   {
     if (!refcount_htexcoords2D_++)
-      add_property( halfedge_texcoords2D_, "h:texcoords2D" );
+      this->add_property( halfedge_texcoords2D_, "h:texcoords2D" );
   }
 
   void request_halfedge_texcoords3D()
   {
     if (!refcount_htexcoords3D_++)
-      add_property( halfedge_texcoords3D_, "h:texcoords3D" );
+      this->add_property( halfedge_texcoords3D_, "h:texcoords3D" );
   }
   
   void request_edge_colors()
   {
     if (!refcount_ecolors_++)
-      add_property( edge_colors_, "e:colors" );
+      this->add_property( edge_colors_, "e:colors" );
   }
 
   void request_halfedge_normals()
   {
     if (!refcount_henormals_++)
-      add_property( halfedge_normals_, "h:normals" );
+      this->add_property( halfedge_normals_, "h:normals" );
   }
 
   void request_halfedge_colors()
   {
     if (!refcount_hecolors_++)
-      add_property( halfedge_colors_, "h:colors" );
+      this->add_property( halfedge_colors_, "h:colors" );
   }
 
   void request_face_normals()
   {
     if (!refcount_fnormals_++)
-      add_property( face_normals_, "f:normals" );
+      this->add_property( face_normals_, "f:normals" );
   }
 
   void request_face_colors()
   {
     if (!refcount_fcolors_++)
-      add_property( face_colors_, "f:colors" );
+      this->add_property( face_colors_, "f:colors" );
   }
 
   void request_face_texture_index()
   {
     if (!refcount_ftextureIndex_++)
-      add_property( face_texture_index_, "f:textureindex" );
+      this->add_property( face_texture_index_, "f:textureindex" );
   }
 
   //------------------------------------------------- release / free properties
@@ -538,79 +489,79 @@ public:
   void release_vertex_normals()
   {
     if ((refcount_vnormals_ > 0) && (! --refcount_vnormals_))
-      remove_property(vertex_normals_);
+      this->remove_property(vertex_normals_);
   }
 
   void release_vertex_colors()
   {
     if ((refcount_vcolors_ > 0) && (! --refcount_vcolors_))
-      remove_property(vertex_colors_);
+      this->remove_property(vertex_colors_);
   }
 
   void release_vertex_texcoords1D() {
     if ((refcount_vtexcoords1D_ > 0) && (! --refcount_vtexcoords1D_))
-      remove_property(vertex_texcoords1D_);
+      this->remove_property(vertex_texcoords1D_);
   }
 
   void release_vertex_texcoords2D() {
     if ((refcount_vtexcoords2D_ > 0) && (! --refcount_vtexcoords2D_))
-      remove_property(vertex_texcoords2D_);
+      this->remove_property(vertex_texcoords2D_);
   }
 
   void release_vertex_texcoords3D() {
     if ((refcount_vtexcoords3D_ > 0) && (! --refcount_vtexcoords3D_))
-      remove_property(vertex_texcoords3D_);
+      this->remove_property(vertex_texcoords3D_);
   }
 
   void release_halfedge_texcoords1D() {
     if ((refcount_htexcoords1D_ > 0) && (! --refcount_htexcoords1D_))
-      remove_property(halfedge_texcoords1D_);
+      this->remove_property(halfedge_texcoords1D_);
   }
 
   void release_halfedge_texcoords2D() {
     if ((refcount_htexcoords2D_ > 0) && (! --refcount_htexcoords2D_))
-      remove_property(halfedge_texcoords2D_);
+      this->remove_property(halfedge_texcoords2D_);
   }
 
   void release_halfedge_texcoords3D() {
     if ((refcount_htexcoords3D_ > 0) && (! --refcount_htexcoords3D_))
-      remove_property(halfedge_texcoords3D_);
+      this->remove_property(halfedge_texcoords3D_);
   }
   
   void release_edge_colors()
   {
       if ((refcount_ecolors_ > 0) && (! --refcount_ecolors_))
-          remove_property(edge_colors_);
+          this->remove_property(edge_colors_);
   }
 
   void release_halfedge_normals()
   {
       if ((refcount_henormals_ > 0) && (! --refcount_henormals_))
-          remove_property(halfedge_normals_);
+          this->remove_property(halfedge_normals_);
   }
 
   void release_halfedge_colors()
   {
       if ((refcount_hecolors_ > 0) && (! --refcount_hecolors_))
-          remove_property(halfedge_colors_);
+          this->remove_property(halfedge_colors_);
   }
 
   void release_face_normals()
   {
     if ((refcount_fnormals_ > 0) && (! --refcount_fnormals_))
-      remove_property(face_normals_);
+      this->remove_property(face_normals_);
   }
 
   void release_face_colors()
   {
     if ((refcount_fcolors_ > 0) && (! --refcount_fcolors_))
-      remove_property(face_colors_);
+      this->remove_property(face_colors_);
   }
 
   void release_face_texture_index()
   {
     if ((refcount_ftextureIndex_ > 0) && (! --refcount_ftextureIndex_))
-      remove_property(face_texture_index_);
+      this->remove_property(face_texture_index_);
   }
 
   //---------------------------------------------- dynamic check for properties
@@ -702,28 +653,28 @@ public:
   { return face_texture_index_; }
 
   VertexData&                               data(VertexHandle _vh)
-  { return property(data_vpph_, _vh); }
+  { return this->property(data_vpph_, _vh); }
 
   const VertexData&                         data(VertexHandle _vh) const
-  { return property(data_vpph_, _vh); }
+  { return this->property(data_vpph_, _vh); }
 
   FaceData&                                 data(FaceHandle _fh)
-  { return property(data_fpph_, _fh); }
+  { return this->property(data_fpph_, _fh); }
 
   const FaceData&                           data(FaceHandle _fh) const
-  { return property(data_fpph_, _fh); }
+  { return this->property(data_fpph_, _fh); }
 
   EdgeData&                                 data(EdgeHandle _eh)
-  { return property(data_epph_, _eh); }
+  { return this->property(data_epph_, _eh); }
 
   const EdgeData&                           data(EdgeHandle _eh) const
-  { return property(data_epph_, _eh); }
+  { return this->property(data_epph_, _eh); }
 
   HalfedgeData&                             data(HalfedgeHandle _heh)
-  { return property(data_hpph_, _heh); }
+  { return this->property(data_hpph_, _heh); }
 
   const HalfedgeData&                       data(HalfedgeHandle _heh) const
-  { return property(data_hpph_, _heh); }
+  { return this->property(data_hpph_, _heh); }
 
 private:
   //standard vertex properties

src/OpenMesh/Core/Mesh/PolyMeshT.cc

@@ -94,12 +94,12 @@ PolyMeshT<Kernel>::
 calc_face_normal(FaceHandle _fh) const
 {
   assert(halfedge_handle(_fh).is_valid());
-  ConstFaceVertexIter fv_it(cfv_iter(_fh));
+  ConstFaceVertexIter fv_it(this->cfv_iter(_fh));
   
-  Point p0 = point(fv_it);
+  Point p0 = this->point(fv_it);
   Point p0i = p0; //save point of vertex 0
   ++fv_it;
-  Point p1 = point(fv_it);
+  Point p1 = this->point(fv_it);
   Point p1i = p1; //save point of vertex 1
   ++fv_it;
   Point p2;
@@ -108,7 +108,7 @@ calc_face_normal(FaceHandle _fh) const
   Normal n(0,0,0);
   for(; fv_it; ++fv_it)
   {
-    p2 = point(fv_it);
+    p2 = this->point(fv_it);
     n += vector_cast<Normal>(calc_face_normal(p0, p1, p2)); 
     p0 = p1;
     p1 = p2;
@@ -170,9 +170,9 @@ calc_face_centroid(FaceHandle _fh, Point& _pt) const
 {
   _pt.vectorize(0);
   uint valence = 0;
-  for (ConstFaceVertexIter cfv_it = cfv_iter(_fh); cfv_it; ++cfv_it, ++valence)
+  for (ConstFaceVertexIter cfv_it = this->cfv_iter(_fh); cfv_it; ++cfv_it, ++valence)
   {
-    _pt += point(cfv_it);
+    _pt += this->point(cfv_it);
   }
   _pt /= valence;
 }
@@ -201,7 +201,7 @@ update_face_normals()
   FaceIter f_it(Kernel::faces_begin()), f_end(Kernel::faces_end());
 
   for (; f_it != f_end; ++f_it)
-    set_normal(f_it.handle(), calc_face_normal(f_it.handle()));
+    this->set_normal(f_it.handle(), calc_face_normal(f_it.handle()));
 }
 
 
@@ -216,7 +216,7 @@ update_halfedge_normals(const double _feature_angle)
   HalfedgeIter h_it(Kernel::halfedges_begin()), h_end(Kernel::halfedges_end());
 
   for (; h_it != h_end; ++h_it)
-    set_normal(h_it.handle(), calc_halfedge_normal(h_it.handle(), _feature_angle));
+    this->set_normal(h_it.handle(), calc_halfedge_normal(h_it.handle(), _feature_angle));
 }
 
 
@@ -324,8 +324,8 @@ void PolyMeshT<Kernel>::
 calc_vertex_normal_fast(VertexHandle _vh, Normal& _n) const
 {
   _n.vectorize(0.0);
-  for (ConstVertexFaceIter vf_it=cvf_iter(_vh); vf_it; ++vf_it)
+  for (ConstVertexFaceIter vf_it=this->cvf_iter(_vh); vf_it; ++vf_it)
-    _n += normal(vf_it.handle());
+    _n += this->normal(vf_it.handle());
 }
 
 //-----------------------------------------------------------------------------
@@ -370,8 +370,8 @@ calc_vertex_normal_loop(VertexHandle _vh, Normal& _n) const
   for (ConstVertexOHalfedgeIter cvoh_it = cvoh_iter(_vh); cvoh_it; ++cvoh_it, ++i)
   {
     VertexHandle r1_v(to_vertex_handle(cvoh_it));
-    t_v += (typename Point::value_type)(loop_scheme_mask__.tang0_weight(vh_val, i))*point(r1_v);
+    t_v += (typename Point::value_type)(loop_scheme_mask__.tang0_weight(vh_val, i))*this->point(r1_v);
-    t_w += (typename Point::value_type)(loop_scheme_mask__.tang1_weight(vh_val, i))*point(r1_v);
+    t_w += (typename Point::value_type)(loop_scheme_mask__.tang1_weight(vh_val, i))*this->point(r1_v);
   }
   _n = cross(t_w, t_v);//hack: should be cross(t_v, t_w), but then the normals are reversed?
 }
@@ -387,7 +387,7 @@ update_vertex_normals()
   VertexIter  v_it(Kernel::vertices_begin()), v_end(Kernel::vertices_end());
 
   for (; v_it!=v_end; ++v_it)
-    set_normal(v_it.handle(), calc_vertex_normal(v_it.handle()));
+    this->set_normal(v_it.handle(), calc_vertex_normal(v_it.handle()));
 }
 
 //=============================================================================

src/OpenMesh/Core/Mesh/PolyMeshT.hh

@@ -192,7 +192,7 @@ public:
   inline VertexHandle new_vertex(const Point& _p)
   {
     VertexHandle vh(Kernel::new_vertex());
-    set_point(vh, _p);
+    this->set_point(vh, _p);
     return vh;
   }
 
@@ -211,7 +211,7 @@ public:
 
   /// Update normal for face _fh
   void update_normal(FaceHandle _fh)
-  { set_normal(_fh, calc_face_normal(_fh)); }
+  { this->set_normal(_fh, calc_face_normal(_fh)); }
 
   /** Update normal vectors for all faces.
       \attention Needs the Attributes::Normal attribute for faces. */
@@ -228,7 +228,7 @@ public:
 
   /// Update normal for halfedge _heh
   void update_normal(HalfedgeHandle _heh, const double _feature_angle = 0.8)
-  { set_normal(_heh, calc_halfedge_normal(_heh)); }
+  { this->set_normal(_heh, calc_halfedge_normal(_heh)); }
 
   /** Update normal vectors for all halfedges.
       \attention Needs the Attributes::Normal attribute for faces. */
@@ -245,7 +245,7 @@ public:
 
   /// Update normal for vertex _vh
   void update_normal(VertexHandle _vh)
-  { set_normal(_vh, calc_vertex_normal(_vh)); }
+  { this->set_normal(_vh, calc_vertex_normal(_vh)); }
 
   /** \brief Update normal vectors for all vertices. 
 

src/OpenMesh/Core/Mesh/TriMeshT.cc

@@ -72,11 +72,11 @@ TriMeshT<Kernel>::
 calc_face_normal(FaceHandle _fh) const
 {
   assert(halfedge_handle(_fh).is_valid());
-  ConstFaceVertexIter fv_it(cfv_iter(_fh));
+  ConstFaceVertexIter fv_it(this->cfv_iter(_fh));
 
-  const Point& p0(point(fv_it));  ++fv_it;
+  const Point& p0(this->point(fv_it));  ++fv_it;
-  const Point& p1(point(fv_it));  ++fv_it;
+  const Point& p1(this->point(fv_it));  ++fv_it;
-  const Point& p2(point(fv_it));
+  const Point& p2(this->point(fv_it));
 
   return PolyMesh::calc_face_normal(p0, p1, p2);
 }

src/OpenMesh/Tools/Smoother/JacobiLaplaceSmootherT.cc

@@ -104,16 +104,16 @@ compute_new_positions_C0()
 
   for (v_it=Base::mesh_.vertices_begin(); v_it!=v_end; ++v_it)
   {
-    if (is_active(v_it))
+    if (this->is_active(v_it))
     {
       // compute umbrella
       u = zero;
       for (vv_it=Base::mesh_.cvv_iter(v_it); vv_it; ++vv_it)
       {
-        w = weight(Base::mesh_.edge_handle(vv_it.current_halfedge_handle()));
+        w = this->weight(Base::mesh_.edge_handle(vv_it.current_halfedge_handle()));
         u += vector_cast<typename Mesh::Normal>(Base::mesh_.point(vv_it)) * w;
       }
-      u *= weight(v_it);
+      u *= this->weight(v_it);
       u -= vector_cast<typename Mesh::Normal>(Base::mesh_.point(v_it));
 
       // damping
@@ -122,7 +122,7 @@ compute_new_positions_C0()
       // store new position
       p  = vector_cast<typename Mesh::Normal>(Base::mesh_.point(v_it));
       p += u;
-      set_new_position(v_it, p);
+      this->set_new_position(v_it, p);
     }
   }
 }
@@ -148,10 +148,10 @@ compute_new_positions_C1()
     u = zero;
     for (vv_it=Base::mesh_.cvv_iter(v_it); vv_it; ++vv_it)
     {
-      w  = weight(Base::mesh_.edge_handle(vv_it.current_halfedge_handle()));
+      w  = this->weight(Base::mesh_.edge_handle(vv_it.current_halfedge_handle()));
       u -= vector_cast<typename Mesh::Normal>(Base::mesh_.point(vv_it))*w;
     }
-    u *= weight(v_it);
+    u *= this->weight(v_it);
     u += vector_cast<typename Mesh::Normal>(Base::mesh_.point(v_it));
 
     Base::mesh_.property(umbrellas_, v_it) = u;
@@ -161,18 +161,18 @@ compute_new_positions_C1()
   // 2nd pass: compute updates
   for (v_it=Base::mesh_.vertices_begin(); v_it!=v_end; ++v_it)
   {
-    if (is_active(v_it))
+    if (this->is_active(v_it))
     {
       uu   = zero;
       diag = 0.0;   
       for (vv_it=Base::mesh_.cvv_iter(v_it); vv_it; ++vv_it)
       {
-	w     = weight(Base::mesh_.edge_handle(vv_it.current_halfedge_handle()));
+	w     = this->weight(Base::mesh_.edge_handle(vv_it.current_halfedge_handle()));
 	uu   -= Base::mesh_.property(umbrellas_, vv_it);
-	diag += (w * weight(vv_it) + 1.0) * w;
+	diag += (w * this->weight(vv_it) + 1.0) * w;
       }
-      uu   *= weight(v_it);
+      uu   *= this->weight(v_it);
-      diag *= weight(v_it);
+      diag *= this->weight(v_it);
       uu   += Base::mesh_.property(umbrellas_, v_it);
       if (diag) uu *= 1.0/diag;
 
@@ -182,7 +182,7 @@ compute_new_positions_C1()
       // store new position
       p  = vector_cast<typename Mesh::Normal>(Base::mesh_.point(v_it));
       p -= uu;
-      set_new_position(v_it, p);
+      this->set_new_position(v_it, p);
     }
   }
 }

src/OpenMesh/Tools/Subdivider/Adaptive/Composite/RulesT.cc

@@ -98,7 +98,7 @@ Tvv3<M>::raise(typename M::FaceHandle& _fh, state_t _target_state)
 {
   if (MOBJ(_fh).state() < _target_state) 
   {
-    update(_fh, _target_state);
+    this->update(_fh, _target_state);
 
     typename M::VertexVertexIter          vv_it;
     typename M::FaceVertexIter            fv_it;
@@ -314,7 +314,7 @@ void Tvv3<M>::raise(typename M::VertexHandle& _vh, state_t _target_state) {
 
   if (MOBJ(_vh).state() < _target_state) {
 
-    update(_vh, _target_state);
+    this->update(_vh, _target_state);
 
     // multiply old position by 3
     MOBJ(_vh).set_position(_target_state, MOBJ(_vh).position(_target_state - 1) * 3.0);
@@ -336,7 +336,7 @@ Tvv4<M>::raise(typename M::FaceHandle& _fh, state_t _target_state)
 
   if (MOBJ(_fh).state() < _target_state) {
 
-    update(_fh, _target_state);
+    this->update(_fh, _target_state);
 
     typename M::FaceVertexIter              fv_it;
     typename M::VertexHandle                temp_vh;
@@ -638,7 +638,7 @@ Tvv4<M>::raise(typename M::VertexHandle& _vh, state_t _target_state)
   if (MOBJ(_vh).state() < _target_state)
   {
 
-    update(_vh, _target_state);
+    this->update(_vh, _target_state);
 
     // multiply old position by 4
     MOBJ(_vh).set_position(_target_state, MOBJ(_vh).position(_target_state - 1) * 4.0);
@@ -654,7 +654,7 @@ Tvv4<M>::raise(typename M::EdgeHandle& _eh, state_t _target_state)
 { 
   if (MOBJ(_eh).state() < _target_state) 
   {
-    update(_eh, _target_state);
+    this->update(_eh, _target_state);
 
     typename M::FaceHandle fh(Base::mesh_.FH(Base::mesh_.HEH(_eh, 0)));
 
@@ -815,7 +815,7 @@ void VF<M>::raise(typename M::FaceHandle& _fh, state_t _target_state)
 {
   if (MOBJ(_fh).state() < _target_state) {
 
-    update(_fh, _target_state);
+    this->update(_fh, _target_state);
 
     // raise all neighbour vertices to level x-1
     typename M::FaceVertexIter            fv_it;
@@ -872,7 +872,7 @@ void FF<M>::raise(typename M::FaceHandle& _fh, state_t _target_state) {
 
   if (MOBJ(_fh).state() < _target_state) {
 
-    update(_fh, _target_state);
+    this->update(_fh, _target_state);
 
     // raise all neighbour faces to level x-1
     typename M::FaceFaceIter              ff_it;
@@ -936,7 +936,7 @@ void FFc<M>::raise(typename M::FaceHandle& _fh, state_t _target_state)
 {
   if (MOBJ(_fh).state() < _target_state) {
 
-    update(_fh, _target_state);
+    this->update(_fh, _target_state);
 
     // raise all neighbour faces to level x-1
     typename M::FaceFaceIter              ff_it(Base::mesh_.ff_iter(_fh));
@@ -1001,7 +1001,7 @@ void FV<M>::raise(typename M::VertexHandle& _vh, state_t _target_state)
 
   if (MOBJ(_vh).state() < _target_state) {
 
-    update(_vh, _target_state);
+    this->update(_vh, _target_state);
 
     // raise all neighbour vertices to level x-1
     typename M::VertexFaceIter            vf_it(Base::mesh_.vf_iter(_vh));
@@ -1070,7 +1070,7 @@ void FVc<M>::raise(typename M::VertexHandle& _vh, state_t _target_state)
 {
   if (MOBJ(_vh).state() < _target_state) {
 
-    update(_vh, _target_state);
+    this->update(_vh, _target_state);
 
     typename M::VertexOHalfedgeIter       voh_it;
     typename M::FaceHandle                fh;
@@ -1245,7 +1245,7 @@ void VV<M>::raise(typename M::VertexHandle& _vh, state_t _target_state)
 {
   if (MOBJ(_vh).state() < _target_state) 
   {
-    update(_vh, _target_state);
+    this->update(_vh, _target_state);
 
     // raise all neighbour vertices to level x-1
     typename M::VertexVertexIter              vv_it(Base::mesh_.vv_iter(_vh));
@@ -1315,7 +1315,7 @@ void VVc<M>::raise(typename M::VertexHandle& _vh, state_t _target_state)
 {
   if (MOBJ(_vh).state() < _target_state) {
 
-    update(_vh, _target_state);
+    this->update(_vh, _target_state);
 
     // raise all neighbour vertices to level x-1
     typename M::VertexVertexIter              vv_it(Base::mesh_.vv_iter(_vh));
@@ -1390,7 +1390,7 @@ void VE<M>::raise(typename M::EdgeHandle& _eh, state_t _target_state)
 {
   if (MOBJ(_eh).state() < _target_state) {
 
-    update(_eh, _target_state);
+    this->update(_eh, _target_state);
 
     // raise all neighbour vertices to level x-1
     typename M::VertexHandle          vh;
@@ -1432,7 +1432,7 @@ void VdE<M>::raise(typename M::EdgeHandle& _eh, state_t _target_state)
 {
   if (MOBJ(_eh).state() < _target_state) 
   {
-    update(_eh, _target_state);
+    this->update(_eh, _target_state);
 
     // raise all neighbour vertices to level x-1
     typename M::VertexHandle             vh;
@@ -1509,7 +1509,7 @@ VdEc<M>::raise(typename M::EdgeHandle& _eh, state_t _target_state)
 {
   if (MOBJ(_eh).state() < _target_state) 
   {
-    update(_eh, _target_state);
+    this->update(_eh, _target_state);
 
     // raise all neighbour vertices to level x-1
     typename M::VertexHandle             vh;
@@ -1585,7 +1585,7 @@ void EV<M>::raise(typename M::VertexHandle& _vh, state_t _target_state)
 {
   if (MOBJ(_vh).state() < _target_state) {
 
-    update(_vh, _target_state);
+    this->update(_vh, _target_state);
 
     // raise all neighbour vertices to level x-1
     typename M::VertexEdgeIter            ve_it(Base::mesh_.ve_iter(_vh));
@@ -1661,7 +1661,7 @@ void EVc<M>::raise(typename M::VertexHandle& _vh, state_t _target_state)
 {
   if (MOBJ(_vh).state() < _target_state) 
   {
-    update(_vh, _target_state);
+    this->update(_vh, _target_state);
 
     // raise all neighbour vertices to level x-1
     typename M::VertexOHalfedgeIter       voh_it;
@@ -1783,7 +1783,7 @@ EF<M>::raise(typename M::FaceHandle& _fh, state_t _target_state) {
 
   if (MOBJ(_fh).state() < _target_state) {
 
-    update(_fh, _target_state);
+    this->update(_fh, _target_state);
 
     // raise all neighbour edges to level x-1
     typename M::FaceEdgeIter              fe_it(Base::mesh_.fe_iter(_fh));
@@ -1853,7 +1853,7 @@ FE<M>::raise(typename M::EdgeHandle& _eh, state_t _target_state) {
 
   if (MOBJ(_eh).state() < _target_state) {
 
-    update(_eh, _target_state);
+    this->update(_eh, _target_state);
 
     // raise all neighbour faces to level x-1
     typename M::FaceHandle                fh;
@@ -1898,7 +1898,7 @@ EdE<M>::raise(typename M::EdgeHandle& _eh, state_t _target_state) {
 
   if (MOBJ(_eh).state() < _target_state) {
 
-    update(_eh, _target_state);
+    this->update(_eh, _target_state);
 
     // raise all neighbour faces and edges to level x-1
     typename M::HalfedgeHandle            hh1, hh2;
@@ -1955,7 +1955,7 @@ EdEc<M>::raise(typename M::EdgeHandle& _eh, state_t _target_state)
 {
   if (MOBJ(_eh).state() < _target_state) {
 
-    update(_eh, _target_state);
+    this->update(_eh, _target_state);
 
     // raise all neighbour faces and edges to level x-1
     typename M::HalfedgeHandle            hh1, hh2;

src/OpenMesh/Tools/Utils/HeapT.hh

@@ -172,7 +172,7 @@ public:
   /// insert the entry _h
   void insert(HeapEntry _h)  
   { 
-    push_back(_h); 
+    this->push_back(_h); 
     upheap(size()-1); 
   }