diff --git a/src/Controls/SMESH_Controls.cxx b/src/Controls/SMESH_Controls.cxx
index d00783422..e6946a84a 100644
--- a/src/Controls/SMESH_Controls.cxx
+++ b/src/Controls/SMESH_Controls.cxx
@@ -3250,3 +3250,35 @@ void ElementsOnShape::process (const SMDS_MeshElement* theElemPtr)
   if (isSatisfy)
     myIds.Add(theElemPtr->GetID());
 }
+
+TSequenceOfXYZ::TSequenceOfXYZ()
+{}
+
+TSequenceOfXYZ::TSequenceOfXYZ(size_type n) : std::vector<gp_XYZ>(n)
+{}
+
+TSequenceOfXYZ::TSequenceOfXYZ(size_type n, const value_type& t) : std::vector<gp_XYZ>(n,t)
+{}
+
+TSequenceOfXYZ::TSequenceOfXYZ(const TSequenceOfXYZ& theSequenceOfXYZ) : std::vector<gp_XYZ>(theSequenceOfXYZ)
+{}
+
+template <class InputIterator>
+TSequenceOfXYZ::TSequenceOfXYZ(InputIterator theBegin, InputIterator theEnd): std::vector<gp_XYZ>(theBegin,theEnd)
+{}
+
+TSequenceOfXYZ& TSequenceOfXYZ::operator=(const TSequenceOfXYZ& theSequenceOfXYZ)
+{
+  std::vector<gp_XYZ>::operator=(theSequenceOfXYZ);
+  return *this;
+}
+
+std::vector<gp_XYZ>::reference TSequenceOfXYZ::operator()(size_type n)
+{
+  return std::vector<gp_XYZ>::operator[](n-1);
+}
+
+std::vector<gp_XYZ>::const_reference TSequenceOfXYZ::operator()(size_type n) const
+{
+  return std::vector<gp_XYZ>::operator[](n-1);
+}
diff --git a/src/Controls/SMESH_ControlsDef.hxx b/src/Controls/SMESH_ControlsDef.hxx
index dba5f8198..38a507c84 100644
--- a/src/Controls/SMESH_ControlsDef.hxx
+++ b/src/Controls/SMESH_ControlsDef.hxx
@@ -71,39 +71,22 @@ namespace SMESH{
     class SMESHCONTROLS_EXPORT TSequenceOfXYZ: public std::vector<gp_XYZ>
     {
     public:
-      typedef std::vector<gp_XYZ> TSuperClass;
-      TSequenceOfXYZ()
-      {}
+      TSequenceOfXYZ();
 
-      TSequenceOfXYZ(size_type n):
-	TSuperClass(n)
-      {}
+      TSequenceOfXYZ(size_type n);
 
-      TSequenceOfXYZ(size_type n, const value_type& t):
-	TSuperClass(n,t)
-      {}
+      TSequenceOfXYZ(size_type n, const value_type& t);
 
-      TSequenceOfXYZ(const TSequenceOfXYZ& theSequenceOfXYZ):
-	TSuperClass(theSequenceOfXYZ)
-      {}
+      TSequenceOfXYZ(const TSequenceOfXYZ& theSequenceOfXYZ);
 
       template <class InputIterator>
-      TSequenceOfXYZ(InputIterator theBegin, InputIterator theEnd):
-	TSuperClass(theBegin,theEnd)
-      {}
+      TSequenceOfXYZ(InputIterator theBegin, InputIterator theEnd);
 
-      TSequenceOfXYZ& operator=(const TSequenceOfXYZ& theSequenceOfXYZ){
-	TSuperClass::operator=(theSequenceOfXYZ);
-	return *this;
-      }
+      TSequenceOfXYZ& operator=(const TSequenceOfXYZ& theSequenceOfXYZ);
 
-      reference operator()(size_type n){
-	return TSuperClass::operator[](n-1);
-      }
+      reference operator()(size_type n);
 
-      const_reference operator()(size_type n) const{
-	return TSuperClass::operator[](n-1);
-      }
+      const_reference operator()(size_type n) const;
 
     private:
       reference operator[](size_type n);