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