0023654: Problem with displaying vertices in OCC view after closing all OCC views...
[occt.git] / src / ViewerTest / ViewerTest_ObjectCommands.cxx
index 5651f2f..d766a40 100755 (executable)
 #include <Prs3d_PointAspect.hxx>
 
 #include <Image_AlienPixMap.hxx>
+#include <TColStd_HArray1OfAsciiString.hxx>
 
 #ifdef HAVE_STRINGS_H
 #include <strings.h>
@@ -2325,7 +2326,7 @@ protected:
   Standard_Real                       aHeight;
   Standard_Boolean                    aZoomable;
   Quantity_Color                      aColor;
-  Standard_CString                    aFont;
+  TCollection_AsciiString             aFont;
   Font_FontAspect                     aFontAspect;
   Graphic3d_HorizontalTextAlignment   aHJustification;
   Graphic3d_VerticalTextAlignment     aVJustification;
@@ -2371,7 +2372,7 @@ void MyTextClass::Compute(const Handle(PrsMgr_PresentationManager3d)& /*aPresent
 
   Handle_Prs3d_TextAspect asp = myDrawer->TextAspect();
 
-  asp->SetFont(aFont);
+  asp->SetFont(aFont.ToCString());
   asp->SetColor(aColor);
   asp->SetHeight(aHeight); // I am changing the myHeight value
 
@@ -2995,10 +2996,10 @@ class MyPArrayObject : public AIS_InteractiveObject
 
 public:
 
-  MyPArrayObject (const Handle(Graphic3d_ArrayOfPrimitives) theArray,
+  MyPArrayObject (Handle(TColStd_HArray1OfAsciiString) theArrayDescription,
                   Handle(Graphic3d_AspectMarker3d) theMarkerAspect = NULL)
   {
-    myArray = theArray;
+    myArrayDescription = theArrayDescription;
     myMarkerAspect = theMarkerAspect;
   }
 
@@ -3013,9 +3014,15 @@ private:
   void ComputeSelection (const Handle(SelectMgr_Selection)& theSelection,
                          const Standard_Integer /*theMode*/);
 
+  bool CheckInputCommand (const TCollection_AsciiString theCommand,
+                          const Handle(TColStd_HArray1OfAsciiString) theArgsArray,
+                          Standard_Integer &theArgIndex,
+                          Standard_Integer theArgCount,
+                          Standard_Integer theMaxArgs);
+
 protected:
 
-  Handle(Graphic3d_ArrayOfPrimitives) myArray;
+  Handle(TColStd_HArray1OfAsciiString) myArrayDescription;
   Handle(Graphic3d_AspectMarker3d) myMarkerAspect;
 
 };
