src/ViewerTest/ViewerTest_ViewerCommands.cxx

   1 // Created on: 1998-09-01
   2 // Created by: Robert COUBLANC
   3 // Copyright (c) 1998-1999 Matra Datavision
   4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
   5 //
   6 // This file is part of Open CASCADE Technology software library.
   7 //
   8 // This library is free software; you can redistribute it and/or modify it under
   9 // the terms of the GNU Lesser General Public License version 2.1 as published
  10 // by the Free Software Foundation, with special exception defined in the file
  11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
  12 // distribution for complete text of the license and disclaimer of any warranty.
  13 //
  14 // Alternatively, this file may be used under the terms of Open CASCADE
  15 // commercial license or contractual agreement.
  16
  17 #include <OpenGl_GlCore20.hxx>
  18
  19 #include <AIS_Animation.hxx>
  20 #include <AIS_AnimationCamera.hxx>
  21 #include <AIS_AnimationObject.hxx>
  22 #include <AIS_CameraFrustum.hxx>
  23 #include <AIS_ColorScale.hxx>
  24 #include <AIS_Manipulator.hxx>
  25 #include <AIS_RubberBand.hxx>
  26 #include <AIS_Shape.hxx>
  27 #include <AIS_InteractiveObject.hxx>
  28 #include <AIS_ListOfInteractive.hxx>
  29 #include <AIS_ListIteratorOfListOfInteractive.hxx>
  30 #include <Aspect_Grid.hxx>
  31 #include <DBRep.hxx>
  32 #include <Draw_ProgressIndicator.hxx>
  33 #include <Graphic3d_ArrayOfPolylines.hxx>
  34 #include <Graphic3d_AspectMarker3d.hxx>
  35 #include <Graphic3d_NameOfTextureEnv.hxx>
  36 #include <Graphic3d_GraduatedTrihedron.hxx>
  37 #include <Graphic3d_TextureEnv.hxx>
  38 #include <Graphic3d_TextureParams.hxx>
  39 #include <Graphic3d_TypeOfTextureFilter.hxx>
  40 #include <Graphic3d_AspectFillArea3d.hxx>
  41 #include <ViewerTest.hxx>
  42 #include <ViewerTest_AutoUpdater.hxx>
  43 #include <ViewerTest_EventManager.hxx>
  44 #include <ViewerTest_DoubleMapOfInteractiveAndName.hxx>
  45 #include <ViewerTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName.hxx>
  46 #include <ViewerTest_CmdParser.hxx>
  47 #include <V3d_AmbientLight.hxx>
  48 #include <V3d_DirectionalLight.hxx>
  49 #include <V3d_PositionalLight.hxx>
  50 #include <V3d_SpotLight.hxx>
  51 #include <Message_ProgressSentry.hxx>
  52 #include <NCollection_DoubleMap.hxx>
  53 #include <NCollection_List.hxx>
  54 #include <NCollection_Vector.hxx>
  55 #include <AIS_InteractiveContext.hxx>
  56 #include <Draw_Interpretor.hxx>
  57 #include <Draw.hxx>
  58 #include <Draw_Appli.hxx>
  59 #include <Image_AlienPixMap.hxx>
  60 #include <Image_VideoRecorder.hxx>
  61 #include <OpenGl_GraphicDriver.hxx>
  62 #include <OSD_Timer.hxx>
  63 #include <TColStd_HSequenceOfAsciiString.hxx>
  64 #include <TColStd_SequenceOfInteger.hxx>
  65 #include <TColStd_HSequenceOfReal.hxx>
  66 #include <TColgp_Array1OfPnt2d.hxx>
  67 #include <TColStd_MapOfAsciiString.hxx>
  68 #include <Aspect_TypeOfLine.hxx>
  69 #include <Image_Diff.hxx>
  70 #include <Aspect_DisplayConnection.hxx>
  71 #include <gp_Pnt.hxx>
  72 #include <gp_Dir.hxx>
  73 #include <gp_Pln.hxx>
  74 #include <PrsMgr_PresentableObject.hxx>
  75 #include <Graphic3d_ClipPlane.hxx>
  76 #include <NCollection_DataMap.hxx>
  77 #include <Graphic3d_Texture2Dmanual.hxx>
  78 #include <Prs3d_ShadingAspect.hxx>
  79 #include <Prs3d_Drawer.hxx>
  80 #include <Prs3d_LineAspect.hxx>
  81 #include <Prs3d_Root.hxx>
  82 #include <Prs3d_Text.hxx>
  83 #include <Select3D_SensitivePrimitiveArray.hxx>
  84
  85 #ifdef _WIN32
  86 #undef DrawText
  87 #endif
  88
  89 #include <cstdlib>
  90
  91 #if defined(_WIN32)
  92   #include <WNT_WClass.hxx>
  93   #include <WNT_Window.hxx>
  94 #elif defined(__APPLE__) && !defined(MACOSX_USE_GLX)
  95   #include <Cocoa_Window.hxx>
  96 #else
  97   #include <Xw_Window.hxx>
  98   #include <X11/Xlib.h> /* contains some dangerous #defines such as Status, True etc. */
  99   #include <X11/Xutil.h>
 100   #include <tk.h>
 101 #endif
 102
 103 // Auxiliary definitions
 104 static const char THE_KEY_DELETE = 127;
 105 static const char THE_KEY_ESCAPE = 27;
 106
 107 //==============================================================================
 108 //  VIEWER GLOBAL VARIABLES
 109 //==============================================================================
 110
 111 Standard_IMPORT Standard_Boolean Draw_VirtualWindows;
 112 Standard_IMPORT Standard_Boolean Draw_Interprete (const char* theCommand);
 113
 114 Standard_EXPORT int ViewerMainLoop(Standard_Integer , const char** argv);
 115 extern ViewerTest_DoubleMapOfInteractiveAndName& GetMapOfAIS();
 116
 117 extern int VErase (Draw_Interpretor& theDI,
 118                    Standard_Integer  theArgNb,
 119                    const char**      theArgVec);
 120
 121 #if defined(_WIN32)
 122 static Handle(WNT_Window)& VT_GetWindow() {
 123   static Handle(WNT_Window) WNTWin;
 124   return WNTWin;
 125 }
 126 #elif defined(__APPLE__) && !defined(MACOSX_USE_GLX)
 127 static Handle(Cocoa_Window)& VT_GetWindow()
 128 {
 129   static Handle(Cocoa_Window) aWindow;
 130   return aWindow;
 131 }
 132 extern void ViewerTest_SetCocoaEventManagerView (const Handle(Cocoa_Window)& theWindow);
 133 extern void SetCocoaWindowTitle (const Handle(Cocoa_Window)& theWindow, Standard_CString theTitle);
 134 extern void GetCocoaScreenResolution (Standard_Integer& theWidth, Standard_Integer& theHeight);
 135
 136 #else
 137 static Handle(Xw_Window)& VT_GetWindow(){
 138   static Handle(Xw_Window) XWWin;
 139   return XWWin;
 140 }
 141
 142 static void VProcessEvents(ClientData,int);
 143 #endif
 144
 145 static Handle(Aspect_DisplayConnection)& GetDisplayConnection()
 146 {
 147   static Handle(Aspect_DisplayConnection) aDisplayConnection;
 148   return aDisplayConnection;
 149 }
 150
 151 static void SetDisplayConnection (const Handle(Aspect_DisplayConnection)& theDisplayConnection)
 152 {
 153   GetDisplayConnection() = theDisplayConnection;
 154 }
 155
 156 #if defined(_WIN32) || (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
 157 Aspect_Handle GetWindowHandle(const Handle(Aspect_Window)& theWindow)
 158 {
 159   Aspect_Handle aWindowHandle = (Aspect_Handle)NULL;
 160 #if defined(_WIN32)
 161   const Handle (WNT_Window) aWindow = Handle(WNT_Window)::DownCast (theWindow);
 162   if (!aWindow.IsNull())
 163     return aWindow->HWindow();
 164 #elif (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
 165   const Handle (Xw_Window) aWindow = Handle(Xw_Window)::DownCast (theWindow);
 166   if (!aWindow.IsNull())
 167   return aWindow->XWindow();
 168 #endif
 169   return aWindowHandle;
 170 }
 171 #endif
 172
 173 //! Setting additional flag to store 2D mode of the View to avoid scene rotation by mouse/key events
 174 class ViewerTest_V3dView : public V3d_View
 175 {
 176   DEFINE_STANDARD_RTTI_INLINE(ViewerTest_V3dView, V3d_View)
 177 public:
 178   //! Initializes the view.
 179   ViewerTest_V3dView (const Handle(V3d_Viewer)& theViewer, const V3d_TypeOfView theType = V3d_ORTHOGRAPHIC,
 180                       bool theIs2dMode = false)
 181   : V3d_View (theViewer, theType), myIs2dMode (theIs2dMode) {}
 182
 183   //! Initializes the view by copying.
 184   ViewerTest_V3dView (const Handle(V3d_Viewer)& theViewer, const Handle(V3d_View)& theView)
 185   : V3d_View (theViewer, theView), myIs2dMode (false)
 186   {
 187     if (Handle(ViewerTest_V3dView) aV3dView = Handle(ViewerTest_V3dView)::DownCast (theView))
 188     {
 189       myIs2dMode = aV3dView->IsViewIn2DMode();
 190     }
 191   }
 192
 193   //! Returns true if 2D mode is set for the view
 194   bool IsViewIn2DMode() const { return myIs2dMode; }
 195
 196   //! Sets 2D mode for the view
 197   void SetView2DMode (bool the2dMode) { myIs2dMode = the2dMode; }
 198
 199 public:
 200
 201   //! Returns true if active view in 2D mode.
 202   static bool IsCurrentViewIn2DMode()
 203   {
 204     if (Handle(ViewerTest_V3dView) aV3dView = Handle(ViewerTest_V3dView)::DownCast (ViewerTest::CurrentView()))
 205     {
 206       return aV3dView->IsViewIn2DMode();
 207     }
 208     return false;
 209   }
 210
 211   //! Set if active view in 2D mode.
 212   static void SetCurrentView2DMode (bool theIs2d)
 213   {
 214     if (Handle(ViewerTest_V3dView) aV3dView = Handle(ViewerTest_V3dView)::DownCast (ViewerTest::CurrentView()))
 215     {
 216       aV3dView->SetView2DMode (theIs2d);
 217     }
 218   }
 219
 220 private:
 221
 222   Standard_Boolean myIs2dMode; //!< 2D mode flag
 223
 224 };
 225
 226 NCollection_DoubleMap <TCollection_AsciiString, Handle(V3d_View)> ViewerTest_myViews;
 227 static NCollection_DoubleMap <TCollection_AsciiString, Handle(AIS_InteractiveContext)>  ViewerTest_myContexts;
 228 static NCollection_DoubleMap <TCollection_AsciiString, Handle(Graphic3d_GraphicDriver)> ViewerTest_myDrivers;
 229 static OpenGl_Caps ViewerTest_myDefaultCaps;
 230
 231 static void OSWindowSetup();
 232
 233 static struct
 234 {
 235   Quantity_Color FlatColor;
 236   Quantity_Color GradientColor1;
 237   Quantity_Color GradientColor2;
 238   Aspect_GradientFillMethod FillMethod;
 239 } ViewerTest_DefaultBackground = { Quantity_NOC_BLACK, Quantity_NOC_BLACK, Quantity_NOC_BLACK, Aspect_GFM_NONE };
 240
 241 //==============================================================================
 242 //  EVENT GLOBAL VARIABLES
 243 //==============================================================================
 244
 245 static int Start_Rot = 0;
 246 Standard_Boolean HasHlrOnBeforeRotation = Standard_False;
 247 int X_Motion = 0; // Current cursor position
 248 int Y_Motion = 0;
 249 int X_ButtonPress = 0; // Last ButtonPress position
 250 int Y_ButtonPress = 0;
 251 Standard_Boolean IsDragged = Standard_False;
 252 Standard_Boolean DragFirst = Standard_False;
 253 Standard_Boolean TheIsAnimating = Standard_False;
 254 Standard_Boolean Draw_ToExitOnCloseView = Standard_False;
 255 Standard_Boolean Draw_ToCloseViewOnEsc  = Standard_False;
 256
 257
 258 Standard_EXPORT const Handle(AIS_RubberBand)& GetRubberBand()
 259 {
 260   static Handle(AIS_RubberBand) aBand;
 261   if (aBand.IsNull())
 262   {
 263     aBand = new AIS_RubberBand (Quantity_NOC_LIGHTBLUE, Aspect_TOL_SOLID, Quantity_NOC_LIGHTBLUE, 0.4, 1.0);
 264     aBand->SetDisplayMode (0);
 265   }
 266   return aBand;
 267 }
 268
 269 typedef NCollection_Map<AIS_Manipulator*> ViewerTest_MapOfAISManipulators;
 270
 271 Standard_EXPORT ViewerTest_MapOfAISManipulators& GetMapOfAISManipulators()
 272 {
 273   static ViewerTest_MapOfAISManipulators aMap;
 274   return aMap;
 275 }
 276
 277 Standard_EXPORT Handle(AIS_Manipulator) GetActiveAISManipulator()
 278 {
 279   ViewerTest_MapOfAISManipulators::Iterator anIt (GetMapOfAISManipulators());
 280   for (; anIt.More(); anIt.Next())
 281   {
 282     if (anIt.Value()->HasActiveMode())
 283     {
 284       return anIt.Value();
 285     }
 286   }
 287   return NULL;
 288 }
 289
 290 //==============================================================================
 291
 292 #ifdef _WIN32
 293 static LRESULT WINAPI ViewerWindowProc(
 294                                        HWND hwnd,
 295                                        UINT uMsg,
 296                                        WPARAM wParam,
 297                                        LPARAM lParam );
 298 static LRESULT WINAPI AdvViewerWindowProc(
 299   HWND hwnd,
 300   UINT uMsg,
 301   WPARAM wParam,
 302   LPARAM lParam );
 303 #endif
 304
 305
 306 //==============================================================================
 307 //function : WClass
 308 //purpose  :
 309 //==============================================================================
 310
 311 const Handle(Standard_Transient)& ViewerTest::WClass()
 312 {
 313   static Handle(Standard_Transient) theWClass;
 314 #if defined(_WIN32)
 315   if (theWClass.IsNull())
 316   {
 317     theWClass = new WNT_WClass ("GW3D_Class", (Standard_Address )AdvViewerWindowProc,
 318                                 CS_VREDRAW | CS_HREDRAW, 0, 0,
 319                                 ::LoadCursor (NULL, IDC_ARROW));
 320   }
 321 #endif
 322   return theWClass;
 323 }
 324
 325 //==============================================================================
 326 //function : CreateName
 327 //purpose  : Create numerical name for new object in theMap
 328 //==============================================================================
 329 template <typename ObjectType>
 330 TCollection_AsciiString CreateName (const NCollection_DoubleMap <TCollection_AsciiString, ObjectType>& theObjectMap,
 331                                     const TCollection_AsciiString& theDefaultString)
 332 {
 333   if (theObjectMap.IsEmpty())
 334     return theDefaultString + TCollection_AsciiString(1);
 335
 336   Standard_Integer aNextKey = 1;
 337   Standard_Boolean isFound = Standard_False;
 338   while (!isFound)
 339   {
 340     TCollection_AsciiString aStringKey = theDefaultString + TCollection_AsciiString(aNextKey);
 341     // Look for objects with default names
 342     if (theObjectMap.IsBound1(aStringKey))
 343     {
 344       aNextKey++;
 345     }
 346     else
 347       isFound = Standard_True;
 348   }
 349
 350   return theDefaultString + TCollection_AsciiString(aNextKey);
 351 }
 352
 353 //==============================================================================
 354 //structure : ViewerTest_Names
 355 //purpose   : Allow to operate with full view name: driverName/viewerName/viewName
 356 //==============================================================================
 357 struct ViewerTest_Names
 358 {
 359 private:
 360   TCollection_AsciiString myDriverName;
 361   TCollection_AsciiString myViewerName;
 362   TCollection_AsciiString myViewName;
 363
 364 public:
 365
 366   const TCollection_AsciiString& GetDriverName () const
 367   {
 368     return myDriverName;
 369   }
 370   void SetDriverName (const TCollection_AsciiString& theDriverName)
 371   {
 372     myDriverName = theDriverName;
 373   }
 374   const TCollection_AsciiString& GetViewerName () const
 375   {
 376     return myViewerName;
 377   }
 378   void SetViewerName (const TCollection_AsciiString& theViewerName)
 379   {
 380     myViewerName = theViewerName;
 381   }
 382   const TCollection_AsciiString& GetViewName () const
 383   {
 384     return myViewName;
 385   }
 386   void SetViewName (const TCollection_AsciiString& theViewName)
 387   {
 388     myViewName = theViewName;
 389   }
 390
 391   //===========================================================================
 392   //function : Constructor for ViewerTest_Names
 393   //purpose  : Get view, viewer, driver names from custom string
 394   //===========================================================================
 395
 396   ViewerTest_Names (const TCollection_AsciiString& theInputString)
 397   {
 398     TCollection_AsciiString aName(theInputString);
 399     if (theInputString.IsEmpty())
 400     {
 401       // Get current configuration
 402       if (ViewerTest_myDrivers.IsEmpty())
 403         myDriverName = CreateName<Handle(Graphic3d_GraphicDriver)>
 404           (ViewerTest_myDrivers, TCollection_AsciiString("Driver"));
 405       else
 406         myDriverName = ViewerTest_myDrivers.Find2
 407         (ViewerTest::GetAISContext()->CurrentViewer()->Driver());
 408
 409       if(ViewerTest_myContexts.IsEmpty())
 410       {
 411         myViewerName = CreateName <Handle(AIS_InteractiveContext)>
 412           (ViewerTest_myContexts, TCollection_AsciiString (myDriverName + "/Viewer"));
 413       }
 414       else
 415       {
 416         myViewerName = ViewerTest_myContexts.Find2 (ViewerTest::GetAISContext());
 417       }
 418
 419       myViewName = CreateName <Handle(V3d_View)> (ViewerTest_myViews, TCollection_AsciiString(myViewerName + "/View"));
 420     }
 421     else
 422     {
 423       // There is at least view name
 424       Standard_Integer aParserNumber = 0;
 425       for (Standard_Integer i = 0; i < 3; ++i)
 426       {
 427         Standard_Integer aParserPos = aName.SearchFromEnd("/");
 428         if(aParserPos != -1)
 429         {
 430           aParserNumber++;
 431           aName.Split(aParserPos-1);
 432         }
 433         else
 434           break;
 435       }
 436       if (aParserNumber == 0)
 437       {
 438         // Only view name
 439         if (!ViewerTest::GetAISContext().IsNull())
 440         {
 441           myDriverName = ViewerTest_myDrivers.Find2
 442           (ViewerTest::GetAISContext()->CurrentViewer()->Driver());
 443           myViewerName = ViewerTest_myContexts.Find2
 444           (ViewerTest::GetAISContext());
 445         }
 446         else
 447         {
 448           // There is no opened contexts here, need to create names for viewer and driver
 449           myDriverName = CreateName<Handle(Graphic3d_GraphicDriver)>
 450             (ViewerTest_myDrivers, TCollection_AsciiString("Driver"));
 451
 452           myViewerName = CreateName <Handle(AIS_InteractiveContext)>
 453             (ViewerTest_myContexts, TCollection_AsciiString (myDriverName + "/Viewer"));
 454         }
 455         myViewName = TCollection_AsciiString(myViewerName + "/" + theInputString);
 456       }
 457       else if (aParserNumber == 1)
 458       {
 459         // Here is viewerName/viewName
 460         if (!ViewerTest::GetAISContext().IsNull())
 461           myDriverName = ViewerTest_myDrivers.Find2
 462           (ViewerTest::GetAISContext()->CurrentViewer()->Driver());
 463         else
 464         {
 465           // There is no opened contexts here, need to create name for driver
 466           myDriverName = CreateName<Handle(Graphic3d_GraphicDriver)>
 467             (ViewerTest_myDrivers, TCollection_AsciiString("Driver"));
 468         }
 469         myViewerName = TCollection_AsciiString(myDriverName + "/" + aName);
 470
 471         myViewName = TCollection_AsciiString(myDriverName + "/" + theInputString);
 472       }
 473       else
 474       {
 475         //Here is driverName/viewerName/viewName
 476         myDriverName = TCollection_AsciiString(aName);
 477
 478         TCollection_AsciiString aViewerName(theInputString);
 479         aViewerName.Split(aViewerName.SearchFromEnd("/") - 1);
 480         myViewerName = TCollection_AsciiString(aViewerName);
 481
 482         myViewName = TCollection_AsciiString(theInputString);
 483       }
 484     }
 485   }
 486 };
 487
 488 //==============================================================================
 489 //function : FindContextByView
 490 //purpose  : Find AIS_InteractiveContext by View
 491 //==============================================================================
 492
 493 Handle(AIS_InteractiveContext) FindContextByView (const Handle(V3d_View)& theView)
 494 {
 495   Handle(AIS_InteractiveContext) anAISContext;
 496
 497   for (NCollection_DoubleMap<TCollection_AsciiString, Handle(AIS_InteractiveContext)>::Iterator
 498        anIter (ViewerTest_myContexts); anIter.More(); anIter.Next())
 499   {
 500     if (anIter.Value()->CurrentViewer() == theView->Viewer())
 501        return anIter.Key2();
 502   }
 503   return anAISContext;
 504 }
 505
 506
 507 //==============================================================================
 508 //function : SetWindowTitle
 509 //purpose  : Set window title
 510 //==============================================================================
 511
 512 void SetWindowTitle (const Handle(Aspect_Window)& theWindow,
 513                      Standard_CString theTitle)
 514 {
 515 #if defined(_WIN32)
 516   const TCollection_ExtendedString theTitleW (theTitle);
 517   SetWindowTextW ((HWND )Handle(WNT_Window)::DownCast(theWindow)->HWindow(), theTitleW.ToWideString());
 518 #elif defined(__APPLE__) && !defined(MACOSX_USE_GLX)
 519   SetCocoaWindowTitle (Handle(Cocoa_Window)::DownCast(theWindow), theTitle);
 520 #else
 521   if(GetDisplayConnection()->GetDisplay())
 522   {
 523     Window aWindow =
 524       Handle(Xw_Window)::DownCast(theWindow)->XWindow();
 525     XStoreName (GetDisplayConnection()->GetDisplay(), aWindow , theTitle);
 526   }
 527 #endif
 528 }
 529
 530 //==============================================================================
 531 //function : IsWindowOverlapped
 532 //purpose  : Check if theWindow overlapp another view
 533 //==============================================================================
 534
 535 Standard_Boolean IsWindowOverlapped (const Standard_Integer thePxLeft,
 536                                      const Standard_Integer thePxTop,
 537                                      const Standard_Integer thePxRight,
 538                                      const Standard_Integer thePxBottom,
 539                                      TCollection_AsciiString& theViewId)
 540 {
 541   for(NCollection_DoubleMap <TCollection_AsciiString, Handle(V3d_View)>::Iterator
 542       anIter(ViewerTest_myViews); anIter.More(); anIter.Next())
 543   {
 544     Standard_Integer aTop = 0,
 545       aLeft = 0,
 546       aRight = 0,
 547       aBottom = 0;
 548     anIter.Value()->Window()->Position(aLeft, aTop, aRight, aBottom);
 549     if ((thePxLeft >= aLeft && thePxLeft <= aRight && thePxTop >= aTop && thePxTop <= aBottom) ||
 550         (thePxLeft >= aLeft && thePxLeft <= aRight && thePxBottom >= aTop && thePxBottom <= aBottom) ||
 551         (thePxRight >= aLeft && thePxRight <= aRight && thePxTop >= aTop && thePxTop <= aBottom) ||
 552         (thePxRight >= aLeft && thePxRight <= aRight && thePxBottom >= aTop && thePxBottom <= aBottom))
 553     {
 554       theViewId = anIter.Key1();
 555       return Standard_True;
 556     }
 557   }
 558   return Standard_False;
 559 }
 560
 561 // Workaround: to create and delete non-orthographic views outside ViewerTest
 562 void ViewerTest::RemoveViewName (const TCollection_AsciiString& theName)
 563 {
 564   ViewerTest_myViews.UnBind1 (theName);
 565 }
 566
 567 void ViewerTest::InitViewName (const TCollection_AsciiString& theName,
 568                                const Handle(V3d_View)& theView)
 569 {
 570   ViewerTest_myViews.Bind (theName, theView);
 571 }
 572
 573 TCollection_AsciiString ViewerTest::GetCurrentViewName ()
 574 {
 575   return ViewerTest_myViews.Find2( ViewerTest::CurrentView());
 576 }
 577 //==============================================================================
 578 //function : ViewerInit
 579 //purpose  : Create the window viewer and initialize all the global variable
 580 //==============================================================================
 581
 582 TCollection_AsciiString ViewerTest::ViewerInit (const Standard_Integer thePxLeft,
 583                                                 const Standard_Integer thePxTop,
 584                                                 const Standard_Integer thePxWidth,
 585                                                 const Standard_Integer thePxHeight,
 586                                                 const TCollection_AsciiString& theViewName,
 587                                                 const TCollection_AsciiString& theDisplayName,
 588                                                 const Handle(V3d_View)& theViewToClone)
 589 {
 590   // Default position and dimension of the viewer window.
 591   // Note that left top corner is set to be sufficiently small to have
 592   // window fit in the small screens (actual for remote desktops, see #23003).
 593   // The position corresponds to the window's client area, thus some
 594   // gap is added for window frame to be visible.
 595   Standard_Integer aPxLeft   = 20;
 596   Standard_Integer aPxTop    = 40;
 597   Standard_Integer aPxWidth  = 409;
 598   Standard_Integer aPxHeight = 409;
 599   Standard_Boolean toCreateViewer = Standard_False;
 600   if (!theViewToClone.IsNull())
 601   {
 602     theViewToClone->Window()->Size (aPxWidth, aPxHeight);
 603   }
 604
 605   Handle(OpenGl_GraphicDriver) aGraphicDriver;
 606   ViewerTest_Names aViewNames(theViewName);
 607   if (ViewerTest_myViews.IsBound1 (aViewNames.GetViewName ()))
 608     aViewNames.SetViewName (aViewNames.GetViewerName() + "/" + CreateName<Handle(V3d_View)>(ViewerTest_myViews, "View"));
 609
 610   if (thePxLeft != 0)
 611     aPxLeft = thePxLeft;
 612   if (thePxTop != 0)
 613     aPxTop = thePxTop;
 614   if (thePxWidth != 0)
 615     aPxWidth = thePxWidth;
 616   if (thePxHeight != 0)
 617     aPxHeight = thePxHeight;
 618
 619   // Get graphic driver (create it or get from another view)
 620   if (!ViewerTest_myDrivers.IsBound1 (aViewNames.GetDriverName()))
 621   {
 622     // Get connection string
 623   #if !defined(_WIN32) && (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
 624     TCollection_AsciiString aDisplayName(theDisplayName);
 625     if (!aDisplayName.IsEmpty())
 626       SetDisplayConnection (new Aspect_DisplayConnection ());
 627     else
 628       SetDisplayConnection (new Aspect_DisplayConnection (aDisplayName));
 629   #else
 630     (void)theDisplayName; // avoid warning on unused argument
 631     SetDisplayConnection (new Aspect_DisplayConnection ());
 632   #endif
 633
 634     if (Draw_VirtualWindows)
 635     {
 636       // don't waste the time waiting for VSync when window is not displayed on the screen
 637       ViewerTest_myDefaultCaps.swapInterval = 0;
 638       // alternatively we can disable buffer swap at all, but this might be inappropriate for testing
 639       //ViewerTest_myDefaultCaps.buffersNoSwap = true;
 640     }
 641     aGraphicDriver = new OpenGl_GraphicDriver (GetDisplayConnection());
 642     aGraphicDriver->ChangeOptions() = ViewerTest_myDefaultCaps;
 643
 644     ViewerTest_myDrivers.Bind (aViewNames.GetDriverName(), aGraphicDriver);
 645     toCreateViewer = Standard_True;
 646   }
 647   else
 648   {
 649     aGraphicDriver = Handle(OpenGl_GraphicDriver)::DownCast (ViewerTest_myDrivers.Find1 (aViewNames.GetDriverName()));
 650   }
 651
 652   //Dispose the window if input parameters are default
 653   if (!ViewerTest_myViews.IsEmpty() && thePxLeft == 0 && thePxTop == 0)
 654   {
 655     Standard_Integer aTop = 0,
 656                      aLeft = 0,
 657                      aRight = 0,
 658                      aBottom = 0,
 659                      aScreenWidth = 0,
 660                      aScreenHeight = 0;
 661
 662     // Get screen resolution
 663 #if defined(_WIN32) || defined(__WIN32__)
 664     RECT aWindowSize;
 665     GetClientRect(GetDesktopWindow(), &aWindowSize);
 666     aScreenHeight = aWindowSize.bottom;
 667     aScreenWidth = aWindowSize.right;
 668 #elif defined(__APPLE__) && !defined(MACOSX_USE_GLX)
 669     GetCocoaScreenResolution (aScreenWidth, aScreenHeight);
 670 #else
 671     Screen *aScreen = DefaultScreenOfDisplay(GetDisplayConnection()->GetDisplay());
 672     aScreenWidth = WidthOfScreen(aScreen);
 673     aScreenHeight = HeightOfScreen(aScreen);
 674 #endif
 675
 676     TCollection_AsciiString anOverlappedViewId("");
 677
 678     while (IsWindowOverlapped (aPxLeft, aPxTop, aPxLeft + aPxWidth, aPxTop + aPxHeight, anOverlappedViewId))
 679     {
 680       ViewerTest_myViews.Find1(anOverlappedViewId)->Window()->Position (aLeft, aTop, aRight, aBottom);
 681
 682       if (IsWindowOverlapped (aRight + 20, aPxTop, aRight + 20 + aPxWidth, aPxTop + aPxHeight, anOverlappedViewId)
 683         && aRight + 2*aPxWidth + 40 > aScreenWidth)
 684       {
 685         if (aBottom + aPxHeight + 40 > aScreenHeight)
 686         {
 687           aPxLeft = 20;
 688           aPxTop = 40;
 689           break;
 690         }
 691         aPxLeft = 20;
 692         aPxTop = aBottom + 40;
 693       }
 694       else
 695         aPxLeft = aRight + 20;
 696     }
 697   }
 698
 699   // Get viewer name
 700   TCollection_AsciiString aTitle("3D View - ");
 701   aTitle = aTitle + aViewNames.GetViewName() + "(*)";
 702
 703   // Change name of current active window
 704   if (!ViewerTest::CurrentView().IsNull())
 705   {
 706     TCollection_AsciiString anActiveWindowTitle("3D View - ");
 707     anActiveWindowTitle = anActiveWindowTitle
 708       + ViewerTest_myViews.Find2 (ViewerTest::CurrentView());
 709     SetWindowTitle (ViewerTest::CurrentView()->Window(), anActiveWindowTitle.ToCString());
 710   }
 711
 712   // Create viewer
 713   Handle(V3d_Viewer) a3DViewer;
 714   // If it's the single view, we first look for empty context
 715   if (ViewerTest_myViews.IsEmpty() && !ViewerTest_myContexts.IsEmpty())
 716   {
 717     NCollection_DoubleMap <TCollection_AsciiString, Handle(AIS_InteractiveContext)>::Iterator
 718       anIter(ViewerTest_myContexts);
 719     if (anIter.More())
 720       ViewerTest::SetAISContext (anIter.Value());
 721     a3DViewer = ViewerTest::GetAISContext()->CurrentViewer();
 722   }
 723   else if (ViewerTest_myContexts.IsBound1(aViewNames.GetViewerName()))
 724   {
 725     ViewerTest::SetAISContext(ViewerTest_myContexts.Find1(aViewNames.GetViewerName()));
 726     a3DViewer = ViewerTest::GetAISContext()->CurrentViewer();
 727   }
 728   else if (a3DViewer.IsNull())
 729   {
 730     toCreateViewer = Standard_True;
 731     a3DViewer = new V3d_Viewer(aGraphicDriver);
 732     a3DViewer->SetDefaultBackgroundColor (ViewerTest_DefaultBackground.FlatColor);
 733     a3DViewer->SetDefaultBgGradientColors (ViewerTest_DefaultBackground.GradientColor1,
 734                                            ViewerTest_DefaultBackground.GradientColor2,
 735                                            ViewerTest_DefaultBackground.FillMethod);
 736   }
 737
 738   // AIS context setup
 739   if (ViewerTest::GetAISContext().IsNull() ||
 740       !(ViewerTest_myContexts.IsBound1(aViewNames.GetViewerName())))
 741   {
 742     Handle(AIS_InteractiveContext) aContext = new AIS_InteractiveContext (a3DViewer);
 743     ViewerTest::SetAISContext (aContext);
 744     ViewerTest_myContexts.Bind (aViewNames.GetViewerName(), ViewerTest::GetAISContext());
 745   }
 746   else
 747   {
 748     ViewerTest::ResetEventManager();
 749   }
 750
 751   // Create window
 752 #if defined(_WIN32)
 753   VT_GetWindow() = new WNT_Window (aTitle.ToCString(),
 754                                     Handle(WNT_WClass)::DownCast (WClass()),
 755                                     Draw_VirtualWindows ? WS_POPUP : WS_OVERLAPPEDWINDOW,
 756                                     aPxLeft, aPxTop,
 757                                     aPxWidth, aPxHeight,
 758                                     Quantity_NOC_BLACK);
 759 #elif defined(__APPLE__) && !defined(MACOSX_USE_GLX)
 760   VT_GetWindow() = new Cocoa_Window (aTitle.ToCString(),
 761                                      aPxLeft, aPxTop,
 762                                      aPxWidth, aPxHeight);
 763   ViewerTest_SetCocoaEventManagerView (VT_GetWindow());
 764 #else
 765   VT_GetWindow() = new Xw_Window (aGraphicDriver->GetDisplayConnection(),
 766                                   aTitle.ToCString(),
 767                                   aPxLeft, aPxTop,
 768                                   aPxWidth, aPxHeight);
 769 #endif
 770   VT_GetWindow()->SetVirtual (Draw_VirtualWindows);
 771
 772   // View setup
 773   Handle(V3d_View) aView;
 774   if (!theViewToClone.IsNull())
 775   {
 776     aView = new ViewerTest_V3dView (a3DViewer, theViewToClone);
 777   }
 778   else
 779   {
 780     aView = new ViewerTest_V3dView (a3DViewer, a3DViewer->DefaultTypeOfView());
 781   }
 782
 783   aView->SetWindow (VT_GetWindow());
 784   ViewerTest::GetAISContext()->RedrawImmediate (a3DViewer);
 785
 786   ViewerTest::CurrentView(aView);
 787   ViewerTest_myViews.Bind (aViewNames.GetViewName(), aView);
 788
 789   // Setup for X11 or NT
 790   OSWindowSetup();
 791
 792   // Set parameters for V3d_View and V3d_Viewer
 793   const Handle (V3d_View) aV3dView = ViewerTest::CurrentView();
 794   aV3dView->SetComputedMode(Standard_False);
 795
 796   a3DViewer->SetDefaultBackgroundColor(Quantity_NOC_BLACK);
 797   if (toCreateViewer)
 798   {
 799     a3DViewer->SetDefaultLights();
 800     a3DViewer->SetLightOn();
 801   }
 802
 803   #if !defined(_WIN32) && (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
 804   #if TCL_MAJOR_VERSION  < 8
 805   Tk_CreateFileHandler((void*)XConnectionNumber(GetDisplayConnection()->GetDisplay()),
 806       TK_READABLE, VProcessEvents, (ClientData) VT_GetWindow()->XWindow() );
 807   #else
 808   Tk_CreateFileHandler(XConnectionNumber(GetDisplayConnection()->GetDisplay()),
 809       TK_READABLE, VProcessEvents, (ClientData) VT_GetWindow()->XWindow() );
 810   #endif
 811   #endif
 812
 813   VT_GetWindow()->Map();
 814
 815   // Set the handle of created view in the event manager
 816   ViewerTest::ResetEventManager();
 817
 818   ViewerTest::CurrentView()->Redraw();
 819
 820   aView.Nullify();
 821   a3DViewer.Nullify();
 822
 823   return aViewNames.GetViewName();
 824 }
 825
 826 //==============================================================================
 827 //function : RedrawAllViews
 828 //purpose  : Redraw all created views
 829 //==============================================================================
 830 void ViewerTest::RedrawAllViews()
 831 {
 832   NCollection_DoubleMap<TCollection_AsciiString, Handle(V3d_View)>::Iterator aViewIt(ViewerTest_myViews);
 833   for (; aViewIt.More(); aViewIt.Next())
 834   {
 835     const Handle(V3d_View)& aView = aViewIt.Key2();
 836     aView->Redraw();
 837   }
 838 }
 839
 840 //==============================================================================
 841 //function : Vinit
 842 //purpose  : Create the window viewer and initialize all the global variable
 843 //    Use Tk_CreateFileHandler on UNIX to catch the X11 Viewer event
 844 //==============================================================================
 845
 846 static int VInit (Draw_Interpretor& theDi, Standard_Integer theArgsNb, const char** theArgVec)
 847 {
 848   TCollection_AsciiString aViewName, aDisplayName;
 849   Standard_Integer aPxLeft = 0, aPxTop = 0, aPxWidth = 0, aPxHeight = 0;
 850   Handle(V3d_View) aCopyFrom;
 851   TCollection_AsciiString aName, aValue;
 852   int is2dMode = -1;
 853   for (Standard_Integer anArgIt = 1; anArgIt < theArgsNb; ++anArgIt)
 854   {
 855     const TCollection_AsciiString anArg = theArgVec[anArgIt];
 856     TCollection_AsciiString anArgCase = anArg;
 857     anArgCase.LowerCase();
 858     if (anArgIt + 1 < theArgsNb
 859      && anArgCase == "-name")
 860     {
 861       aViewName = theArgVec[++anArgIt];
 862     }
 863     else if (anArgIt + 1 < theArgsNb
 864           && (anArgCase == "-left"
 865            || anArgCase == "-l"))
 866     {
 867       aPxLeft = Draw::Atoi (theArgVec[++anArgIt]);
 868     }
 869     else if (anArgIt + 1 < theArgsNb
 870           && (anArgCase == "-top"
 871            || anArgCase == "-t"))
 872     {
 873       aPxTop = Draw::Atoi (theArgVec[++anArgIt]);
 874     }
 875     else if (anArgIt + 1 < theArgsNb
 876           && (anArgCase == "-width"
 877            || anArgCase == "-w"))
 878     {
 879       aPxWidth = Draw::Atoi (theArgVec[++anArgIt]);
 880     }
 881     else if (anArgIt + 1 < theArgsNb
 882           && (anArgCase == "-height"
 883            || anArgCase == "-h"))
 884     {
 885       aPxHeight = Draw::Atoi (theArgVec[++anArgIt]);
 886     }
 887     else if (anArgCase == "-exitonclose")
 888     {
 889       Draw_ToExitOnCloseView = true;
 890       if (anArgIt + 1 < theArgsNb
 891        && ViewerTest::ParseOnOff (theArgVec[anArgIt + 1], Draw_ToExitOnCloseView))
 892       {
 893         ++anArgIt;
 894       }
 895     }
 896     else if (anArgCase == "-closeonescape"
 897           || anArgCase == "-closeonesc")
 898     {
 899       Draw_ToCloseViewOnEsc = true;
 900       if (anArgIt + 1 < theArgsNb
 901        && ViewerTest::ParseOnOff (theArgVec[anArgIt + 1], Draw_ToCloseViewOnEsc))
 902       {
 903         ++anArgIt;
 904       }
 905     }
 906     else if (anArgCase == "-2d_mode"
 907           || anArgCase == "-2dmode"
 908           || anArgCase == "-2d")
 909     {
 910       bool toEnable = true;
 911       if (anArgIt + 1 < theArgsNb
 912        && ViewerTest::ParseOnOff (theArgVec[anArgIt + 1], toEnable))
 913       {
 914         ++anArgIt;
 915       }
 916       is2dMode = toEnable ? 1 : 0;
 917     }
 918     else if (anArgIt + 1 < theArgsNb
 919           && (anArgCase == "-disp"
 920            || anArgCase == "-display"))
 921     {
 922       aDisplayName = theArgVec[++anArgIt];
 923     }
 924     else if (!ViewerTest::CurrentView().IsNull()
 925           &&  aCopyFrom.IsNull()
 926           && (anArgCase == "-copy"
 927            || anArgCase == "-clone"
 928            || anArgCase == "-cloneactive"
 929            || anArgCase == "-cloneactiveview"))
 930     {
 931       aCopyFrom = ViewerTest::CurrentView();
 932     }
 933     // old syntax
 934     else if (ViewerTest::SplitParameter (anArg, aName, aValue))
 935     {
 936       aName.LowerCase();
 937       if (aName == "name")
 938       {
 939         aViewName = aValue;
 940       }
 941       else if (aName == "l"
 942             || aName == "left")
 943       {
 944         aPxLeft = aValue.IntegerValue();
 945       }
 946       else if (aName == "t"
 947             || aName == "top")
 948       {
 949         aPxTop = aValue.IntegerValue();
 950       }
 951       else if (aName == "disp"
 952             || aName == "display")
 953       {
 954         aDisplayName = aValue;
 955       }
 956       else if (aName == "w"
 957             || aName == "width")
 958       {
 959         aPxWidth = aValue.IntegerValue();
 960       }
 961       else if (aName == "h"
 962             || aName == "height")
 963       {
 964         aPxHeight = aValue.IntegerValue();
 965       }
 966       else
 967       {
 968         std::cout << "Syntax error: unknown argument " << anArg << ".\n";
 969         return 1;
 970       }
 971     }
 972     else if (aViewName.IsEmpty())
 973     {
 974       aViewName = anArg;
 975     }
 976     else
 977     {
 978       std::cout << "Syntax error: unknown argument " << anArg << ".\n";
 979       return 1;
 980     }
 981   }
 982
 983 #if defined(_WIN32) || (defined(__APPLE__) && !defined(MACOSX_USE_GLX))
 984   if (!aDisplayName.IsEmpty())
 985   {
 986     aDisplayName.Clear();
 987     std::cout << "Warning: display parameter will be ignored.\n";
 988   }
 989 #endif
 990
 991   ViewerTest_Names aViewNames (aViewName);
 992   if (ViewerTest_myViews.IsBound1 (aViewNames.GetViewName()))
 993   {
 994     TCollection_AsciiString aCommand = TCollection_AsciiString ("vactivate ") + aViewNames.GetViewName();
 995     theDi.Eval (aCommand.ToCString());
 996     if (is2dMode != -1)
 997     {
 998       ViewerTest_V3dView::SetCurrentView2DMode (is2dMode == 1);
 999     }
1000     return 0;
1001   }
1002
1003   TCollection_AsciiString aViewId = ViewerTest::ViewerInit (aPxLeft, aPxTop, aPxWidth, aPxHeight,
1004                                                             aViewName, aDisplayName, aCopyFrom);
1005   if (is2dMode != -1)
1006   {
1007     ViewerTest_V3dView::SetCurrentView2DMode (is2dMode == 1);
1008   }
1009   theDi << aViewId;
1010   return 0;
1011 }
1012
1013 //! Parse HLR algo type.
1014 static Standard_Boolean parseHlrAlgoType (const char* theName,
1015                                           Prs3d_TypeOfHLR& theType)
1016 {
1017   TCollection_AsciiString aName (theName);
1018   aName.LowerCase();
1019   if (aName == "polyalgo")
1020   {
1021     theType = Prs3d_TOH_PolyAlgo;
1022   }
1023   else if (aName == "algo")
1024   {
1025     theType = Prs3d_TOH_Algo;
1026   }
1027   else
1028   {
1029     return Standard_False;
1030   }
1031   return Standard_True;
1032 }
1033
1034 //==============================================================================
1035 //function : VHLR
1036 //purpose  : hidden lines removal algorithm
1037 //==============================================================================
1038
1039 static int VHLR (Draw_Interpretor& di, Standard_Integer argc, const char** argv)
1040 {
1041   const Handle(V3d_View) aView = ViewerTest::CurrentView();
1042   const Handle(AIS_InteractiveContext) aCtx = ViewerTest::GetAISContext();
1043   if (aView.IsNull())
1044   {
1045     std::cerr << "Error: No opened viewer!\n";
1046     return 1;
1047   }
1048
1049   Standard_Boolean hasHlrOnArg = Standard_False;
1050   Standard_Boolean hasShowHiddenArg = Standard_False;
1051   Standard_Boolean isHLROn = Standard_False;
1052   Standard_Boolean toShowHidden = aCtx->DefaultDrawer()->DrawHiddenLine();
1053   Prs3d_TypeOfHLR  aTypeOfHLR = Prs3d_TOH_NotSet;
1054   ViewerTest_AutoUpdater anUpdateTool (Handle(AIS_InteractiveContext)(), aView);
1055   for (Standard_Integer anArgIter = 1; anArgIter < argc; ++anArgIter)
1056   {
1057     TCollection_AsciiString anArg (argv[anArgIter]);
1058     anArg.LowerCase();
1059     if (anUpdateTool.parseRedrawMode (anArg))
1060     {
1061       continue;
1062     }
1063     else if (anArg == "-showhidden"
1064           && anArgIter + 1 < argc
1065           && ViewerTest::ParseOnOff (argv[anArgIter + 1], toShowHidden))
1066     {
1067       ++anArgIter;
1068       hasShowHiddenArg = Standard_True;
1069       continue;
1070     }
1071     else if ((anArg == "-type"
1072            || anArg == "-algo"
1073            || anArg == "-algotype")
1074           && anArgIter + 1 < argc
1075           && parseHlrAlgoType (argv[anArgIter + 1], aTypeOfHLR))
1076     {
1077       ++anArgIter;
1078       continue;
1079     }
1080     else if (!hasHlrOnArg
1081           && ViewerTest::ParseOnOff (argv[anArgIter], isHLROn))
1082     {
1083       hasHlrOnArg = Standard_True;
1084       continue;
1085     }
1086     // old syntax
1087     else if (!hasShowHiddenArg
1088           && ViewerTest::ParseOnOff(argv[anArgIter], toShowHidden))
1089     {
1090       hasShowHiddenArg = Standard_True;
1091       continue;
1092     }
1093     else
1094     {
1095       std::cout << "Syntax error at '" << argv[anArgIter] << "'\n";
1096       return 1;
1097     }
1098   }
1099   if (!hasHlrOnArg)
1100   {
1101     di << "HLR:        " << aView->ComputedMode() << "\n";
1102     di << "HiddenLine: " << aCtx->DefaultDrawer()->DrawHiddenLine() << "\n";
1103     di << "HlrAlgo:    ";
1104     switch (aCtx->DefaultDrawer()->TypeOfHLR())
1105     {
1106       case Prs3d_TOH_NotSet:   di << "NotSet\n";   break;
1107       case Prs3d_TOH_PolyAlgo: di << "PolyAlgo\n"; break;
1108       case Prs3d_TOH_Algo:     di << "Algo\n";     break;
1109     }
1110     anUpdateTool.Invalidate();
1111     return 0;
1112   }
1113
1114   Standard_Boolean toRecompute = Standard_False;
1115   if (aTypeOfHLR != Prs3d_TOH_NotSet
1116    && aTypeOfHLR != aCtx->DefaultDrawer()->TypeOfHLR())
1117   {
1118     toRecompute = Standard_True;
1119     aCtx->DefaultDrawer()->SetTypeOfHLR (aTypeOfHLR);
1120   }
1121   if (toShowHidden != aCtx->DefaultDrawer()->DrawHiddenLine())
1122   {
1123     toRecompute = Standard_True;
1124     if (toShowHidden)
1125     {
1126       aCtx->DefaultDrawer()->EnableDrawHiddenLine();
1127     }
1128     else
1129     {
1130       aCtx->DefaultDrawer()->DisableDrawHiddenLine();
1131     }
1132   }
1133
1134   // redisplay shapes
1135   if (aView->ComputedMode() && isHLROn && toRecompute)
1136   {
1137     AIS_ListOfInteractive aListOfShapes;
1138     aCtx->DisplayedObjects (aListOfShapes);
1139     for (AIS_ListIteratorOfListOfInteractive anIter (aListOfShapes); anIter.More(); anIter.Next())
1140     {
1141       if (Handle(AIS_Shape) aShape = Handle(AIS_Shape)::DownCast(anIter.Value()))
1142       {
1143         aCtx->Redisplay (aShape, Standard_False);
1144       }
1145     }
1146   }
1147
1148   aView->SetComputedMode (isHLROn);
1149   return 0;
1150 }
1151
1152 //==============================================================================
1153 //function : VHLRType
1154 //purpose  : change type of using HLR algorithm
1155 //==============================================================================
1156
1157 static int VHLRType (Draw_Interpretor& , Standard_Integer argc, const char** argv)
1158 {
1159   const Handle(V3d_View) aView = ViewerTest::CurrentView();
1160   const Handle(AIS_InteractiveContext) aCtx = ViewerTest::GetAISContext();
1161   if (aView.IsNull())
1162   {
1163     std::cerr << "Error: No opened viewer!\n";
1164     return 1;
1165   }
1166
1167   Prs3d_TypeOfHLR aTypeOfHLR = Prs3d_TOH_NotSet;
1168   ViewerTest_AutoUpdater anUpdateTool (Handle(AIS_InteractiveContext)(), aView);
1169   AIS_ListOfInteractive aListOfShapes;
1170   for (Standard_Integer anArgIter = 1; anArgIter < argc; ++anArgIter)
1171   {
1172     TCollection_AsciiString anArg (argv[anArgIter]);
1173     anArg.LowerCase();
1174     if (anUpdateTool.parseRedrawMode (anArg))
1175     {
1176       continue;
1177     }
1178     else if ((anArg == "-type"
1179            || anArg == "-algo"
1180            || anArg == "-algotype")
1181           && anArgIter + 1 < argc
1182           && parseHlrAlgoType (argv[anArgIter + 1], aTypeOfHLR))
1183     {
1184       ++anArgIter;
1185       continue;
1186     }
1187     // old syntax
1188     else if (aTypeOfHLR == Prs3d_TOH_NotSet
1189           && parseHlrAlgoType (argv[anArgIter], aTypeOfHLR))
1190     {
1191       continue;
1192     }
1193     else
1194     {
1195       ViewerTest_DoubleMapOfInteractiveAndName& aMap = GetMapOfAIS();
1196       TCollection_AsciiString aName (argv[anArgIter]);
1197       if (!aMap.IsBound2 (aName))
1198       {
1199         std::cout << "Syntax error: Wrong shape name '" << aName << "'.\n";
1200         return 1;
1201       }
1202
1203       Handle(AIS_Shape) aShape = Handle(AIS_Shape)::DownCast (aMap.Find2 (aName));
1204       if (aShape.IsNull())
1205       {
1206         std::cout << "Syntax error: '" << aName << "' is not a shape presentation.\n";
1207         return 1;
1208       }
1209       aListOfShapes.Append (aShape);
1210       continue;
1211     }
1212   }
1213   if (aTypeOfHLR == Prs3d_TOH_NotSet)
1214   {
1215     std::cout << "Syntax error: wrong number of arguments!\n";
1216     return 1;
1217   }
1218
1219   const Standard_Boolean isGlobal = aListOfShapes.IsEmpty();
1220   if (isGlobal)
1221   {
1222     aCtx->DisplayedObjects (aListOfShapes);
1223     aCtx->DefaultDrawer()->SetTypeOfHLR (aTypeOfHLR);
1224   }
1225
1226   for (AIS_ListIteratorOfListOfInteractive anIter(aListOfShapes); anIter.More(); anIter.Next())
1227   {
1228     Handle(AIS_Shape) aShape = Handle(AIS_Shape)::DownCast(anIter.Value());
1229     if (aShape.IsNull())
1230     {
1231       continue;
1232     }
1233
1234     const bool toUpdateShape = aShape->TypeOfHLR() != aTypeOfHLR
1235                             && aView->ComputedMode();
1236     if (!isGlobal
1237      || aShape->TypeOfHLR() != aTypeOfHLR)
1238     {
1239       aShape->SetTypeOfHLR (aTypeOfHLR);
1240     }
1241     if (toUpdateShape)
1242     {
1243       aCtx->Redisplay (aShape, Standard_False);
1244     }
1245   }
1246   return 0;
1247 }
1248
1249 //==============================================================================
1250 //function : FindViewIdByWindowHandle
1251 //purpose  : Find theView Id in the map of views by window handle
1252 //==============================================================================
1253 #if defined(_WIN32) || defined(__WIN32__) || (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
1254 TCollection_AsciiString FindViewIdByWindowHandle(const Aspect_Handle theWindowHandle)
1255 {
1256   for (NCollection_DoubleMap<TCollection_AsciiString, Handle(V3d_View)>::Iterator
1257        anIter(ViewerTest_myViews); anIter.More(); anIter.Next())
1258   {
1259     Aspect_Handle aWindowHandle = GetWindowHandle(anIter.Value()->Window());
1260     if (aWindowHandle == theWindowHandle)
1261       return anIter.Key1();
1262   }
1263   return TCollection_AsciiString("");
1264 }
1265 #endif
1266
1267 //==============================================================================
1268 //function : ActivateView
1269 //purpose  : Make the view active
1270 //==============================================================================
1271
1272 void ActivateView (const TCollection_AsciiString& theViewName)
1273 {
1274   const Handle(V3d_View) aView = ViewerTest_myViews.Find1(theViewName);
1275   if (!aView.IsNull())
1276   {
1277     Handle(AIS_InteractiveContext) anAISContext = FindContextByView(aView);
1278     if (!anAISContext.IsNull())
1279     {
1280       if (!ViewerTest::CurrentView().IsNull())
1281       {
1282         TCollection_AsciiString aTitle("3D View - ");
1283         aTitle = aTitle + ViewerTest_myViews.Find2 (ViewerTest::CurrentView());
1284         SetWindowTitle (ViewerTest::CurrentView()->Window(), aTitle.ToCString());
1285       }
1286
1287       ViewerTest::CurrentView (aView);
1288       ViewerTest::SetAISContext (anAISContext);
1289       TCollection_AsciiString aTitle = TCollection_AsciiString("3D View - ") + theViewName + "(*)";
1290       SetWindowTitle (ViewerTest::CurrentView()->Window(), aTitle.ToCString());
1291 #if defined(_WIN32)
1292       VT_GetWindow() = Handle(WNT_Window)::DownCast(ViewerTest::CurrentView()->Window());
1293 #elif defined(__APPLE__) && !defined(MACOSX_USE_GLX)
1294       VT_GetWindow() = Handle(Cocoa_Window)::DownCast(ViewerTest::CurrentView()->Window());
1295 #else
1296       VT_GetWindow() = Handle(Xw_Window)::DownCast(ViewerTest::CurrentView()->Window());
1297 #endif
1298       SetDisplayConnection(ViewerTest::CurrentView()->Viewer()->Driver()->GetDisplayConnection());
1299       ViewerTest::CurrentView()->Redraw();
1300     }
1301   }
1302 }
1303
1304 //==============================================================================
1305 //function : RemoveView
1306 //purpose  :
1307 //==============================================================================
1308 void ViewerTest::RemoveView (const Handle(V3d_View)& theView,
1309                              const Standard_Boolean  theToRemoveContext)
1310 {
1311   if (!ViewerTest_myViews.IsBound2 (theView))
1312   {
1313     return;
1314   }
1315
1316   const TCollection_AsciiString aViewName = ViewerTest_myViews.Find2 (theView);
1317   RemoveView (aViewName, theToRemoveContext);
1318 }
1319
1320 //==============================================================================
1321 //function : RemoveView
1322 //purpose  : Close and remove view from display, clear maps if neccessary
1323 //==============================================================================
1324 void ViewerTest::RemoveView (const TCollection_AsciiString& theViewName, const Standard_Boolean isContextRemoved)
1325 {
1326   if (!ViewerTest_myViews.IsBound1(theViewName))
1327   {
1328     cout << "Wrong view name\n";
1329     return;
1330   }
1331
1332   // Activate another view if it's active now
1333   if (ViewerTest_myViews.Find1(theViewName) == ViewerTest::CurrentView())
1334   {
1335     if (ViewerTest_myViews.Extent() > 1)
1336     {
1337       TCollection_AsciiString aNewViewName;
1338       for (NCollection_DoubleMap <TCollection_AsciiString, Handle(V3d_View)>::Iterator anIter (ViewerTest_myViews);
1339            anIter.More(); anIter.Next())
1340       {
1341         if (anIter.Key1() != theViewName)
1342         {
1343           aNewViewName = anIter.Key1();
1344           break;
1345         }
1346       }
1347       ActivateView (aNewViewName);
1348     }
1349     else
1350     {
1351       Handle(V3d_View) anEmptyView;
1352 #if defined(_WIN32) || defined(__WIN32__)
1353       Handle(WNT_Window) anEmptyWindow;
1354 #elif defined(__APPLE__) && !defined(MACOSX_USE_GLX)
1355       Handle(Cocoa_Window) anEmptyWindow;
1356 #else
1357       Handle(Xw_Window) anEmptyWindow;
1358 #endif
1359       VT_GetWindow() = anEmptyWindow;
1360       ViewerTest::CurrentView (anEmptyView);
1361       if (isContextRemoved)
1362       {
1363         Handle(AIS_InteractiveContext) anEmptyContext;
1364         ViewerTest::SetAISContext(anEmptyContext);
1365       }
1366     }
1367   }
1368
1369   // Delete view
1370   Handle(V3d_View) aView = ViewerTest_myViews.Find1(theViewName);
1371   Handle(AIS_InteractiveContext) aCurrentContext = FindContextByView(aView);
1372
1373   // Remove view resources
1374   ViewerTest_myViews.UnBind1(theViewName);
1375   aView->Window()->Unmap();
1376   aView->Remove();
1377
1378 #if !defined(_WIN32) && !defined(__WIN32__) && (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
1379   XFlush (GetDisplayConnection()->GetDisplay());
1380 #endif
1381
1382   // Keep context opened only if the closed view is last to avoid
1383   // unused empty contexts
1384   if (!aCurrentContext.IsNull())
1385   {
1386     // Check if there are more difined views in the viewer
1387     aCurrentContext->CurrentViewer()->InitDefinedViews();
1388     if ((isContextRemoved || ViewerTest_myContexts.Size() != 1) && !aCurrentContext->CurrentViewer()->MoreDefinedViews())
1389     {
1390       // Remove driver if there is no viewers that use it
1391       Standard_Boolean isRemoveDriver = Standard_True;
1392       for(NCollection_DoubleMap<TCollection_AsciiString, Handle(AIS_InteractiveContext)>::Iterator
1393           anIter(ViewerTest_myContexts); anIter.More(); anIter.Next())
1394       {
1395         if (aCurrentContext != anIter.Key2() &&
1396           aCurrentContext->CurrentViewer()->Driver() == anIter.Value()->CurrentViewer()->Driver())
1397         {
1398           isRemoveDriver = Standard_False;
1399           break;
1400         }
1401       }
1402
1403       aCurrentContext->RemoveAll (Standard_False);
1404       if(isRemoveDriver)
1405       {
1406         ViewerTest_myDrivers.UnBind2 (aCurrentContext->CurrentViewer()->Driver());
1407       #if !defined(_WIN32) && !defined(__WIN32__) && (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
1408         #if TCL_MAJOR_VERSION  < 8
1409         Tk_DeleteFileHandler((void*)XConnectionNumber(aCurrentContext->CurrentViewer()->Driver()->GetDisplayConnection()->GetDisplay()));
1410         #else
1411         Tk_DeleteFileHandler(XConnectionNumber(aCurrentContext->CurrentViewer()->Driver()->GetDisplayConnection()->GetDisplay()));
1412         #endif
1413       #endif
1414       }
1415
1416       ViewerTest_myContexts.UnBind2(aCurrentContext);
1417     }
1418   }
1419   cout << "3D View - " << theViewName << " was deleted.\n";
1420   if (Draw_ToExitOnCloseView)
1421   {
1422     Draw_Interprete ("exit");
1423   }
1424 }
1425
1426 //==============================================================================
1427 //function : VClose
1428 //purpose  : Remove the view defined by its name
1429 //==============================================================================
1430
1431 static int VClose (Draw_Interpretor& /*theDi*/,
1432                    Standard_Integer  theArgsNb,
1433                    const char**      theArgVec)
1434 {
1435   NCollection_List<TCollection_AsciiString> aViewList;
1436   if (theArgsNb > 1)
1437   {
1438     TCollection_AsciiString anArg (theArgVec[1]);
1439     anArg.UpperCase();
1440     if (anArg.IsEqual ("ALL")
1441      || anArg.IsEqual ("*"))
1442     {
1443       for (NCollection_DoubleMap<TCollection_AsciiString, Handle(V3d_View)>::Iterator anIter (ViewerTest_myViews);
1444            anIter.More(); anIter.Next())
1445       {
1446         aViewList.Append (anIter.Key1());
1447       }
1448       if (aViewList.IsEmpty())
1449       {
1450         std::cout << "No view to close\n";
1451         return 0;
1452       }
1453     }
1454     else
1455     {
1456       ViewerTest_Names aViewName (theArgVec[1]);
1457       if (!ViewerTest_myViews.IsBound1 (aViewName.GetViewName()))
1458       {
1459         std::cerr << "The view with name '" << theArgVec[1] << "' does not exist\n";
1460         return 1;
1461       }
1462       aViewList.Append (aViewName.GetViewName());
1463     }
1464   }
1465   else
1466   {
1467     // close active view
1468     if (ViewerTest::CurrentView().IsNull())
1469     {
1470       std::cerr << "No active view!\n";
1471       return 1;
1472     }
1473     aViewList.Append (ViewerTest_myViews.Find2 (ViewerTest::CurrentView()));
1474   }
1475
1476   Standard_Boolean toRemoveContext = (theArgsNb != 3 || Draw::Atoi (theArgVec[2]) != 1);
1477   for (NCollection_List<TCollection_AsciiString>::Iterator anIter(aViewList);
1478        anIter.More(); anIter.Next())
1479   {
1480     ViewerTest::RemoveView (anIter.Value(), toRemoveContext);
1481   }
1482
1483   return 0;
1484 }
1485
1486 //==============================================================================
1487 //function : VActivate
1488 //purpose  : Activate the view defined by its ID
1489 //==============================================================================
1490
1491 static int VActivate (Draw_Interpretor& theDi, Standard_Integer theArgsNb, const char** theArgVec)
1492 {
1493   if (theArgsNb > 2)
1494   {
1495     theDi << theArgVec[0] << ": wrong number of command arguments.\n"
1496     << "Usage: " << theArgVec[0] << " ViewID\n";
1497     return 1;
1498   }
1499   if(theArgsNb == 1)
1500   {
1501     theDi.Eval("vviewlist");
1502     return 0;
1503   }
1504
1505   TCollection_AsciiString aNameString(theArgVec[1]);
1506   if ( strcasecmp( aNameString.ToCString(), "NONE" ) == 0 )
1507   {
1508     TCollection_AsciiString aTitle("3D View - ");
1509     aTitle = aTitle + ViewerTest_myViews.Find2(ViewerTest::CurrentView());
1510     SetWindowTitle (ViewerTest::CurrentView()->Window(), aTitle.ToCString());
1511     Handle(V3d_View) anEmptyView;
1512 #if defined(_WIN32) || defined(__WIN32__)
1513     Handle(WNT_Window) anEmptyWindow;
1514 #elif defined(__APPLE__) && !defined(MACOSX_USE_GLX)
1515     Handle(Cocoa_Window) anEmptyWindow;
1516 #else
1517     Handle(Xw_Window) anEmptyWindow;
1518 #endif
1519     VT_GetWindow() = anEmptyWindow;
1520     ViewerTest::CurrentView (anEmptyView);
1521     ViewerTest::ResetEventManager();
1522     theDi << theArgVec[0] << ": all views are inactive\n";
1523     return 0;
1524   }
1525
1526   ViewerTest_Names aViewNames(aNameString);
1527
1528   // Check if this view exists in the viewer with the driver
1529   if (!ViewerTest_myViews.IsBound1(aViewNames.GetViewName()))
1530   {
1531     theDi << "Wrong view name\n";
1532     return 1;
1533   }
1534
1535   // Check if it is active already
1536   if (ViewerTest::CurrentView() == ViewerTest_myViews.Find1(aViewNames.GetViewName()))
1537   {
1538     theDi << theArgVec[0] << ": the view is active already\n";
1539     return 0;
1540   }
1541
1542   ActivateView (aViewNames.GetViewName());
1543   return 0;
1544 }
1545
1546 //==============================================================================
1547 //function : VViewList
1548 //purpose  : Print current list of views per viewer and graphic driver ID
1549 //           shared between viewers
1550 //==============================================================================
1551
1552 static int VViewList (Draw_Interpretor& theDi, Standard_Integer theArgsNb, const char** theArgVec)
1553 {
1554   if (theArgsNb > 2)
1555   {
1556     theDi << theArgVec[0] << ": Wrong number of command arguments\n"
1557           << "Usage: " << theArgVec[0] << " name";
1558     return 1;
1559   }
1560   if (ViewerTest_myContexts.Size() < 1)
1561     return 0;
1562
1563   Standard_Boolean isTreeView =
1564     (( theArgsNb==1 ) || ( strcasecmp( theArgVec[1], "long" ) != 0 ));
1565
1566   if (isTreeView)
1567   {
1568     theDi << theArgVec[0] <<":\n";
1569   }
1570
1571   for (NCollection_DoubleMap <TCollection_AsciiString, Handle(Graphic3d_GraphicDriver)>::Iterator aDriverIter (ViewerTest_myDrivers);
1572        aDriverIter.More(); aDriverIter.Next())
1573   {
1574     if (isTreeView)
1575       theDi << aDriverIter.Key1() << ":\n";
1576
1577     for (NCollection_DoubleMap <TCollection_AsciiString, Handle(AIS_InteractiveContext)>::Iterator
1578       aContextIter(ViewerTest_myContexts); aContextIter.More(); aContextIter.Next())
1579     {
1580       if (aContextIter.Key1().Search(aDriverIter.Key1()) != -1)
1581       {
1582         if (isTreeView)
1583         {
1584           TCollection_AsciiString aContextName(aContextIter.Key1());
1585           theDi << " " << aContextName.Split(aDriverIter.Key1().Length() + 1) << ":\n";
1586         }
1587
1588         for (NCollection_DoubleMap <TCollection_AsciiString, Handle(V3d_View)>::Iterator aViewIter (ViewerTest_myViews);
1589              aViewIter.More(); aViewIter.Next())
1590         {
1591           if (aViewIter.Key1().Search(aContextIter.Key1()) != -1)
1592           {
1593             TCollection_AsciiString aViewName(aViewIter.Key1());
1594             if (isTreeView)
1595             {
1596               if (aViewIter.Value() == ViewerTest::CurrentView())
1597                 theDi << "  " << aViewName.Split(aContextIter.Key1().Length() + 1) << "(*)\n";
1598               else
1599                 theDi << "  " << aViewName.Split(aContextIter.Key1().Length() + 1) << "\n";
1600             }
1601             else
1602             {
1603               theDi << aViewName << " ";
1604             }
1605           }
1606         }
1607       }
1608     }
1609   }
1610   return 0;
1611 }
1612
1613 //==============================================================================
1614 //function : VT_ProcessKeyPress
1615 //purpose  : Handle KeyPress event from a CString
1616 //==============================================================================
1617 void VT_ProcessKeyPress (const char* buf_ret)
1618 {
1619   //cout << "KeyPress" << endl;
1620   const Handle(V3d_View) aView = ViewerTest::CurrentView();
1621   // Letter in alphabetic order
1622
1623   if (!strcasecmp (buf_ret, "A")
1624    && !ViewerTest_V3dView::IsCurrentViewIn2DMode())
1625   {
1626     // AXO
1627     aView->SetProj(V3d_XposYnegZpos);
1628   }
1629   else if (!strcasecmp (buf_ret, "D")
1630         && !ViewerTest_V3dView::IsCurrentViewIn2DMode())
1631   {
1632     // Reset
1633     aView->Reset();
1634   }
1635   else if (!strcasecmp (buf_ret, "F"))
1636   {
1637     if (ViewerTest::GetAISContext()->NbSelected() > 0)
1638     {
1639       ViewerTest::GetAISContext()->FitSelected (aView);
1640     }
1641     else
1642     {
1643       // FitAll
1644       aView->FitAll();
1645     }
1646   }
1647   else if (!strcasecmp (buf_ret, "H"))
1648   {
1649     // HLR
1650     std::cout << "HLR" << std::endl;
1651     aView->SetComputedMode (!aView->ComputedMode());
1652     aView->Redraw();
1653   }
1654   else if (!strcasecmp (buf_ret, "P"))
1655   {
1656     // Type of HLR
1657     Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
1658     if (aContext->DefaultDrawer()->TypeOfHLR() == Prs3d_TOH_Algo)
1659       aContext->DefaultDrawer()->SetTypeOfHLR(Prs3d_TOH_PolyAlgo);
1660     else
1661       aContext->DefaultDrawer()->SetTypeOfHLR(Prs3d_TOH_Algo);
1662     if (aContext->NbSelected()==0)
1663     {
1664       AIS_ListOfInteractive aListOfShapes;
1665       aContext->DisplayedObjects(aListOfShapes);
1666       for (AIS_ListIteratorOfListOfInteractive anIter(aListOfShapes);
1667         anIter.More(); anIter.Next())
1668       {
1669         Handle(AIS_Shape) aShape = Handle(AIS_Shape)::DownCast(anIter.Value());
1670         if (aShape.IsNull())
1671           continue;
1672         if (aShape->TypeOfHLR() == Prs3d_TOH_PolyAlgo)
1673           aShape->SetTypeOfHLR (Prs3d_TOH_Algo);
1674         else
1675           aShape->SetTypeOfHLR (Prs3d_TOH_PolyAlgo);
1676         aContext->Redisplay (aShape, Standard_False);
1677       }
1678     }
1679     else
1680     {
1681       for (aContext->InitSelected();aContext->MoreSelected();aContext->NextSelected())
1682       {
1683         Handle(AIS_Shape) aShape = Handle(AIS_Shape)::DownCast(aContext->SelectedInteractive());
1684         if (aShape.IsNull())
1685           continue;
1686         if(aShape->TypeOfHLR() == Prs3d_TOH_PolyAlgo)
1687           aShape->SetTypeOfHLR (Prs3d_TOH_Algo);
1688         else
1689           aShape->SetTypeOfHLR (Prs3d_TOH_PolyAlgo);
1690         aContext->Redisplay (aShape, Standard_False);
1691       }
1692     }
1693
1694     aContext->UpdateCurrentViewer();
1695
1696   }
1697   else if (!strcasecmp (buf_ret, "S"))
1698   {
1699     std::cout << "setup Shaded display mode" << std::endl;
1700
1701     Handle(AIS_InteractiveContext) Ctx = ViewerTest::GetAISContext();
1702     if(Ctx->NbSelected()==0)
1703       Ctx->SetDisplayMode (AIS_Shaded, Standard_True);
1704     else{
1705       for(Ctx->InitSelected();Ctx->MoreSelected();Ctx->NextSelected())
1706         Ctx->SetDisplayMode(Ctx->SelectedInteractive(),1,Standard_False);
1707       Ctx->UpdateCurrentViewer();
1708     }
1709   }
1710   else if (!strcasecmp (buf_ret, "U"))
1711   {
1712     // Unset display mode
1713     std::cout << "reset display mode to defaults" << std::endl;
1714
1715     Handle(AIS_InteractiveContext) Ctx = ViewerTest::GetAISContext();
1716     if(Ctx->NbSelected()==0)
1717       Ctx->SetDisplayMode (AIS_WireFrame, Standard_True);
1718     else{
1719       for(Ctx->InitSelected();Ctx->MoreSelected();Ctx->NextSelected())
1720         Ctx->UnsetDisplayMode(Ctx->SelectedInteractive(),Standard_False);
1721       Ctx->UpdateCurrentViewer();
1722     }
1723
1724   }
1725   else if (!strcasecmp (buf_ret, "T")
1726         && !ViewerTest_V3dView::IsCurrentViewIn2DMode())
1727   {
1728     // Top
1729     aView->SetProj(V3d_Zpos);
1730   }
1731   else if (!strcasecmp (buf_ret, "B")
1732         && !ViewerTest_V3dView::IsCurrentViewIn2DMode())
1733   {
1734     // Bottom
1735     aView->SetProj(V3d_Zneg);
1736   }
1737   else if (!strcasecmp (buf_ret, "L")
1738         && !ViewerTest_V3dView::IsCurrentViewIn2DMode())
1739   {
1740     // Left
1741     aView->SetProj(V3d_Xneg);
1742   }
1743   else if (!strcasecmp (buf_ret, "R")
1744         && !ViewerTest_V3dView::IsCurrentViewIn2DMode())
1745   {
1746     // Right
1747     aView->SetProj(V3d_Xpos);
1748   }
1749   else if (!strcasecmp (buf_ret, "W"))
1750   {
1751     std::cout << "setup WireFrame display mode" << std::endl;
1752     Handle(AIS_InteractiveContext) Ctx = ViewerTest::GetAISContext();
1753     if(Ctx->NbSelected()==0)
1754       Ctx->SetDisplayMode (AIS_WireFrame, Standard_True);
1755     else{
1756       for(Ctx->InitSelected();Ctx->MoreSelected();Ctx->NextSelected())
1757         Ctx->SetDisplayMode(Ctx->SelectedInteractive(),0,Standard_False);
1758       Ctx->UpdateCurrentViewer();
1759     }
1760   }
1761   else if (!strcasecmp (buf_ret, ","))
1762   {
1763     ViewerTest::GetAISContext()->HilightNextDetected(ViewerTest::CurrentView());
1764   }
1765   else if (!strcasecmp (buf_ret, "."))
1766   {
1767     ViewerTest::GetAISContext()->HilightPreviousDetected(ViewerTest::CurrentView());
1768   }
1769   else if (!strcasecmp (buf_ret, "/"))
1770   {
1771     Handle(Graphic3d_Camera) aCamera = aView->Camera();
1772     if (aCamera->IsStereo())
1773     {
1774       aCamera->SetIOD (aCamera->GetIODType(), aCamera->IOD() - 0.01);
1775       aView->Redraw();
1776     }
1777   }
1778   else if (!strcasecmp (buf_ret, "*"))
1779   {
1780     Handle(Graphic3d_Camera) aCamera = aView->Camera();
1781     if (aCamera->IsStereo())
1782     {
1783       aCamera->SetIOD (aCamera->GetIODType(), aCamera->IOD() + 0.01);
1784       aView->Redraw();
1785     }
1786   }
1787   else if (*buf_ret == THE_KEY_DELETE)
1788   {
1789     Handle(AIS_InteractiveContext) aCtx = ViewerTest::GetAISContext();
1790     if (!aCtx.IsNull()
1791      && aCtx->NbSelected() > 0)
1792     {
1793       Draw_Interprete ("verase");
1794     }
1795   }
1796   else if (*buf_ret == THE_KEY_ESCAPE)
1797   {
1798     Handle(AIS_InteractiveContext) aCtx = ViewerTest::GetAISContext();
1799     if (!aCtx.IsNull()
1800      && Draw_ToCloseViewOnEsc)
1801     {
1802       Draw_Interprete (Draw_ToExitOnCloseView ? "exit" : "vclose");
1803     }
1804   }
1805   else
1806   {
1807     // Number
1808     const Standard_Integer aSelMode = Draw::Atoi(buf_ret);
1809     if (aSelMode >= 0 && aSelMode <= 7)
1810     {
1811       bool toEnable = true;
1812       if (const Handle(AIS_InteractiveContext) aCtx = ViewerTest::GetAISContext())
1813       {
1814         AIS_ListOfInteractive aPrsList;
1815         aCtx->DisplayedObjects (aPrsList);
1816         for (AIS_ListOfInteractive::Iterator aPrsIter (aPrsList); aPrsIter.More() && toEnable; aPrsIter.Next())
1817         {
1818           TColStd_ListOfInteger aModes;
1819           aCtx->ActivatedModes (aPrsIter.Value(), aModes);
1820           for (TColStd_ListOfInteger::Iterator aModeIter (aModes); aModeIter.More() && toEnable; aModeIter.Next())
1821           {
1822             if (aModeIter.Value() == aSelMode)
1823             {
1824               toEnable = false;
1825             }
1826           }
1827         }
1828       }
1829       TCollection_AsciiString aCmd = TCollection_AsciiString ("vselmode ") + aSelMode + (toEnable ? " 1" : " 0");
1830       Draw_Interprete (aCmd.ToCString());
1831     }
1832   }
1833 }
1834
1835 //==============================================================================
1836 //function : VT_ProcessExpose
1837 //purpose  : Redraw the View on an Expose Event
1838 //==============================================================================
1839 void VT_ProcessExpose()
1840 {
1841   Handle(V3d_View) aView3d = ViewerTest::CurrentView();
1842   if (!aView3d.IsNull())
1843   {
1844     aView3d->Redraw();
1845   }
1846 }
1847
1848 //==============================================================================
1849 //function : VT_ProcessConfigure
1850 //purpose  : Resize the View on an Configure Event
1851 //==============================================================================
1852 void VT_ProcessConfigure()
1853 {
1854   Handle(V3d_View) aView3d = ViewerTest::CurrentView();
1855   if (aView3d.IsNull())
1856   {
1857     return;
1858   }
1859
1860   aView3d->MustBeResized();
1861   aView3d->Update();
1862   aView3d->Redraw();
1863 }
1864
1865 //==============================================================================
1866 //function : VT_ProcessButton1Press
1867 //purpose  : Picking
1868 //==============================================================================
1869 Standard_Boolean VT_ProcessButton1Press (Standard_Integer ,
1870                                          const char**     theArgVec,
1871                                          Standard_Boolean theToPick,
1872                                          Standard_Boolean theIsShift)
1873 {
1874   if (TheIsAnimating)
1875   {
1876     TheIsAnimating = Standard_False;
1877     return Standard_False;
1878   }
1879
1880   if (theToPick)
1881   {
1882     Standard_Real X, Y, Z;
1883     ViewerTest::CurrentView()->Convert (X_Motion, Y_Motion, X, Y, Z);
1884
1885     Draw::Set (theArgVec[1], X);
1886     Draw::Set (theArgVec[2], Y);
1887     Draw::Set (theArgVec[3], Z);
1888   }
1889
1890   if (theIsShift)
1891   {
1892     ViewerTest::CurrentEventManager()->ShiftSelect();
1893   }
1894   else
1895   {
1896     ViewerTest::CurrentEventManager()->Select();
1897   }
1898
1899   return Standard_False;
1900 }
1901
1902 //==============================================================================
1903 //function : VT_ProcessButton1Release
1904 //purpose  : End selecting
1905 //==============================================================================
1906 void VT_ProcessButton1Release (Standard_Boolean theIsShift)
1907 {
1908   if (IsDragged)
1909   {
1910     IsDragged = Standard_False;
1911     Handle(ViewerTest_EventManager) EM = ViewerTest::CurrentEventManager();
1912     if (theIsShift)
1913     {
1914       EM->ShiftSelect (X_ButtonPress, Y_ButtonPress,
1915                        X_Motion, Y_Motion);
1916     }
1917     else
1918     {
1919       EM->Select (X_ButtonPress, Y_ButtonPress,
1920                   X_Motion, Y_Motion);
1921     }
1922   }
1923 }
1924
1925 //==============================================================================
1926 //function : VT_ProcessButton3Press
1927 //purpose  : Start Rotation
1928 //==============================================================================
1929 void VT_ProcessButton3Press()
1930 {
1931   if (ViewerTest_V3dView::IsCurrentViewIn2DMode())
1932   {
1933     return;
1934   }
1935
1936   Start_Rot = 1;
1937   HasHlrOnBeforeRotation = ViewerTest::CurrentView()->ComputedMode();
1938   if (HasHlrOnBeforeRotation)
1939   {
1940     ViewerTest::CurrentView()->SetComputedMode (Standard_False);
1941   }
1942   ViewerTest::CurrentView()->StartRotation( X_ButtonPress, Y_ButtonPress );
1943 }
1944
1945 //==============================================================================
1946 //function : VT_ProcessButton3Release
1947 //purpose  : End rotation
1948 //==============================================================================
1949 void VT_ProcessButton3Release()
1950 {
1951   if (Start_Rot)
1952   {
1953     Start_Rot = 0;
1954     if (HasHlrOnBeforeRotation)
1955     {
1956       HasHlrOnBeforeRotation = Standard_False;
1957       ViewerTest::CurrentView()->SetComputedMode (Standard_True);
1958       ViewerTest::CurrentView()->Redraw();
1959     }
1960   }
1961 }
1962
1963 //==============================================================================
1964 //function : ProcessControlButton1Motion
1965 //purpose  : Zoom
1966 //==============================================================================
1967
1968 #if defined(_WIN32) || ! defined(__APPLE__) || defined(MACOSX_USE_GLX)
1969 static void ProcessControlButton1Motion()
1970 {
1971   ViewerTest::CurrentView()->Zoom( X_ButtonPress, Y_ButtonPress, X_Motion, Y_Motion);
1972
1973   X_ButtonPress = X_Motion;
1974   Y_ButtonPress = Y_Motion;
1975 }
1976 #endif
1977
1978 //==============================================================================
1979 //function : VT_ProcessControlButton2Motion
1980 //purpose  : Panning
1981 //==============================================================================
1982 void VT_ProcessControlButton2Motion()
1983 {
1984   Standard_Integer aDx = X_Motion - X_ButtonPress;
1985   Standard_Integer aDy = Y_Motion - Y_ButtonPress;
1986
1987   aDy = -aDy; // Xwindow Y axis is from top to Bottom
1988
1989   ViewerTest::CurrentView()->Pan (aDx, aDy);
1990
1991   X_ButtonPress = X_Motion;
1992   Y_ButtonPress = Y_Motion;
1993 }
1994
1995 //==============================================================================
1996 //function : VT_ProcessControlButton3Motion
1997 //purpose  : Rotation
1998 //==============================================================================
1999 void VT_ProcessControlButton3Motion()
2000 {
2001   if (Start_Rot)
2002   {
2003     ViewerTest::CurrentView()->Rotation (X_Motion, Y_Motion);
2004   }
2005 }
2006
2007 //==============================================================================
2008 //function : VT_ProcessMotion
2009 //purpose  :
2010 //==============================================================================
2011 void VT_ProcessMotion()
2012 {
2013   //pre-hilights detected objects at mouse position
2014
2015   Handle(ViewerTest_EventManager) EM = ViewerTest::CurrentEventManager();
2016   EM->MoveTo(X_Motion, Y_Motion);
2017 }
2018
2019
2020 void ViewerTest::GetMousePosition(Standard_Integer& Xpix,Standard_Integer& Ypix)
2021 {
2022   Xpix = X_Motion;Ypix=Y_Motion;
2023 }
2024
2025 //==============================================================================
2026 //function : ViewProject: implements VAxo, VTop, VLeft, ...
2027 //purpose  : Switches to an axonometric, top, left and other views
2028 //==============================================================================
2029
2030 static int ViewProject(Draw_Interpretor& di, const V3d_TypeOfOrientation ori)
2031 {
2032   if ( ViewerTest::CurrentView().IsNull() )
2033   {
2034     di<<"Call vinit before this command, please\n";
2035     return 1;
2036   }
2037
2038   ViewerTest::CurrentView()->SetProj(ori);
2039   return 0;
2040 }
2041
2042 //==============================================================================
2043 //function : VAxo
2044 //purpose  : Switch to an Axonometric view
2045 //Draw arg : No args
2046 //==============================================================================
2047
2048 static int VAxo(Draw_Interpretor& di, Standard_Integer , const char** )
2049 {
2050   return ViewProject(di, V3d_XposYnegZpos);
2051 }
2052
2053 //==============================================================================
2054 //function : VTop
2055 //purpose  : Switch to a Top View
2056 //Draw arg : No args
2057 //==============================================================================
2058
2059 static int VTop(Draw_Interpretor& di, Standard_Integer , const char** )
2060 {
2061   return ViewProject(di, V3d_Zpos);
2062 }
2063
2064 //==============================================================================
2065 //function : VBottom
2066 //purpose  : Switch to a Bottom View
2067 //Draw arg : No args
2068 //==============================================================================
2069
2070 static int VBottom(Draw_Interpretor& di, Standard_Integer , const char** )
2071 {
2072   return ViewProject(di, V3d_Zneg);
2073 }
2074
2075 //==============================================================================
2076 //function : VLeft
2077 //purpose  : Switch to a Left View
2078 //Draw arg : No args
2079 //==============================================================================
2080
2081 static int VLeft(Draw_Interpretor& di, Standard_Integer , const char** )
2082 {
2083   return ViewProject(di, V3d_Xneg);
2084 }
2085
2086 //==============================================================================
2087 //function : VRight
2088 //purpose  : Switch to a Right View
2089 //Draw arg : No args
2090 //==============================================================================
2091
2092 static int VRight(Draw_Interpretor& di, Standard_Integer , const char** )
2093 {
2094   return ViewProject(di, V3d_Xpos);
2095 }
2096
2097 //==============================================================================
2098 //function : VFront
2099 //purpose  : Switch to a Front View
2100 //Draw arg : No args
2101 //==============================================================================
2102
2103 static int VFront(Draw_Interpretor& di, Standard_Integer , const char** )
2104 {
2105   return ViewProject(di, V3d_Yneg);
2106 }
2107
2108 //==============================================================================
2109 //function : VBack
2110 //purpose  : Switch to a Back View
2111 //Draw arg : No args
2112 //==============================================================================
2113
2114 static int VBack(Draw_Interpretor& di, Standard_Integer , const char** )
2115 {
2116   return ViewProject(di, V3d_Ypos);
2117 }
2118
2119 //==============================================================================
2120 //function : VHelp
2121 //purpose  : Dsiplay help on viewer Keyboead and mouse commands
2122 //Draw arg : No args
2123 //==============================================================================
2124
2125 static int VHelp(Draw_Interpretor& di, Standard_Integer , const char** )
2126 {
2127
2128   di << "Q : Quit the application\n";
2129
2130   di << "=========================\n";
2131   di << "F : FitAll\n";
2132   di << "T : TopView\n";
2133   di << "B : BottomView\n";
2134   di << "R : RightView\n";
2135   di << "L : LeftView\n";
2136   di << "A : AxonometricView\n";
2137   di << "D : ResetView\n";
2138
2139   di << "=========================\n";
2140   di << "S : Shading\n";
2141   di << "W : Wireframe\n";
2142   di << "H : HidelLineRemoval\n";
2143   di << "U : Unset display mode\n";
2144   di << "Delete : Remove selection from viewer\n";
2145
2146   di << "=========================\n";
2147   di << "Selection mode \n";
2148   di << "0 : Shape\n";
2149   di << "1 : Vertex\n";
2150   di << "2 : Edge\n";
2151   di << "3 : Wire\n";
2152   di << "4 : Face\n";
2153   di << "5 : Shell\n";
2154   di << "6 : Solid\n";
2155   di << "7 : Compound\n";
2156
2157   di << "=========================\n";
2158   di << "Z : Switch Z clipping On/Off\n";
2159   di << ", : Hilight next detected\n";
2160   di << ". : Hilight previous detected\n";
2161
2162   return 0;
2163 }
2164
2165 #ifdef _WIN32
2166
2167 static Standard_Boolean Ppick = 0;
2168 static Standard_Integer Pargc = 0;
2169 static const char**           Pargv = NULL;
2170
2171
2172 static LRESULT WINAPI AdvViewerWindowProc( HWND hwnd,
2173                                           UINT Msg,
2174                                           WPARAM wParam,
2175                                           LPARAM lParam )
2176 {
2177   if (!ViewerTest_myViews.IsEmpty()) {
2178
2179     WPARAM fwKeys = wParam;
2180
2181     switch( Msg ) {
2182     case WM_CLOSE:
2183        {
2184          // Delete view from map of views
2185          ViewerTest::RemoveView(FindViewIdByWindowHandle(hwnd));
2186          return 0;
2187        }
2188        break;
2189     case WM_ACTIVATE:
2190       if(LOWORD(wParam) == WA_CLICKACTIVE || LOWORD(wParam) == WA_ACTIVE
2191         || ViewerTest::CurrentView().IsNull())
2192       {
2193         // Activate inactive window
2194         if(GetWindowHandle(VT_GetWindow()) != hwnd)
2195         {
2196           ActivateView (FindViewIdByWindowHandle(hwnd));
2197         }
2198       }
2199       break;
2200
2201     case WM_LBUTTONUP:
2202       if (IsDragged && !DragFirst)
2203       {
2204         if (!GetActiveAISManipulator().IsNull())
2205         {
2206           GetActiveAISManipulator()->StopTransform();
2207           ViewerTest::GetAISContext()->ClearSelected (Standard_True);
2208         }
2209
2210         if (ViewerTest::GetAISContext()->IsDisplayed (GetRubberBand()))
2211         {
2212           ViewerTest::GetAISContext()->Remove (GetRubberBand(), Standard_False);
2213           ViewerTest::GetAISContext()->CurrentViewer()->RedrawImmediate();
2214         }
2215
2216         VT_ProcessButton1Release ((fwKeys & MK_SHIFT) != 0);
2217       }
2218       IsDragged = Standard_False;
2219       return ViewerWindowProc( hwnd, Msg, wParam, lParam );
2220
2221     case WM_RBUTTONUP:
2222       if (IsDragged && !DragFirst)
2223       {
2224         if (!GetActiveAISManipulator().IsNull())
2225         {
2226           GetActiveAISManipulator()->StopTransform (Standard_False);
2227           ViewerTest::GetAISContext()->ClearSelected (Standard_True);
2228         }
2229         IsDragged = Standard_False;
2230       }
2231       return ViewerWindowProc (hwnd, Msg, wParam, lParam);
2232
2233     case WM_LBUTTONDOWN:
2234       if (!GetActiveAISManipulator().IsNull())
2235       {
2236         IsDragged = ( fwKeys == MK_LBUTTON );
2237       }
2238       else
2239       {
2240         IsDragged = ( fwKeys == MK_LBUTTON || fwKeys == ( MK_LBUTTON | MK_SHIFT ) );
2241       }
2242
2243       if (IsDragged)
2244       {
2245         DragFirst = Standard_True;
2246         X_ButtonPress = LOWORD(lParam);
2247         Y_ButtonPress = HIWORD(lParam);
2248       }
2249       return ViewerWindowProc( hwnd, Msg, wParam, lParam );
2250
2251     case WM_MOUSEMOVE:
2252       if (IsDragged)
2253       {
2254         X_Motion = LOWORD (lParam);
2255         Y_Motion = HIWORD (lParam);
2256         if (!GetActiveAISManipulator().IsNull())
2257         {
2258           if (DragFirst)
2259           {
2260             GetActiveAISManipulator()->StartTransform (X_ButtonPress, Y_ButtonPress, ViewerTest::CurrentView());
2261           }
2262           else
2263           {
2264             GetActiveAISManipulator()->Transform (X_Motion, Y_Motion, ViewerTest::CurrentView());
2265             ViewerTest::GetAISContext()->CurrentViewer()->Redraw();
2266           }
2267         }
2268         else
2269         {
2270           bool toRedraw = false;
2271           if (!DragFirst && ViewerTest::GetAISContext()->IsDisplayed (GetRubberBand()))
2272           {
2273             ViewerTest::GetAISContext()->Remove (GetRubberBand(), Standard_False);
2274             toRedraw = true;
2275           }
2276
2277           RECT aRect;
2278           if (GetClientRect (hwnd, &aRect))
2279           {
2280             int aHeight = aRect.bottom - aRect.top;
2281             GetRubberBand()->SetRectangle (X_ButtonPress, aHeight - Y_ButtonPress, X_Motion, aHeight - Y_Motion);
2282             ViewerTest::GetAISContext()->Display (GetRubberBand(), 0, -1, Standard_False, AIS_DS_Displayed);
2283             toRedraw = true;
2284           }
2285           if (toRedraw)
2286           {
2287             ViewerTest::GetAISContext()->CurrentViewer()->RedrawImmediate();
2288           }
2289         }
2290
2291         DragFirst = Standard_False;
2292       }
2293       else
2294         return ViewerWindowProc( hwnd, Msg, wParam, lParam );
2295       break;
2296
2297     default:
2298       return ViewerWindowProc( hwnd, Msg, wParam, lParam );
2299     }
2300     return 0;
2301   }
2302   return ViewerWindowProc( hwnd, Msg, wParam, lParam );
2303 }
2304
2305
2306 static LRESULT WINAPI ViewerWindowProc( HWND hwnd,
2307                                        UINT Msg,
2308                                        WPARAM wParam,
2309                                        LPARAM lParam )
2310 {
2311   static int Up = 1;
2312   const Handle(V3d_View)& aView = ViewerTest::CurrentView();
2313   if (aView.IsNull())
2314   {
2315     return DefWindowProcW (hwnd, Msg, wParam, lParam);
2316   }
2317
2318     PAINTSTRUCT    ps;
2319
2320     switch( Msg ) {
2321     case WM_PAINT:
2322       BeginPaint(hwnd, &ps);
2323       EndPaint(hwnd, &ps);
2324       VT_ProcessExpose();
2325       break;
2326
2327     case WM_SIZE:
2328       VT_ProcessConfigure();
2329       break;
2330     case WM_MOVE:
2331     case WM_MOVING:
2332     case WM_SIZING:
2333       switch (aView->RenderingParams().StereoMode)
2334       {
2335         case Graphic3d_StereoMode_RowInterlaced:
2336         case Graphic3d_StereoMode_ColumnInterlaced:
2337         case Graphic3d_StereoMode_ChessBoard:
2338           VT_ProcessConfigure(); // track window moves to reverse stereo pair
2339           break;
2340         default:
2341           break;
2342       }
2343       break;
2344
2345     case WM_KEYDOWN:
2346       if ((wParam != VK_SHIFT) && (wParam != VK_CONTROL))
2347       {
2348         char c[2];
2349         c[0] = (char) wParam;
2350         c[1] = '\0';
2351         if (wParam == VK_DELETE)
2352         {
2353           c[0] = THE_KEY_DELETE;
2354         }
2355         else if (wParam == VK_ESCAPE)
2356         {
2357           c[0] = THE_KEY_ESCAPE;
2358         }
2359         // comma
2360         else if (wParam == VK_OEM_COMMA)
2361         {
2362           c[0] = ',';
2363         }
2364         // dot
2365         else if (wParam == VK_OEM_PERIOD)
2366         {
2367           c[0] = '.';
2368         }
2369         else if (wParam == VK_DIVIDE)
2370         {
2371           c[0] = '/';
2372         }
2373         // dot
2374         else if (wParam == VK_MULTIPLY)
2375         {
2376           c[0] = '*';
2377         }
2378         VT_ProcessKeyPress (c);
2379       }
2380       break;
2381
2382     case WM_LBUTTONUP:
2383     case WM_MBUTTONUP:
2384     case WM_RBUTTONUP:
2385       Up = 1;
2386       VT_ProcessButton3Release();
2387       break;
2388
2389     case WM_LBUTTONDOWN:
2390     case WM_MBUTTONDOWN:
2391     case WM_RBUTTONDOWN:
2392       {
2393         WPARAM fwKeys = wParam;
2394
2395         Up = 0;
2396
2397         X_ButtonPress = LOWORD(lParam);
2398         Y_ButtonPress = HIWORD(lParam);
2399
2400         if (Msg == WM_LBUTTONDOWN)
2401         {
2402           if ((fwKeys & MK_CONTROL) != 0)
2403           {
2404             Ppick = VT_ProcessButton1Press (Pargc, Pargv, Ppick, (fwKeys & MK_SHIFT) != 0);
2405           }
2406           else
2407           {
2408             VT_ProcessButton1Press (Pargc, Pargv, Ppick, (fwKeys & MK_SHIFT) != 0);
2409           }
2410         }
2411         else if (Msg == WM_RBUTTONDOWN)
2412         {
2413           // Start rotation
2414           VT_ProcessButton3Press();
2415         }
2416       }
2417       break;
2418
2419     case WM_MOUSEWHEEL:
2420     {
2421       int aDelta = GET_WHEEL_DELTA_WPARAM (wParam);
2422       if (wParam & MK_CONTROL)
2423       {
2424         if (aView->Camera()->IsStereo())
2425         {
2426           Standard_Real aFocus = aView->Camera()->ZFocus() + (aDelta > 0 ? 0.05 : -0.05);
2427           if (aFocus > 0.2
2428            && aFocus < 2.0)
2429           {
2430             aView->Camera()->SetZFocus (aView->Camera()->ZFocusType(), aFocus);
2431             aView->Redraw();
2432           }
2433         }
2434       }
2435       else
2436       {
2437         aView->Zoom (0, 0, aDelta / 40, aDelta / 40);
2438       }
2439       break;
2440     }
2441
2442     case WM_MOUSEMOVE:
2443       {
2444         //cout << "\t WM_MOUSEMOVE" << endl;
2445         WPARAM fwKeys = wParam;
2446         X_Motion = LOWORD(lParam);
2447         Y_Motion = HIWORD(lParam);
2448
2449         if ( Up &&
2450           (fwKeys & ( MK_LBUTTON|MK_MBUTTON|MK_RBUTTON )) != 0 )
2451           {
2452             Up = 0;
2453             X_ButtonPress = LOWORD(lParam);
2454             Y_ButtonPress = HIWORD(lParam);
2455
2456             if ((fwKeys & MK_RBUTTON) != 0) {
2457               // Start rotation
2458               VT_ProcessButton3Press();
2459             }
2460           }
2461
2462           if ((fwKeys & MK_CONTROL) != 0)
2463           {
2464             if ((fwKeys & MK_LBUTTON) != 0)
2465             {
2466               ProcessControlButton1Motion();
2467             }
2468             else if ((fwKeys & MK_MBUTTON) != 0
2469                  || ((fwKeys & MK_LBUTTON) != 0
2470                   && (fwKeys & MK_RBUTTON) != 0))
2471             {
2472               VT_ProcessControlButton2Motion();
2473             }
2474             else if ((fwKeys & MK_RBUTTON) != 0)
2475             {
2476               VT_ProcessControlButton3Motion();
2477             }
2478           }
2479           else if (GetWindowHandle (VT_GetWindow()) == hwnd)
2480           {
2481             VT_ProcessMotion();
2482           }
2483       }
2484       break;
2485
2486     default:
2487       return DefWindowProcW (hwnd, Msg, wParam, lParam);
2488     }
2489     return 0L;
2490 }
2491
2492 //==============================================================================
2493 //function : ViewerMainLoop
2494 //purpose  : Get a Event on the view and dispatch it
2495 //==============================================================================
2496
2497
2498 int ViewerMainLoop(Standard_Integer argc, const char** argv)
2499 {
2500   Ppick = (argc > 0)? 1 : 0;
2501   Pargc = argc;
2502   Pargv = argv;
2503
2504   if ( Ppick ) {
2505     MSG msg;
2506     msg.wParam = 1;
2507
2508     cout << "Start picking" << endl;
2509
2510     while ( Ppick == 1 ) {
2511       // Wait for a VT_ProcessButton1Press() to toggle pick to 1 or 0
2512       if (GetMessageW (&msg, NULL, 0, 0))
2513       {
2514         TranslateMessage (&msg);
2515         DispatchMessageW (&msg);
2516       }
2517     }
2518
2519     cout << "Picking done" << endl;
2520   }
2521
2522   return Ppick;
2523 }
2524
2525 #elif !defined(__APPLE__) || defined(MACOSX_USE_GLX)
2526
2527 int min( int a, int b )
2528 {
2529   if( a<b )
2530     return a;
2531   else
2532     return b;
2533 }
2534
2535 int max( int a, int b )
2536 {
2537   if( a>b )
2538     return a;
2539   else
2540     return b;
2541 }
2542
2543 int ViewerMainLoop(Standard_Integer argc, const char** argv)
2544
2545 {
2546   static XEvent aReport;
2547   Standard_Boolean pick = argc > 0;
2548   Display *aDisplay = GetDisplayConnection()->GetDisplay();
2549   XNextEvent (aDisplay, &aReport);
2550
2551   // Handle event for the chosen display connection
2552   switch (aReport.type) {
2553       case ClientMessage:
2554         {
2555           if((Atom)aReport.xclient.data.l[0] == GetDisplayConnection()->GetAtom(Aspect_XA_DELETE_WINDOW))
2556           {
2557             // Close the window
2558             ViewerTest::RemoveView(FindViewIdByWindowHandle (aReport.xclient.window));
2559           }
2560         }
2561         return 0;
2562      case FocusIn:
2563       {
2564          // Activate inactive view
2565          Window aWindow = GetWindowHandle(VT_GetWindow());
2566          if(aWindow != aReport.xfocus.window)
2567          {
2568            ActivateView (FindViewIdByWindowHandle (aReport.xfocus.window));
2569          }
2570       }
2571       break;
2572       case Expose:
2573         {
2574           VT_ProcessExpose();
2575         }
2576         break;
2577       case ConfigureNotify:
2578         {
2579           VT_ProcessConfigure();
2580         }
2581         break;
2582       case KeyPress:
2583         {
2584
2585           KeySym ks_ret ;
2586           char buf_ret[11] ;
2587           int ret_len ;
2588           XComposeStatus status_in_out;
2589
2590           ret_len = XLookupString( ( XKeyEvent *)&aReport ,
2591             (char *) buf_ret , 10 ,
2592             &ks_ret , &status_in_out ) ;
2593
2594
2595           buf_ret[ret_len] = '\0' ;
2596
2597           if (ret_len)
2598           {
2599             VT_ProcessKeyPress (buf_ret);
2600           }
2601         }
2602         break;
2603       case ButtonPress:
2604         {
2605           X_ButtonPress = aReport.xbutton.x;
2606           Y_ButtonPress = aReport.xbutton.y;
2607
2608           if (aReport.xbutton.button == Button1)
2609           {
2610             if (aReport.xbutton.state & ControlMask)
2611             {
2612               pick = VT_ProcessButton1Press (argc, argv, pick, (aReport.xbutton.state & ShiftMask));
2613             }
2614             else
2615             {
2616               IsDragged = Standard_True;
2617               DragFirst = Standard_True;
2618             }
2619           }
2620           else if (aReport.xbutton.button == Button3)
2621           {
2622             // Start rotation
2623             VT_ProcessButton3Press();
2624           }
2625         }
2626         break;
2627       case ButtonRelease:
2628         {
2629           if( IsDragged )
2630           {
2631             if( !DragFirst )
2632             {
2633               if (ViewerTest::GetAISContext()->IsDisplayed (GetRubberBand()))
2634               {
2635                 ViewerTest::GetAISContext()->Remove (GetRubberBand(), Standard_False);
2636                 ViewerTest::GetAISContext()->CurrentViewer()->RedrawImmediate();
2637               }
2638             }
2639
2640             Handle( AIS_InteractiveContext ) aContext = ViewerTest::GetAISContext();
2641             if( aContext.IsNull() )
2642             {
2643               cout << "The context is null. Please use vinit before createmesh" << endl;
2644               return 0;
2645             }
2646
2647             Standard_Boolean ShiftPressed = ( aReport.xbutton.state & ShiftMask );
2648             if( aReport.xbutton.button==1 )
2649               if( DragFirst )
2650                 if( ShiftPressed )
2651                 {
2652                   aContext->ShiftSelect (Standard_True);
2653                 }
2654                 else
2655                 {
2656                   aContext->Select (Standard_True);
2657                 }
2658               else
2659                 if( ShiftPressed )
2660                 {
2661                   aContext->ShiftSelect(Min(X_ButtonPress, X_Motion), Min(Y_ButtonPress, Y_Motion),
2662                                         Max(X_ButtonPress, X_Motion), Max(Y_ButtonPress, Y_Motion),
2663                                         ViewerTest::CurrentView(), Standard_True);
2664                 }
2665                 else
2666                 {
2667                   aContext->Select(Min(X_ButtonPress, X_Motion), Min(Y_ButtonPress, Y_Motion),
2668                                    Max(X_ButtonPress, X_Motion), Max(Y_ButtonPress, Y_Motion),
2669                                    ViewerTest::CurrentView(), Standard_True);
2670                 }
2671             else
2672               VT_ProcessButton3Release();
2673
2674             IsDragged = Standard_False;
2675           }
2676           else
2677             VT_ProcessButton3Release();
2678         }
2679         break;
2680       case MotionNotify:
2681         {
2682           if (GetWindowHandle (VT_GetWindow()) != aReport.xmotion.window)
2683           {
2684             break;
2685           }
2686           if( IsDragged )
2687           {
2688             if( !DragFirst )
2689             {
2690               if (ViewerTest::GetAISContext()->IsDisplayed (GetRubberBand()))
2691               {
2692                 ViewerTest::GetAISContext()->Remove (GetRubberBand(), Standard_False);
2693               }
2694             }
2695
2696             X_Motion = aReport.xmotion.x;
2697             Y_Motion = aReport.xmotion.y;
2698             DragFirst = Standard_False;
2699
2700             Window aWindow = GetWindowHandle(VT_GetWindow());
2701             Window aRoot;
2702             int anX, anY;
2703             unsigned int aWidth, aHeight, aBorderWidth, aDepth;
2704             XGetGeometry (aDisplay, aWindow, &aRoot, &anX, &anY, &aWidth, &aHeight, &aBorderWidth, &aDepth);
2705             GetRubberBand()->SetRectangle (X_ButtonPress, aHeight - Y_ButtonPress, X_Motion, aHeight - Y_Motion);
2706             ViewerTest::GetAISContext()->Display (GetRubberBand(), 0, -1, Standard_False, AIS_DS_Displayed);
2707             ViewerTest::GetAISContext()->CurrentViewer()->RedrawImmediate();
2708           }
2709           else
2710           {
2711             X_Motion = aReport.xmotion.x;
2712             Y_Motion = aReport.xmotion.y;
2713
2714             // remove all the ButtonMotionMaskr
2715             while( XCheckMaskEvent( aDisplay, ButtonMotionMask, &aReport) ) ;
2716
2717             if ( aReport.xmotion.state & ControlMask ) {
2718               if ( aReport.xmotion.state & Button1Mask ) {
2719                 ProcessControlButton1Motion();
2720               }
2721               else if ( aReport.xmotion.state & Button2Mask ) {
2722                 VT_ProcessControlButton2Motion();
2723               }
2724               else if ( aReport.xmotion.state & Button3Mask ) {
2725                 VT_ProcessControlButton3Motion();
2726               }
2727             }
2728             else
2729             {
2730               VT_ProcessMotion();
2731             }
2732           }
2733         }
2734         break;
2735 }
2736 return pick;
2737 }
2738
2739 //==============================================================================
2740 //function : VProcessEvents
2741 //purpose  : call by Tk_CreateFileHandler() to be able to manage the
2742 //       event in the Viewer window
2743 //==============================================================================
2744
2745 static void VProcessEvents(ClientData,int)
2746 {
2747   NCollection_Vector<int> anEventNumbers;
2748   // Get number of messages from every display
2749   for (NCollection_DoubleMap <TCollection_AsciiString, Handle(Graphic3d_GraphicDriver)>::Iterator
2750        anIter (ViewerTest_myDrivers); anIter.More(); anIter.Next())
2751   {
2752     anEventNumbers.Append(XPending (anIter.Key2()->GetDisplayConnection()->GetDisplay()));
2753   }
2754     // Handle events for every display
2755   int anEventIter = 0;
2756   for (NCollection_DoubleMap <TCollection_AsciiString, Handle(Graphic3d_GraphicDriver)>::Iterator
2757        anIter (ViewerTest_myDrivers); anIter.More(); anIter.Next(), anEventIter++)
2758   {
2759     for (int i = 0; i < anEventNumbers.Value(anEventIter) &&
2760          XPending (anIter.Key2()->GetDisplayConnection()->GetDisplay()) > 0; ++i)
2761     {
2762       SetDisplayConnection (anIter.Key2()->GetDisplayConnection());
2763       int anEventResult = ViewerMainLoop( 0, NULL);
2764       // If window is closed or context was not found finish current event processing loop
2765       if (!anEventResult)
2766         return;
2767     }
2768   }
2769
2770   SetDisplayConnection (ViewerTest::GetAISContext()->CurrentViewer()->Driver()->GetDisplayConnection());
2771
2772 }
2773 #endif
2774
2775 //==============================================================================
2776 //function : OSWindowSetup
2777 //purpose  : Setup for the X11 window to be able to cath the event
2778 //==============================================================================
2779
2780
2781 static void OSWindowSetup()
2782 {
2783 #if !defined(_WIN32) && !defined(__WIN32__) && (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
2784   // X11
2785
2786   Window  window   = VT_GetWindow()->XWindow();
2787   SetDisplayConnection (ViewerTest::CurrentView()->Viewer()->Driver()->GetDisplayConnection());
2788   Display *aDisplay = GetDisplayConnection()->GetDisplay();
2789   XSynchronize(aDisplay, 1);
2790
2791   // X11 : For keyboard on SUN
2792   XWMHints wmhints;
2793   wmhints.flags = InputHint;
2794   wmhints.input = 1;
2795
2796   XSetWMHints( aDisplay, window, &wmhints);
2797
2798   XSelectInput( aDisplay, window,  ExposureMask | KeyPressMask |
2799     ButtonPressMask | ButtonReleaseMask |
2800     StructureNotifyMask |
2801     PointerMotionMask |
2802     Button1MotionMask | Button2MotionMask |
2803     Button3MotionMask | FocusChangeMask
2804     );
2805   Atom aDeleteWindowAtom = GetDisplayConnection()->GetAtom(Aspect_XA_DELETE_WINDOW);
2806   XSetWMProtocols(aDisplay, window, &aDeleteWindowAtom, 1);
2807
2808   XSynchronize(aDisplay, 0);
2809
2810 #else
2811   // _WIN32
2812 #endif
2813
2814 }
2815
2816 //==============================================================================
2817 //function : VFit
2818 //purpose  :
2819 //==============================================================================
2820
2821 static int VFit (Draw_Interpretor& /*theDi*/, Standard_Integer theArgNb, const char** theArgv)
2822 {
2823   const Handle(V3d_View) aView = ViewerTest::CurrentView();
2824   if (aView.IsNull())
2825   {
2826     std::cout << "Error: no active viewer!\n";
2827     return 1;
2828   }
2829
2830   Standard_Boolean toFit = Standard_True;
2831   ViewerTest_AutoUpdater anUpdateTool (Handle(AIS_InteractiveContext)(), aView);
2832   for (Standard_Integer anArgIter = 1; anArgIter < theArgNb; ++anArgIter)
2833   {
2834     TCollection_AsciiString anArg (theArgv[anArgIter]);
2835     anArg.LowerCase();
2836     if (anUpdateTool.parseRedrawMode (anArg))
2837     {
2838       continue;
2839     }
2840     else if (anArg == "-selected")
2841     {
2842       ViewerTest::GetAISContext()->FitSelected (aView, 0.01, Standard_False);
2843       toFit = Standard_False;
2844     }
2845     else
2846     {
2847       std::cout << "Syntax error at '" << anArg << "'\n";
2848     }
2849   }
2850
2851   if (toFit)
2852   {
2853     aView->FitAll (0.01, Standard_False);
2854   }
2855   return 0;
2856 }
2857
2858 //=======================================================================
2859 //function : VFitArea
2860 //purpose  : Fit view to show area located between two points
2861 //         : given in world 2D or 3D coordinates.
2862 //=======================================================================
2863 static int VFitArea (Draw_Interpretor& theDI, Standard_Integer  theArgNb, const char** theArgVec)
2864 {
2865   Handle(V3d_View) aView = ViewerTest::CurrentView();
2866   if (aView.IsNull())
2867   {
2868     std::cerr << theArgVec[0] << "Error: No active view.\n";
2869     return 1;
2870   }
2871
2872   // Parse arguments.
2873   gp_Pnt aWorldPnt1 (0.0, 0.0, 0.0);
2874   gp_Pnt aWorldPnt2 (0.0, 0.0, 0.0);
2875
2876   if (theArgNb == 5)
2877   {
2878     aWorldPnt1.SetX (Draw::Atof (theArgVec[1]));
2879     aWorldPnt1.SetY (Draw::Atof (theArgVec[2]));
2880     aWorldPnt2.SetX (Draw::Atof (theArgVec[3]));
2881     aWorldPnt2.SetY (Draw::Atof (theArgVec[4]));
2882   }
2883   else if (theArgNb == 7)
2884   {
2885     aWorldPnt1.SetX (Draw::Atof (theArgVec[1]));
2886     aWorldPnt1.SetY (Draw::Atof (theArgVec[2]));
2887     aWorldPnt1.SetZ (Draw::Atof (theArgVec[3]));
2888     aWorldPnt2.SetX (Draw::Atof (theArgVec[4]));
2889     aWorldPnt2.SetY (Draw::Atof (theArgVec[5]));
2890     aWorldPnt2.SetZ (Draw::Atof (theArgVec[6]));
2891   }
2892   else
2893   {
2894     std::cerr << theArgVec[0] << "Error: Invalid number of arguments.\n";
2895     theDI.PrintHelp(theArgVec[0]);
2896     return 1;
2897   }
2898
2899   // Convert model coordinates to view space
2900   Handle(Graphic3d_Camera) aCamera = aView->Camera();
2901   gp_Pnt aViewPnt1 = aCamera->ConvertWorld2View (aWorldPnt1);
2902   gp_Pnt aViewPnt2 = aCamera->ConvertWorld2View (aWorldPnt2);
2903
2904   // Determine fit area
2905   gp_Pnt2d aMinCorner (Min (aViewPnt1.X(), aViewPnt2.X()), Min (aViewPnt1.Y(), aViewPnt2.Y()));
2906   gp_Pnt2d aMaxCorner (Max (aViewPnt1.X(), aViewPnt2.X()), Max (aViewPnt1.Y(), aViewPnt2.Y()));
2907
2908   Standard_Real aDiagonal = aMinCorner.Distance (aMaxCorner);
2909
2910   if (aDiagonal < Precision::Confusion())
2911   {
2912     std::cerr << theArgVec[0] << "Error: view area is too small.\n";
2913     return 1;
2914   }
2915
2916   aView->FitAll (aMinCorner.X(), aMinCorner.Y(), aMaxCorner.X(), aMaxCorner.Y());
2917   return 0;
2918 }
2919
2920 //==============================================================================
2921 //function : VZFit
2922 //purpose  : ZFitall, no DRAW arguments
2923 //Draw arg : No args
2924 //==============================================================================
2925 static int VZFit (Draw_Interpretor& /*theDi*/, Standard_Integer theArgsNb, const char** theArgVec)
2926 {
2927   const Handle(V3d_View)& aCurrentView = ViewerTest::CurrentView();
2928
2929   if (aCurrentView.IsNull())
2930   {
2931     std::cout << theArgVec[0] << ": Call vinit before this command, please.\n";
2932     return 1;
2933   }
2934
2935   if (theArgsNb == 1)
2936   {
2937     aCurrentView->ZFitAll();
2938     aCurrentView->Redraw();
2939     return 0;
2940   }
2941
2942   Standard_Real aScale = 1.0;
2943
2944   if (theArgsNb >= 2)
2945   {
2946     aScale = Draw::Atoi (theArgVec[1]);
2947   }
2948
2949   aCurrentView->ZFitAll (aScale);
2950   aCurrentView->Redraw();
2951
2952   return 0;
2953 }
2954
2955 //==============================================================================
2956 //function : VRepaint
2957 //purpose  :
2958 //==============================================================================
2959 static int VRepaint (Draw_Interpretor& , Standard_Integer theArgNb, const char** theArgVec)
2960 {
2961   Handle(V3d_View) aView = ViewerTest::CurrentView();
2962   if (aView.IsNull())
2963   {
2964     std::cout << "Error: no active viewer!\n";
2965     return 1;
2966   }
2967
2968   Standard_Boolean isImmediateUpdate = Standard_False;
2969   for (Standard_Integer anArgIter = 1; anArgIter < theArgNb; ++anArgIter)
2970   {
2971     TCollection_AsciiString anArg (theArgVec[anArgIter]);
2972     anArg.LowerCase();
2973     if (anArg == "-immediate")
2974     {
2975       isImmediateUpdate = Standard_True;
2976       if (anArgIter + 1 < theArgNb
2977        && ViewerTest::ParseOnOff (theArgVec[anArgIter + 1], isImmediateUpdate))
2978       {
2979         ++anArgIter;
2980       }
2981     }
2982     else
2983     {
2984       std::cout << "Syntax error at '" << anArg << "'\n";
2985     }
2986   }
2987
2988   if (isImmediateUpdate)
2989   {
2990     aView->RedrawImmediate();
2991   }
2992   else
2993   {
2994     aView->Redraw();
2995   }
2996   return 0;
2997 }
2998
2999 //==============================================================================
3000 //function : VClear
3001 //purpose  : Remove all the object from the viewer
3002 //Draw arg : No args
3003 //==============================================================================
3004
3005 static int VClear(Draw_Interpretor& , Standard_Integer , const char** )
3006 {
3007   Handle(V3d_View) V = ViewerTest::CurrentView();
3008   if(!V.IsNull())
3009     ViewerTest::Clear();
3010   return 0;
3011 }
3012
3013 //==============================================================================
3014 //function : VPick
3015 //purpose  :
3016 //==============================================================================
3017
3018 static int VPick(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
3019 { if (ViewerTest::CurrentView().IsNull() ) return 1;
3020
3021 if ( argc < 4 ) {
3022   di << argv[0] << "Invalid number of arguments\n";
3023   return 1;
3024 }
3025
3026 while (ViewerMainLoop( argc, argv)) {
3027 }
3028
3029 return 0;
3030 }
3031
3032 //==============================================================================
3033 //function : VSetBg
3034 //purpose  : Load image as background
3035 //==============================================================================
3036
3037 static int VSetBg(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
3038 {
3039   if (argc < 2 || argc > 3)
3040   {
3041     di << "Usage : " << argv[0] << " imagefile [filltype] : Load image as background\n";
3042     di << "filltype can be one of CENTERED, TILED, STRETCH, NONE\n";
3043     return 1;
3044   }
3045
3046   Handle(AIS_InteractiveContext) AISContext = ViewerTest::GetAISContext();
3047   if(AISContext.IsNull())
3048   {
3049     di << "use 'vinit' command before " << argv[0] << "\n";
3050     return 1;
3051   }
3052
3053   Aspect_FillMethod aFillType = Aspect_FM_CENTERED;
3054   if (argc == 3)
3055   {
3056     const char* szType = argv[2];
3057     if      (strcmp(szType, "NONE"    ) == 0) aFillType = Aspect_FM_NONE;
3058     else if (strcmp(szType, "CENTERED") == 0) aFillType = Aspect_FM_CENTERED;
3059     else if (strcmp(szType, "TILED"   ) == 0) aFillType = Aspect_FM_TILED;
3060     else if (strcmp(szType, "STRETCH" ) == 0) aFillType = Aspect_FM_STRETCH;
3061     else
3062     {
3063       di << "Wrong fill type : " << szType << "\n";
3064       di << "Must be one of CENTERED, TILED, STRETCH, NONE\n";
3065       return 1;
3066     }
3067   }
3068
3069   Handle(V3d_View) V3dView = ViewerTest::CurrentView();
3070   V3dView->SetBackgroundImage(argv[1], aFillType, Standard_True);
3071
3072   return 0;
3073 }
3074
3075 //==============================================================================
3076 //function : VSetBgMode
3077 //purpose  : Change background image fill type
3078 //==============================================================================
3079
3080 static int VSetBgMode(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
3081 {
3082   if (argc != 2)
3083   {
3084     di << "Usage : " << argv[0] << " filltype : Change background image mode\n";
3085     di << "filltype must be one of CENTERED, TILED, STRETCH, NONE\n";
3086     return 1;
3087   }
3088
3089   Handle(AIS_InteractiveContext) AISContext = ViewerTest::GetAISContext();
3090   if(AISContext.IsNull())
3091   {
3092     di << "use 'vinit' command before " << argv[0] << "\n";
3093     return 1;
3094   }
3095   Aspect_FillMethod aFillType = Aspect_FM_NONE;
3096   const char* szType = argv[1];
3097   if      (strcmp(szType, "NONE"    ) == 0) aFillType = Aspect_FM_NONE;
3098   else if (strcmp(szType, "CENTERED") == 0) aFillType = Aspect_FM_CENTERED;
3099   else if (strcmp(szType, "TILED"   ) == 0) aFillType = Aspect_FM_TILED;
3100   else if (strcmp(szType, "STRETCH" ) == 0) aFillType = Aspect_FM_STRETCH;
3101   else
3102   {
3103     di << "Wrong fill type : " << szType << "\n";
3104     di << "Must be one of CENTERED, TILED, STRETCH, NONE\n";
3105     return 1;
3106   }
3107   Handle(V3d_View) V3dView = ViewerTest::CurrentView();
3108   V3dView->SetBgImageStyle(aFillType, Standard_True);
3109   return 0;
3110 }
3111
3112 //==============================================================================
3113 //function : VSetGradientBg
3114 //purpose  : Mount gradient background
3115 //==============================================================================
3116 static int VSetGradientBg(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
3117 {
3118   if (argc != 8 )
3119   {
3120     di << "Usage : " << argv[0] << " R1 G1 B1 R2 G2 B2 Type : Mount gradient background\n";
3121     di << "R1,G1,B1,R2,G2,B2 = [0..255]\n";
3122     di << "Type must be one of 0 = NONE, 1 = HOR, 2 = VER, 3 = DIAG1, 4 = DIAG2\n";
3123     di << "                    5 = CORNER1, 6 = CORNER2, 7 = CORNER3, 8 = CORNER4\n";
3124     return 1;
3125   }
3126
3127   Handle(AIS_InteractiveContext) AISContext = ViewerTest::GetAISContext();
3128   if(AISContext.IsNull())
3129   {
3130     di << "use 'vinit' command before " << argv[0] << "\n";
3131     return 1;
3132   }
3133   if (argc == 8)
3134   {
3135
3136     Standard_Real R1 = Draw::Atof(argv[1])/255.;
3137     Standard_Real G1 = Draw::Atof(argv[2])/255.;
3138     Standard_Real B1 = Draw::Atof(argv[3])/255.;
3139     Quantity_Color aColor1(R1,G1,B1,Quantity_TOC_RGB);
3140
3141     Standard_Real R2 = Draw::Atof(argv[4])/255.;
3142     Standard_Real G2 = Draw::Atof(argv[5])/255.;
3143     Standard_Real B2 = Draw::Atof(argv[6])/255.;
3144
3145     Quantity_Color aColor2(R2,G2,B2,Quantity_TOC_RGB);
3146     int aType = Draw::Atoi(argv[7]);
3147     if( aType < 0 || aType > 8 )
3148     {
3149       di << "Wrong fill type \n";
3150       di << "Must be one of 0 = NONE, 1 = HOR, 2 = VER, 3 = DIAG1, 4 = DIAG2\n";
3151       di << "               5 = CORNER1, 6 = CORNER2, 7 = CORNER3, 8 = CORNER4\n";
3152       return 1;
3153     }
3154
3155     Aspect_GradientFillMethod aMethod = Aspect_GradientFillMethod(aType);
3156
3157     Handle(V3d_View) V3dView = ViewerTest::CurrentView();
3158     V3dView->SetBgGradientColors( aColor1, aColor2, aMethod, 1);
3159   }
3160
3161   return 0;
3162 }
3163
3164 //==============================================================================
3165 //function : VSetGradientBgMode
3166 //purpose  : Change gradient background fill style
3167 //==============================================================================
3168 static int VSetGradientBgMode(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
3169 {
3170   if (argc != 2 )
3171   {
3172     di << "Usage : " << argv[0] << " Type : Change gradient background fill type\n";
3173     di << "Type must be one of 0 = NONE, 1 = HOR, 2 = VER, 3 = DIAG1, 4 = DIAG2\n";
3174     di << "                    5 = CORNER1, 6 = CORNER2, 7 = CORNER3, 8 = CORNER4\n";
3175     return 1;
3176   }
3177
3178   Handle(AIS_InteractiveContext) AISContext = ViewerTest::GetAISContext();
3179   if(AISContext.IsNull())
3180   {
3181     di << "use 'vinit' command before " << argv[0] << "\n";
3182     return 1;
3183   }
3184   if (argc == 2)
3185   {
3186     int aType = Draw::Atoi(argv[1]);
3187     if( aType < 0 || aType > 8 )
3188     {
3189       di << "Wrong fill type \n";
3190       di << "Must be one of 0 = NONE, 1 = HOR, 2 = VER, 3 = DIAG1, 4 = DIAG2\n";
3191       di << "               5 = CORNER1, 6 = CORNER2, 7 = CORNER3, 8 = CORNER4\n";
3192       return 1;
3193     }
3194
3195     Aspect_GradientFillMethod aMethod = Aspect_GradientFillMethod(aType);
3196
3197     Handle(V3d_View) V3dView = ViewerTest::CurrentView();
3198     V3dView->SetBgGradientStyle( aMethod, 1 );
3199   }
3200
3201   return 0;
3202 }
3203
3204 //==============================================================================
3205 //function : VSetColorBg
3206 //purpose  : Set color background
3207 //==============================================================================
3208 static int VSetColorBg(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
3209 {
3210   if (argc != 4 )
3211   {
3212     di << "Usage : " << argv[0] << " R G B : Set color background\n";
3213     di << "R,G,B = [0..255]\n";
3214     return 1;
3215   }
3216
3217   Handle(AIS_InteractiveContext) AISContext = ViewerTest::GetAISContext();
3218   if(AISContext.IsNull())
3219   {
3220     di << "use 'vinit' command before " << argv[0] << "\n";
3221     return 1;
3222   }
3223   if (argc == 4)
3224   {
3225
3226     Standard_Real R = Draw::Atof(argv[1])/255.;
3227     Standard_Real G = Draw::Atof(argv[2])/255.;
3228     Standard_Real B = Draw::Atof(argv[3])/255.;
3229     Quantity_Color aColor(R,G,B,Quantity_TOC_RGB);
3230
3231     Handle(V3d_View) V3dView = ViewerTest::CurrentView();
3232     V3dView->SetBackgroundColor( aColor );
3233     V3dView->Update();
3234   }
3235
3236   return 0;
3237 }
3238
3239 //==============================================================================
3240 //function : VSetDefaultBg
3241 //purpose  : Set default viewer background fill color
3242 //==============================================================================
3243 static int VSetDefaultBg (Draw_Interpretor& theDI, Standard_Integer theArgNb, const char** theArgVec)
3244 {
3245   if (theArgNb != 4
3246    && theArgNb != 8)
3247   {
3248     std::cout << "Error: wrong syntax! See usage:\n";
3249     theDI.PrintHelp (theArgVec[0]);
3250     return 1;
3251   }
3252
3253   ViewerTest_DefaultBackground.FillMethod =
3254     theArgNb == 4 ? Aspect_GFM_NONE
3255                   : (Aspect_GradientFillMethod) Draw::Atoi (theArgVec[7]);
3256
3257   if (theArgNb == 4)
3258   {
3259     Standard_Real R = Draw::Atof (theArgVec[1]) / 255.;
3260     Standard_Real G = Draw::Atof (theArgVec[2]) / 255.;
3261     Standard_Real B = Draw::Atof (theArgVec[3]) / 255.;
3262     ViewerTest_DefaultBackground.FlatColor.SetValues (R, G, B, Quantity_TOC_RGB);
3263   }
3264   else
3265   {
3266     Standard_Real R1 = Draw::Atof (theArgVec[1]) / 255.;
3267     Standard_Real G1 = Draw::Atof (theArgVec[2]) / 255.;
3268     Standard_Real B1 = Draw::Atof (theArgVec[3]) / 255.;
3269     ViewerTest_DefaultBackground.GradientColor1.SetValues (R1, G1, B1, Quantity_TOC_RGB);
3270
3271     Standard_Real R2 = Draw::Atof (theArgVec[4]) / 255.;
3272     Standard_Real G2 = Draw::Atof (theArgVec[5]) / 255.;
3273     Standard_Real B2 = Draw::Atof (theArgVec[6]) / 255.;
3274     ViewerTest_DefaultBackground.GradientColor2.SetValues (R2, G2, B2, Quantity_TOC_RGB);
3275   }
3276
3277   for (NCollection_DoubleMap<TCollection_AsciiString, Handle(AIS_InteractiveContext)>::Iterator
3278        anIter (ViewerTest_myContexts); anIter.More(); anIter.Next())
3279   {
3280     const Handle(V3d_Viewer)& aViewer = anIter.Value()->CurrentViewer();
3281     aViewer->SetDefaultBackgroundColor (ViewerTest_DefaultBackground.FlatColor);
3282     aViewer->SetDefaultBgGradientColors (ViewerTest_DefaultBackground.GradientColor1,
3283                                          ViewerTest_DefaultBackground.GradientColor2,
3284                                          ViewerTest_DefaultBackground.FillMethod);
3285   }
3286
3287   return 0;
3288 }
3289
3290 //==============================================================================
3291 //function : VScale
3292 //purpose  : View Scaling
3293 //==============================================================================
3294
3295 static int VScale(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
3296 {
3297   Handle(V3d_View) V3dView = ViewerTest::CurrentView();
3298   if ( V3dView.IsNull() ) return 1;
3299
3300   if ( argc != 4 ) {
3301     di << argv[0] << "Invalid number of arguments\n";
3302     return 1;
3303   }
3304   V3dView->SetAxialScale( Draw::Atof(argv[1]),  Draw::Atof(argv[2]),  Draw::Atof(argv[3]) );
3305   return 0;
3306 }
3307 //==============================================================================
3308 //function : VZBuffTrihedron
3309 //purpose  :
3310 //==============================================================================
3311
3312 static int VZBuffTrihedron (Draw_Interpretor& /*theDI*/,
3313                             Standard_Integer  theArgNb,
3314                             const char**      theArgVec)
3315 {
3316   Handle(V3d_View) aView = ViewerTest::CurrentView();
3317   if (aView.IsNull())
3318   {
3319     std::cout << "Error: no active viewer!\n";
3320     return 1;
3321   }
3322
3323   ViewerTest_AutoUpdater anUpdateTool (ViewerTest::GetAISContext(), aView);
3324
3325   Aspect_TypeOfTriedronPosition aPosition     = Aspect_TOTP_LEFT_LOWER;
3326   V3d_TypeOfVisualization       aVisType      = V3d_ZBUFFER;
3327   Quantity_Color                aLabelsColor  = Quantity_NOC_WHITE;
3328   Quantity_Color                anArrowColorX = Quantity_NOC_RED;
3329   Quantity_Color                anArrowColorY = Quantity_NOC_GREEN;
3330   Quantity_Color                anArrowColorZ = Quantity_NOC_BLUE1;
3331   Standard_Real                 aScale        = 0.1;
3332   Standard_Real                 aSizeRatio    = 0.8;
3333   Standard_Real                 anArrowDiam   = 0.05;
3334   Standard_Integer              aNbFacets     = 12;
3335   for (Standard_Integer anArgIter = 1; anArgIter < theArgNb; ++anArgIter)
3336   {
3337     Standard_CString        anArg = theArgVec[anArgIter];
3338     TCollection_AsciiString aFlag (anArg);
3339     aFlag.LowerCase();
3340     if (anUpdateTool.parseRedrawMode (aFlag))
3341     {
3342       continue;
3343     }
3344     else if (aFlag == "-on")
3345     {
3346       continue;
3347     }
3348     else if (aFlag == "-off")
3349     {
3350       aView->TriedronErase();
3351       return 0;
3352     }
3353     else if (aFlag == "-pos"
3354           || aFlag == "-position"
3355           || aFlag == "-corner")
3356     {
3357       if (++anArgIter >= theArgNb)
3358       {
3359         std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
3360         return 1;
3361       }
3362
3363       TCollection_AsciiString aPosName (theArgVec[anArgIter]);
3364       aPosName.LowerCase();
3365       if (aPosName == "center")
3366       {
3367         aPosition = Aspect_TOTP_CENTER;
3368       }
3369       else if (aPosName == "left_lower"
3370             || aPosName == "lower_left"
3371             || aPosName == "leftlower"
3372             || aPosName == "lowerleft")
3373       {
3374         aPosition = Aspect_TOTP_LEFT_LOWER;
3375       }
3376       else if (aPosName == "left_upper"
3377             || aPosName == "upper_left"
3378             || aPosName == "leftupper"
3379             || aPosName == "upperleft")
3380       {
3381         aPosition = Aspect_TOTP_LEFT_UPPER;
3382       }
3383       else if (aPosName == "right_lower"
3384             || aPosName == "lower_right"
3385             || aPosName == "rightlower"
3386             || aPosName == "lowerright")
3387       {
3388         aPosition = Aspect_TOTP_RIGHT_LOWER;
3389       }
3390       else if (aPosName == "right_upper"
3391             || aPosName == "upper_right"
3392             || aPosName == "rightupper"
3393             || aPosName == "upperright")
3394       {
3395         aPosition = Aspect_TOTP_RIGHT_UPPER;
3396       }
3397       else
3398       {
3399         std::cerr << "Error: wrong syntax at '" << anArg << "' - unknown position '" << aPosName << "'\n";
3400         return 1;
3401       }
3402     }
3403     else if (aFlag == "-type")
3404     {
3405       if (++anArgIter >= theArgNb)
3406       {
3407         std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
3408         return 1;
3409       }
3410
3411       TCollection_AsciiString aTypeName (theArgVec[anArgIter]);
3412       aTypeName.LowerCase();
3413       if (aTypeName == "wireframe"
3414        || aTypeName == "wire")
3415       {
3416         aVisType = V3d_WIREFRAME;
3417       }
3418       else if (aTypeName == "zbuffer"
3419             || aTypeName == "shaded")
3420       {
3421         aVisType = V3d_ZBUFFER;
3422       }
3423       else
3424       {
3425         std::cerr << "Error: wrong syntax at '" << anArg << "' - unknown type '" << aTypeName << "'\n";
3426       }
3427     }
3428     else if (aFlag == "-scale")
3429     {
3430       if (++anArgIter >= theArgNb)
3431       {
3432         std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
3433         return 1;
3434       }
3435
3436       aScale = Draw::Atof (theArgVec[anArgIter]);
3437     }
3438     else if (aFlag == "-size"
3439           || aFlag == "-sizeratio")
3440     {
3441       if (++anArgIter >= theArgNb)
3442       {
3443         std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
3444         return 1;
3445       }
3446
3447       aSizeRatio = Draw::Atof (theArgVec[anArgIter]);
3448     }
3449     else if (aFlag == "-arrowdiam"
3450           || aFlag == "-arrowdiameter")
3451     {
3452       if (++anArgIter >= theArgNb)
3453       {
3454         std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
3455         return 1;
3456       }
3457
3458       anArrowDiam = Draw::Atof (theArgVec[anArgIter]);
3459     }
3460     else if (aFlag == "-nbfacets")
3461     {
3462       if (++anArgIter >= theArgNb)
3463       {
3464         std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
3465         return 1;
3466       }
3467
3468       aNbFacets = Draw::Atoi (theArgVec[anArgIter]);
3469     }
3470     else if (aFlag == "-colorlabel"
3471           || aFlag == "-colorlabels")
3472     {
3473       Standard_Integer aNbParsed = ViewerTest::ParseColor (theArgNb  - anArgIter - 1,
3474                                                            theArgVec + anArgIter + 1,
3475                                                            aLabelsColor);
3476       if (aNbParsed == 0)
3477       {
3478         std::cerr << "Error: wrong syntax at '" << anArg << "'\n";
3479         return 1;
3480       }
3481       anArgIter += aNbParsed;
3482     }
3483     else if (aFlag == "-colorarrowx")
3484     {
3485       Standard_Integer aNbParsed = ViewerTest::ParseColor (theArgNb  - anArgIter - 1,
3486                                                            theArgVec + anArgIter + 1,
3487                                                            anArrowColorX);
3488       if (aNbParsed == 0)
3489       {
3490         std::cerr << "Error: wrong syntax at '" << anArg << "'\n&q