0026437: Visualization - Improve path tracing rendering engine
[occt.git] / src / ViewerTest / ViewerTest_ViewerCommands.cxx
index 63e4264..a3ebb4b 100644 (file)
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
-#ifdef HAVE_CONFIG_H
-  #include <config.h>
-#endif
-
 #include <OpenGl_GlCore20.hxx>
 #include <AIS_Shape.hxx>
-#include <AIS_Drawer.hxx>
 #include <AIS_InteractiveObject.hxx>
 #include <AIS_ListOfInteractive.hxx>
 #include <AIS_ListIteratorOfListOfInteractive.hxx>
 #include <Graphic3d_AspectMarker3d.hxx>
 #include <Graphic3d_ExportFormat.hxx>
 #include <Graphic3d_NameOfTextureEnv.hxx>
+#include <Graphic3d_GraduatedTrihedron.hxx>
 #include <Graphic3d_TextureEnv.hxx>
 #include <Graphic3d_TextureParams.hxx>
 #include <Graphic3d_TypeOfTextureFilter.hxx>
 #include <Graphic3d_AspectFillArea3d.hxx>
 #include <ViewerTest.hxx>
+#include <ViewerTest_AutoUpdater.hxx>
 #include <ViewerTest_EventManager.hxx>
 #include <ViewerTest_DoubleMapOfInteractiveAndName.hxx>
 #include <ViewerTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName.hxx>
 #include <Visual3d_View.hxx>
 #include <Visual3d_ViewManager.hxx>
 #include <V3d_AmbientLight.hxx>
+#include <V3d_ColorScale.hxx>
 #include <V3d_DirectionalLight.hxx>
 #include <V3d_LayerMgr.hxx>
 #include <V3d_LayerMgrPointer.hxx>
@@ -47,9 +45,6 @@
 #include <NCollection_DoubleMap.hxx>
 #include <NCollection_List.hxx>
 #include <NCollection_Vector.hxx>
-#include <NIS_View.hxx>
-#include <NIS_Triangulated.hxx>
-#include <NIS_InteractiveContext.hxx>
 #include <AIS_InteractiveContext.hxx>
 #include <Draw_Interpretor.hxx>
 #include <Draw.hxx>
@@ -75,6 +70,7 @@
 #include <NCollection_DataMap.hxx>
 #include <Graphic3d_Texture2Dmanual.hxx>
 #include <Prs3d_ShadingAspect.hxx>
+#include <Prs3d_Drawer.hxx>
 
 #ifdef WNT
 #undef DrawText
   #include <tk.h>
 #endif
 
+inline Standard_Boolean parseOnOff (Standard_CString  theArg,
+                                    Standard_Boolean& theIsOn)
+{
+  TCollection_AsciiString aFlag (theArg);
+  aFlag.LowerCase();
+  if (aFlag == "on"
+   || aFlag == "1")
+  {
+    theIsOn = Standard_True;
+    return Standard_True;
+  }
+  else if (aFlag == "off"
+        || aFlag == "0")
+  {
+    theIsOn = Standard_False;
+    return Standard_True;
+  }
+  return Standard_False;
+}
+
 // Auxiliary definitions
 static const char THE_KEY_DELETE = 127;
 
@@ -111,7 +127,6 @@ Standard_IMPORT Standard_Boolean Draw_VirtualWindows;
 Standard_IMPORT Standard_Boolean Draw_Interprete (const char* theCommand);
 
 Standard_EXPORT int ViewerMainLoop(Standard_Integer , const char** argv);
-extern const Handle(NIS_InteractiveContext)& TheNISContext();
 extern ViewerTest_DoubleMapOfInteractiveAndName& GetMapOfAIS();
 
 extern int VErase (Draw_Interpretor& theDI,
@@ -181,6 +196,14 @@ static OpenGl_Caps ViewerTest_myDefaultCaps;
 
 static void OSWindowSetup();
 
+static struct
+{
+  Quantity_Color FlatColor;
+  Quantity_Color GradientColor1;
+  Quantity_Color GradientColor2;
+  Aspect_GradientFillMethod FillMethod;
+} ViewerTest_DefaultBackground = { Quantity_NOC_BLACK, Quantity_NOC_BLACK, Quantity_NOC_BLACK, Aspect_GFM_NONE };
+
 //==============================================================================
 //  EVENT GLOBAL VARIABLES
 //==============================================================================
@@ -622,10 +645,10 @@ TCollection_AsciiString ViewerTest::ViewerInit (const Standard_Integer thePxLeft
     toCreateViewer = Standard_True;
     TCollection_ExtendedString NameOfWindow("Viewer3D");
     a3DViewer = new V3d_Viewer(aGraphicDriver, NameOfWindow.ToExtString());
-
-    NameOfWindow = TCollection_ExtendedString("Collector");
-
-    a3DViewer->SetDefaultBackgroundColor(Quantity_NOC_BLACK);
+    a3DViewer->SetDefaultBackgroundColor (ViewerTest_DefaultBackground.FlatColor);
+    a3DViewer->SetDefaultBgGradientColors (ViewerTest_DefaultBackground.GradientColor1,
+                                           ViewerTest_DefaultBackground.GradientColor2,
+                                           ViewerTest_DefaultBackground.FillMethod);
   }
 
   // AIS context setup
@@ -645,7 +668,7 @@ TCollection_AsciiString ViewerTest::ViewerInit (const Standard_Integer thePxLeft
 #if defined(_WIN32)
   VT_GetWindow() = new WNT_Window (aTitle.ToCString(),
                                     Handle(WNT_WClass)::DownCast (WClass()),
-                                    Draw_VirtualWindows ? WS_POPUPWINDOW : WS_OVERLAPPEDWINDOW,
+                                    Draw_VirtualWindows ? WS_POPUP : WS_OVERLAPPEDWINDOW,
                                     aPxLeft, aPxTop,
                                     aPxWidth, aPxHeight,
                                     Quantity_NOC_BLACK);
@@ -662,12 +685,12 @@ TCollection_AsciiString ViewerTest::ViewerInit (const Standard_Integer thePxLeft
 #endif
   VT_GetWindow()->SetVirtual (Draw_VirtualWindows);
 
-  // NIS setup
-  Handle(NIS_View) aView = new NIS_View (a3DViewer, VT_GetWindow());
+  // View setup
+  Handle(V3d_View) aView = a3DViewer->CreateView();
+  aView->SetWindow (VT_GetWindow());
 
   ViewerTest::CurrentView(aView);
   ViewerTest_myViews.Bind (aViewNames.GetViewName(), aView);
-  TheNISContext()->AttachView (aView);
 
   // Setup for X11 or NT
   OSWindowSetup();
@@ -874,7 +897,7 @@ static int VHLR (Draw_Interpretor& di, Standard_Integer argc, const char** argv)
         {
           continue;
         }
-        aShape->Redisplay();
+        ViewerTest::GetAISContext()->Redisplay (aShape, Standard_False);
       }
     }
   }
@@ -920,7 +943,7 @@ static int VHLRType (Draw_Interpretor& di, Standard_Integer argc, const char** a
       if (aShape->TypeOfHLR() != aTypeOfHLR)
         aShape->SetTypeOfHLR (aTypeOfHLR);
       if (MyHLRIsOn)
-        aShape->Redisplay();
+        ViewerTest::GetAISContext()->Redisplay (aShape, Standard_False);
     }
     ViewerTest::CurrentView()->Update();
     return 0;
@@ -943,7 +966,7 @@ static int VHLRType (Draw_Interpretor& di, Standard_Integer argc, const char** a
         continue;
       anAISObject->SetTypeOfHLR (aTypeOfHLR);
       if (MyHLRIsOn)
-        anAISObject->Redisplay();
+        ViewerTest::GetAISContext()->Redisplay (anAISObject, Standard_False);
     }
     ViewerTest::CurrentView()->Update();
   }
@@ -1077,7 +1100,6 @@ void ViewerTest::RemoveView (const TCollection_AsciiString& theViewName, const S
   Handle(AIS_InteractiveContext) aCurrentContext = FindContextByView(aView);
 
   // Remove view resources
-  TheNISContext()->DetachView(Handle(NIS_View)::DownCast(aView));
   ViewerTest_myViews.UnBind1(theViewName);
   aView->Remove();
 
@@ -1317,7 +1339,6 @@ void VT_ProcessKeyPress (const char* buf_ret)
 {
   //cout << "KeyPress" << endl;
   const Handle(V3d_View) aView = ViewerTest::CurrentView();
-  const Handle(NIS_View) aNisView = Handle(NIS_View)::DownCast (aView);
   // Letter in alphabetic order
 
   if (!strcasecmp (buf_ret, "A"))
@@ -1332,11 +1353,15 @@ void VT_ProcessKeyPress (const char* buf_ret)
   }
   else if (!strcasecmp (buf_ret, "F"))
   {
-    // FitAll
-    if (aNisView.IsNull())
-      aView->FitAll();
+    if (ViewerTest::GetAISContext()->NbSelected() > 0)
+    {
+      ViewerTest::GetAISContext()->FitSelected (aView);
+    }
     else
-      aNisView->FitAll3d();
+    {
+      // FitAll
+      aView->FitAll();
+    }
   }
   else if (!strcasecmp (buf_ret, "H"))
   {
@@ -1367,7 +1392,7 @@ void VT_ProcessKeyPress (const char* buf_ret)
           aShape->SetTypeOfHLR (Prs3d_TOH_Algo);
         else
           aShape->SetTypeOfHLR (Prs3d_TOH_PolyAlgo);
-        aShape->Redisplay();
+        aContext->Redisplay (aShape, Standard_False);
       }
     }
     else
@@ -1381,7 +1406,7 @@ void VT_ProcessKeyPress (const char* buf_ret)
           aShape->SetTypeOfHLR (Prs3d_TOH_Algo);
         else
           aShape->SetTypeOfHLR (Prs3d_TOH_PolyAlgo);
-        aShape->Redisplay();
+        aContext->Redisplay (aShape, Standard_False);
       }
     }
 
@@ -1495,6 +1520,24 @@ void VT_ProcessKeyPress (const char* buf_ret)
   {
     ViewerTest::GetAISContext()->HilightPreviousDetected(ViewerTest::CurrentView());
   }
+  else if (!strcasecmp (buf_ret, "/"))
+  {
+    Handle(Graphic3d_Camera) aCamera = aView->Camera();
+    if (aCamera->IsStereo())
+    {
+      aCamera->SetIOD (aCamera->GetIODType(), aCamera->IOD() - 0.01);
+      aView->Redraw();
+    }
+  }
+  else if (!strcasecmp (buf_ret, "*"))
+  {
+    Handle(Graphic3d_Camera) aCamera = aView->Camera();
+    if (aCamera->IsStereo())
+    {
+      aCamera->SetIOD (aCamera->GetIODType(), aCamera->IOD() + 0.01);
+      aView->Redraw();
+    }
+  }
   else if (*buf_ret == THE_KEY_DELETE)
   {
     Handle(AIS_InteractiveContext) aCtx = ViewerTest::GetAISContext();
@@ -1587,13 +1630,13 @@ void VT_ProcessButton1Release (Standard_Boolean theIsShift)
     Handle(ViewerTest_EventManager) EM = ViewerTest::CurrentEventManager();
     if (theIsShift)
     {
-      EM->ShiftSelect (Min (X_ButtonPress, X_Motion), Max (Y_ButtonPress, Y_Motion),
-                       Max (X_ButtonPress, X_Motion), Min (Y_ButtonPress, Y_Motion));
+      EM->ShiftSelect (X_ButtonPress, Y_ButtonPress,
+                       X_Motion, Y_Motion);
     }
     else
     {
-      EM->Select (Min (X_ButtonPress, X_Motion), Max (Y_ButtonPress, Y_Motion),
-                  Max (X_ButtonPress, X_Motion), Min (Y_ButtonPress, Y_Motion));
+      EM->Select (X_ButtonPress, Y_ButtonPress,
+                  X_Motion, Y_Motion);
     }
   }
 }