@@ -3027,158 +3034,66 @@ void MyPArrayObject::Compute (const Handle(PrsMgr_PresentationManager3d)& /*aPre
                               const Handle(Prs3d_Presentation)& aPresentation,
                               const Standard_Integer /*aMode*/)
 {
-  aPresentation->Clear();
-  if (!myMarkerAspect.IsNull())
-  {
-    Prs3d_Root::CurrentGroup (aPresentation)->SetGroupPrimitivesAspect (myMarkerAspect);
-  }
-  Prs3d_Root::CurrentGroup (aPresentation)->AddPrimitiveArray (myArray);
-}
-
-void MyPArrayObject::ComputeSelection (const Handle(SelectMgr_Selection)& theSelection,
-                                       const Standard_Integer /*theMode*/)
-{
-  Handle(SelectMgr_EntityOwner) anEntityOwner = new SelectMgr_EntityOwner (this);
-
-  for (Standard_Integer anIter = 1; anIter <= myArray->VertexNumber(); anIter++)
-  {
-
-    Handle(Select3D_SensitivePoint) aSensetivePoint = new Select3D_SensitivePoint (anEntityOwner, myArray->Vertice (anIter));
-    theSelection->Add (aSensetivePoint);
-  }
-}
-
-static bool CheckInputCommand (const TCollection_AsciiString theCommand,
-                               const char **theArgStr, int &theArgIndex,
-                               int theArgCount, int theMaxArgs)
-{
-  // check if there is more elements than expected
-  if (theArgIndex >= theMaxArgs)
-    return false;
-
-  TCollection_AsciiString aStrCommand(theArgStr[theArgIndex]);
-  aStrCommand.LowerCase();
-  if (aStrCommand.Search(theCommand) != 1 ||
-      theArgIndex + (theArgCount - 1) >= theMaxArgs)
-    return false;
-
-  // go to the first data element
-  theArgIndex++;
-
-  // check data if it can be converted to numeric
-  for (int aElement = 0; aElement < theArgCount; aElement++, theArgIndex++)
-  {
-    aStrCommand = theArgStr[theArgIndex];
-    if (!aStrCommand.IsRealValue())
-      return false;
-  }
-
-  return true;
-}
-
-//=============================================================================
-//function : VDrawPArray
-//purpose  : Draws primitives array from list of vertexes, bounds, edges
-//=============================================================================
-
-static int VDrawPArray (Draw_Interpretor& di, Standard_Integer argc, const char** argv)
-{
-  Handle(AIS_InteractiveContext) aContextAIS = ViewerTest::GetAISContext();
-  if (aContextAIS.IsNull())
-  {
-    di << "Call vinit before!\n";
-    return 1;
-  }
-  else if (argc < 3)
-  {
-    di << "Use: " << argv[0] << " Name TypeOfArray"
-       << " [vertex] ... [bounds] ... [edges]\n"
-       << "  TypeOfArray={ points | segments | polylines | triangles |\n"
-       << "                trianglefans | trianglestrips | quads |\n"
-       << "                quadstrips | polygons }\n"
-       << "  vertex={ 'v' x y z [normal={ 'n' nx ny nz }] [color={ 'c' r g b }]"
-       << " [texel={ 't' tx ty }] } \n"
-       << "  bounds={ 'b' verticies_count [color={ 'c' r g b }] }\n"
-       << "  edges={ 'e' vertex_id [hidden_edge={'h'}] }\n";
-    return 1;
-  }
 
-  // read the arguments
-  Standard_Integer aArgIndex = 1;
-  TCollection_AsciiString aName (argv[aArgIndex++]);
-  TCollection_AsciiString anArrayType (argv[aArgIndex++]);
-  const Standard_Integer anArgsFrom = aArgIndex;
-
-  // parse number of verticies, bounds, edges
+  // Parsing array description
   Standard_Integer aVertexNum = 0, aBoundNum = 0, aEdgeNum = 0;
   Standard_Boolean hasVColors, hasBColors, hasNormals, hasInfos, hasTexels;
   hasVColors = hasNormals = hasBColors = hasInfos = hasTexels = Standard_False;
 
+  Standard_Integer anArgIndex = 0;
+  Standard_Integer anArgsCount = myArrayDescription->Length();
+  TCollection_AsciiString anArrayType = myArrayDescription->Value (anArgIndex++);
+
   TCollection_AsciiString aCommand;
-  while (aArgIndex < argc)
+  while (anArgIndex < anArgsCount)
   {
-    aCommand = argv[aArgIndex];
+    aCommand = myArrayDescription->Value (anArgIndex);
     aCommand.LowerCase();
-    if (!aCommand.IsAscii())
-    {
-      di << "Unexpected argument: #" << aArgIndex - 1 << " , "
-         << "should be an array element: 'v', 'b', 'e' \n";
-      break;
-    }
 
     // vertex command
-    if (CheckInputCommand ("v", argv, aArgIndex, 3, argc))
+    if (CheckInputCommand ("v", myArrayDescription, anArgIndex, 3, anArgsCount))
     {
       // vertex has a normal or normal with color or texel
-      if (CheckInputCommand ("n", argv, aArgIndex, 3, argc))
+      if (CheckInputCommand ("n", myArrayDescription, anArgIndex, 3, anArgsCount))
         hasNormals = Standard_True;
 
       // vertex has a color
-      if (CheckInputCommand ("c", argv, aArgIndex, 3, argc))
+      if (CheckInputCommand ("c", myArrayDescription, anArgIndex, 3, anArgsCount))
         hasVColors = Standard_True;
 
       // vertex has a texel
-      if (CheckInputCommand ("t", argv, aArgIndex, 2, argc))
+      if (CheckInputCommand ("t", myArrayDescription, anArgIndex, 2, anArgsCount))
         hasTexels = Standard_True;
 
       aVertexNum++;
     }
     // bound command
-    else if (CheckInputCommand ("b", argv, aArgIndex, 1, argc))
+    else if (CheckInputCommand ("b", myArrayDescription, anArgIndex, 1, anArgsCount))
     {
       // bound has color
-      if (CheckInputCommand ("c", argv, aArgIndex, 3, argc))
+      if (CheckInputCommand ("c", myArrayDescription, anArgIndex, 3, anArgsCount))
         hasBColors = Standard_True;
 
       aBoundNum++;
     }
     // edge command
-    else if (CheckInputCommand ("e", argv, aArgIndex, 1, argc))
+    else if (CheckInputCommand ("e", myArrayDescription, anArgIndex, 1, anArgsCount))
     {
       // edge has a hide flag
-      if (CheckInputCommand ("h", argv, aArgIndex, 0, argc))
+      if (CheckInputCommand ("h", myArrayDescription, anArgIndex, 0, anArgsCount))
         hasInfos = Standard_True;
 
       aEdgeNum++;
     }
     // unknown command
     else
-      aArgIndex++;
+      anArgIndex++;
   }
 
-  if (aVertexNum == 0)
-  {
-    di << "You should pass any verticies in the list of array elements\n";
-    return 1;
-  }
-
-  // create an array of primitives by types
   Handle(Graphic3d_ArrayOfPrimitives) anArray;
-  Handle(Graphic3d_AspectMarker3d)    anAspPoints;
   if (anArrayType == "points")
   {
     anArray = new Graphic3d_ArrayOfPoints (aVertexNum);
-    anAspPoints = new Graphic3d_AspectMarker3d (Aspect_TOM_POINT, Quantity_NOC_YELLOW, 1.0f);
   }
   else if (anArrayType == "segments")
     anArray = new Graphic3d_ArrayOfSegments (aVertexNum, aEdgeNum, hasVColors);
@@ -3208,78 +3123,216 @@ static int VDrawPArray (Draw_Interpretor& di, Standard_Integer argc, const char*
     anArray = new Graphic3d_ArrayOfPolygons (aVertexNum, aBoundNum, aEdgeNum,
                                              hasNormals, hasVColors, hasBColors,
                                              hasTexels, hasInfos);
-  else
-  {
-    di << "Unexpected type of primitiives array\n";
-    return 1;
-  }
 
-  // parse an array of primitives
-  aArgIndex = anArgsFrom;
-  while (aArgIndex < argc)
+  anArgIndex = 1;
+  while (anArgIndex < anArgsCount)
   {
-    aCommand = argv[aArgIndex];
+    aCommand = myArrayDescription->Value (anArgIndex);
     aCommand.LowerCase();
     if (!aCommand.IsAscii())
       break;
 
     // vertex command
-    if (CheckInputCommand ("v", argv, aArgIndex, 3, argc))
+    if (CheckInputCommand ("v", myArrayDescription, anArgIndex, 3, anArgsCount))
     {
-      anArray->AddVertex (Draw::Atof (argv[aArgIndex - 3]),
-                          Draw::Atof (argv[aArgIndex - 2]),
-                          Draw::Atof (argv[aArgIndex - 1]));
+      anArray->AddVertex (myArrayDescription->Value (anArgIndex - 3).RealValue(),
+                          myArrayDescription->Value (anArgIndex - 2).RealValue(),
+                          myArrayDescription->Value (anArgIndex - 1).RealValue());
 
       // vertex has a normal or normal with color or texel
-      if (CheckInputCommand ("n", argv, aArgIndex, 3, argc))
+      if (CheckInputCommand ("n", myArrayDescription, anArgIndex, 3, anArgsCount))
         anArray->SetVertexNormal (anArray->VertexNumber (),
-                                  Draw::Atof (argv[aArgIndex - 3]),
-                                  Draw::Atof (argv[aArgIndex - 2]),
-                                  Draw::Atof (argv[aArgIndex - 1]));
+                                  myArrayDescription->Value (anArgIndex - 3).RealValue(),
+                                  myArrayDescription->Value (anArgIndex - 2).RealValue(),
+                                  myArrayDescription->Value (anArgIndex - 1).RealValue());
       
-      if (CheckInputCommand ("c", argv, aArgIndex, 3, argc))
+      if (CheckInputCommand ("c", myArrayDescription, anArgIndex, 3, anArgsCount))
         anArray->SetVertexColor (anArray->VertexNumber (),
-                                 Draw::Atof (argv[aArgIndex - 3]),
-                                 Draw::Atof (argv[aArgIndex - 2]),
-                                 Draw::Atof (argv[aArgIndex - 1]));
+                                 myArrayDescription->Value (anArgIndex - 3).RealValue(),
+                                 myArrayDescription->Value (anArgIndex - 2).RealValue(),
+                                 myArrayDescription->Value (anArgIndex - 1).RealValue());
       
-      if (CheckInputCommand ("t", argv, aArgIndex, 2, argc))
+      if (CheckInputCommand ("t", myArrayDescription, anArgIndex, 2, anArgsCount))
         anArray->SetVertexTexel (anArray->VertexNumber (),
-                                 Draw::Atof (argv[aArgIndex - 2]),
-                                 Draw::Atof (argv[aArgIndex - 1]));
+                                 myArrayDescription->Value (anArgIndex - 2).RealValue(),
+                                 myArrayDescription->Value (anArgIndex - 1).RealValue());
     }
     // bounds command
