1e48b74c70160f55ced49b99e5bf0a9ccd312354
[occt.git] / src / Visual3d / Visual3d_View.cxx
1 // Copyright (c) 1995-1999 Matra Datavision
2 // Copyright (c) 1999-2014 OPEN CASCADE SAS
3 //
4 // This file is part of Open CASCADE Technology software library.
5 //
6 // This library is free software; you can redistribute it and/or modify it under
7 // the terms of the GNU Lesser General Public License version 2.1 as published
8 // by the Free Software Foundation, with special exception defined in the file
9 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
10 // distribution for complete text of the license and disclaimer of any warranty.
11 //
12 // Alternatively, this file may be used under the terms of Open CASCADE
13 // commercial license or contractual agreement.
14
15 #ifdef _WIN32
16   #include <windows.h>
17 #endif
18
19 #include <Visual3d_View.ixx>
20
21 #include <Graphic3d_DataStructureManager.hxx>
22 #include <Graphic3d_GraphicDriver.hxx>
23 #include <Graphic3d_MapOfStructure.hxx>
24 #include <Graphic3d_MapIteratorOfMapOfStructure.hxx>
25 #include <Graphic3d_Structure.hxx>
26 #include <Graphic3d_TextureEnv.hxx>
27 #include <Graphic3d_Vector.hxx>
28 #include <Graphic3d_Vertex.hxx>
29 #include <Visual3d_DepthCueingDefinitionError.hxx>
30 #include <Visual3d_Light.hxx>
31 #include <Visual3d_HSequenceOfView.hxx>
32 #include <Visual3d_ZClippingDefinitionError.hxx>
33 #include <OSD.hxx>
34 #include <TColStd_HArray2OfReal.hxx>
35
36 #if defined(_WIN32)
37   #include <WNT_Window.hxx>
38 #elif (defined(__APPLE__) && !defined(MACOSX_USE_GLX))
39   #include <Cocoa_Window.hxx>
40 #else
41   #include <Xw_Window.hxx>
42 #endif
43
44 #include <float.h>
45
46 // =======================================================================
47 // function : Visual3d_View
48 // purpose  :
49 // =======================================================================
50 Visual3d_View::Visual3d_View (const Handle(Visual3d_ViewManager)& theMgr)
51 : myViewManager         (theMgr.operator->()),
52   myIsInComputedMode    (Standard_False),
53   myAutoZFitIsOn        (Standard_True),
54   myAutoZFitScaleFactor (1.0),
55   myStructuresUpdated   (Standard_True)
56 {
57   MyCView.ViewId                  = theMgr->Identification (this);
58   MyCView.Active                  = 0;
59   MyCView.IsDeleted               = 0;
60   MyCView.WsId                    = -1;
61   MyCView.DefWindow.IsDefined     = 0;
62   MyCView.Context.NbActiveLight   = 0;
63   MyCView.Context.ZBufferActivity = -1;
64
65   MyCView.Backfacing    = 0;
66   MyCView.ptrUnderLayer = 0;
67   MyCView.ptrOverLayer  = 0;
68   MyCView.GContext      = 0;
69   MyCView.GDisplayCB    = 0;
70   MyCView.GClientData   = 0;
71
72   myGraphicDriver = myViewManager->GraphicDriver();
73 }
74
75 // =======================================================================
76 // function : SetWindow
77 // purpose  :
78 // =======================================================================
79 void Visual3d_View::SetWindow (const Handle(Aspect_Window)&      theWindow,
80                                const Aspect_RenderingContext     theContext,
81                                const Aspect_GraphicCallbackProc& theDisplayCB,
82                                const Standard_Address            theClientData)
83 {
84   if (IsDeleted())
85   {
86     return;
87   }
88   else if (IsDefined())
89   {
90     Visual3d_ViewDefinitionError::Raise ("Window already defined");
91   }
92
93   MyCView.GContext    = theContext;
94   MyCView.GDisplayCB  = theDisplayCB;
95   MyCView.GClientData = theClientData;
96   SetWindow (theWindow);
97 }
98
99 // =======================================================================
100 // function : SetWindow
101 // purpose  :
102 // =======================================================================
103 void Visual3d_View::SetWindow (const Handle(Aspect_Window)& theWindow)
104 {
105   if (IsDeleted())
106   {
107     return;
108   }
109   else if (IsDefined())
110   {
111     Visual3d_ViewDefinitionError::Raise ("Window already defined");
112   }
113
114   MyWindow = theWindow;
115   MyCView.WsId = MyCView.ViewId;
116   MyCView.DefWindow.IsDefined = 1;
117 #if defined(_WIN32)
118   const Handle(WNT_Window) aWin   = Handle(WNT_Window)::DownCast (theWindow);
119   MyCView.DefWindow.XWindow       = (HWND )(aWin->HWindow());
120   MyCView.DefWindow.XParentWindow = (HWND )(aWin->HParentWindow());
121   WNT_WindowData* aWinData = (WNT_WindowData* )GetWindowLongPtr ((HWND )(aWin->HWindow()), GWLP_USERDATA);
122   aWinData->WNT_WDriver_Ptr = (void* )this;
123   aWinData->WNT_VMgr        = myViewManager;
124 #elif (defined(__APPLE__) && !defined(MACOSX_USE_GLX))
125   const Handle(Cocoa_Window) aWin = Handle(Cocoa_Window)::DownCast (theWindow);
126   MyCView.DefWindow.XWindow       = (Aspect_Drawable )aWin->HView();
127   MyCView.DefWindow.XParentWindow = NULL;
128   //MyCView.DefWindow.XParentWindow = aWin->HParentWindow();
129 #else
130   const Handle(Xw_Window) aWin    = Handle(Xw_Window)::DownCast (theWindow);
131   MyCView.DefWindow.XWindow       = aWin->XWindow();
132   //MyCView.DefWindow.XParentWindow = aWin->XParentWindow();
133 #endif
134
135   Standard_Integer Width, Height;
136   theWindow->Size (Width, Height);
137   MyCView.DefWindow.dx = float(Width);
138   MyCView.DefWindow.dy = float(Height);
139
140   Standard_Real R, G, B;
141   MyBackground = MyWindow->Background ();
142   MyBackground.Color().Values (R, G, B, Quantity_TOC_RGB);
143   MyCView.DefWindow.Background.r = float (R);
144   MyCView.DefWindow.Background.g = float (G);
145   MyCView.DefWindow.Background.b = float (B);
146
147   UpdateView();
148   if (!myGraphicDriver->View (MyCView))
149   {
150     Visual3d_ViewDefinitionError::Raise ("Association failed");
151   }
152
153   MyGradientBackground = MyWindow->GradientBackground();
154   SetGradientBackground(MyGradientBackground,1);
155
156   Standard_Boolean AWait = Standard_False; // => immediate update
157   myGraphicDriver->SetVisualisation (MyCView);
158   myGraphicDriver->AntiAliasing (MyCView, MyContext.AliasingIsOn());
159   myGraphicDriver->DepthCueing  (MyCView, MyContext.DepthCueingIsOn());
160   myGraphicDriver->ClipLimit    (MyCView, AWait);
161   myGraphicDriver->Environment  (MyCView);
162
163   // Make view manager z layer list consistent with the view's list.
164   myViewManager->InstallZLayers (this);
165
166   // Update planses of model clipping
167   UpdatePlanes();
168
169   // Update light sources
170   UpdateLights();
171
172   // Association view-window does not cause the display
173   // of structures that can be displayed in the new view.
174   // In fact, association view-window is done, but the
175   // display is produced only if the view is activated (Activate).
176   SetRatio();
177 }
178
179 // =======================================================================
180 // function : Window
181 // purpose  :
182 // =======================================================================
183 Handle(Aspect_Window) Visual3d_View::Window() const
184 {
185   if (!IsDefined())
186   {
187     Visual3d_ViewDefinitionError::Raise ("Window not defined");
188   }
189   return MyWindow;
190 }
191
192 // =======================================================================
193 // function : IsDefined
194 // purpose  :
195 // =======================================================================
196 Standard_Boolean Visual3d_View::IsDefined() const
197 {
198   return MyCView.DefWindow.IsDefined != 0;
199 }
200
201 // =======================================================================
202 // function : IsDeleted
203 // purpose  :
204 // =======================================================================
205 Standard_Boolean Visual3d_View::IsDeleted() const
206 {
207   return MyCView.IsDeleted != 0;
208 }
209
210 // =======================================================================
211 // function : Destroy
212 // purpose  :
213 // =======================================================================
214 void Visual3d_View::Destroy()
215 {
216   // Since myViewManager can be already destroyed,
217   // avoid attempts to access it in SetBackground()
218   myViewManager = NULL;
219   Remove();
220 }
221
222 // =======================================================================
223 // function : Remove
224 // purpose  :
225 // =======================================================================
226 void Visual3d_View::Remove()
227 {
228   if (IsDeleted()
229   || !IsDefined())
230   {
231     return;
232   }
233
234   myStructsToCompute.Clear();
235   myStructsComputed .Clear();
236   myStructsDisplayed.Clear();
237
238   Aspect_GradientBackground aBlackGrad;
239   SetBackground (Aspect_Background (Quantity_NOC_BLACK));
240   SetGradientBackground (aBlackGrad, Standard_False);
241
242   if (myViewManager != NULL)
243   {
244     myViewManager->UnIdentification (MyCView.ViewId);
245   }
246
247   myGraphicDriver->RemoveView (MyCView);
248
249   MyCView.WsId                = -1;
250   MyCView.IsDeleted           = 1;
251   MyCView.DefWindow.IsDefined = 0;
252
253   MyWindow.Nullify();
254 }
255
256 // =======================================================================
257 // function : Resized
258 // purpose  :
259 // =======================================================================
260 void Visual3d_View::Resized()
261 {
262   if (IsDeleted())
263   {
264     return;
265   }
266   else if (!IsDefined())
267   {
268     Visual3d_ViewDefinitionError::Raise ("Window not defined");
269   }
270   MyWindow->DoResize();
271   SetRatio();
272 }
273
274 // =======================================================================
275 // function : SetRatio
276 // purpose  :
277 // =======================================================================
278 void Visual3d_View::SetRatio()
279 {
280   if (IsDeleted())
281   {
282     return;
283   }
284
285   const Aspect_TypeOfUpdate anUpdateMode = myViewManager->UpdateMode();
286   myViewManager->SetUpdateMode (Aspect_TOU_WAIT);
287
288   Standard_Integer aWidth, aHeight;
289   MyWindow->Size (aWidth, aHeight);
290   if (aWidth > 0 && aHeight > 0)
291   {
292     Standard_Real aRatio = (Standard_Real)aWidth / (Standard_Real)aHeight; 
293
294     MyCView.DefWindow.dx = Standard_ShortReal (aWidth);
295     MyCView.DefWindow.dy = Standard_ShortReal (aHeight);
296
297     myGraphicDriver->RatioWindow (MyCView);
298
299     // Update camera aspect
300     const Handle(Graphic3d_Camera)& aCamera = MyCView.Context.Camera;
301     if (!aCamera.IsNull())
302     {
303       aCamera->SetAspect (aRatio);
304     }
305
306     if (!myDefaultCamera.IsNull())
307     {
308       myDefaultCamera->SetAspect (aRatio);
309     }
310   }
311
312   myViewManager->SetUpdateMode (anUpdateMode);
313   Update (anUpdateMode);
314 }
315
316 // =======================================================================
317 // function : UpdateLights
318 // purpose  :
319 // =======================================================================
320 void Visual3d_View::UpdateLights()
321 {
322   if (IsDeleted()
323    || !IsDefined())
324   {
325     return;
326   }
327
328   if (MyContext.Model() == Visual3d_TOM_NONE)
329   {
330     // activate only a white ambient light
331     Graphic3d_CLight aCLight;
332     aCLight.Type        = Visual3d_TOLS_AMBIENT;
333     aCLight.IsHeadlight = Standard_False;
334     aCLight.Color.r() = aCLight.Color.g() = aCLight.Color.b() = 1.0f;
335
336     MyCView.Context.NbActiveLight = 1;
337     MyCView.Context.ActiveLight   = &aCLight;
338     myGraphicDriver->SetLight (MyCView);
339     MyCView.Context.ActiveLight   = NULL;
340     return;
341   }
342
343   MyCView.Context.NbActiveLight = Min (MyContext.NumberOfActivatedLights(),
344                                        myGraphicDriver->InquireLightLimit());
345   if (MyCView.Context.NbActiveLight < 1)
346   {
347     myGraphicDriver->SetLight (MyCView);
348     return;
349   }
350
351   // parcing of light sources
352   MyCView.Context.ActiveLight = new Graphic3d_CLight[MyCView.Context.NbActiveLight];
353   for (Standard_Integer aLightIter = 0; aLightIter < MyCView.Context.NbActiveLight; ++aLightIter)
354   {
355     MyCView.Context.ActiveLight[aLightIter] = MyContext.ActivatedLight (aLightIter + 1)->CLight();
356   }
357   myGraphicDriver->SetLight (MyCView);
358   delete[] MyCView.Context.ActiveLight;
359   MyCView.Context.ActiveLight = NULL;
360 }
361
362 // =======================================================================
363 // function : UpdatePlanes
364 // purpose  :
365 // =======================================================================
366 void Visual3d_View::UpdatePlanes()
367 {
368   MyCView.Context.ClipPlanes = MyContext.ClipPlanes();
369   if (IsDeleted() || !IsDefined())
370   {
371     return;
372   }
373
374   myGraphicDriver->SetClipPlanes (MyCView);
375 }
376
377 // =======================================================================
378 // function : SetBackground
379 // purpose  :
380 // =======================================================================
381 void Visual3d_View::SetBackground (const Aspect_Background& theBack)
382 {
383   if (IsDeleted())
384   {
385     return;
386   }
387   else if (!IsDefined())
388   {
389     Visual3d_ViewDefinitionError::Raise ("Window not defined");
390   }
391
392   // At this level, only GL can update the background.
393   // It is not necessary to call MyWindow->SetBackground (ABack); as
394   // this method starts update of window background by X
395   // (if the windowing is X)
396
397   Standard_Real R, G, B;
398   MyBackground = theBack;
399   MyBackground.Color().Values (R, G, B, Quantity_TOC_RGB);
400   MyCView.DefWindow.Background.r = float (R);
401   MyCView.DefWindow.Background.g = float (G);
402   MyCView.DefWindow.Background.b = float (B);
403
404   myGraphicDriver->Background (MyCView);
405
406   if (myViewManager != NULL)
407   {
408     Update (myViewManager->UpdateMode());
409   }
410 }
411
412 // =======================================================================
413 // function : SetGradientBackground
414 // purpose  :
415 // =======================================================================
416 void Visual3d_View::SetGradientBackground (const Aspect_GradientBackground& theBack,
417                                            const Standard_Boolean           theToUpdate)
418 {
419   if (IsDeleted())
420   {
421     return;
422   }
423   else if (!IsDefined())
424   {
425     Visual3d_ViewDefinitionError::Raise ("Window not defined");
426   }
427
428   MyGradientBackground = theBack;
429   Quantity_Color aCol1, aCol2;
430   MyGradientBackground.Colors (aCol1, aCol2);
431   myGraphicDriver->GradientBackground (MyCView, aCol1, aCol2, MyGradientBackground.BgGradientFillMethod());
432
433   if (theToUpdate)
434   {
435      Update (Aspect_TOU_ASAP);
436   }
437   else if (myViewManager != NULL)
438   {
439     Update (myViewManager->UpdateMode());
440   }
441 }
442
443 // =======================================================================
444 // function : SetBackgroundImage
445 // purpose  :
446 // =======================================================================
447 void Visual3d_View::SetBackgroundImage (const Standard_CString  theFileName,
448                                         const Aspect_FillMethod theFillStyle,
449                                         const Standard_Boolean  theToUpdate)
450 {
451   if (IsDeleted())
452   {
453     return;
454   }
455   if (!IsDefined())
456   {
457     Visual3d_ViewDefinitionError::Raise ("Window not defined");
458   }
459
460   myGraphicDriver->BackgroundImage (theFileName, MyCView, theFillStyle);
461
462   Update (theToUpdate ? Aspect_TOU_ASAP : myViewManager->UpdateMode());
463 }
464
465 // =======================================================================
466 // function : SetBgImageStyle
467 // purpose  :
468 // =======================================================================
469 void Visual3d_View::SetBgImageStyle (const Aspect_FillMethod theFillStyle,
470                                      const Standard_Boolean  theToUpdate)
471 {
472   if (IsDeleted())
473   {
474     return;
475   }
476   if (!IsDefined())
477   {
478     Visual3d_ViewDefinitionError::Raise ("Window not defined");
479   }
480
481   myGraphicDriver->SetBgImageStyle (MyCView, theFillStyle);
482
483   Update (theToUpdate ? Aspect_TOU_ASAP : myViewManager->UpdateMode());
484 }
485
486 // =======================================================================
487 // function : Background
488 // purpose  :
489 // =======================================================================
490 Aspect_Background Visual3d_View::Background() const
491 {
492   return MyBackground;
493 }
494
495 // =======================================================================
496 // function : SetBgGradientStyle
497 // purpose  :
498 // =======================================================================
499 void Visual3d_View::SetBgGradientStyle (const Aspect_GradientFillMethod theFillStyle,
500                                         const Standard_Boolean          theToUpdate)
501 {
502   if (IsDeleted())
503   {
504     return;
505   }
506   else if (!IsDefined())
507   {
508     Visual3d_ViewDefinitionError::Raise ("Window not defined");
509   }
510
511   myGraphicDriver->SetBgGradientStyle (MyCView, theFillStyle);
512
513   Update (theToUpdate ? Aspect_TOU_ASAP : myViewManager->UpdateMode());
514 }
515
516 // =======================================================================
517 // function : GradientBackground
518 // purpose  :
519 // =======================================================================
520 Aspect_GradientBackground Visual3d_View::GradientBackground() const
521 {
522   return MyGradientBackground;
523 }
524
525 // =======================================================================
526 // function : DefaultCamera
527 // purpose  :
528 // =======================================================================
529 const Handle(Graphic3d_Camera)& Visual3d_View::DefaultCamera() const
530 {
531   return myDefaultCamera;
532 }
533
534 // =======================================================================
535 // function : Camera
536 // purpose  :
537 // =======================================================================
538 const Handle(Graphic3d_Camera)& Visual3d_View::Camera() const
539 {
540   return MyCView.Context.Camera;
541 }
542
543 // =======================================================================
544 // function : SetCamera
545 // purpose  :
546 // =======================================================================
547 void Visual3d_View::SetCamera (const Handle(Graphic3d_Camera)& theCamera)
548 {
549   MyCView.Context.Camera = theCamera;
550
551   myGraphicDriver->SetCamera (MyCView);
552
553   Update (myViewManager->UpdateMode());
554 }
555
556 // =======================================================================
557 // function : SetViewOrientationDefault
558 // purpose  :
559 // =======================================================================
560 void Visual3d_View::SetViewOrientationDefault()
561 {
562   if (myDefaultCamera.IsNull())
563   {
564     myDefaultCamera = new Graphic3d_Camera();
565   }
566
567   myDefaultCamera->CopyOrientationData (MyCView.Context.Camera);
568 }
569
570 // =======================================================================
571 // function : ViewOrientationReset
572 // purpose  :
573 // =======================================================================
574 void Visual3d_View::ViewOrientationReset()
575 {
576   if (IsDeleted())
577   {
578     return;
579   }
580
581   if (!myDefaultCamera.IsNull())
582   {
583     MyCView.Context.Camera->CopyOrientationData (myDefaultCamera);
584   }
585
586   Update (myViewManager->UpdateMode());
587 }
588
589 // =======================================================================
590 // function : SetViewMappingDefault
591 // purpose  :
592 // =======================================================================
593 void Visual3d_View::SetViewMappingDefault()
594 {
595   if (myDefaultCamera.IsNull())
596   {
597     myDefaultCamera = new Graphic3d_Camera();
598   }
599   myDefaultCamera->CopyMappingData (MyCView.Context.Camera);
600 }
601
602 // =======================================================================
603 // function : ViewMappingReset
604 // purpose  :
605 // =======================================================================
606 void Visual3d_View::ViewMappingReset()
607 {
608   if (IsDeleted())
609   {
610     return;
611   }
612
613   if (!myDefaultCamera.IsNull())
614   {
615     MyCView.Context.Camera->CopyMappingData (myDefaultCamera);
616   }
617
618   Update (myViewManager->UpdateMode());
619 }
620
621 // =======================================================================
622 // function : SetContext
623 // purpose  :
624 // =======================================================================
625 void Visual3d_View::SetContext (const Visual3d_ContextView& theViewCtx)
626 {
627   if (IsDeleted())
628   {
629     return;
630   }
631
632   // To manage display only in case of change of visualisation mode
633   const bool isVisModeChanged = theViewCtx.Visualization() != MyContext.Visualization();
634   const bool isModelChanged   = theViewCtx.Model()         != MyContext.Model();
635
636   // To manage antialiasing only in case of change
637   const Standard_Boolean anAliasingModeOld = MyContext.AliasingIsOn();
638   const Standard_Boolean anAliasingModeNew = theViewCtx.AliasingIsOn();
639
640   // To manage the depth cueing only in case of change
641   const Standard_Boolean aDepthCueingModeOld = MyContext.DepthCueingIsOn();
642   const Standard_Boolean aDepthCueingModeNew = theViewCtx.DepthCueingIsOn();
643
644   const Standard_Real aDepthCueingFrontPlaneOld = MyContext.DepthCueingFrontPlane();
645   const Standard_Real aDepthCueingFrontPlaneNew = theViewCtx.DepthCueingFrontPlane();
646   const Standard_Real aDepthCueingBackPlaneOld  = MyContext.DepthCueingBackPlane();
647   const Standard_Real aDepthCueingBackPlaneNew  = theViewCtx.DepthCueingBackPlane();
648
649   // To manage the Zclipping only in case of change
650   const Standard_Boolean aFrontZClippingModeOld = MyContext.FrontZClippingIsOn();
651   const Standard_Boolean aFrontZClippingModeNew = theViewCtx.FrontZClippingIsOn();
652   const Standard_Boolean aBackZClippingModeOld  = MyContext.BackZClippingIsOn();
653   const Standard_Boolean aBackZClippingModeNew  = theViewCtx.BackZClippingIsOn();
654
655   const Standard_Real aZClippingFrontPlaneOld = MyContext.ZClippingFrontPlane();
656   const Standard_Real aZClippingFrontPlaneNew = theViewCtx.ZClippingFrontPlane();
657   const Standard_Real aZClippingBackPlaneOld  = MyContext.ZClippingBackPlane();
658   const Standard_Real aZClippingBackPlaneNew  = theViewCtx.ZClippingBackPlane();
659
660   const bool isTextEnvChanged    = theViewCtx.TextureEnv()    != MyContext.TextureEnv();
661   const bool isSurfDetailChanged = theViewCtx.SurfaceDetail() != MyContext.SurfaceDetail();
662
663   MyContext = theViewCtx;
664
665   UpdateView();
666
667   Standard_Boolean toWait = Standard_False; // => immediate update
668   if (IsDefined())
669   {
670     // management of visualization modes and types of shading.
671     if (isVisModeChanged
672      || isModelChanged)
673     {
674       myGraphicDriver->SetVisualisation (MyCView);
675     }
676
677     // management of antialiasing
678     if (anAliasingModeOld != anAliasingModeNew)
679     {
680       myGraphicDriver->AntiAliasing (MyCView, anAliasingModeNew);
681     }
682
683     // management of depth_cueing
684     if (aDepthCueingModeOld       != aDepthCueingModeNew
685      || aDepthCueingFrontPlaneOld != aDepthCueingFrontPlaneNew
686      || aDepthCueingBackPlaneOld  != aDepthCueingBackPlaneNew)
687     {
688       if (aDepthCueingModeNew
689       &&  aDepthCueingBackPlaneNew >= aDepthCueingFrontPlaneNew)
690       {
691         Visual3d_DepthCueingDefinitionError::Raise ("Bad value for DepthCueingPlanes position");
692       }
693       myGraphicDriver->DepthCueing (MyCView, aDepthCueingModeNew);
694     }
695
696     // management of Zclipping
697     if (aFrontZClippingModeOld  != aFrontZClippingModeNew
698      || aBackZClippingModeOld   != aBackZClippingModeNew
699      || aZClippingFrontPlaneOld != aZClippingFrontPlaneNew
700      || aZClippingBackPlaneOld  != aZClippingBackPlaneNew)
701     {
702       if (aBackZClippingModeNew
703        && aFrontZClippingModeNew
704        && aZClippingBackPlaneNew >= aZClippingFrontPlaneNew)
705       {
706         Visual3d_ZClippingDefinitionError::Raise ("Bad value for ZClippingPlanes position");
707       }
708
709       myGraphicDriver->ClipLimit (MyCView, toWait);
710     }
711
712     // management of textures
713     if (isTextEnvChanged
714      || isSurfDetailChanged)
715     {
716       myGraphicDriver->Environment (MyCView);
717     }
718
719     UpdatePlanes(); // Update of planes of model clipping
720     UpdateLights(); // Update of light sources
721   }
722
723   if (isVisModeChanged)
724   {
725     // Change of context =>
726     // Remove structures that cannot be displayed in the new visualisation mode.
727     // It is not necessary to warn ViewManager as this structure should not disappear from
728     // the list of structures displayed in it.
729     NCollection_Sequence<Handle(Graphic3d_Structure)> aStructs;
730     for (Graphic3d_MapIteratorOfMapOfStructure aStructIter (myStructsDisplayed); aStructIter.More(); aStructIter.Next())
731     {
732       const Handle(Graphic3d_Structure)& aStruct  = aStructIter.Key();
733       const Visual3d_TypeOfAnswer        anAnswer = AcceptDisplay (aStruct);
734       if (anAnswer == Visual3d_TOA_NO
735        || anAnswer == Visual3d_TOA_COMPUTE)
736       {
737         aStructs.Append (aStruct);
738       }
739     }
740     for (NCollection_Sequence<Handle(Graphic3d_Structure)>::Iterator aStructIter (aStructs); aStructIter.More(); aStructIter.Next())
741     {
742       Erase (aStructIter.ChangeValue(), Aspect_TOU_WAIT);
743     }
744     aStructs.Clear();
745
746     // Change of context =>
747     // Display structures that can be displayed with the new visualisation mode.
748     // All structures with status Displayed are removed from the ViewManager
749     // and displayed in the view directly, if the structure is not already
750     // displayed and if the view accepts it in its context.
751     Graphic3d_MapOfStructure aMapDisplayed;
752     myViewManager->DisplayedStructures (aMapDisplayed);
753     for (Graphic3d_MapIteratorOfMapOfStructure aStructIter (aMapDisplayed); aStructIter.More(); aStructIter.Next())
754     {
755       const Handle(Graphic3d_Structure)& aStruct = aStructIter.Key();
756       if (IsDisplayed (aStruct))
757       {
758         continue;
759       }
760
761       const Visual3d_TypeOfAnswer anAnswer = AcceptDisplay (aStruct);
762       if (anAnswer == Visual3d_TOA_YES
763        || anAnswer == Visual3d_TOA_COMPUTE)
764       {
765         aStructs.Append (aStruct);
766       }
767     }
768
769     for (NCollection_Sequence<Handle(Graphic3d_Structure)>::Iterator aStructIter (aStructs); aStructIter.More(); aStructIter.Next())
770     {
771       Display (aStructIter.ChangeValue(), Aspect_TOU_WAIT);
772     }
773   }
774
775   Update (myViewManager->UpdateMode());
776 }
777
778 // =======================================================================
779 // function : Context
780 // purpose  :
781 // =======================================================================
782 const Visual3d_ContextView& Visual3d_View::Context() const
783 {
784   return MyContext;
785 }
786
787 // =======================================================================
788 // function : DisplayedStructures
789 // purpose  :
790 // =======================================================================
791 void Visual3d_View::DisplayedStructures (Graphic3d_MapOfStructure& theStructures) const
792 {
793   if (IsDeleted())
794   {
795     return;
796   }
797
798   for (Graphic3d_MapIteratorOfMapOfStructure aStructIter (myStructsDisplayed); aStructIter.More(); aStructIter.Next())
799   {
800     theStructures.Add (aStructIter.Key());
801   }
802 }
803
804 // =======================================================================
805 // function : Activate
806 // purpose  :
807 // =======================================================================
808 void Visual3d_View::Activate()
809 {
810   if (IsDeleted())
811   {
812     return;
813   }
814   else if (!IsDefined())
815   {
816     Visual3d_ViewDefinitionError::Raise ("Window not defined");
817   }
818
819   if (!IsActive())
820   {
821     myGraphicDriver->ActivateView (MyCView);
822     myGraphicDriver->Background   (MyCView);
823     myGraphicDriver->Transparency (MyCView, myViewManager->Transparency());
824
825     MyCView.Active = 1;
826
827     // Activation of a new view =>
828     // Display structures that can be displayed in this new view.
829     // All structures with status
830     // Displayed in ViewManager are returned and displayed in
831     // the view directly, if the structure is not already
832     // displayed and if the view accepts it in its context.
833     Graphic3d_MapOfStructure aDisplayedStructs;
834     myViewManager->DisplayedStructures (aDisplayedStructs);
835     for (Graphic3d_MapIteratorOfMapOfStructure aStructIter (aDisplayedStructs); aStructIter.More(); aStructIter.Next())
836     {
837       const Handle(Graphic3d_Structure)& aStruct = aStructIter.Key();
838       if (IsDisplayed (aStruct))
839       {
840         continue;
841       }
842
843       // If the structure can be displayed in the new context of the view, it is displayed.
844       const Visual3d_TypeOfAnswer anAnswer = AcceptDisplay (aStruct);
845       if (anAnswer == Visual3d_TOA_YES
846        || anAnswer == Visual3d_TOA_COMPUTE)
847       {
848         Display (aStruct, Aspect_TOU_WAIT);
849       }
850     }
851   }
852
853   // If the activation/desactivation of ZBuffer should be automatic
854   // depending on the presence or absence of facets.
855   if (myViewManager->ZBufferAuto())
856   {
857     const Standard_Boolean containsFacet = ContainsFacet();
858     const Standard_Boolean hasZBuffer    = ZBufferIsActivated();
859     if (containsFacet && !hasZBuffer)
860     {
861       SetZBufferActivity (1); // If the view contains facets and if ZBuffer is not active
862     }
863     else if (!containsFacet && hasZBuffer)
864     {
865       SetZBufferActivity (0); // If the view does not contain facets and if ZBuffer is active
866     }
867   }
868
869   Update (myViewManager->UpdateMode());
870 }
871
872 // =======================================================================
873 // function : IsActive
874 // purpose  :
875 // =======================================================================
876 Standard_Boolean Visual3d_View::IsActive() const
877 {
878   return !IsDeleted()
879       &&  MyCView.Active;
880 }
881
882 // =======================================================================
883 // function : Deactivate
884 // purpose  :
885 // =======================================================================
886 void Visual3d_View::Deactivate()
887 {
888   if (IsDeleted())
889   {
890     return;
891   }
892   else if (!IsDefined())
893   {
894     Visual3d_ViewDefinitionError::Raise ("Window not defined");
895   }
896
897   if (IsActive())
898   {
899     myGraphicDriver->DeactivateView (MyCView);
900
901     // Deactivation of a view =>
902     // Removal of structures displayed in this view.
903     // All structures with status
904     // Displayed in ViewManager are returned and removed from
905     // the view directly, if the structure is not already
906     // displayed and if the view accepts it in its context.
907     Graphic3d_MapOfStructure aDisplayedStructs;
908     myViewManager->DisplayedStructures (aDisplayedStructs);
909     for (Graphic3d_MapIteratorOfMapOfStructure aStructIter (aDisplayedStructs); aStructIter.More(); aStructIter.Next())
910     {
911       const Handle(Graphic3d_Structure)& aStruct = aStructIter.Key();
912       if (IsDisplayed (aStruct))
913       {
914         continue;
915       }
916
917       const Visual3d_TypeOfAnswer anAnswer = AcceptDisplay (aStruct);
918       if (anAnswer == Visual3d_TOA_YES
919        || anAnswer == Visual3d_TOA_COMPUTE)
920       {
921         Erase (aStruct, Aspect_TOU_WAIT);
922       }
923     }
924
925     Update (myViewManager->UpdateMode());
926     MyCView.Active = 0; // No action currently possible in the view
927   }
928 }
929
930 // =======================================================================
931 // function : Redraw
932 // purpose  :
933 // =======================================================================
934 void Visual3d_View::Redraw()
935 {
936   Redraw (myViewManager->UnderLayer(), myViewManager->OverLayer(), 0, 0, 0, 0);
937 }
938
939 // =======================================================================
940 // function : Redraw
941 // purpose  :
942 // =======================================================================
943 void Visual3d_View::Redraw (const Standard_Integer theX,
944                             const Standard_Integer theY,
945                             const Standard_Integer theWidth,
946                             const Standard_Integer theHeight)
947 {
948   Redraw (myViewManager->UnderLayer(), myViewManager->OverLayer(),
949           theX, theY, theWidth, theHeight);
950 }
951
952 // =======================================================================
953 // function : Redraw
954 // purpose  :
955 // =======================================================================
956 void Visual3d_View::Redraw (const Handle(Visual3d_Layer)& theUnderLayer,
957                             const Handle(Visual3d_Layer)& theOverLayer)
958 {
959   Redraw (theUnderLayer, theOverLayer, 0, 0, 0, 0);
960 }
961
962 // =======================================================================
963 // function : Redraw
964 // purpose  :
965 // =======================================================================
966 void Visual3d_View::Redraw (const Handle(Visual3d_Layer)& theUnderLayer,
967                             const Handle(Visual3d_Layer)& theOverLayer,
968                             const Standard_Integer        theX,
969                             const Standard_Integer        theY,
970                             const Standard_Integer        theWidth,
971                             const Standard_Integer        theHeight)
972 {
973   if (IsDeleted()
974    || !IsDefined()
975    || !IsActive()
976    || !MyWindow->IsMapped())
977   {
978     return;
979   }
980
981   Aspect_CLayer2d anOverCLayer, anUnderCLayer;
982   anOverCLayer.ptrLayer = anUnderCLayer.ptrLayer = NULL;
983   if (!theOverLayer .IsNull()) anOverCLayer  = theOverLayer ->CLayer();
984   if (!theUnderLayer.IsNull()) anUnderCLayer = theUnderLayer->CLayer();
985
986   for (Standard_Integer aRetryIter = 0; aRetryIter < 2; ++aRetryIter)
987   {
988     if (myGraphicDriver->IsDeviceLost())
989     {
990       myViewManager->RecomputeStructures();
991       myViewManager->RecomputeStructures (myImmediateStructures);
992       myGraphicDriver->ResetDeviceLostFlag();
993     }
994
995     // set up Z buffer state before redrawing
996     if (myViewManager->ZBufferAuto())
997     {
998       const Standard_Boolean hasFacet   = ContainsFacet();
999       const Standard_Boolean hasZBuffer = ZBufferIsActivated();
1000       // if the view contains facets and if ZBuffer is not active
1001       if (hasFacet && !hasZBuffer)
1002       {
1003         SetZBufferActivity (1);
1004       }
1005       // if the view contains only facets and if ZBuffer is active
1006       if (!hasFacet && hasZBuffer)
1007       {
1008         SetZBufferActivity (0);
1009       }
1010     }
1011
1012     if (myStructuresUpdated)
1013     {
1014       AutoZFit();
1015       myStructuresUpdated = Standard_False;
1016     }
1017
1018     myGraphicDriver->Redraw (MyCView, anUnderCLayer, anOverCLayer, theX, theY, theWidth, theHeight);
1019     if (!myGraphicDriver->IsDeviceLost())
1020     {
1021       return;
1022     }
1023   }
1024 }
1025
1026 // =======================================================================
1027 // function : RedrawImmediate
1028 // purpose  :
1029 // =======================================================================
1030 void Visual3d_View::RedrawImmediate()
1031 {
1032   RedrawImmediate (myViewManager->UnderLayer(), myViewManager->OverLayer());
1033 }
1034
1035 // =======================================================================
1036 // function : RedrawImmediate
1037 // purpose  :
1038 // =======================================================================
1039 void Visual3d_View::RedrawImmediate (const Handle(Visual3d_Layer)& theUnderLayer,
1040                                      const Handle(Visual3d_Layer)& theOverLayer)
1041 {
1042   if (IsDeleted()
1043    || !IsDefined()
1044    || !IsActive()
1045    || !MyWindow->IsMapped())
1046   {
1047     return;
1048   }
1049
1050   Aspect_CLayer2d anOverCLayer, anUnderCLayer;
1051   anOverCLayer.ptrLayer = anUnderCLayer.ptrLayer = NULL;
1052   if (!theOverLayer .IsNull()) anOverCLayer  = theOverLayer ->CLayer();
1053   if (!theUnderLayer.IsNull()) anUnderCLayer = theUnderLayer->CLayer();
1054   myGraphicDriver->RedrawImmediate (MyCView, anUnderCLayer, anOverCLayer);
1055 }
1056
1057 // =======================================================================
1058 // function : Invalidate
1059 // purpose  :
1060 // =======================================================================
1061 void Visual3d_View::Invalidate()
1062 {
1063   myGraphicDriver->Invalidate (MyCView);
1064 }
1065
1066 // =======================================================================
1067 // function : Update
1068 // purpose  :
1069 // =======================================================================
1070 void Visual3d_View::Update (Aspect_TypeOfUpdate theUpdateMode)
1071 {
1072   myStructuresUpdated = Standard_True;
1073   if (theUpdateMode == Aspect_TOU_ASAP)
1074   {
1075     Compute();
1076     Redraw (myViewManager->UnderLayer(), myViewManager->OverLayer(), 0, 0, 0, 0);
1077   }
1078 }
1079
1080 // =======================================================================
1081 // function : Update
1082 // purpose  :
1083 // =======================================================================
1084 void Visual3d_View::Update (const Handle(Visual3d_Layer)& theUnderLayer,
1085                             const Handle(Visual3d_Layer)& theOverLayer)
1086 {
1087   Compute();
1088   myStructuresUpdated = Standard_True;
1089   Redraw (theUnderLayer, theOverLayer, 0, 0, 0, 0);
1090 }
1091
1092 // ========================================================================
1093 // function : SetAutoZFitMode
1094 // purpose  :
1095 // ========================================================================
1096 void Visual3d_View::SetAutoZFitMode (const Standard_Boolean theIsOn,
1097                                      const Standard_Real    theScaleFactor)
1098 {
1099   Standard_ASSERT_RAISE (theScaleFactor > 0.0, "Zero or negative scale factor is not allowed.");
1100   myAutoZFitScaleFactor = theScaleFactor;
1101   myAutoZFitIsOn = theIsOn;
1102 }
1103
1104 // ========================================================================
1105 // function : AutoZFitMode
1106 // purpose  :
1107 // ========================================================================
1108 Standard_Boolean Visual3d_View::AutoZFitMode() const
1109 {
1110   return myAutoZFitIsOn;
1111 }
1112
1113 // ========================================================================
1114 // function : AutoZFitScaleFactor
1115 // purpose  :
1116 // ========================================================================
1117 Standard_Real Visual3d_View::AutoZFitScaleFactor() const
1118 {
1119   return myAutoZFitScaleFactor;
1120 }
1121
1122 // ========================================================================
1123 // function : AutoZFit
1124 // purpose  :
1125 // ========================================================================
1126 void Visual3d_View::AutoZFit()
1127 {
1128   if (!AutoZFitMode())
1129   {
1130     return;
1131   }
1132
1133   ZFitAll (myAutoZFitScaleFactor);
1134 }
1135
1136 // ========================================================================
1137 // function : ZFitAll
1138 // purpose  :
1139 // ========================================================================
1140 void Visual3d_View::ZFitAll (const Standard_Real theScaleFactor)
1141 {
1142   Standard_Real aMinMax[6];    // applicative min max boundaries
1143   MinMaxValues (aMinMax[0], aMinMax[1], aMinMax[2],
1144     aMinMax[3], aMinMax[4], aMinMax[5],
1145     Standard_False);
1146
1147   Standard_Real aGraphicBB[6]; // real graphical boundaries (not accounting infinite flag).
1148   MinMaxValues (aGraphicBB[0], aGraphicBB[1], aGraphicBB[2],
1149     aGraphicBB[3], aGraphicBB[4], aGraphicBB[5],
1150     Standard_True);
1151
1152   Bnd_Box aMinMaxBox;
1153   Bnd_Box aGraphicBox;
1154
1155   aMinMaxBox.Update (aMinMax[0], aMinMax[1], aMinMax[2],
1156     aMinMax[3], aMinMax[4], aMinMax[5]);
1157
1158   aGraphicBox.Update (aGraphicBB[0], aGraphicBB[1], aGraphicBB[2],
1159     aGraphicBB[3], aGraphicBB[4], aGraphicBB[5]);
1160
1161   const Handle(Graphic3d_Camera)& aCamera = MyCView.Context.Camera;
1162   aCamera->ZFitAll (theScaleFactor, aMinMaxBox, aGraphicBox);
1163 }
1164
1165 // ========================================================================
1166 // function : AcceptDisplay
1167 // purpose  :
1168 // ========================================================================
1169 Visual3d_TypeOfAnswer Visual3d_View::AcceptDisplay (const Handle(Graphic3d_Structure)& theStruct) const
1170 {
1171   const Visual3d_TypeOfVisualization ViewType = MyContext.Visualization();
1172   switch (theStruct->Visual())
1173   {
1174     case Graphic3d_TOS_ALL:
1175     {
1176       return Visual3d_TOA_YES; // The structure accepts any type of view
1177     }
1178     case Graphic3d_TOS_SHADING:
1179     {
1180       return ViewType == Visual3d_TOV_SHADING
1181            ? Visual3d_TOA_YES
1182            : Visual3d_TOA_NO;
1183     }
1184     case Graphic3d_TOS_WIREFRAME:
1185     {
1186       return ViewType == Visual3d_TOV_WIREFRAME
1187            ? Visual3d_TOA_YES
1188            : Visual3d_TOA_NO;
1189     }
1190     case Graphic3d_TOS_COMPUTED:
1191     {
1192       return (ViewType == Visual3d_TOV_SHADING || ViewType == Visual3d_TOV_WIREFRAME)
1193            ?  Visual3d_TOA_COMPUTE
1194            :  Visual3d_TOA_NO;
1195     }
1196   }
1197   return Visual3d_TOA_NO;
1198 }
1199
1200 // ========================================================================
1201 // function : ChangeDisplayPriority
1202 // purpose  :
1203 // ========================================================================
1204 void Visual3d_View::ChangeDisplayPriority (const Handle(Graphic3d_Structure)& theStruct,
1205                                            const Standard_Integer           /*theOldPriority*/,
1206                                            const Standard_Integer             theNewPriority)
1207 {
1208   if (IsDeleted()
1209   || !IsDefined()
1210   || !IsActive()
1211   || !IsDisplayed (theStruct))
1212   {
1213     return;
1214   }
1215
1216   if (!myIsInComputedMode)
1217   {
1218     myGraphicDriver->ChangePriority (*theStruct->CStructure(), MyCView, theNewPriority);
1219     return;
1220   }
1221
1222   const Standard_Integer      anIndex  = IsComputed (theStruct);
1223   const Graphic3d_CStructure& aCStruct = anIndex != 0
1224                                        ? *(myStructsComputed.Value (anIndex)->CStructure())
1225                                        : *theStruct->CStructure();
1226   myGraphicDriver->ChangePriority (aCStruct, MyCView, theNewPriority);
1227 }
1228
1229 // ========================================================================
1230 // function : Clear
1231 // purpose  :
1232 // ========================================================================
1233 void Visual3d_View::Clear (const Handle(Graphic3d_Structure)& theStruct,
1234                            const Standard_Boolean             theWithDestruction)
1235 {
1236   const Standard_Integer anIndex = IsComputed (theStruct);
1237   if (anIndex != 0)
1238   {
1239     const Handle(Graphic3d_Structure)& aCompStruct = myStructsComputed.Value (anIndex);
1240     aCompStruct->GraphicClear (theWithDestruction);
1241     aCompStruct->SetHLRValidation (Standard_False);
1242   }
1243 }
1244
1245 // ========================================================================
1246 // function : Connect
1247 // purpose  :
1248 // ========================================================================
1249 void Visual3d_View::Connect (const Handle(Graphic3d_Structure)& theMother,
1250                              const Handle(Graphic3d_Structure)& theDaughter)
1251 {
1252   Standard_Integer anIndexM = IsComputed (theMother);
1253   Standard_Integer anIndexD = IsComputed (theDaughter);
1254   if (anIndexM != 0
1255    && anIndexD != 0)
1256   {
1257     const Handle(Graphic3d_Structure)& aStructM = myStructsComputed.Value (anIndexM);
1258     const Handle(Graphic3d_Structure)& aStructD = myStructsComputed.Value (anIndexD);
1259     aStructM->GraphicConnect (aStructD);
1260   }
1261 }
1262
1263 // ========================================================================
1264 // function : Disconnect
1265 // purpose  :
1266 // ========================================================================
1267 void Visual3d_View::Disconnect (const Handle(Graphic3d_Structure)& theMother,
1268                                 const Handle(Graphic3d_Structure)& theDaughter)
1269 {
1270   Standard_Integer anIndexM = IsComputed (theMother);
1271   Standard_Integer anIndexD = IsComputed (theDaughter);
1272   if (anIndexM != 0
1273    && anIndexD != 0)
1274   {
1275     const Handle(Graphic3d_Structure)& aStructM = myStructsComputed.Value (anIndexM);
1276     const Handle(Graphic3d_Structure)& aStructD = myStructsComputed.Value (anIndexD);
1277     aStructM->GraphicDisconnect (aStructD);
1278   }
1279 }
1280
1281 // ========================================================================
1282 // function : DisplayImmediate
1283 // purpose  :
1284 // ========================================================================
1285 Standard_Boolean Visual3d_View::DisplayImmediate (const Handle(Graphic3d_Structure)& theStructure,
1286                                                   const Standard_Boolean             theIsSingleView)
1287 {
1288   if (!myImmediateStructures.Add (theStructure))
1289   {
1290     return Standard_False;
1291   }
1292
1293   if (theIsSingleView)
1294   {
1295     Handle(Visual3d_HSequenceOfView) aViews = myViewManager->DefinedView();
1296
1297     for (int i=1;i<=aViews->Length();i++)
1298     {
1299       if (aViews->Value(i).Access() != this)
1300       {
1301         aViews->Value(i)->EraseImmediate (theStructure);
1302       }
1303     }
1304   }
1305
1306   myGraphicDriver->DisplayImmediateStructure (MyCView, *theStructure->CStructure());
1307   return Standard_True;
1308 }
1309
1310 // ========================================================================
1311 // function : EraseImmediate
1312 // purpose  :
1313 // ========================================================================
1314 Standard_Boolean Visual3d_View::EraseImmediate (const Handle(Graphic3d_Structure)& theStructure)
1315 {
1316   const Standard_Boolean isErased = myImmediateStructures.Remove (theStructure);
1317   if (isErased)
1318   {
1319     myGraphicDriver->EraseImmediateStructure (MyCView, *theStructure->CStructure());
1320   }
1321
1322   return isErased;
1323 }
1324
1325 // ========================================================================
1326 // function : ClearImmediate
1327 // purpose  :
1328 // ========================================================================
1329 Standard_Boolean Visual3d_View::ClearImmediate()
1330 {
1331   if (myImmediateStructures.IsEmpty())
1332   {
1333     return Standard_False;
1334   }
1335
1336   for (Graphic3d_MapIteratorOfMapOfStructure anIter (myImmediateStructures); anIter.More(); anIter.Next())
1337   {
1338     myGraphicDriver->EraseImmediateStructure (MyCView, *anIter.Key()->CStructure());
1339   }
1340   myImmediateStructures.Clear();
1341   return Standard_True;
1342 }
1343
1344 // ========================================================================
1345 // function : Display
1346 // purpose  :
1347 // ========================================================================
1348 void Visual3d_View::Display (const Handle(Graphic3d_Structure)& theStruct)
1349 {
1350   Display (theStruct, myViewManager->UpdateMode());
1351 }
1352
1353 // ========================================================================
1354 // function : Display
1355 // purpose  :
1356 // ========================================================================
1357 void Visual3d_View::Display (const Handle(Graphic3d_Structure)& theStruct,
1358                              const Aspect_TypeOfUpdate          theUpdateMode)
1359 {
1360   if (IsDeleted()
1361   || !IsDefined()
1362   || !IsActive())
1363   {
1364     return;
1365   }
1366
1367   // If Display on a structure present in the list of calculated structures while it is not
1368   // or more, of calculated type =>
1369   // - removes it as well as the associated old computed
1370   // THis happens when hlhsr becomes again of type e non computed after SetVisual.
1371   Standard_Integer anIndex = IsComputed (theStruct);
1372   if (anIndex != 0
1373    && theStruct->Visual() != Graphic3d_TOS_COMPUTED)
1374   {
1375     myStructsToCompute.Remove (anIndex);
1376     myStructsComputed .Remove (anIndex);
1377     anIndex = 0;
1378   }
1379
1380   Visual3d_TypeOfAnswer anAnswer = AcceptDisplay (theStruct);
1381   if (anAnswer == Visual3d_TOA_NO)
1382   {
1383     return;
1384   }
1385
1386   if (!ComputedMode())
1387   {
1388     anAnswer = Visual3d_TOA_YES;
1389   }
1390
1391   if (anAnswer == Visual3d_TOA_YES)
1392   {
1393     if (IsDisplayed (theStruct))
1394     {
1395       return;
1396     }
1397
1398     theStruct->CalculateBoundBox();
1399     myGraphicDriver->DisplayStructure (MyCView, *theStruct->CStructure(), theStruct->DisplayPriority());
1400     myStructsDisplayed.Add (theStruct);
1401     Update (theUpdateMode);
1402     return;
1403   }
1404   else if (anAnswer != Visual3d_TOA_COMPUTE)
1405   {
1406     return;
1407   }
1408
1409   if (anIndex != 0)
1410   {
1411     // Already computed, is COMPUTED still valid?
1412     const Handle(Graphic3d_Structure)& anOldStruct = myStructsComputed.Value (anIndex);
1413     if (anOldStruct->HLRValidation())
1414     {
1415       // Case COMPUTED valid
1416       // to be displayed
1417       if (!IsDisplayed (theStruct))
1418       {
1419         myStructsDisplayed.Add (theStruct);
1420         myGraphicDriver->DisplayStructure (MyCView, *anOldStruct->CStructure(), theStruct->DisplayPriority());
1421         Update (theUpdateMode);
1422       }
1423       return;
1424     }
1425     else
1426     {
1427       // Case COMPUTED invalid
1428       // Is there another valid representation?
1429       // Find in the sequence of already calculated structures
1430       // 1/ Structure having the same Owner as <AStructure>
1431       // 2/ That is not <AStructure>
1432       // 3/ The COMPUTED which of is valid
1433       const Standard_Integer aNewIndex = HaveTheSameOwner (theStruct);
1434       if (aNewIndex != 0)
1435       {
1436         // Case of COMPUTED invalid, WITH a valid of replacement
1437         // to be displayed
1438         if (!IsDisplayed (theStruct))
1439         {
1440           const Handle(Graphic3d_Structure)& aNewStruct = myStructsComputed.Value (aNewIndex);
1441           myStructsComputed.SetValue (anIndex, aNewStruct);
1442           myStructsDisplayed.Add (theStruct);
1443           myGraphicDriver->DisplayStructure (MyCView, *aNewStruct->CStructure(), theStruct->DisplayPriority());
1444           Update (theUpdateMode);
1445         }
1446         return;
1447       }
1448       else
1449       {
1450         // Case COMPUTED invalid, WITHOUT a valid of replacement
1451         // COMPUTED is removed if displayed
1452         if (IsDisplayed (theStruct))
1453         {
1454           myGraphicDriver->EraseStructure (MyCView, *anOldStruct->CStructure());
1455         }
1456       }
1457     }
1458   }
1459
1460   // Compute + Validation
1461   Handle(Graphic3d_Structure) aStruct;
1462   TColStd_Array2OfReal aTrsf (0, 3, 0, 3);
1463   theStruct->Transform (aTrsf);
1464   if (anIndex != 0)
1465   {
1466     TColStd_Array2OfReal anIdent (0, 3, 0, 3);
1467     for (Standard_Integer ii = 0; ii <= 3; ++ii)
1468     {
1469       for (Standard_Integer jj = 0; jj <= 3; ++jj)
1470       {
1471         anIdent (ii, jj) = (ii == jj ? 1.0 : 0.0);
1472       }
1473     }
1474
1475     aStruct = myStructsComputed.Value (anIndex);
1476     aStruct->SetTransform (anIdent, Graphic3d_TOC_REPLACE);
1477     if (theStruct->IsTransformed())
1478     {
1479       theStruct->Compute (this, aTrsf, aStruct);
1480     }
1481     else
1482     {
1483       theStruct->Compute (this, aStruct);
1484     }
1485   }
1486   else
1487   {
1488     aStruct = theStruct->IsTransformed()
1489             ? theStruct->Compute (this, aTrsf)
1490             : theStruct->Compute (this);
1491   }
1492
1493   aStruct->SetHLRValidation (Standard_True);
1494
1495   // TOCOMPUTE and COMPUTED associated to sequences are added
1496   myStructsToCompute.Append (theStruct);
1497   myStructsComputed .Append (aStruct);
1498
1499   // The previous are removed if necessary
1500   if (anIndex != 0)
1501   {
1502     myStructsToCompute.Remove (anIndex);
1503     myStructsComputed .Remove (anIndex);
1504   }
1505
1506   // Of which type will be the computed?
1507   const Visual3d_TypeOfVisualization aViewType = MyContext.Visualization();
1508   const Standard_Boolean toComputeWireframe = aViewType == Visual3d_TOV_WIREFRAME
1509                                            && theStruct->ComputeVisual() != Graphic3d_TOS_SHADING;
1510   const Standard_Boolean toComputeShading   = aViewType == Visual3d_TOV_SHADING
1511                                            && theStruct->ComputeVisual() != Graphic3d_TOS_WIREFRAME;
1512   if (!toComputeShading && !toComputeWireframe)
1513   {
1514     anAnswer = Visual3d_TOA_NO;
1515   }
1516   else
1517   {
1518     aStruct->SetVisual (toComputeWireframe ? Graphic3d_TOS_WIREFRAME : Graphic3d_TOS_SHADING);
1519     anAnswer = AcceptDisplay (aStruct);
1520   }
1521
1522   if (theStruct->IsHighlighted())
1523   {
1524     aStruct->SetHighlightColor (theStruct->HighlightColor());
1525     aStruct->GraphicHighlight (Aspect_TOHM_COLOR);
1526   }
1527
1528   // It is displayed only if the calculated structure
1529   // has a proper type corresponding to the one of the view.
1530   if (anAnswer != Visual3d_TOA_NO)
1531   {
1532     if (!IsDisplayed (theStruct))
1533     {
1534       myStructsDisplayed.Add (theStruct);
1535     }
1536     myGraphicDriver->DisplayStructure (MyCView, *aStruct->CStructure(), theStruct->DisplayPriority());
1537     Update (theUpdateMode);
1538   }
1539 }
1540
1541 // ========================================================================
1542 // function : Erase
1543 // purpose  :
1544 // ========================================================================
1545 void Visual3d_View::Erase (const Handle(Graphic3d_Structure)& theStruct)
1546 {
1547   if (!IsDeleted())
1548   {
1549     Erase (theStruct, myViewManager->UpdateMode());
1550   }
1551 }
1552
1553 // ========================================================================
1554 // function : Erase
1555 // purpose  :
1556 // ========================================================================
1557 void Visual3d_View::Erase (const Handle(Graphic3d_Structure)& theStruct,
1558                            const Aspect_TypeOfUpdate          theUpdateMode)
1559 {
1560   if (IsDeleted()
1561   || !IsDisplayed (theStruct))
1562   {
1563     return;
1564   }
1565
1566   Visual3d_TypeOfAnswer anAnswer = AcceptDisplay (theStruct);
1567   if (!ComputedMode())
1568   {
1569     anAnswer = Visual3d_TOA_YES;
1570   }
1571
1572   if (anAnswer != Visual3d_TOA_COMPUTE)
1573   {
1574     myGraphicDriver->EraseStructure (MyCView, *theStruct->CStructure());
1575   }
1576   else if (anAnswer == Visual3d_TOA_COMPUTE
1577        && myIsInComputedMode)
1578   {
1579     const Standard_Integer anIndex = IsComputed (theStruct);
1580     if (anIndex != 0)
1581     {
1582       const Handle(Graphic3d_Structure)& aCompStruct = myStructsComputed.ChangeValue (anIndex);
1583       myGraphicDriver->EraseStructure (MyCView, *aCompStruct->CStructure());
1584     }
1585   }
1586   myStructsDisplayed.Remove (theStruct);
1587   Update (theUpdateMode);
1588 }
1589
1590 // ========================================================================
1591 // function : Highlight
1592 // purpose  :
1593 // ========================================================================
1594 void Visual3d_View::Highlight (const Handle(Graphic3d_Structure)& theStruct,
1595                                const Aspect_TypeOfHighlightMethod theMethod)
1596 {
1597   const Standard_Integer anIndex = IsComputed (theStruct);
1598   if (anIndex != 0)
1599   {
1600     const Handle(Graphic3d_Structure)& aCompStruct = myStructsComputed.ChangeValue (anIndex);
1601     aCompStruct->SetHighlightColor (theStruct->HighlightColor());
1602     aCompStruct->GraphicHighlight (theMethod);
1603   }
1604 }
1605
1606 // ========================================================================
1607 // function : SetTransform
1608 // purpose  :
1609 // ========================================================================
1610 void Visual3d_View::SetTransform (const Handle(Graphic3d_Structure)& theStruct,
1611                                   const TColStd_Array2OfReal&        theTrsf)
1612 {
1613   const Standard_Integer anIndex = IsComputed (theStruct);
1614   if (anIndex != 0)
1615   {
1616     // Test is somewhat light !
1617     // trsf is transferred only if it is :
1618     // a translation
1619     // a scale
1620     if (theTrsf (0, 1) != 0.0 || theTrsf (0, 2) != 0.0
1621      || theTrsf (1, 0) != 0.0 || theTrsf (1, 2) != 0.0
1622      || theTrsf (2, 0) != 0.0 || theTrsf (2, 1) != 0.0)
1623     {
1624       ReCompute (theStruct);
1625     }
1626     else
1627     {
1628       const Handle(Graphic3d_Structure)& aCompStruct = myStructsComputed.ChangeValue (anIndex);
1629       aCompStruct->GraphicTransform (theTrsf);
1630     }
1631   }
1632
1633   theStruct->CalculateBoundBox();
1634   if (!theStruct->IsMutable()
1635    && !theStruct->CStructure()->IsForHighlight
1636    && !theStruct->CStructure()->IsInfinite)
1637   {
1638     const Standard_Integer aLayerId = theStruct->GetZLayer();
1639     myGraphicDriver->InvalidateBVHData (MyCView, aLayerId);
1640   }
1641 }
1642
1643 // ========================================================================
1644 // function : UnHighlight
1645 // purpose  :
1646 // ========================================================================
1647 void Visual3d_View::UnHighlight (const Handle(Graphic3d_Structure)& theStruct)
1648 {
1649   Standard_Integer anIndex = IsComputed (theStruct);
1650   if (anIndex != 0)
1651   {
1652     const Handle(Graphic3d_Structure)& aCompStruct = myStructsComputed.ChangeValue (anIndex);
1653     aCompStruct->GraphicUnHighlight();
1654   }
1655 }
1656
1657 // ========================================================================
1658 // function : IsComputed
1659 // purpose  :
1660 // ========================================================================
1661 Standard_Integer Visual3d_View::IsComputed (const Handle(Graphic3d_Structure)& theStruct) const
1662 {
1663   const Standard_Integer aStructId  = theStruct->Identification();
1664   const Standard_Integer aNbStructs = myStructsToCompute.Length();
1665   for (Standard_Integer aStructIter = 1; aStructIter <= aNbStructs; ++aStructIter)
1666   {
1667     const Handle(Graphic3d_Structure)& aStruct = myStructsToCompute.Value (aStructIter);
1668     if (aStruct->Identification() == aStructId)
1669     {
1670       return aStructIter;
1671     }
1672   }
1673   return 0;
1674 }
1675
1676 // ========================================================================
1677 // function : IsDisplayed
1678 // purpose  :
1679 // ========================================================================
1680 Standard_Boolean Visual3d_View::IsDisplayed (const Handle(Graphic3d_Structure)& theStruct) const
1681 {
1682   return !IsDeleted()
1683       &&  myStructsDisplayed.Contains (theStruct);
1684 }
1685
1686 // ========================================================================
1687 // function : ContainsFacet
1688 // purpose  :
1689 // ========================================================================
1690 Standard_Boolean Visual3d_View::ContainsFacet() const
1691 {
1692   return ContainsFacet (myStructsDisplayed);
1693 }
1694
1695 // ========================================================================
1696 // function : ContainsFacet
1697 // purpose  :
1698 // ========================================================================
1699 Standard_Boolean Visual3d_View::ContainsFacet (const Graphic3d_MapOfStructure& theSet) const
1700 {
1701   for (Graphic3d_MapIteratorOfMapOfStructure aStructIter (theSet); aStructIter.More(); aStructIter.Next())
1702   {
1703     if (aStructIter.Key()->ContainsFacet())
1704     {
1705       return Standard_True;
1706     }
1707   }
1708   return Standard_False;
1709 }
1710
1711 // ========================================================================
1712 // function : MinMaxValues
1713 // purpose  :
1714 // ========================================================================
1715 void Visual3d_View::MinMaxValues (Standard_Real& theXMin,
1716                                   Standard_Real& theYMin,
1717                                   Standard_Real& theZMin,
1718                                   Standard_Real& theXMax,
1719                                   Standard_Real& theYMax,
1720                                   Standard_Real& theZMax,
1721                                   const Standard_Boolean theToIgnoreInfiniteFlag) const
1722 {
1723   MinMaxValues (myStructsDisplayed,
1724                 theXMin, theYMin, theZMin,
1725                 theXMax, theYMax, theZMax,
1726                 theToIgnoreInfiniteFlag);
1727 }
1728
1729 // ========================================================================
1730 // function : MinMaxValues
1731 // purpose  :
1732 // ========================================================================
1733 void Visual3d_View::MinMaxValues (const Graphic3d_MapOfStructure& theSet,
1734                                   Standard_Real& theXMin,
1735                                   Standard_Real& theYMin,
1736                                   Standard_Real& theZMin,
1737                                   Standard_Real& theXMax,
1738                                   Standard_Real& theYMax,
1739                                   Standard_Real& theZMax,
1740                                   const Standard_Boolean theToIgnoreInfiniteFlag) const
1741 {
1742   if (theSet.IsEmpty ())
1743   {
1744     theXMin = RealFirst();
1745     theYMin = RealFirst();
1746     theZMin = RealFirst();
1747
1748     theXMax = RealLast();
1749     theYMax = RealLast();
1750     theZMax = RealLast();
1751   }
1752   else
1753   {
1754     Standard_Real aXm, aYm, aZm, aXM, aYM, aZM;
1755     Graphic3d_MapIteratorOfMapOfStructure anIterator (theSet);
1756
1757     theXMin = RealLast();
1758     theYMin = RealLast();
1759     theZMin = RealLast();
1760
1761     theXMax = RealFirst ();
1762     theYMax = RealFirst ();
1763     theZMax = RealFirst ();
1764
1765     for (anIterator.Initialize (theSet); anIterator.More(); anIterator.Next())
1766     {
1767       const Handle(Graphic3d_Structure)& aStructure = anIterator.Key();
1768
1769       if (aStructure->IsInfinite() && !theToIgnoreInfiniteFlag)
1770       {
1771         //XMin, YMin .... ZMax are initialized by means of infinite line data
1772         aStructure->MinMaxValues (aXm, aYm, aZm, aXM, aYM, aZM, Standard_False);
1773         if (aXm != RealFirst() && aXm < theXMin)
1774         {
1775           theXMin = aXm;
1776         }
1777         if (aYm != RealFirst() && aYm < theYMin)
1778         {
1779           theYMin = aYm;
1780         }
1781         if (aZm != RealFirst() && aZm < theZMin)
1782         {
1783           theZMin = aZm;
1784         }
1785         if (aXM != RealLast() && aXM > theXMax)
1786         {
1787           theXMax = aXM;
1788         }
1789         if (aYM != RealLast() && aYM > theYMax)
1790         {
1791           theYMax = aYM;
1792         }
1793         if (aZM != RealLast() && aZM > theZMax)
1794         {
1795           theZMax = aZM;
1796         }
1797       }
1798
1799       // Only non-empty and non-infinite structures
1800       // are taken into account for calculation of MinMax
1801       if ((!aStructure->IsInfinite() || theToIgnoreInfiniteFlag) && !aStructure->IsEmpty())
1802       {
1803         aStructure->MinMaxValues (aXm, aYm, aZm, aXM, aYM, aZM, theToIgnoreInfiniteFlag);
1804
1805         /* ABD 29/10/04  Transform Persistence of Presentation( pan, zoom, rotate ) */
1806         //"FitAll" operation ignores object with transform persitence parameter
1807         if(aStructure->TransformPersistenceMode() == Graphic3d_TMF_None )
1808         {
1809           theXMin = Min (aXm, theXMin);
1810           theYMin = Min (aYm, theYMin);
1811           theZMin = Min (aZm, theZMin);
1812           theXMax = Max (aXM, theXMax);
1813           theYMax = Max (aYM, theYMax);
1814           theZMax = Max (aZM, theZMax);
1815         }
1816       }
1817     }
1818
1819     // The following cases are relevant
1820     // For exemple if all structures are empty or infinite
1821     if (theXMax < theXMin) { aXm = theXMin; theXMin = theXMax; theXMax = aXm; }
1822     if (theYMax < theYMin) { aYm = theYMin; theYMin = theYMax; theYMax = aYm; }
1823     if (theZMax < theZMin) { aZm = theZMin; theZMin = theZMax; theZMax = aZm; }
1824   }
1825 }
1826
1827 // ========================================================================
1828 // function : MinMaxValues
1829 // purpose  :
1830 // ========================================================================
1831 void Visual3d_View::MinMaxValues (Standard_Real& theXMin,
1832                                   Standard_Real& theYMin,
1833                                   Standard_Real& theXMax,
1834                                   Standard_Real& theYMax,
1835                                   const Standard_Boolean theToIgnoreInfiniteFlag) const
1836 {
1837   MinMaxValues (myStructsDisplayed,
1838                 theXMin, theYMin,
1839                 theXMax, theYMax,
1840                 theToIgnoreInfiniteFlag);
1841 }
1842
1843 // ========================================================================
1844 // function : MinMaxValues
1845 // purpose  :
1846 // ========================================================================
1847 void Visual3d_View::MinMaxValues (const Graphic3d_MapOfStructure& theSet,
1848                                   Standard_Real& theXMin,
1849                                   Standard_Real& theYMin,
1850                                   Standard_Real& theXMax,
1851                                   Standard_Real& theYMax,
1852                                   const Standard_Boolean theToIgnoreInfiniteFlag) const
1853 {
1854   Standard_Real aXm, aYm, aZm, aXM, aYM, aZM;
1855   Standard_Real aXp, aYp, aZp;
1856
1857   MinMaxValues (theSet, aXm, aYm, aZm, aXM, aYM, aZM, theToIgnoreInfiniteFlag);
1858
1859   Projects (aXm, aYm, aZm, aXp, aYp, aZp);
1860   theXMin = aXp;
1861   theYMin = aYp;
1862
1863   Projects (aXM, aYM, aZM, aXp, aYp, aZp);
1864   theXMax = aXp;
1865   theYMax = aYp;
1866
1867   if (theXMax < theXMin) { aXp = theXMax; theXMax = theXMin; theXMin = aXp; }
1868   if (theYMax < theYMin) { aYp = theYMax; theYMax = theYMin; theYMin = aYp; }
1869 }
1870
1871 // =======================================================================
1872 // function : NumberOfDisplayedStructures
1873 // purpose  :
1874 // =======================================================================
1875 Standard_Integer Visual3d_View::NumberOfDisplayedStructures() const
1876 {
1877   return myStructsDisplayed.Extent();
1878 }
1879
1880 // =======================================================================
1881 // function : Projects
1882 // purpose  :
1883 // =======================================================================
1884 void Visual3d_View::Projects (const Standard_Real theX,
1885                               const Standard_Real theY,
1886                               const Standard_Real theZ,
1887                               Standard_Real& thePX,
1888                               Standard_Real& thePY,
1889                               Standard_Real& thePZ) const
1890 {
1891   const Handle(Graphic3d_Camera)& aCamera = MyCView.Context.Camera;
1892
1893   gp_XYZ aViewSpaceDimensions = aCamera->ViewDimensions();
1894   Standard_Real aXSize = aViewSpaceDimensions.X();
1895   Standard_Real aYSize = aViewSpaceDimensions.Y();
1896   Standard_Real aZSize = aViewSpaceDimensions.Z();
1897
1898   gp_Pnt aPoint = aCamera->Project (gp_Pnt (theX, theY, theZ));
1899
1900   // NDC [-1, 1] --> PROJ [ -size / 2, +size / 2 ]
1901   thePX = aPoint.X() * aXSize * 0.5;
1902   thePY = aPoint.Y() * aYSize * 0.5;
1903   thePZ = aPoint.Z() * aZSize * 0.5;
1904 }
1905
1906 // =======================================================================
1907 // function : Identification
1908 // purpose  :
1909 // =======================================================================
1910 Standard_Integer Visual3d_View::Identification() const
1911 {
1912   return MyCView.ViewId;
1913 }
1914
1915 // =======================================================================
1916 // function : ZBufferIsActivated
1917 // purpose  :
1918 // =======================================================================
1919 Standard_Boolean Visual3d_View::ZBufferIsActivated() const
1920 {
1921   if (IsDeleted()
1922   || !IsDefined()
1923   || !IsActive())
1924   {
1925     return Standard_False;
1926   }
1927
1928   if (MyCView.Context.ZBufferActivity == -1)
1929   {
1930     // not forced by the programmer => depends on the type of visualisation
1931     return MyContext.Visualization () == Visual3d_TOV_SHADING;
1932   }
1933   return MyCView.Context.ZBufferActivity != 0; //  0 or 1 => forced by the programmer
1934 }
1935
1936 // =======================================================================
1937 // function : SetTransparency
1938 // purpose  :
1939 // =======================================================================
1940 void Visual3d_View::SetTransparency (const Standard_Boolean theActivity)
1941 {
1942   if (IsDeleted()
1943   || !IsDefined()
1944   || !IsActive())
1945   {
1946     return;
1947   }
1948
1949   myGraphicDriver->Transparency (MyCView, theActivity);
1950 }
1951
1952 // =======================================================================
1953 // function : SetZBufferActivity
1954 // purpose  :
1955 // =======================================================================
1956 void Visual3d_View::SetZBufferActivity (const Standard_Integer theActivity)
1957 {
1958   if (IsDeleted()
1959   ||  MyCView.Context.ZBufferActivity == theActivity
1960   || !IsDefined()
1961   || !IsActive())
1962   {
1963     return;
1964   }
1965
1966   MyCView.Context.ZBufferActivity = theActivity;
1967   myGraphicDriver->SetVisualisation (MyCView);
1968 }
1969
1970 // =======================================================================
1971 // function : UpdateView
1972 // purpose  :
1973 // =======================================================================
1974 void Visual3d_View::UpdateView()
1975 {
1976   MyCView.Context.Aliasing        = MyContext.AliasingIsOn();
1977   MyCView.Context.BackZClipping   = MyContext.BackZClippingIsOn();
1978   MyCView.Context.FrontZClipping  = MyContext.FrontZClippingIsOn();
1979   MyCView.Context.DepthCueing     = MyContext.DepthCueingIsOn();
1980
1981   MyCView.Context.ZClipFrontPlane = float (MyContext.ZClippingFrontPlane());
1982   MyCView.Context.ZClipBackPlane  = float (MyContext.ZClippingBackPlane());
1983   MyCView.Context.DepthFrontPlane = float (MyContext.DepthCueingFrontPlane());
1984   MyCView.Context.DepthBackPlane  = float (MyContext.DepthCueingBackPlane());
1985
1986   MyCView.Context.Model           = MyContext.Model();
1987   MyCView.Context.Visualization   = MyContext.Visualization();
1988
1989   MyCView.Context.TextureEnv      = MyContext.TextureEnv();
1990   MyCView.Context.SurfaceDetail   = MyContext.SurfaceDetail();
1991 }
1992
1993 // =======================================================================
1994 // function : Compute
1995 // purpose  :
1996 // =======================================================================
1997 void Visual3d_View::Compute()
1998 {
1999   // force HLRValidation to False on all structures calculated in the view
2000   const Standard_Integer aNbCompStructs = myStructsComputed.Length();
2001   for (Standard_Integer aStructIter = 1; aStructIter <= aNbCompStructs; ++aStructIter)
2002   {
2003     myStructsComputed.Value (aStructIter)->SetHLRValidation (Standard_False);
2004   }
2005
2006   if (!ComputedMode())
2007   {
2008     return;
2009   }
2010
2011   // Change of orientation or of projection type =>
2012   // Remove structures that were calculated for the previous orientation.
2013   // Recalculation of new structures.
2014   NCollection_Sequence<Handle(Graphic3d_Structure)> aStructsSeq;
2015   for (Graphic3d_MapIteratorOfMapOfStructure aStructIter (myStructsDisplayed); aStructIter.More(); aStructIter.Next())
2016   {
2017     const Visual3d_TypeOfAnswer anAnswer = AcceptDisplay (aStructIter.Key());
2018     if (anAnswer == Visual3d_TOA_COMPUTE)
2019     {
2020       aStructsSeq.Append (aStructIter.Key()); // if the structure was calculated, it is recalculated
2021     }
2022   }
2023
2024   for (NCollection_Sequence<Handle(Graphic3d_Structure)>::Iterator aStructIter (aStructsSeq); aStructIter.More(); aStructIter.Next())
2025   {
2026     Display (aStructIter.ChangeValue(), Aspect_TOU_WAIT);
2027   }
2028 }
2029
2030 // =======================================================================
2031 // function : ReCompute
2032 // purpose  :
2033 // =======================================================================
2034 void Visual3d_View::ReCompute (const Handle(Graphic3d_Structure)& theStruct)
2035 {
2036   theStruct->CalculateBoundBox();
2037   if (!theStruct->IsMutable()
2038    && !theStruct->CStructure()->IsForHighlight
2039    && !theStruct->CStructure()->IsInfinite)
2040   {
2041     const Standard_Integer aLayerId = theStruct->DisplayPriority();
2042     myGraphicDriver->InvalidateBVHData(MyCView, aLayerId);
2043   }
2044
2045   if (!ComputedMode()
2046    ||  IsDeleted()
2047    || !IsDefined()
2048    || !IsActive()
2049    || !MyWindow->IsMapped()
2050    || !theStruct->IsDisplayed())
2051   {
2052     return;
2053   }
2054
2055   const Visual3d_TypeOfAnswer anAnswer = AcceptDisplay (theStruct);
2056   if (anAnswer != Visual3d_TOA_COMPUTE)
2057   {
2058     return;
2059   }
2060
2061   const Standard_Integer anIndex = IsComputed (theStruct);
2062   if (anIndex == 0)
2063   {
2064     return;
2065   }
2066
2067   // compute + validation
2068   TColStd_Array2OfReal anIdent (0, 3, 0, 3);
2069   for (Standard_Integer aRow = 0; aRow <= 3; ++aRow)
2070   {
2071     for (Standard_Integer aCol = 0; aCol <= 3; ++aCol)
2072     {
2073       anIdent (aRow, aCol) = (aRow == aCol ? 1.0 : 0.0);
2074     }
2075   }
2076   TColStd_Array2OfReal aTrsf (0, 3, 0, 3);
2077   theStruct->Transform (aTrsf);
2078
2079   Handle(Graphic3d_Structure) aCompStructOld = myStructsComputed.ChangeValue (anIndex);
2080   Handle(Graphic3d_Structure) aCompStruct    = aCompStructOld;
2081   aCompStruct->SetTransform (anIdent, Graphic3d_TOC_REPLACE);
2082   theStruct->IsTransformed() ? theStruct->Compute (this, aTrsf, aCompStruct)
2083                              : theStruct->Compute (this,        aCompStruct);
2084   aCompStruct->SetHLRValidation (Standard_True);
2085
2086   // of which type will be the computed?
2087   const Visual3d_TypeOfVisualization aViewType = MyContext.Visualization();
2088   const Standard_Boolean toComputeWireframe = aViewType == Visual3d_TOV_WIREFRAME
2089                                            && theStruct->ComputeVisual() != Graphic3d_TOS_SHADING;
2090   const Standard_Boolean toComputeShading   = aViewType == Visual3d_TOV_SHADING
2091                                            && theStruct->ComputeVisual() != Graphic3d_TOS_WIREFRAME;
2092   if (toComputeWireframe)
2093   {
2094     aCompStruct->SetVisual (Graphic3d_TOS_WIREFRAME);
2095   }
2096   else if (toComputeShading)
2097   {
2098     aCompStruct->SetVisual (Graphic3d_TOS_SHADING);
2099   }
2100
2101   if (theStruct->IsHighlighted())
2102   {
2103     aCompStruct->SetHighlightColor (theStruct->HighlightColor());
2104     aCompStruct->GraphicHighlight (Aspect_TOHM_COLOR);
2105   }
2106
2107   // The previous calculation is removed and the new one is dislayed
2108   myGraphicDriver->EraseStructure   (MyCView, *aCompStructOld->CStructure());
2109   myGraphicDriver->DisplayStructure (MyCView, *aCompStruct->CStructure(), theStruct->DisplayPriority());
2110
2111   // why not just replace existing items?
2112   //myStructsToCompute.ChangeValue (anIndex) = theStruct;
2113   //myStructsComputed .ChangeValue (anIndex) = aCompStruct;
2114
2115   // hlhsr and the new associated compute are added
2116   myStructsToCompute.Append (theStruct);
2117   myStructsComputed .Append (aCompStruct);
2118
2119   // hlhsr and the new associated compute are removed
2120   myStructsToCompute.Remove (anIndex);
2121   myStructsComputed .Remove (anIndex);
2122 }
2123
2124 // =======================================================================
2125 // function : GraphicDriver
2126 // purpose  :
2127 // =======================================================================
2128 const Handle(Graphic3d_GraphicDriver)& Visual3d_View::GraphicDriver() const
2129 {
2130   return myGraphicDriver;
2131 }
2132
2133 // =======================================================================
2134 // function : HaveTheSameOwner
2135 // purpose  :
2136 // =======================================================================
2137 Standard_Integer Visual3d_View::HaveTheSameOwner (const Handle(Graphic3d_Structure)& theStruct) const
2138 {
2139   // Find in the sequence of already calculated structures
2140   // 1/ Structure with the same Owner as <AStructure>
2141   // 2/ Which is not <AStructure>
2142   // 3/ COMPUTED which of is valid
2143   const Standard_Integer aNbToCompStructs = myStructsToCompute.Length();
2144   for (Standard_Integer aStructIter = 1; aStructIter <= aNbToCompStructs; ++aStructIter)
2145   {
2146     const Handle(Graphic3d_Structure)& aStructToComp = myStructsToCompute.Value (aStructIter);
2147     if (aStructToComp->Owner()          == theStruct->Owner()
2148      && aStructToComp->Identification() != theStruct->Identification())
2149     {
2150       const Handle(Graphic3d_Structure)& aStructComp = myStructsComputed.Value (aStructIter);
2151       if (aStructComp->HLRValidation())
2152       {
2153         return aStructIter;
2154       }
2155     }
2156   }
2157   return 0;
2158 }
2159
2160 // =======================================================================
2161 // function : CView
2162 // purpose  :
2163 // =======================================================================
2164 Standard_Address Visual3d_View::CView() const
2165 {
2166   return Standard_Address (&MyCView);
2167 }
2168
2169 // =======================================================================
2170 // function : ZBufferTriedronSetup
2171 // purpose  :
2172 // =======================================================================
2173 void Visual3d_View::ZBufferTriedronSetup (const Quantity_NameOfColor theXColor,
2174                                           const Quantity_NameOfColor theYColor,
2175                                           const Quantity_NameOfColor theZColor,
2176                                           const Standard_Real        theSizeRatio,
2177                                           const Standard_Real        theAxisDiametr,
2178                                           const Standard_Integer     theNbFacettes)
2179 {
2180   myGraphicDriver->ZBufferTriedronSetup (theXColor, theYColor, theZColor,
2181                                          theSizeRatio, theAxisDiametr, theNbFacettes);
2182 }
2183
2184 // =======================================================================
2185 // function : TriedronDisplay
2186 // purpose  :
2187 // =======================================================================
2188 void Visual3d_View::TriedronDisplay (const Aspect_TypeOfTriedronPosition thePosition,
2189                                      const Quantity_NameOfColor          theColor,
2190                                      const Standard_Real                 theScale,
2191                                      const Standard_Boolean              theAsWireframe)
2192 {
2193   myGraphicDriver->TriedronDisplay (MyCView, thePosition, theColor, theScale, theAsWireframe);
2194 }
2195
2196 // =======================================================================
2197 // function : TriedronErase
2198 // purpose  :
2199 // =======================================================================
2200 void Visual3d_View::TriedronErase()
2201 {
2202   myGraphicDriver->TriedronErase (MyCView);
2203 }
2204
2205 // =======================================================================
2206 // function : TriedronEcho
2207 // purpose  :
2208 // =======================================================================
2209 void Visual3d_View::TriedronEcho (const Aspect_TypeOfTriedronEcho theType)
2210 {
2211   myGraphicDriver->TriedronEcho (MyCView, theType);
2212 }
2213
2214 static Standard_Boolean checkFloat (const Standard_Real theValue)
2215 {
2216   return theValue > -FLT_MAX
2217       && theValue <  FLT_MAX;
2218 }
2219
2220 static void SetMinMaxValuesCallback (Visual3d_View* theView)
2221 {
2222   Graphic3d_Vec3d aMin, aMax;
2223   theView->MinMaxValues (aMin.x(), aMin.y(), aMin.z(),
2224                          aMax.x(), aMax.y(), aMax.z());
2225   if (checkFloat (aMin.x()) && checkFloat (aMin.y()) && checkFloat (aMin.z())
2226    && checkFloat (aMax.x()) && checkFloat (aMax.y()) && checkFloat (aMax.z()))
2227   {
2228     const Handle(Graphic3d_GraphicDriver)& aDriver = theView->GraphicDriver();
2229     aDriver->GraduatedTrihedronMinMaxValues ((Standard_ShortReal )aMin.x(), (Standard_ShortReal )aMin.y(), (Standard_ShortReal )aMin.z(),
2230                                              (Standard_ShortReal )aMax.x(), (Standard_ShortReal )aMax.y(), (Standard_ShortReal )aMax.z());
2231   }
2232 }
2233
2234 // =======================================================================
2235 // function : GetGraduatedTrihedron
2236 // purpose  :
2237 // =======================================================================
2238 Standard_Boolean Visual3d_View::GetGraduatedTrihedron (TCollection_ExtendedString& theXName,
2239                                                        TCollection_ExtendedString& theYName,
2240                                                        TCollection_ExtendedString& theZName,
2241                                                        Standard_Boolean&           theToDrawXName,
2242                                                        Standard_Boolean&           theToDrawYName,
2243                                                        Standard_Boolean&           theToDrawZName,
2244                                                        Standard_Boolean&           theToDrawXValues,
2245                                                        Standard_Boolean&           theToDrawYValues,
2246                                                        Standard_Boolean&           theToDrawZValues,
2247                                                        Standard_Boolean&           theToDrawGrid,
2248                                                        Standard_Boolean&           theToDrawAxes,
2249                                                        Standard_Integer&           theNbX,
2250                                                        Standard_Integer&           theNbY,
2251                                                        Standard_Integer&           theNbZ,
2252                                                        Standard_Integer&           theXOffset,
2253                                                        Standard_Integer&           theYOffset,
2254                                                        Standard_Integer&           theZOffset,
2255                                                        Standard_Integer&           theXAxisOffset,
2256                                                        Standard_Integer&           theYAxisOffset,
2257                                                        Standard_Integer&           theZAxisOffset,
2258                                                        Standard_Boolean&           theToDrawXTickMarks,
2259                                                        Standard_Boolean&           theToDrawYTickMarks,
2260                                                        Standard_Boolean&           theToDrawZTickMarks,
2261                                                        Standard_Integer&           theXTickMarkLength,
2262                                                        Standard_Integer&           theYTickMarkLength,
2263                                                        Standard_Integer&           theZTickMarkLength,
2264                                                        Quantity_Color&             theGridColor,
2265                                                        Quantity_Color&             theXNameColor,
2266                                                        Quantity_Color&             theYNameColor,
2267                                                        Quantity_Color&             theZNameColor,
2268                                                        Quantity_Color&             theXColor,
2269                                                        Quantity_Color&             theYColor,
2270                                                        Quantity_Color&             theZColor,
2271                                                        TCollection_AsciiString&    theFontOfNames,
2272                                                        Font_FontAspect&            theStyleOfNames,
2273                                                        Standard_Integer&           theSizeOfNames,
2274                                                        TCollection_AsciiString&    theFontOfValues,
2275                                                        Font_FontAspect&            theStyleOfValues,
2276                                                        Standard_Integer&           theSizeOfValues) const
2277 {
2278   if (!MyGTrihedron.ptrVisual3dView)
2279   {
2280     return Standard_False;
2281   }
2282
2283   theXName = MyGTrihedron.xname;
2284   theYName = MyGTrihedron.yname;
2285   theZName = MyGTrihedron.zname;
2286   theToDrawXName   = MyGTrihedron.xdrawname;
2287   theToDrawYName   = MyGTrihedron.ydrawname;
2288   theToDrawZName   = MyGTrihedron.zdrawname;
2289   theToDrawXValues = MyGTrihedron.xdrawvalues;
2290   theToDrawYValues = MyGTrihedron.ydrawvalues;
2291   theToDrawZValues = MyGTrihedron.zdrawvalues;
2292   theToDrawGrid    = MyGTrihedron.drawgrid;
2293   theToDrawAxes    = MyGTrihedron.drawaxes;
2294   theNbX = MyGTrihedron.nbx;
2295   theNbY = MyGTrihedron.nby;
2296   theNbZ = MyGTrihedron.nbz;
2297   theXOffset     = MyGTrihedron.xoffset;
2298   theYOffset     = MyGTrihedron.yoffset;
2299   theZOffset     = MyGTrihedron.zoffset;
2300   theXAxisOffset = MyGTrihedron.xaxisoffset;
2301   theYAxisOffset = MyGTrihedron.yaxisoffset;
2302   theZAxisOffset = MyGTrihedron.zaxisoffset;
2303   theToDrawXTickMarks = MyGTrihedron.xdrawtickmarks;
2304   theToDrawYTickMarks = MyGTrihedron.ydrawtickmarks;
2305   theToDrawZTickMarks = MyGTrihedron.zdrawtickmarks;
2306   theXTickMarkLength  = MyGTrihedron.xtickmarklength;
2307   theYTickMarkLength  = MyGTrihedron.ytickmarklength;
2308   theZTickMarkLength  = MyGTrihedron.ztickmarklength;
2309   theGridColor  = MyGTrihedron.gridcolor;
2310   theXNameColor = MyGTrihedron.xnamecolor;
2311   theYNameColor = MyGTrihedron.ynamecolor;
2312   theZNameColor = MyGTrihedron.znamecolor;
2313   theXColor     = MyGTrihedron.xcolor;
2314   theYColor     = MyGTrihedron.ycolor;
2315   theZColor     = MyGTrihedron.zcolor;
2316   theFontOfNames   = MyGTrihedron.fontOfNames;
2317   theStyleOfNames  = MyGTrihedron.styleOfNames;
2318   theSizeOfNames   = MyGTrihedron.sizeOfNames;
2319   theFontOfValues  = MyGTrihedron.fontOfValues;
2320   theStyleOfValues = MyGTrihedron.styleOfValues;
2321   theSizeOfValues  = MyGTrihedron.sizeOfValues;
2322   return Standard_True;
2323 }
2324
2325 // =======================================================================
2326 // function : GraduatedTrihedronDisplay
2327 // purpose  :
2328 // =======================================================================
2329 void Visual3d_View::GraduatedTrihedronDisplay (const TCollection_ExtendedString& theXName,
2330                                                const TCollection_ExtendedString& theYName,
2331                                                const TCollection_ExtendedString& theZName,
2332                                                const Standard_Boolean theToDrawXName,
2333                                                const Standard_Boolean theToDrawYName,
2334                                                const Standard_Boolean theToDrawZName,
2335                                                const Standard_Boolean theToDrawXValues,
2336                                                const Standard_Boolean theToDrawYValues,
2337                                                const Standard_Boolean theToDrawZValues,
2338                                                const Standard_Boolean theToDrawGrid,
2339                                                const Standard_Boolean theToDrawAxes,
2340                                                const Standard_Integer theNbX,
2341                                                const Standard_Integer theNbY,
2342                                                const Standard_Integer theNbZ,
2343                                                const Standard_Integer theXOffset,
2344                                                const Standard_Integer theYOffset,
2345                                                const Standard_Integer theZOffset,
2346                                                const Standard_Integer theXAxisOffset,
2347                                                const Standard_Integer theYAxisOffset,
2348                                                const Standard_Integer theZAxisOffset,
2349                                                const Standard_Boolean theToDrawXTickMarks,
2350                                                const Standard_Boolean theToDrawYTickMarks,
2351                                                const Standard_Boolean theToDrawZTickMarks,
2352                                                const Standard_Integer theXTickMarkLength,
2353                                                const Standard_Integer theYTickMarkLength,
2354                                                const Standard_Integer theZTickMarkLength,
2355                                                const Quantity_Color&  theGridColor,
2356                                                const Quantity_Color&  theXNameColor,
2357                                                const Quantity_Color&  theYNameColor,
2358                                                const Quantity_Color&  theZNameColor,
2359                                                const Quantity_Color&  theXColor,
2360                                                const Quantity_Color&  theYColor,
2361                                                const Quantity_Color&  theZColor,
2362                                                const TCollection_AsciiString& theFontOfNames,
2363                                                const Font_FontAspect  theStyleOfNames,
2364                                                const Standard_Integer theSizeOfNames,
2365                                                const TCollection_AsciiString& theFontOfValues,
2366                                                const Font_FontAspect  theStyleOfValues,
2367                                                const Standard_Integer theSizeOfValues)
2368 {
2369   MyGTrihedron.xname = theXName;
2370   MyGTrihedron.yname = theYName;
2371   MyGTrihedron.zname = theZName;
2372   MyGTrihedron.xdrawname = theToDrawXName;
2373   MyGTrihedron.ydrawname = theToDrawYName;
2374   MyGTrihedron.zdrawname = theToDrawZName;
2375   MyGTrihedron.xdrawvalues = theToDrawXValues;
2376   MyGTrihedron.ydrawvalues = theToDrawYValues;
2377   MyGTrihedron.zdrawvalues = theToDrawZValues;
2378   MyGTrihedron.drawgrid = theToDrawGrid;
2379   MyGTrihedron.drawaxes = theToDrawAxes;
2380   MyGTrihedron.nbx = theNbX;
2381   MyGTrihedron.nby = theNbY;
2382   MyGTrihedron.nbz = theNbZ;
2383   MyGTrihedron.xoffset = theXOffset;
2384   MyGTrihedron.yoffset = theYOffset;
2385   MyGTrihedron.zoffset = theZOffset;
2386   MyGTrihedron.xaxisoffset = theXAxisOffset;
2387   MyGTrihedron.yaxisoffset = theYAxisOffset;
2388   MyGTrihedron.zaxisoffset = theZAxisOffset;
2389   MyGTrihedron.xdrawtickmarks = theToDrawXTickMarks;
2390   MyGTrihedron.ydrawtickmarks = theToDrawYTickMarks;
2391   MyGTrihedron.zdrawtickmarks = theToDrawZTickMarks;
2392   MyGTrihedron.xtickmarklength = theXTickMarkLength;
2393   MyGTrihedron.ytickmarklength = theYTickMarkLength;
2394   MyGTrihedron.ztickmarklength = theZTickMarkLength;
2395   MyGTrihedron.gridcolor  = theGridColor;
2396   MyGTrihedron.xnamecolor = theXNameColor;
2397   MyGTrihedron.ynamecolor = theYNameColor;
2398   MyGTrihedron.znamecolor = theZNameColor;
2399   MyGTrihedron.xcolor = theXColor;
2400   MyGTrihedron.ycolor = theYColor;
2401   MyGTrihedron.zcolor = theZColor;
2402   MyGTrihedron.fontOfNames   = theFontOfNames;
2403   MyGTrihedron.styleOfNames  = theStyleOfNames;
2404   MyGTrihedron.sizeOfNames   = theSizeOfNames;
2405   MyGTrihedron.fontOfValues  = theFontOfValues;
2406   MyGTrihedron.styleOfValues = theStyleOfValues;
2407   MyGTrihedron.sizeOfValues  = theSizeOfValues;
2408
2409   MyGTrihedron.ptrVisual3dView = this;
2410   MyGTrihedron.cbCubicAxes     = SetMinMaxValuesCallback;
2411   myGraphicDriver->GraduatedTrihedronDisplay (MyCView, MyGTrihedron);
2412 }
2413
2414 // =======================================================================
2415 // function : GraduatedTrihedronErase
2416 // purpose  :
2417 // =======================================================================
2418 void Visual3d_View::GraduatedTrihedronErase()
2419 {
2420   MyGTrihedron.ptrVisual3dView = NULL;
2421   myGraphicDriver->GraduatedTrihedronErase (MyCView);
2422 }
2423
2424 // =======================================================================
2425 // function : UnderLayer
2426 // purpose  :
2427 // =======================================================================
2428 const Handle(Visual3d_Layer)& Visual3d_View::UnderLayer() const
2429 {
2430   return myViewManager->UnderLayer();
2431 }
2432
2433 // =======================================================================
2434 // function : OverLayer
2435 // purpose  :
2436 // =======================================================================
2437 const Handle(Visual3d_Layer)& Visual3d_View::OverLayer() const
2438 {
2439   return myViewManager->OverLayer();
2440 }
2441
2442 // =======================================================================
2443 // function : LightLimit
2444 // purpose  :
2445 // =======================================================================
2446 Standard_Integer Visual3d_View::LightLimit() const
2447 {
2448   return myGraphicDriver->InquireLightLimit();
2449 }
2450
2451 // =======================================================================
2452 // function : PlaneLimit
2453 // purpose  :
2454 // =======================================================================
2455 Standard_Integer Visual3d_View::PlaneLimit() const
2456 {
2457   return myGraphicDriver->InquirePlaneLimit();
2458 }
2459
2460 // =======================================================================
2461 // function : ViewManager
2462 // purpose  :
2463 // =======================================================================
2464 Handle(Visual3d_ViewManager) Visual3d_View::ViewManager() const
2465 {
2466   return myViewManager;
2467 }
2468
2469 // =======================================================================
2470 // function : SetComputedMode
2471 // purpose  :
2472 // =======================================================================
2473 void Visual3d_View::SetComputedMode (const Standard_Boolean theMode)
2474 {
2475   if (( theMode &&  myIsInComputedMode)
2476    || (!theMode && !myIsInComputedMode))
2477   {
2478     return;
2479   }
2480
2481   myIsInComputedMode = theMode;
2482   if (!myIsInComputedMode)
2483   {
2484     for (Graphic3d_MapIteratorOfMapOfStructure aStructIter (myStructsDisplayed); aStructIter.More(); aStructIter.Next())
2485     {
2486       const Handle(Graphic3d_Structure)& aStruct  = aStructIter.Key();
2487       const Visual3d_TypeOfAnswer        anAnswer = AcceptDisplay (aStruct);
2488       if (anAnswer != Visual3d_TOA_COMPUTE)
2489       {
2490         continue;
2491       }
2492
2493       const Standard_Integer anIndex = IsComputed (aStruct);
2494       if (anIndex != 0)
2495       {
2496         const Handle(Graphic3d_Structure)& aStructComp = myStructsComputed.Value (anIndex);
2497         myGraphicDriver->EraseStructure   (MyCView, *aStructComp->CStructure());
2498         myGraphicDriver->DisplayStructure (MyCView, *aStruct->CStructure(), aStruct->DisplayPriority());
2499       }
2500     }
2501     return;
2502   }
2503
2504   for (Graphic3d_MapIteratorOfMapOfStructure aDispStructIter (myStructsDisplayed); aDispStructIter.More(); aDispStructIter.Next())
2505   {
2506     Handle(Graphic3d_Structure) aStruct = aDispStructIter.Key();
2507     const Visual3d_TypeOfAnswer anAnswer = AcceptDisplay (aStruct);
2508     if (anAnswer != Visual3d_TOA_COMPUTE)
2509     {
2510       continue;
2511     }
2512
2513     const Standard_Integer anIndex = IsComputed (aStruct);
2514     if (anIndex != 0)
2515     {
2516       myGraphicDriver->EraseStructure   (MyCView, *aStruct->CStructure());
2517       myGraphicDriver->DisplayStructure (MyCView, *(myStructsComputed.Value (anIndex)->CStructure()), aStruct->DisplayPriority());
2518
2519       Display (aStruct, Aspect_TOU_WAIT);
2520       if (aStruct->IsHighlighted())
2521       {
2522         const Handle(Graphic3d_Structure)& aCompStruct = myStructsComputed.Value (anIndex);
2523         if (!aCompStruct->IsHighlighted())
2524         {
2525           aCompStruct->SetHighlightColor (aStruct->HighlightColor());
2526           aCompStruct->GraphicHighlight (Aspect_TOHM_COLOR);
2527         }
2528       }
2529     }
2530     else
2531     {
2532       TColStd_Array2OfReal aTrsf (0, 3, 0, 3);
2533       aStruct->Transform (aTrsf);
2534       Handle(Graphic3d_Structure) aCompStruct = aStruct->IsTransformed() ? aStruct->Compute (this, aTrsf) : aStruct->Compute (this);
2535       aCompStruct->SetHLRValidation (Standard_True);
2536
2537       const Visual3d_TypeOfVisualization aViewType = MyContext.Visualization();
2538       const Standard_Boolean toComputeWireframe = aViewType == Visual3d_TOV_WIREFRAME
2539                                                 && aStruct->ComputeVisual() != Graphic3d_TOS_SHADING;
2540       const Standard_Boolean toComputeShading   = aViewType == Visual3d_TOV_SHADING
2541                                                 && aStruct->ComputeVisual() != Graphic3d_TOS_WIREFRAME;
2542       if (toComputeWireframe) aCompStruct->SetVisual (Graphic3d_TOS_WIREFRAME);
2543       if (toComputeShading  ) aCompStruct->SetVisual (Graphic3d_TOS_SHADING);
2544
2545       if (aStruct->IsHighlighted())
2546       {
2547         aCompStruct->SetHighlightColor (aStruct->HighlightColor());
2548         aCompStruct->GraphicHighlight (Aspect_TOHM_COLOR);
2549       }
2550
2551       Standard_Boolean hasResult = Standard_False;
2552       const Standard_Integer aNbToCompute = myStructsToCompute.Length();
2553       const Standard_Integer aStructId    = aStruct->Identification();
2554       for (Standard_Integer aToCompStructIter = 1; aToCompStructIter <= aNbToCompute; ++aToCompStructIter)
2555       {
2556         if (myStructsToCompute.Value (aToCompStructIter)->Identification() == aStructId)
2557         {
2558           hasResult = Standard_True;
2559           myStructsComputed.ChangeValue (aToCompStructIter) = aCompStruct;
2560           break;
2561         }
2562       }
2563
2564       if (!hasResult)
2565       {
2566         myStructsToCompute.Append (aStruct);
2567         myStructsComputed .Append (aCompStruct);
2568       }
2569
2570       myGraphicDriver->EraseStructure   (MyCView, *aStruct->CStructure());
2571       myGraphicDriver->DisplayStructure (MyCView, *aCompStruct->CStructure(), aStruct->DisplayPriority());
2572     }
2573   }
2574   Update (myViewManager->UpdateMode());
2575 }
2576
2577 // =======================================================================
2578 // function : ComputedMode
2579 // purpose  :
2580 // =======================================================================
2581 Standard_Boolean Visual3d_View::ComputedMode() const
2582 {
2583   return myIsInComputedMode;
2584 }
2585
2586 // =======================================================================
2587 // function : SetBackFacingModel
2588 // purpose  :
2589 // =======================================================================
2590 void Visual3d_View::SetBackFacingModel (const Visual3d_TypeOfBackfacingModel theModel)
2591 {
2592   switch (theModel)
2593   {
2594     default:
2595     case Visual3d_TOBM_AUTOMATIC:
2596       MyCView.Backfacing = 0;
2597       break;
2598     case Visual3d_TOBM_FORCE:
2599       MyCView.Backfacing = 1;
2600       break;
2601     case Visual3d_TOBM_DISABLE:
2602       MyCView.Backfacing = -1;
2603       break;
2604   }
2605   myGraphicDriver->SetBackFacingModel (MyCView);
2606 }
2607
2608 // =======================================================================
2609 // function : BackFacingModel
2610 // purpose  :
2611 // =======================================================================
2612 Visual3d_TypeOfBackfacingModel Visual3d_View::BackFacingModel() const
2613 {
2614   switch (MyCView.Backfacing)
2615   {
2616     case 0: return Visual3d_TOBM_AUTOMATIC;
2617     case 1: return Visual3d_TOBM_FORCE;
2618   }
2619   return Visual3d_TOBM_DISABLE;
2620 }
2621
2622 // =======================================================================
2623 // function : EnableDepthTest
2624 // purpose  :
2625 // =======================================================================
2626 void Visual3d_View::EnableDepthTest (const Standard_Boolean theToEnable) const
2627 {
2628   myGraphicDriver->SetDepthTestEnabled (MyCView, theToEnable);
2629 }
2630
2631 // =======================================================================
2632 // function : IsDepthTestEnabled
2633 // purpose  :
2634 // =======================================================================
2635 Standard_Boolean Visual3d_View::IsDepthTestEnabled() const
2636 {
2637   return myGraphicDriver->IsDepthTestEnabled (MyCView);
2638 }
2639
2640 // =======================================================================
2641 // function : ReadDepths
2642 // purpose  :
2643 // =======================================================================
2644 void Visual3d_View::ReadDepths (const Standard_Integer theX,
2645                                 const Standard_Integer theY,
2646                                 const Standard_Integer theWidth,
2647                                 const Standard_Integer theHeight,
2648                                 const Standard_Address theBuffer) const
2649 {
2650   myGraphicDriver->ReadDepths (MyCView, theX, theY, theWidth, theHeight, theBuffer);
2651 }
2652
2653 // =======================================================================
2654 // function : FBOCreate
2655 // purpose  :
2656 // =======================================================================
2657 Graphic3d_PtrFrameBuffer Visual3d_View::FBOCreate(const Standard_Integer theWidth,
2658                                                   const Standard_Integer theHeight)
2659 {
2660   return myGraphicDriver->FBOCreate( MyCView, theWidth, theHeight );
2661 }
2662
2663 // =======================================================================
2664 // function : FBORelease
2665 // purpose  :
2666 // =======================================================================
2667 void Visual3d_View::FBORelease(Graphic3d_PtrFrameBuffer& theFBOPtr)
2668 {
2669   myGraphicDriver->FBORelease( MyCView, theFBOPtr );
2670 }
2671
2672 // =======================================================================
2673 // function : FBOGetDimensions
2674 // purpose  :
2675 // =======================================================================
2676 void Visual3d_View::FBOGetDimensions(const Graphic3d_PtrFrameBuffer theFBOPtr,
2677                                      Standard_Integer& theWidth,    Standard_Integer& theHeight,
2678                                      Standard_Integer& theWidthMax, Standard_Integer& theHeightMax)
2679 {
2680   myGraphicDriver->FBOGetDimensions( MyCView, theFBOPtr,
2681                                      theWidth, theHeight,
2682                                      theWidthMax, theHeightMax );
2683 }
2684
2685 // =======================================================================
2686 // function : FBOChangeViewport
2687 // purpose  :
2688 // =======================================================================
2689 void Visual3d_View::FBOChangeViewport(Graphic3d_PtrFrameBuffer& theFBOPtr,
2690                                       const Standard_Integer theWidth, const Standard_Integer theHeight)
2691 {
2692   myGraphicDriver->FBOChangeViewport( MyCView, theFBOPtr,
2693                                      theWidth, theHeight );
2694 }
2695
2696 // =======================================================================
2697 // function : BufferDump
2698 // purpose  :
2699 // =======================================================================
2700 Standard_Boolean Visual3d_View::BufferDump (Image_PixMap&               theImage,
2701                                             const Graphic3d_BufferType& theBufferType)
2702 {
2703   return myGraphicDriver->BufferDump (MyCView, theImage, theBufferType);
2704 }
2705
2706 // =======================================================================
2707 // function : EnableGLLight
2708 // purpose  :
2709 // =======================================================================
2710 void Visual3d_View::EnableGLLight( const Standard_Boolean enable ) const
2711 {
2712   myGraphicDriver->SetGLLightEnabled( MyCView, enable );
2713 }
2714
2715 // =======================================================================
2716 // function : IsGLLightEnabled
2717 // purpose  :
2718 // =======================================================================
2719 Standard_Boolean Visual3d_View::IsGLLightEnabled() const
2720 {
2721   return myGraphicDriver->IsGLLightEnabled( MyCView );
2722 }
2723
2724 // =======================================================================
2725 // function : Export
2726 // purpose  :
2727 // =======================================================================
2728 Standard_Boolean Visual3d_View::Export (const Standard_CString       theFileName,
2729                                         const Graphic3d_ExportFormat theFormat,
2730                                         const Graphic3d_SortType     theSortType,
2731                                         const Standard_Real          thePrecision,
2732                                         const Standard_Address       theProgressBarFunc,
2733                                         const Standard_Address       theProgressObject) const
2734 {
2735   Handle(Visual3d_Layer) anUnderLayer = myViewManager->UnderLayer();
2736   Handle(Visual3d_Layer) anOverLayer  = myViewManager->OverLayer();
2737
2738   Aspect_CLayer2d anOverCLayer;
2739   Aspect_CLayer2d anUnderCLayer;
2740   anOverCLayer.ptrLayer = anUnderCLayer.ptrLayer = NULL;
2741
2742   if (!anOverLayer.IsNull())
2743     anOverCLayer = anOverLayer->CLayer();
2744   if (!anUnderLayer.IsNull())
2745     anUnderCLayer = anUnderLayer->CLayer();
2746
2747   Standard_Integer aWidth, aHeight;
2748   Window()->Size (aWidth, aHeight);
2749
2750   return myGraphicDriver->Export (theFileName, theFormat, theSortType,
2751                                   aWidth, aHeight, MyCView, anUnderCLayer, anOverCLayer,
2752                                   thePrecision, theProgressBarFunc, theProgressObject);
2753 }
2754
2755 // =======================================================================
2756 // function : SetZLayerSettings
2757 // purpose  :
2758 // =======================================================================
2759 void Visual3d_View::SetZLayerSettings (const Standard_Integer theLayerId,
2760                                        const Graphic3d_ZLayerSettings& theSettings)
2761 {
2762   myGraphicDriver->SetZLayerSettings (MyCView, theLayerId, theSettings);
2763 }
2764
2765 // =======================================================================
2766 // function : AddZLayer
2767 // purpose  :
2768 // =======================================================================
2769 void Visual3d_View::AddZLayer (const Standard_Integer theLayerId)
2770 {
2771   myGraphicDriver->AddZLayer (MyCView, theLayerId);
2772 }
2773
2774 // =======================================================================
2775 // function : RemoveZLayer
2776 // purpose  :
2777 // =======================================================================
2778 void Visual3d_View::RemoveZLayer (const Standard_Integer theLayerId)
2779 {
2780   myGraphicDriver->RemoveZLayer (MyCView, theLayerId);
2781 }
2782
2783 // =======================================================================
2784 // function : ChangeZLayer
2785 // purpose  :
2786 // =======================================================================
2787 void Visual3d_View::ChangeZLayer (const Handle(Graphic3d_Structure)& theStructure,
2788                                   const Standard_Integer theLayerId)
2789 {
2790   myGraphicDriver->ChangeZLayer (*(theStructure->CStructure()), MyCView, theLayerId);
2791 }
2792
2793 // =======================================================================
2794 // function : Print
2795 // purpose  :
2796 // =======================================================================
2797 Standard_Boolean Visual3d_View::Print (const Aspect_Handle    thePrintDC, 
2798                                        const Standard_Boolean theToShowBackground,
2799                                        const Standard_CString theFilename,
2800                                        const Aspect_PrintAlgo thePrintAlgorithm,
2801                                        const Standard_Real    theScaleFactor) const
2802 {
2803   return Print (myViewManager->UnderLayer(),
2804                 myViewManager->OverLayer(),
2805                 thePrintDC, theToShowBackground,
2806                 theFilename, thePrintAlgorithm, 
2807                 theScaleFactor);
2808 }
2809
2810 // =======================================================================
2811 // function : Print
2812 // purpose  :
2813 // =======================================================================
2814 Standard_Boolean Visual3d_View::Print (const Handle(Visual3d_Layer)& theUnderLayer,
2815                                        const Handle(Visual3d_Layer)& theOverLayer,
2816                                        const Aspect_Handle           thePrintDC,
2817                                        const Standard_Boolean        theToShowBackground,
2818                                        const Standard_CString        theFilename,
2819                                        const Aspect_PrintAlgo        thePrintAlgorithm,
2820                                        const Standard_Real           theScaleFactor) const
2821 {
2822   if (IsDeleted()
2823   || !IsDefined()
2824   || !IsActive()
2825   || !MyWindow->IsMapped())
2826   {
2827     return Standard_False;
2828   }
2829
2830   Aspect_CLayer2d anOverCLayer;
2831   Aspect_CLayer2d anUnderCLayer;
2832   anOverCLayer.ptrLayer = anUnderCLayer.ptrLayer = NULL;
2833   if (!theOverLayer.IsNull())  anOverCLayer  = theOverLayer->CLayer();
2834   if (!theUnderLayer.IsNull()) anUnderCLayer = theUnderLayer->CLayer();
2835   return myGraphicDriver->Print (MyCView, anUnderCLayer, anOverCLayer,
2836                                  thePrintDC, theToShowBackground, theFilename,
2837                                  thePrintAlgorithm, theScaleFactor);
2838 }