@@ -1637,29 +1680,24 @@ void ProcessZClipMotion()
 {
   Handle(V3d_View)  a3DView = ViewerTest::CurrentView();
   if ( Abs(X_Motion - X_ButtonPress) > 2 ) {
-    static Standard_Real CurZPos = 0.;
 
     //Quantity_Length VDX, VDY;
     //a3DView->Size(VDX,VDY);
     //Standard_Real VDZ = a3DView->ZSize();
     //printf("View size (%lf,%lf,%lf)\n", VDX, VDY, VDZ);
 
-    Quantity_Length dx = a3DView->Convert(X_Motion - X_ButtonPress);
+    Quantity_Length aDx = a3DView->Convert(X_Motion - X_ButtonPress);
 
     // Front = Depth + width/2.
-    Standard_Real D = 0.5;
-    Standard_Real W = 0.1;
-
-    CurZPos += (dx);
+    Standard_Real aDepth = 0.5;
+    Standard_Real aWidth = 0.1;
+    a3DView->ZClipping(aDepth,aWidth);
 
-    D += CurZPos;
+    aDepth += aDx;
 
     //printf("dx %lf Depth %lf Width %lf\n", dx, D, W);
 
-    a3DView->SetZClippingType(V3d_OFF);
-    a3DView->SetZClippingDepth(D);
-    a3DView->SetZClippingWidth(W);
-    a3DView->SetZClippingType(V3d_FRONT);
+    a3DView->SetZClippingDepth(aDepth);
 
     a3DView->Redraw();
 
@@ -1971,8 +2009,12 @@ static LRESULT WINAPI ViewerWindowProc( HWND hwnd,
                                        LPARAM lParam )
 {
   static int Up = 1;
+  const Handle(V3d_View)& aView = ViewerTest::CurrentView();
+  if (aView.IsNull())
+  {
+    return DefWindowProc( hwnd, Msg, wParam, lParam );
+  }
 
-  if ( !ViewerTest::CurrentView().IsNull() ) {
     PAINTSTRUCT    ps;
 
     switch( Msg ) {
@@ -1985,6 +2027,20 @@ static LRESULT WINAPI ViewerWindowProc( HWND hwnd,
     case WM_SIZE:
       VT_ProcessConfigure();
       break;
+    case WM_MOVE:
+    case WM_MOVING:
+    case WM_SIZING:
+      switch (aView->RenderingParams().StereoMode)
+      {
+        case Graphic3d_StereoMode_RowInterlaced:
+        case Graphic3d_StereoMode_ColumnInterlaced:
+        case Graphic3d_StereoMode_ChessBoard:
+          VT_ProcessConfigure(); // track window moves to reverse stereo pair
+          break;
+        default:
+          break;
+      }
+      break;
 
     case WM_KEYDOWN:
       if ((wParam != VK_SHIFT) && (wParam != VK_CONTROL))
@@ -1996,6 +2052,25 @@ static LRESULT WINAPI ViewerWindowProc( HWND hwnd,
         {
           c[0] = THE_KEY_DELETE;
         }
+        // comma
+        else if (wParam == VK_OEM_COMMA)
+        {
+          c[0] = ',';
+        }
+        // dot
+        else if (wParam == VK_OEM_PERIOD)
+        {
+          c[0] = '.';
+        }
+        else if (wParam == VK_DIVIDE)
+        {
+          c[0] = '/';
+        }
+        // dot
+        else if (wParam == VK_MULTIPLY)
+        {
+          c[0] = '*';
+        }
         VT_ProcessKeyPress (c);
       }
       break;
@@ -2037,6 +2112,29 @@ static LRESULT WINAPI ViewerWindowProc( HWND hwnd,
       }
       break;
 
+    case WM_MOUSEWHEEL:
+    {
+      int aDelta = GET_WHEEL_DELTA_WPARAM (wParam);
+      if (wParam & MK_CONTROL)
+      {
+        if (aView->Camera()->IsStereo())
+        {
+          Standard_Real aFocus = aView->Camera()->ZFocus() + (aDelta > 0 ? 0.05 : -0.05);
+          if (aFocus > 0.2
+           && aFocus < 2.0)
+          {
+            aView->Camera()->SetZFocus (aView->Camera()->ZFocusType(), aFocus);
+            aView->Redraw();
+          }
+        }
+      }
+      else
+      {
+        aView->Zoom (0, 0, aDelta / 40, aDelta / 40);
+      }
+      break;
+    }
+
     case WM_MOUSEMOVE:
       {
         //cout << "\t WM_MOUSEMOVE" << endl;
@@ -2098,9 +2196,6 @@ static LRESULT WINAPI ViewerWindowProc( HWND hwnd,
       return( DefWindowProc( hwnd, Msg, wParam, lParam ));
     }
     return 0L;
-  }
-
-  return DefWindowProc( hwnd, Msg, wParam, lParam );
 }
 
 
@@ -2443,7 +2538,6 @@ static void OSWindowSetup()
 
 }
 
-
 //==============================================================================
 //function : VFit
 
@@ -2451,18 +2545,94 @@ static void OSWindowSetup()
 //Draw arg : No args
 //==============================================================================
 
-static int VFit(Draw_Interpretor& , Standard_Integer , const char** )
+static int VFit (Draw_Interpretor& /*theDi*/, Standard_Integer theArgc, const char** theArgv)
 {
+  if (theArgc > 2)
+  {
+    std::cout << "Wrong number of arguments! Use: vfit [-selected]" << std::endl;
+  }
+
   const Handle(V3d_View) aView = ViewerTest::CurrentView();
-  Handle(NIS_View) V = Handle(NIS_View)::DownCast(aView);
-  if (V.IsNull() == Standard_False) {
-    V->FitAll3d();
-  } else if (aView.IsNull() == Standard_False) {
+
+  if (theArgc == 2)
+  {
+    TCollection_AsciiString anArg (theArgv[1]);
+    anArg.LowerCase();
+    if (anArg == "-selected")
+    {
+      ViewerTest::GetAISContext()->FitSelected (aView);
+      return 0;
+    }
+  }
+  if (aView.IsNull() == Standard_False) {
+
     aView->FitAll();
   }
   return 0;
 }
 
+//=======================================================================
+//function : VFitArea
+//purpose  : Fit view to show area located between two points
+//         : given in world 2D or 3D coordinates.
+//=======================================================================
+static int VFitArea (Draw_Interpretor& theDI, Standard_Integer  theArgNb, const char** theArgVec)
+{
+  Handle(V3d_View) aView = ViewerTest::CurrentView();
+  if (aView.IsNull())
+  {
+    std::cerr << theArgVec[0] << "Error: No active view.\n";
+    return 1;
+  }
+
+  // Parse arguments.
+  gp_Pnt aWorldPnt1 (0.0, 0.0, 0.0);
+  gp_Pnt aWorldPnt2 (0.0, 0.0, 0.0);
+
+  if (theArgNb == 5)
+  {
+    aWorldPnt1.SetX (Draw::Atof (theArgVec[1]));
+    aWorldPnt1.SetY (Draw::Atof (theArgVec[2]));
+    aWorldPnt2.SetX (Draw::Atof (theArgVec[3]));
+    aWorldPnt2.SetY (Draw::Atof (theArgVec[4]));
+  }
+  else if (theArgNb == 7)
+  {
+    aWorldPnt1.SetX (Draw::Atof (theArgVec[1]));
+    aWorldPnt1.SetY (Draw::Atof (theArgVec[2]));
+    aWorldPnt1.SetZ (Draw::Atof (theArgVec[3]));
+    aWorldPnt2.SetX (Draw::Atof (theArgVec[4]));
+    aWorldPnt2.SetY (Draw::Atof (theArgVec[5]));
+    aWorldPnt2.SetZ (Draw::Atof (theArgVec[6]));
+  }
+  else
+  {
+    std::cerr << theArgVec[0] << "Error: Invalid number of arguments.\n";
+    theDI.PrintHelp(theArgVec[0]);
+    return 1;
+  }
+
+  // Convert model coordinates to view space
+  Handle(Graphic3d_Camera) aCamera = aView->Camera();
+  gp_Pnt aViewPnt1 = aCamera->ConvertWorld2View (aWorldPnt1);
+  gp_Pnt aViewPnt2 = aCamera->ConvertWorld2View (aWorldPnt2);
+
+  // Determine fit area
+  gp_Pnt2d aMinCorner (Min (aViewPnt1.X(), aViewPnt2.X()), Min (aViewPnt1.Y(), aViewPnt2.Y()));
+  gp_Pnt2d aMaxCorner (Max (aViewPnt1.X(), aViewPnt2.X()), Max (aViewPnt1.Y(), aViewPnt2.Y()));
+
+  Standard_Real aDiagonal = aMinCorner.Distance (aMaxCorner);
+
+  if (aDiagonal < Precision::Confusion())
+  {
+    std::cerr << theArgVec[0] << "Error: view area is too small.\n";
+    return 1;
+  }
+
+  aView->FitAll (aMinCorner.X(), aMinCorner.Y(), aMaxCorner.X(), aMaxCorner.Y());
+  return 0;
+}
+
 //==============================================================================
 //function : VZFit
 //purpose  : ZFitall, no DRAW arguments
@@ -2480,7 +2650,7 @@ static int VZFit (Draw_Interpretor& /*theDi*/, Standard_Integer theArgsNb, const
 
   if (theArgsNb == 1)
   {
-    aCurrentView->ZFitAll();
+    aCurrentView->View()->ZFitAll();
     aCurrentView->Redraw();
     return 0;
   }
@@ -2492,7 +2662,7 @@ static int VZFit (Draw_Interpretor& /*theDi*/, Standard_Integer theArgsNb, const
     aScale = Draw::Atoi (theArgVec[1]);
   }
 
-  aCurrentView->ZFitAll (aScale);
+  aCurrentView->View()->ZFitAll (aScale);
   aCurrentView->Redraw();
 
   return 0;
@@ -2749,6 +2919,57 @@ static int VSetColorBg(Draw_Interpretor& di, Standard_Integer argc, const char**
 }
 
 //==============================================================================
+//function : VSetDefaultBg
+//purpose  : Set default viewer background fill color
+//==============================================================================
+static int VSetDefaultBg (Draw_Interpretor& theDI, Standard_Integer theArgNb, const char** theArgVec)
+{
+  if (theArgNb != 4
+   && theArgNb != 8)
+  {
+    std::cout << "Error: wrong syntax! See usage:\n";
+    theDI.PrintHelp (theArgVec[0]);
+    return 1;
+  }
+
+  ViewerTest_DefaultBackground.FillMethod =
+    theArgNb == 4 ? Aspect_GFM_NONE
+                  : (Aspect_GradientFillMethod) Draw::Atoi (theArgVec[7]);
+
+  if (theArgNb == 4)
+  {
+    Standard_Real R = Draw::Atof (theArgVec[1]) / 255.;
+    Standard_Real G = Draw::Atof (theArgVec[2]) / 255.;
+    Standard_Real B = Draw::Atof (theArgVec[3]) / 255.;
+    ViewerTest_DefaultBackground.FlatColor.SetValues (R, G, B, Quantity_TOC_RGB);
+  }
+  else
+  {
+    Standard_Real R1 = Draw::Atof (theArgVec[1]) / 255.;
+    Standard_Real G1 = Draw::Atof (theArgVec[2]) / 255.;
+    Standard_Real B1 = Draw::Atof (theArgVec[3]) / 255.;
+    ViewerTest_DefaultBackground.GradientColor1.SetValues (R1, G1, B1, Quantity_TOC_RGB);
+
+    Standard_Real R2 = Draw::Atof (theArgVec[4]) / 255.;
+    Standard_Real G2 = Draw::Atof (theArgVec[5]) / 255.;
+    Standard_Real B2 = Draw::Atof (theArgVec[6]) / 255.;
+    ViewerTest_DefaultBackground.GradientColor2.SetValues (R2, G2, B2, Quantity_TOC_RGB);
+  }
+
+  for (NCollection_DoubleMap<TCollection_AsciiString, Handle(AIS_InteractiveContext)>::Iterator
+       anIter (ViewerTest_myContexts); anIter.More(); anIter.Next())
+  {
+    const Handle(V3d_Viewer)& aViewer = anIter.Value()->CurrentViewer();
+    aViewer->SetDefaultBackgroundColor (ViewerTest_DefaultBackground.FlatColor);
+    aViewer->SetDefaultBgGradientColors (ViewerTest_DefaultBackground.GradientColor1,
+                                         ViewerTest_DefaultBackground.GradientColor2,
+                                         ViewerTest_DefaultBackground.FillMethod);
+  }
+
+  return 0;
+}
+
+//==============================================================================
 //function : VScale
 //purpose  : View Scaling
 //==============================================================================
@@ -2766,93 +2987,228 @@ static int VScale(Draw_Interpretor& di, Standard_Integer argc, const char** argv
   return 0;
 }
 //==============================================================================
-//function : VTestZBuffTrihedron
-//purpose  : Displays a V3d_ZBUFFER'ed or V3d_WIREFRAME'd trihedron
+//function : VZBuffTrihedron
+//purpose  :
 //==============================================================================
 
-static int VTestZBuffTrihedron(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
+static int VZBuffTrihedron (Draw_Interpretor& /*theDI*/,
+                            Standard_Integer  theArgNb,
+                            const char**      theArgVec)
 {
-  Handle(V3d_View) V3dView = ViewerTest::CurrentView();
-  if ( V3dView.IsNull() ) return 1;
+  Handle(V3d_View) aView = ViewerTest::CurrentView();
+  if (aView.IsNull())
+  {
+    std::cout << "Error: no active viewer!\n";
+    return 1;
+  }
 
-  V3dView->ZBufferTriedronSetup();
+  ViewerTest_AutoUpdater anUpdateTool (ViewerTest::GetAISContext(), aView);
 
-  if ( argc == 1 ) {
-    // Set up default trihedron parameters
-    V3dView->TriedronDisplay( Aspect_TOTP_LEFT_LOWER, Quantity_NOC_WHITE, 0.1, V3d_ZBUFFER );
-  } else
-  if ( argc == 7 )
+  Aspect_TypeOfTriedronPosition aPosition     = Aspect_TOTP_LEFT_LOWER;
+  V3d_TypeOfVisualization       aVisType      = V3d_ZBUFFER;
+  Quantity_Color                aLabelsColor  = Quantity_NOC_WHITE;
+  Quantity_Color                anArrowColorX = Quantity_NOC_RED;
+  Quantity_Color                anArrowColorY = Quantity_NOC_GREEN;
+  Quantity_Color                anArrowColorZ = Quantity_NOC_BLUE1;
+  Standard_Real                 aScale        = 0.1;
+  Standard_Real                 aSizeRatio    = 0.8;
+  Standard_Real                 anArrowDiam   = 0.05;
+  Standard_Integer              aNbFacets     = 12;
+  for (Standard_Integer anArgIter = 1; anArgIter < theArgNb; ++anArgIter)
   {
-    Aspect_TypeOfTriedronPosition aPosition = Aspect_TOTP_LEFT_LOWER;
-    const char* aPosType = argv[1];
-
-    if ( strcmp(aPosType, "center") == 0 )
+    Standard_CString        anArg = theArgVec[anArgIter];
+    TCollection_AsciiString aFlag (anArg);
+    aFlag.LowerCase();
+    if (anUpdateTool.parseRedrawMode (aFlag))
     {
-      aPosition = Aspect_TOTP_CENTER;
-    } else
-    if (strcmp(aPosType, "left_lower") == 0)
+      continue;
+    }
+    else if (aFlag == "-on")
     {
-      aPosition = Aspect_TOTP_LEFT_LOWER;
-    } else
-    if (strcmp(aPosType, "left_upper") == 0)
+      continue;
+    }
+    else if (aFlag == "-off")
     {
-      aPosition = Aspect_TOTP_LEFT_UPPER;
-    } else
-    if (strcmp(aPosType, "right_lower") == 0)
+      aView->TriedronErase();
+      return 0;
+    }
+    else if (aFlag == "-pos"
+          || aFlag == "-position"
+          || aFlag == "-corner")
     {
-      aPosition = Aspect_TOTP_RIGHT_LOWER;
-    } else
-    if (strcmp(aPosType, "right_upper") == 0)
+      if (++anArgIter >= theArgNb)
+      {
+        std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+        return 1;
+      }
+
+      TCollection_AsciiString aPosName (theArgVec[anArgIter]);
+      aPosName.LowerCase();
+      if (aPosName == "center")
+      {
+        aPosition = Aspect_TOTP_CENTER;
+      }
+      else if (aPosName == "left_lower"
+            || aPosName == "lower_left"
+            || aPosName == "leftlower"
+            || aPosName == "lowerleft")
+      {
+        aPosition = Aspect_TOTP_LEFT_LOWER;
+      }
+      else if (aPosName == "left_upper"
+            || aPosName == "upper_left"
+            || aPosName == "leftupper"
+            || aPosName == "upperleft")
+      {
+        aPosition = Aspect_TOTP_LEFT_UPPER;
+      }
+      else if (aPosName == "right_lower"
+            || aPosName == "lower_right"
+            || aPosName == "rightlower"
+            || aPosName == "lowerright")
+      {
+        aPosition = Aspect_TOTP_RIGHT_LOWER;
+      }
+      else if (aPosName == "right_upper"
+            || aPosName == "upper_right"
+            || aPosName == "rightupper"
+            || aPosName == "upperright")
+      {
+        aPosition = Aspect_TOTP_RIGHT_UPPER;
+      }
+      else
+      {
+        std::cerr << "Error: wrong syntax at '" << anArg << "' - unknown position '" << aPosName << "'\n";
+        return 1;
+      }
+    }
+    else if (aFlag == "-type")
     {
-      aPosition = Aspect_TOTP_RIGHT_UPPER;
-    } else
+      if (++anArgIter >= theArgNb)
+      {
+        std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+        return 1;
+      }
+
+      TCollection_AsciiString aTypeName (theArgVec[anArgIter]);
+      aTypeName.LowerCase();
+      if (aTypeName == "wireframe"
+       || aTypeName == "wire")
+      {
+        aVisType = V3d_WIREFRAME;
+      }
+      else if (aTypeName == "zbuffer"
+            || aTypeName == "shaded")
+      {
+        aVisType = V3d_ZBUFFER;
+      }
+      else
+      {
+        std::cerr << "Error: wrong syntax at '" << anArg << "' - unknown type '" << aTypeName << "'\n";
+      }
+    }
+    else if (aFlag == "-scale")
     {
-      di << argv[1] << " Invalid type of alignment"  << "\n";
-      di << "Must be one of [ center, left_lower,"   << "\n";
-      di << "left_upper, right_lower, right_upper ]" << "\n";
-      return 1;
+      if (++anArgIter >= theArgNb)
+      {
+        std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+        return 1;
+      }
+
+      aScale = Draw::Atof (theArgVec[anArgIter]);
     }
+    else if (aFlag == "-size"
+          || aFlag == "-sizeratio")
+    {
+      if (++anArgIter >= theArgNb)
+      {
+        std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+        return 1;
+      }
 
-    Standard_Real R = Draw::Atof(argv[2])/255.;
-    Standard_Real G = Draw::Atof(argv[3])/255.;
-    Standard_Real B = Draw::Atof(argv[4])/255.;
-    Quantity_Color aColor(R, G, B, Quantity_TOC_RGB);
+      aSizeRatio = Draw::Atof (theArgVec[anArgIter]);
+    }
+    else if (aFlag == "-arrowdiam"
+          || aFlag == "-arrowdiameter")
+    {
+      if (++anArgIter >= theArgNb)
+      {
+        std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+        return 1;
+      }
 
-    Standard_Real aScale = Draw::Atof(argv[5]);
+      anArrowDiam = Draw::Atof (theArgVec[anArgIter]);
+    }
+    else if (aFlag == "-nbfacets")
+    {
+      if (++anArgIter >= theArgNb)
+      {
+        std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+        return 1;
+      }
 
-    if( aScale <= 0.0 )
+      aNbFacets = Draw::Atoi (theArgVec[anArgIter]);
+    }
+    else if (aFlag == "-colorlabel"
+          || aFlag == "-colorlabels")
     {
-      di << argv[5] << " Invalid value. Must be > 0" << "\n";
-      return 1;
+      Standard_Integer aNbParsed = ViewerTest::ParseColor (theArgNb  - anArgIter - 1,
+                                                           theArgVec + anArgIter + 1,
+                                                           aLabelsColor);
+      if (aNbParsed == 0)
+      {
+        std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+        return 1;
+      }
+      anArgIter += aNbParsed;
     }
-
-    V3d_TypeOfVisualization aPresentation = V3d_ZBUFFER;
-    const char* aPresType = argv[6];
-
-    if ( strcmp(aPresType, "wireframe") == 0 )
+    else if (aFlag == "-colorarrowx")
+    {
+      Standard_Integer aNbParsed = ViewerTest::ParseColor (theArgNb  - anArgIter - 1,
+                                                           theArgVec + anArgIter + 1,
+                                                           anArrowColorX);
+      if (aNbParsed == 0)
+      {
+        std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+        return 1;
+      }
+      anArgIter += aNbParsed;
+    }
+    else if (aFlag == "-colorarrowy")
     {
-      aPresentation = V3d_WIREFRAME;
-    } else
-    if (strcmp(aPresType, "zbuffer") == 0)
+      Standard_Integer aNbParsed = ViewerTest::ParseColor (theArgNb  - anArgIter - 1,
+                                                           theArgVec + anArgIter + 1,
+                                                           anArrowColorY);
+      if (aNbParsed == 0)
+      {
+        std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+        return 1;
+      }
+      anArgIter += aNbParsed;
+    }
+    else if (aFlag == "-colorarrowz")
     {
-      aPresentation = V3d_ZBUFFER;
-    } else
+      Standard_Integer aNbParsed = ViewerTest::ParseColor (theArgNb  - anArgIter - 1,
+                                                           theArgVec + anArgIter + 1,
+                                                           anArrowColorZ);
+      if (aNbParsed == 0)
+      {
+        std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
+        return 1;
+      }
+      anArgIter += aNbParsed;
+    }
+    else
     {
-      di << argv[6] << " Invalid type of visualization" << "\n";
-      di << "Must be one of [ wireframe, zbuffer ]"     << "\n";
+      std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
       return 1;
     }
-
-    V3dView->TriedronDisplay( aPosition, aColor.Name(), aScale, aPresentation );
-
-  } else
-  {
-    di << argv[0] << " Invalid number of arguments" << "\n";
-    return 1;
   }
 
-  V3dView->ZFitAll();
-
+  aView->ZBufferTriedronSetup (anArrowColorX.Name(), anArrowColorY.Name(), anArrowColorZ.Name(),
+                               aSizeRatio, anArrowDiam, aNbFacets);
+  aView->TriedronDisplay (aPosition, aLabelsColor.Name(), aScale, aVisType);
+  aView->View()->ZFitAll();
   return 0;
 }
 