-    else if (CheckInputCommand ("b", argv, aArgIndex, 1, argc))
+    else if (CheckInputCommand ("b", myArrayDescription, anArgIndex, 1, anArgsCount))
     {
-      Standard_Integer aVertCount = Draw::Atoi (argv[aArgIndex - 1]);
+      Standard_Integer aVertCount = myArrayDescription->Value (anArgIndex - 1).IntegerValue();
 
-      if (CheckInputCommand ("c", argv, aArgIndex, 3, argc))
+      if (CheckInputCommand ("c", myArrayDescription, anArgIndex, 3, anArgsCount))
         anArray->AddBound (aVertCount,
-                           Draw::Atof (argv[aArgIndex - 3]),
-                           Draw::Atof (argv[aArgIndex - 2]),
-                           Draw::Atof (argv[aArgIndex - 1]));
+                           myArrayDescription->Value (anArgIndex - 3).RealValue(),
+                           myArrayDescription->Value (anArgIndex - 2).RealValue(),
+                           myArrayDescription->Value (anArgIndex - 1).RealValue());
 
       else
         anArray->AddBound (aVertCount);
     }
     // edge command
-    else if (CheckInputCommand ("e", argv, aArgIndex, 1, argc))
+    else if (CheckInputCommand ("e", myArrayDescription, anArgIndex, 1, anArgsCount))
     {
-      Standard_Integer aVertIndex = Draw::Atoi (argv[aArgIndex - 1]);
+      Standard_Integer aVertIndex = myArrayDescription->Value (anArgIndex - 1).IntegerValue();
 
       // edge has/hasn't hide flag
-      if (CheckInputCommand ("h", argv, aArgIndex, 0, argc))
+      if (CheckInputCommand ("h", myArrayDescription, anArgIndex, 0, anArgsCount))
         anArray->AddEdge (aVertIndex, Standard_False);
       else
         anArray->AddEdge (aVertIndex, Standard_True);
     }
     // unknown command
     else
