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