@@ -2861,26 +3217,88 @@ static int VTestZBuffTrihedron(Draw_Interpretor& di, Standard_Integer argc, cons
 //purpose  : Camera Rotating
 //==============================================================================
 
-static int VRotate( Draw_Interpretor& di, Standard_Integer argc, const char** argv ) {
-  Handle(V3d_View) V3dView = ViewerTest::CurrentView();
-  if ( V3dView.IsNull() ) {
+static int VRotate (Draw_Interpretor& /*theDi*/, Standard_Integer theArgNb, const char** theArgVec)
+{
+  Handle(V3d_View) aView = ViewerTest::CurrentView();
+  if (aView.IsNull())
+  {
+    std::cout << "No active view!\n";
     return 1;
   }
 
-  if ( argc == 4 ) {
-    V3dView->Rotate( Draw::Atof(argv[1]), Draw::Atof(argv[2]), Draw::Atof(argv[3]) );
-    return 0;
-  } else if ( argc == 7 ) {
-    V3dView->Rotate( Draw::Atof(argv[1]), Draw::Atof(argv[2]), Draw::Atof(argv[3]), Draw::Atof(argv[4]), Draw::Atof(argv[5]), Draw::Atof(argv[6]) );
-    return 0;
-  } else {
-    di << argv[0] << " Invalid number of arguments" << "\n";
-    return 1;
-  }
-}
+  Standard_Boolean hasFlags = Standard_False;
+  for (Standard_Integer anArgIter = 1; anArgIter < theArgNb; ++anArgIter)
+  {
+    Standard_CString        anArg (theArgVec[anArgIter]);
+    TCollection_AsciiString aFlag (anArg);
+    aFlag.LowerCase();
+    if (aFlag == "-mousestart"
+     || aFlag == "-mousefrom")
+    {
+      hasFlags = Standard_True;
+      if (anArgIter + 2 >= theArgNb)
+      {
+        std::cout << "Error: wrong syntax at '" << anArg << "'\n";
+        return 1;
+      }
 
-//==============================================================================
-//function : VZoom
+      Standard_Integer anX = Draw::Atoi (theArgVec[++anArgIter]);
+      Standard_Integer anY = Draw::Atoi (theArgVec[++anArgIter]);
+      aView->StartRotation (anX, anY);
+    }
+    else if (aFlag == "-mousemove")
+    {
+      hasFlags = Standard_True;
+      if (anArgIter + 2 >= theArgNb)
+      {
+        std::cout << "Error: wrong syntax at '" << anArg << "'\n";
+        return 1;
+      }
+
+      Standard_Integer anX = Draw::Atoi (theArgVec[++anArgIter]);
+      Standard_Integer anY = Draw::Atoi (theArgVec[++anArgIter]);
+      aView->Rotation (anX, anY);
+    }
+    else if (theArgNb != 4
+          && theArgNb != 7)
+    {
+      std::cout << "Error: wrong syntax at '" << anArg << "'\n";
+      return 1;
+    }
+  }
+
+  if (hasFlags)
+  {
+    return 0;
+  }
+  else if (theArgNb == 4)
+  {
+    Standard_Real anAX = Draw::Atof (theArgVec[1]);
+    Standard_Real anAY = Draw::Atof (theArgVec[2]);
+    Standard_Real anAZ = Draw::Atof (theArgVec[3]);
+    aView->Rotate (anAX, anAY, anAZ);
+    return 0;
+  }
+  else if (theArgNb == 7)
+  {
+    Standard_Real anAX = Draw::Atof (theArgVec[1]);
+    Standard_Real anAY = Draw::Atof (theArgVec[2]);
+    Standard_Real anAZ = Draw::Atof (theArgVec[3]);
+
+    Standard_Real anX = Draw::Atof (theArgVec[4]);
+    Standard_Real anY = Draw::Atof (theArgVec[5]);
+    Standard_Real anZ = Draw::Atof (theArgVec[6]);
+
+    aView->Rotate (anAX, anAY, anAZ, anX, anY, anZ);
+    return 0;
+  }
+
+  std::cout << "Error: Invalid number of arguments\n";
+  return 1;
+}
+
+//==============================================================================
+//function : VZoom
 //purpose  : View zoom in / out (relative to current zoom)
 //==============================================================================
 
@@ -2922,6 +3340,29 @@ static int VPan( Draw_Interpretor& di, Standard_Integer argc, const char** argv
   }
 }
 
+//==============================================================================
+//function : VPlace
+//purpose  : Place the point (in pixels) at the center of the window
+//==============================================================================
+static int VPlace (Draw_Interpretor& /*theDi*/, Standard_Integer theArgNb, const char** theArgs)
+{
+  Handle(V3d_View) aView = ViewerTest::CurrentView();
+  if (aView.IsNull())
+  {
+    std::cerr << theArgs[0] << "Error: no active view." << std::endl;
+    return 1;
+  }
+
+  if (theArgNb != 3)
+  {
+    std::cerr << theArgs[0] << "Error: invalid number of arguments." << std::endl;
+    return 1;
+  }
+
+  aView->Place (Draw::Atoi (theArgs[1]), Draw::Atoi (theArgs[2]), aView->Scale());
+
+  return 0;
+}
 
 //==============================================================================
 //function : VExport
@@ -3011,165 +3452,798 @@ static int VExport(Draw_Interpretor& di, Standard_Integer argc, const char** arg
 //function : VColorScale
 //purpose  : representation color scale
 //==============================================================================
-#include <V3d_ColorScale.hxx>
 
-static int VColorScale (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
+static Standard_Boolean checkColor (const TCollection_AsciiString& theRed,
+                                    const TCollection_AsciiString& theGreen,
+                                    const TCollection_AsciiString& theBlue,
+                                                    Standard_Real& theRedValue,
+                                                    Standard_Real& theGreenValue,
+                                                    Standard_Real& theBlueValue)
+{
+  if (!theRed.IsRealValue()
+   || !theGreen.IsRealValue()
+   || !theBlue.IsRealValue())
+  {
+    std::cout << "Error: RGB color values should be real!\n";
+    return Standard_True;
+  }
+  theRedValue = theRed    .RealValue();
+  theGreenValue = theGreen.RealValue();
+  theBlueValue = theBlue  .RealValue();
+  if (theRedValue < 0.0 || theRedValue > 1.0
+   || theGreenValue < 0.0 || theGreenValue > 1.0
+   || theBlueValue < 0.0 || theBlueValue > 1.0)
+  {
+    std::cout << "Error: RGB color values should be within range 0..1!\n";
+    return Standard_True;
+  }
+  return Standard_False;
+}
+
+static int VColorScale (Draw_Interpretor& theDI,
+                        Standard_Integer  theArgNb,
+                        const char**      theArgVec)
+{
+  Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
+  Handle(V3d_View)               aView    = ViewerTest::CurrentView();
+  if (aContext.IsNull())
+  {
+    std::cout << "Error: no active view!\n";
+    return 1;
+  }
+
+  Handle(V3d_ColorScale) aCS = Handle(V3d_ColorScale)::DownCast (aView->ColorScale());
+  if (aCS.IsNull())
+  {
+    std::cout << "Error: color scale is undefined!\n";
+    return 1;
+  }
+
+  Standard_Real                   aMinRange    = aCS->GetMin();
+  Standard_Real                   aMaxRange    = aCS->GetMax();
+  Standard_Integer                aNbIntervals = aCS->GetNumberOfIntervals();
+  Standard_Integer                aTextHeight  = aCS->GetTextHeight();
+  Aspect_TypeOfColorScalePosition aLabPosition = aCS->GetLabelPosition();
+  gp_XY                           aPos (aCS->GetXPosition(), aCS->GetYPosition());
+
+  ViewerTest_AutoUpdater anUpdateTool (aContext, aView);
+
+  if (theArgNb <= 1)
+  {
+    theDI << "Current color scale parameters:\n"
+          << "Min range: " << aMinRange << "\n"
+          << "Max range: " << aMaxRange << "\n"
+          << "Number of intervals: " << aNbIntervals << "\n"
+          << "Text height: " << aTextHeight << "\n"
+          << "Color scale position: " << aPos.X() <<" "<< aPos.Y()<< "\n"
+          << "Color scale title: " << aCS->GetTitle() << "\n"
+          << "Label position: ";
+    switch (aLabPosition)
+    {
+      case Aspect_TOCSP_NONE:
+        theDI << "None\n";
+        break;
+      case Aspect_TOCSP_LEFT:
+        theDI << "Left\n";
+        break;
+      case Aspect_TOCSP_RIGHT:
+        theDI << "Right\n";
+        break;
+      case Aspect_TOCSP_CENTER:
+        theDI << "Center\n";
+        break;
+    }
+    return 0;
+  }
+  Standard_CString        aFirstArg = theArgVec[1];
+  TCollection_AsciiString aFlag (aFirstArg);
+  aFlag.LowerCase();
+  if (aFlag == "-hide" ||
+      aFlag == "-erase")
+  {
+    if (theArgNb > 2)
+    {
+      std::cout << "Error: wrong syntax at argument '" << theArgVec[1] << "'!\n";
+      return 1;
+    }
+    if (!aView->ColorScaleIsDisplayed())
+    {
+      std::cout << "Error: color scale is not displayed!\n";
+      return 1;
+   }
+    else
+    {
+      aView->ColorScaleErase();
+      return 0;
+    }
+  }
+  else if (aFlag == "-show" ||
+           aFlag == "-display")
+  {
+    if (theArgNb > 2)
+    {
+      std::cout << "Error: wrong syntax at argument '" << theArgVec[1] << "'!\n";
+      return 1;
+    }
+    aView->ColorScaleDisplay();
+    return 0;
+  }
+
+  for (Standard_Integer anArgIter = 1; anArgIter < theArgNb; ++anArgIter)
+  {
+    Standard_CString        anArg = theArgVec[anArgIter];
+    TCollection_AsciiString aFlag (anArg);
+    aFlag.LowerCase();
+    if (anUpdateTool.parseRedrawMode (aFlag))
+    {
+      continue;
+    }
+    else if (aFlag == "-range")
+    {
+      if (anArgIter + 3 >= theArgNb)
+      {
+        std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+        return 1;
+      }
+
+      TCollection_AsciiString anArg1 (theArgVec[++anArgIter]);
+      TCollection_AsciiString anArg2 (theArgVec[++anArgIter]);
+      TCollection_AsciiString anArg3 (theArgVec[++anArgIter]);
+      if (!anArg1.IsRealValue())
+      {
+        std::cout << "Error: the minRange value should be real!\n";
+        return 1;
+      }
+      else if (!anArg2.IsRealValue())
+      {
+        std::cout << "Error: the maxRange value should be real!\n";
+        return 1;
+      }
+      else if (!anArg3.IsIntegerValue())
+      {
+        std::cout << "Error: the number of intervals should be integer!\n";
+        return 1;
+      }
+
+      aMinRange    = anArg1.RealValue();
+      aMaxRange    = anArg2.RealValue();
+      aNbIntervals = anArg3.IntegerValue();
+    }
+    else if (aFlag == "-font")
+    {
+      if (anArgIter + 1 >= theArgNb)
+      {
+        std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+        return 1;
+      }
+      TCollection_AsciiString anArg (theArgVec[anArgIter + 1]);
+      if (!anArg.IsIntegerValue())
+      {
+        std::cout << "Error: HeightFont value should be integer!\n";
+        return 1;
+      }
+
+      aTextHeight = anArg.IntegerValue();
+      anArgIter += 1;
+    }
+    else if (aFlag == "-textpos")
+    {
+      if (anArgIter + 1 >= theArgNb)
+      {
+        std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+        return 1;
+      }
+      TCollection_AsciiString anArg (theArgVec[++anArgIter]);
+      anArg.LowerCase();
+      if (anArg == "none")
+      {
+        aLabPosition = Aspect_TOCSP_NONE;
+      }
+      else if (anArg == "left")
+      {
+        aLabPosition = Aspect_TOCSP_LEFT;
+      }
+      else if (anArg == "right")
+      {
+        aLabPosition = Aspect_TOCSP_RIGHT;
+      }
+      else if (anArg == "center")
+      {
+        aLabPosition = Aspect_TOCSP_CENTER;
+      }
+      else
+      {
+        std::cout << "Error: unknown position '" << anArg << "'!\n";
+        return 1;
+      }
+    }
+    else if (aFlag == "-xy")
+    {
+      if (anArgIter + 2 >= theArgNb)
+      {
+        std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+        return 1;
+      }
+
+      TCollection_AsciiString aX (theArgVec[++anArgIter]);
+      TCollection_AsciiString aY (theArgVec[++anArgIter]);
+      if (!aX.IsRealValue()
+       || !aY.IsRealValue())
+      {
+        std::cout << "Error: coordinates should be real values!\n";
+        return 1;
+      }
+
+      aPos.SetCoord (aX.RealValue(), aY.RealValue());
+    }
+    else if (aFlag == "-color")
+    {
+      if (aCS->GetColorType() != Aspect_TOCSD_USER)
+      {
+        std::cout << "Error: wrong color type! Call -colors before to set user-specified colors!\n";
+        return 1;
+      }
+
+      Quantity_NameOfColor aColorName;
+      if (anArgIter + 4 >= theArgNb)
+      {
+        if (anArgIter + 2 >= theArgNb)
+        {
+          std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+          return 1;
+        }
+        else if (!Quantity_Color::ColorFromName (theArgVec[anArgIter + 2], aColorName))
+        {
+          std::cout << "Error: wrong color name: '" << theArgVec[anArgIter + 2] << "' !\n";
+          return 1;
+        }
+      }
+
+      TCollection_AsciiString anInd (theArgVec[anArgIter + 1]);
+      if (!anInd.IsIntegerValue())
+      {
+        std::cout << "Error: Index value should be integer!\n";
+        return 1;
+      }
+
+      Standard_Integer anIndex = anInd.IntegerValue();
+      if (anIndex < 0
+       || anIndex > aNbIntervals - 1)
+      {
+        std::cout << "Error: Index value should be within range 0..." << (aNbIntervals - 1) <<"!\n";
+        return 1;
+      }
+
+      if (Quantity_Color::ColorFromName (theArgVec[anArgIter + 2], aColorName))
+      {
+        aCS->SetColor    (Quantity_Color (aColorName), anIndex);
+        aCS->SetColorType(Aspect_TOCSD_USER);
+        anArgIter += 2;
+        continue;
+      }
+
+      TCollection_AsciiString aRed   (theArgVec[anArgIter + 2]);
+      TCollection_AsciiString aGreen (theArgVec[anArgIter + 3]);
+      TCollection_AsciiString aBlue  (theArgVec[anArgIter + 4]);
+      Standard_Real aRedValue,aGreenValue, aBlueValue;
+      if(checkColor (aRed, aGreen, aBlue, aRedValue, aGreenValue, aBlueValue))
+      {
+        return 1;
+      }
+      aCS->SetColor     (Quantity_Color (aRedValue, aGreenValue, aBlueValue, Quantity_TOC_RGB), anIndex);
+      aCS->SetColorType (Aspect_TOCSD_USER);
+      anArgIter += 4;
+    }
+    else if (aFlag == "-label")
+    {
+      if (aCS->GetColorType() != Aspect_TOCSD_USER)
+      {
+        std::cout << "Error: wrong label type! Call -labels before to set user-specified labels!\n";
+        return 1;
+      }
+      else if (anArgIter + 2 >= theArgNb)
+      {
+        std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+        return 1;
+      }
+
+      Standard_Integer anIndex = Draw::Atoi (theArgVec[anArgIter + 1]);
+      if (anIndex < 0
+       || anIndex > aNbIntervals)
+      {
+        std::cout << "Error: Index value should be within range 0..." << aNbIntervals <<"!\n";
+        return 1;
+      }
+
+      TCollection_ExtendedString aText (theArgVec[anArgIter + 2]);
+      aCS->SetLabel     (aText, anIndex);
+      aCS->SetLabelType (Aspect_TOCSD_USER);
+      anArgIter += 2;
+    }
+    else if (aFlag == "-colors")
+    {
+      Aspect_SequenceOfColor aSeq;
+      if (anArgIter + aNbIntervals + 1 > theArgNb)
+      {
+        std::cout << "Error: not enough arguments! You should provide color names or RGB color values for every interval of the "
+                  << aNbIntervals << " intervals\n";
+        return 1;
+      }
+
+      Standard_Integer aColorIter = anArgIter + 1;
+      while (aColorIter < theArgNb)
+      {
+        if (theArgVec[aColorIter][0] == '-')
+        {
+          break;
+        }
+
+        else if (theArgVec[aColorIter][0] >= 97
+              && theArgVec[aColorIter][0] <= 122)
+        {
+          Quantity_NameOfColor aColorName;
+          if (!Quantity_Color::ColorFromName (theArgVec[aColorIter], aColorName))
+          {
+            std::cout << "Error: wrong color name: " << theArgVec[aColorIter] << " !\n";
+            return 1;
+          }
+          aSeq.Append (Quantity_Color (aColorName));
+          aColorIter++;
+          anArgIter++;
+        }
+        else
+        {
+          TCollection_AsciiString aRed   (theArgVec[aColorIter]);
+          TCollection_AsciiString aGreen (theArgVec[aColorIter + 1]);
+          TCollection_AsciiString aBlue  (theArgVec[aColorIter + 2]);
+          Standard_Real aRedValue,aGreenValue, aBlueValue;
+          if (checkColor (aRed, aGreen, aBlue, aRedValue, aGreenValue, aBlueValue))
+          {
+            return 1;
+          }
+          aSeq.Append (Quantity_Color (aRedValue, aGreenValue, aBlueValue, Quantity_TOC_RGB));
+          aColorIter += 3;
+          anArgIter += 3;
+        }
+      }
+      if (aSeq.Length() < aNbIntervals)
+      {
+        std::cout << "Error: not enough arguments! You should provide color names or RGB color values for every interval of the "
+                  << aNbIntervals << " intervals\n";
+        return 1;
+      }
+
+      aCS->SetColors    (aSeq);
+      aCS->SetColorType (Aspect_TOCSD_USER);
+    }
+    else if (aFlag == "-labels")
+    {
+      if (anArgIter + aNbIntervals + 1 >= theArgNb)
+      {
+        std::cout << "Error: not enough arguments! You should provide " << (aNbIntervals + 1)
+                  << " text labels for " << aNbIntervals << " intervals.\n";
+        return 1;
+      }
+
+      TColStd_SequenceOfExtendedString aSeq;
+      for (int aLabelIter = anArgIter + 1; aLabelIter <= anArgIter + aNbIntervals + 1; aLabelIter += 1)
+      {
+        aSeq.Append (TCollection_ExtendedString (theArgVec[aLabelIter]));
+      }
+      aCS->SetLabels (aSeq);
+      aCS->SetLabelType (Aspect_TOCSD_USER);
+      anArgIter += aSeq.Length();
+    }
+    else if (aFlag == "-title")
+    {
+      if (anArgIter + 1 >= theArgNb)
+      {
+        std::cout << "Error: wrong syntax at argument '" << anArg << "'!\n";
+        return 1;
+      }
+
+      Standard_Boolean isTwoArgs = Standard_False;
+      if (anArgIter + 2 < theArgNb)
+      {
+        TCollection_AsciiString aSecondArg (theArgVec[anArgIter + 2]);
+        aSecondArg.LowerCase();
+        if (aSecondArg == "none")
+        {
+          aCS->SetTitlePosition (Aspect_TOCSP_NONE);
+          isTwoArgs = Standard_True;
+        }
+        else if (aSecondArg == "left")
+        {
+          aCS->SetTitlePosition (Aspect_TOCSP_LEFT);
+          isTwoArgs = Standard_True;
+        }
+        else if (aSecondArg == "right")
+        {
+          aCS->SetTitlePosition (Aspect_TOCSP_RIGHT);
+          isTwoArgs = Standard_True;
+        }
+        else if (aSecondArg == "center")
+        {
+          aCS->SetTitlePosition (Aspect_TOCSP_CENTER);
+          isTwoArgs = Standard_True;
+        }
+      }
+
+      aCS->SetTitle (theArgVec[anArgIter + 1]);
+      if (isTwoArgs)
+      {
+        anArgIter += 1;
+      }
+      anArgIter += 1;
+    }
+    else if (aFlag == "-demoversion"
+          || aFlag == "-demo")
+    {
+      aPos.SetCoord (0.0, 0.0);
+      aTextHeight  = 16;
+      aMinRange    = 0.0;
+      aMaxRange    = 100;
+      aNbIntervals = 10;
+      aLabPosition = Aspect_TOCSP_RIGHT;
+      aCS->SetColorType(Aspect_TOCSD_AUTO);
+      aCS->SetLabelType(Aspect_TOCSD_AUTO);
+    }
+    else
+    {
+      std::cout << "Error: wrong syntax at " << anArg << " - unknown argument!\n";
+      return 1;
+    }
+  }
+
+  aCS->SetPosition          (aPos.X(), aPos.Y());
+  aCS->SetHeight            (0.95);
+  aCS->SetTextHeight        (aTextHeight);
+  aCS->SetRange             (aMinRange, aMaxRange);
+  aCS->SetNumberOfIntervals (aNbIntervals);
+  aCS->SetLabelPosition     (aLabPosition);
+
+  if (!aView->ColorScaleIsDisplayed())
+  {
+    aView->ColorScaleDisplay();
+  }
+
+  return 0;
+}
+
+//==============================================================================
+//function : VGraduatedTrihedron
+//purpose  : Displays or hides a graduated trihedron
+//==============================================================================
+static Standard_Boolean GetColor (const TCollection_AsciiString& theValue,
+                                  Quantity_Color& theColor)
+{
+  Quantity_NameOfColor aColorName;
+  TCollection_AsciiString aVal = theValue;
+  aVal.UpperCase();
+  if (!Quantity_Color::ColorFromName (aVal.ToCString(), aColorName))
+  {
+    return Standard_False;
+  }
+  theColor = Quantity_Color (aColorName);
+  return Standard_True;
+}
+
+static int VGraduatedTrihedron (Draw_Interpretor& /*theDi*/, Standard_Integer theArgNum, const char** theArgs)
 {
-  if ( argc != 1 && argc != 4 && argc != 5 && argc != 6 && argc != 8 )
+  if (theArgNum < 2)
+  {
+    std::cout << theArgs[0] << " error: wrong number of parameters. Type 'help"
+              << theArgs[0] <<"' for more information.\n";
+    return 1;  //TCL_ERROR
+  }
+
+  NCollection_DataMap<TCollection_AsciiString, Handle(TColStd_HSequenceOfAsciiString)> aMapOfArgs;
+  TCollection_AsciiString aParseKey;
+  for (Standard_Integer anArgIt = 1; anArgIt < theArgNum; ++anArgIt)
+  {
+    TCollection_AsciiString anArg (theArgs [anArgIt]);
+
+    if (anArg.Value (1) == '-' && !anArg.IsRealValue())
+    {
+      aParseKey = anArg;
+      aParseKey.Remove (1);
+      aParseKey.LowerCase();
+      aMapOfArgs.Bind (aParseKey, new TColStd_HSequenceOfAsciiString);
+      continue;
+    }
+
+    if (aParseKey.IsEmpty())
+    {
+      continue;
+    }
+
+    aMapOfArgs(aParseKey)->Append (anArg);
+  }
+
+  // Check parameters
+  for (NCollection_DataMap<TCollection_AsciiString, Handle(TColStd_HSequenceOfAsciiString)>::Iterator aMapIt (aMapOfArgs);
+       aMapIt.More(); aMapIt.Next())
+  {
+    const TCollection_AsciiString& aKey = aMapIt.Key();
+    const Handle(TColStd_HSequenceOfAsciiString)& anArgs = aMapIt.Value();
+
+    // Bool key, without arguments
+    if ((aKey.IsEqual ("on") || aKey.IsEqual ("off"))
+        && anArgs->IsEmpty())
+    {
+      continue;
+    }
+
+    // One argument
+    if ( (aKey.IsEqual ("xname") || aKey.IsEqual ("yname") || aKey.IsEqual ("zname"))
+          && anArgs->Length() == 1)
+    {
+      continue;
+    }
+
+    // On/off arguments
+    if ((aKey.IsEqual ("xdrawname") || aKey.IsEqual ("ydrawname") || aKey.IsEqual ("zdrawname")
+        || aKey.IsEqual ("xdrawticks") || aKey.IsEqual ("ydrawticks") || aKey.IsEqual ("zdrawticks")
+        || aKey.IsEqual ("xdrawvalues") || aKey.IsEqual ("ydrawvalues") || aKey.IsEqual ("zdrawvalues")
+        || aKey.IsEqual ("drawgrid") || aKey.IsEqual ("drawaxes"))
+        && anArgs->Length() == 1 && (anArgs->Value(1).IsEqual ("on") || anArgs->Value(1).IsEqual ("off")))
+    {
+      continue;
+    }
+
+    // One string argument
+    if ( (aKey.IsEqual ("xnamecolor") || aKey.IsEqual ("ynamecolor") || aKey.IsEqual ("znamecolor")
+          || aKey.IsEqual ("xcolor") || aKey.IsEqual ("ycolor") || aKey.IsEqual ("zcolor"))
+          && anArgs->Length() == 1 && !anArgs->Value(1).IsIntegerValue() && !anArgs->Value(1).IsRealValue())
+    {
+      continue;
+    }
+
+    // One integer argument
+    if ( (aKey.IsEqual ("xticks") || aKey.IsEqual ("yticks") || aKey.IsEqual ("zticks")
+          || aKey.IsEqual ("xticklength") || aKey.IsEqual ("yticklength") || aKey.IsEqual ("zticklength")
+          || aKey.IsEqual ("xnameoffset") || aKey.IsEqual ("ynameoffset") || aKey.IsEqual ("znameoffset")
+          || aKey.IsEqual ("xvaluesoffset") || aKey.IsEqual ("yvaluesoffset") || aKey.IsEqual ("zvaluesoffset"))
+         && anArgs->Length() == 1 && anArgs->Value(1).IsIntegerValue())
+    {
+      continue;
+    }
+
+    // One real argument
+    if ( aKey.IsEqual ("arrowlength")
+         && anArgs->Length() == 1 && (anArgs->Value(1).IsIntegerValue() || anArgs->Value(1).IsRealValue()))
+    {
+      continue;
+    }
+
+    // Two string arguments
+    if ( (aKey.IsEqual ("namefont") || aKey.IsEqual ("valuesfont"))
+         && anArgs->Length() == 1 && !anArgs->Value(1).IsIntegerValue() && !anArgs->Value(1).IsRealValue())
+    {
+      continue;
+    }
+
+    TCollection_AsciiString aLowerKey;
+    aLowerKey  = "-";
+    aLowerKey += aKey;
+    aLowerKey.LowerCase();
+    std::cout << theArgs[0] << ": " << aLowerKey << " is unknown option, or the arguments are unacceptable.\n";
+    std::cout << "Type help for more information.\n";
+    return 1;
+  }
+
+  Handle(AIS_InteractiveContext) anAISContext = ViewerTest::GetAISContext();
+  if (anAISContext.IsNull())
+  {
+    std::cout << theArgs[0] << ": " << " please use 'vinit' command to initialize view.\n";
+    return 1;
+  }
+
+  Standard_Boolean toDisplay = Standard_True;
+  Quantity_Color aColor;
+  Graphic3d_GraduatedTrihedron aTrihedronData;
+  // Process parameters
+  Handle(TColStd_HSequenceOfAsciiString) aValues;
+  if (aMapOfArgs.Find ("off", aValues))
+  {
+    toDisplay = Standard_False;
+  }
+
+  // AXES NAMES
+  if (aMapOfArgs.Find ("xname", aValues))
+  {
+    aTrihedronData.ChangeXAxisAspect().SetName (aValues->Value(1));
+  }
+  if (aMapOfArgs.Find ("yname", aValues))
+  {
+    aTrihedronData.ChangeYAxisAspect().SetName (aValues->Value(1));
+  }
+  if (aMapOfArgs.Find ("zname", aValues))
+  {
+    aTrihedronData.ChangeZAxisAspect().SetName (aValues->Value(1));
+  }
+  if (aMapOfArgs.Find ("xdrawname", aValues))
+  {
+    aTrihedronData.ChangeXAxisAspect().SetDrawName (aValues->Value(1).IsEqual ("on"));
+  }
+  if (aMapOfArgs.Find ("ydrawname", aValues))
+  {
+    aTrihedronData.ChangeYAxisAspect().SetDrawName (aValues->Value(1).IsEqual ("on"));
+  }
+  if (aMapOfArgs.Find ("zdrawname", aValues))
+  {
+    aTrihedronData.ChangeZAxisAspect().SetDrawName (aValues->Value(1).IsEqual ("on"));
+  }
+  if (aMapOfArgs.Find ("xnameoffset", aValues))
+  {
+    aTrihedronData.ChangeXAxisAspect().SetNameOffset (aValues->Value(1).IntegerValue());
+  }
+  if (aMapOfArgs.Find ("ynameoffset", aValues))
+  {
+    aTrihedronData.ChangeYAxisAspect().SetNameOffset (aValues->Value(1).IntegerValue());
+  }
+  if (aMapOfArgs.Find ("znameoffset", aValues))
+  {
+    aTrihedronData.ChangeZAxisAspect().SetNameOffset (aValues->Value(1).IntegerValue());
+  }
+
+  // COLORS
+  if (aMapOfArgs.Find ("xnamecolor", aValues))
+  {
+    if (!GetColor (aValues->Value(1), aColor))
+    {
+      std::cout << theArgs[0] << "error: -xnamecolor wrong color name.\n";
+      return 1;
+    }
+    aTrihedronData.ChangeXAxisAspect().SetNameColor (aColor);
+  }
+  if (aMapOfArgs.Find ("ynamecolor", aValues))
+  {
+    if (!GetColor (aValues->Value(1), aColor))
+    {
+      std::cout << theArgs[0] << "error: -ynamecolor wrong color name.\n";
+      return 1;
+    }
+    aTrihedronData.ChangeYAxisAspect().SetNameColor (aColor);
+  }
+  if (aMapOfArgs.Find ("znamecolor", aValues))
+  {
+    if (!GetColor (aValues->Value(1), aColor))
+    {
+      std::cout << theArgs[0] << "error: -znamecolor wrong color name.\n";
+      return 1;
+    }
+    aTrihedronData.ChangeZAxisAspect().SetNameColor (aColor);
+  }
+  if (aMapOfArgs.Find ("xcolor", aValues))
+  {
+    if (!GetColor (aValues->Value(1), aColor))
+    {
+      std::cout << theArgs[0] << "error: -xcolor wrong color name.\n";
+      return 1;
+    }
+    aTrihedronData.ChangeXAxisAspect().SetColor (aColor);
+  }
+  if (aMapOfArgs.Find ("ycolor", aValues))
+  {
+    if (!GetColor (aValues->Value(1), aColor))
+    {
+      std::cout << theArgs[0] << "error: -ycolor wrong color name.\n";
+      return 1;
+    }
+    aTrihedronData.ChangeYAxisAspect().SetColor (aColor);
+  }
+  if (aMapOfArgs.Find ("zcolor", aValues))
+  {
+    if (!GetColor (aValues->Value(1), aColor))
+    {
+      std::cout << theArgs[0] << "error: -zcolor wrong color name.\n";
+      return 1;
+    }
+    aTrihedronData.ChangeZAxisAspect().SetColor (aColor);
+  }
+
+  // TICKMARKS
+  if (aMapOfArgs.Find ("xticks", aValues))
+  {
+    aTrihedronData.ChangeXAxisAspect().SetTickmarksNumber (aValues->Value(1).IntegerValue());
+  }
+  if (aMapOfArgs.Find ("yticks", aValues))
+  {
+    aTrihedronData.ChangeYAxisAspect().SetTickmarksNumber (aValues->Value(1).IntegerValue());
+  }
+  if (aMapOfArgs.Find ("zticks", aValues))
+  {
+    aTrihedronData.ChangeZAxisAspect().SetTickmarksNumber (aValues->Value(1).IntegerValue());
+  }
+  if (aMapOfArgs.Find ("xticklength", aValues))
+  {
+    aTrihedronData.ChangeXAxisAspect().SetTickmarksLength (aValues->Value(1).IntegerValue());
+  }
+  if (aMapOfArgs.Find ("yticklength", aValues))
+  {
+    aTrihedronData.ChangeYAxisAspect().SetTickmarksLength (aValues->Value(1).IntegerValue());
+  }
+  if (aMapOfArgs.Find ("zticklength", aValues))
+  {
+    aTrihedronData.ChangeZAxisAspect().SetTickmarksLength (aValues->Value(1).IntegerValue());
+  }
+  if (aMapOfArgs.Find ("xdrawticks", aValues))
+  {
+    aTrihedronData.ChangeXAxisAspect().SetDrawTickmarks (aValues->Value(1).IsEqual ("on"));
+  }
+  if (aMapOfArgs.Find ("ydrawticks", aValues))
+  {
+    aTrihedronData.ChangeYAxisAspect().SetDrawTickmarks (aValues->Value(1).IsEqual ("on"));
+  }
+  if (aMapOfArgs.Find ("zdrawticks", aValues))
+  {
+    aTrihedronData.ChangeZAxisAspect().SetDrawTickmarks (aValues->Value(1).IsEqual ("on"));
+  }
+
+  // VALUES
+  if (aMapOfArgs.Find ("xdrawvalues", aValues))
+  {
+    aTrihedronData.ChangeXAxisAspect().SetDrawValues (aValues->Value(1).IsEqual ("on"));
+  }
+  if (aMapOfArgs.Find ("ydrawvalues", aValues))
+  {
+    aTrihedronData.ChangeYAxisAspect().SetDrawValues (aValues->Value(1).IsEqual ("on"));
+  }
+  if (aMapOfArgs.Find ("zdrawvalues", aValues))
+  {
+    aTrihedronData.ChangeZAxisAspect().SetDrawValues (aValues->Value(1).IsEqual ("on"));
+  }
+  if (aMapOfArgs.Find ("xvaluesoffset", aValues))
   {
-    di << "Usage : " << argv[0] << " [RangeMin = 0 RangeMax = 100 Intervals = 10 HeightFont = 16 Position = Right X = 0 Y = 0]  " << "\n";
-    return 1;
+    aTrihedronData.ChangeXAxisAspect().SetValuesOffset (aValues->Value(1).IntegerValue());
   }
-
-  Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
-  if(aContext.IsNull()) {
-    di << argv[0] << " ERROR : use 'vinit' command before " << "\n";
-    return -1;
+  if (aMapOfArgs.Find ("yvaluesoffset", aValues))
+  {
+    aTrihedronData.ChangeYAxisAspect().SetValuesOffset (aValues->Value(1).IntegerValue());
   }
-
-  Standard_Real minRange = 0. , maxRange = 100. ;
-
-  Standard_Integer numIntervals = 10 ;
-  Standard_Integer textHeight = 16;
-  Aspect_TypeOfColorScalePosition position = Aspect_TOCSP_RIGHT;
-  Standard_Real X = 0., Y = 0. ;
-
-  if ( argc < 9 )
-  {
-     if( argc > 3 )
-     {
-       minRange = Draw::Atof( argv[1] );
-       maxRange = Draw::Atof( argv[2] );
-       numIntervals = Draw::Atoi( argv[3] );
-     }
-     if ( argc > 4 )
-       textHeight = Draw::Atoi( argv[4] );
-     if ( argc > 5 )
-       position = (Aspect_TypeOfColorScalePosition)Draw::Atoi( argv[5] );
-     if ( argc > 7 )
-     {
-       X = Draw::Atof( argv[6] );
-       Y = Draw::Atof( argv[7] );
-     }
-  }
-  Handle(V3d_View) curView = ViewerTest::CurrentView( );
-  if ( curView.IsNull( ) )
-    return 1;
-  Handle(Aspect_ColorScale) aCSV = curView->ColorScale( );
-  Handle(V3d_ColorScale) aCS = ( Handle( V3d_ColorScale )::DownCast( aCSV ) );
-  if( ! aCS.IsNull( ) )
-  {
-    aCS->SetPosition( X , Y );
-    aCS->SetHeight( 0.95) ;
-    aCS->SetTextHeight( textHeight );
-    aCS->SetRange( minRange , maxRange );
-    aCS->SetNumberOfIntervals( numIntervals );
-    aCS->SetLabelPosition( position );
-    if( !curView->ColorScaleIsDisplayed() )
-      curView->ColorScaleDisplay( );
+  if (aMapOfArgs.Find ("zvaluesoffset", aValues))
+  {
+    aTrihedronData.ChangeZAxisAspect().SetValuesOffset (aValues->Value(1).IntegerValue());
   }
-  return 0;
-}
-
-//==============================================================================
-//function : VGraduatedTrihedron
-//purpose  : Displays a graduated trihedron
-//==============================================================================
 
-static void AddMultibyteString (TCollection_ExtendedString &name, const char *arg)
-{
-  const char *str = arg;
-  while (*str)
+  // ARROWS
+  if (aMapOfArgs.Find ("arrowlength", aValues))
   {
-    unsigned short c1 = *str++;
-    unsigned short c2 = *str++;
-    if (!c1 || !c2) break;
-    name += (Standard_ExtCharacter)((c1 << 8) | c2);
+    aTrihedronData.SetArrowsLength ((Standard_ShortReal) aValues->Value(1).RealValue());
   }
-}
 
-static int VGraduatedTrihedron(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
-{
-  // Check arguments
-  if (argc != 2 && argc < 5)
+  // FONTS
+  if (aMapOfArgs.Find ("namefont", aValues))
   {
-    di<<"Error: "<<argv[0]<<" - invalid number of arguments\n";
-    di<<"Usage: type help "<<argv[0]<<"\n";
-    return 1; //TCL_ERROR
+    aTrihedronData.SetNamesFont (aValues->Value(1));
   }
-
-  Handle(V3d_View) aV3dView = ViewerTest::CurrentView();
-
-  // Create 3D view if it doesn't exist
-  if ( aV3dView.IsNull() )
+  if (aMapOfArgs.Find ("valuesfont", aValues))
   {
-    ViewerTest::ViewerInit();
-    aV3dView = ViewerTest::CurrentView();
-    if( aV3dView.IsNull() )
-    {
-      di << "Error: Cannot create a 3D view\n";
-      return 1; //TCL_ERROR
-    }
+    aTrihedronData.SetValuesFont (aValues->Value(1));
   }
 
-  // Erase (==0) or display (!=0)
-  const int display = Draw::Atoi(argv[1]);
-
-  if (display)
+  if (aMapOfArgs.Find ("drawgrid", aValues))
   {
-    // Text font
-    TCollection_AsciiString font;
-    if (argc < 6)
-      font.AssignCat("Courier");
-    else
-      font.AssignCat(argv[5]);
-
-    // Text is multibyte
-    const Standard_Boolean isMultibyte = (argc < 7)? Standard_False : (Draw::Atoi(argv[6]) != 0);
+    aTrihedronData.SetDrawGrid (aValues->Value(1).IsEqual ("on"));
+  }
+  if (aMapOfArgs.Find ("drawaxes", aValues))
+  {
+    aTrihedronData.SetDrawAxes (aValues->Value(1).IsEqual ("on"));
+  }
 
-    // Set axis names
-    TCollection_ExtendedString xname, yname, zname;
-    if (argc >= 5)
-    {
-      if (isMultibyte)
-      {
-        AddMultibyteString(xname, argv[2]);
-        AddMultibyteString(yname, argv[3]);
-        AddMultibyteString(zname, argv[4]);
-      }
-      else
-      {
-        xname += argv[2];
-        yname += argv[3];
-        zname += argv[4];
-      }
-    }
-    else
-    {
-      xname += "X (mm)";
-      yname += "Y (mm)";
-      zname += "Z (mm)";
-    }
-
-    aV3dView->GraduatedTrihedronDisplay(xname, yname, zname,
-                                        Standard_True/*xdrawname*/, Standard_True/*ydrawname*/, Standard_True/*zdrawname*/,
-                                        Standard_True/*xdrawvalues*/, Standard_True/*ydrawvalues*/, Standard_True/*zdrawvalues*/,
-                                        Standard_True/*drawgrid*/,
-                                        Standard_True/*drawaxes*/,
-                                        5/*nbx*/, 5/*nby*/, 5/*nbz*/,
-                                        10/*xoffset*/, 10/*yoffset*/, 10/*zoffset*/,
-                                        30/*xaxisoffset*/, 30/*yaxisoffset*/, 30/*zaxisoffset*/,
-                                        Standard_True/*xdrawtickmarks*/, Standard_True/*ydrawtickmarks*/, Standard_True/*zdrawtickmarks*/,
-                                        10/*xtickmarklength*/, 10/*ytickmarklength*/, 10/*ztickmarklength*/,
-                                        Quantity_NOC_WHITE/*gridcolor*/,
-                                        Quantity_NOC_RED/*xnamecolor*/,Quantity_NOC_GREEN/*ynamecolor*/,Quantity_NOC_BLUE1/*znamecolor*/,
-                                        Quantity_NOC_RED/*xcolor*/,Quantity_NOC_GREEN/*ycolor*/,Quantity_NOC_BLUE1/*zcolor*/,font);
+  // The final step: display of erase trihedron
+  if (toDisplay)
+  {
+    ViewerTest::CurrentView()->GraduatedTrihedronDisplay (aTrihedronData);
   }
   else
-    aV3dView->GraduatedTrihedronErase();
+  {
+    ViewerTest::CurrentView()->GraduatedTrihedronErase();
+  }
 
   ViewerTest::GetAISContext()->UpdateCurrentViewer();
-  aV3dView->Redraw();
+  ViewerTest::CurrentView()->Redraw();
 
   return 0;
 }
@@ -3405,6 +4479,18 @@ static int VZLayer (Draw_Interpretor& di, Standard_Integer argc, const char** ar
       return 1;
     }
 
+    for (ViewerTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName anObjIter (GetMapOfAIS());
+         anObjIter.More(); anObjIter.Next())
+    {
+      Handle(PrsMgr_PresentableObject) aPrs = Handle(PrsMgr_PresentableObject)::DownCast (anObjIter.Key1());
+      if (aPrs.IsNull()
+       || aPrs->ZLayer() != aDelId)
+      {
+        continue;
+      }
+      aPrs->SetZLayer (Graphic3d_ZLayerId_Default);
+    }
+
     di << "Z layer " << aDelId << " has been removed\n";
   }
   else if (anOp == "get")
@@ -3541,15 +4627,13 @@ static int VZLayer (Draw_Interpretor& di, Standard_Integer argc, const char** ar
   return 0;
 }
 
-DEFINE_STANDARD_HANDLE(V3d_TextItem, Visual3d_LayerItem)
-
 // this class provides a presentation of text item in v3d view under-/overlayer
 class V3d_TextItem : public Visual3d_LayerItem
 {
 public:
 
   // CASCADE RTTI
-  DEFINE_STANDARD_RTTI(V3d_TextItem)
+  DEFINE_STANDARD_RTTI(V3d_TextItem, Visual3d_LayerItem)
 
   // constructor
   Standard_EXPORT V3d_TextItem(const TCollection_AsciiString& theText,
@@ -3578,8 +4662,6 @@ private:
   TCollection_AsciiString  myFontName;
 };
 
-IMPLEMENT_STANDARD_HANDLE(V3d_TextItem, Visual3d_LayerItem)
-IMPLEMENT_STANDARD_RTTIEXT(V3d_TextItem, Visual3d_LayerItem)
 
 // create and add to display the text item
 V3d_TextItem::V3d_TextItem (const TCollection_AsciiString& theText,
@@ -3615,8 +4697,6 @@ void V3d_TextItem::RedrawLayerPrs ()
   myLayer->DrawText (myText.ToCString (), myX1, myY1, myHeight);
 }
 
-DEFINE_STANDARD_HANDLE(V3d_LineItem, Visual3d_LayerItem)
-
 // The Visual3d_LayerItem line item for "vlayerline" command
 // it provides a presentation of line with user-defined
 // linewidth, linetype and transparency.
@@ -3624,7 +4704,7 @@ class V3d_LineItem : public Visual3d_LayerItem
 {
 public:
   // CASCADE RTTI
-  DEFINE_STANDARD_RTTI(V3d_LineItem)
+  DEFINE_STANDARD_RTTI(V3d_LineItem, Visual3d_LayerItem)
 
   // constructor
   Standard_EXPORT V3d_LineItem(Standard_Real X1, Standard_Real Y1,
@@ -3646,8 +4726,6 @@ private:
   Standard_Real       myTransparency;
 };
 
-IMPLEMENT_STANDARD_HANDLE(V3d_LineItem, Visual3d_LayerItem)
-IMPLEMENT_STANDARD_RTTIEXT(V3d_LineItem, Visual3d_LayerItem)
 
 // default constructor for line item
 V3d_LineItem::V3d_LineItem(Standard_Real X1, Standard_Real Y1,
@@ -3981,6 +5059,221 @@ static int VGrid (Draw_Interpretor& /*theDI*/,
 }
 
 //==============================================================================
+//function : VPriviledgedPlane
+//purpose  :
+//==============================================================================
+
+static int VPriviledgedPlane (Draw_Interpretor& theDI,
+                              Standard_Integer  theArgNb,
+                              const char**      theArgVec)
+{
+  if (theArgNb != 1 && theArgNb != 7 && theArgNb != 10)
+  {
+    std::cerr << "Error: wrong number of arguments! See usage:\n";
+    theDI.PrintHelp (theArgVec[0]);
+    return 1;
+  }
+
+  // get the active viewer
+  Handle(V3d_Viewer) aViewer = ViewerTest::GetViewerFromContext();
+  if (aViewer.IsNull())
+  {
+    std::cerr << "Error: no active viewer. Please call vinit.\n";
+    return 1;
+  }
+
+  if (theArgNb == 1)
+  {
+    gp_Ax3 aPriviledgedPlane = aViewer->PrivilegedPlane();
+    const gp_Pnt& anOrig = aPriviledgedPlane.Location();
+    const gp_Dir& aNorm = aPriviledgedPlane.Direction();
+    const gp_Dir& aXDir = aPriviledgedPlane.XDirection();
+    theDI << "Origin: " << anOrig.X() << " " << anOrig.Y() << " " << anOrig.Z() << " "
+          << "Normal: " << aNorm.X() << " " << aNorm.Y() << " " << aNorm.Z() << " "
+          << "X-dir: "  << aXDir.X() << " " << aXDir.Y() << " " << aXDir.Z() << "\n";
+    return 0;
+  }
+
+  Standard_Integer anArgIdx = 1;
+  Standard_Real anOrigX = Draw::Atof (theArgVec[anArgIdx++]);
+  Standard_Real anOrigY = Draw::Atof (theArgVec[anArgIdx++]);
+  Standard_Real anOrigZ = Draw::Atof (theArgVec[anArgIdx++]);
+  Standard_Real aNormX  = Draw::Atof (theArgVec[anArgIdx++]);
+  Standard_Real aNormY  = Draw::Atof (theArgVec[anArgIdx++]);
+  Standard_Real aNormZ  = Draw::Atof (theArgVec[anArgIdx++]);
+
+  gp_Ax3 aPriviledgedPlane;
+  gp_Pnt anOrig (anOrigX, anOrigY, anOrigZ);
+  gp_Dir aNorm (aNormX, aNormY, aNormZ);
+  if (theArgNb > 7)
+  {
+    Standard_Real aXDirX = Draw::Atof (theArgVec[anArgIdx++]);
+    Standard_Real aXDirY = Draw::Atof (theArgVec[anArgIdx++]);
+    Standard_Real aXDirZ = Draw::Atof (theArgVec[anArgIdx++]);
+    gp_Dir aXDir (aXDirX, aXDirY, aXDirZ);
+    aPriviledgedPlane = gp_Ax3 (anOrig, aNorm, aXDir);
+  }
+  else
+  {
+    aPriviledgedPlane = gp_Ax3 (anOrig, aNorm);
+  }
+
+  aViewer->SetPrivilegedPlane (aPriviledgedPlane);
+
+  return 0;
+}
+
+//==============================================================================
+//function : VConvert
+//purpose  :
+//==============================================================================
+
+static int VConvert (Draw_Interpretor& theDI,
+                     Standard_Integer  theArgNb,
+                     const char**      theArgVec)
+{
+  // get the active view
+  Handle(V3d_View) aView = ViewerTest::CurrentView();
+  if (aView.IsNull())
+  {
+    std::cerr << "Error: no active view. Please call vinit.\n";
+    return 1;
+  }
+
+  enum { Model, Ray, View, Window, Grid } aMode = Model;
+
+  // access coordinate arguments
+  TColStd_SequenceOfReal aCoord;
+  Standard_Integer anArgIdx = 1;
+  for (; anArgIdx < 4 && anArgIdx < theArgNb; ++anArgIdx)
+  {
+    TCollection_AsciiString anArg (theArgVec[anArgIdx]);
+    if (!anArg.IsRealValue())
+    {
+      break;
+    }
+    aCoord.Append (anArg.RealValue());
+  }
+
+  // non-numeric argument too early
+  if (aCoord.IsEmpty())
+  {
+    std::cerr << "Error: wrong number of arguments! See usage:\n";
+    theDI.PrintHelp (theArgVec[0]);
+    return 1;
+  }
+
+  // collect all other arguments and options
+  for (; anArgIdx < theArgNb; ++anArgIdx)
+  {
+    TCollection_AsciiString anArg (theArgVec[anArgIdx]);
+    anArg.LowerCase();
+    if      (anArg == "window") aMode = Window;
+    else if (anArg == "view")   aMode = View;
+    else if (anArg == "grid")   aMode = Grid;
+    else if (anArg == "ray")    aMode = Ray;
+    else
+    {
+      std::cerr << "Error: wrong argument " << anArg << "! See usage:\n";
+      theDI.PrintHelp (theArgVec[0]);
+      return 1;
+    }
+  }
+
+  // complete input checks
+  if ((aCoord.Length() == 1 && theArgNb > 3) ||
+      (aCoord.Length() == 2 && theArgNb > 4) ||
+      (aCoord.Length() == 3 && theArgNb > 5))
+  {
+    std::cerr << "Error: wrong number of arguments! See usage:\n";
+    theDI.PrintHelp (theArgVec[0]);
+    return 1;
+  }
+
+  Standard_Real aXYZ[6] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
+  Standard_Integer aXYp[2] = {0, 0};
+
+  // convert one-dimensional coordinate
+  if (aCoord.Length() == 1)
+  {
+    switch (aMode)
+    {
+      case View   : theDI << "View Vv: "   << aView->Convert ((Standard_Integer) aCoord (1)); return 0;
+      case Window : theDI << "Window Vp: " << aView->Convert ((Quantity_Length) aCoord (1));  return 0;
+      default:
+        std::cerr << "Error: wrong arguments! See usage:\n";
+        theDI.PrintHelp (theArgVec[0]);
+        return 1;
+    }
+  }
+
+  // convert 2D coordinates from projection or view reference space
+  if (aCoord.Length() == 2)
+  {
+    switch (aMode)
+    {
+      case Model :
+        aView->Convert ((Standard_Integer) aCoord (1), (Standard_Integer) aCoord (2), aXYZ[0], aXYZ[1], aXYZ[2]);
+        theDI << "Model X,Y,Z: " << aXYZ[0] << " " << aXYZ[1] << " " << aXYZ[2] << "\n";
+        return 0;
+
+      case View :
+        aView->Convert ((Standard_Integer) aCoord (1), (Standard_Integer) aCoord (2), aXYZ[0], aXYZ[1]);
+        theDI << "View Xv,Yv: " << aXYZ[0] << " " << aXYZ[1] << "\n";
+        return 0;
+
+      case Window :
+        aView->Convert ((V3d_Coordinate) aCoord (1), (V3d_Coordinate) aCoord (2), aXYp[0], aXYp[1]);
+        theDI << "Window Xp,Yp: " << aXYp[0] << " " << aXYp[1] << "\n";
+        return 0;
+
+      case Grid :
+        aView->Convert ((Standard_Integer) aCoord (1), (Standard_Integer) aCoord (2), aXYZ[0], aXYZ[1], aXYZ[2]);
+        aView->ConvertToGrid (aXYZ[0], aXYZ[1], aXYZ[2], aXYZ[3], aXYZ[4], aXYZ[5]);
+        theDI << "Model X,Y,Z: " << aXYZ[3] << " " << aXYZ[4] << " " << aXYZ[5] << "\n";
+        return 0;
+
+      case Ray :
+        aView->ConvertWithProj ((Standard_Integer) aCoord (1),
+                                (Standard_Integer) aCoord (2),
+                                aXYZ[0], aXYZ[1], aXYZ[2],
+                                aXYZ[3], aXYZ[4], aXYZ[5]);
+        theDI << "Model DX,DY,DZ: " << aXYZ[3] << " " << aXYZ[4] << " " << aXYZ[5] << "\n";
+        return 0;
+
+      default:
+        std::cerr << "Error: wrong arguments! See usage:\n";
+        theDI.PrintHelp (theArgVec[0]);
+        return 1;
+    }
+  }
+
+  // convert 3D coordinates from view reference space
+  else if (aCoord.Length() == 3)
+  {
+    switch (aMode)
+    {
+      case Window :
+        aView->Convert (aCoord (1), aCoord (2), aCoord (3), aXYp[0], aXYp[1]);
+        theDI << "Window Xp,Yp: " << aXYp[0] << " " << aXYp[1] << "\n";
+        return 0;
+
+      case Grid :
+        aView->ConvertToGrid (aCoord (1), aCoord (2), aCoord (3), aXYZ[0], aXYZ[1], aXYZ[2]);
+        theDI << "Model X,Y,Z: " << aXYZ[0] << " " << aXYZ[1] << " " << aXYZ[2] << "\n";
+        return 0;
+
+      default:
+        std::cerr << "Error: wrong arguments! See usage:\n";
+        theDI.PrintHelp (theArgVec[0]);
+        return 1;
+    }
+  }
+
+  return 0;
+}
+
+//==============================================================================
 //function : VFps
 //purpose  :
 //==============================================================================
@@ -4027,6 +5320,22 @@ static int VFps (Draw_Interpretor& theDI,
   theDI << "FPS: " << aFpsAver << "\n"
         << "CPU: " << (1000.0 * aCpuAver) << " msec\n";
 
+  // compute additional statistics in ray-tracing mode
+  Graphic3d_RenderingParams& aParams = aView->ChangeRenderingParams();
+
+  if (aParams.Method == Graphic3d_RM_RAYTRACING)
+  {
+    Standard_Integer aSizeX;
+    Standard_Integer aSizeY;
+
+    aView->Window()->Size (aSizeX, aSizeY);
+
+    // 1 shadow ray and 1 secondary ray pew each bounce
+    const Standard_Real aMRays = aSizeX * aSizeY * aFpsAver * aParams.RaytracingDepth * 2 / 1.0e6f;
+
+    theDI << "MRays/sec (upper bound): " << aMRays << "\n";
+  }
+
   return 0;
 }
 
@@ -4039,23 +5348,134 @@ static int VGlDebug (Draw_Interpretor& theDI,
                      Standard_Integer  theArgNb,
                      const char**      theArgVec)
 {
+  Handle(OpenGl_GraphicDriver) aDriver;
+  Handle(V3d_View) aView = ViewerTest::CurrentView();
+  if (!aView.IsNull())
+  {
+    aDriver = Handle(OpenGl_GraphicDriver)::DownCast (aView->Viewer()->Driver());
+  }
+  OpenGl_Caps* aDefCaps = &ViewerTest_myDefaultCaps;
+  OpenGl_Caps* aCaps    = !aDriver.IsNull() ? &aDriver->ChangeOptions() : NULL;
+
   if (theArgNb < 2)
   {
-    Handle(V3d_View) aView = ViewerTest::CurrentView();
-    if (aView.IsNull())
+    TCollection_AsciiString aDebActive, aSyncActive;
+    if (aCaps == NULL)
     {
-      std::cerr << "No active view. Please call vinit.\n";
-      return 0;
+      aCaps = aDefCaps;
+    }
+    else
+    {
+      Standard_Boolean isActive = OpenGl_Context::CheckExtension ((const char* )::glGetString (GL_EXTENSIONS),
+                                                                  "GL_ARB_debug_output");
+      aDebActive = isActive ? " (active)" : " (inactive)";
+      if (isActive)
+      {
+        // GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB
+        aSyncActive = ::glIsEnabled (0x8242) == GL_TRUE ? " (active)" : " (inactive)";
+      }
     }
 
-    Standard_Boolean isActive = OpenGl_Context::CheckExtension ((const char* )glGetString (GL_EXTENSIONS),
-                                                                "GL_ARB_debug_output");
-    std::cout << "Active graphic driver: debug " << (isActive ? "ON" : "OFF") << "\n";
-    theDI << (isActive ? "1" : "0");
+    theDI << "debug:   " << (aCaps->contextDebug      ? "1" : "0") << aDebActive  << "\n"
+          << "sync:    " << (aCaps->contextSyncDebug  ? "1" : "0") << aSyncActive << "\n"
+          << "glslWarn:" << (aCaps->glslWarnings      ? "1" : "0") << "\n"
+          << "extraMsg:" << (aCaps->suppressExtraMsg  ? "0" : "1") << "\n";
     return 0;
   }
 
-  ViewerTest_myDefaultCaps.contextDebug = Draw::Atoi (theArgVec[1]) != 0;
+  for (Standard_Integer anArgIter = 1; anArgIter < theArgNb; ++anArgIter)
+  {
+    Standard_CString        anArg     = theArgVec[anArgIter];
+    TCollection_AsciiString anArgCase (anArg);
+    anArgCase.LowerCase();
+    Standard_Boolean toEnableDebug = Standard_True;
+    if (anArgCase == "-glsl"
+     || anArgCase == "-glslwarn"
+     || anArgCase == "-glslwarns"
+     || anArgCase == "-glslwarnings")
+    {
+      Standard_Boolean toShowWarns = Standard_True;
+      if (++anArgIter < theArgNb
+      && !parseOnOff (theArgVec[anArgIter], toShowWarns))
+      {
+        --anArgIter;
+      }
+      aDefCaps->glslWarnings = toShowWarns;
+      if (aCaps != NULL)
+      {
+        aCaps->glslWarnings = toShowWarns;
+      }
+    }
+    else if (anArgCase == "-extra"
+          || anArgCase == "-extramsg"
+          || anArgCase == "-extramessages")
+    {
+      Standard_Boolean toShow = Standard_True;
+      if (++anArgIter < theArgNb
+      && !parseOnOff (theArgVec[anArgIter], toShow))
+      {
+        --anArgIter;
+      }
+      aDefCaps->suppressExtraMsg = !toShow;
+      if (aCaps != NULL)
+      {
+        aCaps->suppressExtraMsg = !toShow;
+      }
+    }
+    else if (anArgCase == "-noextra"
+          || anArgCase == "-noextramsg"
+          || anArgCase == "-noextramessages")
+    {
+      Standard_Boolean toSuppress = Standard_True;
+      if (++anArgIter < theArgNb
+      && !parseOnOff (theArgVec[anArgIter], toSuppress))
+      {
+        --anArgIter;
+      }
+      aDefCaps->suppressExtraMsg = toSuppress;
+      if (aCaps != NULL)
+      {
+        aCaps->suppressExtraMsg = toSuppress;
+      }
+    }
+    else if (anArgCase == "-sync")
+    {
+      Standard_Boolean toSync = Standard_True;
+      if (++anArgIter < theArgNb
+      && !parseOnOff (theArgVec[anArgIter], toSync))
+      {
+        --anArgIter;
+      }
+      aDefCaps->contextSyncDebug = toSync;
+      if (toSync)
+      {
+        aDefCaps->contextDebug = Standard_True;
+      }
+    }
+    else if (anArgCase == "-debug")
+    {
+      if (++anArgIter < theArgNb
+      && !parseOnOff (theArgVec[anArgIter], toEnableDebug))
+      {
+        --anArgIter;
+      }
+      aDefCaps->contextDebug = toEnableDebug;
+    }
+    else if (parseOnOff (anArg, toEnableDebug)
+          && (anArgIter + 1 == theArgNb))
+    {
+      // simple alias to turn on almost everything
+      aDefCaps->contextDebug     = toEnableDebug;
+      aDefCaps->contextSyncDebug = toEnableDebug;
+      aDefCaps->glslWarnings     = toEnableDebug;
+    }
+    else
+    {
+      std::cout << "Error: wrong syntax at '" << anArg << "'\n";
+      return 1;
+    }
+  }
+
   return 0;
 }
 
@@ -4112,10 +5532,10 @@ static int VCaps (Draw_Interpretor& theDI,
 {
   OpenGl_Caps* aCaps = &ViewerTest_myDefaultCaps;
   Handle(OpenGl_GraphicDriver)   aDriver;
-  Handle(AIS_InteractiveContext) aContextAIS = ViewerTest::GetAISContext();
-  if (!aContextAIS.IsNull())
+  Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
+  if (!aContext.IsNull())
   {
-    aDriver = Handle(OpenGl_GraphicDriver)::DownCast (aContextAIS->CurrentViewer()->Driver());
+    aDriver = Handle(OpenGl_GraphicDriver)::DownCast (aContext->CurrentViewer()->Driver());
     aCaps   = &aDriver->ChangeOptions();
   }
 
@@ -4124,27 +5544,133 @@ static int VCaps (Draw_Interpretor& theDI,
     theDI << "VBO:     " << (aCaps->vboDisable        ? "0" : "1") << "\n";
     theDI << "Sprites: " << (aCaps->pntSpritesDisable ? "0" : "1") << "\n";
     theDI << "SoftMode:" << (aCaps->contextNoAccel    ? "1" : "0") << "\n";
+    theDI << "FFP:     " << (aCaps->ffpEnable         ? "1" : "0") << "\n";
+    theDI << "VSync:   " <<  aCaps->swapInterval                   << "\n";
+    theDI << "Compatible:" << (aCaps->contextCompatible ? "1" : "0") << "\n";
+    theDI << "Stereo:  " << (aCaps->contextStereo ? "1" : "0") << "\n";
     return 0;
   }
 
+  ViewerTest_AutoUpdater anUpdateTool (aContext, ViewerTest::CurrentView());
   for (Standard_Integer anArgIter = 1; anArgIter < theArgNb; ++anArgIter)
   {
-    const TCollection_AsciiString anArg (theArgVec[anArgIter]);
-    if (anArg.Search ("vbo=") > -1)
+    Standard_CString        anArg     = theArgVec[anArgIter];
+    TCollection_AsciiString anArgCase (anArg);
+    anArgCase.LowerCase();
+    if (anUpdateTool.parseRedrawMode (anArg))
+    {
+      continue;
+    }
+    else if (anArgCase == "-vsync"
+          || anArgCase == "-swapinterval")
+    {
+      Standard_Boolean toEnable = Standard_True;
+      if (++anArgIter < theArgNb
+      && !parseOnOff (theArgVec[anArgIter], toEnable))
+      {
+        --anArgIter;
+      }
+      aCaps->swapInterval = toEnable;
+    }
+    else if (anArgCase == "-ffp")
+    {
+      Standard_Boolean toEnable = Standard_True;
+      if (++anArgIter < theArgNb
+      && !parseOnOff (theArgVec[anArgIter], toEnable))
+      {
+        --anArgIter;
+      }
+      aCaps->ffpEnable = toEnable;
+    }
+    else if (anArgCase == "-vbo")
+    {
+      Standard_Boolean toEnable = Standard_True;
+      if (++anArgIter < theArgNb
+      && !parseOnOff (theArgVec[anArgIter], toEnable))
+      {
+        --anArgIter;
+      }
+      aCaps->vboDisable = !toEnable;
+    }
+    else if (anArgCase == "-sprite"
+          || anArgCase == "-sprites")
+    {
+      Standard_Boolean toEnable = Standard_True;
+      if (++anArgIter < theArgNb
+      && !parseOnOff (theArgVec[anArgIter], toEnable))
+      {
+        --anArgIter;
+      }
+      aCaps->pntSpritesDisable = !toEnable;
+    }
+    else if (anArgCase == "-softmode")
+    {
+      Standard_Boolean toEnable = Standard_True;
+      if (++anArgIter < theArgNb
+      && !parseOnOff (theArgVec[anArgIter], toEnable))
+      {
+        --anArgIter;
+      }
+      aCaps->contextNoAccel = toEnable;
+    }
+    else if (anArgCase == "-accel"
+          || anArgCase == "-acceleration")
+    {
+      Standard_Boolean toEnable = Standard_True;
+      if (++anArgIter < theArgNb
+      && !parseOnOff (theArgVec[anArgIter], toEnable))
+      {
+        --anArgIter;
+      }
+      aCaps->contextNoAccel = !toEnable;
+    }
+    else if (anArgCase == "-compat"
+          || anArgCase == "-compatprofile"
+          || anArgCase == "-compatible"
+          || anArgCase == "-compatibleprofile")
     {
-      aCaps->vboDisable        = anArg.Token ("=", 2).IntegerValue() == 0;
+      Standard_Boolean toEnable = Standard_True;
+      if (++anArgIter < theArgNb
+      && !parseOnOff (theArgVec[anArgIter], toEnable))
+      {
+        --anArgIter;
+      }
+      aCaps->contextCompatible = toEnable;
+      if (!aCaps->contextCompatible)
+      {
+        aCaps->ffpEnable = Standard_False;
+      }
     }
-    else if (anArg.Search ("sprites=") > -1)
+    else if (anArgCase == "-core"
+          || anArgCase == "-coreprofile")
     {
-      aCaps->pntSpritesDisable = anArg.Token ("=", 2).IntegerValue() == 0;
+      Standard_Boolean toEnable = Standard_True;
+      if (++anArgIter < theArgNb
+      && !parseOnOff (theArgVec[anArgIter], toEnable))
+      {
+        --anArgIter;
+      }
+      aCaps->contextCompatible = !toEnable;
+      if (!aCaps->contextCompatible)
+      {
+        aCaps->ffpEnable = Standard_False;
+      }
     }
-    else if (anArg.Search ("soft=") > -1)
+    else if (anArgCase == "-stereo"
+          || anArgCase == "-quadbuffer")
     {
-      aCaps->contextNoAccel = anArg.Token ("=", 2).IntegerValue() != 0;
+      Standard_Boolean toEnable = Standard_True;
+      if (++anArgIter < theArgNb
+      && !parseOnOff (theArgVec[anArgIter], toEnable))
+      {
+        --anArgIter;
+      }
+      aCaps->contextStereo = toEnable;
     }
     else
     {
-      std::cerr << "Unknown argument: " << anArg << "\n";
+      std::cout << "Error: unknown argument '" << anArg << "'\n";
+      return 1;
     }
   }
   if (aCaps != &ViewerTest_myDefaultCaps)
@@ -4375,7 +5901,7 @@ static int VDiffImage (Draw_Interpretor& theDI, Standard_Integer theArgNb, const
   theDI << aDiffColorsNb << "\n";
 
   // save image of difference
-  if (aDiffImagePath != NULL)
+  if (aDiffColorsNb >0 && aDiffImagePath != NULL)
   {
     aComparer.SaveDiffImage (aDiffImagePath);
   }
@@ -4408,34 +5934,48 @@ static Standard_Integer VSelect (Draw_Interpretor& di,
     di << "use 'vinit' command before " << argv[0] << "\n";
     return 1;
   }
-  const Standard_Boolean isShiftSelection = (argc>3 && !(argc%2) && (atoi(argv[argc-1])==1));
+
+  const Standard_Boolean isShiftSelection = (argc > 3 && !(argc % 2) && (atoi (argv[argc - 1]) == 1));
+  Standard_Integer aCoordsNb = isShiftSelection ? argc - 2 : argc - 1;
+  TCollection_AsciiString anArg;
+  anArg = isShiftSelection ? argv[argc - 3] : argv[argc - 2];
+  anArg.LowerCase();
+  if (anArg == "-allowoverlap")
+  {
+    Standard_Boolean isValidated = isShiftSelection ? argc == 8
+      : argc == 7;
+    if (!isValidated)
+    {
+      di << "Wrong number of arguments! -allowoverlap key is applied only for rectangle selection";
+      return 1;
+    }
+
+    Standard_Integer isToAllow = isShiftSelection ? Draw::Atoi(argv[argc - 2]) : Draw::Atoi(argv[argc - 1]);
+    myAIScontext->MainSelector()->AllowOverlapDetection((Standard_Boolean)isToAllow);
+    aCoordsNb -= 2;
+  }
+
   Handle(ViewerTest_EventManager) aCurrentEventManager = ViewerTest::CurrentEventManager();
   aCurrentEventManager->MoveTo(atoi(argv[1]),atoi(argv[2]));
-  if(argc <= 4)
+  if(aCoordsNb == 2)
   {
     if(isShiftSelection)
       aCurrentEventManager->ShiftSelect();
     else
       aCurrentEventManager->Select();
   }
-  else if(argc <= 6)
+  else if(aCoordsNb == 4)
   {
     if(isShiftSelection)
-      aCurrentEventManager->ShiftSelect(atoi(argv[1]),atoi(argv[2]),atoi(argv[3]),atoi(argv[4]));
+      aCurrentEventManager->ShiftSelect (atoi (argv[1]), atoi (argv[2]), atoi (argv[3]), atoi (argv[4]), Standard_False);
     else
-      aCurrentEventManager->Select(atoi(argv[1]),atoi(argv[2]),atoi(argv[3]),atoi(argv[4]));
+      aCurrentEventManager->Select (atoi (argv[1]), atoi (argv[2]), atoi (argv[3]), atoi (argv[4]), Standard_False);
   }
   else
   {
-    Standard_Integer anUpper = 0;
-
-    if(isShiftSelection)
-      anUpper = (argc-1)/2;
-    else
-      anUpper = argc/2;
-    TColgp_Array1OfPnt2d aPolyline(1,anUpper);
+    TColgp_Array1OfPnt2d aPolyline (1,aCoordsNb / 2);
 
-    for(Standard_Integer i=1;i<=anUpper;++i)
+    for(Standard_Integer i=1;i<=aCoordsNb / 2;++i)
       aPolyline.SetValue(i,gp_Pnt2d(atoi(argv[2*i-1]),atoi(argv[2*i])));
 
     if(isShiftSelection)
@@ -4797,13 +6337,13 @@ static Standard_Integer VZClipping (Draw_Interpretor& di,
       Quantity_Length aDepth = 0., aWidth = 1.;
       if(argc == 3)
       {
-        aDepth = atof(argv[1]);
-        aWidth = atof(argv[2]);
+        aDepth = Draw::Atof (argv[1]);
+        aWidth = Draw::Atof (argv[2]);
       }
       else if(argc == 4)
       {
-        aDepth = atof(argv[2]);
-        aWidth = atof(argv[3]);
+        aDepth = Draw::Atof (argv[2]);
+        aWidth = Draw::Atof (argv[3]);
       }
 
       if(aDepth<0. || aDepth>1.)
@@ -4924,7 +6464,7 @@ static Standard_Integer VSetViewSize (Draw_Interpretor& di,
     di<<"Usage : " << argv[0] << " Size\n";
     return 1;
   }
-  Standard_Real aSize = atof(argv[1]);
+  Standard_Real aSize = Draw::Atof (argv[1]);
   if (aSize <= 0.)
   {
     di<<"Bad Size value  : " << aSize << "\n";
@@ -4955,13 +6495,13 @@ static Standard_Integer VMoveView (Draw_Interpretor& di,
     di<<"Usage : " << argv[0] << " Dx Dy Dz [Start = 1|0]\n";
     return 1;
   }
-  Standard_Real Dx = atof(argv[1]);
-  Standard_Real Dy = atof(argv[2]);
-  Standard_Real Dz = atof(argv[3]);
+  Standard_Real Dx = Draw::Atof (argv[1]);
+  Standard_Real Dy = Draw::Atof (argv[2]);
+  Standard_Real Dz = Draw::Atof (argv[3]);
   Standard_Boolean aStart = Standard_True;
   if (argc == 5)
   {
-      aStart = (atoi(argv[4]) > 0);
+      aStart = (Draw::Atoi (argv[4]) > 0);
   }
 
   Handle(V3d_View) aView = ViewerTest::CurrentView();
@@ -4988,13 +6528,13 @@ static Standard_Integer VTranslateView (Draw_Interpretor& di,
     di<<"Usage : " << argv[0] << " Dx Dy Dz [Start = 1|0]\n";
     return 1;
   }
-  Standard_Real Dx = atof(argv[1]);
-  Standard_Real Dy = atof(argv[2]);
-  Standard_Real Dz = atof(argv[3]);
+  Standard_Real Dx = Draw::Atof (argv[1]);
+  Standard_Real Dy = Draw::Atof (argv[2]);
+  Standard_Real Dz = Draw::Atof (argv[3]);
   Standard_Boolean aStart = Standard_True;
   if (argc == 5)
   {
-      aStart = (atoi(argv[4]) > 0);
+      aStart = (Draw::Atoi (argv[4]) > 0);
   }
 
   Handle(V3d_View) aView = ViewerTest::CurrentView();
@@ -5019,13 +6559,13 @@ static Standard_Integer VTurnView (Draw_Interpretor& di,
     di<<"Usage : " << argv[0] << " Ax Ay Az [Start = 1|0]\n";
     return 1;
   }
-  Standard_Real Ax = atof(argv[1]);
-  Standard_Real Ay = atof(argv[2]);
-  Standard_Real Az = atof(argv[3]);
+  Standard_Real Ax = Draw::Atof (argv[1]);
+  Standard_Real Ay = Draw::Atof (argv[2]);
+  Standard_Real Az = Draw::Atof (argv[3]);
   Standard_Boolean aStart = Standard_True;
   if (argc == 5)
   {
-      aStart = (atoi(argv[4]) > 0);
+      aStart = (Draw::Atoi (argv[4]) > 0);
   }
 
   Handle(V3d_View) aView = ViewerTest::CurrentView();
@@ -5050,11 +6590,12 @@ public:
                             const Standard_ShortReal theXShift,
                             const Standard_ShortReal theYShift,
                             const Standard_ShortReal theAngle);
-  DEFINE_STANDARD_RTTI(OCC_TextureEnv);
+  DEFINE_STANDARD_RTTI(OCC_TextureEnv, Graphic3d_TextureEnv);
 };
 DEFINE_STANDARD_HANDLE(OCC_TextureEnv, Graphic3d_TextureEnv);
-IMPLEMENT_STANDARD_HANDLE(OCC_TextureEnv, Graphic3d_TextureEnv);
-IMPLEMENT_STANDARD_RTTIEXT(OCC_TextureEnv, Graphic3d_TextureEnv);
+
+
+
 
 OCC_TextureEnv::OCC_TextureEnv(const Standard_CString theFileName)
   : Graphic3d_TextureEnv(theFileName)
@@ -5414,10 +6955,10 @@ static int VClipPlane (Draw_Interpretor& theDi, Standard_Integer theArgsNb, cons
         return 1;
       }
 
-      Standard_Real aCoeffA = atof (theArgVec [4]);
-      Standard_Real aCoeffB = atof (theArgVec [5]);
-      Standard_Real aCoeffC = atof (theArgVec [6]);
-      Standard_Real aCoeffD = atof (theArgVec [7]);
+      Standard_Real aCoeffA = Draw::Atof (theArgVec [4]);
+      Standard_Real aCoeffB = Draw::Atof (theArgVec [5]);
+      Standard_Real aCoeffC = Draw::Atof (theArgVec [6]);
+      Standard_Real aCoeffD = Draw::Atof (theArgVec [7]);
       aClipPlane->SetEquation (gp_Pln (aCoeffA, aCoeffB, aCoeffC, aCoeffD));
     }
     else if (aChangeArg == "capping") // change capping aspects
@@ -5450,12 +6991,14 @@ static int VClipPlane (Draw_Interpretor& theDi, Standard_Integer theArgsNb, cons
           return 1;
         }
 
-        Standard_Real aRed = atof (theArgVec [5]);
-        Standard_Real aGrn = atof (theArgVec [6]);
-        Standard_Real aBlu = atof (theArgVec [7]);
+        Standard_Real aRed = Draw::Atof (theArgVec [5]);
+        Standard_Real aGrn = Draw::Atof (theArgVec [6]);
+        Standard_Real aBlu = Draw::Atof (theArgVec [7]);
 
         Graphic3d_MaterialAspect aMat = aClipPlane->CappingMaterial();
-        aMat.SetColor (Quantity_Color (aRed, aGrn, aBlu, Quantity_TOC_RGB));
+        Quantity_Color aColor (aRed, aGrn, aBlu, Quantity_TOC_RGB);
+        aMat.SetAmbientColor (aColor);
+        aMat.SetDiffuseColor (aColor);
         aClipPlane->SetCappingMaterial (aMat);
       }
       else if (aCappingArg == "texname") // texture name
@@ -5628,8 +7171,8 @@ static int VZRange (Draw_Interpretor& theDi, Standard_Integer theArgsNb, const c
 
   if (theArgsNb == 3)
   {
-    Standard_Real aNewZNear = atof (theArgVec[1]);
-    Standard_Real aNewZFar = atof (theArgVec[2]);
+    Standard_Real aNewZNear = Draw::Atof (theArgVec[1]);
+    Standard_Real aNewZFar  = Draw::Atof (theArgVec[2]);
 
     if (aNewZNear >= aNewZFar)
     {
@@ -5671,7 +7214,7 @@ static int VAutoZFit (Draw_Interpretor& theDi, Standard_Integer theArgsNb, const
     return 1;
   }
 
-  Standard_Real aScale = aCurrentView->AutoZFitScaleFactor();
+  Standard_Real aScale = aCurrentView->View()->AutoZFitScaleFactor();
 
   if (theArgsNb > 3)
   {
@@ -5682,7 +7225,7 @@ static int VAutoZFit (Draw_Interpretor& theDi, Standard_Integer theArgsNb, const
   if (theArgsNb < 2)
   {
     theDi << "Auto z-fit mode: " << "\n"
-          << "On: " << (aCurrentView->AutoZFitMode() ? "enabled" : "disabled") << "\n"
+          << "On: " << (aCurrentView->View()->AutoZFitMode() ? "enabled" : "disabled") << "\n"
           << "Scale: " << aScale << "\n";
     return 0;
   }
@@ -5694,126 +7237,313 @@ static int VAutoZFit (Draw_Interpretor& theDi, Standard_Integer theArgsNb, const
     aScale = Draw::Atoi (theArgVec[2]);
   }
 
-  aCurrentView->SetAutoZFitMode (isOn, aScale);
-  aCurrentView->AutoZFit();
+  aCurrentView->View()->SetAutoZFitMode (isOn, aScale);
+  aCurrentView->View()->AutoZFit();
   aCurrentView->Redraw();
 
   return 0;
 }
 
+//! Auxiliary function to print projection type
+inline const char* projTypeName (Graphic3d_Camera::Projection theProjType)
+{
+  switch (theProjType)
+  {
+    case Graphic3d_Camera::Projection_Orthographic: return "orthographic";
+    case Graphic3d_Camera::Projection_Perspective:  return "perspective";
+    case Graphic3d_Camera::Projection_Stereo:       return "stereoscopic";
+    case Graphic3d_Camera::Projection_MonoLeftEye:  return "monoLeftEye";
+    case Graphic3d_Camera::Projection_MonoRightEye: return "monoRightEye";
+  }
+  return "UNKNOWN";
+}
+
 //===============================================================================================
-//function : VChangeCamera
+//function : VCamera
 //purpose  :
 //===============================================================================================
-static int VChangeCamera (Draw_Interpretor& theDi, Standard_Integer theArgsNb, const char** theArgVec)
+static int VCamera (Draw_Interpretor& theDI,
+                    Standard_Integer  theArgsNb,
+                    const char**      theArgVec)
 {
-  if (ViewerTest::CurrentView().IsNull())
+  Handle(V3d_View) aView = ViewerTest::CurrentView();
+  if (aView.IsNull())
   {
-    theDi << theArgVec[0] << ": Call vinit before this command, please.\n";
+    std::cout << "Error: no active view.\n";
     return 1;
   }
 
-  const char anErrorMessage[] = ": wrong command arguments. Type help for more information.\n";
-  if (theArgsNb < 3)
+  Handle(Graphic3d_Camera) aCamera = aView->Camera();
+  if (theArgsNb < 2)
   {
-    theDi << theArgVec[0] << anErrorMessage;
-    return 1;
+    theDI << "ProjType:   " << projTypeName (aCamera->ProjectionType()) << "\n";
+    theDI << "FOVy:       " << aCamera->FOVy() << "\n";
+    theDI << "Distance:   " << aCamera->Distance() << "\n";
+    theDI << "IOD:        " << aCamera->IOD() << "\n";
+    theDI << "IODType:    " << (aCamera->GetIODType() == Graphic3d_Camera::IODType_Absolute   ? "absolute" : "relative") << "\n";
+    theDI << "ZFocus:     " << aCamera->ZFocus() << "\n";
+    theDI << "ZFocusType: " << (aCamera->ZFocusType() == Graphic3d_Camera::FocusType_Absolute ? "absolute" : "relative") << "\n";
+    return 0;
   }
 
-  Handle(Graphic3d_Camera) aCamera = ViewerTest::CurrentView()->Camera();
-
-  TCollection_AsciiString aCommand (theArgVec[1]);
-  TCollection_AsciiString aValue (theArgVec[2]);
-
-  aCommand.LowerCase();
-  aValue.LowerCase();
-
-  if (aCommand == "proj")
+  for (Standard_Integer anArgIter = 1; anArgIter < theArgsNb; ++anArgIter)
   {
-    if (aValue == "ortho")
+    Standard_CString        anArg = theArgVec[anArgIter];
+    TCollection_AsciiString anArgCase (anArg);
+    anArgCase.LowerCase();
+    if (anArgCase == "-proj"
+     || anArgCase == "-projection"
+     || anArgCase == "-projtype"
+     || anArgCase == "-projectiontype")
+    {
+      theDI << projTypeName (aCamera->ProjectionType()) << " ";
+    }
+    else if (anArgCase == "-ortho"
+          || anArgCase == "-orthographic")
     {
       aCamera->SetProjectionType (Graphic3d_Camera::Projection_Orthographic);
-    } 
-    else if (aValue == "persp")
+    }
+    else if (anArgCase == "-persp"
+          || anArgCase == "-perspective"
+          || anArgCase == "-perspmono"
+          || anArgCase == "-perspectivemono"
+          || anArgCase == "-mono")
     {
       aCamera->SetProjectionType (Graphic3d_Camera::Projection_Perspective);
     }
-    else if (aValue == "left")
+    else if (anArgCase == "-stereo"
+          || anArgCase == "-stereoscopic"
+          || anArgCase == "-perspstereo"
+          || anArgCase == "-perspectivestereo")
+    {
+      aCamera->SetProjectionType (Graphic3d_Camera::Projection_Stereo);
+    }
+    else if (anArgCase == "-left"
+          || anArgCase == "-lefteye"
+          || anArgCase == "-monoleft"
+          || anArgCase == "-monolefteye"
+          || anArgCase == "-perpsleft"
+          || anArgCase == "-perpslefteye")
     {
       aCamera->SetProjectionType (Graphic3d_Camera::Projection_MonoLeftEye);
     }
-    else if (aValue == "right")
+    else if (anArgCase == "-right"
+          || anArgCase == "-righteye"
+          || anArgCase == "-monoright"
+          || anArgCase == "-monorighteye"
+          || anArgCase == "-perpsright")
     {
       aCamera->SetProjectionType (Graphic3d_Camera::Projection_MonoRightEye);
     }
-    else if (aValue == "stereo")
+    else if (anArgCase == "-dist"
+          || anArgCase == "-distance")
     {
-      aCamera->SetProjectionType (Graphic3d_Camera::Projection_Stereo);
+      Standard_CString anArgValue = (anArgIter + 1 < theArgsNb) ? theArgVec[anArgIter + 1] : NULL;
+      if (anArgValue != NULL
+      && *anArgValue != '-')
+      {
+        ++anArgIter;
+        aCamera->SetDistance (Draw::Atof (anArgValue));
+        continue;
+      }
+      theDI << aCamera->Distance() << " ";
+    }
+    else if (anArgCase == "-iod")
+    {
+      Standard_CString anArgValue = (anArgIter + 1 < theArgsNb) ? theArgVec[anArgIter + 1] : NULL;
+      if (anArgValue != NULL
+      && *anArgValue != '-')
+      {
+        ++anArgIter;
+        aCamera->SetIOD (aCamera->GetIODType(), Draw::Atof (anArgValue));
+        continue;
+      }
+      theDI << aCamera->IOD() << " ";
+    }
+    else if (anArgCase == "-iodtype")
+    {
+      Standard_CString        anArgValue = (anArgIter + 1 < theArgsNb) ? theArgVec[anArgIter + 1] : "";
+      TCollection_AsciiString anValueCase (anArgValue);
+      anValueCase.LowerCase();
+      if (anValueCase == "abs"
+       || anValueCase == "absolute")
+      {
+        ++anArgIter;
+        aCamera->SetIOD (Graphic3d_Camera::IODType_Absolute, aCamera->IOD());
+        continue;
+      }
+      else if (anValueCase == "rel"
+            || anValueCase == "relative")
+      {
+        ++anArgIter;
+        aCamera->SetIOD (Graphic3d_Camera::IODType_Relative, aCamera->IOD());
+        continue;
+      }
+      else if (*anArgValue != '-')
+      {
+        std::cout << "Error: unknown IOD type '" << anArgValue << "'\n";
+        return 1;
+      }
+      switch (aCamera->GetIODType())
+      {
+        case Graphic3d_Camera::IODType_Absolute: theDI << "absolute "; break;
+        case Graphic3d_Camera::IODType_Relative: theDI << "relative "; break;
+      }
+    }
+    else if (anArgCase == "-zfocus")
+    {
+      Standard_CString anArgValue = (anArgIter + 1 < theArgsNb) ? theArgVec[anArgIter + 1] : NULL;
+      if (anArgValue != NULL
+      && *anArgValue != '-')
+      {
+        ++anArgIter;
+        aCamera->SetZFocus (aCamera->ZFocusType(), Draw::Atof (anArgValue));
+        continue;
+      }
+      theDI << aCamera->ZFocus() << " ";
+    }
+    else if (anArgCase == "-zfocustype")
+    {
+      Standard_CString        anArgValue = (anArgIter + 1 < theArgsNb) ? theArgVec[anArgIter + 1] : "";
+      TCollection_AsciiString anValueCase (anArgValue);
+      anValueCase.LowerCase();
+      if (anValueCase == "abs"
+       || anValueCase == "absolute")
+      {
+        ++anArgIter;
+        aCamera->SetZFocus (Graphic3d_Camera::FocusType_Absolute, aCamera->ZFocus());
+        continue;
+      }
+      else if (anValueCase == "rel"
+            || anValueCase == "relative")
+      {
+        ++anArgIter;
+        aCamera->SetZFocus (Graphic3d_Camera::FocusType_Relative, aCamera->ZFocus());
+        continue;
+      }
+      else if (*anArgValue != '-')
+      {
+        std::cout << "Error: unknown ZFocus type '" << anArgValue << "'\n";
+        return 1;
+      }
+      switch (aCamera->ZFocusType())
+      {
+        case Graphic3d_Camera::FocusType_Absolute: theDI << "absolute "; break;
+        case Graphic3d_Camera::FocusType_Relative: theDI << "relative "; break;
+      }
+    }
+    else if (anArgCase == "-fov"
+          || anArgCase == "-fovy")
+    {
+      Standard_CString anArgValue = (anArgIter + 1 < theArgsNb) ? theArgVec[anArgIter + 1] : NULL;
+      if (anArgValue != NULL
+      && *anArgValue != '-')
+      {
+        ++anArgIter;
+        aCamera->SetFOVy (Draw::Atof (anArgValue));
+        continue;
+      }
+      theDI << aCamera->FOVy() << " ";
     }
     else
     {
-      theDi << theArgVec[0] << anErrorMessage;
+      std::cout << "Error: unknown argument '" << anArg << "'\n";
       return 1;
     }
   }
-  else if (aCommand == "dist")
+
+  aView->View()->AutoZFit();
+  aView->Redraw();
+
+  return 0;
+}
+
+//! Parse stereo output mode
+inline Standard_Boolean parseStereoMode (Standard_CString      theArg,
+                                         Graphic3d_StereoMode& theMode)
+{
+  TCollection_AsciiString aFlag (theArg);
+  aFlag.LowerCase();
+  if (aFlag == "quadbuffer")
   {
-    aCamera->SetDistance (aValue.RealValue());
+    theMode = Graphic3d_StereoMode_QuadBuffer;
   }
-  else if (aCommand == "iod")
+  else if (aFlag == "anaglyph")
   {
-    aCamera->SetIOD (aCamera->GetIODType(), aValue.RealValue());
+    theMode = Graphic3d_StereoMode_Anaglyph;
   }
-  else if (aCommand == "zfocus")
+  else if (aFlag == "row"
+        || aFlag == "rowinterlaced")
   {
-    aCamera->SetZFocus (aCamera->ZFocusType(), aValue.RealValue());
+    theMode = Graphic3d_StereoMode_RowInterlaced;
   }
-  else if (aCommand == "fov")
+  else if (aFlag == "col"
+        || aFlag == "colinterlaced"
+        || aFlag == "columninterlaced")
   {
-    aCamera->SetFOVy (aValue.RealValue());
+    theMode = Graphic3d_StereoMode_ColumnInterlaced;
   }
-  else if (aCommand == "zfocustype")
+  else if (aFlag == "chess"
+        || aFlag == "chessboard")
   {
-    if (aValue == "absolute")
-    {
-      aCamera->SetZFocus (Graphic3d_Camera::FocusType_Absolute, aCamera->ZFocus());
-    } 
-    else if (aValue == "relative")
-    {
-      aCamera->SetZFocus (Graphic3d_Camera::FocusType_Relative, aCamera->ZFocus());
-    }
-    else
-    {
-      theDi << theArgVec[0] << anErrorMessage;
-      return 1;
-    }
+    theMode = Graphic3d_StereoMode_ChessBoard;
   }
-  else if (aCommand == "iodtype")
+  else if (aFlag == "sbs"
+        || aFlag == "sidebyside")
   {
-    if (aValue == "absolute")
-    {
-      aCamera->SetIOD (Graphic3d_Camera::IODType_Absolute, aCamera->IOD());
-    } 
-    else if (aValue == "relative")
-    {
-      aCamera->SetIOD (Graphic3d_Camera::IODType_Relative, aCamera->IOD());
-    }
-    else
-    {
-      theDi << theArgVec[0] << anErrorMessage;
-      return 1;
-    }
+    theMode = Graphic3d_StereoMode_SideBySide;
+  }
+  else if (aFlag == "ou"
+        || aFlag == "overunder")
+  {
+    theMode = Graphic3d_StereoMode_OverUnder;
+  }
+  else if (aFlag == "pageflip"
+        || aFlag == "softpageflip")
+  {
+    theMode = Graphic3d_StereoMode_SoftPageFlip;
   }
   else
   {
-    theDi << theArgVec[0] << anErrorMessage;
-    return 1;
+    return Standard_False;
   }
+  return Standard_True;
+}
 
-  ViewerTest::CurrentView()->AutoZFit();
-  ViewerTest::CurrentView()->Redraw();
-
-  return 0;
+//! Parse anaglyph filter
+inline Standard_Boolean parseAnaglyphFilter (Standard_CString                     theArg,
+                                             Graphic3d_RenderingParams::Anaglyph& theFilter)
+{
+  TCollection_AsciiString aFlag (theArg);
+  aFlag.LowerCase();
+  if (aFlag == "redcyansimple")
+  {
+    theFilter = Graphic3d_RenderingParams::Anaglyph_RedCyan_Simple;
+  }
+  else if (aFlag == "redcyan"
+        || aFlag == "redcyanoptimized")
+  {
+    theFilter = Graphic3d_RenderingParams::Anaglyph_RedCyan_Optimized;
+  }
+  else if (aFlag == "yellowbluesimple")
+  {
+    theFilter = Graphic3d_RenderingParams::Anaglyph_YellowBlue_Simple;
+  }
+  else if (aFlag == "yellowblue"
+        || aFlag == "yellowblueoptimized")
+  {
+    theFilter = Graphic3d_RenderingParams::Anaglyph_YellowBlue_Optimized;
+  }
+  else if (aFlag == "greenmagenta"
+        || aFlag == "greenmagentasimple")
+  {
+    theFilter = Graphic3d_RenderingParams::Anaglyph_GreenMagenta_Simple;
+  }
+  else
+  {
+    return Standard_False;
+  }
+  return Standard_True;
 }
 
 //==============================================================================
@@ -5825,12 +7555,12 @@ static int VStereo (Draw_Interpretor& theDI,
                     Standard_Integer  theArgNb,
                     const char**      theArgVec)
 {
+  Handle(V3d_View) aView = ViewerTest::CurrentView();
   if (theArgNb < 2)
   {
-    Handle(V3d_View) aView = ViewerTest::CurrentView();
     if (aView.IsNull())
     {
-      std::cerr << "No active view. Please call vinit.\n";
+      std::cout << "Error: no active viewer!\n";
       return 0;
     }
 
@@ -5839,7 +7569,130 @@ static int VStereo (Draw_Interpretor& theDI,
     return 0;
   }
 
-  ViewerTest_myDefaultCaps.contextStereo = Draw::Atoi (theArgVec[1]) != 0;
+  Handle(Graphic3d_Camera) aCamera;
+  Graphic3d_RenderingParams*   aParams   = NULL;
+  Graphic3d_StereoMode         aMode     = Graphic3d_StereoMode_QuadBuffer;
+  if (!aView.IsNull())
+  {
+    aParams   = &aView->ChangeRenderingParams();
+    aMode     = aParams->StereoMode;
+    aCamera   = aView->Camera();
+  }
+
+  ViewerTest_AutoUpdater anUpdateTool (ViewerTest::GetAISContext(), aView);
+  for (Standard_Integer anArgIter = 1; anArgIter < theArgNb; ++anArgIter)
+  {
+    Standard_CString        anArg = theArgVec[anArgIter];
+    TCollection_AsciiString aFlag (anArg);
+    aFlag.LowerCase();
+    if (anUpdateTool.parseRedrawMode (aFlag))
+    {
+      continue;
+    }
+    else if (aFlag == "0"
+          || aFlag == "off")
+    {
+      if (++anArgIter < theArgNb)
+      {
+        std::cout << "Error: wrong number of arguments!\n";
+        return 1;
+      }
+
+      if (!aCamera.IsNull()
+       &&  aCamera->ProjectionType() == Graphic3d_Camera::Projection_Stereo)
+      {
+        aCamera->SetProjectionType (Graphic3d_Camera::Projection_Perspective);
+      }
+      ViewerTest_myDefaultCaps.contextStereo = Standard_False;
+      return 0;
+    }
+    else if (aFlag == "1"
+          || aFlag == "on")
+    {
+      if (++anArgIter < theArgNb)
+      {
+        std::cout << "Error: wrong number of arguments!\n";
+        return 1;
+      }
+
+      if (!aCamera.IsNull())
+      {
+        aCamera->SetProjectionType (Graphic3d_Camera::Projection_Stereo);
+      }
+      ViewerTest_myDefaultCaps.contextStereo = Standard_True;
+      return 0;
+    }
+    else if (aFlag == "-reverse"
+          || aFlag == "-reversed"
+          || aFlag == "-swap")
+    {
+      Standard_Boolean toEnable = Standard_True;
+      if (++anArgIter < theArgNb
+      && !parseOnOff (theArgVec[anArgIter], toEnable))
+      {
+        --anArgIter;
+      }
+      aParams->ToReverseStereo = toEnable;
+    }
+    else if (aFlag == "-noreverse"
+          || aFlag == "-noswap")
+    {
+      Standard_Boolean toDisable = Standard_True;
+      if (++anArgIter < theArgNb
+      && !parseOnOff (theArgVec[anArgIter], toDisable))
+      {
+        --anArgIter;
+      }
+      aParams->ToReverseStereo = !toDisable;
+    }
+    else if (aFlag == "-mode"
+          || aFlag == "-stereomode")
+    {
+      if (++anArgIter >= theArgNb
+      || !parseStereoMode (theArgVec[anArgIter], aMode))
+      {
+        std::cout << "Error: syntax error at '" << anArg << "'\n";
+        return 1;
+      }
+
+      if (aMode == Graphic3d_StereoMode_QuadBuffer)
+      {
+        ViewerTest_myDefaultCaps.contextStereo = Standard_True;
+      }
+    }
+    else if (aFlag == "-anaglyph"
+          || aFlag == "-anaglyphfilter")
+    {
+      Graphic3d_RenderingParams::Anaglyph aFilter = Graphic3d_RenderingParams::Anaglyph_RedCyan_Simple;
+      if (++anArgIter >= theArgNb
+      || !parseAnaglyphFilter (theArgVec[anArgIter], aFilter))
+      {
+        std::cout << "Error: syntax error at '" << anArg << "'\n";
+        return 1;
+      }
+
+      aMode = Graphic3d_StereoMode_Anaglyph;
+      aParams->AnaglyphFilter = aFilter;
+    }
+    else if (parseStereoMode (anArg, aMode)) // short syntax
+    {
+      if (aMode == Graphic3d_StereoMode_QuadBuffer)
+      {
+        ViewerTest_myDefaultCaps.contextStereo = Standard_True;
+      }
+    }
+    else
+    {
+      std::cout << "Error: syntax error at '" << anArg << "'\n";
+      return 1;
+    }
+  }
+
+  if (!aView.IsNull())
+  {
+    aParams->StereoMode = aMode;
+    aCamera->SetProjectionType (Graphic3d_Camera::Projection_Stereo);
+  }
   return 0;
 }
 
@@ -5872,44 +7725,74 @@ static int VDefaults (Draw_Interpretor& theDi,
             << "AbsoluteDeflection: " << aDefParams->MaximalChordialDeviation() << "\n";
     }
     theDi << "AngularDeflection:  " << (180.0 * aDefParams->HLRAngle() / M_PI) << "\n";
+    theDi << "AutoTriangulation:  " << (aDefParams->IsAutoTriangulation() ? "on" : "off") << "\n";
     return 0;
   }
 
   for (Standard_Integer anArgIter = 1; anArgIter < theArgsNb; ++anArgIter)
   {
     TCollection_AsciiString anArg (theArgVec[anArgIter]);
-    TCollection_AsciiString aKey, aValue;
-    if (!ViewerTest::SplitParameter (anArg, aKey, aValue)
-     || aValue.IsEmpty())
-    {
-      std::cerr << "Error, wrong syntax at: '" << anArg.ToCString() << "'!\n";
-      return 1;
-    }
-
-    aKey.UpperCase();
-    if (aKey == "ABSDEFL"
-     || aKey == "ABSOLUTEDEFLECTION"
-     || aKey == "DEFL"
-     || aKey == "DEFLECTION")
+    anArg.UpperCase();
+    if (anArg == "-ABSDEFL"
+     || anArg == "-ABSOLUTEDEFLECTION"
+     || anArg == "-DEFL"
+     || anArg == "-DEFLECTION")
     {
+      if (++anArgIter >= theArgsNb)
+      {
+        std::cout << "Error: wrong syntax at " << anArg << "\n";
+        return 1;
+      }
       aDefParams->SetTypeOfDeflection         (Aspect_TOD_ABSOLUTE);
-      aDefParams->SetMaximalChordialDeviation (aValue.RealValue());
+      aDefParams->SetMaximalChordialDeviation (Draw::Atof (theArgVec[anArgIter]));
     }
-    else if (aKey == "RELDEFL"
-          || aKey == "RELATIVEDEFLECTION"
-          || aKey == "DEVCOEFF"
-          || aKey == "DEVIATIONCOEFF"
-          || aKey == "DEVIATIONCOEFFICIENT")
+    else if (anArg == "-RELDEFL"
+          || anArg == "-RELATIVEDEFLECTION"
+          || anArg == "-DEVCOEFF"
+          || anArg == "-DEVIATIONCOEFF"
+          || anArg == "-DEVIATIONCOEFFICIENT")
     {
+      if (++anArgIter >= theArgsNb)
+      {
+        std::cout << "Error: wrong syntax at " << anArg << "\n";
+        return 1;
+      }
       aDefParams->SetTypeOfDeflection     (Aspect_TOD_RELATIVE);
-      aDefParams->SetDeviationCoefficient (aValue.RealValue());
+      aDefParams->SetDeviationCoefficient (Draw::Atof (theArgVec[anArgIter]));
     }
-    else if (aKey == "ANGDEFL"
-          || aKey == "ANGULARDEFL"
-          || aKey == "ANGULARDEFLECTION")
+    else if (anArg == "-ANGDEFL"
+          || anArg == "-ANGULARDEFL"
+          || anArg == "-ANGULARDEFLECTION")
     {
+      if (++anArgIter >= theArgsNb)
+      {
+        std::cout << "Error: wrong syntax at " << anArg << "\n";
+        return 1;
+      }
       // currently HLRDeviationAngle is used instead of DeviationAngle in most places
-      aDefParams->SetHLRAngle (M_PI * aValue.RealValue() / 180.0);
+      aDefParams->SetHLRAngle (M_PI * Draw::Atof (theArgVec[anArgIter]) / 180.0);
+    }
+    else if (anArg == "-AUTOTR"
+          || anArg == "-AUTOTRIANG"
+          || anArg == "-AUTOTRIANGULATION")
+    {
+      if (++anArgIter >= theArgsNb)
+      {
+        std::cout << "Error: wrong syntax at " << anArg << "\n";
+        return 1;
+      }
+      TCollection_AsciiString aValue (theArgVec[anArgIter]);
+      aValue.LowerCase();
+      if (aValue == "on"
+       || aValue == "1")
+      {
+        aDefParams->SetAutoTriangulation (Standard_True);
+      }
+      else if (aValue == "off"
+            || aValue == "0")
+      {
+        aDefParams->SetAutoTriangulation (Standard_False);
+      }
     }
     else
     {
@@ -5987,58 +7870,64 @@ static int VLight (Draw_Interpretor& theDi,
       {
         case V3d_AMBIENT:
         {
-          theDi << "  Type:      Ambient\n";
+          theDi << "  Type:       Ambient\n";
+          theDi << "  Intensity:  " << aLight->Intensity() << "\n";
           break;
         }
         case V3d_DIRECTIONAL:
         {
           Handle(V3d_DirectionalLight) aLightDir = Handle(V3d_DirectionalLight)::DownCast (aLight);
-          theDi << "  Type:      Directional\n";
-          theDi << "  Headlight: " << (aLight->Headlight() ? "TRUE" : "FALSE") << "\n";
+          theDi << "  Type:       Directional\n";
+          theDi << "  Intensity:  " << aLight->Intensity() << "\n";
+          theDi << "  Headlight:  " << (aLight->Headlight() ? "TRUE" : "FALSE") << "\n";
+          theDi << "  Smoothness: " << aLight->Smoothness() << "\n";
           if (!aLightDir.IsNull())
           {
             aLightDir->Position  (anXYZ[0], anXYZ[1], anXYZ[2]);
-            theDi << "  Position:  " << anXYZ[0] << ", " << anXYZ[1] << ", " << anXYZ[2] << "\n";
+            theDi << "  Position:   " << anXYZ[0] << ", " << anXYZ[1] << ", " << anXYZ[2] << "\n";
             aLightDir->Direction (anXYZ[0], anXYZ[1], anXYZ[2]);
-            theDi << "  Direction: " << anXYZ[0] << ", " << anXYZ[1] << ", " << anXYZ[2] << "\n";
+            theDi << "  Direction:  " << anXYZ[0] << ", " << anXYZ[1] << ", " << anXYZ[2] << "\n";
           }
           break;
         }
         case V3d_POSITIONAL:
         {
           Handle(V3d_PositionalLight) aLightPos = Handle(V3d_PositionalLight)::DownCast (aLight);
-          theDi << "  Type:      Positional\n";
-          theDi << "  Headlight: " << (aLight->Headlight() ? "TRUE" : "FALSE") << "\n";
+          theDi << "  Type:       Positional\n";
+          theDi << "  Intensity:  " << aLight->Intensity() << "\n";
+          theDi << "  Headlight:  " << (aLight->Headlight() ? "TRUE" : "FALSE") << "\n";
+          theDi << "  Smoothness: " << aLight->Smoothness() << "\n";
           if (!aLightPos.IsNull())
           {
             aLightPos->Position  (anXYZ[0], anXYZ[1], anXYZ[2]);
-            theDi << "  Position:  " << anXYZ[0] << ", " << anXYZ[1] << ", " << anXYZ[2] << "\n";
+            theDi << "  Position:   " << anXYZ[0] << ", " << anXYZ[1] << ", " << anXYZ[2] << "\n";
             aLightPos->Attenuation (anAtten[0], anAtten[1]);
-            theDi << "  Atten.:    " << anAtten[0] << " " << anAtten[1] << "\n";
+            theDi << "  Atten.:     " << anAtten[0] << " " << anAtten[1] << "\n";
           }
           break;
         }
         case V3d_SPOT:
         {
           Handle(V3d_SpotLight) aLightSpot = Handle(V3d_SpotLight)::DownCast (aLight);
-          theDi << "  Type:      Spot\n";
-          theDi << "  Headlight: " << (aLight->Headlight() ? "TRUE" : "FALSE") << "\n";
+          theDi << "  Type:       Spot\n";
+          theDi << "  Intensity:  " << aLight->Intensity() << "\n";
+          theDi << "  Headlight:  " << (aLight->Headlight() ? "TRUE" : "FALSE") << "\n";
           if (!aLightSpot.IsNull())
           {
             aLightSpot->Position  (anXYZ[0], anXYZ[1], anXYZ[2]);
-            theDi << "  Position:  " << anXYZ[0] << ", " << anXYZ[1] << ", " << anXYZ[2] << "\n";
+            theDi << "  Position:   " << anXYZ[0] << ", " << anXYZ[1] << ", " << anXYZ[2] << "\n";
             aLightSpot->Direction (anXYZ[0], anXYZ[1], anXYZ[2]);
-            theDi << "  Direction: " << anXYZ[0] << ", " << anXYZ[1] << ", " << anXYZ[2] << "\n";
+            theDi << "  Direction:  " << anXYZ[0] << ", " << anXYZ[1] << ", " << anXYZ[2] << "\n";
             aLightSpot->Attenuation (anAtten[0], anAtten[1]);
-            theDi << "  Atten.:    " << anAtten[0] << " " << anAtten[1] << "\n";
-            theDi << "  Angle:     " << (aLightSpot->Angle() * 180.0 / M_PI) << "\n";
-            theDi << "  Exponent:  " << aLightSpot->Concentration() << "\n";
+            theDi << "  Atten.:     " << anAtten[0] << " " << anAtten[1] << "\n";
+            theDi << "  Angle:      " << (aLightSpot->Angle() * 180.0 / M_PI) << "\n";
+            theDi << "  Exponent:   " << aLightSpot->Concentration() << "\n";
           }
           break;
         }
         default:
         {
-          theDi << "  Type:      UNKNOWN\n";
+          theDi << "  Type:       UNKNOWN\n";
           break;
         }
       }
@@ -6270,6 +8159,56 @@ static int VLight (Draw_Interpretor& theDi,
         return 1;
       }
     }
+    else if (anArgCase.IsEqual ("SM")
+          || anArgCase.IsEqual ("SMOOTHNESS"))
+    {
+      if (++anArgIt >= theArgsNb)
+      {
+        std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+        return 1;
+      }
+
+      Standard_Real aSmoothness = Atof (theArgVec[anArgIt]);
+
+      if (fabs (aSmoothness) < Precision::Confusion())
+      {
+        aLightCurr->SetIntensity (1.f);
+      }
+      else if (fabs (aLightCurr->Smoothness()) < Precision::Confusion())
+      {
+        aLightCurr->SetIntensity ((aSmoothness * aSmoothness) / 3.f);
+      }
+      else
+      {
+        Standard_ShortReal aSmoothnessRatio = static_cast<Standard_ShortReal> (aSmoothness / aLightCurr->Smoothness());
+        aLightCurr->SetIntensity (aLightCurr->Intensity() / (aSmoothnessRatio * aSmoothnessRatio));
+      }
+
+      if (!aLightPos.IsNull())
+      {
+        aLightPos->SetSmoothRadius (aSmoothness);
+      }
+      else if (!aLightDir.IsNull())
+      {
+        aLightDir->SetSmoothAngle (aSmoothness);
+      }
+    }
+    else if (anArgCase.IsEqual ("INT")
+          || anArgCase.IsEqual ("INTENSITY"))
+    {
+      if (++anArgIt >= theArgsNb)
+      {
+        std::cerr << "Wrong syntax at argument '" << anArg << "'!\n";
+        return 1;
+      }
+
+      Standard_Real aIntensity = Atof (theArgVec[anArgIt]);
+
+      if (!aLightCurr.IsNull())
+      {
+        aLightCurr->SetIntensity (aIntensity);
+      }
+    }
     else if (anArgCase.IsEqual ("ANG")
           || anArgCase.IsEqual ("ANGLE"))
     {
@@ -6394,24 +8333,6 @@ static int VLight (Draw_Interpretor& theDi,
   return 0;
 }
 
-inline Standard_Boolean parseOnOff (Standard_CString  theArg,
-                                    Standard_Boolean& theIsOn)
-{
-  TCollection_AsciiString aFlag (theArg);
-  aFlag.LowerCase();
-  if (aFlag == "on")
-  {
-    theIsOn = Standard_True;
-    return Standard_True;
-  }
-  else if (aFlag == "off")
-  {
-    theIsOn = Standard_False;
-    return Standard_True;
-  }
-  return Standard_False;
-}
-
 //=======================================================================
 //function : VRenderParams
 //purpose  : Enables/disables rendering features
@@ -6429,6 +8350,45 @@ static Standard_Integer VRenderParams (Draw_Interpretor& theDI,
   }
 
   Graphic3d_RenderingParams& aParams = aView->ChangeRenderingParams();
+  TCollection_AsciiString aCmdName (theArgVec[0]);
+  aCmdName.LowerCase();
+  if (aCmdName == "vraytrace")
+  {
+    if (theArgNb == 1)
+    {
+      theDI << (aParams.Method == Graphic3d_RM_RAYTRACING ? "on" : "off") << " ";
+      return 0;
+    }
+    else if (theArgNb == 2)
+    {
+      TCollection_AsciiString aValue (theArgVec[1]);
+      aValue.LowerCase();
+      if (aValue == "on"
+       || aValue == "1")
+      {
+        aParams.Method = Graphic3d_RM_RAYTRACING;
+        aView->Redraw();
+        return 0;
+      }
+      else if (aValue == "off"
+            || aValue == "0")
+      {
+        aParams.Method = Graphic3d_RM_RASTERIZATION;
+        aView->Redraw();
+        return 0;
+      }
+      else
+      {
+        std::cout << "Error: unknown argument '" << theArgVec[1] << "'\n";
+        return 1;
+      }
+    }
+    else
+    {
+      std::cout << "Error: wrong number of arguments\n";
+      return 1;
+    }
+  }
 
   if (theArgNb < 2)
   {
@@ -6439,24 +8399,41 @@ static Standard_Integer VRenderParams (Draw_Interpretor& theDI,
       case Graphic3d_RM_RAYTRACING:    theDI << "raytrace ";      break;
     }
     theDI << "\n";
-    theDI << "fsaa:        " << (aParams.IsAntialiasingEnabled      ? "on" : "off") << "\n";
-    theDI << "shadows:     " << (aParams.IsShadowEnabled            ? "on" : "off") << "\n";
-    theDI << "reflections: " << (aParams.IsReflectionEnabled        ? "on" : "off") << "\n";
-    theDI << "rayDepth:    " <<  aParams.RaytracingDepth                            << "\n";
-    theDI << "gleam:       " << (aParams.IsTransparentShadowEnabled ? "on" : "off") << "\n";
+    theDI << "fsaa:         " << (aParams.IsAntialiasingEnabled       ? "on" : "off") << "\n";
+    theDI << "shadows:      " << (aParams.IsShadowEnabled             ? "on" : "off") << "\n";
+    theDI << "reflections:  " << (aParams.IsReflectionEnabled         ? "on" : "off") << "\n";
+    theDI << "rayDepth:     " <<  aParams.RaytracingDepth                             << "\n";
+    theDI << "gleam:        " << (aParams.IsTransparentShadowEnabled  ? "on" : "off") << "\n";
+    theDI << "GI:           " << (aParams.IsGlobalIlluminationEnabled ? "on" : "off") << "\n";
+    theDI << "blocked RNG:  " << (aParams.CoherentPathTracingMode     ? "on" : "off") << "\n";
+    theDI << "shadingModel: ";
+    switch (aView->ShadingModel())
+    {
+      case V3d_COLOR:   theDI << "color";   break;
+      case V3d_FLAT:    theDI << "flat";    break;
+      case V3d_GOURAUD: theDI << "gouraud"; break;
+      case V3d_PHONG:   theDI << "phong";   break;
+    }
+    theDI << "\n";
     return 0;
   }
 
   Standard_Boolean toPrint = Standard_False;
+  ViewerTest_AutoUpdater anUpdateTool (ViewerTest::GetAISContext(), aView);
   for (Standard_Integer anArgIter = 1; anArgIter < theArgNb; ++anArgIter)
   {
     Standard_CString        anArg (theArgVec[anArgIter]);
     TCollection_AsciiString aFlag (anArg);
     aFlag.LowerCase();
-    if (aFlag == "-echo"
-     || aFlag == "-print")
+    if (anUpdateTool.parseRedrawMode (aFlag))
+    {
+      continue;
+    }
+    else if (aFlag == "-echo"
+          || aFlag == "-print")
     {
       toPrint = Standard_True;
+      anUpdateTool.Invalidate();
     }
     else if (aFlag == "-mode"
           || aFlag == "-rendermode"
@@ -6515,7 +8492,9 @@ static Standard_Integer VRenderParams (Draw_Interpretor& theDI,
       }
 
       const Standard_Integer aDepth = Draw::Atoi (theArgVec[anArgIter]);
-      if (aDepth < 1 || aDepth > 10)
+
+      // We allow RaytracingDepth be more than 10 in case of GI enabled
+      if (aDepth < 1 || (aDepth > 10 && !aParams.IsGlobalIlluminationEnabled))
       {
         std::cerr << "Error: invalid ray-tracing depth " << aDepth << ". Should be within range [1; 10]\n";
         return 1;
@@ -6591,6 +8570,111 @@ static Standard_Integer VRenderParams (Draw_Interpretor& theDI,
       }
       aParams.IsTransparentShadowEnabled = toEnable;
     }
+    else if (aFlag == "-gi")
+    {
+      if (toPrint)
+      {
+        theDI << (aParams.IsGlobalIlluminationEnabled ? "on" : "off") << " ";
+        continue;
+      }
+
+      Standard_Boolean toEnable = Standard_True;
+      if (++anArgIter < theArgNb
+      && !parseOnOff (theArgVec[anArgIter], toEnable))
+      {
+        --anArgIter;
+      }
+      aParams.IsGlobalIlluminationEnabled = toEnable;
+      if (!toEnable)
+      {
+        aParams.RaytracingDepth = Min (aParams.RaytracingDepth, 10);
+      }
+    }
+    else if (aFlag == "-blockedrng"
+          || aFlag == "-brng")
+    {
+      if (toPrint)
+      {
+        theDI << (aParams.CoherentPathTracingMode ? "on" : "off") << " ";
+        continue;
+      }
+
+      Standard_Boolean toEnable = Standard_True;
+      if (++anArgIter < theArgNb
+        && !parseOnOff (theArgVec[anArgIter], toEnable))
+      {
+        --anArgIter;
+      }
+      aParams.CoherentPathTracingMode = toEnable;
+    }
+    else if (aFlag == "-env")
+    {
+      if (toPrint)
+      {
+        theDI << (aParams.UseEnvironmentMapBackground ? "on" : "off") << " ";
+        continue;
+      }
+
+      Standard_Boolean toEnable = Standard_True;
+      if (++anArgIter < theArgNb
+        && !parseOnOff (theArgVec[anArgIter], toEnable))
+      {
+        --anArgIter;
+      }
+      aParams.UseEnvironmentMapBackground = toEnable;
+    }
+    else if (aFlag == "-shademodel"
+          || aFlag == "-shadingmodel"
+          || aFlag == "-shading")
+    {
+      if (toPrint)
+      {
+        switch (aView->ShadingModel())
+        {
+          case V3d_COLOR:   theDI << "color ";   break;
+          case V3d_FLAT:    theDI << "flat ";    break;
+          case V3d_GOURAUD: theDI << "gouraud "; break;
+          case V3d_PHONG:   theDI << "phong ";   break;
+        }
+        continue;
+      }
+
+      if (++anArgIter >= theArgNb)
+      {
+        std::cerr << "Error: wrong syntax at argument '" << anArg << "'\n";
+      }
+
+      TCollection_AsciiString aMode (theArgVec[anArgIter]);
+      aMode.LowerCase();
+      if (aMode == "color"
+       || aMode == "none")
+      {
+        aView->SetShadingModel (V3d_COLOR);
+      }
+      else if (aMode == "flat"
+            || aMode == "facet")
+      {
+        aView->SetShadingModel (V3d_FLAT);
+      }
+      else if (aMode == "gouraud"
+            || aMode == "vertex"
+            || aMode == "vert")
+      {
+        aView->SetShadingModel (V3d_GOURAUD);
+      }
+      else if (aMode == "phong"
+            || aMode == "fragment"
+            || aMode == "frag"
+            || aMode == "pixel")
+      {
+        aView->SetShadingModel (V3d_PHONG);
+      }
+      else
+      {
+        std::cout << "Error: unknown shading model '" << aMode << "'\n";
+        return 1;
+      }
+    }
     else
     {
       std::cout << "Error: wrong syntax, unknown flag '" << anArg << "'\n";
@@ -6598,11 +8682,56 @@ static Standard_Integer VRenderParams (Draw_Interpretor& theDI,
     }
   }
 
-  aView->Redraw();
   return 0;
 }
 
 //=======================================================================
+//function : VProgressiveMode
+//purpose  :
+//=======================================================================
+#if defined(_WIN32)
+static Standard_Integer VProgressiveMode (Draw_Interpretor& /*theDI*/,
+                                          Standard_Integer  /*theNbArgs*/,
+                                          const char**      /*theArgs*/)
+{
+  Handle(V3d_View) aView = ViewerTest::CurrentView();
+  if (aView.IsNull())
+  {
+    std::cerr << "Error: no active viewer!\n";
+    return 1;
+  }
+
+  std::cout << "Press Enter or Escape key to exit progressive rendering mode" << std::endl;
+
+  for (;;)
+  {
+    aView->Redraw();
+
+    Standard_Boolean toExit = Standard_False;
+
+    MSG aMsg;
+    while (PeekMessage (&aMsg, NULL, NULL, NULL, PM_REMOVE))
+    {
+      if (aMsg.message == WM_KEYDOWN && (aMsg.wParam == 0x0d || aMsg.wParam == 0x1b))
+      {
+        toExit = Standard_True;
+      }
+
+      TranslateMessage (&aMsg);
+      DispatchMessage  (&aMsg);
+    }
+
+    if (toExit)
+    {
+      break;
+    }
+  }
+
+  return 0;
+}
+#endif
+
+//=======================================================================
 //function : VFrustumCulling
 //purpose  : enables/disables view volume's culling.
 //=======================================================================
@@ -6650,6 +8779,117 @@ static int VFrustumCulling (Draw_Interpretor& theDI,
 }
 
 //=======================================================================
+//function : VHighlightSelected
+//purpose  : 
+//=======================================================================
+static int VHighlightSelected (Draw_Interpretor& theDI,
+                               Standard_Integer  theArgNb,
+                               const char**      theArgVec)
+{
+  if (ViewerTest::GetAISContext().IsNull())
+  {
+    std::cout << theArgVec[0] << " error : Context is not created. Please call vinit before.\n";
+    return 1;
+  }
+
+  const Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
+
+  if (theArgNb < 2)
+  {
+    theDI << (aContext->ToHilightSelected() ? "on" : "off");
+    return 0;
+  }
+
+  if (theArgNb != 2)
+  {
+    std::cout  << theArgVec[0] << " error : wrong number of parameters."
+          << "Type 'help" << theArgVec[0] << "' for more information.";
+    return 1;
+  }
+
+  // Parse parameter
+  TCollection_AsciiString aMode (theArgVec[1]);
+  aMode.LowerCase();
+  Standard_Boolean toEnable = Standard_False;
+  if (aMode.IsEqual ("on"))
+  {
+    toEnable = Standard_True;
+  }
+  else if (aMode.IsEqual ("off"))
+  {
+    toEnable = Standard_False;
+  }
+  else
+  {
+    toEnable = Draw::Atoi (theArgVec[1]) != 0;
+  }
+
+  if (toEnable != aContext->ToHilightSelected())
+  {
+    aContext->SetToHilightSelected (toEnable);
+
+    // Move cursor to null position and  back to process updating of detection
+    // and highlighting of selected object immediatly.
+    Standard_Integer aPixX = 0;
+    Standard_Integer aPixY = 0;
+    const Handle(ViewerTest_EventManager)& anEventManager =  ViewerTest::CurrentEventManager();
+
+    anEventManager->GetCurrentPosition (aPixX, aPixY);
+    anEventManager->MoveTo (0, 0);
+    anEventManager->MoveTo (aPixX, aPixY);
+  }
+
+  return 0;
+}
+
+//=======================================================================
+//function : VXRotate
+//purpose  :
+//=======================================================================
+static Standard_Integer VXRotate (Draw_Interpretor& di,
+                                   Standard_Integer argc,
+                                   const char ** argv)
+{
+  Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
+  if (aContext.IsNull())
+  {
+    di << argv[0] << "ERROR : use 'vinit' command before " << "\n";
+    return 1;
+  }
+  
+  if (argc != 3)
+  {
+    di << "ERROR : Usage : " << argv[0] << " name angle" << "\n";
+    return 1;
+  }
+
+  TCollection_AsciiString aName (argv[1]);
+  Standard_Real anAngle = Draw::Atof (argv[2]);
+
+  // find object
+  ViewerTest_DoubleMapOfInteractiveAndName& aMap = GetMapOfAIS();
+  Handle(AIS_InteractiveObject) anIObj;
+  if (!aMap.IsBound2 (aName) )
+  {
+    di << "Use 'vdisplay' before" << "\n";
+    return 1;
+  }
+  else
+  {
+    anIObj = Handle(AIS_InteractiveObject)::DownCast (aMap.Find2 (aName));
+
+    gp_Trsf aTransform;
+    aTransform.SetRotation (gp_Ax1 (gp_Pnt (0.0, 0.0, 0.0), gp_Vec (1.0, 0.0, 0.0)), anAngle);
+    aTransform.SetTranslationPart (anIObj->LocalTransformation().TranslationPart());
+
+    aContext->SetLocation (anIObj, aTransform);
+    aContext->UpdateCurrentViewer();
+  }
+
+  return 0;
+}
+
+//=======================================================================
 //function : ViewerCommands
 //purpose  :
 //=======================================================================
@@ -6723,8 +8963,15 @@ void ViewerTest::ViewerCommands(Draw_Interpretor& theCommands)
     "vpick           : vpick X Y Z [shape subshape] ( all variables as string )",
     VPick,group);
   theCommands.Add("vfit"    ,
-    "vfit or <F>         : vfit",
+    "vfit or <F> [-selected]"
+    "\n\t\t: [-selected] fits the scene according to bounding box of currently selected objects",
     __FILE__,VFit,group);
+  theCommands.Add ("vfitarea",
+    "vfitarea x1 y1 x2 y2"
+    "\n\t\t: vfitarea x1 y1 z1 x2 y2 z2"
+    "\n\t\t: Fit view to show area located between two points"
+    "\n\t\t: given in world 2D or 3D corrdinates.",
+    __FILE__, VFitArea, group);
   theCommands.Add ("vzfit", "vzfit [scale]\n"
     "   Matches Z near, Z far view volume planes to the displayed objects.\n"
     "   \"scale\" - specifies factor to scale computed z range.\n",
@@ -6750,16 +8997,28 @@ void ViewerTest::ViewerCommands(Draw_Interpretor& theCommands)
   theCommands.Add("vsetcolorbg",
     "vsetcolorbg     : vsetcolorbg r g b : Set background color",
     __FILE__,VSetColorBg,group);
+  theCommands.Add("vsetdefaultbg",
+    "vsetdefaultbg r g b\n"
+    "\n\t\t: vsetdefaultbg r1 g1 b1 r2 g2 b2 fillmode"
+    "\n\t\t: Set default viewer background fill color (flat/gradient).",
+    __FILE__,VSetDefaultBg,group);
   theCommands.Add("vscale",
     "vscale          : vscale X Y Z",
     __FILE__,VScale,group);
   theCommands.Add("vzbufftrihedron",
-    "vzbufftrihedron [center|left_lower|left_upper|right_lower|right_upper"
-    " textR=255 textG=255 textB=255 scale=0.1 wireframe|zbuffer]"
-    " : Displays a V3d_ZBUFFER'ed or V3d_WIREFRAME'd trihedron",
-    __FILE__,VTestZBuffTrihedron,group);
+            "vzbufftrihedron [{-on|-off}=-on] [-type {wireframe|zbuffer}=zbuffer]"
+    "\n\t\t:       [-position center|left_lower|left_upper|right_lower|right_upper]"
+    "\n\t\t:       [-scale value=0.1] [-size value=0.8] [-arrowDiam value=0.05]"
+    "\n\t\t:       [-colorArrowX color=RED] [-colorArrowY color=GREEN] [-colorArrowZ color=BLUE]"
+    "\n\t\t:       [-nbfacets value=12] [-colorLabels color=WHITE]"
+    "\n\t\t: Displays a trihedron",
+    __FILE__,VZBuffTrihedron,group);
   theCommands.Add("vrotate",
-    "vrotate         : vrotate AX AY AZ [X Y Z]",
+    "vrotate [[-mouseStart X Y] [-mouseMove X Y]]|[AX AY AZ [X Y Z]]"
+    "\n                : Option -mouseStart starts rotation according to the mouse position"
+    "\n                : Option -mouseMove continues rotation with angle computed"
+    "\n                : from last and new mouse position."
+    "\n                : vrotate AX AY AZ [X Y Z]",
     __FILE__,VRotate,group);
   theCommands.Add("vzoom",
     "vzoom           : vzoom coef",
@@ -6773,10 +9032,45 @@ void ViewerTest::ViewerCommands(Draw_Interpretor& theCommands)
     " : notice that EMF format requires patched gl2ps",
     __FILE__,VExport,group);
   theCommands.Add("vcolorscale",
-    "vcolorscale     : vcolorscale [RangeMin = 0 RangeMax = 100 Intervals = 10 HeightFont = 16 Position = 2 X = 0 Y = 0]: draw color scale",
+    "vcolorscale     : vcolorscale [-range RangeMin = 0 RangeMax = 100 Intervals = 10 -font HeightFont = 16  -textpos "
+    "Position = left -xy X = 0 Y = 0] [-noupdate|-update]: draw color scale\n"
+    "-demo/-demoversion draw a demoversion of color scale.\n"
+    "-show/display display color scale.\n"
+    "-hide/erase erase color scale.\n"
+    "Please note that -show/-hide option must be the first argument!\n"
+    "-color Index R G B: set color for indexed interval\n"
+    "-color Index ColorName: set color for indexed interval\n"
+    "-colors R G B R G B ...: set colors for all intervals\n"
+    "-colors ColorName1 ColorName2 ...: set colors for all intervals\n"
+    "-colors supports both color names and rgb values in one call\n"
+    "-label Index Text: set label for indexed interval\n"
+    "-labels Text Text Text ...: set labels for all intervals\n"
+    "-title Title [Position]: set the title for color scale with certain position. Default position = center;\n"
+    "Available text positions: left, right, center, none;\n",
     __FILE__,VColorScale,group);
   theCommands.Add("vgraduatedtrihedron",
-    "vgraduatedtrihedron : 1/0 (display/erase) [Xname Yname Zname [Font [isMultibyte]]]",
+    "vgraduatedtrihedron : -on/-off [-xname Name] [-yname Name] [-zname Name] [-arrowlength Value]\n"
+    "\t[-namefont Name] [-valuesfont Name]\n"
+    "\t[-xdrawname on/off] [-ydrawname on/off] [-zdrawname on/off]\n"
+    "\t[-xnameoffset IntVal] [-ynameoffset IntVal] [-znameoffset IntVal]"
+    "\t[-xnamecolor Color] [-ynamecolor Color] [-znamecolor Color]\n"
+    "\t[-xdrawvalues on/off] [-ydrawvalues on/off] [-zdrawvalues on/off]\n"
+    "\t[-xvaluesoffset IntVal] [-yvaluesoffset IntVal] [-zvaluesoffset IntVal]"
+    "\t[-xcolor Color] [-ycolor Color] [-zcolor Color]\n"
+    "\t[-xdrawticks on/off] [-ydrawticks on/off] [-zdrawticks on/off]\n"
+    "\t[-xticks Number] [-yticks Number] [-zticks Number]\n"
+    "\t[-xticklength IntVal] [-yticklength IntVal] [-zticklength IntVal]\n"
+    "\t[-drawgrid on/off] [-drawaxes on/off]\n"
+    " - Displays or erases graduated trihedron"
+    " - xname, yname, zname - names of axes, default: X, Y, Z\n"
+    " - namefont - font of axes names. Default: Arial\n"
+    " - xnameoffset, ynameoffset, znameoffset - offset of name from values or tickmarks or axis. Default: 30\n"
+    " - xnamecolor, ynamecolor, znamecolor - colors of axes names\n"
+    " - xvaluesoffset, yvaluesoffset, zvaluesoffset - offset of values from tickmarks or axis. Default: 10\n"
+    " - valuesfont - font of axes values. Default: Arial\n"
+    " - xcolor, ycolor, zcolor - color of axis and values\n"
+    " - xticks, yticks, xzicks - number of tickmark on axes. Default: 5\n"
+    " - xticklength, yticklength, xzicklength - length of tickmark on axes. Default: 10\n",
     __FILE__,VGraduatedTrihedron,group);
   theCommands.Add("vprintview" ,
     "vprintview : width height filename [algo=0] [tile_width tile_height] : Test print algorithm: algo = 0 - stretch, algo = 1 - tile",
@@ -6813,22 +9107,89 @@ void ViewerTest::ViewerCommands(Draw_Interpretor& theCommands)
     " : Mode - rectangular or circular"
     " : Type - lines or points",
     __FILE__, VGrid, group);
+  theCommands.Add ("vpriviledgedplane",
+    "vpriviledgedplane [Ox Oy Oz Nx Ny Nz [Xx Xy Xz]]"
+    "\n\t\t:   Ox, Oy, Oz - plane origin"
+    "\n\t\t:   Nx, Ny, Nz - plane normal direction"
+    "\n\t\t:   Xx, Xy, Xz - plane x-reference axis direction"
+    "\n\t\t: Sets or prints viewer's priviledged plane geometry.",
+    __FILE__, VPriviledgedPlane, group);
+  theCommands.Add ("vconvert",
+    "vconvert v [Mode={window|view}]"
+    "\n\t\t: vconvert x y [Mode={window|view|grid|ray}]"
+    "\n\t\t: vconvert x y z [Mode={window|grid}]"
+    "\n\t\t:   window - convert to window coordinates, pixels"
+    "\n\t\t:   view   - convert to view projection plane"
+    "\n\t\t:   grid   - convert to model coordinates, given on grid"
+    "\n\t\t:   ray    - convert projection ray to model coordiantes"
+    "\n\t\t: - vconvert v window : convert view to window;"
+    "\n\t\t: - vconvert v view   : convert window to view;"
+    "\n\t\t: - vconvert x y window : convert view to window;"
+    "\n\t\t: - vconvert x y view : convert window to view;"
+    "\n\t\t: - vconvert x y : convert window to model;"
+    "\n\t\t: - vconvert x y grid : convert window to model using grid;"
+    "\n\t\t: - vconvert x y ray : convert window projection line to model;"
+    "\n\t\t: - vconvert x y z window : convert model to window;"
+    "\n\t\t: - vconvert x y z grid : convert view to model using grid;"
+    "\n\t\t: Converts the given coordinates to window/view/model space.",
+    __FILE__, VConvert, group);
   theCommands.Add ("vfps",
     "vfps [framesNb=100] : estimate average frame rate for active view",
     __FILE__, VFps, group);
   theCommands.Add ("vgldebug",
-    "vgldebug [{0|1}] : request debug GL context, should be called before vinit\n"
-    "                : this function is implemented only for Windows\n"
-    "                : GL_ARB_debug_output extension should be exported by OpenGL driver!",
+            "vgldebug [-sync {0|1}] [-debug {0|1}] [-glslWarn {0|1}]"
+    "\n\t\t:          [-extraMsg {0|1}] [{0|1}]"
+    "\n\t\t: Request debug GL context. Should be called BEFORE vinit."
+    "\n\t\t: Debug context can be requested only on Windows"
+    "\n\t\t: with GL_ARB_debug_output extension implemented by GL driver!"
+    "\n\t\t:  -sync     - request synchronized debug GL context"
+    "\n\t\t:  -glslWarn - log GLSL compiler/linker warnings,"
+    "\n\t\t:              which are suppressed by default,"
+    "\n\t\t:  -extraMsg - log extra diagnostic messages from GL context,"
+    "\n\t\t:              which are suppressed by default",
     __FILE__, VGlDebug, group);
   theCommands.Add ("vvbo",
     "vvbo [{0|1}] : turn VBO usage On/Off; affects only newly displayed objects",
     __FILE__, VVbo, group);
   theCommands.Add ("vstereo",
-    "\nvstereo [{0|1}] : turn stereo usage On/Off; affects only newly displayed objects",
+            "vstereo [0|1] [-mode Mode] [-reverse {0|1}]"
+    "\n\t\t:         [-anaglyph Filter]"
+    "\n\t\t: Control stereo output mode. Available modes for -mode:"
+    "\n\t\t:  quadBuffer        - OpenGL QuadBuffer stereo,"
+    "\n\t\t:                     requires driver support."
+    "\n\t\t:                     Should be called BEFORE vinit!"
+    "\n\t\t:  anaglyph         - Anaglyph glasses"
+    "\n\t\t:  rowInterlaced    - row-interlaced display"
+    "\n\t\t:  columnInterlaced - column-interlaced display"
+    "\n\t\t:  chessBoard       - chess-board output"
+    "\n\t\t:  sideBySide       - horizontal pair"
+    "\n\t\t:  overUnder        - vertical   pair"
+    "\n\t\t: Available Anaglyph filters for -anaglyph:"
+    "\n\t\t:  redCyan, redCyanSimple, yellowBlue, yellowBlueSimple,"
+    "\n\t\t:  greenMagentaSimple",
     __FILE__, VStereo, group);
   theCommands.Add ("vcaps",
-    "vcaps [vbo={0|1}] [sprites={0|1}] [soft={0|1}] : modify particular graphic driver options",
+            "vcaps [-vbo {0|1}] [-sprites {0|1}] [-ffp {0|1}]"
+    "\n\t\t:       [-compatibleContext {0|1}]"
+    "\n\t\t:       [-vsync {0|1}]"
+    "\n\t\t:       [-quadBuffer {0|1}] [-stereo {0|1}]"
+    "\n\t\t:       [-softMode {0|1}] [-noupdate|-update]"
+    "\n\t\t: Modify particular graphic driver options:"
+    "\n\t\t:  FFP      - use fixed-function pipeline instead of"
+    "\n\t\t:             built-in GLSL programs"
+    "\n\t\t:            (requires compatible profile)"
+    "\n\t\t:  VBO      - use Vertex Buffer Object (copy vertex"
+    "\n\t\t:             arrays to GPU memory)"
+    "\n\t\t:  sprite   - use textured sprites instead of bitmaps"
+    "\n\t\t:  vsync    - switch VSync on or off"
+    "\n\t\t: Context creation options:"
+    "\n\t\t:  softMode          - software OpenGL implementation"
+    "\n\t\t:  compatibleProfile - backward-compatible profile"
+    "\n\t\t:  quadbuffer        - QuadBuffer"
+    "\n\t\t: Unlike vrenderparams, these parameters control alternative"
+    "\n\t\t: rendering paths producing the same visual result when"
+    "\n\t\t: possible."
+    "\n\t\t: Command is intended for testing old hardware compatibility.",
     __FILE__, VCaps, group);
   theCommands.Add ("vmemgpu",
     "vmemgpu [f]: print system-dependent GPU memory information if available;"
@@ -6842,12 +9203,14 @@ void ViewerTest::ViewerCommands(Draw_Interpretor& theCommands)
     "diffimage     : diffimage imageFile1 imageFile2 toleranceOfColor(0..1) blackWhite(1|0) borderFilter(1|0) [diffImageFile]",
     __FILE__, VDiffImage, group);
   theCommands.Add ("vselect",
-    "vselect x1 y1 [x2 y2 [x3 y3 ... xn yn]] [shift_selection = 0|1]\n"
+    "vselect x1 y1 [x2 y2 [x3 y3 ... xn yn]] [-allowoverlap 0|1] [shift_selection = 0|1]\n"
     "- emulates different types of selection:\n"
     "- 1) single click selection\n"
     "- 2) selection with rectangle having corners at pixel positions (x1,y1) and (x2,y2)\n"
     "- 3) selection with polygon having corners in pixel positions (x1,y1), (x2,y2),...,(xn,yn)\n"
-    "- 4) any of these selections with shift button pressed",
+    "- 4) -allowoverlap determines will partially included objects be selected in rectangular selection"
+    " (partial inclusion - overlap - is not allowed by default)\n"
+    "- 5) any of these selections with shift button pressed",
     __FILE__, VSelect, group);
   theCommands.Add ("vmoveto",
     "vmoveto x y"
@@ -6880,24 +9243,30 @@ void ViewerTest::ViewerCommands(Draw_Interpretor& theCommands)
     __FILE__,VZClipping,group);
   theCommands.Add ("vnbselected",
     "vnbselected", __FILE__, VNbSelected, group);
-  theCommands.Add ("vchangecamera",
-    " changes camera parameters \n"
-    "- vchangecamera [param_type] [value]\n"
-    "- vchangecamera proj {ortho/persp/left/right/stereo}\n"
-    "     Projection type including left and right stereo parts.\n"
-    "- vchangecamera dist [real]\n"
-    "     Sets distance from target point to camera eye (moving eye).\n"
-    "- vchangecamera iod [real]\n"
-    "     Intraocular distance value.\n"
-    "- vchangecamera zfocus [real]\n"
-    "     Stereographic focus value.\n"
-    "- vchangecamera fov [real]\n"
-    "     Field Of View value (in degrees).\n"
-    "- vchangecamera zfocustype {absolute/relative}\n"
-    "     Stereographic focus definition type (absolute value or coefficient).\n"
-    "- vchangecamera iodtype {absolute/relative}\n"
-    "     Intraocular distance definition type (absolute value or coefficient).\n", 
-    __FILE__, VChangeCamera, group);
+  theCommands.Add ("vcamera",
+              "vcamera [-ortho] [-projtype]"
+      "\n\t\t:         [-persp]"
+      "\n\t\t:         [-fovy   [Angle]] [-distance [Distance]]"
+      "\n\t\t:         [-stereo] [-leftEye] [-rightEye]"
+      "\n\t\t:         [-iod [Distance]] [-iodType    [absolute|relative]]"
+      "\n\t\t:         [-zfocus [Value]] [-zfocusType [absolute|relative]]"
+      "\n\t\t: Manage camera parameters."
+      "\n\t\t: Prints current value when option called without argument."
+      "\n\t\t: Orthographic camera:"
+      "\n\t\t:   -ortho      activate orthographic projection"
+      "\n\t\t: Perspective camera:"
+      "\n\t\t:   -persp      activate perspective  projection (mono)"
+      "\n\t\t:   -fovy       field of view in y axis, in degrees"
+      "\n\t\t:   -distance   distance of eye from camera center"
+      "\n\t\t: Stereoscopic camera:"
+      "\n\t\t:   -stereo     perspective  projection (stereo)"
+      "\n\t\t:   -leftEye    perspective  projection (left  eye)"
+      "\n\t\t:   -rightEye   perspective  projection (right eye)"
+      "\n\t\t:   -iod        intraocular distance value"
+      "\n\t\t:   -iodType    distance type, absolute or relative"
+      "\n\t\t:   -zfocus     stereographic focus value"
+      "\n\t\t:   -zfocusType focus type, absolute or relative",
+    __FILE__, VCamera, group);
   theCommands.Add ("vautozfit", "command to enable or disable automatic z-range adjusting\n"
     "- vautozfit [on={1|0}] [scale]\n"
     "    Prints or changes parameters of automatic z-fit mode:\n"
@@ -6981,8 +9350,11 @@ void ViewerTest::ViewerCommands(Draw_Interpretor& theCommands)
     "  this command sets texture details mode for the specified view.\n"
     , __FILE__, VSetTextureMode, group);
   theCommands.Add("vdefaults",
-    "vdefaults [absDefl=value] [devCoeff=value] [angDefl=value]",
-    __FILE__, VDefaults, group);
+               "vdefaults [-absDefl value]"
+       "\n\t\t:           [-devCoeff value]"
+       "\n\t\t:           [-angDefl value]"
+       "\n\t\t:           [-autoTriang {off/on | 0/1}]"
+    , __FILE__, VDefaults, group);
   theCommands.Add("vlight",
     "tool to manage light sources, without arguments shows list of lights."
     "\n    Main commands: "
@@ -6996,6 +9368,8 @@ void ViewerTest::ViewerCommands(Draw_Interpretor& theCommands)
     "\n        {dir}ection X Y Z (for directional light or for spotlight)"
     "\n        color colorName"
     "\n        {head}light 0|1"
+    "\n        {sm}oothness value"
+    "\n        {int}ensity value"
     "\n        {constAtten}uation value"
     "\n        {linearAtten}uation value"
     "\n        angle angleDeg"
@@ -7004,17 +9378,48 @@ void ViewerTest::ViewerCommands(Draw_Interpretor& theCommands)
     "\n\n        example: vlight add positional head 1 pos 0 1 1 color red"
     "\n        example: vlight change 0 direction 0 -1 0 linearAttenuation 0.2",
     __FILE__, VLight, group);
+  theCommands.Add("vraytrace",
+            "vraytrace [0|1]"
+    "\n\t\t: Turns on/off ray-tracing renderer."
+    "\n\t\t:   'vraytrace 0' alias for 'vrenderparams -raster'."
+    "\n\t\t:   'vraytrace 1' alias for 'vrenderparams -rayTrace'.",
+    __FILE__, VRenderParams, group);
   theCommands.Add("vrenderparams",
     "\n    Manages rendering parameters: "
-    "\n      '-rayTrace'            Enables  GPU ray-tracing"
-    "\n      '-raster'              Disables GPU ray-tracing"
-    "\n      '-rayDepth    0..10'   Defines maximum ray-tracing depth"
-    "\n      '-shadows     on|off'  Enables/disables shadows rendering"
-    "\n      '-reflections on|off'  Enables/disables specular reflections"
-    "\n      '-fsaa        on|off'  Enables/disables adaptive anti-aliasing"
-    "\n      '-gleam       on|off'  Enables/disables transparency shadow effects",
+    "\n      '-rayTrace'             Enables  GPU ray-tracing"
+    "\n      '-raster'               Disables GPU ray-tracing"
+    "\n      '-rayDepth     0..10'   Defines maximum ray-tracing depth"
+    "\n      '-shadows      on|off'  Enables/disables shadows rendering"
+    "\n      '-reflections  on|off'  Enables/disables specular reflections"
+    "\n      '-fsaa         on|off'  Enables/disables adaptive anti-aliasing"
+    "\n      '-gleam        on|off'  Enables/disables transparency shadow effects"
+    "\n      '-gi           on|off'  Enables/disables global illumination effects"
+    "\n      '-brng         on|off'  Enables/disables blocked RNG (fast coherent PT)"
+    "\n      '-env          on|off'  Enables/disables environment map background"
+    "\n      '-shadingModel model'   Controls shading model from enumeration"
+    "\n                              color, flat, gouraud, phong"
+    "\n    Unlike vcaps, these parameters dramatically change visual properties."
+    "\n    Command is intended to control presentation quality depending on"
+    "\n    hardware capabilities and performance.",
     __FILE__, VRenderParams, group);
   theCommands.Add("vfrustumculling",
     "vfrustumculling [toEnable]: enables/disables objects clipping",
     __FILE__,VFrustumCulling,group);
+  theCommands.Add("vhighlightselected",
+    "vhighlightselected [0|1] or vhighlightselected [on|off]: enables/disables highlighting of selected objects.\n"
+    "Without arguments it shows if highlighting of selected objects is enabled now.",
+    __FILE__,VHighlightSelected,group);
+  theCommands.Add ("vplace",
+            "vplace dx dy"
+    "\n\t\t: Places the point (in pixels) at the center of the window",
+    __FILE__, VPlace, group);
+  theCommands.Add("vxrotate",
+    "vxrotate",
+    __FILE__,VXRotate,group);
+
+#if defined(_WIN32)
+  theCommands.Add("vprogressive",
+    "vprogressive",
+    __FILE__, VProgressiveMode, group);
+#endif
 }