-      aArgIndex++;
+      anArgIndex++;
+  }
+
+  aPresentation->Clear();
+  if (!myMarkerAspect.IsNull())
+  {
+    Prs3d_Root::CurrentGroup (aPresentation)->SetGroupPrimitivesAspect (myMarkerAspect);
+  }
+  Prs3d_Root::CurrentGroup (aPresentation)->AddPrimitiveArray (anArray);
+}
+
+void MyPArrayObject::ComputeSelection (const Handle(SelectMgr_Selection)& theSelection,
+                                       const Standard_Integer /*theMode*/)
+{
+  Handle(SelectMgr_EntityOwner) anEntityOwner = new SelectMgr_EntityOwner (this);
+
+  Standard_Integer anArgIndex = 1;
+  while (anArgIndex < myArrayDescription->Length())
+  {
+    if (CheckInputCommand ("v", myArrayDescription, anArgIndex, 3, myArrayDescription->Length()))
+    {
+      gp_Pnt aPoint (myArrayDescription->Value (anArgIndex - 3).RealValue(),
+                     myArrayDescription->Value (anArgIndex - 2).RealValue(),
+                     myArrayDescription->Value (anArgIndex - 1).RealValue());
+      Handle(Select3D_SensitivePoint) aSensetivePoint = new Select3D_SensitivePoint (anEntityOwner, aPoint);
+      theSelection->Add (aSensetivePoint);
+    }
+    else
+    {
+      anArgIndex++;
+    }
+  }
+}
+
+bool MyPArrayObject::CheckInputCommand (const TCollection_AsciiString theCommand,
+                                       const Handle(TColStd_HArray1OfAsciiString) theArgsArray,
+                                       Standard_Integer &theArgIndex,
+                                       Standard_Integer theArgCount,
+                                       Standard_Integer theMaxArgs)
+{
+  // check if there is more elements than expected
+  if (theArgIndex >= theMaxArgs)
+    return false;
+
+  TCollection_AsciiString aStrCommand = theArgsArray->Value (theArgIndex);
+  aStrCommand.LowerCase();
+  if (aStrCommand.Search(theCommand) != 1 ||
+      theArgIndex + (theArgCount - 1) >= theMaxArgs)
+    return false;
+
+  // go to the first data element
+  theArgIndex++;
+
+  // check data if it can be converted to numeric
+  for (int aElement = 0; aElement < theArgCount; aElement++, theArgIndex++)
+  {
+    aStrCommand = theArgsArray->Value (theArgIndex);
+    if (!aStrCommand.IsRealValue())
+      return false;
+  }
+
+  return true;
+}
+
+//=============================================================================
+//function : VDrawPArray
+//purpose  : Draws primitives array from list of vertexes, bounds, edges
+//=============================================================================
+
+static int VDrawPArray (Draw_Interpretor& di, Standard_Integer argc, const char** argv)
+{
+  Handle(AIS_InteractiveContext) aContextAIS = ViewerTest::GetAISContext();
+  if (aContextAIS.IsNull())
+  {
+    di << "Call vinit before!\n";
+    return 1;
+  }
+  else if (argc < 3)
+  {
+    di << "Use: " << argv[0] << " Name TypeOfArray"
+       << " [vertex] ... [bounds] ... [edges]\n"
+       << "  TypeOfArray={ points | segments | polylines | triangles |\n"
+       << "                trianglefans | trianglestrips | quads |\n"
+       << "                quadstrips | polygons }\n"
+       << "  vertex={ 'v' x y z [normal={ 'n' nx ny nz }] [color={ 'c' r g b }]"
+       << " [texel={ 't' tx ty }] } \n"
+       << "  bounds={ 'b' verticies_count [color={ 'c' r g b }] }\n"
+       << "  edges={ 'e' vertex_id [hidden_edge={'h'}] }\n";
+    return 1;
+  }
+
+  // read the arguments
+  Standard_Integer aArgIndex = 1;
+  TCollection_AsciiString aName (argv[aArgIndex++]);
+  TCollection_AsciiString anArrayType (argv[aArgIndex++]);
+
+  Standard_Boolean hasVertex = Standard_False;
+
+  Handle(TColStd_HArray1OfAsciiString) anArgsArray = new TColStd_HArray1OfAsciiString (0, argc - 2);
+  anArgsArray->SetValue (0, anArrayType);
+
+  if (anArrayType != "points"         &&
+      anArrayType != "segments"       &&
+      anArrayType != "polylines"      &&
+      anArrayType != "triangles"      &&
+      anArrayType != "trianglefans"   &&
+      anArrayType != "trianglestrips" &&
+      anArrayType != "quads"          &&
+      anArrayType != "quadstrips"     &&
+      anArrayType != "polygons")
+  {
+    di << "Unexpected type of primitives array\n";
+    return 1;
+  }
+
+  TCollection_AsciiString aCommand;
+  for (Standard_Integer anArgIndex = 3; anArgIndex < argc; anArgIndex++)
+  {
+    aCommand = argv[anArgIndex];
+    aCommand.LowerCase();
+    if (!aCommand.IsAscii())
+    {
+      di << "Unexpected argument: #" << aArgIndex - 1 << " , "
+         << "should be an array element: 'v', 'b', 'e' \n";
+      break;
+    }
+
+    if (aCommand == "v")
+    {
+      hasVertex = Standard_True;
+    }
+
+    anArgsArray->SetValue (anArgIndex - 2, aCommand);
+  }
+
+  if (!hasVertex)
+  {
+    di << "You should pass any verticies in the list of array elements\n";
+    return 1;
+  }
+
+  Handle(Graphic3d_AspectMarker3d)    anAspPoints;
+  if (anArrayType == "points")
+  {
+    anAspPoints = new Graphic3d_AspectMarker3d (Aspect_TOM_POINT, Quantity_NOC_YELLOW, 1.0f);
   }
 
   // create primitives array object
-  Handle(MyPArrayObject) aPObject = new MyPArrayObject (anArray, anAspPoints);
+  Handle(MyPArrayObject) aPObject = new MyPArrayObject (anArgsArray, anAspPoints);
 
   // register the object in map
   VDisplayAISObject (aName, aPObject);
@@ -4440,6 +4493,105 @@ static Standard_Integer VShowFaceBoundary (Draw_Interpretor& /*di*/,
   return 0;
 }
 
+// This class is used for testing markers.
+DEFINE_STANDARD_HANDLE(ViewerTest_MarkersArrayObject, AIS_InteractiveObject)
+class ViewerTest_MarkersArrayObject : public AIS_InteractiveObject
+{
+
+public:
+
+  ViewerTest_MarkersArrayObject (const gp_XYZ& theStartPoint,
+                                 const Standard_Integer& thePointsOnSide,
+                                 Handle(Graphic3d_AspectMarker3d) theMarkerAspect = NULL)
+  {
+    myStartPoint = theStartPoint;
+    myPointsOnSide = thePointsOnSide;
+    myMarkerAspect = theMarkerAspect;
+  }
+
+  DEFINE_STANDARD_RTTI(MyPArrayObject);
+
+private:
+
+  void Compute (const Handle(PrsMgr_PresentationManager3d)& aPresentationManager,
+                const Handle(Prs3d_Presentation)& aPresentation,
+                const Standard_Integer aMode);
+
+  void ComputeSelection (const Handle(SelectMgr_Selection)& theSelection,
+                         const Standard_Integer /*theMode*/);
+
+protected:
+
+  gp_XYZ myStartPoint;
+  Standard_Integer myPointsOnSide;
+  Handle(Graphic3d_AspectMarker3d) myMarkerAspect;
+};
+
+IMPLEMENT_STANDARD_HANDLE(ViewerTest_MarkersArrayObject, AIS_InteractiveObject)
+IMPLEMENT_STANDARD_RTTIEXT(ViewerTest_MarkersArrayObject, AIS_InteractiveObject)
+
+void ViewerTest_MarkersArrayObject::Compute (const Handle(PrsMgr_PresentationManager3d)& /*aPresentationManager*/,
+                              const Handle(Prs3d_Presentation)& aPresentation,
+                              const Standard_Integer /*aMode*/)
+{
+  Handle(Graphic3d_ArrayOfPrimitives) anArray = new Graphic3d_ArrayOfPoints ((Standard_Integer )Pow (myPointsOnSide, 3), myPointsOnSide != 1);
+  if (myPointsOnSide == 1)
+  {
+    anArray->AddVertex (myStartPoint);
+  }
+  else
+  {
+    for (Standard_Real i = 1; i <= myPointsOnSide; i++)
+    {
+      for (Standard_Real j = 1; j <= myPointsOnSide; j++)
+      {
+        for (Standard_Real k = 1; k <= myPointsOnSide; k++)
+        {
+          anArray->AddVertex (myStartPoint.X() + i, myStartPoint.Y() + j, myStartPoint.Z() + k);
+          anArray->SetVertexColor (anArray->VertexNumber(),
+                                   i / myPointsOnSide,
+                                   j / myPointsOnSide,
+                                   k / myPointsOnSide);
+        }
+      }
+    }
+  }
+
+  aPresentation->Clear();
+  if (!myMarkerAspect.IsNull())
+  {
+    Prs3d_Root::CurrentGroup (aPresentation)->SetGroupPrimitivesAspect (myMarkerAspect);
+  }
+  Prs3d_Root::CurrentGroup (aPresentation)->AddPrimitiveArray (anArray);
+}
+
+void ViewerTest_MarkersArrayObject::ComputeSelection (const Handle(SelectMgr_Selection)& theSelection,
+                                       const Standard_Integer /*theMode*/)
+{
+  Handle(SelectMgr_EntityOwner) anEntityOwner = new SelectMgr_EntityOwner (this);
+
+  if (myPointsOnSide == 1)
+  {
+    gp_Pnt aPoint (myStartPoint);
+    Handle(Select3D_SensitivePoint) aSensetivePoint = new Select3D_SensitivePoint (anEntityOwner, aPoint);
+    theSelection->Add (aSensetivePoint);
+  }
+  else
+  {
+    for (Standard_Real i = 1; i <= myPointsOnSide; i++)
+    {
+      for (Standard_Real j = 1; j <= myPointsOnSide; j++)
+      {
+        for (Standard_Real k = 1; k <= myPointsOnSide; k++)
+        {
+          gp_Pnt aPoint (myStartPoint.X() + i, myStartPoint.Y() + j, myStartPoint.Z() + k);
+          Handle(Select3D_SensitivePoint) aSensetivePoint = new Select3D_SensitivePoint (anEntityOwner, aPoint);
+          theSelection->Add (aSensetivePoint);
+        }
+      }
+    }
+  }
+}
 //=======================================================================
 //function : VMarkersTest
 //purpose  : Draws an array of markers for testing purposes.
@@ -4519,31 +4671,8 @@ static Standard_Integer VMarkersTest (Draw_Interpretor&,
     anAspect = new Graphic3d_AspectMarker3d (aMarkerType >= 0 ? (Aspect_TypeOfMarker )aMarkerType : Aspect_TOM_POINT, aColor, aScale);
   }
 
-  Handle(Graphic3d_ArrayOfPrimitives) anArray = new Graphic3d_ArrayOfPoints ((Standard_Integer )Pow (aPointsOnSide, 3), aPointsOnSide != 1);
-  if (aPointsOnSide == 1)
-  {
-    anArray->AddVertex (aPnt);
-  }
-  else
-  {
-    for (Standard_Real i = 1; i <= aPointsOnSide; i++)
-    {
-      for (Standard_Real j = 1; j <= aPointsOnSide; j++)
-      {
-        for (Standard_Real k = 1; k <= aPointsOnSide; k++)
-        {
-          anArray->AddVertex (aPnt.X() + i, aPnt.Y() + j, aPnt.Z() + k);
-          anArray->SetVertexColor (anArray->VertexNumber(),
-                                   i / aPointsOnSide,
-                                   j / aPointsOnSide,
-                                   k / aPointsOnSide);
-        }
-      }
-    }
-  }
-
-  Handle(MyPArrayObject) aPObject = new MyPArrayObject (anArray, anAspect);
-  VDisplayAISObject (aName, aPObject);
+  Handle(ViewerTest_MarkersArrayObject) aMarkersArray = new ViewerTest_MarkersArrayObject (aPnt, aPointsOnSide, anAspect);
+  VDisplayAISObject (aName, aMarkersArray);
 
   return 0;
 }