9e3d762a017822053c03fe7b3773ff9ba0d77777
[occt.git] / 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 #ifdef HAVE_CONFIG_H
18   #include <config.h>
19 #endif
20
21 #include <OpenGl_GlCore20.hxx>
22 #include <AIS_Shape.hxx>
23 #include <AIS_Drawer.hxx>
24 #include <AIS_InteractiveObject.hxx>
25 #include <AIS_ListOfInteractive.hxx>
26 #include <AIS_ListIteratorOfListOfInteractive.hxx>
27 #include <DBRep.hxx>
28 #include <Graphic3d_AspectMarker3d.hxx>
29 #include <Graphic3d_ExportFormat.hxx>
30 #include <Graphic3d_NameOfTextureEnv.hxx>
31 #include <Graphic3d_TextureEnv.hxx>
32 #include <Graphic3d_TextureParams.hxx>
33 #include <Graphic3d_TypeOfTextureFilter.hxx>
34 #include <Graphic3d_AspectFillArea3d.hxx>
35 #include <ViewerTest.hxx>
36 #include <ViewerTest_EventManager.hxx>
37 #include <ViewerTest_DoubleMapOfInteractiveAndName.hxx>
38 #include <ViewerTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName.hxx>
39 #include <Visual3d_View.hxx>
40 #include <Visual3d_ViewManager.hxx>
41 #include <V3d_AmbientLight.hxx>
42 #include <V3d_DirectionalLight.hxx>
43 #include <V3d_LayerMgr.hxx>
44 #include <V3d_LayerMgrPointer.hxx>
45 #include <V3d_PositionalLight.hxx>
46 #include <V3d_SpotLight.hxx>
47 #include <NCollection_DoubleMap.hxx>
48 #include <NCollection_List.hxx>
49 #include <NCollection_Vector.hxx>
50 #include <NIS_View.hxx>
51 #include <NIS_Triangulated.hxx>
52 #include <NIS_InteractiveContext.hxx>
53 #include <AIS_InteractiveContext.hxx>
54 #include <Draw_Interpretor.hxx>
55 #include <Draw.hxx>
56 #include <Draw_Appli.hxx>
57 #include <Aspect_PrintAlgo.hxx>
58 #include <Image_AlienPixMap.hxx>
59 #include <OpenGl_GraphicDriver.hxx>
60 #include <OSD_Timer.hxx>
61 #include <TColStd_HSequenceOfAsciiString.hxx>
62 #include <TColStd_SequenceOfInteger.hxx>
63 #include <TColStd_HSequenceOfReal.hxx>
64 #include <TColgp_Array1OfPnt2d.hxx>
65 #include <TColStd_MapOfAsciiString.hxx>
66 #include <Visual3d_LayerItem.hxx>
67 #include <Aspect_TypeOfLine.hxx>
68 #include <Image_Diff.hxx>
69 #include <Aspect_DisplayConnection.hxx>
70 #include <Graphic3d.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
80 #ifdef WNT
81 #undef DrawText
82 #endif
83
84 #include <Visual3d_Layer.hxx>
85 #include <cstdlib>
86
87 #if defined(_WIN32)
88   #include <WNT_WClass.hxx>
89   #include <WNT_Window.hxx>
90
91   #if defined(_MSC_VER)
92     #define _CRT_SECURE_NO_DEPRECATE
93     #pragma warning (disable:4996)
94   #endif
95 #elif defined(__APPLE__) && !defined(MACOSX_USE_GLX)
96   #include <Cocoa_Window.hxx>
97 #else
98   #include <Xw_Window.hxx>
99   #include <X11/Xlib.h> /* contains some dangerous #defines such as Status, True etc. */
100   #include <X11/Xutil.h>
101   #include <tk.h>
102 #endif
103
104 // Auxiliary definitions
105 static const char THE_KEY_DELETE = 127;
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 const Handle(NIS_InteractiveContext)& TheNISContext();
116 extern ViewerTest_DoubleMapOfInteractiveAndName& GetMapOfAIS();
117
118 extern int VErase (Draw_Interpretor& theDI,
119                    Standard_Integer  theArgNb,
120                    const char**      theArgVec);
121
122 #if defined(_WIN32)
123 static Handle(WNT_Window)& VT_GetWindow() {
124   static Handle(WNT_Window) WNTWin;
125   return WNTWin;
126 }
127 #elif defined(__APPLE__) && !defined(MACOSX_USE_GLX)
128 static Handle(Cocoa_Window)& VT_GetWindow()
129 {
130   static Handle(Cocoa_Window) aWindow;
131   return aWindow;
132 }
133 extern void ViewerTest_SetCocoaEventManagerView (const Handle(Cocoa_Window)& theWindow);
134 extern void SetCocoaWindowTitle (const Handle(Cocoa_Window)& theWindow, Standard_CString theTitle);
135 extern void GetCocoaScreenResolution (Standard_Integer& theWidth, Standard_Integer& theHeight);
136
137 #else
138 static Handle(Xw_Window)& VT_GetWindow(){
139   static Handle(Xw_Window) XWWin;
140   return XWWin;
141 }
142
143 static void VProcessEvents(ClientData,int);
144 #endif
145
146 static Handle(Aspect_DisplayConnection)& GetDisplayConnection()
147 {
148   static Handle(Aspect_DisplayConnection) aDisplayConnection;
149   return aDisplayConnection;
150 }
151
152 static void SetDisplayConnection (const Handle(Aspect_DisplayConnection)& theDisplayConnection)
153 {
154   GetDisplayConnection() = theDisplayConnection;
155 }
156
157 #if defined(_WIN32) || (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
158 Aspect_Handle GetWindowHandle(const Handle(Aspect_Window)& theWindow)
159 {
160   Aspect_Handle aWindowHandle = (Aspect_Handle)NULL;
161 #if defined(_WIN32)
162   const Handle (WNT_Window) aWindow = Handle(WNT_Window)::DownCast (theWindow);
163   if (!aWindow.IsNull())
164     return aWindow->HWindow();
165 #elif (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
166   const Handle (Xw_Window) aWindow = Handle(Xw_Window)::DownCast (theWindow);
167   if (!aWindow.IsNull())
168   return aWindow->XWindow();
169 #endif
170   return aWindowHandle;
171 }
172 #endif
173
174 static Standard_Boolean MyHLRIsOn = Standard_False;
175
176 NCollection_DoubleMap <TCollection_AsciiString, Handle(V3d_View)> ViewerTest_myViews;
177 static NCollection_DoubleMap <TCollection_AsciiString, Handle(AIS_InteractiveContext)>  ViewerTest_myContexts;
178 static NCollection_DoubleMap <TCollection_AsciiString, Handle(Graphic3d_GraphicDriver)> ViewerTest_myDrivers;
179 static OpenGl_Caps ViewerTest_myDefaultCaps;
180
181 #define ZCLIPWIDTH 1.
182
183 static void OSWindowSetup();
184
185 //==============================================================================
186 //  EVENT GLOBAL VARIABLES
187 //==============================================================================
188
189 static int Start_Rot = 0;
190 static int ZClipIsOn = 0;
191 int X_Motion = 0; // Current cursor position
192 int Y_Motion = 0;
193 int X_ButtonPress = 0; // Last ButtonPress position
194 int Y_ButtonPress = 0;
195 Standard_Boolean IsDragged = Standard_False;
196 Standard_Boolean DragFirst;
197
198 //==============================================================================
199
200 #ifdef WNT
201 static LRESULT WINAPI ViewerWindowProc(
202                                        HWND hwnd,
203                                        UINT uMsg,
204                                        WPARAM wParam,
205                                        LPARAM lParam );
206 static LRESULT WINAPI AdvViewerWindowProc(
207   HWND hwnd,
208   UINT uMsg,
209   WPARAM wParam,
210   LPARAM lParam );
211 #endif
212
213
214 //==============================================================================
215 //function : WClass
216 //purpose  :
217 //==============================================================================
218
219 const Handle(MMgt_TShared)& ViewerTest::WClass()
220 {
221   static Handle(MMgt_TShared) theWClass;
222 #if defined(_WIN32)
223   if (theWClass.IsNull())
224   {
225     theWClass = new WNT_WClass ("GW3D_Class", AdvViewerWindowProc,
226       CS_VREDRAW | CS_HREDRAW, 0, 0,
227       ::LoadCursor (NULL, IDC_ARROW));
228   }
229 #endif
230   return theWClass;
231 }
232
233 //==============================================================================
234 //function : CreateName
235 //purpose  : Create numerical name for new object in theMap
236 //==============================================================================
237 template <typename ObjectType>
238 TCollection_AsciiString CreateName (const NCollection_DoubleMap <TCollection_AsciiString, ObjectType>& theObjectMap,
239                                     const TCollection_AsciiString& theDefaultString)
240 {
241   if (theObjectMap.IsEmpty())
242     return theDefaultString + TCollection_AsciiString(1);
243
244   Standard_Integer aNextKey = 1;
245   Standard_Boolean isFound = Standard_False;
246   while (!isFound)
247   {
248     TCollection_AsciiString aStringKey = theDefaultString + TCollection_AsciiString(aNextKey);
249     // Look for objects with default names
250     if (theObjectMap.IsBound1(aStringKey))
251     {
252       aNextKey++;
253     }
254     else
255       isFound = Standard_True;
256   }
257
258   return theDefaultString + TCollection_AsciiString(aNextKey);
259 }
260
261 //==============================================================================
262 //structure : ViewerTest_Names
263 //purpose   : Allow to operate with full view name: driverName/viewerName/viewName
264 //==============================================================================
265 struct ViewerTest_Names
266 {
267 private:
268   TCollection_AsciiString myDriverName;
269   TCollection_AsciiString myViewerName;
270   TCollection_AsciiString myViewName;
271
272 public:
273
274   const TCollection_AsciiString& GetDriverName () const
275   {
276     return myDriverName;
277   }
278   void SetDriverName (const TCollection_AsciiString& theDriverName)
279   {
280     myDriverName = theDriverName;
281   }
282   const TCollection_AsciiString& GetViewerName () const
283   {
284     return myViewerName;
285   }
286   void SetViewerName (const TCollection_AsciiString& theViewerName)
287   {
288     myViewerName = theViewerName;
289   }
290   const TCollection_AsciiString& GetViewName () const
291   {
292     return myViewName;
293   }
294   void SetViewName (const TCollection_AsciiString& theViewName)
295   {
296     myViewName = theViewName;
297   }
298
299   //===========================================================================
300   //function : Constructor for ViewerTest_Names
301   //purpose  : Get view, viewer, driver names from custom string
302   //===========================================================================
303
304   ViewerTest_Names (const TCollection_AsciiString& theInputString)
305   {
306     TCollection_AsciiString aName(theInputString);
307     if (theInputString.IsEmpty())
308     {
309       // Get current configuration
310       if (ViewerTest_myDrivers.IsEmpty())
311         myDriverName = CreateName<Handle(Graphic3d_GraphicDriver)>
312           (ViewerTest_myDrivers, TCollection_AsciiString("Driver"));
313       else
314         myDriverName = ViewerTest_myDrivers.Find2
315         (ViewerTest::GetAISContext()->CurrentViewer()->Driver());
316
317       if(ViewerTest_myContexts.IsEmpty())
318       {
319         myViewerName = CreateName <Handle(AIS_InteractiveContext)>
320           (ViewerTest_myContexts, TCollection_AsciiString (myDriverName + "/Viewer"));
321       }
322       else
323         myViewerName = ViewerTest_myContexts.Find2 (ViewerTest::GetAISContext());
324
325         myViewName = CreateName <Handle(V3d_View)>
326           (ViewerTest_myViews, TCollection_AsciiString(myViewerName + "/View"));
327     }
328     else
329     {
330       // There is at least view name
331       Standard_Integer aParserNumber = 0;
332       for (Standard_Integer i = 0; i < 3; ++i)
333       {
334         Standard_Integer aParserPos = aName.SearchFromEnd("/");
335         if(aParserPos != -1)
336         {
337           aParserNumber++;
338           aName.Split(aParserPos-1);
339         }
340         else
341           break;
342       }
343       if (aParserNumber == 0)
344       {
345         // Only view name
346         if (!ViewerTest::GetAISContext().IsNull())
347         {
348           myDriverName = ViewerTest_myDrivers.Find2
349           (ViewerTest::GetAISContext()->CurrentViewer()->Driver());
350           myViewerName = ViewerTest_myContexts.Find2
351           (ViewerTest::GetAISContext());
352         }
353         else
354         {
355           // There is no opened contexts here, need to create names for viewer and driver
356           myDriverName = CreateName<Handle(Graphic3d_GraphicDriver)>
357             (ViewerTest_myDrivers, TCollection_AsciiString("Driver"));
358
359           myViewerName = CreateName <Handle(AIS_InteractiveContext)>
360             (ViewerTest_myContexts, TCollection_AsciiString (myDriverName + "/Viewer"));
361         }
362         myViewName = TCollection_AsciiString(myViewerName + "/" + theInputString);
363       }
364       else if (aParserNumber == 1)
365       {
366         // Here is viewerName/viewName
367         if (!ViewerTest::GetAISContext().IsNull())
368           myDriverName = ViewerTest_myDrivers.Find2
369           (ViewerTest::GetAISContext()->CurrentViewer()->Driver());
370         else
371         {
372           // There is no opened contexts here, need to create name for driver
373           myDriverName = CreateName<Handle(Graphic3d_GraphicDriver)>
374             (ViewerTest_myDrivers, TCollection_AsciiString("Driver"));
375         }
376         myViewerName = TCollection_AsciiString(myDriverName + "/" + aName);
377
378         myViewName = TCollection_AsciiString(myDriverName + "/" + theInputString);
379       }
380       else
381       {
382         //Here is driverName/viewerName/viewName
383         myDriverName = TCollection_AsciiString(aName);
384
385         TCollection_AsciiString aViewerName(theInputString);
386         aViewerName.Split(aViewerName.SearchFromEnd("/") - 1);
387         myViewerName = TCollection_AsciiString(aViewerName);
388
389         myViewName = TCollection_AsciiString(theInputString);
390       }
391     }
392   }
393 };
394
395 //==============================================================================
396 //function : FindContextByView
397 //purpose  : Find AIS_InteractiveContext by View
398 //==============================================================================
399
400 Handle(AIS_InteractiveContext) FindContextByView (const Handle(V3d_View)& theView)
401 {
402   Handle(AIS_InteractiveContext) anAISContext;
403
404   for (NCollection_DoubleMap<TCollection_AsciiString, Handle(AIS_InteractiveContext)>::Iterator
405        anIter (ViewerTest_myContexts); anIter.More(); anIter.Next())
406   {
407     if (anIter.Value()->CurrentViewer() == theView->Viewer())
408        return anIter.Key2();
409   }
410   return anAISContext;
411 }
412
413
414 //==============================================================================
415 //function : SetWindowTitle
416 //purpose  : Set window title
417 //==============================================================================
418
419 void SetWindowTitle (const Handle(Aspect_Window)& theWindow,
420                      Standard_CString theTitle)
421 {
422 #if defined(_WIN32)
423   SetWindowText ((HWND)Handle(WNT_Window)::DownCast(theWindow)->HWindow(),
424     theTitle);
425 #elif defined(__APPLE__) && !defined(MACOSX_USE_GLX)
426   SetCocoaWindowTitle (Handle(Cocoa_Window)::DownCast(theWindow), theTitle);
427 #else
428   if(GetDisplayConnection()->GetDisplay())
429   {
430     Window aWindow =
431       Handle(Xw_Window)::DownCast(theWindow)->XWindow();
432     XStoreName (GetDisplayConnection()->GetDisplay(), aWindow , theTitle);
433   }
434 #endif
435 }
436
437 //==============================================================================
438 //function : IsWindowOverlapped
439 //purpose  : Check if theWindow overlapp another view
440 //==============================================================================
441
442 Standard_Boolean IsWindowOverlapped (const Standard_Integer thePxLeft,
443                                      const Standard_Integer thePxTop,
444                                      const Standard_Integer thePxRight,
445                                      const Standard_Integer thePxBottom,
446                                      TCollection_AsciiString& theViewId)
447 {
448   for(NCollection_DoubleMap <TCollection_AsciiString, Handle(V3d_View)>::Iterator
449       anIter(ViewerTest_myViews); anIter.More(); anIter.Next())
450   {
451     Standard_Integer aTop = 0,
452       aLeft = 0,
453       aRight = 0,
454       aBottom = 0;
455     anIter.Value()->Window()->Position(aLeft, aTop, aRight, aBottom);
456     if ((thePxLeft >= aLeft && thePxLeft <= aRight && thePxTop >= aTop && thePxTop <= aBottom) ||
457         (thePxLeft >= aLeft && thePxLeft <= aRight && thePxBottom >= aTop && thePxBottom <= aBottom) ||
458         (thePxRight >= aLeft && thePxRight <= aRight && thePxTop >= aTop && thePxTop <= aBottom) ||
459         (thePxRight >= aLeft && thePxRight <= aRight && thePxBottom >= aTop && thePxBottom <= aBottom))
460     {
461       theViewId = anIter.Key1();
462       return Standard_True;
463     }
464   }
465   return Standard_False;
466 }
467
468 // Workaround: to create and delete non-orthographic views outside ViewerTest
469 void ViewerTest::RemoveViewName (const TCollection_AsciiString& theName)
470 {
471   ViewerTest_myViews.UnBind1 (theName);
472 }
473
474 void ViewerTest::InitViewName (const TCollection_AsciiString& theName,
475                                const Handle(V3d_View)& theView)
476 {
477   ViewerTest_myViews.Bind (theName, theView);
478 }
479
480 TCollection_AsciiString ViewerTest::GetCurrentViewName ()
481 {
482   return ViewerTest_myViews.Find2( ViewerTest::CurrentView());
483 }
484 //==============================================================================
485 //function : ViewerInit
486 //purpose  : Create the window viewer and initialize all the global variable
487 //==============================================================================
488
489 TCollection_AsciiString ViewerTest::ViewerInit (const Standard_Integer thePxLeft,
490                                                 const Standard_Integer thePxTop,
491                                                 const Standard_Integer thePxWidth,
492                                                 const Standard_Integer thePxHeight,
493                                                 Standard_CString theViewName,
494                                                 Standard_CString theDisplayName)
495 {
496   // Default position and dimension of the viewer window.
497   // Note that left top corner is set to be sufficiently small to have
498   // window fit in the small screens (actual for remote desktops, see #23003).
499   // The position corresponds to the window's client area, thus some
500   // gap is added for window frame to be visible.
501   Standard_Integer aPxLeft   = 20;
502   Standard_Integer aPxTop    = 40;
503   Standard_Integer aPxWidth  = 409;
504   Standard_Integer aPxHeight = 409;
505   Standard_Boolean toCreateViewer = Standard_False;
506
507   Handle(OpenGl_GraphicDriver) aGraphicDriver;
508   ViewerTest_Names aViewNames(theViewName);
509   if (ViewerTest_myViews.IsBound1 (aViewNames.GetViewName ()))
510     aViewNames.SetViewName (aViewNames.GetViewerName() + "/" + CreateName<Handle(V3d_View)>(ViewerTest_myViews, "View"));
511
512   if (thePxLeft != 0)
513     aPxLeft = thePxLeft;
514   if (thePxTop != 0)
515     aPxTop = thePxTop;
516   if (thePxWidth != 0)
517     aPxWidth = thePxWidth;
518   if (thePxHeight != 0)
519     aPxHeight = thePxHeight;
520
521   // Get graphic driver (create it or get from another view)
522   if (!ViewerTest_myDrivers.IsBound1 (aViewNames.GetDriverName()))
523   {
524     // Get connection string
525   #if !defined(_WIN32) && (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
526     TCollection_AsciiString aDisplayName(theDisplayName);
527     if (!aDisplayName.IsEmpty())
528       SetDisplayConnection (new Aspect_DisplayConnection ());
529     else
530       SetDisplayConnection (new Aspect_DisplayConnection (aDisplayName));
531   #else
532     (void)theDisplayName; // avoid warning on unused argument
533     SetDisplayConnection (new Aspect_DisplayConnection ());
534   #endif
535     aGraphicDriver = new OpenGl_GraphicDriver (GetDisplayConnection());
536     aGraphicDriver->ChangeOptions() = ViewerTest_myDefaultCaps;
537     ViewerTest_myDrivers.Bind (aViewNames.GetDriverName(), aGraphicDriver);
538     toCreateViewer = Standard_True;
539   }
540   else
541   {
542     aGraphicDriver = Handle(OpenGl_GraphicDriver)::DownCast (ViewerTest_myDrivers.Find1 (aViewNames.GetDriverName()));
543   }
544
545   //Dispose the window if input parameters are default
546   if (!ViewerTest_myViews.IsEmpty() && thePxLeft == 0 && thePxTop == 0)
547   {
548     Standard_Integer aTop = 0,
549                      aLeft = 0,
550                      aRight = 0,
551                      aBottom = 0,
552                      aScreenWidth = 0,
553                      aScreenHeight = 0;
554
555     // Get screen resolution
556 #if defined(_WIN32) || defined(__WIN32__)
557     RECT aWindowSize;
558     GetClientRect(GetDesktopWindow(), &aWindowSize);
559     aScreenHeight = aWindowSize.bottom;
560     aScreenWidth = aWindowSize.right;
561 #elif defined(__APPLE__) && !defined(MACOSX_USE_GLX)
562     GetCocoaScreenResolution (aScreenWidth, aScreenHeight);
563 #else
564     Screen *aScreen = DefaultScreenOfDisplay(GetDisplayConnection()->GetDisplay());
565     aScreenWidth = WidthOfScreen(aScreen);
566     aScreenHeight = HeightOfScreen(aScreen);
567 #endif
568
569     TCollection_AsciiString anOverlappedViewId("");
570
571     while (IsWindowOverlapped (aPxLeft, aPxTop, aPxLeft + aPxWidth, aPxTop + aPxHeight, anOverlappedViewId))
572     {
573       ViewerTest_myViews.Find1(anOverlappedViewId)->Window()->Position (aLeft, aTop, aRight, aBottom);
574
575       if (IsWindowOverlapped (aRight + 20, aPxTop, aRight + 20 + aPxWidth, aPxTop + aPxHeight, anOverlappedViewId)
576         && aRight + 2*aPxWidth + 40 > aScreenWidth)
577       {
578         if (aBottom + aPxHeight + 40 > aScreenHeight)
579         {
580           aPxLeft = 20;
581           aPxTop = 40;
582           break;
583         }
584         aPxLeft = 20;
585         aPxTop = aBottom + 40;
586       }
587       else
588         aPxLeft = aRight + 20;
589     }
590   }
591
592   // Get viewer name
593   TCollection_AsciiString aTitle("3D View - ");
594   aTitle = aTitle + aViewNames.GetViewName() + "(*)";
595
596   // Change name of current active window
597   if (!ViewerTest::CurrentView().IsNull())
598   {
599     TCollection_AsciiString aTitle("3D View - ");
600     aTitle = aTitle
601       + ViewerTest_myViews.Find2 (ViewerTest::CurrentView());
602     SetWindowTitle (ViewerTest::CurrentView()->Window(), aTitle.ToCString());
603   }
604
605   // Create viewer
606   Handle(V3d_Viewer) a3DViewer;
607   // If it's the single view, we first look for empty context
608   if (ViewerTest_myViews.IsEmpty() && !ViewerTest_myContexts.IsEmpty())
609   {
610     NCollection_DoubleMap <TCollection_AsciiString, Handle(AIS_InteractiveContext)>::Iterator
611       anIter(ViewerTest_myContexts);
612     if (anIter.More())
613       ViewerTest::SetAISContext (anIter.Value());
614     a3DViewer = ViewerTest::GetAISContext()->CurrentViewer();
615   }
616   else if (ViewerTest_myContexts.IsBound1(aViewNames.GetViewerName()))
617   {
618     ViewerTest::SetAISContext(ViewerTest_myContexts.Find1(aViewNames.GetViewerName()));
619     a3DViewer = ViewerTest::GetAISContext()->CurrentViewer();
620   }
621   else if (a3DViewer.IsNull())
622   {
623     toCreateViewer = Standard_True;
624     TCollection_ExtendedString NameOfWindow("Viewer3D");
625     a3DViewer = new V3d_Viewer(aGraphicDriver, NameOfWindow.ToExtString());
626
627     NameOfWindow = TCollection_ExtendedString("Collector");
628
629     a3DViewer->SetDefaultBackgroundColor(Quantity_NOC_BLACK);
630   }
631
632   // AIS context setup
633   if (ViewerTest::GetAISContext().IsNull() ||
634       !(ViewerTest_myContexts.IsBound1(aViewNames.GetViewerName())))
635   {
636     Handle(AIS_InteractiveContext) aContext = new AIS_InteractiveContext (a3DViewer);
637     ViewerTest::SetAISContext (aContext);
638     ViewerTest_myContexts.Bind (aViewNames.GetViewerName(), ViewerTest::GetAISContext());
639   }
640   else
641   {
642     ViewerTest::ResetEventManager();
643   }
644
645   // Create window
646 #if defined(_WIN32)
647   VT_GetWindow() = new WNT_Window (aTitle.ToCString(),
648                                     Handle(WNT_WClass)::DownCast (WClass()),
649                                     Draw_VirtualWindows ? WS_POPUPWINDOW : WS_OVERLAPPEDWINDOW,
650                                     aPxLeft, aPxTop,
651                                     aPxWidth, aPxHeight,
652                                     Quantity_NOC_BLACK);
653 #elif defined(__APPLE__) && !defined(MACOSX_USE_GLX)
654   VT_GetWindow() = new Cocoa_Window (aTitle.ToCString(),
655                                      aPxLeft, aPxTop,
656                                      aPxWidth, aPxHeight);
657   ViewerTest_SetCocoaEventManagerView (VT_GetWindow());
658 #else
659   VT_GetWindow() = new Xw_Window (aGraphicDriver->GetDisplayConnection(),
660                                   aTitle.ToCString(),
661                                   aPxLeft, aPxTop,
662                                   aPxWidth, aPxHeight);
663 #endif
664   VT_GetWindow()->SetVirtual (Draw_VirtualWindows);
665
666   // NIS setup
667   Handle(NIS_View) aView = new NIS_View (a3DViewer, VT_GetWindow());
668
669   ViewerTest::CurrentView(aView);
670   ViewerTest_myViews.Bind (aViewNames.GetViewName(), aView);
671   TheNISContext()->AttachView (aView);
672
673   // Setup for X11 or NT
674   OSWindowSetup();
675
676   // Set parameters for V3d_View and V3d_Viewer
677   const Handle (V3d_View) aV3dView = ViewerTest::CurrentView();
678   aV3dView->SetComputedMode(Standard_False);
679   MyHLRIsOn = aV3dView->ComputedMode();
680   aV3dView->SetZClippingDepth(0.5);
681   aV3dView->SetZClippingWidth(ZCLIPWIDTH/2.);
682
683   a3DViewer->SetDefaultBackgroundColor(Quantity_NOC_BLACK);
684   if (toCreateViewer)
685   {
686     a3DViewer->SetDefaultLights();
687     a3DViewer->SetLightOn();
688   }
689
690   #if !defined(_WIN32) && (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
691   #if TCL_MAJOR_VERSION  < 8
692   Tk_CreateFileHandler((void*)XConnectionNumber(GetDisplayConnection()->GetDisplay()),
693       TK_READABLE, VProcessEvents, (ClientData) VT_GetWindow()->XWindow() );
694   #else
695   Tk_CreateFileHandler(XConnectionNumber(GetDisplayConnection()->GetDisplay()),
696       TK_READABLE, VProcessEvents, (ClientData) VT_GetWindow()->XWindow() );
697   #endif
698   #endif
699
700   VT_GetWindow()->Map();
701
702   // Set the handle of created view in the event manager
703   ViewerTest::ResetEventManager();
704
705   ViewerTest::CurrentView()->Redraw();
706
707   aView.Nullify();
708   a3DViewer.Nullify();
709
710   return aViewNames.GetViewName();
711 }
712
713 //==============================================================================
714 //function : RedrawAllViews
715 //purpose  : Redraw all created views
716 //==============================================================================
717 void ViewerTest::RedrawAllViews()
718 {
719   NCollection_DoubleMap<TCollection_AsciiString, Handle(V3d_View)>::Iterator aViewIt(ViewerTest_myViews);
720   for (; aViewIt.More(); aViewIt.Next())
721   {
722     const Handle(V3d_View)& aView = aViewIt.Key2();
723     aView->Redraw();
724   }
725 }
726
727 //==============================================================================
728 //function : Vinit
729 //purpose  : Create the window viewer and initialize all the global variable
730 //    Use Tk_CreateFileHandler on UNIX to catch the X11 Viewer event
731 //==============================================================================
732
733 static int VInit (Draw_Interpretor& theDi, Standard_Integer theArgsNb, const char** theArgVec)
734 {
735   if (theArgsNb > 9)
736   {
737     std::cerr << theArgVec[0] << ": incorrect number of command arguments.\n"
738               << "Type help for more information.\n";
739     return 1;
740   }
741
742   TCollection_AsciiString aViewName, aDisplayName;
743   Standard_Integer aPxLeft = 0, aPxTop = 0, aPxWidth = 0, aPxHeight = 0;
744   TCollection_AsciiString aName, aValue;
745   for (Standard_Integer anArgIt = 1; anArgIt < theArgsNb; ++anArgIt)
746   {
747     const TCollection_AsciiString anArg = theArgVec[anArgIt];
748     TCollection_AsciiString anArgCase = anArg;
749     anArgCase.UpperCase();
750     if (ViewerTest::SplitParameter (anArg, aName, aValue))
751     {
752       aName.UpperCase();
753       if (aName.IsEqual ("NAME"))
754       {
755         aViewName = aValue;
756       }
757       else if (aName.IsEqual ("L")
758             || aName.IsEqual ("LEFT"))
759       {
760         aPxLeft = aValue.IntegerValue();
761       }
762       else if (aName.IsEqual ("T")
763             || aName.IsEqual ("TOP"))
764       {
765         aPxTop = aValue.IntegerValue();
766       }
767     #if !defined(_WIN32) && (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
768       else if (aName.IsEqual ("DISP")
769             || aName.IsEqual ("DISPLAY"))
770       {
771         aDisplayName = aValue;
772       }
773     #endif
774       else if (aName.IsEqual ("W")
775             || aName.IsEqual ("WIDTH"))
776       {
777         aPxWidth = aValue.IntegerValue();
778       }
779       else if (aName.IsEqual ("H")
780             || aName.IsEqual ("HEIGHT"))
781       {
782         aPxHeight = aValue.IntegerValue();
783       }
784       else
785       {
786         std::cerr << theArgVec[0] << ": Warning: unknown argument " << anArg << ".\n";
787       }
788     }
789     else if (aViewName.IsEmpty())
790     {
791       aViewName = anArg;
792     }
793     else
794     {
795       std::cerr << theArgVec[0] << ": Warning: unknown argument " << anArg << ".\n";
796     }
797   }
798
799   ViewerTest_Names aViewNames (aViewName);
800   if (ViewerTest_myViews.IsBound1 (aViewNames.GetViewName()))
801   {
802     TCollection_AsciiString aCommand = TCollection_AsciiString ("vactivate ") + aViewNames.GetViewName();
803     theDi.Eval (aCommand.ToCString());
804     return 0;
805   }
806
807   TCollection_AsciiString aViewId = ViewerTest::ViewerInit (aPxLeft, aPxTop, aPxWidth, aPxHeight,
808                                                             aViewName.ToCString(),
809                                                             aDisplayName.ToCString());
810   theDi << aViewId;
811   return 0;
812 }
813
814 //==============================================================================
815 //function : VHLR
816 //purpose  : hidden lines removal algorithm
817 //draw args: vhlr is_enabled={on|off} [show_hidden={1|0}]
818 //==============================================================================
819
820 static int VHLR (Draw_Interpretor& di, Standard_Integer argc, const char** argv)
821 {
822   if (ViewerTest::CurrentView().IsNull())
823   {
824     di << argv[0] << ": Call vinit before this command, please.\n";
825     return 1;
826   }
827
828   if (argc < 2)
829   {
830     di << argv[0] << ": Wrong number of command arguments.\n"
831       << "Type help " << argv[0] << " for more information.\n";
832     return 1;
833   }
834
835   // Enable or disable HLR mode.
836   Standard_Boolean isHLROn =
837     (!strcasecmp (argv[1], "on")) ? Standard_True : Standard_False;
838
839   if (isHLROn != MyHLRIsOn)
840   {
841     MyHLRIsOn = isHLROn;
842     ViewerTest::CurrentView()->SetComputedMode (MyHLRIsOn);
843   }
844
845   // Show or hide hidden lines in HLR mode.
846   Standard_Boolean isCurrentShowHidden
847     = ViewerTest::GetAISContext()->DefaultDrawer()->DrawHiddenLine();
848
849   Standard_Boolean isShowHidden =
850     (argc == 3) ? (atoi(argv[2]) == 1 ? Standard_True : Standard_False)
851                 : isCurrentShowHidden;
852
853
854   if (isShowHidden != isCurrentShowHidden)
855   {
856     if (isShowHidden)
857     {
858       ViewerTest::GetAISContext()->DefaultDrawer()->EnableDrawHiddenLine();
859     }
860     else
861     {
862       ViewerTest::GetAISContext()->DefaultDrawer()->DisableDrawHiddenLine();
863     }
864
865     // Redisplay shapes.
866     if (MyHLRIsOn)
867     {
868       AIS_ListOfInteractive aListOfShapes;
869       ViewerTest::GetAISContext()->DisplayedObjects (aListOfShapes);
870
871       for (AIS_ListIteratorOfListOfInteractive anIter(aListOfShapes); anIter.More(); anIter.Next())
872       {
873         Handle(AIS_Shape) aShape = Handle(AIS_Shape)::DownCast (anIter.Value());
874         if (aShape.IsNull())
875         {
876           continue;
877         }
878         aShape->Redisplay();
879       }
880     }
881   }
882
883   ViewerTest::CurrentView()->Update();
884   return 0;
885 }
886
887 //==============================================================================
888 //function : VHLRType
889 //purpose  : change type of using HLR algorithm
890 //==============================================================================
891
892 static int VHLRType (Draw_Interpretor& di, Standard_Integer argc, const char** argv)
893 {
894   if (ViewerTest::CurrentView().IsNull())
895   {
896     di << argv[0] << ": Call vinit before this command, please.\n";
897     return 1;
898   }
899
900   if (argc < 2)
901   {
902     di << argv[0] << ": Wrong number of command arguments.\n"
903       << "Type help " << argv[0] << " for more information.\n";
904     return 1;
905   }
906
907   Prs3d_TypeOfHLR aTypeOfHLR =
908     (!strcasecmp (argv[1], "algo")) ? Prs3d_TOH_Algo : Prs3d_TOH_PolyAlgo;
909
910   if (argc == 2)
911   {
912     AIS_ListOfInteractive aListOfShapes;
913     ViewerTest::GetAISContext()->DisplayedObjects (aListOfShapes);
914     ViewerTest::GetAISContext()->DefaultDrawer()->SetTypeOfHLR(aTypeOfHLR);
915     for (AIS_ListIteratorOfListOfInteractive anIter(aListOfShapes);
916       anIter.More(); anIter.Next())
917     {
918       Handle(AIS_Shape) aShape = Handle(AIS_Shape)::DownCast(anIter.Value());
919       if (aShape.IsNull())
920         continue;
921       if (aShape->TypeOfHLR() != aTypeOfHLR)
922         aShape->SetTypeOfHLR (aTypeOfHLR);
923       if (MyHLRIsOn)
924         aShape->Redisplay();
925     }
926     ViewerTest::CurrentView()->Update();
927     return 0;
928   }
929   else
930   {
931     for (Standard_Integer i = 2; i < argc; ++i)
932     {
933       ViewerTest_DoubleMapOfInteractiveAndName& aMap = GetMapOfAIS();
934       TCollection_AsciiString aName (argv[i]);
935
936       if (!aMap.IsBound2 (aName))
937       {
938         di << argv[0] << ":" << " Wrong shape name:" << aName.ToCString() << ".\n";
939         continue;
940       }
941       Handle(AIS_Shape) anAISObject =
942         Handle(AIS_Shape)::DownCast (aMap.Find2(aName));
943       if (anAISObject.IsNull())
944         continue;
945       anAISObject->SetTypeOfHLR (aTypeOfHLR);
946       if (MyHLRIsOn)
947         anAISObject->Redisplay();
948     }
949     ViewerTest::CurrentView()->Update();
950   }
951
952   return 0;
953 }
954
955 //==============================================================================
956 //function : FindViewIdByWindowHandle
957 //purpose  : Find theView Id in the map of views by window handle
958 //==============================================================================
959 #if defined(_WIN32) || defined(__WIN32__) || (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
960 TCollection_AsciiString FindViewIdByWindowHandle(const Aspect_Handle theWindowHandle)
961 {
962   for (NCollection_DoubleMap<TCollection_AsciiString, Handle(V3d_View)>::Iterator
963        anIter(ViewerTest_myViews); anIter.More(); anIter.Next())
964   {
965     Aspect_Handle aWindowHandle = GetWindowHandle(anIter.Value()->Window());
966     if (aWindowHandle == theWindowHandle)
967       return anIter.Key1();
968   }
969   return TCollection_AsciiString("");
970 }
971 #endif
972
973 //==============================================================================
974 //function : ActivateView
975 //purpose  : Make the view active
976 //==============================================================================
977
978 void ActivateView (const TCollection_AsciiString& theViewName)
979 {
980   const Handle(V3d_View) aView = ViewerTest_myViews.Find1(theViewName);
981   if (!aView.IsNull())
982   {
983     Handle(AIS_InteractiveContext) anAISContext = FindContextByView(aView);
984     if (!anAISContext.IsNull())
985     {
986       if (!ViewerTest::CurrentView().IsNull())
987       {
988         TCollection_AsciiString aTitle("3D View - ");
989         aTitle = aTitle + ViewerTest_myViews.Find2 (ViewerTest::CurrentView());
990         SetWindowTitle (ViewerTest::CurrentView()->Window(), aTitle.ToCString());
991       }
992
993       ViewerTest::CurrentView (aView);
994       // Update degenerate mode
995       MyHLRIsOn = ViewerTest::CurrentView()->ComputedMode();
996       ViewerTest::SetAISContext (anAISContext);
997       TCollection_AsciiString aTitle = TCollection_AsciiString("3D View - ");
998       aTitle = aTitle + theViewName + "(*)";
999       SetWindowTitle (ViewerTest::CurrentView()->Window(), aTitle.ToCString());
1000 #if defined(_WIN32) || defined(__WIN32__)
1001       VT_GetWindow() = Handle(WNT_Window)::DownCast(ViewerTest::CurrentView()->Window());
1002 #elif defined(__APPLE__) && !defined(MACOSX_USE_GLX)
1003       VT_GetWindow() = Handle(Cocoa_Window)::DownCast(ViewerTest::CurrentView()->Window());
1004 #else
1005       VT_GetWindow() = Handle(Xw_Window)::DownCast(ViewerTest::CurrentView()->Window());
1006 #endif
1007       SetDisplayConnection(ViewerTest::CurrentView()->Viewer()->Driver()->GetDisplayConnection());
1008       ViewerTest::CurrentView()->Redraw();
1009     }
1010   }
1011 }
1012
1013 //==============================================================================
1014 //function : RemoveView
1015 //purpose  : Close and remove view from display, clear maps if neccessary
1016 //==============================================================================
1017 void ViewerTest::RemoveView (const TCollection_AsciiString& theViewName, const Standard_Boolean isContextRemoved)
1018 {
1019   if (!ViewerTest_myViews.IsBound1(theViewName))
1020   {
1021     cout << "Wrong view name\n";
1022     return;
1023   }
1024
1025   // Activate another view if it's active now
1026   if (ViewerTest_myViews.Find1(theViewName) == ViewerTest::CurrentView())
1027   {
1028     if (ViewerTest_myViews.Extent() > 1)
1029     {
1030       TCollection_AsciiString aNewViewName;
1031       for (NCollection_DoubleMap <TCollection_AsciiString, Handle(V3d_View)> :: Iterator
1032            anIter(ViewerTest_myViews); anIter.More(); anIter.Next())
1033         if (anIter.Key1() != theViewName)
1034         {
1035           aNewViewName = anIter.Key1();
1036           break;
1037         }
1038         ActivateView (aNewViewName);
1039     }
1040     else
1041     {
1042       Handle(V3d_View) anEmptyView;
1043 #if defined(_WIN32) || defined(__WIN32__)
1044       Handle(WNT_Window) anEmptyWindow;
1045 #elif defined(__APPLE__) && !defined(MACOSX_USE_GLX)
1046       Handle(Cocoa_Window) anEmptyWindow;
1047 #else
1048       Handle(Xw_Window) anEmptyWindow;
1049 #endif
1050       VT_GetWindow() = anEmptyWindow;
1051       ViewerTest::CurrentView (anEmptyView);
1052       if (isContextRemoved)
1053       {
1054         Handle(AIS_InteractiveContext) anEmptyContext;
1055         ViewerTest::SetAISContext(anEmptyContext);
1056       }
1057     }
1058   }
1059
1060   // Delete view
1061   Handle(V3d_View) aView = ViewerTest_myViews.Find1(theViewName);
1062   Handle(AIS_InteractiveContext) aCurrentContext = FindContextByView(aView);
1063
1064   // Remove view resources
1065   TheNISContext()->DetachView(Handle(NIS_View)::DownCast(aView));
1066   ViewerTest_myViews.UnBind1(theViewName);
1067   aView->Remove();
1068
1069 #if !defined(_WIN32) && !defined(__WIN32__) && (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
1070   XFlush (GetDisplayConnection()->GetDisplay());
1071 #endif
1072
1073   // Keep context opened only if the closed view is last to avoid
1074   // unused empty contexts
1075   if (!aCurrentContext.IsNull())
1076   {
1077     // Check if there are more difined views in the viewer
1078     aCurrentContext->CurrentViewer()->InitDefinedViews();
1079     if ((isContextRemoved || ViewerTest_myContexts.Size() != 1) && !aCurrentContext->CurrentViewer()->MoreDefinedViews())
1080     {
1081       // Remove driver if there is no viewers that use it
1082       Standard_Boolean isRemoveDriver = Standard_True;
1083       for(NCollection_DoubleMap<TCollection_AsciiString, Handle(AIS_InteractiveContext)>::Iterator
1084           anIter(ViewerTest_myContexts); anIter.More(); anIter.Next())
1085       {
1086         if (aCurrentContext != anIter.Key2() &&
1087           aCurrentContext->CurrentViewer()->Driver() == anIter.Value()->CurrentViewer()->Driver())
1088         {
1089           isRemoveDriver = Standard_False;
1090           break;
1091         }
1092       }
1093       if(isRemoveDriver)
1094       {
1095         ViewerTest_myDrivers.UnBind2 (aCurrentContext->CurrentViewer()->Driver());
1096       #if !defined(_WIN32) && !defined(__WIN32__) && (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
1097         #if TCL_MAJOR_VERSION  < 8
1098         Tk_DeleteFileHandler((void*)XConnectionNumber(aCurrentContext->CurrentViewer()->Driver()->GetDisplayConnection()->GetDisplay()));
1099         #else
1100         Tk_DeleteFileHandler(XConnectionNumber(aCurrentContext->CurrentViewer()->Driver()->GetDisplayConnection()->GetDisplay()));
1101         #endif
1102       #endif
1103       }
1104
1105       ViewerTest_myContexts.UnBind2(aCurrentContext);
1106     }
1107   }
1108   cout << "3D View - " << theViewName << " was deleted.\n";
1109
1110 }
1111
1112 //==============================================================================
1113 //function : VClose
1114 //purpose  : Remove the view defined by its name
1115 //==============================================================================
1116
1117 static int VClose (Draw_Interpretor& /*theDi*/,
1118                    Standard_Integer  theArgsNb,
1119                    const char**      theArgVec)
1120 {
1121   NCollection_List<TCollection_AsciiString> aViewList;
1122   if (theArgsNb > 1)
1123   {
1124     TCollection_AsciiString anArg (theArgVec[1]);
1125     anArg.UpperCase();
1126     if (anArg.IsEqual ("ALL")
1127      || anArg.IsEqual ("*"))
1128     {
1129       for (NCollection_DoubleMap<TCollection_AsciiString, Handle(V3d_View)>::Iterator anIter (ViewerTest_myViews);
1130            anIter.More(); anIter.Next())
1131       {
1132         aViewList.Append (anIter.Key1());
1133       }
1134       if (aViewList.IsEmpty())
1135       {
1136         std::cout << "No view to close\n";
1137         return 0;
1138       }
1139     }
1140     else
1141     {
1142       ViewerTest_Names aViewName (theArgVec[1]);
1143       if (!ViewerTest_myViews.IsBound1 (aViewName.GetViewName()))
1144       {
1145         std::cerr << "The view with name '" << theArgVec[1] << "' does not exist\n";
1146         return 1;
1147       }
1148       aViewList.Append (aViewName.GetViewName());
1149     }
1150   }
1151   else
1152   {
1153     // close active view
1154     if (ViewerTest::CurrentView().IsNull())
1155     {
1156       std::cerr << "No active view!\n";
1157       return 1;
1158     }
1159     aViewList.Append (ViewerTest_myViews.Find2 (ViewerTest::CurrentView()));
1160   }
1161
1162   Standard_Boolean toRemoveContext = (theArgsNb != 3 || Draw::Atoi (theArgVec[2]) != 1);
1163   for (NCollection_List<TCollection_AsciiString>::Iterator anIter(aViewList);
1164        anIter.More(); anIter.Next())
1165   {
1166     ViewerTest::RemoveView (anIter.Value(), toRemoveContext);
1167   }
1168
1169   return 0;
1170 }
1171
1172 //==============================================================================
1173 //function : VActivate
1174 //purpose  : Activate the view defined by its ID
1175 //==============================================================================
1176
1177 static int VActivate (Draw_Interpretor& theDi, Standard_Integer theArgsNb, const char** theArgVec)
1178 {
1179   if (theArgsNb > 2)
1180   {
1181     theDi << theArgVec[0] << ": wrong number of command arguments.\n"
1182     << "Usage: " << theArgVec[0] << " ViewID\n";
1183     return 1;
1184   }
1185   if(theArgsNb == 1)
1186   {
1187     theDi.Eval("vviewlist");
1188     return 0;
1189   }
1190
1191   TCollection_AsciiString aNameString(theArgVec[1]);
1192   if ( strcasecmp( aNameString.ToCString(), "NONE" ) == 0 )
1193   {
1194     TCollection_AsciiString aTitle("3D View - ");
1195     aTitle = aTitle + ViewerTest_myViews.Find2(ViewerTest::CurrentView());
1196     SetWindowTitle (ViewerTest::CurrentView()->Window(), aTitle.ToCString());
1197     Handle(V3d_View) anEmptyView;
1198 #if defined(_WIN32) || defined(__WIN32__)
1199     Handle(WNT_Window) anEmptyWindow;
1200 #elif defined(__APPLE__) && !defined(MACOSX_USE_GLX)
1201     Handle(Cocoa_Window) anEmptyWindow;
1202 #else
1203     Handle(Xw_Window) anEmptyWindow;
1204 #endif
1205     VT_GetWindow() = anEmptyWindow;
1206     ViewerTest::CurrentView (anEmptyView);
1207     ViewerTest::ResetEventManager();
1208     theDi << theArgVec[0] << ": all views are inactive\n";
1209     return 0;
1210   }
1211
1212   ViewerTest_Names aViewNames(aNameString);
1213
1214   // Check if this view exists in the viewer with the driver
1215   if (!ViewerTest_myViews.IsBound1(aViewNames.GetViewName()))
1216   {
1217     theDi << "Wrong view name\n";
1218     return 1;
1219   }
1220
1221   // Check if it is active already
1222   if (ViewerTest::CurrentView() == ViewerTest_myViews.Find1(aViewNames.GetViewName()))
1223   {
1224     theDi << theArgVec[0] << ": the view is active already\n";
1225     return 0;
1226   }
1227
1228   ActivateView (aViewNames.GetViewName());
1229   return 0;
1230 }
1231
1232 //==============================================================================
1233 //function : VViewList
1234 //purpose  : Print current list of views per viewer and graphic driver ID
1235 //           shared between viewers
1236 //==============================================================================
1237
1238 static int VViewList (Draw_Interpretor& theDi, Standard_Integer theArgsNb, const char** theArgVec)
1239 {
1240   if (theArgsNb > 2)
1241   {
1242     theDi << theArgVec[0] << ": Wrong number of command arguments\n"
1243           << "Usage: " << theArgVec[0] << " name";
1244     return 1;
1245   }
1246   if (ViewerTest_myContexts.Size() < 1)
1247     return 0;
1248
1249   Standard_Boolean isTreeView =
1250     (( theArgsNb==1 ) || ( strcasecmp( theArgVec[1], "long" ) != 0 ));
1251
1252   if (isTreeView)
1253     theDi << theArgVec[0] <<":\n";
1254
1255     for (NCollection_DoubleMap <TCollection_AsciiString, Handle(Graphic3d_GraphicDriver)>::Iterator
1256       aDriverIter(ViewerTest_myDrivers); aDriverIter.More(); aDriverIter.Next())
1257     {
1258       if (isTreeView)
1259         theDi << aDriverIter.Key1() << ":\n";
1260
1261       for (NCollection_DoubleMap <TCollection_AsciiString, Handle(AIS_InteractiveContext)>::Iterator
1262         aContextIter(ViewerTest_myContexts); aContextIter.More(); aContextIter.Next())
1263       {
1264         if (aContextIter.Key1().Search(aDriverIter.Key1()) != -1)
1265         {
1266           if (isTreeView)
1267           {
1268             TCollection_AsciiString aContextName(aContextIter.Key1());
1269             theDi << " " << aContextName.Split(aDriverIter.Key1().Length() + 1) << ":" << "\n";
1270           }
1271
1272           for (NCollection_DoubleMap <TCollection_AsciiString, Handle(V3d_View)>::Iterator
1273             aViewIter(ViewerTest_myViews); aViewIter.More(); aViewIter.Next())
1274           {
1275             if (aViewIter.Key1().Search(aContextIter.Key1()) != -1)
1276             {
1277               TCollection_AsciiString aViewName(aViewIter.Key1());
1278               if (isTreeView)
1279               {
1280                 if (aViewIter.Value() == ViewerTest::CurrentView())
1281                   theDi << "  " << aViewName.Split(aContextIter.Key1().Length() + 1) << "(*)" << "\n";
1282                 else
1283                   theDi << "  " << aViewName.Split(aContextIter.Key1().Length() + 1) << "\n";
1284               }
1285               else
1286               {
1287                 theDi << aViewName << " ";
1288               }
1289             }
1290           }
1291         }
1292       }
1293     }
1294   return 0;
1295 }
1296
1297 //==============================================================================
1298 //function : VT_ProcessKeyPress
1299 //purpose  : Handle KeyPress event from a CString
1300 //==============================================================================
1301 void VT_ProcessKeyPress (const char* buf_ret)
1302 {
1303   //cout << "KeyPress" << endl;
1304   const Handle(V3d_View) aView = ViewerTest::CurrentView();
1305   const Handle(NIS_View) aNisView = Handle(NIS_View)::DownCast (aView);
1306   // Letter in alphabetic order
1307
1308   if (!strcasecmp (buf_ret, "A"))
1309   {
1310     // AXO
1311     aView->SetProj(V3d_XposYnegZpos);
1312   }
1313   else if (!strcasecmp (buf_ret, "D"))
1314   {
1315     // Reset
1316     aView->Reset();
1317   }
1318   else if (!strcasecmp (buf_ret, "F"))
1319   {
1320     // FitAll
1321     if (aNisView.IsNull())
1322       aView->FitAll();
1323     else
1324       aNisView->FitAll3d();
1325   }
1326   else if (!strcasecmp (buf_ret, "H"))
1327   {
1328     // HLR
1329     cout << "HLR" << endl;
1330     aView->SetComputedMode (!aView->ComputedMode());
1331     MyHLRIsOn = aView->ComputedMode();
1332   }
1333   else if (!strcasecmp (buf_ret, "P"))
1334   {
1335     // Type of HLR
1336     Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
1337     if (aContext->DefaultDrawer()->TypeOfHLR() == Prs3d_TOH_Algo)
1338       aContext->DefaultDrawer()->SetTypeOfHLR(Prs3d_TOH_PolyAlgo);
1339     else
1340       aContext->DefaultDrawer()->SetTypeOfHLR(Prs3d_TOH_Algo);
1341     if (aContext->NbCurrents()==0 || aContext->NbSelected() == 0)
1342     {
1343       AIS_ListOfInteractive aListOfShapes;
1344       aContext->DisplayedObjects(aListOfShapes);
1345       for (AIS_ListIteratorOfListOfInteractive anIter(aListOfShapes);
1346         anIter.More(); anIter.Next())
1347       {
1348         Handle(AIS_Shape) aShape = Handle(AIS_Shape)::DownCast(anIter.Value());
1349         if (aShape.IsNull())
1350           continue;
1351         if (aShape->TypeOfHLR() == Prs3d_TOH_PolyAlgo)
1352           aShape->SetTypeOfHLR (Prs3d_TOH_Algo);
1353         else
1354           aShape->SetTypeOfHLR (Prs3d_TOH_PolyAlgo);
1355         aShape->Redisplay();
1356       }
1357     }
1358     else
1359     {
1360       for (aContext->InitCurrent();aContext->MoreCurrent();aContext->NextCurrent())
1361       {
1362         Handle(AIS_Shape) aShape = Handle(AIS_Shape)::DownCast(aContext->Current());
1363         if (aShape.IsNull())
1364           continue;
1365         if(aShape->TypeOfHLR() == Prs3d_TOH_PolyAlgo)
1366           aShape->SetTypeOfHLR (Prs3d_TOH_Algo);
1367         else
1368           aShape->SetTypeOfHLR (Prs3d_TOH_PolyAlgo);
1369         aShape->Redisplay();
1370       }
1371     }
1372
1373     aContext->UpdateCurrentViewer();
1374
1375   }
1376   else if (!strcasecmp (buf_ret, "S"))
1377   {
1378     std::cout << "setup Shaded display mode" << std::endl;
1379
1380     Handle(AIS_InteractiveContext) Ctx = ViewerTest::GetAISContext();
1381     if(Ctx->NbCurrents()==0 ||
1382       Ctx->NbSelected()==0)
1383       Ctx->SetDisplayMode(AIS_Shaded);
1384     else{
1385       if(Ctx->HasOpenedContext()){
1386         for(Ctx->InitSelected();Ctx->MoreSelected();Ctx->NextSelected())
1387           Ctx->SetDisplayMode(Ctx->Interactive(),1,Standard_False);
1388       }
1389       else{
1390         for(Ctx->InitCurrent();Ctx->MoreCurrent();Ctx->NextCurrent())
1391           Ctx->SetDisplayMode(Ctx->Current(),1,Standard_False);
1392       }
1393       Ctx->UpdateCurrentViewer();
1394     }
1395   }
1396   else if (!strcasecmp (buf_ret, "U"))
1397   {
1398     // Unset display mode
1399     std::cout << "reset display mode to defaults" << std::endl;
1400
1401     Handle(AIS_InteractiveContext) Ctx = ViewerTest::GetAISContext();
1402     if(Ctx->NbCurrents()==0 ||
1403       Ctx->NbSelected()==0)
1404       Ctx->SetDisplayMode(AIS_WireFrame);
1405     else{
1406       if(Ctx->HasOpenedContext()){
1407         for(Ctx->InitSelected();Ctx->MoreSelected();Ctx->NextSelected())
1408           Ctx->UnsetDisplayMode(Ctx->Interactive(),Standard_False);
1409       }
1410       else{
1411         for(Ctx->InitCurrent();Ctx->MoreCurrent();Ctx->NextCurrent())
1412           Ctx->UnsetDisplayMode(Ctx->Current(),Standard_False);
1413       }
1414       Ctx->UpdateCurrentViewer();
1415     }
1416
1417   }
1418   else if (!strcasecmp (buf_ret, "T"))
1419   {
1420     // Top
1421     aView->SetProj(V3d_Zpos);
1422   }
1423   else if (!strcasecmp (buf_ret, "B"))
1424   {
1425     // Bottom
1426     aView->SetProj(V3d_Zneg);
1427   }
1428   else if (!strcasecmp (buf_ret, "L"))
1429   {
1430     // Left
1431     aView->SetProj(V3d_Xneg);
1432   }
1433   else if (!strcasecmp (buf_ret, "R"))
1434   {
1435     // Right
1436     aView->SetProj(V3d_Xpos);
1437   }
1438   else if (!strcasecmp (buf_ret, "W"))
1439   {
1440     std::cout << "setup WireFrame display mode" << std::endl;
1441     Handle(AIS_InteractiveContext) Ctx = ViewerTest::GetAISContext();
1442     if(Ctx->NbCurrents()==0 ||
1443       Ctx->NbSelected()==0)
1444       Ctx->SetDisplayMode(AIS_WireFrame);
1445     else{
1446       if(Ctx->HasOpenedContext()){
1447         for(Ctx->InitSelected();Ctx->MoreSelected();Ctx->NextSelected())
1448           Ctx->SetDisplayMode(Ctx->Interactive(),0,Standard_False);
1449       }
1450       else{
1451         for(Ctx->InitCurrent();Ctx->MoreCurrent();Ctx->NextCurrent())
1452           Ctx->SetDisplayMode(Ctx->Current(),0,Standard_False);
1453       }
1454       Ctx->UpdateCurrentViewer();
1455     }
1456   }
1457   else if (!strcasecmp (buf_ret, "Z"))
1458   {
1459     // ZCLIP
1460     if ( ZClipIsOn ) {
1461       cout << "ZClipping OFF" << endl;
1462       ZClipIsOn = 0;
1463
1464       aView->SetZClippingType(V3d_OFF);
1465       aView->Redraw();
1466     }
1467     else {
1468       cout << "ZClipping ON" << endl;
1469       ZClipIsOn = 1;
1470
1471       aView->SetZClippingType(V3d_FRONT);
1472       aView->Redraw();
1473     }
1474   }
1475   else if (!strcasecmp (buf_ret, ","))
1476   {
1477     ViewerTest::GetAISContext()->HilightNextDetected(ViewerTest::CurrentView());
1478   }
1479   else if (!strcasecmp (buf_ret, "."))
1480   {
1481     ViewerTest::GetAISContext()->HilightPreviousDetected(ViewerTest::CurrentView());
1482   }
1483   else if (*buf_ret == THE_KEY_DELETE)
1484   {
1485     Handle(AIS_InteractiveContext) aCtx = ViewerTest::GetAISContext();
1486     if (!aCtx.IsNull()
1487      && aCtx->NbCurrents() > 0
1488      && aCtx->NbSelected() > 0)
1489     {
1490       Draw_Interprete ("verase");
1491     }
1492   }
1493   else
1494   {
1495     // Number
1496     Standard_Integer Num = Draw::Atoi(buf_ret);
1497     if(Num>=0 && Num<=7)
1498       ViewerTest::StandardModeActivation(Num);
1499   }
1500 }
1501
1502 //==============================================================================
1503 //function : VT_ProcessExpose
1504 //purpose  : Redraw the View on an Expose Event
1505 //==============================================================================
1506 void VT_ProcessExpose()
1507 {
1508   Handle(V3d_View) aView3d = ViewerTest::CurrentView();
1509   if (!aView3d.IsNull())
1510   {
1511     aView3d->Redraw();
1512   }
1513 }
1514
1515 //==============================================================================
1516 //function : VT_ProcessConfigure
1517 //purpose  : Resize the View on an Configure Event
1518 //==============================================================================
1519 void VT_ProcessConfigure()
1520 {
1521   Handle(V3d_View) aView3d = ViewerTest::CurrentView();
1522   if (aView3d.IsNull())
1523   {
1524     return;
1525   }
1526
1527   aView3d->MustBeResized();
1528   aView3d->Update();
1529   aView3d->Redraw();
1530 }
1531
1532 //==============================================================================
1533 //function : VT_ProcessButton1Press
1534 //purpose  : Picking
1535 //==============================================================================
1536 Standard_Boolean VT_ProcessButton1Press (Standard_Integer ,
1537                                          const char**     theArgVec,
1538                                          Standard_Boolean theToPick,
1539                                          Standard_Boolean theIsShift)
1540 {
1541   if (theToPick)
1542   {
1543     Standard_Real X, Y, Z;
1544     ViewerTest::CurrentView()->Convert (X_Motion, Y_Motion, X, Y, Z);
1545
1546     Draw::Set (theArgVec[1], X);
1547     Draw::Set (theArgVec[2], Y);
1548     Draw::Set (theArgVec[3], Z);
1549   }
1550
1551   if (theIsShift)
1552   {
1553     ViewerTest::CurrentEventManager()->ShiftSelect();
1554   }
1555   else
1556   {
1557     ViewerTest::CurrentEventManager()->Select();
1558   }
1559
1560   return Standard_False;
1561 }
1562
1563 //==============================================================================
1564 //function : VT_ProcessButton1Release
1565 //purpose  : End selecting
1566 //==============================================================================
1567 void VT_ProcessButton1Release (Standard_Boolean theIsShift)
1568 {
1569   if (IsDragged)
1570   {
1571     IsDragged = Standard_False;
1572     Handle(ViewerTest_EventManager) EM = ViewerTest::CurrentEventManager();
1573     if (theIsShift)
1574     {
1575       EM->ShiftSelect (Min (X_ButtonPress, X_Motion), Max (Y_ButtonPress, Y_Motion),
1576                        Max (X_ButtonPress, X_Motion), Min (Y_ButtonPress, Y_Motion));
1577     }
1578     else
1579     {
1580       EM->Select (Min (X_ButtonPress, X_Motion), Max (Y_ButtonPress, Y_Motion),
1581                   Max (X_ButtonPress, X_Motion), Min (Y_ButtonPress, Y_Motion));
1582     }
1583   }
1584 }
1585
1586 //==============================================================================
1587 //function : VT_ProcessButton3Press
1588 //purpose  : Start Rotation
1589 //==============================================================================
1590 void VT_ProcessButton3Press()
1591 {
1592   Start_Rot = 1;
1593   if (MyHLRIsOn)
1594   {
1595     ViewerTest::CurrentView()->SetComputedMode (Standard_False);
1596   }
1597   ViewerTest::CurrentView()->StartRotation( X_ButtonPress, Y_ButtonPress );
1598 }
1599
1600 //==============================================================================
1601 //function : VT_ProcessButton3Release
1602 //purpose  : End rotation
1603 //==============================================================================
1604 void VT_ProcessButton3Release()
1605 {
1606   if (Start_Rot)
1607   {
1608     Start_Rot = 0;
1609     if (MyHLRIsOn)
1610     {
1611       ViewerTest::CurrentView()->SetComputedMode (Standard_True);
1612     }
1613   }
1614 }
1615
1616 //==============================================================================
1617 //function : ProcessZClipMotion
1618 //purpose  : Zoom
1619 //==============================================================================
1620
1621 void ProcessZClipMotion()
1622 {
1623   Handle(V3d_View)  a3DView = ViewerTest::CurrentView();
1624   if ( Abs(X_Motion - X_ButtonPress) > 2 ) {
1625     static Standard_Real CurZPos = 0.;
1626
1627     //Quantity_Length VDX, VDY;
1628     //a3DView->Size(VDX,VDY);
1629     //Standard_Real VDZ = a3DView->ZSize();
1630     //printf("View size (%lf,%lf,%lf)\n", VDX, VDY, VDZ);
1631
1632     Quantity_Length dx = a3DView->Convert(X_Motion - X_ButtonPress);
1633
1634     // Front = Depth + width/2.
1635     Standard_Real D = 0.5;
1636     Standard_Real W = 0.1;
1637
1638     CurZPos += (dx);
1639
1640     D += CurZPos;
1641
1642     //printf("dx %lf Depth %lf Width %lf\n", dx, D, W);
1643
1644     a3DView->SetZClippingType(V3d_OFF);
1645     a3DView->SetZClippingDepth(D);
1646     a3DView->SetZClippingWidth(W);
1647     a3DView->SetZClippingType(V3d_FRONT);
1648
1649     a3DView->Redraw();
1650
1651     X_ButtonPress = X_Motion;
1652     Y_ButtonPress = Y_Motion;
1653   }
1654 }
1655
1656 //==============================================================================
1657 //function : ProcessControlButton1Motion
1658 //purpose  : Zoom
1659 //==============================================================================
1660
1661 #if defined(_WIN32) || ! defined(__APPLE__) || defined(MACOSX_USE_GLX)
1662 static void ProcessControlButton1Motion()
1663 {
1664   ViewerTest::CurrentView()->Zoom( X_ButtonPress, Y_ButtonPress, X_Motion, Y_Motion);
1665
1666   X_ButtonPress = X_Motion;
1667   Y_ButtonPress = Y_Motion;
1668 }
1669 #endif
1670
1671 //==============================================================================
1672 //function : VT_ProcessControlButton2Motion
1673 //purpose  : Panning
1674 //==============================================================================
1675 void VT_ProcessControlButton2Motion()
1676 {
1677   Standard_Integer aDx = X_Motion - X_ButtonPress;
1678   Standard_Integer aDy = Y_Motion - Y_ButtonPress;
1679
1680   aDy = -aDy; // Xwindow Y axis is from top to Bottom
1681
1682   ViewerTest::CurrentView()->Pan (aDx, aDy);
1683
1684   X_ButtonPress = X_Motion;
1685   Y_ButtonPress = Y_Motion;
1686 }
1687
1688 //==============================================================================
1689 //function : VT_ProcessControlButton3Motion
1690 //purpose  : Rotation
1691 //==============================================================================
1692 void VT_ProcessControlButton3Motion()
1693 {
1694   if (Start_Rot)
1695   {
1696     ViewerTest::CurrentView()->Rotation (X_Motion, Y_Motion);
1697   }
1698 }
1699
1700 //==============================================================================
1701 //function : VT_ProcessMotion
1702 //purpose  :
1703 //==============================================================================
1704 void VT_ProcessMotion()
1705 {
1706   //pre-hilights detected objects at mouse position
1707
1708   Handle(ViewerTest_EventManager) EM = ViewerTest::CurrentEventManager();
1709   EM->MoveTo(X_Motion, Y_Motion);
1710 }
1711
1712
1713 void ViewerTest::GetMousePosition(Standard_Integer& Xpix,Standard_Integer& Ypix)
1714 {
1715   Xpix = X_Motion;Ypix=Y_Motion;
1716 }
1717
1718 //==============================================================================
1719 //function : ViewProject: implements VAxo, VTop, VLeft, ...
1720 //purpose  : Switches to an axonometric, top, left and other views
1721 //==============================================================================
1722
1723 static int ViewProject(Draw_Interpretor& di, const V3d_TypeOfOrientation ori)
1724 {
1725   if ( ViewerTest::CurrentView().IsNull() )
1726   {
1727     di<<"Call vinit before this command, please"<<"\n";
1728     return 1;
1729   }
1730
1731   ViewerTest::CurrentView()->SetProj(ori);
1732   return 0;
1733 }
1734
1735 //==============================================================================
1736 //function : VAxo
1737 //purpose  : Switch to an Axonometric view
1738 //Draw arg : No args
1739 //==============================================================================
1740
1741 static int VAxo(Draw_Interpretor& di, Standard_Integer , const char** )
1742 {
1743   return ViewProject(di, V3d_XposYnegZpos);
1744 }
1745
1746 //==============================================================================
1747 //function : VTop
1748 //purpose  : Switch to a Top View
1749 //Draw arg : No args
1750 //==============================================================================
1751
1752 static int VTop(Draw_Interpretor& di, Standard_Integer , const char** )
1753 {
1754   return ViewProject(di, V3d_Zpos);
1755 }
1756
1757 //==============================================================================
1758 //function : VBottom
1759 //purpose  : Switch to a Bottom View
1760 //Draw arg : No args
1761 //==============================================================================
1762
1763 static int VBottom(Draw_Interpretor& di, Standard_Integer , const char** )
1764 {
1765   return ViewProject(di, V3d_Zneg);
1766 }
1767
1768 //==============================================================================
1769 //function : VLeft
1770 //purpose  : Switch to a Left View
1771 //Draw arg : No args
1772 //==============================================================================
1773
1774 static int VLeft(Draw_Interpretor& di, Standard_Integer , const char** )
1775 {
1776   return ViewProject(di, V3d_Ypos);
1777 }
1778
1779 //==============================================================================
1780 //function : VRight
1781 //purpose  : Switch to a Right View
1782 //Draw arg : No args
1783 //==============================================================================
1784
1785 static int VRight(Draw_Interpretor& di, Standard_Integer , const char** )
1786 {
1787   return ViewProject(di, V3d_Yneg);
1788 }
1789
1790 //==============================================================================
1791 //function : VFront
1792 //purpose  : Switch to a Front View
1793 //Draw arg : No args
1794 //==============================================================================
1795
1796 static int VFront(Draw_Interpretor& di, Standard_Integer , const char** )
1797 {
1798   return ViewProject(di, V3d_Xpos);
1799 }
1800
1801 //==============================================================================
1802 //function : VBack
1803 //purpose  : Switch to a Back View
1804 //Draw arg : No args
1805 //==============================================================================
1806
1807 static int VBack(Draw_Interpretor& di, Standard_Integer , const char** )
1808 {
1809   return ViewProject(di, V3d_Xneg);
1810 }
1811
1812 //==============================================================================
1813 //function : VHelp
1814 //purpose  : Dsiplay help on viewer Keyboead and mouse commands
1815 //Draw arg : No args
1816 //==============================================================================
1817
1818 static int VHelp(Draw_Interpretor& di, Standard_Integer , const char** )
1819 {
1820
1821   di << "Q : Quit the application" << "\n";
1822
1823   di << "========================="<<"\n";
1824   di << "F : FitAll" << "\n";
1825   di << "T : TopView" << "\n";
1826   di << "B : BottomView" << "\n";
1827   di << "R : RightView" << "\n";
1828   di << "L : LeftView" << "\n";
1829   di << "A : AxonometricView" << "\n";
1830   di << "D : ResetView" << "\n";
1831
1832   di << "========================="<<"\n";
1833   di << "S : Shading" << "\n";
1834   di << "W : Wireframe" << "\n";
1835   di << "H : HidelLineRemoval" << "\n";
1836   di << "U : Unset display mode" << "\n";
1837   di << "Delete : Remove selection from viewer" << "\n";
1838
1839   di << "========================="<<"\n";
1840   di << "Selection mode "<<"\n";
1841   di << "0 : Shape" <<"\n";
1842   di << "1 : Vertex" <<"\n";
1843   di << "2 : Edge" <<"\n";
1844   di << "3 : Wire" <<"\n";
1845   di << "4 : Face" <<"\n";
1846   di << "5 : Shell" <<"\n";
1847   di << "6 : Solid" <<"\n";
1848   di << "7 : Compound" <<"\n";
1849
1850   di << "========================="<<"\n";
1851   di << "Z : Switch Z clipping On/Off" << "\n";
1852   di << ", : Hilight next detected" << "\n";
1853   di << ". : Hilight previous detected" << "\n";
1854
1855   return 0;
1856 }
1857
1858 #ifdef WNT
1859
1860 static Standard_Boolean Ppick = 0;
1861 static Standard_Integer Pargc = 0;
1862 static const char**           Pargv = NULL;
1863
1864
1865 static LRESULT WINAPI AdvViewerWindowProc( HWND hwnd,
1866                                           UINT Msg,
1867                                           WPARAM wParam,
1868                                           LPARAM lParam )
1869 {
1870   if (!ViewerTest_myViews.IsEmpty()) {
1871
1872     WPARAM fwKeys = wParam;
1873
1874     switch( Msg ) {
1875     case WM_CLOSE:
1876        {
1877          // Delete view from map of views
1878          ViewerTest::RemoveView(FindViewIdByWindowHandle(hwnd));
1879          return 0;
1880        }
1881        break;
1882     case WM_ACTIVATE:
1883       if(LOWORD(wParam) == WA_CLICKACTIVE || LOWORD(wParam) == WA_ACTIVE
1884         || ViewerTest::CurrentView().IsNull())
1885       {
1886         // Activate inactive window
1887         if(GetWindowHandle(VT_GetWindow()) != hwnd)
1888         {
1889           ActivateView (FindViewIdByWindowHandle(hwnd));
1890         }
1891       }
1892       break;
1893     case WM_LBUTTONUP:
1894       IsDragged = Standard_False;
1895       if( !DragFirst )
1896       {
1897         HDC hdc = GetDC( hwnd );
1898         SelectObject( hdc, GetStockObject( HOLLOW_BRUSH ) );
1899         SetROP2( hdc, R2_NOT );
1900         Rectangle( hdc, X_ButtonPress, Y_ButtonPress, X_Motion, Y_Motion );
1901         ReleaseDC( hwnd, hdc );
1902
1903         const Handle(ViewerTest_EventManager) EM =
1904           ViewerTest::CurrentEventManager();
1905         if ( fwKeys & MK_SHIFT )
1906           EM->ShiftSelect( min( X_ButtonPress, X_Motion ), max( Y_ButtonPress, Y_Motion ),
1907           max( X_ButtonPress, X_Motion ), min( Y_ButtonPress, Y_Motion ));
1908         else
1909           EM->Select( min( X_ButtonPress, X_Motion ), max( Y_ButtonPress, Y_Motion ),
1910           max( X_ButtonPress, X_Motion ), min( Y_ButtonPress, Y_Motion ));
1911       }
1912       return ViewerWindowProc( hwnd, Msg, wParam, lParam );
1913
1914     case WM_LBUTTONDOWN:
1915       if( fwKeys == MK_LBUTTON || fwKeys == ( MK_LBUTTON | MK_SHIFT ) )
1916       {
1917         IsDragged = Standard_True;
1918         DragFirst = Standard_True;
1919         X_ButtonPress = LOWORD(lParam);
1920         Y_ButtonPress = HIWORD(lParam);
1921       }
1922       return ViewerWindowProc( hwnd, Msg, wParam, lParam );
1923
1924       break;
1925
1926     case WM_MOUSEMOVE:
1927       if( IsDragged )
1928       {
1929         HDC hdc = GetDC( hwnd );
1930
1931         HGDIOBJ anObj = SelectObject( hdc, GetStockObject( WHITE_PEN ) );
1932         SelectObject( hdc, GetStockObject( HOLLOW_BRUSH ) );
1933         SetROP2( hdc, R2_NOT );
1934
1935         if( !DragFirst )
1936           Rectangle( hdc, X_ButtonPress, Y_ButtonPress, X_Motion, Y_Motion );
1937
1938         DragFirst = Standard_False;
1939         X_Motion = LOWORD(lParam);
1940         Y_Motion = HIWORD(lParam);
1941
1942         Rectangle( hdc, X_ButtonPress, Y_ButtonPress, X_Motion, Y_Motion );
1943
1944         SelectObject( hdc, anObj );
1945
1946         ReleaseDC( hwnd, hdc );
1947       }
1948       else
1949         return ViewerWindowProc( hwnd, Msg, wParam, lParam );
1950       break;
1951
1952     default:
1953       return ViewerWindowProc( hwnd, Msg, wParam, lParam );
1954     }
1955     return 0;
1956   }
1957   return ViewerWindowProc( hwnd, Msg, wParam, lParam );
1958 }
1959
1960
1961 static LRESULT WINAPI ViewerWindowProc( HWND hwnd,
1962                                        UINT Msg,
1963                                        WPARAM wParam,
1964                                        LPARAM lParam )
1965 {
1966   static int Up = 1;
1967
1968   if ( !ViewerTest::CurrentView().IsNull() ) {
1969     PAINTSTRUCT    ps;
1970
1971     switch( Msg ) {
1972     case WM_PAINT:
1973       BeginPaint(hwnd, &ps);
1974       EndPaint(hwnd, &ps);
1975       VT_ProcessExpose();
1976       break;
1977
1978     case WM_SIZE:
1979       VT_ProcessConfigure();
1980       break;
1981
1982     case WM_KEYDOWN:
1983       if ((wParam != VK_SHIFT) && (wParam != VK_CONTROL))
1984       {
1985         char c[2];
1986         c[0] = (char) wParam;
1987         c[1] = '\0';
1988         if (wParam == VK_DELETE)
1989         {
1990           c[0] = THE_KEY_DELETE;
1991         }
1992         VT_ProcessKeyPress (c);
1993       }
1994       break;
1995
1996     case WM_LBUTTONUP:
1997     case WM_MBUTTONUP:
1998     case WM_RBUTTONUP:
1999       Up = 1;
2000       VT_ProcessButton3Release();
2001       break;
2002
2003     case WM_LBUTTONDOWN:
2004     case WM_MBUTTONDOWN:
2005     case WM_RBUTTONDOWN:
2006       {
2007         WPARAM fwKeys = wParam;
2008
2009         Up = 0;
2010
2011         X_ButtonPress = LOWORD(lParam);
2012         Y_ButtonPress = HIWORD(lParam);
2013
2014         if (Msg == WM_LBUTTONDOWN)
2015         {
2016           if (fwKeys & MK_CONTROL)
2017           {
2018             Ppick = VT_ProcessButton1Press (Pargc, Pargv, Ppick, (fwKeys & MK_SHIFT));
2019           }
2020           else
2021           {
2022             VT_ProcessButton1Press (Pargc, Pargv, Ppick, (fwKeys & MK_SHIFT));
2023           }
2024         }
2025         else if (Msg == WM_RBUTTONDOWN)
2026         {
2027           // Start rotation
2028           VT_ProcessButton3Press();
2029         }
2030       }
2031       break;
2032
2033     case WM_MOUSEMOVE:
2034       {
2035         //cout << "\t WM_MOUSEMOVE" << endl;
2036         WPARAM fwKeys = wParam;
2037         X_Motion = LOWORD(lParam);
2038         Y_Motion = HIWORD(lParam);
2039
2040         if ( Up &&
2041           fwKeys & ( MK_LBUTTON|MK_MBUTTON|MK_RBUTTON ) ) {
2042             Up = 0;
2043             X_ButtonPress = LOWORD(lParam);
2044             Y_ButtonPress = HIWORD(lParam);
2045
2046             if ( fwKeys & MK_RBUTTON ) {
2047               // Start rotation
2048               VT_ProcessButton3Press();
2049             }
2050           }
2051
2052           if ( fwKeys & MK_CONTROL ) {
2053             if ( fwKeys & MK_LBUTTON ) {
2054               ProcessControlButton1Motion();
2055             }
2056             else if ( fwKeys & MK_MBUTTON ||
2057               ((fwKeys&MK_LBUTTON) &&
2058               (fwKeys&MK_RBUTTON) ) ){
2059                 VT_ProcessControlButton2Motion();
2060               }
2061             else if ( fwKeys & MK_RBUTTON ) {
2062               VT_ProcessControlButton3Motion();
2063             }
2064           }
2065 #ifdef BUG
2066           else if ( fwKeys & MK_SHIFT ) {
2067             if ( fwKeys & MK_MBUTTON ||
2068               ((fwKeys&MK_LBUTTON) &&
2069               (fwKeys&MK_RBUTTON) ) ) {
2070                 cout << "ProcessZClipMotion()" << endl;
2071                 ProcessZClipMotion();
2072               }
2073           }
2074 #endif
2075           else if (GetWindowHandle (VT_GetWindow()) == hwnd)
2076           {
2077             if ((fwKeys & MK_MBUTTON
2078             || ((fwKeys & MK_LBUTTON) && (fwKeys & MK_RBUTTON))))
2079             {
2080               ProcessZClipMotion();
2081             }
2082             else
2083             {
2084               VT_ProcessMotion();
2085             }
2086           }
2087       }
2088       break;
2089
2090     default:
2091       return( DefWindowProc( hwnd, Msg, wParam, lParam ));
2092     }
2093     return 0L;
2094   }
2095
2096   return DefWindowProc( hwnd, Msg, wParam, lParam );
2097 }
2098
2099
2100
2101
2102 //==============================================================================
2103 //function : ViewerMainLoop
2104 //purpose  : Get a Event on the view and dispatch it
2105 //==============================================================================
2106
2107
2108 int ViewerMainLoop(Standard_Integer argc, const char** argv)
2109 {
2110   Ppick = (argc > 0)? 1 : 0;
2111   Pargc = argc;
2112   Pargv = argv;
2113
2114   if ( Ppick ) {
2115     MSG msg;
2116     msg.wParam = 1;
2117
2118     cout << "Start picking" << endl;
2119
2120     while ( Ppick == 1 ) {
2121       // Wait for a VT_ProcessButton1Press() to toggle pick to 1 or 0
2122       if (GetMessage(&msg, NULL, 0, 0) ) {
2123         TranslateMessage(&msg);
2124         DispatchMessage(&msg);
2125       }
2126     }
2127
2128     cout << "Picking done" << endl;
2129   }
2130
2131   return Ppick;
2132 }
2133
2134 #elif !defined(__APPLE__) || defined(MACOSX_USE_GLX)
2135
2136 int min( int a, int b )
2137 {
2138   if( a<b )
2139     return a;
2140   else
2141     return b;
2142 }
2143
2144 int max( int a, int b )
2145 {
2146   if( a>b )
2147     return a;
2148   else
2149     return b;
2150 }
2151
2152 int ViewerMainLoop(Standard_Integer argc, const char** argv)
2153
2154 {
2155   static XEvent aReport;
2156   Standard_Boolean pick = argc > 0;
2157   Display *aDisplay = GetDisplayConnection()->GetDisplay();
2158   XNextEvent (aDisplay, &aReport);
2159
2160   // Handle event for the chosen display connection
2161   switch (aReport.type) {
2162       case ClientMessage:
2163         {
2164           if(aReport.xclient.data.l[0] == GetDisplayConnection()->GetAtom(Aspect_XA_DELETE_WINDOW))
2165           {
2166             // Close the window
2167             ViewerTest::RemoveView(FindViewIdByWindowHandle (aReport.xclient.window));
2168           }
2169         }
2170         return 0;
2171      case FocusIn:
2172       {
2173          // Activate inactive view
2174          Window aWindow = GetWindowHandle(VT_GetWindow());
2175          if(aWindow != aReport.xfocus.window)
2176          {
2177            ActivateView (FindViewIdByWindowHandle (aReport.xfocus.window));
2178          }
2179       }
2180       break;
2181       case Expose:
2182         {
2183           VT_ProcessExpose();
2184         }
2185         break;
2186       case ConfigureNotify:
2187         {
2188           VT_ProcessConfigure();
2189         }
2190         break;
2191       case KeyPress:
2192         {
2193
2194           KeySym ks_ret ;
2195           char buf_ret[11] ;
2196           int ret_len ;
2197           XComposeStatus status_in_out;
2198
2199           ret_len = XLookupString( ( XKeyEvent *)&aReport ,
2200             (char *) buf_ret , 10 ,
2201             &ks_ret , &status_in_out ) ;
2202
2203
2204           buf_ret[ret_len] = '\0' ;
2205
2206           if (ret_len)
2207           {
2208             VT_ProcessKeyPress (buf_ret);
2209           }
2210         }
2211         break;
2212       case ButtonPress:
2213         {
2214           X_ButtonPress = aReport.xbutton.x;
2215           Y_ButtonPress = aReport.xbutton.y;
2216
2217           if (aReport.xbutton.button == Button1)
2218           {
2219             if (aReport.xbutton.state & ControlMask)
2220             {
2221               pick = VT_ProcessButton1Press (argc, argv, pick, (aReport.xbutton.state & ShiftMask));
2222             }
2223             else
2224             {
2225               IsDragged = Standard_True;
2226               DragFirst = Standard_True;
2227             }
2228           }
2229           else if (aReport.xbutton.button == Button3)
2230           {
2231             // Start rotation
2232             VT_ProcessButton3Press();
2233           }
2234         }
2235         break;
2236       case ButtonRelease:
2237         {
2238           if( IsDragged )
2239           {
2240             if( !DragFirst )
2241             {
2242               Aspect_Handle aWindow = VT_GetWindow()->XWindow();
2243               GC gc = XCreateGC( aDisplay, aWindow, 0, 0 );
2244               XDrawRectangle( aDisplay, aWindow, gc, min( X_ButtonPress, X_Motion ), min( Y_ButtonPress, Y_Motion ), abs( X_Motion-X_ButtonPress ), abs( Y_Motion-Y_ButtonPress ) );
2245             }
2246
2247             Handle( AIS_InteractiveContext ) aContext = ViewerTest::GetAISContext();
2248             if( aContext.IsNull() )
2249             {
2250               cout << "The context is null. Please use vinit before createmesh" << endl;
2251               return 0;
2252             }
2253
2254             Standard_Boolean ShiftPressed = ( aReport.xbutton.state & ShiftMask );
2255             if( aReport.xbutton.button==1 )
2256               if( DragFirst )
2257                 if( ShiftPressed )
2258                 {
2259                   aContext->ShiftSelect();
2260                 }
2261                 else
2262                 {
2263                   aContext->Select();
2264                 }
2265               else
2266                 if( ShiftPressed )
2267                 {
2268                   aContext->ShiftSelect( min( X_ButtonPress, X_Motion ), min( Y_ButtonPress, Y_Motion ),
2269                     max( X_ButtonPress, X_Motion ), max( Y_ButtonPress, Y_Motion ),
2270                     ViewerTest::CurrentView());
2271                 }
2272                 else
2273                 {
2274                   aContext->Select( min( X_ButtonPress, X_Motion ), min( Y_ButtonPress, Y_Motion ),
2275                     max( X_ButtonPress, X_Motion ), max( Y_ButtonPress, Y_Motion ),
2276                     ViewerTest::CurrentView() );
2277                 }
2278             else
2279               VT_ProcessButton3Release();
2280
2281             IsDragged = Standard_False;
2282           }
2283           else
2284             VT_ProcessButton3Release();
2285         }
2286         break;
2287       case MotionNotify:
2288         {
2289           if (GetWindowHandle (VT_GetWindow()) != aReport.xmotion.window)
2290           {
2291             break;
2292           }
2293           if( IsDragged )
2294           {
2295             Aspect_Handle aWindow = VT_GetWindow()->XWindow();
2296             GC gc = XCreateGC( aDisplay, aWindow, 0, 0 );
2297             XSetFunction( aDisplay, gc, GXinvert );
2298
2299             if( !DragFirst )
2300               XDrawRectangle(aDisplay, aWindow, gc, min( X_ButtonPress, X_Motion ), min( Y_ButtonPress, Y_Motion ), abs( X_Motion-X_ButtonPress ), abs( Y_Motion-Y_ButtonPress ) );
2301
2302             X_Motion = aReport.xmotion.x;
2303             Y_Motion = aReport.xmotion.y;
2304             DragFirst = Standard_False;
2305
2306             XDrawRectangle( aDisplay, aWindow, gc, min( X_ButtonPress, X_Motion ), min( Y_ButtonPress, Y_Motion ), abs( X_Motion-X_ButtonPress ), abs( Y_Motion-Y_ButtonPress ) );
2307           }
2308           else
2309           {
2310             X_Motion = aReport.xmotion.x;
2311             Y_Motion = aReport.xmotion.y;
2312
2313             // remove all the ButtonMotionMaskr
2314             while( XCheckMaskEvent( aDisplay, ButtonMotionMask, &aReport) ) ;
2315
2316             if ( ZClipIsOn && aReport.xmotion.state & ShiftMask ) {
2317               if ( Abs(X_Motion - X_ButtonPress) > 2 ) {
2318
2319                 Quantity_Length VDX, VDY;
2320
2321                 ViewerTest::CurrentView()->Size(VDX,VDY);
2322                 Standard_Real VDZ =0 ;
2323                 VDZ = ViewerTest::CurrentView()->ZSize();
2324
2325                 printf("%f,%f,%f\n", VDX, VDY, VDZ);
2326
2327                 Quantity_Length dx = 0 ;
2328                 dx = ViewerTest::CurrentView()->Convert(X_Motion - X_ButtonPress);
2329
2330                 cout << dx << endl;
2331
2332                 dx = dx / VDX * VDZ;
2333
2334                 cout << dx << endl;
2335
2336                 ViewerTest::CurrentView()->Redraw();
2337               }
2338             }
2339
2340             if ( aReport.xmotion.state & ControlMask ) {
2341               if ( aReport.xmotion.state & Button1Mask ) {
2342                 ProcessControlButton1Motion();
2343               }
2344               else if ( aReport.xmotion.state & Button2Mask ) {
2345                 VT_ProcessControlButton2Motion();
2346               }
2347               else if ( aReport.xmotion.state & Button3Mask ) {
2348                 VT_ProcessControlButton3Motion();
2349               }
2350             }
2351             else
2352             {
2353               VT_ProcessMotion();
2354             }
2355           }
2356         }
2357         break;
2358 }
2359 return pick;
2360 }
2361
2362 //==============================================================================
2363 //function : VProcessEvents
2364 //purpose  : call by Tk_CreateFileHandler() to be able to manage the
2365 //       event in the Viewer window
2366 //==============================================================================
2367
2368 static void VProcessEvents(ClientData,int)
2369 {
2370   NCollection_Vector<int> anEventNumbers;
2371   // Get number of messages from every display
2372   for (NCollection_DoubleMap <TCollection_AsciiString, Handle(Graphic3d_GraphicDriver)>::Iterator
2373        anIter (ViewerTest_myDrivers); anIter.More(); anIter.Next())
2374   {
2375     anEventNumbers.Append(XPending (anIter.Key2()->GetDisplayConnection()->GetDisplay()));
2376   }
2377     // Handle events for every display
2378   int anEventIter = 0;
2379   for (NCollection_DoubleMap <TCollection_AsciiString, Handle(Graphic3d_GraphicDriver)>::Iterator
2380        anIter (ViewerTest_myDrivers); anIter.More(); anIter.Next(), anEventIter++)
2381   {
2382     for (int i = 0; i < anEventNumbers.Value(anEventIter) &&
2383          XPending (anIter.Key2()->GetDisplayConnection()->GetDisplay()) > 0; ++i)
2384     {
2385       SetDisplayConnection (anIter.Key2()->GetDisplayConnection());
2386       int anEventResult = ViewerMainLoop( 0, NULL);
2387       // If window is closed or context was not found finish current event processing loop
2388       if (!anEventResult)
2389         return;
2390     }
2391   }
2392
2393   SetDisplayConnection (ViewerTest::GetAISContext()->CurrentViewer()->Driver()->GetDisplayConnection());
2394
2395 }
2396 #endif
2397
2398 //==============================================================================
2399 //function : OSWindowSetup
2400 //purpose  : Setup for the X11 window to be able to cath the event
2401 //==============================================================================
2402
2403
2404 static void OSWindowSetup()
2405 {
2406 #if !defined(_WIN32) && !defined(__WIN32__) && (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
2407   // X11
2408
2409   Window  window   = VT_GetWindow()->XWindow();
2410   SetDisplayConnection (ViewerTest::CurrentView()->Viewer()->Driver()->GetDisplayConnection());
2411   Display *aDisplay = GetDisplayConnection()->GetDisplay();
2412   XSynchronize(aDisplay, 1);
2413
2414   // X11 : For keyboard on SUN
2415   XWMHints wmhints;
2416   wmhints.flags = InputHint;
2417   wmhints.input = 1;
2418
2419   XSetWMHints( aDisplay, window, &wmhints);
2420
2421   XSelectInput( aDisplay, window,  ExposureMask | KeyPressMask |
2422     ButtonPressMask | ButtonReleaseMask |
2423     StructureNotifyMask |
2424     PointerMotionMask |
2425     Button1MotionMask | Button2MotionMask |
2426     Button3MotionMask | FocusChangeMask
2427     );
2428   Atom aDeleteWindowAtom = GetDisplayConnection()->GetAtom(Aspect_XA_DELETE_WINDOW);
2429   XSetWMProtocols(aDisplay, window, &aDeleteWindowAtom, 1);
2430
2431   XSynchronize(aDisplay, 0);
2432
2433 #else
2434   // WNT
2435 #endif
2436
2437 }
2438
2439
2440 //==============================================================================
2441 //function : VFit
2442
2443 //purpose  : Fitall, no DRAW arguments
2444 //Draw arg : No args
2445 //==============================================================================
2446
2447 static int VFit(Draw_Interpretor& , Standard_Integer , const char** )
2448 {
2449   const Handle(V3d_View) aView = ViewerTest::CurrentView();
2450   Handle(NIS_View) V = Handle(NIS_View)::DownCast(aView);
2451   if (V.IsNull() == Standard_False) {
2452     V->FitAll3d();
2453   } else if (aView.IsNull() == Standard_False) {
2454     aView->FitAll();
2455   }
2456   return 0;
2457 }
2458
2459 //==============================================================================
2460 //function : VZFit
2461 //purpose  : ZFitall, no DRAW arguments
2462 //Draw arg : No args
2463 //==============================================================================
2464 static int VZFit (Draw_Interpretor& /*theDi*/, Standard_Integer theArgsNb, const char** theArgVec)
2465 {
2466   const Handle(V3d_View)& aCurrentView = ViewerTest::CurrentView();
2467
2468   if (aCurrentView.IsNull())
2469   {
2470     std::cout << theArgVec[0] << ": Call vinit before this command, please.\n";
2471     return 1;
2472   }
2473
2474   if (theArgsNb == 1)
2475   {
2476     aCurrentView->ZFitAll();
2477     aCurrentView->Redraw();
2478     return 0;
2479   }
2480
2481   Standard_Real aScale = 1.0;
2482
2483   if (theArgsNb >= 2)
2484   {
2485     aScale = Draw::Atoi (theArgVec[1]);
2486   }
2487
2488   aCurrentView->ZFitAll (aScale);
2489   aCurrentView->Redraw();
2490
2491   return 0;
2492 }
2493
2494 //==============================================================================
2495 //function : VRepaint
2496 //purpose  :
2497 //==============================================================================
2498 static int VRepaint (Draw_Interpretor& , Standard_Integer , const char** )
2499 {
2500   Handle(V3d_View) V = ViewerTest::CurrentView();
2501   if ( !V.IsNull() ) V->Redraw(); return 0;
2502 }
2503
2504 //==============================================================================
2505 //function : VClear
2506 //purpose  : Remove all the object from the viewer
2507 //Draw arg : No args
2508 //==============================================================================
2509
2510 static int VClear(Draw_Interpretor& , Standard_Integer , const char** )
2511 {
2512   Handle(V3d_View) V = ViewerTest::CurrentView();
2513   if(!V.IsNull())
2514     ViewerTest::Clear();
2515   return 0;
2516 }
2517
2518 //==============================================================================
2519 //function : VPick
2520 //purpose  :
2521 //==============================================================================
2522
2523 static int VPick(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
2524 { if (ViewerTest::CurrentView().IsNull() ) return 1;
2525
2526 if ( argc < 4 ) {
2527   di << argv[0] << "Invalid number of arguments" << "\n";
2528   return 1;
2529 }
2530
2531 while (ViewerMainLoop( argc, argv)) {
2532 }
2533
2534 return 0;
2535 }
2536
2537 //==============================================================================
2538 //function : InitViewerTest
2539 //purpose  : initialisation de toutes les variables static de  ViewerTest (dp)
2540 //==============================================================================
2541
2542 void ViewerTest_InitViewerTest (const Handle(AIS_InteractiveContext)& theContext)
2543 {
2544   Handle(V3d_Viewer) aViewer = theContext->CurrentViewer();
2545   ViewerTest::SetAISContext(theContext);
2546   aViewer->InitActiveViews();
2547   Handle(V3d_View) aView = aViewer->ActiveView();
2548   if (aViewer->MoreActiveViews()) ViewerTest::CurrentView(aView);
2549   ViewerTest::ResetEventManager();
2550   Handle(Aspect_Window) aWindow = aView->Window();
2551 #if !defined(_WIN32) && !defined(__WIN32__) && (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
2552   // X11
2553   VT_GetWindow() = Handle(Xw_Window)::DownCast(aWindow);
2554   OSWindowSetup();
2555   static int aFirst = 1;
2556   if ( aFirst ) {
2557 #if TCL_MAJOR_VERSION  < 8
2558     Tk_CreateFileHandler((void*)XConnectionNumber(GetDisplayConnection()->GetDisplay()),
2559       TK_READABLE, VProcessEvents, (ClientData) 0);
2560 #else
2561     Tk_CreateFileHandler(XConnectionNumber(GetDisplayConnection()->GetDisplay()),
2562       TK_READABLE, VProcessEvents, (ClientData) 0);
2563 #endif
2564     aFirst = 0;
2565   }
2566 #endif
2567 }
2568
2569 //==============================================================================
2570 //function : VSetBg
2571 //purpose  : Load image as background
2572 //==============================================================================
2573
2574 static int VSetBg(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
2575 {
2576   if (argc < 2 || argc > 3)
2577   {
2578     di << "Usage : " << argv[0] << " imagefile [filltype] : Load image as background" << "\n";
2579     di << "filltype can be one of CENTERED, TILED, STRETCH, NONE" << "\n";
2580     return 1;
2581   }
2582
2583   Handle(AIS_InteractiveContext) AISContext = ViewerTest::GetAISContext();
2584   if(AISContext.IsNull())
2585   {
2586     di << "use 'vinit' command before " << argv[0] << "\n";
2587     return 1;
2588   }
2589
2590   Aspect_FillMethod aFillType = Aspect_FM_CENTERED;
2591   if (argc == 3)
2592   {
2593     const char* szType = argv[2];
2594     if      (strcmp(szType, "NONE"    ) == 0) aFillType = Aspect_FM_NONE;
2595     else if (strcmp(szType, "CENTERED") == 0) aFillType = Aspect_FM_CENTERED;
2596     else if (strcmp(szType, "TILED"   ) == 0) aFillType = Aspect_FM_TILED;
2597     else if (strcmp(szType, "STRETCH" ) == 0) aFillType = Aspect_FM_STRETCH;
2598     else
2599     {
2600       di << "Wrong fill type : " << szType << "\n";
2601       di << "Must be one of CENTERED, TILED, STRETCH, NONE" << "\n";
2602       return 1;
2603     }
2604   }
2605
2606   Handle(V3d_View) V3dView = ViewerTest::CurrentView();
2607   V3dView->SetBackgroundImage(argv[1], aFillType, Standard_True);
2608
2609   return 0;
2610 }
2611
2612 //==============================================================================
2613 //function : VSetBgMode
2614 //purpose  : Change background image fill type
2615 //==============================================================================
2616
2617 static int VSetBgMode(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
2618 {
2619   if (argc != 2)
2620   {
2621     di << "Usage : " << argv[0] << " filltype : Change background image mode" << "\n";
2622     di << "filltype must be one of CENTERED, TILED, STRETCH, NONE" << "\n";
2623     return 1;
2624   }
2625
2626   Handle(AIS_InteractiveContext) AISContext = ViewerTest::GetAISContext();
2627   if(AISContext.IsNull())
2628   {
2629     di << "use 'vinit' command before " << argv[0] << "\n";
2630     return 1;
2631   }
2632   Aspect_FillMethod aFillType = Aspect_FM_NONE;
2633   const char* szType = argv[1];
2634   if      (strcmp(szType, "NONE"    ) == 0) aFillType = Aspect_FM_NONE;
2635   else if (strcmp(szType, "CENTERED") == 0) aFillType = Aspect_FM_CENTERED;
2636   else if (strcmp(szType, "TILED"   ) == 0) aFillType = Aspect_FM_TILED;
2637   else if (strcmp(szType, "STRETCH" ) == 0) aFillType = Aspect_FM_STRETCH;
2638   else
2639   {
2640     di << "Wrong fill type : " << szType << "\n";
2641     di << "Must be one of CENTERED, TILED, STRETCH, NONE" << "\n";
2642     return 1;
2643   }
2644   Handle(V3d_View) V3dView = ViewerTest::CurrentView();
2645   V3dView->SetBgImageStyle(aFillType, Standard_True);
2646   return 0;
2647 }
2648
2649 //==============================================================================
2650 //function : VSetGradientBg
2651 //purpose  : Mount gradient background
2652 //==============================================================================
2653 static int VSetGradientBg(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
2654 {
2655   if (argc != 8 )
2656   {
2657     di << "Usage : " << argv[0] << " R1 G1 B1 R2 G2 B2 Type : Mount gradient background" << "\n";
2658     di << "R1,G1,B1,R2,G2,B2 = [0..255]" << "\n";
2659     di << "Type must be one of 0 = NONE, 1 = HOR, 2 = VER, 3 = DIAG1, 4 = DIAG2" << "\n";
2660     di << "                    5 = CORNER1, 6 = CORNER2, 7 = CORNER3, 8 = CORNER4" << "\n";
2661     return 1;
2662   }
2663
2664   Handle(AIS_InteractiveContext) AISContext = ViewerTest::GetAISContext();
2665   if(AISContext.IsNull())
2666   {
2667     di << "use 'vinit' command before " << argv[0] << "\n";
2668     return 1;
2669   }
2670   if (argc == 8)
2671   {
2672
2673     Standard_Real R1 = Draw::Atof(argv[1])/255.;
2674     Standard_Real G1 = Draw::Atof(argv[2])/255.;
2675     Standard_Real B1 = Draw::Atof(argv[3])/255.;
2676     Quantity_Color aColor1(R1,G1,B1,Quantity_TOC_RGB);
2677
2678     Standard_Real R2 = Draw::Atof(argv[4])/255.;
2679     Standard_Real G2 = Draw::Atof(argv[5])/255.;
2680     Standard_Real B2 = Draw::Atof(argv[6])/255.;
2681
2682     Quantity_Color aColor2(R2,G2,B2,Quantity_TOC_RGB);
2683     int aType = Draw::Atoi(argv[7]);
2684     if( aType < 0 || aType > 8 )
2685     {
2686       di << "Wrong fill type " << "\n";
2687       di << "Must be one of 0 = NONE, 1 = HOR, 2 = VER, 3 = DIAG1, 4 = DIAG2" << "\n";
2688       di << "               5 = CORNER1, 6 = CORNER2, 7 = CORNER3, 8 = CORNER4" << "\n";
2689       return 1;
2690     }
2691
2692     Aspect_GradientFillMethod aMethod = Aspect_GradientFillMethod(aType);
2693
2694     Handle(V3d_View) V3dView = ViewerTest::CurrentView();
2695     V3dView->SetBgGradientColors( aColor1, aColor2, aMethod, 1);
2696   }
2697
2698   return 0;
2699 }
2700
2701 //==============================================================================
2702 //function : VSetGradientBgMode
2703 //purpose  : Change gradient background fill style
2704 //==============================================================================
2705 static int VSetGradientBgMode(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
2706 {
2707   if (argc != 2 )
2708   {
2709     di << "Usage : " << argv[0] << " Type : Change gradient background fill type" << "\n";
2710     di << "Type must be one of 0 = NONE, 1 = HOR, 2 = VER, 3 = DIAG1, 4 = DIAG2" << "\n";
2711     di << "                    5 = CORNER1, 6 = CORNER2, 7 = CORNER3, 8 = CORNER4" << "\n";
2712     return 1;
2713   }
2714
2715   Handle(AIS_InteractiveContext) AISContext = ViewerTest::GetAISContext();
2716   if(AISContext.IsNull())
2717   {
2718     di << "use 'vinit' command before " << argv[0] << "\n";
2719     return 1;
2720   }
2721   if (argc == 2)
2722   {
2723     int aType = Draw::Atoi(argv[1]);
2724     if( aType < 0 || aType > 8 )
2725     {
2726       di << "Wrong fill type " << "\n";
2727       di << "Must be one of 0 = NONE, 1 = HOR, 2 = VER, 3 = DIAG1, 4 = DIAG2" << "\n";
2728       di << "               5 = CORNER1, 6 = CORNER2, 7 = CORNER3, 8 = CORNER4" << "\n";
2729       return 1;
2730     }
2731
2732     Aspect_GradientFillMethod aMethod = Aspect_GradientFillMethod(aType);
2733
2734     Handle(V3d_View) V3dView = ViewerTest::CurrentView();
2735     V3dView->SetBgGradientStyle( aMethod, 1 );
2736   }
2737
2738   return 0;
2739 }
2740
2741 //==============================================================================
2742 //function : VSetColorBg
2743 //purpose  : Set color background
2744 //==============================================================================
2745 static int VSetColorBg(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
2746 {
2747   if (argc != 4 )
2748   {
2749     di << "Usage : " << argv[0] << " R G B : Set color background" << "\n";
2750     di << "R,G,B = [0..255]" << "\n";
2751     return 1;
2752   }
2753
2754   Handle(AIS_InteractiveContext) AISContext = ViewerTest::GetAISContext();
2755   if(AISContext.IsNull())
2756   {
2757     di << "use 'vinit' command before " << argv[0] << "\n";
2758     return 1;
2759   }
2760   if (argc == 4)
2761   {
2762
2763     Standard_Real R = Draw::Atof(argv[1])/255.;
2764     Standard_Real G = Draw::Atof(argv[2])/255.;
2765     Standard_Real B = Draw::Atof(argv[3])/255.;
2766     Quantity_Color aColor(R,G,B,Quantity_TOC_RGB);
2767
2768     Handle(V3d_View) V3dView = ViewerTest::CurrentView();
2769     V3dView->SetBackgroundColor( aColor );
2770     V3dView->Update();
2771   }
2772
2773   return 0;
2774 }
2775
2776 //==============================================================================
2777 //function : VScale
2778 //purpose  : View Scaling
2779 //==============================================================================
2780
2781 static int VScale(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
2782 {
2783   Handle(V3d_View) V3dView = ViewerTest::CurrentView();
2784   if ( V3dView.IsNull() ) return 1;
2785
2786   if ( argc != 4 ) {
2787     di << argv[0] << "Invalid number of arguments" << "\n";
2788     return 1;
2789   }
2790   V3dView->SetAxialScale( Draw::Atof(argv[1]),  Draw::Atof(argv[2]),  Draw::Atof(argv[3]) );
2791   return 0;
2792 }
2793 //==============================================================================
2794 //function : VTestZBuffTrihedron
2795 //purpose  : Displays a V3d_ZBUFFER'ed or V3d_WIREFRAME'd trihedron
2796 //==============================================================================
2797
2798 static int VTestZBuffTrihedron(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
2799 {
2800   Handle(V3d_View) V3dView = ViewerTest::CurrentView();
2801   if ( V3dView.IsNull() ) return 1;
2802
2803   V3dView->ZBufferTriedronSetup();
2804
2805   if ( argc == 1 ) {
2806     // Set up default trihedron parameters
2807     V3dView->TriedronDisplay( Aspect_TOTP_LEFT_LOWER, Quantity_NOC_WHITE, 0.1, V3d_ZBUFFER );
2808   } else
2809   if ( argc == 7 )
2810   {
2811     Aspect_TypeOfTriedronPosition aPosition = Aspect_TOTP_LEFT_LOWER;
2812     const char* aPosType = argv[1];
2813
2814     if ( strcmp(aPosType, "center") == 0 )
2815     {
2816       aPosition = Aspect_TOTP_CENTER;
2817     } else
2818     if (strcmp(aPosType, "left_lower") == 0)
2819     {
2820       aPosition = Aspect_TOTP_LEFT_LOWER;
2821     } else
2822     if (strcmp(aPosType, "left_upper") == 0)
2823     {
2824       aPosition = Aspect_TOTP_LEFT_UPPER;
2825     } else
2826     if (strcmp(aPosType, "right_lower") == 0)
2827     {
2828       aPosition = Aspect_TOTP_RIGHT_LOWER;
2829     } else
2830     if (strcmp(aPosType, "right_upper") == 0)
2831     {
2832       aPosition = Aspect_TOTP_RIGHT_UPPER;
2833     } else
2834     {
2835       di << argv[1] << " Invalid type of alignment"  << "\n";
2836       di << "Must be one of [ center, left_lower,"   << "\n";
2837       di << "left_upper, right_lower, right_upper ]" << "\n";
2838       return 1;
2839     }
2840
2841     Standard_Real R = Draw::Atof(argv[2])/255.;
2842     Standard_Real G = Draw::Atof(argv[3])/255.;
2843     Standard_Real B = Draw::Atof(argv[4])/255.;
2844     Quantity_Color aColor(R, G, B, Quantity_TOC_RGB);
2845
2846     Standard_Real aScale = Draw::Atof(argv[5]);
2847
2848     if( aScale <= 0.0 )
2849     {
2850       di << argv[5] << " Invalid value. Must be > 0" << "\n";
2851       return 1;
2852     }
2853
2854     V3d_TypeOfVisualization aPresentation = V3d_ZBUFFER;
2855     const char* aPresType = argv[6];
2856
2857     if ( strcmp(aPresType, "wireframe") == 0 )
2858     {
2859       aPresentation = V3d_WIREFRAME;
2860     } else
2861     if (strcmp(aPresType, "zbuffer") == 0)
2862     {
2863       aPresentation = V3d_ZBUFFER;
2864     } else
2865     {
2866       di << argv[6] << " Invalid type of visualization" << "\n";
2867       di << "Must be one of [ wireframe, zbuffer ]"     << "\n";
2868       return 1;
2869     }
2870
2871     V3dView->TriedronDisplay( aPosition, aColor.Name(), aScale, aPresentation );
2872
2873   } else
2874   {
2875     di << argv[0] << " Invalid number of arguments" << "\n";
2876     return 1;
2877   }
2878
2879   V3dView->ZFitAll();
2880
2881   return 0;
2882 }
2883
2884 //==============================================================================
2885 //function : VRotate
2886 //purpose  : Camera Rotating
2887 //==============================================================================
2888
2889 static int VRotate( Draw_Interpretor& di, Standard_Integer argc, const char** argv ) {
2890   Handle(V3d_View) V3dView = ViewerTest::CurrentView();
2891   if ( V3dView.IsNull() ) {
2892     return 1;
2893   }
2894
2895   if ( argc == 4 ) {
2896     V3dView->Rotate( Draw::Atof(argv[1]), Draw::Atof(argv[2]), Draw::Atof(argv[3]) );
2897     return 0;
2898   } else if ( argc == 7 ) {
2899     V3dView->Rotate( Draw::Atof(argv[1]), Draw::Atof(argv[2]), Draw::Atof(argv[3]), Draw::Atof(argv[4]), Draw::Atof(argv[5]), Draw::Atof(argv[6]) );
2900     return 0;
2901   } else {
2902     di << argv[0] << " Invalid number of arguments" << "\n";
2903     return 1;
2904   }
2905 }
2906
2907 //==============================================================================
2908 //function : VZoom
2909 //purpose  : View zoom in / out (relative to current zoom)
2910 //==============================================================================
2911
2912 static int VZoom( Draw_Interpretor& di, Standard_Integer argc, const char** argv ) {
2913   Handle(V3d_View) V3dView = ViewerTest::CurrentView();
2914   if ( V3dView.IsNull() ) {
2915     return 1;
2916   }
2917
2918   if ( argc == 2 ) {
2919     Standard_Real coef = Draw::Atof(argv[1]);
2920     if ( coef <= 0.0 ) {
2921       di << argv[1] << "Invalid value" << "\n";
2922       return 1;
2923     }
2924     V3dView->SetZoom( Draw::Atof(argv[1]) );
2925     return 0;
2926   } else {
2927     di << argv[0] << " Invalid number of arguments" << "\n";
2928     return 1;
2929   }
2930 }
2931
2932 //==============================================================================
2933 //function : VPan
2934 //purpose  : View panning (in pixels)
2935 //==============================================================================
2936
2937 static int VPan( Draw_Interpretor& di, Standard_Integer argc, const char** argv ) {
2938   Handle(V3d_View) V3dView = ViewerTest::CurrentView();
2939   if ( V3dView.IsNull() ) return 1;
2940
2941   if ( argc == 3 ) {
2942     V3dView->Pan( Draw::Atoi(argv[1]), Draw::Atoi(argv[2]) );
2943     return 0;
2944   } else {
2945     di << argv[0] << " Invalid number of arguments" << "\n";
2946     return 1;
2947   }
2948 }
2949
2950
2951 //==============================================================================
2952 //function : VExport
2953 //purpose  : Export the view to a vector graphic format (PS, EMF, PDF)
2954 //==============================================================================
2955
2956 static int VExport(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
2957 {
2958   Handle(V3d_View) V3dView = ViewerTest::CurrentView();
2959   if (V3dView.IsNull())
2960     return 1;
2961
2962   if (argc == 1)
2963   {
2964     std::cout << "Usage: " << argv[0] << " Filename [Format]\n";
2965     return 1;
2966   }
2967
2968   Graphic3d_ExportFormat anExpFormat = Graphic3d_EF_PDF;
2969   TCollection_AsciiString aFormatStr;
2970
2971   TCollection_AsciiString aFileName (argv[1]);
2972   Standard_Integer aLen = aFileName.Length();
2973
2974   if (argc > 2)
2975   {
2976     aFormatStr = TCollection_AsciiString (argv[2]);
2977   }
2978   else if (aLen >= 4)
2979   {
2980     if (aFileName.Value (aLen - 2) == '.')
2981     {
2982       aFormatStr = aFileName.SubString (aLen - 1, aLen);
2983     }
2984     else if (aFileName.Value (aLen - 3) == '.')
2985     {
2986       aFormatStr = aFileName.SubString (aLen - 2, aLen);
2987     }
2988     else
2989     {
2990       std::cout << "Export format couln't be detected from filename '" << argv[1] << "'\n";
2991       return 1;
2992     }
2993   }
2994   else
2995   {
2996     std::cout << "Export format couln't be detected from filename '" << argv[1] << "'\n";
2997     return 1;
2998   }
2999
3000   aFormatStr.UpperCase();
3001   if (aFormatStr == "PS")
3002     anExpFormat = Graphic3d_EF_PostScript;
3003   else if (aFormatStr == "EPS")
3004     anExpFormat = Graphic3d_EF_EnhPostScript;
3005   else if (aFormatStr == "TEX")
3006     anExpFormat = Graphic3d_EF_TEX;
3007   else if (aFormatStr == "PDF")
3008     anExpFormat = Graphic3d_EF_PDF;
3009   else if (aFormatStr == "SVG")
3010     anExpFormat = Graphic3d_EF_SVG;
3011   else if (aFormatStr == "PGF")
3012     anExpFormat = Graphic3d_EF_PGF;
3013   else if (aFormatStr == "EMF")
3014     anExpFormat = Graphic3d_EF_EMF;
3015   else
3016   {
3017     std::cout << "Invalid export format '" << aFormatStr << "'\n";
3018     return 1;
3019   }
3020
3021   try {
3022     if (!V3dView->View()->Export (argv[1], anExpFormat))
3023     {
3024       di << "Error: export of image to " << aFormatStr << " failed!\n";
3025     }
3026   }
3027   catch (Standard_Failure)
3028   {
3029     di << "Error: export of image to " << aFormatStr << " failed";
3030     di << " (exception: " << Standard_Failure::Caught()->GetMessageString() << ")";
3031   }
3032   return 0;
3033 }
3034
3035 //==============================================================================
3036 //function : VColorScale
3037 //purpose  : representation color scale
3038 //==============================================================================
3039 #include <V3d_ColorScale.hxx>
3040
3041 static int VColorScale (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
3042 {
3043   if ( argc != 1 && argc != 4 && argc != 5 && argc != 6 && argc != 8 )
3044   {
3045     di << "Usage : " << argv[0] << " [RangeMin = 0 RangeMax = 100 Intervals = 10 HeightFont = 16 Position = Right X = 0 Y = 0]  " << "\n";
3046     return 1;
3047   }
3048
3049   Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
3050   if(aContext.IsNull()) {
3051     di << argv[0] << " ERROR : use 'vinit' command before " << "\n";
3052     return -1;
3053   }
3054
3055   Standard_Real minRange = 0. , maxRange = 100. ;
3056
3057   Standard_Integer numIntervals = 10 ;
3058   Standard_Integer textHeight = 16;
3059   Aspect_TypeOfColorScalePosition position = Aspect_TOCSP_RIGHT;
3060   Standard_Real X = 0., Y = 0. ;
3061
3062   if ( argc < 9 )
3063   {
3064      if( argc > 3 )
3065      {
3066        minRange = Draw::Atof( argv[1] );
3067        maxRange = Draw::Atof( argv[2] );
3068        numIntervals = Draw::Atoi( argv[3] );
3069      }
3070      if ( argc > 4 )
3071        textHeight = Draw::Atoi( argv[4] );
3072      if ( argc > 5 )
3073        position = (Aspect_TypeOfColorScalePosition)Draw::Atoi( argv[5] );
3074      if ( argc > 7 )
3075      {
3076        X = Draw::Atof( argv[6] );
3077        Y = Draw::Atof( argv[7] );
3078      }
3079   }
3080   Handle(V3d_View) curView = ViewerTest::CurrentView( );
3081   if ( curView.IsNull( ) )
3082     return 1;
3083   Handle(Aspect_ColorScale) aCSV = curView->ColorScale( );
3084   Handle(V3d_ColorScale) aCS = ( Handle( V3d_ColorScale )::DownCast( aCSV ) );
3085   if( ! aCS.IsNull( ) )
3086   {
3087     aCS->SetPosition( X , Y );
3088     aCS->SetHeight( 0.95) ;
3089     aCS->SetTextHeight( textHeight );
3090     aCS->SetRange( minRange , maxRange );
3091     aCS->SetNumberOfIntervals( numIntervals );
3092     aCS->SetLabelPosition( position );
3093     if( !curView->ColorScaleIsDisplayed() )
3094       curView->ColorScaleDisplay( );
3095   }
3096   return 0;
3097 }
3098
3099 //==============================================================================
3100 //function : VGraduatedTrihedron
3101 //purpose  : Displays a graduated trihedron
3102 //==============================================================================
3103
3104 static void AddMultibyteString (TCollection_ExtendedString &name, const char *arg)
3105 {
3106   const char *str = arg;
3107   while (*str)
3108   {
3109     unsigned short c1 = *str++;
3110     unsigned short c2 = *str++;
3111     if (!c1 || !c2) break;
3112     name += (Standard_ExtCharacter)((c1 << 8) | c2);
3113   }
3114 }
3115
3116 static int VGraduatedTrihedron(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
3117 {
3118   // Check arguments
3119   if (argc != 2 && argc < 5)
3120   {
3121     di<<"Error: "<<argv[0]<<" - invalid number of arguments\n";
3122     di<<"Usage: type help "<<argv[0]<<"\n";
3123     return 1; //TCL_ERROR
3124   }
3125
3126   Handle(V3d_View) aV3dView = ViewerTest::CurrentView();
3127
3128   // Create 3D view if it doesn't exist
3129   if ( aV3dView.IsNull() )
3130   {
3131     ViewerTest::ViewerInit();
3132     aV3dView = ViewerTest::CurrentView();
3133     if( aV3dView.IsNull() )
3134     {
3135       di << "Error: Cannot create a 3D view\n";
3136       return 1; //TCL_ERROR
3137     }
3138   }
3139
3140   // Erase (==0) or display (!=0)
3141   const int display = Draw::Atoi(argv[1]);
3142
3143   if (display)
3144   {
3145     // Text font
3146     TCollection_AsciiString font;
3147     if (argc < 6)
3148       font.AssignCat("Courier");
3149     else
3150       font.AssignCat(argv[5]);
3151
3152     // Text is multibyte
3153     const Standard_Boolean isMultibyte = (argc < 7)? Standard_False : (Draw::Atoi(argv[6]) != 0);
3154
3155     // Set axis names
3156     TCollection_ExtendedString xname, yname, zname;
3157     if (argc >= 5)
3158     {
3159       if (isMultibyte)
3160       {
3161         AddMultibyteString(xname, argv[2]);
3162         AddMultibyteString(yname, argv[3]);
3163         AddMultibyteString(zname, argv[4]);
3164       }
3165       else
3166       {
3167         xname += argv[2];
3168         yname += argv[3];
3169         zname += argv[4];
3170       }
3171     }
3172     else
3173     {
3174       xname += "X (mm)";
3175       yname += "Y (mm)";
3176       zname += "Z (mm)";
3177     }
3178
3179     aV3dView->GraduatedTrihedronDisplay(xname, yname, zname,
3180                                         Standard_True/*xdrawname*/, Standard_True/*ydrawname*/, Standard_True/*zdrawname*/,
3181                                         Standard_True/*xdrawvalues*/, Standard_True/*ydrawvalues*/, Standard_True/*zdrawvalues*/,
3182                                         Standard_True/*drawgrid*/,
3183                                         Standard_True/*drawaxes*/,
3184                                         5/*nbx*/, 5/*nby*/, 5/*nbz*/,
3185                                         10/*xoffset*/, 10/*yoffset*/, 10/*zoffset*/,
3186                                         30/*xaxisoffset*/, 30/*yaxisoffset*/, 30/*zaxisoffset*/,
3187                                         Standard_True/*xdrawtickmarks*/, Standard_True/*ydrawtickmarks*/, Standard_True/*zdrawtickmarks*/,
3188                                         10/*xtickmarklength*/, 10/*ytickmarklength*/, 10/*ztickmarklength*/,
3189                                         Quantity_NOC_WHITE/*gridcolor*/,
3190                                         Quantity_NOC_RED/*xnamecolor*/,Quantity_NOC_GREEN/*ynamecolor*/,Quantity_NOC_BLUE1/*znamecolor*/,
3191                                         Quantity_NOC_RED/*xcolor*/,Quantity_NOC_GREEN/*ycolor*/,Quantity_NOC_BLUE1/*zcolor*/,font);
3192   }
3193   else
3194     aV3dView->GraduatedTrihedronErase();
3195
3196   ViewerTest::GetAISContext()->UpdateCurrentViewer();
3197   aV3dView->Redraw();
3198
3199   return 0;
3200 }
3201
3202 //==============================================================================
3203 //function : VPrintView
3204 //purpose  : Test printing algorithm, print the view to image file with given
3205 //           width and height. Printing implemented only for WNT.
3206 //==============================================================================
3207 static int VPrintView (Draw_Interpretor& di, Standard_Integer argc,
3208                        const char** argv)
3209 {
3210 #ifndef WNT
3211   di << "Printing implemented only for wnt!\n";
3212   return 0;
3213 #else
3214
3215   Handle(AIS_InteractiveContext) aContextAIS = NULL;
3216   Handle(V3d_View) aView = NULL;
3217   aContextAIS = ViewerTest::GetAISContext();
3218   if (!aContextAIS.IsNull())
3219   {
3220     const Handle(V3d_Viewer)& Vwr = aContextAIS->CurrentViewer();
3221     Vwr->InitActiveViews();
3222     if(Vwr->MoreActiveViews())
3223       aView = Vwr->ActiveView();
3224   }
3225
3226   // check for errors
3227   if (aView.IsNull())
3228   {
3229     di << "Call vinit before!\n";
3230     return 1;
3231   }
3232   else if (argc < 4)
3233   {
3234     di << "Use: " << argv[0];
3235     di << " width height filename [print algo=0] [tile_width tile_height]\n";
3236     di << "width, height of the intermediate buffer for operation\n";
3237     di << "algo : {0|1}\n";
3238     di << "        0 - stretch algorithm\n";
3239     di << "        1 - tile algorithm\n";
3240     di << "test printing algorithms into an intermediate buffer\n";
3241     di << "using specific tile size if provided\n";
3242     di << "with saving output to an image file\n";
3243     return 1;
3244   }
3245
3246   // get the input params
3247   Standard_Integer aWidth  = Draw::Atoi (argv[1]);
3248   Standard_Integer aHeight = Draw::Atoi (argv[2]);
3249   Standard_Integer aMode   = 0;
3250   TCollection_AsciiString aFileName = TCollection_AsciiString (argv[3]);
3251   if (argc >= 5)
3252     aMode = Draw::Atoi (argv[4]);
3253
3254   Standard_Integer aTileWidth  = 0;
3255   Standard_Integer aTileHeight = 0;
3256   Standard_Boolean isTileSizeProvided = Standard_False;
3257   if (argc == 7)
3258   {
3259     isTileSizeProvided = Standard_True;
3260     aTileWidth  = Draw::Atoi (argv[5]);
3261     aTileHeight = Draw::Atoi (argv[6]);
3262   }
3263
3264   // check the input parameters
3265   if (aWidth <= 0 || aHeight <= 0)
3266   {
3267     di << "Width and height must be positive values!\n";
3268     return 1;
3269   }
3270   if (aMode != 0 && aMode != 1)
3271     aMode = 0;
3272
3273   // define compatible bitmap
3274   HDC anDC = CreateCompatibleDC(0);
3275   BITMAPINFO aBitmapData;
3276   memset (&aBitmapData, 0, sizeof (BITMAPINFOHEADER));
3277   aBitmapData.bmiHeader.biSize          = sizeof (BITMAPINFOHEADER);
3278   aBitmapData.bmiHeader.biWidth         = aWidth ;
3279   aBitmapData.bmiHeader.biHeight        = aHeight;
3280   aBitmapData.bmiHeader.biPlanes        = 1;
3281   aBitmapData.bmiHeader.biBitCount      = 24;
3282   aBitmapData.bmiHeader.biXPelsPerMeter = 0;
3283   aBitmapData.bmiHeader.biYPelsPerMeter = 0;
3284   aBitmapData.bmiHeader.biClrUsed       = 0;
3285   aBitmapData.bmiHeader.biClrImportant  = 0;
3286   aBitmapData.bmiHeader.biCompression   = BI_RGB;
3287   aBitmapData.bmiHeader.biSizeImage     = 0;
3288
3289   // Create Device Independent Bitmap
3290   void* aBitsOut = NULL;
3291   HBITMAP aMemoryBitmap = CreateDIBSection (anDC, &aBitmapData, DIB_RGB_COLORS,
3292                                             &aBitsOut, NULL, 0);
3293   HGDIOBJ anOldBitmap   = SelectObject(anDC, aMemoryBitmap);
3294
3295   Standard_Boolean isSaved = Standard_False, isPrinted = Standard_False;
3296   if (aBitsOut != NULL)
3297   {
3298     if (aMode == 0)
3299       isPrinted = aView->Print(anDC,1,1,0,Aspect_PA_STRETCH);
3300     else
3301     {
3302       if (isTileSizeProvided)
3303       {
3304         Graphic3d_CView* aCView = static_cast<Graphic3d_CView*> (ViewerTest::CurrentView()->View()->CView());
3305         Graphic3d_PtrFrameBuffer anOldBuffer = static_cast<Graphic3d_PtrFrameBuffer> (aCView->ptrFBO);
3306         aCView->ptrFBO = aView->View()->FBOCreate (aTileWidth, aTileHeight);
3307
3308         isPrinted = aView->Print (anDC, 1, 1, 0, Aspect_PA_TILE);
3309
3310         Graphic3d_PtrFrameBuffer aNewBuffer = static_cast<Graphic3d_PtrFrameBuffer> (aCView->ptrFBO);
3311         aView->View()->FBORelease (aNewBuffer);
3312         aCView->ptrFBO = anOldBuffer;
3313       }
3314       else
3315       {
3316         isPrinted = aView->Print (anDC, 1, 1, 0, Aspect_PA_TILE);
3317       }
3318     }
3319
3320     // succesfully printed into an intermediate buffer
3321     if (isPrinted)
3322     {
3323       Image_PixMap aWrapper;
3324       aWrapper.InitWrapper (Image_PixMap::ImgBGR, (Standard_Byte* )aBitsOut, aWidth, aHeight, aWidth * 3 + aWidth % 4);
3325       aWrapper.SetTopDown (false);
3326
3327       Image_AlienPixMap anImageBitmap;
3328       anImageBitmap.InitCopy (aWrapper);
3329       isSaved = anImageBitmap.Save (aFileName);
3330     }
3331     else
3332     {
3333       di << "Print operation failed due to printing errors or\n";
3334       di << "insufficient memory available\n";
3335       di << "Please, try to use smaller dimensions for this test\n";
3336       di << "command, as it allocates intermediate buffer for storing\n";
3337       di << "the result\n";
3338     }
3339   }
3340   else
3341   {
3342     di << "Can't allocate memory for intermediate buffer\n";
3343     di << "Please use smaller dimensions\n";
3344   }
3345
3346   if (aMemoryBitmap)
3347   {
3348     SelectObject (anDC, anOldBitmap);
3349     DeleteObject (aMemoryBitmap);
3350     DeleteDC(anDC);
3351   }
3352
3353   if (!isSaved)
3354   {
3355     di << "Save to file operation failed. This operation may fail\n";
3356     di << "if you don't have enough available memory, then you can\n";
3357     di << "use smaller dimensions for the output file\n";
3358     return 1;
3359   }
3360
3361   return 0;
3362
3363 #endif
3364 }
3365
3366 //==============================================================================
3367 //function : VZLayer
3368 //purpose  : Test z layer operations for v3d viewer
3369 //==============================================================================
3370 static int VZLayer (Draw_Interpretor& di, Standard_Integer argc, const char** argv)
3371 {
3372   Handle(AIS_InteractiveContext) aContextAIS = ViewerTest::GetAISContext ();
3373   if (aContextAIS.IsNull())
3374   {
3375     di << "Call vinit before!\n";
3376     return 1;
3377   }
3378   else if (argc < 2)
3379   {
3380     di << "Use: vzlayer " << argv[0];
3381     di << " add/del/get [id]\n";
3382     di << " add - add new z layer to viewer and print its id\n";
3383     di << " del - del z layer by its id\n";
3384     di << " get - print sequence of z layers in increasing order of their overlay level\n";
3385     di << "id - the layer identificator value defined when removing z layer\n";
3386     return 1;
3387   }
3388
3389   const Handle(V3d_Viewer)& aViewer = aContextAIS->CurrentViewer();
3390   if (aViewer.IsNull())
3391   {
3392     di << "No active viewer!\n";
3393     return 1;
3394   }
3395
3396   // perform operation
3397   TCollection_AsciiString anOp = TCollection_AsciiString (argv[1]);
3398   if (anOp == "add")
3399   {
3400     Standard_Integer aNewId;
3401     if (!aViewer->AddZLayer (aNewId))
3402     {
3403       di << "Impossible to add new z layer!\n";
3404       return 1;
3405     }
3406
3407     di << "New z layer added with index: " << aNewId << "\n";
3408   }
3409   else if (anOp == "del")
3410   {
3411     if (argc < 3)
3412     {
3413       di << "Please also provide as argument id of z layer to remove\n";
3414       return 1;
3415     }
3416
3417     Standard_Integer aDelId = Draw::Atoi (argv[2]);
3418     if (!aViewer->RemoveZLayer (aDelId))
3419     {
3420       di << "Impossible to remove the z layer or invalid id!\n";
3421       return 1;
3422     }
3423
3424     di << "Z layer " << aDelId << " has been removed\n";
3425   }
3426   else if (anOp == "get")
3427   {
3428     TColStd_SequenceOfInteger anIds;
3429     aViewer->GetAllZLayers (anIds);
3430     for (Standard_Integer aSeqIdx = 1; aSeqIdx <= anIds.Length(); aSeqIdx++)
3431     {
3432       di << anIds.Value (aSeqIdx) << " ";
3433     }
3434
3435     di << "\n";
3436   }
3437   else
3438   {
3439     di << "Invalid operation, please use { add / del / get }\n";
3440     return 1;
3441   }
3442
3443   return 0;
3444 }
3445
3446 DEFINE_STANDARD_HANDLE(V3d_TextItem, Visual3d_LayerItem)
3447
3448 // this class provides a presentation of text item in v3d view under-/overlayer
3449 class V3d_TextItem : public Visual3d_LayerItem
3450 {
3451 public:
3452
3453   // CASCADE RTTI
3454   DEFINE_STANDARD_RTTI(V3d_TextItem)
3455
3456   // constructor
3457   Standard_EXPORT V3d_TextItem(const TCollection_AsciiString& theText,
3458                                const Standard_Real theX1,
3459                                const Standard_Real theY1,
3460                                const Standard_Real theHeight,
3461                                const TCollection_AsciiString& theFontName,
3462                                const Quantity_Color& theColor,
3463                                const Quantity_Color& theSubtitleColor,
3464                                const Aspect_TypeOfDisplayText& theTypeOfDisplay,
3465                                const Handle(Visual3d_Layer)& theLayer);
3466
3467   // redraw method
3468   Standard_EXPORT void RedrawLayerPrs();
3469
3470 private:
3471
3472   Standard_Real            myX1;
3473   Standard_Real            myY1;
3474   TCollection_AsciiString  myText;
3475   Standard_Real            myHeight;
3476   Handle(Visual3d_Layer)   myLayer;
3477   Quantity_Color           myColor;
3478   Quantity_Color           mySubtitleColor;
3479   Aspect_TypeOfDisplayText myType;
3480   TCollection_AsciiString  myFontName;
3481 };
3482
3483 IMPLEMENT_STANDARD_HANDLE(V3d_TextItem, Visual3d_LayerItem)
3484 IMPLEMENT_STANDARD_RTTIEXT(V3d_TextItem, Visual3d_LayerItem)
3485
3486 // create and add to display the text item
3487 V3d_TextItem::V3d_TextItem (const TCollection_AsciiString& theText,
3488                             const Standard_Real theX1,
3489                             const Standard_Real theY1,
3490                             const Standard_Real theHeight,
3491                             const TCollection_AsciiString& theFontName,
3492                             const Quantity_Color& theColor,
3493                             const Quantity_Color& theSubtitleColor,
3494                             const Aspect_TypeOfDisplayText& theTypeOfDisplay,
3495                             const Handle(Visual3d_Layer)& theLayer)
3496  : myX1 (theX1), myY1 (theY1),
3497    myText (theText),
3498    myHeight (theHeight),
3499    myLayer (theLayer),
3500    myColor (theColor),
3501    mySubtitleColor (theSubtitleColor),
3502    myType (theTypeOfDisplay),
3503    myFontName (theFontName)
3504 {
3505   if (!myLayer.IsNull ())
3506     myLayer->AddLayerItem (this);
3507 }
3508
3509 // render item
3510 void V3d_TextItem::RedrawLayerPrs ()
3511 {
3512   if (myLayer.IsNull ())
3513     return;
3514
3515   myLayer->SetColor (myColor);
3516   myLayer->SetTextAttributes (myFontName.ToCString (), myType, mySubtitleColor);
3517   myLayer->DrawText (myText.ToCString (), myX1, myY1, myHeight);
3518 }
3519
3520 DEFINE_STANDARD_HANDLE(V3d_LineItem, Visual3d_LayerItem)
3521
3522 // The Visual3d_LayerItem line item for "vlayerline" command
3523 // it provides a presentation of line with user-defined
3524 // linewidth, linetype and transparency.
3525 class V3d_LineItem : public Visual3d_LayerItem
3526 {
3527 public:
3528   // CASCADE RTTI
3529   DEFINE_STANDARD_RTTI(V3d_LineItem)
3530
3531   // constructor
3532   Standard_EXPORT V3d_LineItem(Standard_Real X1, Standard_Real Y1,
3533                                Standard_Real X2, Standard_Real Y2,
3534                                V3d_LayerMgrPointer theLayerMgr,
3535                                Aspect_TypeOfLine theType = Aspect_TOL_SOLID,
3536                                Standard_Real theWidth    = 0.5,
3537                                Standard_Real theTransp   = 1.0);
3538
3539   // redraw method
3540   Standard_EXPORT   void RedrawLayerPrs();
3541
3542 private:
3543
3544   Standard_Real       myX1, myY1, myX2, myY2;
3545   V3d_LayerMgrPointer myLayerMgr;
3546   Aspect_TypeOfLine   myType;
3547   Standard_Real       myWidth;
3548   Standard_Real       myTransparency;
3549 };
3550
3551 IMPLEMENT_STANDARD_HANDLE(V3d_LineItem, Visual3d_LayerItem)
3552 IMPLEMENT_STANDARD_RTTIEXT(V3d_LineItem, Visual3d_LayerItem)
3553
3554 // default constructor for line item
3555 V3d_LineItem::V3d_LineItem(Standard_Real X1, Standard_Real Y1,
3556                            Standard_Real X2, Standard_Real Y2,
3557                            V3d_LayerMgrPointer theLayerMgr,
3558                            Aspect_TypeOfLine theType,
3559                            Standard_Real theWidth,
3560                            Standard_Real theTransp) :
3561   myX1(X1), myY1(Y1), myX2(X2), myY2(Y2), myLayerMgr(theLayerMgr),
3562   myType(theType), myWidth(theWidth), myTransparency(theTransp)
3563 {
3564   if (myLayerMgr && !myLayerMgr->Overlay().IsNull())
3565     myLayerMgr->Overlay()->AddLayerItem (this);
3566 }
3567
3568 // render line
3569 void V3d_LineItem::RedrawLayerPrs ()
3570 {
3571   Handle (Visual3d_Layer) aOverlay;
3572
3573   if (myLayerMgr)
3574     aOverlay = myLayerMgr->Overlay();
3575
3576   if (!aOverlay.IsNull())
3577   {
3578     Quantity_Color aColor(1.0, 0, 0, Quantity_TOC_RGB);
3579     aOverlay->SetColor(aColor);
3580     aOverlay->SetTransparency((Standard_ShortReal)myTransparency);
3581     aOverlay->SetLineAttributes((Aspect_TypeOfLine)myType, myWidth);
3582     aOverlay->BeginPolyline();
3583     aOverlay->AddVertex(myX1, myY1);
3584     aOverlay->AddVertex(myX2, myY2);
3585     aOverlay->ClosePrimitive();
3586   }
3587 }
3588
3589 //=============================================================================
3590 //function : VLayerLine
3591 //purpose  : Draws line in the v3d view layer with given attributes: linetype,
3592 //         : linewidth, transparency coefficient
3593 //============================================================================
3594 static int VLayerLine(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
3595 {
3596   // get the active view
3597   Handle(V3d_View) aView = ViewerTest::CurrentView();
3598   if (aView.IsNull())
3599   {
3600     di << "Call vinit before!\n";
3601     return 1;
3602   }
3603   else if (argc < 5)
3604   {
3605     di << "Use: " << argv[0];
3606     di << " x1 y1 x2 y2 [linewidth = 0.5] [linetype = 0] [transparency = 1]\n";
3607     di << " linetype : { 0 | 1 | 2 | 3 } \n";
3608     di << "              0 - solid  \n";
3609     di << "              1 - dashed \n";
3610     di << "              2 - dot    \n";
3611     di << "              3 - dashdot\n";
3612     di << " transparency : { 0.0 - 1.0 } \n";
3613     di << "                  0.0 - transparent\n";
3614     di << "                  1.0 - visible    \n";
3615     return 1;
3616   }
3617
3618   // get the input params
3619   Standard_Real X1 = Draw::Atof(argv[1]);
3620   Standard_Real Y1 = Draw::Atof(argv[2]);
3621   Standard_Real X2 = Draw::Atof(argv[3]);
3622   Standard_Real Y2 = Draw::Atof(argv[4]);
3623
3624   Standard_Real    aWidth = 0.5;
3625   Standard_Integer aType  = 0;
3626   Standard_Real    aTransparency = 1.0;
3627
3628   // has width
3629   if (argc > 5)
3630     aWidth = Draw::Atof(argv[5]);
3631
3632   // has type
3633   if (argc > 6)
3634      aType = (Standard_Integer) Draw::Atoi(argv[6]);
3635
3636   // has transparency
3637   if (argc > 7)
3638   {
3639     aTransparency = Draw::Atof(argv[7]);
3640     if (aTransparency < 0 || aTransparency > 1.0)
3641       aTransparency = 1.0;
3642   }
3643
3644   // select appropriate line type
3645   Aspect_TypeOfLine aLineType;
3646   switch (aType)
3647   {
3648     case 1:
3649       aLineType = Aspect_TOL_DASH;
3650     break;
3651
3652     case 2:
3653       aLineType = Aspect_TOL_DOT;
3654     break;
3655
3656     case 3:
3657       aLineType = Aspect_TOL_DOTDASH;
3658     break;
3659
3660     default:
3661       aLineType = Aspect_TOL_SOLID;
3662   }
3663
3664   // replace layer manager
3665   Handle(V3d_LayerMgr) aMgr = new V3d_LayerMgr(aView);
3666   aView->SetLayerMgr(aMgr);
3667
3668   // add line item
3669   Handle (V3d_LineItem) anItem = new V3d_LineItem(X1, Y1, X2, Y2,
3670                                                   aMgr.operator->(),
3671                                                   aLineType, aWidth,
3672                                                   aTransparency);
3673
3674   // update view
3675   aView->MustBeResized();
3676   aView->Redraw();
3677
3678   return 0;
3679 }
3680
3681 //=======================================================================
3682 //function : VOverlayText
3683 //purpose  : Test text displaying in view overlay
3684 //=======================================================================
3685 static int VOverlayText (Draw_Interpretor& di, Standard_Integer argc, const char**argv)
3686 {
3687   // get the active view
3688   Handle(V3d_View) aView = ViewerTest::CurrentView();
3689   if (aView.IsNull())
3690   {
3691     di << "No active view. Please call vinit.\n";
3692     return 1;
3693   }
3694   else if (argc < 4 || argc > 13)
3695   {
3696     di << "Use: " << argv[0];
3697     di << " text x y [height] [font_name] [text_color: R G B] [displayType]\n";
3698     di << "[background_color: R G B]\n";
3699     di << "  height - pixel height of the text (default=10.0)\n";
3700     di << "  font_name - name of font (default=courier)\n";
3701     di << "  text_color - R G B values of text color (default=255.0 255.0 255.0)\n";
3702     di << "  display_type = {normal/subtitle/decal/blend/dimension}, (default=normal)\n";
3703     di << "  background_color- R G B values used for subtitle and decal text\n";
3704     di << "(default=255.0 255.0 255.0)\n";
3705     return 1;
3706   }
3707
3708   TCollection_AsciiString aText (argv[1]);
3709   Standard_Real aPosX = Draw::Atof(argv[2]);
3710   Standard_Real aPosY = Draw::Atof(argv[3]);
3711   Standard_Real aHeight = (argc >= 5) ? Draw::Atof (argv[4]) : 10.0;
3712
3713   // font name
3714   TCollection_AsciiString aFontName = "Courier";
3715   if (argc >= 6)
3716     aFontName = TCollection_AsciiString (argv[5]);
3717
3718   // text colors
3719   Quantity_Parameter aColorRed   = 1.0;
3720   Quantity_Parameter aColorGreen = 1.0;
3721   Quantity_Parameter aColorBlue  = 1.0;
3722   if (argc >= 9)
3723   {
3724     aColorRed   = Draw::Atof (argv[6])/255.;
3725     aColorGreen = Draw::Atof (argv[7])/255.;
3726     aColorBlue  = Draw::Atof (argv[8])/255.;
3727   }
3728
3729   // display type
3730   TCollection_AsciiString aDispStr;
3731   if (argc >= 10)
3732     aDispStr = TCollection_AsciiString (argv[9]);
3733
3734   Aspect_TypeOfDisplayText aTextType = Aspect_TODT_NORMAL;
3735   if (aDispStr.IsEqual ("subtitle"))
3736     aTextType = Aspect_TODT_SUBTITLE;
3737   else if (aDispStr.IsEqual ("decal"))
3738     aTextType = Aspect_TODT_DEKALE;
3739   else if (aDispStr.IsEqual ("blend"))
3740     aTextType = Aspect_TODT_BLEND;
3741   else if (aDispStr.IsEqual ("dimension"))
3742     aTextType = Aspect_TODT_DIMENSION;
3743
3744   // subtitle color
3745   Quantity_Parameter aSubRed   = 1.0;
3746   Quantity_Parameter aSubGreen = 1.0;
3747   Quantity_Parameter aSubBlue  = 1.0;
3748   if (argc == 13)
3749   {
3750     aSubRed   = Draw::Atof (argv[10])/255.;
3751     aSubGreen = Draw::Atof (argv[11])/255.;
3752     aSubBlue  = Draw::Atof (argv[12])/255.;
3753   }
3754
3755   // check fo current overlay
3756   Handle(Visual3d_Layer) anOverlay = aView->Viewer()->Viewer()->OverLayer ();
3757   if (anOverlay.IsNull ())
3758   {
3759     Handle(V3d_LayerMgr) aMgr = new V3d_LayerMgr (aView);
3760     anOverlay = aMgr->Overlay ();
3761     aView->SetLayerMgr (aMgr);
3762   }
3763
3764   Quantity_Color aTextColor (aColorRed, aColorGreen,
3765     aColorBlue, Quantity_TOC_RGB);
3766   Quantity_Color aSubtColor (aSubRed, aSubGreen,
3767     aSubBlue, Quantity_TOC_RGB);
3768
3769   // add text item
3770   Handle(V3d_TextItem) anItem = new V3d_TextItem (aText, aPosX, aPosY,
3771     aHeight, aFontName, aTextColor, aSubtColor, aTextType, anOverlay);
3772
3773   // update view
3774   aView->MustBeResized();
3775   aView->Redraw();
3776
3777   return 0;
3778 }
3779
3780 //==============================================================================
3781 //function : VGrid
3782 //purpose  :
3783 //==============================================================================
3784
3785 static int VGrid (Draw_Interpretor& /*theDI*/,
3786                   Standard_Integer  theArgNb,
3787                   const char**      theArgVec)
3788 {
3789   // get the active view
3790   Handle(V3d_View)   aView   = ViewerTest::CurrentView();
3791   Handle(V3d_Viewer) aViewer = ViewerTest::GetViewerFromContext();
3792   if (aView.IsNull() || aViewer.IsNull())
3793   {
3794     std::cerr << "No active view. Please call vinit.\n";
3795     return 1;
3796   }
3797
3798   Aspect_GridType     aType = aViewer->GridType();
3799   Aspect_GridDrawMode aMode = aViewer->GridDrawMode();
3800
3801   Standard_Integer anIter = 1;
3802   for (; anIter < theArgNb; ++anIter)
3803   {
3804     const char* aValue = theArgVec[anIter];
3805     if (*aValue == 'r')
3806     {
3807       aType = Aspect_GT_Rectangular;
3808     }
3809     else if (*aValue == 'c')
3810     {
3811       aType = Aspect_GT_Circular;
3812     }
3813     else if (*aValue == 'l')
3814     {
3815       aMode = Aspect_GDM_Lines;
3816     }
3817     else if (*aValue == 'p')
3818     {
3819       aMode = Aspect_GDM_Points;
3820     }
3821     else if (strcmp (aValue, "off" ) == 0)
3822     {
3823       aViewer->DeactivateGrid();
3824       return 0;
3825     }
3826     else
3827     {
3828       break;
3829     }
3830   }
3831
3832   Standard_Integer aTail = (theArgNb - anIter);
3833   if (aTail == 0)
3834   {
3835     aViewer->ActivateGrid (aType, aMode);
3836     return 0;
3837   }
3838   else if (aTail != 2 && aTail != 5)
3839   {
3840     std::cerr << "Incorrect arguments number! Usage:\n"
3841               << "vgrid [off] [Mode={r|c}] [Type={l|p}] [OriginX OriginY [StepX/StepRadius StepY/DivNb RotAngle]]\n";
3842     return 1;
3843   }
3844
3845   Quantity_Length anOriginX, anOriginY;
3846   Quantity_PlaneAngle aRotAngle;
3847   if (aType == Aspect_GT_Rectangular)
3848   {
3849     Quantity_Length aRStepX, aRStepY;
3850     aViewer->RectangularGridValues (anOriginX, anOriginY, aRStepX, aRStepY, aRotAngle);
3851
3852     anOriginX = Draw::Atof (theArgVec[anIter++]);
3853     anOriginY = Draw::Atof (theArgVec[anIter++]);
3854     if (aTail == 5)
3855     {
3856       aRStepX   = Draw::Atof (theArgVec[anIter++]);
3857       aRStepY   = Draw::Atof (theArgVec[anIter++]);
3858       aRotAngle = Draw::Atof (theArgVec[anIter++]);
3859     }
3860     aViewer->SetRectangularGridValues (anOriginX, anOriginY, aRStepX, aRStepY, aRotAngle);
3861     aViewer->ActivateGrid (aType, aMode);
3862   }
3863   else if (aType == Aspect_GT_Circular)
3864   {
3865     Quantity_Length aRadiusStep;
3866     Standard_Integer aDivisionNumber;
3867     aViewer->CircularGridValues (anOriginX, anOriginY, aRadiusStep, aDivisionNumber, aRotAngle);
3868
3869     anOriginX = Draw::Atof (theArgVec[anIter++]);
3870     anOriginY = Draw::Atof (theArgVec[anIter++]);
3871     if (aTail == 5)
3872     {
3873       aRadiusStep     = Draw::Atof (theArgVec[anIter++]);
3874       aDivisionNumber = Draw::Atoi (theArgVec[anIter++]);
3875       aRotAngle       = Draw::Atof (theArgVec[anIter++]);
3876     }
3877
3878     aViewer->SetCircularGridValues (anOriginX, anOriginY, aRadiusStep, aDivisionNumber, aRotAngle);
3879     aViewer->ActivateGrid (aType, aMode);
3880   }
3881
3882   return 0;
3883 }
3884
3885 //==============================================================================
3886 //function : VFps
3887 //purpose  :
3888 //==============================================================================
3889
3890 static int VFps (Draw_Interpretor& theDI,
3891                  Standard_Integer  theArgNb,
3892                  const char**      theArgVec)
3893 {
3894   // get the active view
3895   Handle(V3d_View) aView = ViewerTest::CurrentView();
3896   if (aView.IsNull())
3897   {
3898     std::cerr << "No active view. Please call vinit.\n";
3899     return 1;
3900   }
3901
3902   Standard_Integer aFramesNb = (theArgNb > 1) ? Draw::Atoi(theArgVec[1]) : 100;
3903   if (aFramesNb <= 0)
3904   {
3905     std::cerr << "Incorrect arguments!\n";
3906     return 1;
3907   }
3908
3909   // the time is meaningless for first call
3910   // due to async OpenGl rendering
3911   aView->Redraw();
3912
3913   // redraw view in loop to estimate average values
3914   OSD_Timer aTimer;
3915   aTimer.Start();
3916   for (Standard_Integer anInter = 0; anInter < aFramesNb; ++anInter)
3917   {
3918     aView->Redraw();
3919   }
3920   aTimer.Stop();
3921   Standard_Real aCpu;
3922   const Standard_Real aTime = aTimer.ElapsedTime();
3923   aTimer.OSD_Chronometer::Show (aCpu);
3924
3925   const Standard_Real aFpsAver = Standard_Real(aFramesNb) / aTime;
3926   const Standard_Real aCpuAver = aCpu / Standard_Real(aFramesNb);
3927
3928   // return statistics
3929   theDI << "FPS: " << aFpsAver << "\n"
3930         << "CPU: " << (1000.0 * aCpuAver) << " msec\n";
3931
3932   return 0;
3933 }
3934
3935 //==============================================================================
3936 //function : VGlDebug
3937 //purpose  :
3938 //==============================================================================
3939
3940 static int VGlDebug (Draw_Interpretor& theDI,
3941                      Standard_Integer  theArgNb,
3942                      const char**      theArgVec)
3943 {
3944   if (theArgNb < 2)
3945   {
3946     Handle(V3d_View) aView = ViewerTest::CurrentView();
3947     if (aView.IsNull())
3948     {
3949       std::cerr << "No active view. Please call vinit.\n";
3950       return 0;
3951     }
3952
3953     Standard_Boolean isActive = OpenGl_Context::CheckExtension ((const char* )glGetString (GL_EXTENSIONS),
3954                                                                 "GL_ARB_debug_output");
3955     std::cout << "Active graphic driver: debug " << (isActive ? "ON" : "OFF") << "\n";
3956     theDI << (isActive ? "1" : "0");
3957     return 0;
3958   }
3959
3960   ViewerTest_myDefaultCaps.contextDebug = Draw::Atoi (theArgVec[1]) != 0;
3961   return 0;
3962 }
3963
3964 //==============================================================================
3965 //function : VVbo
3966 //purpose  :
3967 //==============================================================================
3968
3969 static int VVbo (Draw_Interpretor& theDI,
3970                  Standard_Integer  theArgNb,
3971                  const char**      theArgVec)
3972 {
3973   const Standard_Boolean toSet    = (theArgNb > 1);
3974   const Standard_Boolean toUseVbo = toSet ? (Draw::Atoi (theArgVec[1]) == 0) : 1;
3975   if (toSet)
3976   {
3977     ViewerTest_myDefaultCaps.vboDisable = toUseVbo;
3978   }
3979
3980   // get the context
3981   Handle(AIS_InteractiveContext) aContextAIS = ViewerTest::GetAISContext();
3982   if (aContextAIS.IsNull())
3983   {
3984     if (!toSet)
3985     {
3986       std::cerr << "No active view!\n";
3987     }
3988     return 1;
3989   }
3990   Handle(OpenGl_GraphicDriver) aDriver = Handle(OpenGl_GraphicDriver)::DownCast (aContextAIS->CurrentViewer()->Driver());
3991   if (!aDriver.IsNull())
3992   {
3993     if (!toSet)
3994     {
3995       theDI << (aDriver->Options().vboDisable ? "0" : "1") << "\n";
3996     }
3997     else
3998     {
3999       aDriver->ChangeOptions().vboDisable = toUseVbo;
4000     }
4001   }
4002
4003   return 0;
4004 }
4005
4006 //==============================================================================
4007 //function : VCaps
4008 //purpose  :
4009 //==============================================================================
4010
4011 static int VCaps (Draw_Interpretor& theDI,
4012                   Standard_Integer  theArgNb,
4013                   const char**      theArgVec)
4014 {
4015   OpenGl_Caps* aCaps = &ViewerTest_myDefaultCaps;
4016   Handle(OpenGl_GraphicDriver)   aDriver;
4017   Handle(AIS_InteractiveContext) aContextAIS = ViewerTest::GetAISContext();
4018   if (!aContextAIS.IsNull())
4019   {
4020     aDriver = Handle(OpenGl_GraphicDriver)::DownCast (aContextAIS->CurrentViewer()->Driver());
4021     aCaps   = &aDriver->ChangeOptions();
4022   }
4023
4024   if (theArgNb < 2)
4025   {
4026     theDI << "VBO:     " << (aCaps->vboDisable        ? "0" : "1") << "\n";
4027     theDI << "Sprites: " << (aCaps->pntSpritesDisable ? "0" : "1") << "\n";
4028     theDI << "SoftMode:" << (aCaps->contextNoAccel    ? "1" : "0") << "\n";
4029     return 0;
4030   }
4031
4032   for (Standard_Integer anArgIter = 1; anArgIter < theArgNb; ++anArgIter)
4033   {
4034     const TCollection_AsciiString anArg (theArgVec[anArgIter]);
4035     if (anArg.Search ("vbo=") > -1)
4036     {
4037       aCaps->vboDisable        = anArg.Token ("=", 2).IntegerValue() == 0;
4038     }
4039     else if (anArg.Search ("sprites=") > -1)
4040     {
4041       aCaps->pntSpritesDisable = anArg.Token ("=", 2).IntegerValue() == 0;
4042     }
4043     else if (anArg.Search ("soft=") > -1)
4044     {
4045       aCaps->contextNoAccel = anArg.Token ("=", 2).IntegerValue() != 0;
4046     }
4047     else
4048     {
4049       std::cerr << "Unknown argument: " << anArg << "\n";
4050     }
4051   }
4052   if (aCaps != &ViewerTest_myDefaultCaps)
4053   {
4054     ViewerTest_myDefaultCaps = *aCaps;
4055   }
4056   return 0;
4057 }
4058
4059 //==============================================================================
4060 //function : VMemGpu
4061 //purpose  :
4062 //==============================================================================
4063
4064 static int VMemGpu (Draw_Interpretor& theDI,
4065                     Standard_Integer  theArgNb,
4066                     const char**      theArgVec)
4067 {
4068   // get the context
4069   Handle(AIS_InteractiveContext) aContextAIS = ViewerTest::GetAISContext();
4070   if (aContextAIS.IsNull())
4071   {
4072     std::cerr << "No active view. Please call vinit.\n";
4073     return 1;
4074   }
4075
4076   Handle(Graphic3d_GraphicDriver) aDriver = aContextAIS->CurrentViewer()->Driver();
4077   if (aDriver.IsNull())
4078   {
4079     std::cerr << "Graphic driver not available.\n";
4080     return 1;
4081   }
4082
4083   Standard_Size aFreeBytes = 0;
4084   TCollection_AsciiString anInfo;
4085   if (!aDriver->MemoryInfo (aFreeBytes, anInfo))
4086   {
4087     std::cerr << "Information not available.\n";
4088     return 1;
4089   }
4090
4091   if (theArgNb > 1 && *theArgVec[1] == 'f')
4092   {
4093     theDI << Standard_Real (aFreeBytes);
4094   }
4095   else
4096   {
4097     theDI << anInfo;
4098   }
4099
4100   return 0;
4101 }
4102
4103 // ==============================================================================
4104 // function : VReadPixel
4105 // purpose  :
4106 // ==============================================================================
4107 static int VRe