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