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