diff --git a/Common/GmshDefines.h b/Common/GmshDefines.h
index 90b2509c5a17bb2e791e425c6782035357e8d16b..01675502375e4a3ebe585a96fdbb72cbf00b2c8b 100644
--- a/Common/GmshDefines.h
+++ b/Common/GmshDefines.h
@@ -38,6 +38,18 @@
 #define FORMAT_MED           33
 #define FORMAT_DIFF          34
 
+// Element types
+#define TYPE_PNT 1
+#define TYPE_LIN 2
+#define TYPE_TRI 3
+#define TYPE_QUA 4
+#define TYPE_TET 5
+#define TYPE_PYR 6
+#define TYPE_PRI 7
+#define TYPE_HEX 8
+#define TYPE_POLYG 9
+#define TYPE_POLYH 10
+
 // Element types in .msh file format
 #define MSH_LIN_2  1
 #define MSH_TRI_3  2
diff --git a/Fltk/classificationEditor.cpp b/Fltk/classificationEditor.cpp
index c7dd3eacf719666d5b3c967497ab0bf1a31cafbf..de28d7e67ed17547f81d6e73849ac35c9938b57e 100644
--- a/Fltk/classificationEditor.cpp
+++ b/Fltk/classificationEditor.cpp
@@ -105,7 +105,7 @@ static void class_deleteedge_cb(Fl_Widget *w, void *data)
       if(CTX::instance()->pickElements){
         for(unsigned int i = 0; i < GUI::instance()->selectedElements.size(); i++){
           MElement *me = GUI::instance()->selectedElements[i];
-          if(me->getNumEdges() == 1 && me->getVisibility() != 2){
+          if(me->getType() == TYPE_LIN && me->getVisibility() != 2){
             me->setVisibility(2); ele.push_back((MLine*)me);
           }
         }
@@ -548,7 +548,7 @@ static void class_select_cb(Fl_Widget *w, void *data)
       if(CTX::instance()->pickElements){
         for(unsigned int i = 0; i < GUI::instance()->selectedElements.size(); i++){
           MElement *me = GUI::instance()->selectedElements[i];
-          if(me->getNumEdges() == 3 && me->getVisibility() != 2){
+          if(me->getType() == TYPE_TRI && me->getVisibility() != 2){
             me->setVisibility(2); ele.push_back((MTriangle*)me);
           }
         }
diff --git a/Geo/GModel.cpp b/Geo/GModel.cpp
index e6810fca264f383dabece93ceaeeefda8ff3dd89..e0a0d39ce93a2cb917157c37d5d477a7b4540049 100644
--- a/Geo/GModel.cpp
+++ b/Geo/GModel.cpp
@@ -362,11 +362,13 @@ int GModel::getMeshStatus(bool countDiscrete)
     if((countDiscrete || ((*it)->geomType() != GEntity::DiscreteVolume &&
 			  (*it)->meshAttributes.Method != MESH_NONE)) &&
        ((*it)->tetrahedra.size() ||(*it)->hexahedra.size() ||
-        (*it)->prisms.size() || (*it)->pyramids.size())) return 3;
+        (*it)->prisms.size() || (*it)->pyramids.size() ||
+        (*it)->polyhedra.size())) return 3;
   for(fiter it = firstFace(); it != lastFace(); ++it)
     if((countDiscrete || ((*it)->geomType() != GEntity::DiscreteSurface &&
 			  (*it)->meshAttributes.Method != MESH_NONE)) &&
-       ((*it)->triangles.size() || (*it)->quadrangles.size())) return 2;
+       ((*it)->triangles.size() || (*it)->quadrangles.size() ||
+        (*it)->polygons.size())) return 2;
   for(eiter it = firstEdge(); it != lastEdge(); ++it)
     if((countDiscrete || ((*it)->geomType() != GEntity::DiscreteCurve &&
 			  (*it)->meshAttributes.Method != MESH_NONE)) &&
@@ -552,12 +554,14 @@ void GModel::removeInvisibleElements()
     removeInvisible((*it)->hexahedra, all);
     removeInvisible((*it)->prisms, all);
     removeInvisible((*it)->pyramids, all);
+    removeInvisible((*it)->polyhedra, all);
     (*it)->deleteVertexArrays();
   }
   for(fiter it = firstFace(); it != lastFace(); ++it){
     bool all = !(*it)->getVisibility();
     removeInvisible((*it)->triangles, all);
     removeInvisible((*it)->quadrangles, all);
+    removeInvisible((*it)->polygons, all);
     (*it)->deleteVertexArrays();
   }
   for(eiter it = firstEdge(); it != lastEdge(); ++it){
@@ -643,9 +647,9 @@ void GModel::_storeElementsInEntities(std::map<int, std::vector<MElement*> > &ma
   std::map<int, std::vector<MElement*> >::const_iterator it = map.begin();
   for(; it != map.end(); ++it){
     if(!it->second.size()) continue;
-    int numEdges = it->second[0]->getNumEdges();
-    switch(numEdges){
-    case 0:
+    int type = it->second[0]->getType();
+    switch(type){
+    case TYPE_PNT:
       {
         GVertex *v = getVertexByTag(it->first);
         if(!v){
@@ -656,7 +660,7 @@ void GModel::_storeElementsInEntities(std::map<int, std::vector<MElement*> > &ma
 	  _addElements(v->points, it->second);
       }
       break;
-    case 1:
+    case TYPE_LIN:
       {
         GEdge *e = getEdgeByTag(it->first);
         if(!e){
@@ -666,28 +670,30 @@ void GModel::_storeElementsInEntities(std::map<int, std::vector<MElement*> > &ma
         _addElements(e->lines, it->second);
       }
       break;
-    case 3: case 4:
+    case TYPE_TRI: case TYPE_QUA: case TYPE_POLYG:
       {
         GFace *f = getFaceByTag(it->first);
         if(!f){
           f = new discreteFace(this, it->first);
           add(f);
         }
-        if(numEdges == 3) _addElements(f->triangles, it->second);
-        else _addElements(f->quadrangles, it->second);
+        if(type == TYPE_TRI) _addElements(f->triangles, it->second);
+        else if(type == TYPE_QUA) _addElements(f->quadrangles, it->second);
+        else _addElements(f->polygons, it->second);
       }
       break;
-    case 6: case 12: case 9: case 8:
+    case TYPE_TET: case TYPE_HEX: case TYPE_PYR: case TYPE_PRI: case TYPE_POLYH:
       {
         GRegion *r = getRegionByTag(it->first);
         if(!r){
           r = new discreteRegion(this, it->first);
           add(r);
         }
-        if(numEdges == 6) _addElements(r->tetrahedra, it->second);
-        else if(numEdges == 12) _addElements(r->hexahedra, it->second);
-        else if(numEdges == 9) _addElements(r->prisms, it->second);
-        else _addElements(r->pyramids, it->second);
+        if(type == TYPE_TET) _addElements(r->tetrahedra, it->second);
+        else if(type == TYPE_HEX) _addElements(r->hexahedra, it->second);
+        else if(type == TYPE_PRI) _addElements(r->prisms, it->second);
+        else if(type == TYPE_PYR) _addElements(r->pyramids, it->second);
+        else _addElements(r->polyhedra, it->second);
       }
       break;
     }
@@ -717,10 +723,12 @@ void GModel::_associateEntityWithMeshVertices()
     _associateEntityWithElementVertices(*it, (*it)->hexahedra);
     _associateEntityWithElementVertices(*it, (*it)->prisms);
     _associateEntityWithElementVertices(*it, (*it)->pyramids);
+    _associateEntityWithElementVertices(*it, (*it)->polyhedra);
   }
   for(fiter it = firstFace(); it != lastFace(); ++it){
     _associateEntityWithElementVertices(*it, (*it)->triangles);
     _associateEntityWithElementVertices(*it, (*it)->quadrangles);
+    _associateEntityWithElementVertices(*it, (*it)->polygons);
   }
   for(eiter it = firstEdge(); it != lastEdge(); ++it){
     _associateEntityWithElementVertices(*it, (*it)->lines);
@@ -865,7 +873,7 @@ int GModel::removeDuplicateMeshVertices(double tolerance)
     return 0;
   }
 
-  std::map<int, std::vector<MElement*> > elements[8];
+  std::map<int, std::vector<MElement*> > elements[10];
   for(unsigned int i = 0; i < entities.size(); i++){
     for(unsigned int j = 0; j < entities[i]->getNumMeshElements(); j++){
       MElement *e = entities[i]->getMeshElement(j);
@@ -881,15 +889,18 @@ int GModel::removeDuplicateMeshVertices(double tolerance)
       MElementFactory factory;
       MElement *e2 = factory.create(e->getTypeForMSH(), verts, e->getNum(),
                                     e->getPartition());
-      switch(e2->getNumEdges()){
-      case 0:  elements[0][entities[i]->tag()].push_back(e2); break;
-      case 1:  elements[1][entities[i]->tag()].push_back(e2); break;
-      case 3:  elements[2][entities[i]->tag()].push_back(e2); break;
-      case 4:  elements[3][entities[i]->tag()].push_back(e2); break;
-      case 6:  elements[4][entities[i]->tag()].push_back(e2); break;
-      case 12: elements[5][entities[i]->tag()].push_back(e2); break;
-      case 9:  elements[6][entities[i]->tag()].push_back(e2); break;
-      case 8:  elements[7][entities[i]->tag()].push_back(e2); break;
+      switch(e2->getType()){
+      case TYPE_PNT: elements[0][entities[i]->tag()].push_back(e2); break;
+      case TYPE_LIN: elements[1][entities[i]->tag()].push_back(e2); break;
+      case TYPE_TRI: elements[2][entities[i]->tag()].push_back(e2); break;
+      case TYPE_QUA: elements[3][entities[i]->tag()].push_back(e2); break;
+      case TYPE_TET: elements[4][entities[i]->tag()].push_back(e2); break;
+      case TYPE_HEX: elements[5][entities[i]->tag()].push_back(e2); break;
+      case TYPE_PRI: elements[6][entities[i]->tag()].push_back(e2); break;
+      case TYPE_PYR: elements[7][entities[i]->tag()].push_back(e2); break;
+      case TYPE_POLYG: elements[8][entities[i]->tag()].push_back(e2); break;
+      case TYPE_POLYH: elements[9][entities[i]->tag()].push_back(e2); break;
+
       }
     }
   }
diff --git a/Geo/GModelIO_Mesh.cpp b/Geo/GModelIO_Mesh.cpp
index 43f800065e0c20bc038d8976738563a2e5518d6c..67b908a7f99dab0c67c1fe3653389191fce59e51 100644
--- a/Geo/GModelIO_Mesh.cpp
+++ b/Geo/GModelIO_Mesh.cpp
@@ -82,64 +82,39 @@ static bool getVertices(int num, int *indices, std::vector<MVertex*> &vec,
   return true;
 }
 
-static void createElementMSH(GModel *m, int num, int type, int physical, 
+static void createElementMSH(GModel *m, int num, int typeMSH, int physical, 
                              int reg, int part, std::vector<MVertex*> &v, 
                              std::map<int, std::vector<MElement*> > elements[10],
                              std::map<int, std::map<int, std::string> > physicals[4])
 {
   MElementFactory factory;
-  MElement *e = factory.create(type, v, num, part);
+  MElement *e = factory.create(typeMSH, v, num, part);
 
   if(!e){
-    Msg::Error("Unknown type of element %d", type);
+    Msg::Error("Unknown type of element %d", typeMSH);
     return;
   }
 
-  switch(type){
-  case MSH_PNT :
+  switch(e->getType()){
+  case TYPE_PNT :
     elements[0][reg].push_back(e); break;
-  case MSH_LIN_2 :
-  case MSH_LIN_3 :
-  case MSH_LIN_4 :
-  case MSH_LIN_5 :
-  case MSH_LIN_6 :
+  case TYPE_LIN :
     elements[1][reg].push_back(e); break;
-  case MSH_TRI_3 :
-  case MSH_TRI_6 :
-  case MSH_TRI_9 :
-  case MSH_TRI_10 :
-  case MSH_TRI_12 :
-  case MSH_TRI_15 :
-  case MSH_TRI_15I :
-  case MSH_TRI_21 :
+  case TYPE_TRI :
     elements[2][reg].push_back(e); break;
-  case MSH_QUA_4 :
-  case MSH_QUA_9 :
-  case MSH_QUA_8 :
+  case TYPE_QUA :
     elements[3][reg].push_back(e); break;
-  case MSH_TET_4 :
-  case MSH_TET_10 :
-  case MSH_TET_20 :
-  case MSH_TET_35 :
-  case MSH_TET_56 :
-  case MSH_TET_34 :
-  case MSH_TET_52 :
+  case TYPE_TET :
     elements[4][reg].push_back(e); break;
-  case MSH_HEX_8 :
-  case MSH_HEX_27 :
-  case MSH_HEX_20 :
+  case TYPE_HEX :
     elements[5][reg].push_back(e); break;
-  case MSH_PRI_6 :
-  case MSH_PRI_18 :
-  case MSH_PRI_15 :
+  case TYPE_PRI :
     elements[6][reg].push_back(e); break;
-  case MSH_PYR_5 :
-  case MSH_PYR_14 :
-  case MSH_PYR_13 :
+  case TYPE_PYR :
     elements[7][reg].push_back(e); break;
-  case MSH_POLYG_ :
+  case TYPE_POLYG :
     elements[8][reg].push_back(e); break;
-  case MSH_POLYH_ :
+  case TYPE_POLYH :
     elements[9][reg].push_back(e); break;
   default : Msg::Error("Wrong type of element"); return;
   }
@@ -272,7 +247,7 @@ int GModel::readMSH(const std::string &name)
 	      if(fread(uv, sizeof(double), 1, fp) != 1) return 0;
 	      if(swap) SwapBytes((char*)uv, sizeof(double), 1);
 	    }
-	    newVertex = new MEdgeVertex(xyz[0], xyz[1], xyz[2], ge, uv[0], -1.0, num);	      
+	    newVertex = new MEdgeVertex(xyz[0], xyz[1], xyz[2], ge, uv[0], -1.0, num);
 	  }
 	  else if (iClasDim == 2){
 	    GFace *gf = getFaceByTag(iClasTag);
@@ -283,7 +258,7 @@ int GModel::readMSH(const std::string &name)
 	      if(fread(uv, sizeof(double), 2, fp) != 2) return 0;
 	      if(swap) SwapBytes((char*)uv, sizeof(double), 2);
 	    }	    
-	    newVertex = new MFaceVertex(xyz[0], xyz[1], xyz[2], gf, uv[0], uv[1], num);	      
+	    newVertex = new MFaceVertex(xyz[0], xyz[1], xyz[2], gf, uv[0], uv[1], num);
 	  }
 	  else if (iClasDim == 3){
 	    GRegion *gr = getRegionByTag(iClasTag);
diff --git a/Geo/MElement.cpp b/Geo/MElement.cpp
index 58b6464317356c60e86b9756c4510f739795682d..13613451cad7aa0fabb440cda31010455d0ab54d 100644
--- a/Geo/MElement.cpp
+++ b/Geo/MElement.cpp
@@ -470,7 +470,7 @@ void MElement::writePOS(FILE *fp, bool printElementary, bool printElementNumber,
 
 void MElement::writeSTL(FILE *fp, bool binary, double scalingFactor)
 {
-  if(getNumEdges() != 3 && getNumEdges() != 4) return;
+  if(getType() != TYPE_TRI && getType() != TYPE_QUA) return;
   int qid[3] = {0, 2, 3};
   SVector3 n = getFace(0).normal();
   if(!binary){
diff --git a/Geo/MElement.h b/Geo/MElement.h
index 8a381843550e798bcecb3f597ee8ff536ea9c04d..f53d7ff23d5b0ae2c3b58f295b263fab1a1085e4 100644
--- a/Geo/MElement.h
+++ b/Geo/MElement.h
@@ -139,6 +139,9 @@ class MElement
     v.resize(0);
   }
 
+  //get the type of the element
+  virtual int getType() const = 0;
+
   // get the max/min edge length
   virtual double maxEdge();
   virtual double minEdge();
diff --git a/Geo/MElementCut.h b/Geo/MElementCut.h
index cfef4956b175f3939f6429e4e803b270b60e9369..011d1d3bbc950cddaa2f79892651ae4da54888ed 100644
--- a/Geo/MElementCut.h
+++ b/Geo/MElementCut.h
@@ -116,6 +116,7 @@ class MPolyhedron : public MElement {
     v[1] = _faces[num].getVertex(1);
     v[2] = _faces[num].getVertex(2);
   }
+  virtual int getType() const { return TYPE_POLYH; }
   virtual int getTypeForMSH() const { return MSH_POLYH_; }
   virtual double getVolume()
   {
@@ -207,7 +208,7 @@ class MPolygon : public MElement {
   virtual int getNumFacesRep() { return _parts.size(); }
   virtual void getFaceRep(int num, double *x, double *y, double *z, SVector3 *n)
   {
-   _getFaceRep(_parts[num]->getVertex(0), _parts[num]->getVertex(1),
+    _getFaceRep(_parts[num]->getVertex(0), _parts[num]->getVertex(1),
                 _parts[num]->getVertex(2), x, y, z, n);
   }
   virtual void getFaceVertices(const int num, std::vector<MVertex*> &v) const
@@ -216,6 +217,7 @@ class MPolygon : public MElement {
     for (unsigned int i = 0; i < _vertices.size(); i++)
       v[i] = _vertices[i];
   }
+  virtual int getType() const { return TYPE_POLYG; }
   virtual int getTypeForMSH() const { return MSH_POLYG_; }
   virtual const gmshFunctionSpace* getFunctionSpace(int order=-1) const 
   {
diff --git a/Geo/MHexahedron.h b/Geo/MHexahedron.h
index e614f6d3c066ee402e53fa15650b66bbe410ca4c..302df4efc9d8de502a1b3434b75a3eff825d3f63 100644
--- a/Geo/MHexahedron.h
+++ b/Geo/MHexahedron.h
@@ -111,6 +111,7 @@ class MHexahedron : public MElement {
     v.resize(4);
     _getFaceVertices(num, v);
   }
+  virtual int getType() const { return TYPE_HEX; }
   virtual int getTypeForMSH() const { return MSH_HEX_8; }
   virtual int getTypeForUNV() const { return 115; } // solid linear brick
   virtual int getTypeForVTK() const { return 12; }
diff --git a/Geo/MLine.h b/Geo/MLine.h
index 15e53a4578b089bf694539a3a011b96cb5b93b2a..8f4689f5619befa55121ef5787d2812631c5a8aa 100644
--- a/Geo/MLine.h
+++ b/Geo/MLine.h
@@ -53,6 +53,7 @@ class MLine : public MElement {
   virtual MFace getFace(int num){ return MFace(); }
   virtual int getNumFacesRep(){ return 0; }
   virtual void getFaceRep(int num, double *x, double *y, double *z, SVector3 *n){}
+  virtual int getType() const { return TYPE_LIN; }
   virtual int getTypeForMSH() const { return MSH_LIN_2; }
   virtual int getTypeForUNV() const { return 21; } // linear beam
   virtual int getTypeForVTK() const { return 3; }
diff --git a/Geo/MPoint.h b/Geo/MPoint.h
index b9d7b403098f70ac0b6a4ffd5fbc697cec448e51..55ed9c2c695412713393334bc6f2d03883fd5fb4 100644
--- a/Geo/MPoint.h
+++ b/Geo/MPoint.h
@@ -38,6 +38,7 @@ class MPoint : public MElement {
   virtual MFace getFace(int num){ return MFace(); }
   virtual int getNumFacesRep(){ return 0; }
   virtual void getFaceRep(int num, double *x, double *y, double *z, SVector3 *n){}
+  virtual int getType() const { return TYPE_PNT; }
   virtual int getTypeForMSH() const { return MSH_PNT; }
   virtual int getTypeForVTK() const { return 1; }
   virtual const char *getStringForPOS() const { return "SP"; }
diff --git a/Geo/MPrism.h b/Geo/MPrism.h
index 07807e8b71cfa8086ab6ce39cd5a2006370699df..48152c6173ac0b44bab713c3acffda486da73655 100644
--- a/Geo/MPrism.h
+++ b/Geo/MPrism.h
@@ -116,6 +116,7 @@ class MPrism : public MElement {
     v.resize((num < 2) ? 3 : 4);
     _getFaceVertices(num, v);
   }
+  virtual int getType() const { return TYPE_PRI; }
   virtual int getTypeForMSH() const { return MSH_PRI_6; }
   virtual int getTypeForUNV() const { return 112; } // solid linear wedge
   virtual int getTypeForVTK() const { return 13; }
diff --git a/Geo/MPyramid.h b/Geo/MPyramid.h
index 7c91efe97ed3c070e9e6432e294db9b9a19b3974..f27c606c1cf2fac15e2abb9c47a8419cb1acbbeb 100644
--- a/Geo/MPyramid.h
+++ b/Geo/MPyramid.h
@@ -117,6 +117,7 @@ class MPyramid : public MElement {
     v.resize((num < 4) ? 3 : 4);
     _getFaceVertices(num, v);
   }
+  virtual int getType() const { return TYPE_PYR; }
   virtual int getTypeForMSH() const { return MSH_PYR_5; }
   virtual int getTypeForVTK() const { return 14; }
   virtual const char *getStringForPOS() const { return "SY"; }
diff --git a/Geo/MQuadrangle.h b/Geo/MQuadrangle.h
index 2eb10507144aacd56fc59fde3fa8f60849b1bf16..7d009b041bdb258291a885f81d8b41479c34f0f3 100644
--- a/Geo/MQuadrangle.h
+++ b/Geo/MQuadrangle.h
@@ -95,6 +95,7 @@ class MQuadrangle : public MElement {
     v.resize(4);
     _getFaceVertices(v);
   }
+  virtual int getType() const { return TYPE_QUA; }
   virtual int getTypeForMSH() const { return MSH_QUA_4; }
   virtual int getTypeForUNV() const { return 94; } // thin shell linear quadrilateral
   virtual int getTypeForVTK() const { return 9; }
diff --git a/Geo/MTetrahedron.h b/Geo/MTetrahedron.h
index 21c723185aa58c5cc30a781eca15dc2fdbdfa34a..d3ed297d774718b9f2bb8ee99388974be935f18c 100644
--- a/Geo/MTetrahedron.h
+++ b/Geo/MTetrahedron.h
@@ -100,6 +100,7 @@ class MTetrahedron : public MElement {
     v.resize(3);
     _getFaceVertices(num, v);
   }
+  virtual int getType() const { return TYPE_TET; }
   virtual int getTypeForMSH() const { return MSH_TET_4; }
   virtual int getTypeForUNV() const { return 111; } // solid linear tetrahedron
   virtual int getTypeForVTK() const { return 10; }
diff --git a/Geo/MTriangle.h b/Geo/MTriangle.h
index 9d52e2bb913642d478507a265486c3dc4ba99796..13516f421cce53a15d59dc141f0d0c04541f3fa4 100644
--- a/Geo/MTriangle.h
+++ b/Geo/MTriangle.h
@@ -97,6 +97,7 @@ class MTriangle : public MElement {
     v.resize(3);
     _getFaceVertices(v);
   }
+  virtual int getType() const { return TYPE_TRI; }
   virtual int getTypeForMSH() const { return MSH_TRI_3; }
   virtual int getTypeForUNV() const { return 91; } // thin shell linear triangle
   virtual int getTypeForVTK() const { return 5; }
diff --git a/Graphics/drawMesh.cpp b/Graphics/drawMesh.cpp
index 3c0bbfed211c92fd8d2ac362289d7f8f5d2fa559..f65ce59744900633bfea4231bd1e2523d5032cb0 100644
--- a/Graphics/drawMesh.cpp
+++ b/Graphics/drawMesh.cpp
@@ -52,14 +52,14 @@ static unsigned int getColorByElement(MElement *ele)
     return CTX::instance()->color.geom.selection;
   }
   else if(CTX::instance()->mesh.colorCarousel == 0){ // by element type
-    switch(ele->getNumEdges()){
-    case 1: return CTX::instance()->color.mesh.line;
-    case 3: return CTX::instance()->color.mesh.triangle;
-    case 4: return CTX::instance()->color.mesh.quadrangle;
-    case 6: return CTX::instance()->color.mesh.tetrahedron;
-    case 12: return CTX::instance()->color.mesh.hexahedron;
-    case 9: return CTX::instance()->color.mesh.prism;
-    case 8: return CTX::instance()->color.mesh.pyramid;
+    switch(ele->getType()){
+    case TYPE_LIN: return CTX::instance()->color.mesh.line;
+    case TYPE_TRI: return CTX::instance()->color.mesh.triangle;
+    case TYPE_QUA: return CTX::instance()->color.mesh.quadrangle;
+    case TYPE_TET: return CTX::instance()->color.mesh.tetrahedron;
+    case TYPE_HEX: return CTX::instance()->color.mesh.hexahedron;
+    case TYPE_PRI: return CTX::instance()->color.mesh.prism;
+    case TYPE_PYR: return CTX::instance()->color.mesh.pyramid;
     default: return CTX::instance()->color.mesh.vertex;
     }
   }
diff --git a/Graphics/drawPost.cpp b/Graphics/drawPost.cpp
index 9493eb63e5441b678fe7021fc964c61c004860e7..ad2f2bd8035a19c5c3aa2cf2db2070df220db293 100644
--- a/Graphics/drawPost.cpp
+++ b/Graphics/drawPost.cpp
@@ -7,6 +7,7 @@
 #include <algorithm>
 #include "GmshConfig.h"
 #include "GmshMessage.h"
+#include "GmshDefines.h"
 #include "drawContext.h"
 #include "Numeric.h"
 #include "Iso.h"
@@ -181,7 +182,7 @@ static void applyGeneralRaise(PView *p, int numNodes, int numComp,
 }
 
 static void changeCoordinates(PView *p, int ient, int iele,
-                              int numNodes, int numEdges, int numComp, 
+                              int numNodes, int type, int numComp, 
                               double xyz[NMAX][3], double val[NMAX][9])
 {
   PViewOptions *opt = p->getOptions();
@@ -227,9 +228,9 @@ static void changeCoordinates(PView *p, int ient, int iele,
     }
   }
 
-  if(opt->normalRaise && numEdges >= 1 && numEdges <= 4){
+  if(opt->normalRaise && (type == TYPE_LIN || type == TYPE_TRI || type ==TYPE_QUA)){
     SVector3 n;
-    if(numEdges == 1){
+    if(type == TYPE_LIN){
       // assumes lines in z=const plane, and raises in that plane
       double x[2] = {xyz[0][0], xyz[1][0]};
       double y[2] = {xyz[0][1], xyz[1][1]};
@@ -781,38 +782,38 @@ static void addScalarPyramid(PView *p, double xyz[NMAX][3], double val[NMAX][9],
     addScalarTetrahedron(p, xyz, val, pre, is[i][0], is[i][1], is[i][2], is[i][3]);
 }
 
-static void addOutlineElement(PView *p, int numEdges, double xyz[NMAX][3], bool pre)
+static void addOutlineElement(PView *p, int type, double xyz[NMAX][3], bool pre)
 {
   PViewOptions *opt = p->getOptions();
-  switch(numEdges){
-  case 0: addOutlinePoint(p, xyz, opt->color.point, pre); break;
-  case 1: addOutlineLine(p, xyz, opt->color.line, pre); break;
-  case 3: addOutlineTriangle(p, xyz, opt->color.triangle, pre); break;
-  case 4: addOutlineQuadrangle(p, xyz, opt->color.quadrangle, pre); break;
-  case 6: addOutlineTetrahedron(p, xyz, opt->color.tetrahedron, pre); break;
-  case 12: addOutlineHexahedron(p, xyz, opt->color.hexahedron, pre); break;
-  case 9: addOutlinePrism(p, xyz, opt->color.prism, pre); break;
-  case 8: addOutlinePyramid(p, xyz, opt->color.pyramid, pre); break;
+  switch(type){
+  case TYPE_PNT: addOutlinePoint(p, xyz, opt->color.point, pre); break;
+  case TYPE_LIN: addOutlineLine(p, xyz, opt->color.line, pre); break;
+  case TYPE_TRI: addOutlineTriangle(p, xyz, opt->color.triangle, pre); break;
+  case TYPE_QUA: addOutlineQuadrangle(p, xyz, opt->color.quadrangle, pre); break;
+  case TYPE_TET: addOutlineTetrahedron(p, xyz, opt->color.tetrahedron, pre); break;
+  case TYPE_HEX: addOutlineHexahedron(p, xyz, opt->color.hexahedron, pre); break;
+  case TYPE_PRI: addOutlinePrism(p, xyz, opt->color.prism, pre); break;
+  case TYPE_PYR: addOutlinePyramid(p, xyz, opt->color.pyramid, pre); break;
   }
 }
 
-static void addScalarElement(PView *p, int numEdges, double xyz[NMAX][3],
+static void addScalarElement(PView *p, int type, double xyz[NMAX][3],
 			     double val[NMAX][9], bool pre)
 {
-  switch(numEdges){
-  case 0: addScalarPoint(p, xyz, val, pre); break;
-  case 1: addScalarLine(p, xyz, val, pre); break;
-  case 3: addScalarTriangle(p, xyz, val, pre); break;
-  case 4: addScalarQuadrangle(p, xyz, val, pre); break;
-  case 6: addScalarTetrahedron(p, xyz, val, pre); break;
-  case 12: addScalarHexahedron(p, xyz, val, pre); break;
-  case 9: addScalarPrism(p, xyz, val, pre); break;
-  case 8: addScalarPyramid(p, xyz, val, pre); break;
+  switch(type){
+  case TYPE_PNT: addScalarPoint(p, xyz, val, pre); break;
+  case TYPE_LIN: addScalarLine(p, xyz, val, pre); break;
+  case TYPE_TRI: addScalarTriangle(p, xyz, val, pre); break;
+  case TYPE_QUA: addScalarQuadrangle(p, xyz, val, pre); break;
+  case TYPE_TET: addScalarTetrahedron(p, xyz, val, pre); break;
+  case TYPE_HEX: addScalarHexahedron(p, xyz, val, pre); break;
+  case TYPE_PRI: addScalarPrism(p, xyz, val, pre); break;
+  case TYPE_PYR: addScalarPyramid(p, xyz, val, pre); break;
   }
 }
 
 static void addVectorElement(PView *p, int ient, int iele, int numNodes, 
-			     int numEdges, double xyz[NMAX][3], double val[NMAX][9], 
+			     int type, double xyz[NMAX][3], double val[NMAX][9], 
 			     bool pre)
 {
   // use adaptive data if available
@@ -832,7 +833,7 @@ static void addVectorElement(PView *p, int ient, int iele, int numNodes,
     double min = opt->tmpMin, max = opt->tmpMax;
     opt->tmpMin = opt->externalMin;
     opt->tmpMax = opt->externalMax;
-    addScalarElement(p, numEdges, xyz, val2, pre);
+    addScalarElement(p, type, xyz, val2, pre);
     opt->tmpMin = min;
     opt->tmpMax = max;
 
@@ -918,7 +919,7 @@ static void addVectorElement(PView *p, int ient, int iele, int numNodes,
   }
 }
 
-static void addTensorElement(PView *p, int numNodes, int numEdges,
+static void addTensorElement(PView *p, int numNodes, int type,
 			     double xyz[NMAX][3], double val[NMAX][9], bool pre)
 {
   PViewOptions *opt = p->getOptions();
@@ -926,7 +927,7 @@ static void addTensorElement(PView *p, int numNodes, int numEdges,
   if(opt->tensorType == PViewOptions::VonMises){
     for(int i = 0; i < numNodes; i++)
       val[i][0] = ComputeVonMises(val[i]);
-    addScalarElement(p, numEdges, xyz, val, pre);
+    addScalarElement(p, type, xyz, val, pre);
   }
 }
 
@@ -943,8 +944,8 @@ static void addElementsInArrays(PView *p, bool preprocessNormalsOnly)
     if(data->skipEntity(opt->timeStep, ent)) continue;
     for(int i = 0; i < data->getNumElements(opt->timeStep, ent); i++){
       if(data->skipElement(opt->timeStep, ent, i, true)) continue;
-      int numEdges = data->getNumEdges(opt->timeStep, ent, i);
-      if(opt->skipElement(numEdges)) continue;
+      int type = data->getType(opt->timeStep, ent, i);
+      if(opt->skipElement(type)) continue;
       int numComp = data->getNumComponents(opt->timeStep, ent, i);
       int numNodes = data->getNumNodes(opt->timeStep, ent, i);
       if(numNodes > 20){
@@ -960,7 +961,7 @@ static void addElementsInArrays(PView *p, bool preprocessNormalsOnly)
         for(int k = 0; k < numComp; k++)
           data->getValue(opt->timeStep, ent, i, j, k, val[j][k]);
       }
-      changeCoordinates(p, ent, i, numNodes, numEdges, numComp, xyz, val);
+      changeCoordinates(p, ent, i, numNodes, type, numComp, xyz, val);
       int dim = data->getDimension(opt->timeStep, ent, i);
       if(!isElementVisible(opt, dim, numNodes, xyz)) continue;
 
@@ -968,7 +969,7 @@ static void addElementsInArrays(PView *p, bool preprocessNormalsOnly)
         opt->tmpBBox += SPoint3(xyz[j][0], xyz[j][1], xyz[j][2]);
       
       if(opt->showElement && !data->useGaussPoints()) 
-        addOutlineElement(p, numEdges, xyz, preprocessNormalsOnly);
+        addOutlineElement(p, type, xyz, preprocessNormalsOnly);
       
       if(opt->intervalsType != PViewOptions::Numeric){
 	if(data->useGaussPoints()){
@@ -980,19 +981,19 @@ static void addElementsInArrays(PView *p, bool preprocessNormalsOnly)
 	    for(int k = 0; k < numComp; k++)
 	      val2[0][k] = val[j][k];
 	    if(numComp == 1 && opt->drawScalars)
-	      addScalarElement(p, 0, xyz2, val2, preprocessNormalsOnly);
+	      addScalarElement(p, TYPE_PNT, xyz2, val2, preprocessNormalsOnly);
 	    else if(numComp == 3 && opt->drawVectors)
-	      addVectorElement(p, ent, i, 1, 0, xyz2, val2, preprocessNormalsOnly);
+	      addVectorElement(p, ent, i, 1, TYPE_PNT, xyz2, val2, preprocessNormalsOnly);
 	    else if(numComp == 9 && opt->drawTensors)
-	      addTensorElement(p, 1, 0, xyz2, val2, preprocessNormalsOnly);
+	      addTensorElement(p, 1, TYPE_PNT, xyz2, val2, preprocessNormalsOnly);
 	  }
 	}
         else if(numComp == 1 && opt->drawScalars)
-          addScalarElement(p, numEdges, xyz, val, preprocessNormalsOnly);
+          addScalarElement(p, type, xyz, val, preprocessNormalsOnly);
         else if(numComp == 3 && opt->drawVectors)
-          addVectorElement(p, ent, i, numNodes, numEdges, xyz, val, preprocessNormalsOnly);
+          addVectorElement(p, ent, i, numNodes, type, xyz, val, preprocessNormalsOnly);
         else if(numComp == 9 && opt->drawTensors)
-          addTensorElement(p, numNodes, numEdges, xyz, val, preprocessNormalsOnly);
+          addTensorElement(p, numNodes, type, xyz, val, preprocessNormalsOnly);
       }
     }
   }
@@ -1225,8 +1226,8 @@ static void drawGlyphs(drawContext *ctx, PView *p)
     if(data->skipEntity(opt->timeStep, ent)) continue;
     for(int i = 0; i < data->getNumElements(opt->timeStep, ent); i++){
       if(data->skipElement(opt->timeStep, ent, i, true)) continue;
-      int numEdges = data->getNumEdges(opt->timeStep, ent, i);
-      if(opt->skipElement(numEdges)) continue;
+      int type = data->getType(opt->timeStep, ent, i);
+      if(opt->skipElement(type)) continue;
       int dim = data->getDimension(opt->timeStep, ent, i);
       int numComp = data->getNumComponents(opt->timeStep, ent, i);
       int numNodes = data->getNumNodes(opt->timeStep, ent, i);
@@ -1235,7 +1236,7 @@ static void drawGlyphs(drawContext *ctx, PView *p)
         for(int k = 0; k < numComp; k++)
           data->getValue(opt->timeStep, ent, i, j, k, val[j][k]);
       }
-      changeCoordinates(p, ent, i, numNodes, numEdges, numComp, xyz, val);
+      changeCoordinates(p, ent, i, numNodes, type, numComp, xyz, val);
       if(opt->intervalsType == PViewOptions::Numeric)
         drawNumberGlyphs(ctx, p, numNodes, numComp, xyz, val);
       if(dim == 2 && opt->normals)
diff --git a/Parser/Gmsh.tab.cpp b/Parser/Gmsh.tab.cpp
index 80a739352d4d4538aa910342c2585322af90ac78..c07b3381be93c2cb0e916940af1f44049196761d 100644
--- a/Parser/Gmsh.tab.cpp
+++ b/Parser/Gmsh.tab.cpp
@@ -3945,87 +3945,87 @@ yyreduce:
       }
       else if(!strncmp((yyvsp[(1) - (1)].c), "SL", 2)){
 	ViewValueList = &ViewData->SL; ViewNumList = &ViewData->NbSL;
-        if(strlen((yyvsp[(1) - (1)].c)) > 2) ViewData->setOrder2(1);
+        if(strlen((yyvsp[(1) - (1)].c)) > 2) ViewData->setOrder2(TYPE_LIN);
       }
       else if(!strncmp((yyvsp[(1) - (1)].c), "VL", 2)){
 	ViewValueList = &ViewData->VL; ViewNumList = &ViewData->NbVL;
-        if(strlen((yyvsp[(1) - (1)].c)) > 2) ViewData->setOrder2(1);
+        if(strlen((yyvsp[(1) - (1)].c)) > 2) ViewData->setOrder2(TYPE_LIN);
       }
       else if(!strncmp((yyvsp[(1) - (1)].c), "TL", 2)){
 	ViewValueList = &ViewData->TL; ViewNumList = &ViewData->NbTL;
-        if(strlen((yyvsp[(1) - (1)].c)) > 2) ViewData->setOrder2(1);
+        if(strlen((yyvsp[(1) - (1)].c)) > 2) ViewData->setOrder2(TYPE_LIN);
       }
       else if(!strncmp((yyvsp[(1) - (1)].c), "ST", 2)){
 	ViewValueList = &ViewData->ST; ViewNumList = &ViewData->NbST;
-        if(strlen((yyvsp[(1) - (1)].c)) > 2) ViewData->setOrder2(3);
+        if(strlen((yyvsp[(1) - (1)].c)) > 2) ViewData->setOrder2(TYPE_TRI);
       }
       else if(!strncmp((yyvsp[(1) - (1)].c), "VT", 2)){
 	ViewValueList = &ViewData->VT; ViewNumList = &ViewData->NbVT;
-        if(strlen((yyvsp[(1) - (1)].c)) > 2) ViewData->setOrder2(3);
+        if(strlen((yyvsp[(1) - (1)].c)) > 2) ViewData->setOrder2(TYPE_TRI);
       }
       else if(!strncmp((yyvsp[(1) - (1)].c), "TT", 2)){
 	ViewValueList = &ViewData->TT; ViewNumList = &ViewData->NbTT;
-        if(strlen((yyvsp[(1) - (1)].c)) > 2) ViewData->setOrder2(3);
+        if(strlen((yyvsp[(1) - (1)].c)) > 2) ViewData->setOrder2(TYPE_TRI);
       }
       else if(!strncmp((yyvsp[(1) - (1)].c), "SQ", 2)){
 	ViewValueList = &ViewData->SQ; ViewNumList = &ViewData->NbSQ;
-        if(strlen((yyvsp[(1) - (1)].c)) > 2) ViewData->setOrder2(4);
+        if(strlen((yyvsp[(1) - (1)].c)) > 2) ViewData->setOrder2(TYPE_QUA);
       }
       else if(!strncmp((yyvsp[(1) - (1)].c), "VQ", 2)){
 	ViewValueList = &ViewData->VQ; ViewNumList = &ViewData->NbVQ;
-        if(strlen((yyvsp[(1) - (1)].c)) > 2) ViewData->setOrder2(4);
+        if(strlen((yyvsp[(1) - (1)].c)) > 2) ViewData->setOrder2(TYPE_QUA);
       }
       else if(!strncmp((yyvsp[(1) - (1)].c), "TQ", 2)){
 	ViewValueList = &ViewData->TQ; ViewNumList = &ViewData->NbTQ;
-        if(strlen((yyvsp[(1) - (1)].c)) > 2) ViewData->setOrder2(4);
+        if(strlen((yyvsp[(1) - (1)].c)) > 2) ViewData->setOrder2(TYPE_QUA);
       }
       else if(!strncmp((yyvsp[(1) - (1)].c), "SS", 2)){
 	ViewValueList = &ViewData->SS; ViewNumList = &ViewData->NbSS;
-        if(strlen((yyvsp[(1) - (1)].c)) > 2) ViewData->setOrder2(6);
+        if(strlen((yyvsp[(1) - (1)].c)) > 2) ViewData->setOrder2(TYPE_TET);
       }
       else if(!strncmp((yyvsp[(1) - (1)].c), "VS", 2)){
 	ViewValueList = &ViewData->VS; ViewNumList = &ViewData->NbVS;
-        if(strlen((yyvsp[(1) - (1)].c)) > 2) ViewData->setOrder2(6);
+        if(strlen((yyvsp[(1) - (1)].c)) > 2) ViewData->setOrder2(TYPE_TET);
       }
       else if(!strncmp((yyvsp[(1) - (1)].c), "TS", 2)){
 	ViewValueList = &ViewData->TS; ViewNumList = &ViewData->NbTS;
-        if(strlen((yyvsp[(1) - (1)].c)) > 2) ViewData->setOrder2(6);
+        if(strlen((yyvsp[(1) - (1)].c)) > 2) ViewData->setOrder2(TYPE_TET);
       }
       else if(!strncmp((yyvsp[(1) - (1)].c), "SH", 2)){
 	ViewValueList = &ViewData->SH; ViewNumList = &ViewData->NbSH;
-        if(strlen((yyvsp[(1) - (1)].c)) > 2) ViewData->setOrder2(12);
+        if(strlen((yyvsp[(1) - (1)].c)) > 2) ViewData->setOrder2(TYPE_HEX);
       }
       else if(!strncmp((yyvsp[(1) - (1)].c), "VH", 2)){
 	ViewValueList = &ViewData->VH; ViewNumList = &ViewData->NbVH;
-        if(strlen((yyvsp[(1) - (1)].c)) > 2) ViewData->setOrder2(12);
+        if(strlen((yyvsp[(1) - (1)].c)) > 2) ViewData->setOrder2(TYPE_HEX);
       }
       else if(!strncmp((yyvsp[(1) - (1)].c), "TH", 2)){
 	ViewValueList = &ViewData->TH; ViewNumList = &ViewData->NbTH;
-        if(strlen((yyvsp[(1) - (1)].c)) > 2) ViewData->setOrder2(12);
+        if(strlen((yyvsp[(1) - (1)].c)) > 2) ViewData->setOrder2(TYPE_HEX);
       }
       else if(!strncmp((yyvsp[(1) - (1)].c), "SI", 2)){
 	ViewValueList = &ViewData->SI; ViewNumList = &ViewData->NbSI;
-        if(strlen((yyvsp[(1) - (1)].c)) > 2) ViewData->setOrder2(9);
+        if(strlen((yyvsp[(1) - (1)].c)) > 2) ViewData->setOrder2(TYPE_PRI);
       }
       else if(!strncmp((yyvsp[(1) - (1)].c), "VI", 2)){
 	ViewValueList = &ViewData->VI; ViewNumList = &ViewData->NbVI;
-        if(strlen((yyvsp[(1) - (1)].c)) > 2) ViewData->setOrder2(9);
+        if(strlen((yyvsp[(1) - (1)].c)) > 2) ViewData->setOrder2(TYPE_PRI);
       }
       else if(!strncmp((yyvsp[(1) - (1)].c), "TI", 2)){
 	ViewValueList = &ViewData->TI; ViewNumList = &ViewData->NbTI;
-        if(strlen((yyvsp[(1) - (1)].c)) > 2) ViewData->setOrder2(9);
+        if(strlen((yyvsp[(1) - (1)].c)) > 2) ViewData->setOrder2(TYPE_PRI);
       }
       else if(!strncmp((yyvsp[(1) - (1)].c), "SY", 2)){
 	ViewValueList = &ViewData->SY; ViewNumList = &ViewData->NbSY;
-        if(strlen((yyvsp[(1) - (1)].c)) > 2) ViewData->setOrder2(8);
+        if(strlen((yyvsp[(1) - (1)].c)) > 2) ViewData->setOrder2(TYPE_PYR);
       }
       else if(!strncmp((yyvsp[(1) - (1)].c), "VY", 2)){
 	ViewValueList = &ViewData->VY; ViewNumList = &ViewData->NbVY;
-        if(strlen((yyvsp[(1) - (1)].c)) > 2) ViewData->setOrder2(8);
+        if(strlen((yyvsp[(1) - (1)].c)) > 2) ViewData->setOrder2(TYPE_PYR);
       }
       else if(!strncmp((yyvsp[(1) - (1)].c), "TY", 2)){
 	ViewValueList = &ViewData->TY; ViewNumList = &ViewData->NbTY;
-        if(strlen((yyvsp[(1) - (1)].c)) > 2) ViewData->setOrder2(8);
+        if(strlen((yyvsp[(1) - (1)].c)) > 2) ViewData->setOrder2(TYPE_PYR);
       }
       else{
 	yymsg(0, "Unknown element type '%s'", (yyvsp[(1) - (1)].c));	
@@ -4145,12 +4145,13 @@ yyreduce:
     {
 #if !defined(HAVE_NO_POST)
       int type = 
-	(ViewData->NbSL || ViewData->NbVL) ? 1 : 
-	(ViewData->NbST || ViewData->NbVT) ? 3 : 
-	(ViewData->NbSQ || ViewData->NbVQ) ? 4 : 
-	(ViewData->NbSS || ViewData->NbVS) ? 6 : 
-	(ViewData->NbSI || ViewData->NbVI) ? 9 : 
-      	(ViewData->NbSH || ViewData->NbVH) ? 12 : 
+	(ViewData->NbSL || ViewData->NbVL) ? TYPE_LIN : 
+	(ViewData->NbST || ViewData->NbVT) ? TYPE_TRI : 
+	(ViewData->NbSQ || ViewData->NbVQ) ? TYPE_QUA : 
+	(ViewData->NbSS || ViewData->NbVS) ? TYPE_TET : 
+	(ViewData->NbSY || ViewData->NbVY) ? TYPE_PYR : 
+	(ViewData->NbSI || ViewData->NbVI) ? TYPE_PRI : 
+      	(ViewData->NbSH || ViewData->NbVH) ? TYPE_HEX : 
 	0;
       ViewData->setInterpolationMatrices(type, ListOfListOfDouble2Matrix((yyvsp[(3) - (8)].l)), 
                                          ListOfListOfDouble2Matrix((yyvsp[(6) - (8)].l)));
@@ -4163,11 +4164,11 @@ yyreduce:
     {
 #if !defined(HAVE_NO_POST)
       int type = 
-	(ViewData->NbSL || ViewData->NbVL) ? 1 : 
-	(ViewData->NbST || ViewData->NbVT) ? 3 : 
-	(ViewData->NbSQ || ViewData->NbVQ) ? 4 : 
-	(ViewData->NbSS || ViewData->NbVS) ? 6 : 
-      	(ViewData->NbSH || ViewData->NbVH) ? 12 : 
+	(ViewData->NbSL || ViewData->NbVL) ? TYPE_LIN : 
+	(ViewData->NbST || ViewData->NbVT) ? TYPE_TRI : 
+	(ViewData->NbSQ || ViewData->NbVQ) ? TYPE_QUA : 
+	(ViewData->NbSS || ViewData->NbVS) ? TYPE_TET : 
+      	(ViewData->NbSH || ViewData->NbVH) ? TYPE_HEX : 
 	0;
       ViewData->setInterpolationMatrices(type, ListOfListOfDouble2Matrix((yyvsp[(3) - (14)].l)), 
                                          ListOfListOfDouble2Matrix((yyvsp[(6) - (14)].l)),
diff --git a/Parser/Gmsh.y b/Parser/Gmsh.y
index 31a8617e4711b9d71708f1395f6ce6685db3c5f7..32ab51d26cc41b75c59c0e9393858b7588ca294e 100644
--- a/Parser/Gmsh.y
+++ b/Parser/Gmsh.y
@@ -321,87 +321,87 @@ Element :
       }
       else if(!strncmp($1, "SL", 2)){
 	ViewValueList = &ViewData->SL; ViewNumList = &ViewData->NbSL;
-        if(strlen($1) > 2) ViewData->setOrder2(1);
+        if(strlen($1) > 2) ViewData->setOrder2(TYPE_LIN);
       }
       else if(!strncmp($1, "VL", 2)){
 	ViewValueList = &ViewData->VL; ViewNumList = &ViewData->NbVL;
-        if(strlen($1) > 2) ViewData->setOrder2(1);
+        if(strlen($1) > 2) ViewData->setOrder2(TYPE_LIN);
       }
       else if(!strncmp($1, "TL", 2)){
 	ViewValueList = &ViewData->TL; ViewNumList = &ViewData->NbTL;
-        if(strlen($1) > 2) ViewData->setOrder2(1);
+        if(strlen($1) > 2) ViewData->setOrder2(TYPE_LIN);
       }
       else if(!strncmp($1, "ST", 2)){
 	ViewValueList = &ViewData->ST; ViewNumList = &ViewData->NbST;
-        if(strlen($1) > 2) ViewData->setOrder2(3);
+        if(strlen($1) > 2) ViewData->setOrder2(TYPE_TRI);
       }
       else if(!strncmp($1, "VT", 2)){
 	ViewValueList = &ViewData->VT; ViewNumList = &ViewData->NbVT;
-        if(strlen($1) > 2) ViewData->setOrder2(3);
+        if(strlen($1) > 2) ViewData->setOrder2(TYPE_TRI);
       }
       else if(!strncmp($1, "TT", 2)){
 	ViewValueList = &ViewData->TT; ViewNumList = &ViewData->NbTT;
-        if(strlen($1) > 2) ViewData->setOrder2(3);
+        if(strlen($1) > 2) ViewData->setOrder2(TYPE_TRI);
       }
       else if(!strncmp($1, "SQ", 2)){
 	ViewValueList = &ViewData->SQ; ViewNumList = &ViewData->NbSQ;
-        if(strlen($1) > 2) ViewData->setOrder2(4);
+        if(strlen($1) > 2) ViewData->setOrder2(TYPE_QUA);
       }
       else if(!strncmp($1, "VQ", 2)){
 	ViewValueList = &ViewData->VQ; ViewNumList = &ViewData->NbVQ;
-        if(strlen($1) > 2) ViewData->setOrder2(4);
+        if(strlen($1) > 2) ViewData->setOrder2(TYPE_QUA);
       }
       else if(!strncmp($1, "TQ", 2)){
 	ViewValueList = &ViewData->TQ; ViewNumList = &ViewData->NbTQ;
-        if(strlen($1) > 2) ViewData->setOrder2(4);
+        if(strlen($1) > 2) ViewData->setOrder2(TYPE_QUA);
       }
       else if(!strncmp($1, "SS", 2)){
 	ViewValueList = &ViewData->SS; ViewNumList = &ViewData->NbSS;
-        if(strlen($1) > 2) ViewData->setOrder2(6);
+        if(strlen($1) > 2) ViewData->setOrder2(TYPE_TET);
       }
       else if(!strncmp($1, "VS", 2)){
 	ViewValueList = &ViewData->VS; ViewNumList = &ViewData->NbVS;
-        if(strlen($1) > 2) ViewData->setOrder2(6);
+        if(strlen($1) > 2) ViewData->setOrder2(TYPE_TET);
       }
       else if(!strncmp($1, "TS", 2)){
 	ViewValueList = &ViewData->TS; ViewNumList = &ViewData->NbTS;
-        if(strlen($1) > 2) ViewData->setOrder2(6);
+        if(strlen($1) > 2) ViewData->setOrder2(TYPE_TET);
       }
       else if(!strncmp($1, "SH", 2)){
 	ViewValueList = &ViewData->SH; ViewNumList = &ViewData->NbSH;
-        if(strlen($1) > 2) ViewData->setOrder2(12);
+        if(strlen($1) > 2) ViewData->setOrder2(TYPE_HEX);
       }
       else if(!strncmp($1, "VH", 2)){
 	ViewValueList = &ViewData->VH; ViewNumList = &ViewData->NbVH;
-        if(strlen($1) > 2) ViewData->setOrder2(12);
+        if(strlen($1) > 2) ViewData->setOrder2(TYPE_HEX);
       }
       else if(!strncmp($1, "TH", 2)){
 	ViewValueList = &ViewData->TH; ViewNumList = &ViewData->NbTH;
-        if(strlen($1) > 2) ViewData->setOrder2(12);
+        if(strlen($1) > 2) ViewData->setOrder2(TYPE_HEX);
       }
       else if(!strncmp($1, "SI", 2)){
 	ViewValueList = &ViewData->SI; ViewNumList = &ViewData->NbSI;
-        if(strlen($1) > 2) ViewData->setOrder2(9);
+        if(strlen($1) > 2) ViewData->setOrder2(TYPE_PRI);
       }
       else if(!strncmp($1, "VI", 2)){
 	ViewValueList = &ViewData->VI; ViewNumList = &ViewData->NbVI;
-        if(strlen($1) > 2) ViewData->setOrder2(9);
+        if(strlen($1) > 2) ViewData->setOrder2(TYPE_PRI);
       }
       else if(!strncmp($1, "TI", 2)){
 	ViewValueList = &ViewData->TI; ViewNumList = &ViewData->NbTI;
-        if(strlen($1) > 2) ViewData->setOrder2(9);
+        if(strlen($1) > 2) ViewData->setOrder2(TYPE_PRI);
       }
       else if(!strncmp($1, "SY", 2)){
 	ViewValueList = &ViewData->SY; ViewNumList = &ViewData->NbSY;
-        if(strlen($1) > 2) ViewData->setOrder2(8);
+        if(strlen($1) > 2) ViewData->setOrder2(TYPE_PYR);
       }
       else if(!strncmp($1, "VY", 2)){
 	ViewValueList = &ViewData->VY; ViewNumList = &ViewData->NbVY;
-        if(strlen($1) > 2) ViewData->setOrder2(8);
+        if(strlen($1) > 2) ViewData->setOrder2(TYPE_PYR);
       }
       else if(!strncmp($1, "TY", 2)){
 	ViewValueList = &ViewData->TY; ViewNumList = &ViewData->NbTY;
-        if(strlen($1) > 2) ViewData->setOrder2(8);
+        if(strlen($1) > 2) ViewData->setOrder2(TYPE_PYR);
       }
       else{
 	yymsg(0, "Unknown element type '%s'", $1);	
@@ -504,12 +504,13 @@ InterpolationMatrix :
     {
 #if !defined(HAVE_NO_POST)
       int type = 
-	(ViewData->NbSL || ViewData->NbVL) ? 1 : 
-	(ViewData->NbST || ViewData->NbVT) ? 3 : 
-	(ViewData->NbSQ || ViewData->NbVQ) ? 4 : 
-	(ViewData->NbSS || ViewData->NbVS) ? 6 : 
-	(ViewData->NbSI || ViewData->NbVI) ? 9 : 
-      	(ViewData->NbSH || ViewData->NbVH) ? 12 : 
+	(ViewData->NbSL || ViewData->NbVL) ? TYPE_LIN : 
+	(ViewData->NbST || ViewData->NbVT) ? TYPE_TRI : 
+	(ViewData->NbSQ || ViewData->NbVQ) ? TYPE_QUA : 
+	(ViewData->NbSS || ViewData->NbVS) ? TYPE_TET : 
+	(ViewData->NbSY || ViewData->NbVY) ? TYPE_PYR : 
+	(ViewData->NbSI || ViewData->NbVI) ? TYPE_PRI : 
+      	(ViewData->NbSH || ViewData->NbVH) ? TYPE_HEX : 
 	0;
       ViewData->setInterpolationMatrices(type, ListOfListOfDouble2Matrix($3), 
                                          ListOfListOfDouble2Matrix($6));
@@ -522,11 +523,11 @@ InterpolationMatrix :
     {
 #if !defined(HAVE_NO_POST)
       int type = 
-	(ViewData->NbSL || ViewData->NbVL) ? 1 : 
-	(ViewData->NbST || ViewData->NbVT) ? 3 : 
-	(ViewData->NbSQ || ViewData->NbVQ) ? 4 : 
-	(ViewData->NbSS || ViewData->NbVS) ? 6 : 
-      	(ViewData->NbSH || ViewData->NbVH) ? 12 : 
+	(ViewData->NbSL || ViewData->NbVL) ? TYPE_LIN : 
+	(ViewData->NbST || ViewData->NbVT) ? TYPE_TRI : 
+	(ViewData->NbSQ || ViewData->NbVQ) ? TYPE_QUA : 
+	(ViewData->NbSS || ViewData->NbVS) ? TYPE_TET : 
+      	(ViewData->NbSH || ViewData->NbVH) ? TYPE_HEX : 
 	0;
       ViewData->setInterpolationMatrices(type, ListOfListOfDouble2Matrix($3), 
                                          ListOfListOfDouble2Matrix($6),
diff --git a/Plugin/Curl.cpp b/Plugin/Curl.cpp
index 61c999723aa776add7966b09ef654767231eb9ee..4407c40d4f276e355afeb0a0330fe7fbd677a100 100644
--- a/Plugin/Curl.cpp
+++ b/Plugin/Curl.cpp
@@ -5,6 +5,7 @@
 
 #include "Curl.h"
 #include "shapeFunctions.h"
+#include "GmshDefines.h"
 
 StringXNumber CurlOptions_Number[] = {
   {GMSH_FULLRC, "iView", NULL, -1.}
@@ -51,17 +52,17 @@ void GMSH_CurlPlugin::catchErrorMessage(char *errorMessage) const
   strcpy(errorMessage, "Curl failed...");
 }
 
-static std::vector<double> *incrementList(PViewDataList *data2, int numEdges)
+static std::vector<double> *incrementList(PViewDataList *data2, int type)
 {
-  switch(numEdges){
-  case 0: data2->NbVP++; return &data2->VP;
-  case 1: data2->NbVL++; return &data2->VL;
-  case 3: data2->NbVT++; return &data2->VT;
-  case 4: data2->NbVQ++; return &data2->VQ;
-  case 6: data2->NbVS++; return &data2->VS;
-  case 12: data2->NbVH++; return &data2->VH;
-  case 9: data2->NbVI++; return &data2->VI;
-  case 8: data2->NbVY++; return &data2->VY;
+  switch(type){
+  case TYPE_PNT: data2->NbVP++; return &data2->VP;
+  case TYPE_LIN: data2->NbVL++; return &data2->VL;
+  case TYPE_TRI: data2->NbVT++; return &data2->VT;
+  case TYPE_QUA: data2->NbVQ++; return &data2->VQ;
+  case TYPE_TET: data2->NbVS++; return &data2->VS;
+  case TYPE_HEX: data2->NbVH++; return &data2->VH;
+  case TYPE_PRI: data2->NbVI++; return &data2->VI;
+  case TYPE_PYR: data2->NbVY++; return &data2->VY;
   default: return 0;
   }
 }
@@ -87,8 +88,8 @@ PView *GMSH_CurlPlugin::execute(PView *v)
       if(data1->skipElement(0, ent, ele)) continue;
       int numComp = data1->getNumComponents(0, ent, ele);
       if(numComp != 3) continue;
-      int numEdges = data1->getNumEdges(0, ent, ele);
-      std::vector<double> *out = incrementList(data2, numEdges);
+      int type = data1->getType(0, ent, ele);
+      std::vector<double> *out = incrementList(data2, type);
       if(!out) continue;
       int numNodes = data1->getNumNodes(0, ent, ele);
       double x[8], y[8], z[8], val[8 * 3];
diff --git a/Plugin/Divergence.cpp b/Plugin/Divergence.cpp
index ad2befd7f19eb1282fa7def123881a67517428f1..b81434f14a00835a6cef2bbc1d867c0d191062f4 100644
--- a/Plugin/Divergence.cpp
+++ b/Plugin/Divergence.cpp
@@ -5,6 +5,7 @@
 
 #include "Divergence.h"
 #include "shapeFunctions.h"
+#include "GmshDefines.h"
 
 StringXNumber DivergenceOptions_Number[] = {
   {GMSH_FULLRC, "iView", NULL, -1.}
@@ -51,17 +52,17 @@ void GMSH_DivergencePlugin::catchErrorMessage(char *errorMessage) const
   strcpy(errorMessage, "Divergence failed...");
 }
 
-static std::vector<double> *incrementList(PViewDataList *data2, int numEdges)
+static std::vector<double> *incrementList(PViewDataList *data2, int type)
 {
-  switch(numEdges){
-  case 0: data2->NbSP++; return &data2->SP;
-  case 1: data2->NbSL++; return &data2->SL;
-  case 3: data2->NbST++; return &data2->ST;
-  case 4: data2->NbSQ++; return &data2->SQ;
-  case 6: data2->NbSS++; return &data2->SS;
-  case 12: data2->NbSH++; return &data2->SH;
-  case 9: data2->NbSI++; return &data2->SI;
-  case 8: data2->NbSY++; return &data2->SY;
+  switch(type){
+  case TYPE_PNT: data2->NbSP++; return &data2->SP;
+  case TYPE_LIN: data2->NbSL++; return &data2->SL;
+  case TYPE_TRI: data2->NbST++; return &data2->ST;
+  case TYPE_QUA: data2->NbSQ++; return &data2->SQ;
+  case TYPE_TET: data2->NbSS++; return &data2->SS;
+  case TYPE_HEX: data2->NbSH++; return &data2->SH;
+  case TYPE_PRI: data2->NbSI++; return &data2->SI;
+  case TYPE_PYR: data2->NbSY++; return &data2->SY;
   default: return 0;
   }
 }
@@ -87,8 +88,8 @@ PView *GMSH_DivergencePlugin::execute(PView *v)
       if(data1->skipElement(0, ent, ele)) continue;
       int numComp = data1->getNumComponents(0, ent, ele);
       if(numComp != 3) continue;
-      int numEdges = data1->getNumEdges(0, ent, ele);
-      std::vector<double> *out = incrementList(data2, numEdges);
+      int type = data1->getType(0, ent, ele);
+      std::vector<double> *out = incrementList(data2, type);
       if(!out) continue;
       int numNodes = data1->getNumNodes(0, ent, ele);
       double x[8], y[8], z[8], val[8 * 3];
diff --git a/Plugin/Eigenvalues.cpp b/Plugin/Eigenvalues.cpp
index 94c25bd7acfca681173f4de1d4bd340b20a93905..bc285d89f69419e93b53baaaa9f124f2b81d3e7c 100644
--- a/Plugin/Eigenvalues.cpp
+++ b/Plugin/Eigenvalues.cpp
@@ -5,6 +5,7 @@
 
 #include "Eigenvalues.h"
 #include "Numeric.h"
+#include "GmshDefines.h"
 
 StringXNumber EigenvaluesOptions_Number[] = {
   {GMSH_FULLRC, "iView", NULL, -1.}
@@ -50,17 +51,17 @@ void GMSH_EigenvaluesPlugin::catchErrorMessage(char *errorMessage) const
   strcpy(errorMessage, "Eigenvalues failed...");
 }
 
-static std::vector<double> *incrementList(PViewDataList *data2, int numEdges)
+static std::vector<double> *incrementList(PViewDataList *data2, int type)
 {
-  switch(numEdges){
-  case 0: data2->NbSP++; return &data2->SP;
-  case 1: data2->NbSL++; return &data2->SL;
-  case 3: data2->NbST++; return &data2->ST;
-  case 4: data2->NbSQ++; return &data2->SQ;
-  case 6: data2->NbSS++; return &data2->SS;
-  case 12: data2->NbSH++; return &data2->SH;
-  case 9: data2->NbSI++; return &data2->SI;
-  case 8: data2->NbSY++; return &data2->SY;
+  switch(type){
+  case TYPE_PNT: data2->NbSP++; return &data2->SP;
+  case TYPE_LIN: data2->NbSL++; return &data2->SL;
+  case TYPE_TRI: data2->NbST++; return &data2->ST;
+  case TYPE_QUA: data2->NbSQ++; return &data2->SQ;
+  case TYPE_TET: data2->NbSS++; return &data2->SS;
+  case TYPE_HEX: data2->NbSH++; return &data2->SH;
+  case TYPE_PRI: data2->NbSI++; return &data2->SI;
+  case TYPE_PYR: data2->NbSY++; return &data2->SY;
   default: return 0;
   }
 }
@@ -91,10 +92,10 @@ PView *GMSH_EigenvaluesPlugin::execute(PView *v)
       if(data1->skipElement(0, ent, ele)) continue;
       int numComp = data1->getNumComponents(0, ent, ele);
       if(numComp != 9) continue;
-      int numEdges = data1->getNumEdges(0, ent, ele);
-      std::vector<double> *outmin = incrementList(dmin, numEdges);
-      std::vector<double> *outmid = incrementList(dmid, numEdges);
-      std::vector<double> *outmax = incrementList(dmax, numEdges);
+      int type = data1->getType(0, ent, ele);
+      std::vector<double> *outmin = incrementList(dmin, type);
+      std::vector<double> *outmid = incrementList(dmid, type);
+      std::vector<double> *outmax = incrementList(dmax, type);
       if(!outmin || !outmid || !outmax) continue;
       int numNodes = data1->getNumNodes(0, ent, ele);
       double xyz[3][8];
diff --git a/Plugin/Eigenvectors.cpp b/Plugin/Eigenvectors.cpp
index 11e5a9082f31697bf5ee0b06e5c04aafd4248f41..fa869e61a77314354394b9bd7c9dd07c6041e0ff 100644
--- a/Plugin/Eigenvectors.cpp
+++ b/Plugin/Eigenvectors.cpp
@@ -6,6 +6,7 @@
 #include "Eigenvectors.h"
 #include "Numeric.h"
 #include "EigSolve.h"
+#include "GmshDefines.h"
 
 StringXNumber EigenvectorsOptions_Number[] = {
   {GMSH_FULLRC, "ScaleByEigenvalues", NULL, 1.},
@@ -58,17 +59,17 @@ void GMSH_EigenvectorsPlugin::catchErrorMessage(char *errorMessage) const
   strcpy(errorMessage, "Eigenvectors failed...");
 }
 
-static std::vector<double> *incrementList(PViewDataList *data2, int numEdges)
+static std::vector<double> *incrementList(PViewDataList *data2, int type)
 {
-  switch(numEdges){
-  case 0: data2->NbVP++; return &data2->VP;
-  case 1: data2->NbVL++; return &data2->VL;
-  case 3: data2->NbVT++; return &data2->VT;
-  case 4: data2->NbVQ++; return &data2->VQ;
-  case 6: data2->NbVS++; return &data2->VS;
-  case 12: data2->NbVH++; return &data2->VH;
-  case 9: data2->NbVI++; return &data2->VI;
-  case 8: data2->NbVY++; return &data2->VY;
+  switch(type){
+  case TYPE_PNT: data2->NbVP++; return &data2->VP;
+  case TYPE_LIN: data2->NbVL++; return &data2->VL;
+  case TYPE_TRI: data2->NbVT++; return &data2->VT;
+  case TYPE_QUA: data2->NbVQ++; return &data2->VQ;
+  case TYPE_TET: data2->NbVS++; return &data2->VS;
+  case TYPE_HEX: data2->NbVH++; return &data2->VH;
+  case TYPE_PRI: data2->NbVI++; return &data2->VI;
+  case TYPE_PYR: data2->NbVY++; return &data2->VY;
   default: return 0;
   }
 }
@@ -109,10 +110,10 @@ PView *GMSH_EigenvectorsPlugin::execute(PView *v)
       if(data1->skipElement(0, ent, ele)) continue;
       int numComp = data1->getNumComponents(0, ent, ele);
       if(numComp != 9) continue;
-      int numEdges = data1->getNumEdges(0, ent, ele);
-      std::vector<double> *outmin = incrementList(dmin, numEdges);
-      std::vector<double> *outmid = incrementList(dmid, numEdges);
-      std::vector<double> *outmax = incrementList(dmax, numEdges);
+      int type = data1->getType(0, ent, ele);
+      std::vector<double> *outmin = incrementList(dmin, type);
+      std::vector<double> *outmid = incrementList(dmid, type);
+      std::vector<double> *outmax = incrementList(dmax, type);
       if(!outmin || !outmid || !outmax) continue;
       int numNodes = data1->getNumNodes(0, ent, ele);
       double xyz[3][8];
diff --git a/Plugin/Extract.cpp b/Plugin/Extract.cpp
index f0c9b05616b1d452d23d3407e8841f672933e622..99afe6518bef41545766d63807a300ed79396488 100644
--- a/Plugin/Extract.cpp
+++ b/Plugin/Extract.cpp
@@ -4,6 +4,7 @@
 // bugs and problems to <gmsh@geuz.org>.
 
 #include "GmshConfig.h"
+#include "GmshDefines.h"
 #include "Extract.h"
 
 #if defined(HAVE_MATH_EVAL)
@@ -98,45 +99,45 @@ void GMSH_ExtractPlugin::catchErrorMessage(char *errorMessage) const
 }
 
 static std::vector<double> *incrementList(PViewDataList *data, int numComp, 
-                                          int numEdges)
+                                          int type)
 {
-  switch(numEdges){
-  case 0:
+  switch(type){
+  case TYPE_PNT:
     if     (numComp == 1){ data->NbSP++; return &data->SP; }
     else if(numComp == 3){ data->NbVP++; return &data->VP; }
     else if(numComp == 9){ data->NbTP++; return &data->TP; }
     break;
-  case 1:
+  case TYPE_LIN:
     if     (numComp == 1){ data->NbSL++; return &data->SL; }
     else if(numComp == 3){ data->NbVL++; return &data->VL; }
     else if(numComp == 9){ data->NbTL++; return &data->TL; }
     break;
-  case 3: 
+  case TYPE_TRI:
     if     (numComp == 1){ data->NbST++; return &data->ST; }
     else if(numComp == 3){ data->NbVT++; return &data->VT; }
     else if(numComp == 9){ data->NbTT++; return &data->TT; }
     break;
-  case 4: 
+  case TYPE_QUA:
     if     (numComp == 1){ data->NbSQ++; return &data->SQ; }
     else if(numComp == 3){ data->NbVQ++; return &data->VQ; }
     else if(numComp == 9){ data->NbTQ++; return &data->TQ; }
     break;
-  case 6:
+  case TYPE_TET:
     if     (numComp == 1){ data->NbSS++; return &data->SS; }
     else if(numComp == 3){ data->NbVS++; return &data->VS; }
     else if(numComp == 9){ data->NbTS++; return &data->TS; }
     break;
-  case 12: 
+  case TYPE_HEX:
     if     (numComp == 1){ data->NbSH++; return &data->SH; }
     else if(numComp == 3){ data->NbVH++; return &data->VH; }
     else if(numComp == 9){ data->NbTH++; return &data->TH; }
     break;
-  case 9: 
+  case TYPE_PRI:
     if     (numComp == 1){ data->NbSI++; return &data->SI; }
     else if(numComp == 3){ data->NbVI++; return &data->VI; }
     else if(numComp == 9){ data->NbTI++; return &data->TI; }
     break;
-  case 8:
+  case TYPE_PYR:
     if     (numComp == 1){ data->NbSY++; return &data->SY; }
     else if(numComp == 3){ data->NbVY++; return &data->VY; }
     else if(numComp == 9){ data->NbTY++; return &data->TY; }
@@ -232,9 +233,9 @@ PView *GMSH_ExtractPlugin::execute(PView *v)
     for(int ele = 0; ele < data1->getNumElements(0, ent); ele++){
       if(data1->skipElement(0, ent, ele)) continue;
       int numNodes = data1->getNumNodes(0, ent, ele);
-      int numEdges = data1->getNumEdges(0, ent, ele);
+      int type = data1->getType(0, ent, ele);
       int numComp = data1->getNumComponents(0, ent, ele);
-      std::vector<double> *out = incrementList(data2, numComp2, numEdges);
+      std::vector<double> *out = incrementList(data2, numComp2, type);
       std::vector<double> x(numNodes), y(numNodes), z(numNodes);
       for(int nod = 0; nod < numNodes; nod++)
         data1->getNode(0, ent, ele, nod, x[nod], y[nod], z[nod]);
diff --git a/Plugin/Gradient.cpp b/Plugin/Gradient.cpp
index 0792a1a7f1f6eadcc81cfcb0423791ffd3f00bc9..ffc4b0dec9ef7921b29a5c5f28c69ca22cb5d6ab 100644
--- a/Plugin/Gradient.cpp
+++ b/Plugin/Gradient.cpp
@@ -5,6 +5,7 @@
 
 #include "Gradient.h"
 #include "shapeFunctions.h"
+#include "GmshDefines.h"
 
 StringXNumber GradientOptions_Number[] = {
   {GMSH_FULLRC, "iView", NULL, -1.}
@@ -51,31 +52,31 @@ void GMSH_GradientPlugin::catchErrorMessage(char *errorMessage) const
   strcpy(errorMessage, "Gradient failed...");
 }
 
-static std::vector<double> *incrementList(PViewDataList *data2, int numComp, int numEdges)
+static std::vector<double> *incrementList(PViewDataList *data2, int numComp, int type)
 {
   if(numComp == 1){
-    switch(numEdges){
-    case 0: data2->NbVP++; return &data2->VP;
-    case 1: data2->NbVL++; return &data2->VL;
-    case 3: data2->NbVT++; return &data2->VT;
-    case 4: data2->NbVQ++; return &data2->VQ;
-    case 6: data2->NbVS++; return &data2->VS;
-    case 12: data2->NbVH++; return &data2->VH;
-    case 9: data2->NbVI++; return &data2->VI;
-    case 8: data2->NbVY++; return &data2->VY;
+    switch(type){
+    case TYPE_PNT: data2->NbVP++; return &data2->VP;
+    case TYPE_LIN: data2->NbVL++; return &data2->VL;
+    case TYPE_TRI: data2->NbVT++; return &data2->VT;
+    case TYPE_QUA: data2->NbVQ++; return &data2->VQ;
+    case TYPE_TET: data2->NbVS++; return &data2->VS;
+    case TYPE_HEX: data2->NbVH++; return &data2->VH;
+    case TYPE_PRI: data2->NbVI++; return &data2->VI;
+    case TYPE_PYR: data2->NbVY++; return &data2->VY;
     default: return 0;
     }
   }
   else if(numComp == 3){
-    switch(numEdges){
-    case 0: data2->NbTP++; return &data2->TP;
-    case 1: data2->NbTL++; return &data2->TL;
-    case 3: data2->NbTT++; return &data2->TT;
-    case 4: data2->NbTQ++; return &data2->TQ;
-    case 6: data2->NbTS++; return &data2->TS;
-    case 12: data2->NbTH++; return &data2->TH;
-    case 9: data2->NbTI++; return &data2->TI;
-    case 8: data2->NbTY++; return &data2->TY;
+    switch(type){
+    case TYPE_PNT: data2->NbTP++; return &data2->TP;
+    case TYPE_LIN: data2->NbTL++; return &data2->TL;
+    case TYPE_TRI: data2->NbTT++; return &data2->TT;
+    case TYPE_QUA: data2->NbTQ++; return &data2->TQ;
+    case TYPE_TET: data2->NbTS++; return &data2->TS;
+    case TYPE_HEX: data2->NbTH++; return &data2->TH;
+    case TYPE_PRI: data2->NbTI++; return &data2->TI;
+    case TYPE_PYR: data2->NbTY++; return &data2->TY;
     default: return 0;
     }
   }
@@ -103,8 +104,8 @@ PView *GMSH_GradientPlugin::execute(PView *v)
       if(data1->skipElement(0, ent, ele)) continue;
       int numComp = data1->getNumComponents(0, ent, ele);
       if(numComp != 1 && numComp != 3) continue;
-      int numEdges = data1->getNumEdges(0, ent, ele);
-      std::vector<double> *out = incrementList(data2, numComp, numEdges);
+      int type = data1->getType(0, ent, ele);
+      std::vector<double> *out = incrementList(data2, numComp, type);
       if(!out) continue;
       int numNodes = data1->getNumNodes(0, ent, ele);
       double x[8], y[8], z[8], val[8 * 3];
diff --git a/Plugin/HarmonicToTime.cpp b/Plugin/HarmonicToTime.cpp
index 54be4b5b88b4f7d666c846acf064141ccb4e7188..7132eb45d388088c65e3760f4df89d44777d8741 100644
--- a/Plugin/HarmonicToTime.cpp
+++ b/Plugin/HarmonicToTime.cpp
@@ -4,6 +4,7 @@
 // bugs and problems to <gmsh@geuz.org>.
 
 #include "HarmonicToTime.h"
+#include "GmshDefines.h"
 
 StringXNumber HarmonicToTimeOptions_Number[] = {
   {GMSH_FULLRC, "RealPart", NULL, 0.},
@@ -59,45 +60,45 @@ void GMSH_HarmonicToTimePlugin::catchErrorMessage(char *errorMessage) const
 }
 
 static std::vector<double> *incrementList(PViewDataList *data, int numComp, 
-                                          int numEdges)
+                                          int type)
 {
-  switch(numEdges){
-  case 0:
+  switch(type){
+  case TYPE_PNT:
     if     (numComp == 1){ data->NbSP++; return &data->SP; }
     else if(numComp == 3){ data->NbVP++; return &data->VP; }
     else if(numComp == 9){ data->NbTP++; return &data->TP; }
     break;
-  case 1:
+  case TYPE_LIN:
     if     (numComp == 1){ data->NbSL++; return &data->SL; }
     else if(numComp == 3){ data->NbVL++; return &data->VL; }
     else if(numComp == 9){ data->NbTL++; return &data->TL; }
     break;
-  case 3: 
+  case TYPE_TRI:
     if     (numComp == 1){ data->NbST++; return &data->ST; }
     else if(numComp == 3){ data->NbVT++; return &data->VT; }
     else if(numComp == 9){ data->NbTT++; return &data->TT; }
     break;
-  case 4: 
+  case TYPE_QUA:
     if     (numComp == 1){ data->NbSQ++; return &data->SQ; }
     else if(numComp == 3){ data->NbVQ++; return &data->VQ; }
     else if(numComp == 9){ data->NbTQ++; return &data->TQ; }
     break;
-  case 6:
+  case TYPE_TET:
     if     (numComp == 1){ data->NbSS++; return &data->SS; }
     else if(numComp == 3){ data->NbVS++; return &data->VS; }
     else if(numComp == 9){ data->NbTS++; return &data->TS; }
     break;
-  case 12: 
+  case TYPE_HEX:
     if     (numComp == 1){ data->NbSH++; return &data->SH; }
     else if(numComp == 3){ data->NbVH++; return &data->VH; }
     else if(numComp == 9){ data->NbTH++; return &data->TH; }
     break;
-  case 9: 
+  case TYPE_PRI:
     if     (numComp == 1){ data->NbSI++; return &data->SI; }
     else if(numComp == 3){ data->NbVI++; return &data->VI; }
     else if(numComp == 9){ data->NbTI++; return &data->TI; }
     break;
-  case 8:
+  case TYPE_PYR:
     if     (numComp == 1){ data->NbSY++; return &data->SY; }
     else if(numComp == 3){ data->NbVY++; return &data->VY; }
     else if(numComp == 9){ data->NbTY++; return &data->TY; }
@@ -140,9 +141,9 @@ PView *GMSH_HarmonicToTimePlugin::execute(PView * v)
     for(int ele = 0; ele < data1->getNumElements(0, ent); ele++){
       if(data1->skipElement(0, ent, ele)) continue;
       int numNodes = data1->getNumNodes(0, ent, ele);
-      int numEdges = data1->getNumEdges(0, ent, ele);
+      int type = data1->getType(0, ent, ele);
       int numComp = data1->getNumComponents(0, ent, ele);
-      std::vector<double> *out = incrementList(data2, numComp, numEdges);
+      std::vector<double> *out = incrementList(data2, numComp, type);
       std::vector<double> x(numNodes), y(numNodes), z(numNodes);
       std::vector<double> vr(numNodes * numComp), vi(numNodes * numComp);
       for(int nod = 0; nod < numNodes; nod++){
diff --git a/Plugin/Levelset.cpp b/Plugin/Levelset.cpp
index 799cfab65802e521d5fd37b6100079ee407e71d4..e22baaaa0a8e7c81e1152a51d87e5933fc90c53e 100644
--- a/Plugin/Levelset.cpp
+++ b/Plugin/Levelset.cpp
@@ -7,6 +7,7 @@
 #include "MakeSimplex.h"
 #include "Numeric.h"
 #include "adaptiveData.h"
+#include "GmshDefines.h"
 
 static const int exn[13][12][2] = {
   {{0,0}}, // point
@@ -24,18 +25,18 @@ static const int exn[13][12][2] = {
    {2,6}, {3,7}, {4,5}, {4,7}, {5,6}, {6,7}} // hexa
 };
 
-static int numSimplexDec(int numEdges)
+static int numSimplexDec(int type)
 {
-  switch(numEdges){
-  case 4: return 2;
-  case 12: return 6;
-  case 9: return 3;
-  case 8: return 2;
+  switch(type){
+  case TYPE_QUA: return 2;
+  case TYPE_HEX: return 6;
+  case TYPE_PRI: return 3;
+  case TYPE_PYR: return 2;
   default: return 1;
   }
 }
 
-static void getSimplexDec(int numNodes, int numEdges, int i, 
+static void getSimplexDec(int numNodes, int numEdges, int type, int i, 
                           int &n0, int &n1, int &n2, int &n3,
                           int &nn, int &ne)
 {
@@ -44,17 +45,17 @@ static void getSimplexDec(int numNodes, int numEdges, int i,
                                 {1,2,3,7}, {1,6,2,7}, {1,5,6,7}};
   static const int pri[3][4] = {{0,1,2,4}, {0,2,4,5}, {0,3,4,5}};
   static const int pyr[2][4] = {{0,1,3,4}, {1,2,3,4}};
-  switch(numEdges){
-  case 4: 
+  switch(type){
+  case TYPE_QUA:
     n0 = qua[i][0]; n1 = qua[i][1]; n2 = qua[i][2]; nn = 3; ne = 3; 
     break;
-  case 12:
+  case TYPE_HEX:
     n0 = hex[i][0]; n1 = hex[i][1]; n2 = hex[i][2]; n3 = hex[i][3]; nn = 4; ne = 6;
     break;
-  case 9:
+  case TYPE_PRI:
     n0 = pri[i][0]; n1 = pri[i][1]; n2 = pri[i][2]; n3 = pri[i][3]; nn = 4; ne = 6;
     break;
-  case 8:
+  case TYPE_PYR:
     n0 = pyr[i][0]; n1 = pyr[i][1]; n2 = pyr[i][2]; n3 = pyr[i][3]; nn = 4; ne = 6;
     break;
   default:
@@ -265,11 +266,12 @@ void GMSH_LevelsetPlugin::_cutAndAddElements(PViewData *vdata, PViewData *wdata,
   int numNodes = vdata->getNumNodes(step, ent, ele);
   int numEdges = vdata->getNumEdges(step, ent, ele);
   int numComp = wdata->getNumComponents(wstep, ent, ele);
+  int type = vdata->getType(step, ent, ele);
 
-  for(int simplex = 0; simplex < numSimplexDec(numEdges); simplex++){
+  for(int simplex = 0; simplex < numSimplexDec(type); simplex++){
     double xp[12], yp[12], zp[12], valp[12][9];
     int n[4], np = 0, ep[12], nsn, nse;
-    getSimplexDec(numNodes, numEdges, simplex, n[0], n[1], n[2], n[3], nsn, nse);
+    getSimplexDec(numNodes, numEdges, type, simplex, n[0], n[1], n[2], n[3], nsn, nse);
 
     for(int i = 0; i < nse; i++){
       int n0 = exn[nse][i][0], n1 = exn[nse][i][1];
diff --git a/Plugin/Skin.cpp b/Plugin/Skin.cpp
index 214505816ec17d124b96761ecb0d3f23d963cd86..3156d783ac995641ebb3f10f9226d23302a04abd 100644
--- a/Plugin/Skin.cpp
+++ b/Plugin/Skin.cpp
@@ -6,6 +6,7 @@
 #include <set>
 #include "Skin.h"
 #include "Context.h"
+#include "GmshDefines.h"
 
 StringXNumber SkinOptions_Number[] = {
   {GMSH_FULLRC, "iView", NULL, -1.}
@@ -122,7 +123,7 @@ class ElmDataLessThan{
 
 double ElmDataLessThan::tolerance = 1.e-12;
 
-static int getBoundary(int numEdges, const int (**boundary)[6][4])
+static int getBoundary(int type, const int (**boundary)[6][4])
 {
   static const int tri[6][4] = 
     {{0,1,-1,-1}, {1,2,-1,-1}, {2,0,-1,-1}};
@@ -136,13 +137,13 @@ static int getBoundary(int numEdges, const int (**boundary)[6][4])
     {{0,1,4,3}, {0,3,5,2}, {1,2,5,4}, {0,2,1,-1}, {3,4,5,-1}};
   static const int pyr[6][4] = 
     {{0,3,2,1}, {0,1,4,-1}, {0,4,3,-1}, {1,2,4,-1}, {2,3,4,-1}};
-  switch(numEdges){
-  case 3: *boundary = &tri; return 3;
-  case 4: *boundary = &qua; return 4;
-  case 6: *boundary = &tet; return 4;
-  case 12: *boundary = &hex; return 6;
-  case 9: *boundary = &pri; return 5;
-  case 8: *boundary = &pyr; return 5;
+  switch(type){
+  case TYPE_TRI: *boundary = &tri; return 3;
+  case TYPE_QUA: *boundary = &qua; return 4;
+  case TYPE_TET: *boundary = &tet; return 4;
+  case TYPE_HEX: *boundary = &hex; return 6;
+  case TYPE_PRI: *boundary = &pri; return 5;
+  case TYPE_PYR: *boundary = &pyr; return 5;
   default : return 0;
   }
 }
@@ -170,9 +171,9 @@ PView *GMSH_SkinPlugin::execute(PView *v)
     for(int ele = 0; ele < data1->getNumElements(0, ent); ele++){
       if(data1->skipElement(0, ent, ele)) continue;
       int numComp = data1->getNumComponents(0, ent, ele);
-      int numEdges = data1->getNumEdges(0, ent, ele);
+      int type = data1->getType(0, ent, ele);
       const int (*boundary)[6][4];
-      int numBoundary = getBoundary(numEdges, &boundary);
+      int numBoundary = getBoundary(type, &boundary);
       if(!numBoundary) continue;
       for(int i = 0; i < numBoundary; i++){
         ElmData e(numComp);
diff --git a/Post/PViewData.h b/Post/PViewData.h
index 7d72d8c0f803e3a6531475b978641781805ca73d..d592827192f61b00ee6aefd4839c3f4e868486e4 100644
--- a/Post/PViewData.h
+++ b/Post/PViewData.h
@@ -33,8 +33,7 @@ class PViewData {
  protected:
   // adaptive visualization data
   adaptiveData *_adaptive;
-  // interpolation matrices, indexed by the number of edges per
-  // element (1 for lines, 3 for triangles, etc.)
+  // interpolation matrices, indexed by the type of element
   std::map<int, std::vector<gmshMatrix<double>*> > _interpolation;
 
  public:
@@ -136,6 +135,9 @@ class PViewData {
   // entity
   virtual int getNumEdges(int step, int ent, int ele) = 0;
 
+  // return the type of the ele-th element in the ent-th entity
+  virtual int getType(int step, int ent, int ele) = 0;
+
   // return the number of 2D/3D strings in the view
   virtual int getNumStrings2D(){ return 0; }
   virtual int getNumStrings3D(){ return 0; }
@@ -176,8 +178,7 @@ class PViewData {
   // return the adaptive data
   adaptiveData *getAdaptiveData(){ return _adaptive; }
 
-  // set/get the interpolation matrices for elements with "type"
-  // number of edges
+  // set/get the interpolation matrices for elements with type "type"
   void setInterpolationMatrices(int type, 
                                 const gmshMatrix<double> &coefVal,
                                 const gmshMatrix<double> &expVal);
diff --git a/Post/PViewDataGModel.cpp b/Post/PViewDataGModel.cpp
index b225802f04b707d2b70d27c42071cc041952df12..7f7c063fcdccf167bcb22eb24bdef1d9ea2a26cd 100644
--- a/Post/PViewDataGModel.cpp
+++ b/Post/PViewDataGModel.cpp
@@ -92,14 +92,14 @@ bool PViewDataGModel::finalize()
 
 void PViewDataGModel::_addInterpolationMatricesForElement(MElement *e)
 {
-  int edg = e->getNumEdges();
+  int type = e->getType();
   const gmshFunctionSpace *fs = e->getFunctionSpace();
   if(fs){
     if(e->getPolynomialOrder() > 1)
-      setInterpolationMatrices(edg, fs->coefficients, fs->monomials,
+      setInterpolationMatrices(type, fs->coefficients, fs->monomials,
                                fs->coefficients, fs->monomials);
     else
-      setInterpolationMatrices(edg, fs->coefficients, fs->monomials);
+      setInterpolationMatrices(type, fs->coefficients, fs->monomials);
   }                               
 }
 
@@ -413,6 +413,11 @@ int PViewDataGModel::getNumEdges(int step, int ent, int ele)
   return _getElement(step, ent, ele)->getNumEdges();
 }
 
+int PViewDataGModel::getType(int step, int ent, int ele)
+{
+  return _getElement(step, ent, ele)->getType();
+}
+
 void PViewDataGModel::revertElement(int step, int ent, int ele)
 {
   if(!step) _getElement(step, ent, ele)->revert();
diff --git a/Post/PViewDataGModel.h b/Post/PViewDataGModel.h
index 0d23113f9de25e01c99347fe0326ccb750c4a5c6..2d0639194de96cd67ebc203d8de6944c5195d95b 100644
--- a/Post/PViewDataGModel.h
+++ b/Post/PViewDataGModel.h
@@ -158,6 +158,7 @@ class PViewDataGModel : public PViewData {
   void getValue(int step, int ent, int ele, int node, int comp, double &val);
   void setValue(int step, int ent, int ele, int node, int comp, double val);
   int getNumEdges(int step, int ent, int ele);
+  int getType(int step, int ent, int ele);
   void revertElement(int step, int ent, int ele);
   void smooth();
   bool skipEntity(int step, int ent);
diff --git a/Post/PViewDataList.cpp b/Post/PViewDataList.cpp
index 20957492522eb395763bfe2e590cb32afc5314e9..b2f97f0781fb485b7888d0a8b424c9a41c9ea7d2 100644
--- a/Post/PViewDataList.cpp
+++ b/Post/PViewDataList.cpp
@@ -20,7 +20,7 @@ PViewDataList::PViewDataList()
     NbSY(0), NbVY(0), NbTY(0), NbT2(0), NbT3(0),
     _lastElement(-1), _lastDimension(-1), _lastNumNodes(-1), 
     _lastNumComponents(-1), _lastNumValues(-1), _lastNumEdges(-1),
-    _lastXYZ(0), _lastVal(0)
+    _lastType(-1), _lastXYZ(0), _lastVal(0)
 {
   for(int i = 0; i < 24; i++) _index[i] = 0;
 }
@@ -39,14 +39,22 @@ bool PViewDataList::finalize()
   _stat(T2D, T2C, 4); _stat(T3D, T3C, 5);
 
   // compute min/max and other statistics for all element lists
-  _stat(SP, 1, NbSP, 1, 0); _stat(VP, 3, NbVP, 1, 0); _stat(TP, 9, NbTP, 1, 0);
-  _stat(SL, 1, NbSL, 2, 1); _stat(VL, 3, NbVL, 2, 1); _stat(TL, 9, NbTL, 2, 1);
-  _stat(ST, 1, NbST, 3, 3); _stat(VT, 3, NbVT, 3, 3); _stat(TT, 9, NbTT, 3, 3);
-  _stat(SQ, 1, NbSQ, 4, 4); _stat(VQ, 3, NbVQ, 4, 4); _stat(TQ, 9, NbTQ, 4, 4);
-  _stat(SS, 1, NbSS, 4, 6); _stat(VS, 3, NbVS, 4, 6); _stat(TS, 9, NbTS, 4, 6);
-  _stat(SH, 1, NbSH, 8,12); _stat(VH, 3, NbVH, 8,12); _stat(TH, 9, NbTH, 8,12);
-  _stat(SI, 1, NbSI, 6, 9); _stat(VI, 3, NbVI, 6, 9); _stat(TI, 9, NbTI, 6, 9);
-  _stat(SY, 1, NbSY, 5, 8); _stat(VY, 3, NbVY, 5, 8); _stat(TY, 9, NbTY, 5, 8);
+  _stat(SP, 1, NbSP, 1, TYPE_PNT); _stat(VP, 3, NbVP, 1, TYPE_PNT);
+  _stat(TP, 9, NbTP, 1, TYPE_PNT);
+  _stat(SL, 1, NbSL, 2, TYPE_LIN); _stat(VL, 3, NbVL, 2, TYPE_LIN);
+  _stat(TL, 9, NbTL, 2, TYPE_LIN);
+  _stat(ST, 1, NbST, 3, TYPE_TRI); _stat(VT, 3, NbVT, 3, TYPE_TRI);
+  _stat(TT, 9, NbTT, 3, TYPE_TRI);
+  _stat(SQ, 1, NbSQ, 4, TYPE_QUA); _stat(VQ, 3, NbVQ, 4, TYPE_QUA);
+  _stat(TQ, 9, NbTQ, 4, TYPE_QUA);
+  _stat(SS, 1, NbSS, 4, TYPE_TET); _stat(VS, 3, NbVS, 4, TYPE_TET);
+  _stat(TS, 9, NbTS, 4, TYPE_TET);
+  _stat(SH, 1, NbSH, 8, TYPE_HEX); _stat(VH, 3, NbVH, 8, TYPE_HEX);
+  _stat(TH, 9, NbTH, 8, TYPE_HEX);
+  _stat(SI, 1, NbSI, 6, TYPE_PRI); _stat(VI, 3, NbVI, 6, TYPE_PRI);
+  _stat(TI, 9, NbTI, 6, TYPE_PRI);
+  _stat(SY, 1, NbSY, 5, TYPE_PYR); _stat(VY, 3, NbVY, 5, TYPE_PYR);
+  _stat(TY, 9, NbTY, 5, TYPE_PYR);
 
   // add dummy time values if none (or too few) time values are
   // provided (e.g. using the old parsed format)
@@ -132,7 +140,7 @@ void PViewDataList::_stat(std::vector<double> &D, std::vector<char> &C, int nb)
 }
 
 void PViewDataList::_stat(std::vector<double> &list, int nbcomp, int nbelm,
-                          int nbnod, int nbedg)
+                          int nbnod, int type)
 {
   // compute statistics for element lists
   if(!nbelm) return;  
@@ -141,7 +149,7 @@ void PViewDataList::_stat(std::vector<double> &list, int nbcomp, int nbelm,
 
   if(haveInterpolationMatrices()){
     std::vector<gmshMatrix<double>*> im;
-    int nim = getInterpolationMatrices(nbedg, im);
+    int nim = getInterpolationMatrices(type, im);
     if(nim == 4)
       nbnod = im[2]->size1();
     if(nim)
@@ -189,12 +197,12 @@ void PViewDataList::_stat(std::vector<double> &list, int nbcomp, int nbelm,
   }
 }
 
-void PViewDataList::_setLast(int ele, int dim, int nbnod, int nbcomp, int nbedg,
+void PViewDataList::_setLast(int ele, int dim, int nbnod, int nbcomp, int nbedg, int type,
                              std::vector<double> &list, int nblist)
 {
   if(haveInterpolationMatrices()){
     std::vector<gmshMatrix<double>*> im;
-    if(getInterpolationMatrices(nbedg, im) == 4)
+    if(getInterpolationMatrices(type, im) == 4)
       nbnod = im[2]->size1();
   }
 
@@ -202,6 +210,7 @@ void PViewDataList::_setLast(int ele, int dim, int nbnod, int nbcomp, int nbedg,
   _lastNumNodes = nbnod;
   _lastNumComponents = nbcomp;
   _lastNumEdges = nbedg;
+  _lastType = type;
   int nb = list.size() / nblist;
   _lastXYZ = &list[ele * nb];
   _lastVal = &list[ele * nb + 3 * _lastNumNodes];
@@ -212,44 +221,44 @@ void PViewDataList::_setLast(int ele)
 {
   _lastElement = ele;
   if(ele < _index[2]){ // points
-    if(ele < _index[0]) _setLast(ele, 0, 1, 1, 0, SP, NbSP);
-    else if(ele < _index[1]) _setLast(ele - _index[0], 0, 1, 3, 0, VP, NbVP);
-    else _setLast(ele - _index[1], 0, 1, 9, 0, TP, NbTP);
+    if(ele < _index[0]) _setLast(ele, 0, 1, 1, 0, TYPE_PNT, SP, NbSP);
+    else if(ele < _index[1]) _setLast(ele - _index[0], 0, 1, 3, 0, TYPE_PNT, VP, NbVP);
+    else _setLast(ele - _index[1], 0, 1, 9, 0, TYPE_PNT, TP, NbTP);
   }
   else if(ele < _index[5]){ // lines
-    if(ele < _index[3]) _setLast(ele - _index[2], 1, 2, 1, 1, SL, NbSL);
-    else if(ele < _index[4]) _setLast(ele - _index[3], 1, 2, 3, 1, VL, NbVL);
-    else _setLast(ele - _index[4], 1, 2, 9, 1, TL, NbTL);
+    if(ele < _index[3]) _setLast(ele - _index[2], 1, 2, 1, 1, TYPE_LIN, SL, NbSL);
+    else if(ele < _index[4]) _setLast(ele - _index[3], 1, 2, 3, 1, TYPE_LIN, VL, NbVL);
+    else _setLast(ele - _index[4], 1, 2, 9, 1, TYPE_LIN, TL, NbTL);
   }
   else if(ele < _index[8]){ // triangles
-    if(ele < _index[6]) _setLast(ele - _index[5], 2, 3, 1, 3, ST, NbST);
-    else if(ele < _index[7]) _setLast(ele - _index[6], 2, 3, 3, 3, VT, NbVT);
-    else _setLast(ele - _index[7], 2, 3, 9, 3, TT, NbTT);
+    if(ele < _index[6]) _setLast(ele - _index[5], 2, 3, 1, 3, TYPE_TRI, ST, NbST);
+    else if(ele < _index[7]) _setLast(ele - _index[6], 2, 3, 3, 3, TYPE_TRI, VT, NbVT);
+    else _setLast(ele - _index[7], 2, 3, 9, 3, TYPE_TRI, TT, NbTT);
   }
   else if(ele < _index[11]){ // quadrangles
-    if(ele < _index[9]) _setLast(ele - _index[8], 2, 4, 1, 4, SQ, NbSQ);
-    else if(ele < _index[10]) _setLast(ele - _index[9], 2, 4, 3, 4, VQ, NbVQ);
-    else _setLast(ele - _index[10], 2, 4, 9, 4, TQ, NbTQ);
+    if(ele < _index[9]) _setLast(ele - _index[8], 2, 4, 1, 4, TYPE_QUA, SQ, NbSQ);
+    else if(ele < _index[10]) _setLast(ele - _index[9], 2, 4, 3, 4, TYPE_QUA, VQ, NbVQ);
+    else _setLast(ele - _index[10], 2, 4, 9, 4, TYPE_QUA, TQ, NbTQ);
   }
   else if(ele < _index[14]){ // tetrahedra
-    if(ele < _index[12]) _setLast(ele - _index[11], 3, 4, 1, 6, SS, NbSS);
-    else if(ele < _index[13]) _setLast(ele - _index[12], 3, 4, 3, 6, VS, NbVS);
-    else _setLast(ele - _index[13], 3, 4, 9, 6, TS, NbTS);
+    if(ele < _index[12]) _setLast(ele - _index[11], 3, 4, 1, 6, TYPE_TET, SS, NbSS);
+    else if(ele < _index[13]) _setLast(ele - _index[12], 3, 4, 3, 6, TYPE_TET, VS, NbVS);
+    else _setLast(ele - _index[13], 3, 4, 9, 6, TYPE_TET, TS, NbTS);
   }
   else if(ele < _index[17]){ // hexahedra
-    if(ele < _index[15]) _setLast(ele - _index[14], 3, 8, 1, 12, SH, NbSH);
-    else if(ele < _index[16]) _setLast(ele - _index[15], 3, 8, 3, 12, VH, NbVH);
-    else _setLast(ele - _index[16], 3, 8, 9, 12, TH, NbTH);
+    if(ele < _index[15]) _setLast(ele - _index[14], 3, 8, 1, 12, TYPE_HEX, SH, NbSH);
+    else if(ele < _index[16]) _setLast(ele - _index[15], 3, 8, 3, 12, TYPE_HEX, VH, NbVH);
+    else _setLast(ele - _index[16], 3, 8, 9, 12, TYPE_HEX, TH, NbTH);
   }
   else if(ele < _index[20]){ // prisms
-    if(ele < _index[18]) _setLast(ele - _index[17], 3, 6, 1, 9, SI, NbSI);
-    else if(ele < _index[19]) _setLast(ele - _index[18], 3, 6, 3, 9, VI, NbVI);
-    else _setLast(ele - _index[19], 3, 6, 9, 9, TI, NbTI);
+    if(ele < _index[18]) _setLast(ele - _index[17], 3, 6, 1, 9, TYPE_PRI, SI, NbSI);
+    else if(ele < _index[19]) _setLast(ele - _index[18], 3, 6, 3, 9, TYPE_PRI, VI, NbVI);
+    else _setLast(ele - _index[19], 3, 6, 9, 9, TYPE_PRI, TI, NbTI);
   }
   else{ // pyramids
-    if(ele < _index[21]) _setLast(ele - _index[20], 3, 5, 1, 8, SY, NbSY);
-    else if(ele < _index[22]) _setLast(ele - _index[21], 3, 5, 3, 8, VY, NbVY);
-    else _setLast(ele - _index[22], 3, 5, 9, 8, TY, NbTY);
+    if(ele < _index[21]) _setLast(ele - _index[20], 3, 5, 1, 8, TYPE_PYR, SY, NbSY);
+    else if(ele < _index[22]) _setLast(ele - _index[21], 3, 5, 3, 8, TYPE_PYR, VY, NbVY);
+    else _setLast(ele - _index[22], 3, 5, 9, 8, TYPE_PYR, TY, NbTY);
   }
 }
 
@@ -328,6 +337,12 @@ int PViewDataList::getNumEdges(int step, int ent, int ele)
   return _lastNumEdges;
 }
 
+int PViewDataList::getType(int step, int ent, int ele)
+{
+  if(ele != _lastElement) _setLast(ele);
+  return _lastType;
+}
+
 void PViewDataList::_getString(int dim, int i, int step, std::string &str, 
                                double &x, double &y, double &z, double &style)
 {
@@ -757,23 +772,23 @@ void PViewDataList::getRawData(int type, std::vector<double> **l, int **ne,
   }
 }
 
-void PViewDataList::setOrder2(int numEdges)
+void PViewDataList::setOrder2(int type)
 {
-  int type = 0;
-  switch(numEdges){
-  case 1: type = MSH_LIN_3; break;
-  case 3: type = MSH_TRI_6; break;
-  case 4: type = MSH_QUA_9; break;
-  case 6: type = MSH_TET_10; break;
-  case 12: type = MSH_HEX_27; break;
-  case 9: type = MSH_PRI_18; break;
-  case 8: type = MSH_PYR_14; break;
-  }
-  const gmshFunctionSpace *fs = &gmshFunctionSpaces::find(type);
+  int typeMSH = 0;
+  switch(type){
+  case TYPE_LIN: typeMSH = MSH_LIN_3; break;
+  case TYPE_TRI: typeMSH = MSH_TRI_6; break;
+  case TYPE_QUA: typeMSH = MSH_QUA_9; break;
+  case TYPE_TET: typeMSH = MSH_TET_10; break;
+  case TYPE_HEX: typeMSH = MSH_HEX_27; break;
+  case TYPE_PRI: typeMSH = MSH_PRI_18; break;
+  case TYPE_PYR: typeMSH = MSH_PYR_14; break;
+  }
+  const gmshFunctionSpace *fs = &gmshFunctionSpaces::find(typeMSH);
   if(!fs){
-    Msg::Error("Could not find function space for element type %d", type);
+    Msg::Error("Could not find function space for element type %d", typeMSH);
     return;
   }
-  setInterpolationMatrices(numEdges, fs->coefficients, fs->monomials,
+  setInterpolationMatrices(type, fs->coefficients, fs->monomials,
                            fs->coefficients, fs->monomials);
 }
diff --git a/Post/PViewDataList.h b/Post/PViewDataList.h
index 0644ae8b777a12cfef6c15cf149a6afce8e119a6..e626256a0437bb728f00ca943b0c7fa290436ca9 100644
--- a/Post/PViewDataList.h
+++ b/Post/PViewDataList.h
@@ -44,12 +44,12 @@ class PViewDataList : public PViewData {
  private:
   int _index[24];
   int _lastElement, _lastDimension;
-  int _lastNumNodes, _lastNumComponents, _lastNumValues, _lastNumEdges;
+  int _lastNumNodes, _lastNumComponents, _lastNumValues, _lastNumEdges, _lastType;
   double *_lastXYZ, *_lastVal;
   void _stat(std::vector<double> &D, std::vector<char> &C, int nb);
-  void _stat(std::vector<double> &list, int nbcomp, int nbelm, int nbnod, int nbedg);
+  void _stat(std::vector<double> &list, int nbcomp, int nbelm, int nbnod, int type);
   void _setLast(int ele);
-  void _setLast(int ele, int dim, int nbnod, int nbcomp, int nbedg,
+  void _setLast(int ele, int dim, int nbnod, int nbcomp, int nbedg, int type,
                 std::vector<double> &list, int nblist);
   void _getString(int dim, int i, int timestep, std::string &str, 
                   double &x, double &y, double &z, double &style);
@@ -86,6 +86,7 @@ class PViewDataList : public PViewData {
   void getValue(int step, int ent, int ele, int nod, int comp, double &val);
   void setValue(int step, int ent, int ele, int nod, int comp, double val);
   int getNumEdges(int step, int ent, int ele);
+  int getType(int step, int ent, int ele);
   int getNumStrings2D(){ return NbT2; }
   int getNumStrings3D(){ return NbT3; }
   void getString2D(int i, int step, std::string &str, 
@@ -99,7 +100,7 @@ class PViewDataList : public PViewData {
 
   // specific to list-based data sets
   void getRawData(int type, std::vector<double> **l, int **ne, int *nc, int *nn);
-  void setOrder2(int nbedg);
+  void setOrder2(int type);
 
   // I/O routines
   bool readPOS(FILE *fp, double version, bool binary);
diff --git a/Post/PViewDataListIO.cpp b/Post/PViewDataListIO.cpp
index c914353fa71606b2c3ac5581f58c0aea233e3fc8..8c45f93ae06f02788b46ec771f5b6a079c5094aa 100644
--- a/Post/PViewDataListIO.cpp
+++ b/Post/PViewDataListIO.cpp
@@ -9,6 +9,7 @@
 #include "Numeric.h"
 #include "StringUtils.h"
 #include "GmshMessage.h"
+#include "GmshDefines.h"
 #include "Context.h"
 #include "adaptiveData.h"
 
@@ -218,27 +219,27 @@ bool PViewDataList::readPOS(FILE *fp, double version, bool binary)
   dVecRead(SY, NbSY2 * (NbTimeStep * 14 * 1 + 42), fp, binary, swap);
   dVecRead(VY, NbVY2 * (NbTimeStep * 14 * 3 + 42), fp, binary, swap);
   dVecRead(TY, NbTY2 * (NbTimeStep * 14 * 9 + 42), fp, binary, swap);
-  if(NbSL2){ NbSL = NbSL2; setOrder2(1); }
-  if(NbVL2){ NbVL = NbVL2; setOrder2(1); }
-  if(NbTL2){ NbTL = NbTL2; setOrder2(1); }
-  if(NbST2){ NbST = NbST2; setOrder2(3); }
-  if(NbVT2){ NbVT = NbVT2; setOrder2(3); }
-  if(NbTT2){ NbTT = NbTT2; setOrder2(3); }
-  if(NbSQ2){ NbSQ = NbSQ2; setOrder2(4); }
-  if(NbVQ2){ NbVQ = NbVQ2; setOrder2(4); }
-  if(NbTQ2){ NbTQ = NbTQ2; setOrder2(4); }
-  if(NbSS2){ NbSS = NbSS2; setOrder2(6); }
-  if(NbVS2){ NbVS = NbVS2; setOrder2(6); }
-  if(NbTS2){ NbTS = NbTS2; setOrder2(6); }
-  if(NbSH2){ NbSH = NbSH2; setOrder2(12); }
-  if(NbVH2){ NbVH = NbVH2; setOrder2(12); }
-  if(NbTH2){ NbTH = NbTH2; setOrder2(12); }
-  if(NbSI2){ NbSI = NbSI2; setOrder2(9); }
-  if(NbVI2){ NbVI = NbVI2; setOrder2(9); }
-  if(NbTI2){ NbTI = NbTI2; setOrder2(9); }
-  if(NbSY2){ NbSY = NbSY2; setOrder2(8); }
-  if(NbVY2){ NbVY = NbVY2; setOrder2(8); }
-  if(NbTY2){ NbTY = NbTY2; setOrder2(8); }
+  if(NbSL2){ NbSL = NbSL2; setOrder2(TYPE_LIN); }
+  if(NbVL2){ NbVL = NbVL2; setOrder2(TYPE_LIN); }
+  if(NbTL2){ NbTL = NbTL2; setOrder2(TYPE_LIN); }
+  if(NbST2){ NbST = NbST2; setOrder2(TYPE_TRI); }
+  if(NbVT2){ NbVT = NbVT2; setOrder2(TYPE_TRI); }
+  if(NbTT2){ NbTT = NbTT2; setOrder2(TYPE_TRI); }
+  if(NbSQ2){ NbSQ = NbSQ2; setOrder2(TYPE_QUA); }
+  if(NbVQ2){ NbVQ = NbVQ2; setOrder2(TYPE_QUA); }
+  if(NbTQ2){ NbTQ = NbTQ2; setOrder2(TYPE_QUA); }
+  if(NbSS2){ NbSS = NbSS2; setOrder2(TYPE_TET); }
+  if(NbVS2){ NbVS = NbVS2; setOrder2(TYPE_TET); }
+  if(NbTS2){ NbTS = NbTS2; setOrder2(TYPE_TET); }
+  if(NbSH2){ NbSH = NbSH2; setOrder2(TYPE_HEX); }
+  if(NbVH2){ NbVH = NbVH2; setOrder2(TYPE_HEX); }
+  if(NbTH2){ NbTH = NbTH2; setOrder2(TYPE_HEX); }
+  if(NbSI2){ NbSI = NbSI2; setOrder2(TYPE_PRI); }
+  if(NbVI2){ NbVI = NbVI2; setOrder2(TYPE_PRI); }
+  if(NbTI2){ NbTI = NbTI2; setOrder2(TYPE_PRI); }
+  if(NbSY2){ NbSY = NbSY2; setOrder2(TYPE_PYR); }
+  if(NbVY2){ NbVY = NbVY2; setOrder2(TYPE_PYR); }
+  if(NbTY2){ NbTY = NbTY2; setOrder2(TYPE_PYR); }
  
   dVecRead(T2D, NbT2 * 4, fp, binary, swap);
   cVecRead(T2C, t2l, fp, binary, swap, (version <= 1.2));
diff --git a/Post/PViewOptions.cpp b/Post/PViewOptions.cpp
index 2760a01cb13fdc082d1f4d080b525b9b3530225b..5843c79ad6144d2e0c8da3336289969bdbf530fd 100644
--- a/Post/PViewOptions.cpp
+++ b/Post/PViewOptions.cpp
@@ -6,6 +6,7 @@
 #include <string.h>
 #include "GmshConfig.h"
 #include "GmshMessage.h"
+#include "GmshDefines.h"
 #include "PViewOptions.h"
 
 #if defined(HAVE_MATH_EVAL)
@@ -140,17 +141,17 @@ void PViewOptions::createGeneralRaise()
 #endif
 }
 
-bool PViewOptions::skipElement(int numEdges)
+bool PViewOptions::skipElement(int type)
 {
-  switch(numEdges){
-  case 0: return !drawPoints;
-  case 1: return !drawLines;
-  case 3: return !drawTriangles;
-  case 4: return !drawQuadrangles;
-  case 6: return !drawTetrahedra;
-  case 12: return !drawHexahedra;
-  case 9: return !drawPrisms;
-  case 8: return !drawPyramids;
+  switch(type){
+  case TYPE_PNT: return !drawPoints;
+  case TYPE_LIN: return !drawLines;
+  case TYPE_TRI: return !drawTriangles;
+  case TYPE_QUA: return !drawQuadrangles;
+  case TYPE_TET: return !drawTetrahedra;
+  case TYPE_HEX: return !drawHexahedra;
+  case TYPE_PRI: return !drawPrisms;
+  case TYPE_PYR: return !drawPyramids;
   default: return true;
   }
 }
diff --git a/Post/PViewOptions.h b/Post/PViewOptions.h
index a68e5b1a67089a4aff87e7d545ae2c5bd8b8f275..0d31e7e8605b0951f2bb75b45b0af7cab3d18c2f 100644
--- a/Post/PViewOptions.h
+++ b/Post/PViewOptions.h
@@ -113,8 +113,8 @@ class PViewOptions {
   // create/destroy math evaluators for general raise option
   void createGeneralRaise();
   void destroyGeneralRaise();
-  // return true if one should not draw elements with numEdges edges
-  bool skipElement(int numEdges);
+  // return true if one should not draw elements with type type
+  bool skipElement(int type);
 };
 
 #endif
diff --git a/Post/adaptiveData.cpp b/Post/adaptiveData.cpp
index 3eefc3f5ad60f0765c2f49fe6ed9c67fc66ff271..132d9a0e867a51149af1f2b3749d547cb4a91bb2 100644
--- a/Post/adaptiveData.cpp
+++ b/Post/adaptiveData.cpp
@@ -9,6 +9,7 @@
 #include "adaptiveData.h"
 #include "Plugin.h"
 #include "OS.h"
+#include "GmshDefines.h"
 
 //#define TIMER
 
@@ -1135,27 +1136,27 @@ adaptiveData::adaptiveData(PViewData *data)
   _outData = new PViewDataList();
   std::vector<gmshMatrix<double>*> p;
   if(_inData->getNumLines()){
-    _inData->getInterpolationMatrices(1, p);
+    _inData->getInterpolationMatrices(TYPE_LIN, p);
     _lines = new adaptiveElements<adaptiveLine>(p);
   }
   if(_inData->getNumTriangles()){
-    _inData->getInterpolationMatrices(3, p);
+    _inData->getInterpolationMatrices(TYPE_TRI, p);
     _triangles = new adaptiveElements<adaptiveTriangle>(p);
   }
   if(_inData->getNumQuadrangles()){
-    _inData->getInterpolationMatrices(4, p);
+    _inData->getInterpolationMatrices(TYPE_QUA, p);
     _quadrangles = new adaptiveElements<adaptiveQuadrangle>(p);
   }
   if(_inData->getNumTetrahedra()){
-    _inData->getInterpolationMatrices(6, p);
+    _inData->getInterpolationMatrices(TYPE_TET, p);
     _tetrahedra = new adaptiveElements<adaptiveTetrahedron>(p);
   }
   if(_inData->getNumPrisms()){
-    _inData->getInterpolationMatrices(9, p);
+    _inData->getInterpolationMatrices(TYPE_PRI, p);
     _prisms = new adaptiveElements<adaptivePrism>(p);
   }
   if(_inData->getNumHexahedra()){
-    _inData->getInterpolationMatrices(12, p);
+    _inData->getInterpolationMatrices(TYPE_HEX, p);
     _hexahedra = new adaptiveElements<adaptiveHexahedron>(p);
   }
 }