e66712044dffb345d04c423cd97b6c7879bb9433
[occt.git] / src / Visual3d / Visual3d_View.cxx
1 // Copyright (c) 1995-1999 Matra Datavision
2 // Copyright (c) 1999-2012 OPEN CASCADE SAS
3 //
4 // The content of this file is subject to the Open CASCADE Technology Public
5 // License Version 6.5 (the "License"). You may not use the content of this file
6 // except in compliance with the License. Please obtain a copy of the License
7 // at http://www.opencascade.org and read it completely before using this file.
8 //
9 // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
10 // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
11 //
12 // The Original Code and all software distributed under the License is
13 // distributed on an "AS IS" basis, without warranty of any kind, and the
14 // Initial Developer hereby disclaims all such warranties, including without
15 // limitation, any warranties of merchantability, fitness for a particular
16 // purpose or non-infringement. Please see the License for the specific terms
17 // and conditions governing the rights and limitations under the License.
18
19 /***********************************************************************
20
21      FONCTION :
22      ----------
23         Classe Visual3d_View.cxx :
24
25
26         Declaration of variables specific to views.
27
28         A view is defined by :
29                 -  ViewManager
30                 -  ContextView
31                 -  ViewMapping
32                 -  ViewOrientation
33
34      HISTORIQUE DES MODIFICATIONS   :
35      --------------------------------
36       Mars 1992 : NW,JPB,CAL ; Creation.
37       04-02-97  : FMN ; Suppression de PSOutput, XWDOutput ...
38       22-04-97  : CAL ; Ajout du Plot.
39       03-06-97  : FMN ; Correction calcul SetRatio
40       06-05-97  : CAL ; Ajout du Clear sur les TOS_COMPUTED.
41       28-07-97  : PCT ; Ajout lumiere frontale headlight.
42       19-09-97  : CAL ; Remplacement de Window->Position par Window->Size;
43       17-10-97  : CAL ; Le Projects nouveau est arrive. (NewProjects)
44       24-10-97  : CAL ; Retrait de DownCast.
45       24-10-97  : CAL ; Retrait des DataStructure (Vieille maquette inutilisee).
46       17-11-97  : FMN ; Ajout DoResize dans Resized()
47       20-11-97  : CAL ; Disparition de la dependance avec math
48       ??-11-97  : CAL ; Retrait de la dependance avec math. Calcul developpe.
49       ??-11-97  : CAL ; Ajout de NumberOfDisplayedStructures
50       07-08-97  : PCT ; ajout support texture mapping
51       05-01-98  : CAL ; Ajout de AnimationMode
52       15-01-98  : FMN ; FRA60019 calcul Ratio pour MyViewMappingReset
53       15-01-98  : CAL ; Ajout de la transformation d'une TOS_COMPUTED
54       26-01-98  : CAL ; Ajout de la methode HaveTheSameOwner
55       06-02-98  : FMN ; CTS19079: TOP TEN: Probleme de highlight dans EDesigner.
56       05-03-98  : CAL ; GraphicTransform que si Trsf non invalidante
57       27-03-98  : CAL ; Ajout de TheStructure = devant Compute (...) !!!!
58       16-04-98  : CAL ; Remise a ID de la Trsf sur la COMPUTED
59       20-05-98  : CAL ; Perfs. Connection entre structures COMPUTED.
60       24-06-98  : CAL ; PRO14526 SetTransparency sur une vue non active.
61       17-07-98  : CAL ; PRO14872 test sur aTrsf dans ::SetTransform.
62       16-09-98  : BGN ; Points d'entree du Triedre (S3819, Phase 1)
63       22-09-98  : BGN ; S3989 (anciennement S3819)
64                         TypeOfTriedron* from Aspect (pas Visual3d)
65       06-10-98  : CAL ; Ajout d'un TIMER si CSF_GraphicTimer est definie.
66       16-10-98  : CAL ; Ajout d'un TIMER si CSF_GraphicTimer est definie.
67       02-11-98  : CAL ; Retrait de OSD::SetSignal.
68       18-11-98  : FMN ; Correction sur la gestion de la perspective
69       02-12-98  : CAL ; S4062. Ajout des layers.
70       13-09-99  : GG  ; GER61454 Adds LightLimit() and PlaneLimit() methods
71       10-11-99  : GG  ; PRO19603 Add Redraw( area ) method
72       14-01-00  : GG  ; IMP140100 Add ViewManager( ) method
73       22-10-01  : SAV ; Added EnableDepthTest() method.
74       30-04-02  : JMB ; MyDisplayStructure : use a Map instead of a Set (very bad performance
75                         in data access when a lot of objects are used)
76                         Will improve performance of selection mechanisms
77
78 ************************************************************************/
79
80 #define BUC60572        //GG_03-08-99    Add protection on Zclipping & Zcueing planes
81 //              positions.
82
83 #define BUC60570        //GG 14-09-99 Don't activates lighting
84 //                      when the view shading model is NONE.
85
86 #define GER61454        //GG 14-09-99 Activates model clipping planes
87
88 #define G003            //EUG 30-09-00 Degeneration management
89 //                                     Backfacing management
90
91 #define RIC120302       //GG Add a NEW SetWindow method which enable
92 //                      to connect a graphic widget and context to OGL.
93
94 //BUC61044 25/10/01 SAV ; added functionality to control gl depth testing from higher API
95 //BUC61045 25/10/01 SAV ; added functionality to control gl lighting from higher API
96
97 //OCC1188 SAV Added methods to set background image
98
99 /*----------------------------------------------------------------------*/
100 /*
101  * Constantes
102  */
103
104 #define NO_DEBUG
105 #define NO_DESTROY
106 #define NO_TRACE
107 #define NO_TRACE_ACCEPT
108 #define NO_TRACE_CLEAR
109 #define NO_TRACE_CONNECT
110 #define NO_TRACE_HIGH
111 #define NO_TRACE_COMP
112 #define NO_TRACE_TRSF
113 #define NO_TRACE_DISPLAY
114 #define NO_TRACE_ISCOMP
115 #define NO_TRACE_LENGTH
116 #define NO_TRACE_LAYER
117
118 /*----------------------------------------------------------------------*/
119 /*
120  * Includes
121  */
122
123 #ifdef WNT
124 #include <windows.h>
125 #endif
126
127 // for the class
128 #include <Visual3d_View.ixx>
129 #include <Visual3d_View.pxx>
130 #include <Visual3d_DepthCueingDefinitionError.hxx>
131 #include <Visual3d_ZClippingDefinitionError.hxx>
132
133 #ifdef OLD_METHOD
134 #include <math_Vector.hxx>
135 #endif /* OLD_METHOD */
136
137 #include <OSD.hxx>
138
139 #include <Graphic3d_Structure.hxx>
140 #include <Graphic3d_MapOfStructure.hxx>
141 #include <Graphic3d_MapIteratorOfMapOfStructure.hxx>
142 #include <Graphic3d_DataStructureManager.hxx>
143
144 #include <Graphic3d_GraphicDriver.hxx>
145
146 #include <Graphic3d_Vector.hxx>
147 #include <Graphic3d_Vertex.hxx>
148
149 #include <Visual3d_Light.hxx>
150 #include <Visual3d_SetOfLight.hxx>
151 #include <Visual3d_HSetOfLight.hxx>
152 #include <Visual3d_SetIteratorOfSetOfLight.hxx>
153
154 #include <Visual3d_ClipPlane.hxx>
155 #include <Visual3d_SetOfClipPlane.hxx>
156 #include <Visual3d_HSetOfClipPlane.hxx>
157 #include <Visual3d_SetIteratorOfSetOfClipPlane.hxx>
158
159 #include <Visual3d_SetIteratorOfSetOfView.hxx>
160
161 #include <Graphic3d_TextureEnv.hxx>
162
163 #include <TColStd_HArray2OfReal.hxx>
164
165 #if (defined(_WIN32) || defined(__WIN32__))
166   #include <WNT_Window.hxx>
167 #elif (defined(__APPLE__) && !defined(MACOSX_USE_GLX))
168   #include <Cocoa_Window.hxx>
169 #else
170   #include <Xw_Window.hxx>
171 #endif
172
173 #include <float.h>
174
175 //-Aliases
176
177 //-Global data definitions
178
179 //-Constructors
180
181 Visual3d_View::Visual3d_View (const Handle(Visual3d_ViewManager)& AManager):
182 MyContext (),
183 MyViewMapping (),
184 MyViewMappingReset (),
185 MyViewOrientation (),
186 MyViewOrientationReset (),
187 MyTransformation (0, 3, 0, 3),
188 MyMatrixOfMapping (0, 3, 0, 3),
189 MyMatrixOfOrientation (0, 3, 0, 3),
190 MyTOCOMPUTESequence (),
191 MyCOMPUTEDSequence (),
192 MyDisplayedStructure ()
193 {
194 Standard_Integer i, j;
195
196         MyPtrViewManager        = AManager.operator->();
197         MyCView.ViewId          = int (AManager->Identification (this));
198         MyCView.Active          = 0;
199         MyCView.IsDeleted       = 0;
200
201         MyCView.WsId                  = -1;
202         MyCView.DefWindow.IsDefined   = 0;
203
204         MyCView.Context.NbActiveLight = 0;
205         MyCView.Context.NbActivePlane = 0;
206 #ifdef GER61454
207         MyCView.Context.ActivePlane   = NULL;
208 #endif
209
210         for (i=0; i<=3; i++)
211                 for (j=0; j<=3; j++)
212                         if (i == j)     MyTransformation (i, j) = 1.0;
213                         else            MyTransformation (i, j) = 0.0;
214
215 Standard_Real X, Y, Z;
216
217         (MyViewOrientation.ViewReferencePoint ()).Coord (X, Y, Z);
218         MyCView.Orientation.ViewReferencePoint.x        = float (X);
219         MyCView.Orientation.ViewReferencePoint.y        = float (Y);
220         MyCView.Orientation.ViewReferencePoint.z        = float (Z);
221         (MyViewOrientation.ViewReferencePlane ()).Coord (X, Y, Z);
222         MyCView.Orientation.ViewReferencePlane.x        = float (X);
223         MyCView.Orientation.ViewReferencePlane.y        = float (Y);
224         MyCView.Orientation.ViewReferencePlane.z        = float (Z);
225         (MyViewOrientation.ViewReferenceUp ()).Coord (X, Y, Z);
226         MyCView.Orientation.ViewReferenceUp.x           = float (X);
227         MyCView.Orientation.ViewReferenceUp.y           = float (Y);
228         MyCView.Orientation.ViewReferenceUp.z           = float (Z);
229
230 Standard_Real Sx, Sy, Sz;
231
232         MyViewOrientation.AxialScale(Sx, Sy, Sz);
233         MyCView.Orientation.ViewScaleX                  = float (Sx);
234         MyCView.Orientation.ViewScaleY                  = float (Sy);
235         MyCView.Orientation.ViewScaleZ                  = float (Sz);
236
237         // NKV : 23/07/07 - Define custom MODELVIEW matrix
238         MyCView.Orientation.IsCustomMatrix = 0;
239         memset( (float*)MyCView.Orientation.ModelViewMatrix, 0, 16*sizeof( float ) );
240         MyCView.Orientation.ModelViewMatrix[0][0] =
241         MyCView.Orientation.ModelViewMatrix[1][1] =
242         MyCView.Orientation.ModelViewMatrix[2][2] =
243         MyCView.Orientation.ModelViewMatrix[3][3] = 1.;
244         //
245
246 Standard_Real um, vm, uM, vM;
247
248         MyCView.Mapping.Projection      = int (MyViewMapping.Projection ());
249         (MyViewMapping.ProjectionReferencePoint ()).Coord (X, Y, Z);
250         MyCView.Mapping.ProjectionReferencePoint.x      = float (X);
251         MyCView.Mapping.ProjectionReferencePoint.y      = float (Y);
252         MyCView.Mapping.ProjectionReferencePoint.z      = float (Z);
253         MyCView.Mapping.ViewPlaneDistance       =
254                         float (MyViewMapping.ViewPlaneDistance ());
255         MyCView.Mapping.BackPlaneDistance       =
256                         float (MyViewMapping.BackPlaneDistance ());
257         MyCView.Mapping.FrontPlaneDistance      =
258                         float (MyViewMapping.FrontPlaneDistance ());
259         MyViewMapping.WindowLimit (um, vm, uM, vM);
260         MyCView.Mapping.WindowLimit.um  = float (um);
261         MyCView.Mapping.WindowLimit.vm  = float (vm);
262         MyCView.Mapping.WindowLimit.uM  = float (uM);
263         MyCView.Mapping.WindowLimit.vM  = float (vM);
264
265         // NKV : 23/07/07 - Define custom MODELVIEW matrix
266         MyCView.Mapping.IsCustomMatrix = 0;
267         memset( (float*)MyCView.Mapping.ProjectionMatrix, 0, 16*sizeof( float ) );
268         MyCView.Mapping.ProjectionMatrix[0][0] =
269         MyCView.Mapping.ProjectionMatrix[1][1] =
270         MyCView.Mapping.ProjectionMatrix[2][2] =
271         MyCView.Mapping.ProjectionMatrix[3][3] = 1.;
272         //
273
274         MyCView.Context.ZBufferActivity = -1;
275
276         MyMatOfMapIsEvaluated   = Standard_False;
277         MyMatOfOriIsEvaluated   = Standard_False;
278
279         DegenerateModeIsActive  = Standard_False;
280         AnimationModeIsActive   = Standard_False;
281
282         IsInitialized = Standard_False;
283 #ifdef G003
284         MyCView.IsDegenerates     = 0;
285         MyCView.IsDegeneratesPrev = 0;
286         ComputedModeIsActive      = Standard_False;
287         MyCView.Backfacing        = 0;
288 #endif  // G003
289
290         MyCView.ptrUnderLayer = 0;
291         MyCView.ptrOverLayer = 0;
292         MyCView.GContext = 0;
293         MyCView.GDisplayCB = 0;
294         MyCView.GClientData = 0;
295
296         MyGraphicDriver = MyViewManager->GraphicDriver();
297
298 }
299
300 Visual3d_View::Visual3d_View (const Handle(Visual3d_ViewManager)& AManager, const Visual3d_ViewOrientation& VO, const Visual3d_ViewMapping& VM, const Visual3d_ContextView& CTX):
301 MyTransformation (0, 3, 0, 3),
302 MyMatrixOfMapping (0, 3, 0, 3),
303 MyMatrixOfOrientation (0, 3, 0, 3),
304 MyTOCOMPUTESequence (),
305 MyCOMPUTEDSequence (),
306 MyDisplayedStructure ()
307 {
308 Standard_Integer i, j;
309
310         MyPtrViewManager        = AManager.operator->();
311         MyViewOrientation       = VO;
312         MyViewMapping           = VM;
313         MyContext               = CTX;
314         MyViewOrientationReset  = VO;
315         MyViewMappingReset      = VM;
316
317         MyCView.ViewId          = int (AManager->Identification (this));
318         MyCView.Active          = 0;
319         MyCView.IsDeleted       = 0;
320
321         MyCView.WsId                  = -1;
322         MyCView.DefWindow.IsDefined   = 0;
323
324         MyCView.Context.NbActiveLight = 0;
325         MyCView.Context.NbActivePlane = 0;
326 #ifdef GER61454
327         MyCView.Context.ActivePlane = NULL;
328 #endif
329
330         for (i=0; i<=3; i++)
331                 for (j=0; j<=3; j++)
332                         if (i == j)     MyTransformation (i, j) = 1.0;
333                         else            MyTransformation (i, j) = 0.0;
334
335 Standard_Real X, Y, Z;
336
337         (MyViewOrientation.ViewReferencePoint ()).Coord (X, Y, Z);
338         MyCView.Orientation.ViewReferencePoint.x        = float (X);
339         MyCView.Orientation.ViewReferencePoint.y        = float (Y);
340         MyCView.Orientation.ViewReferencePoint.z        = float (Z);
341         (MyViewOrientation.ViewReferencePlane ()).Coord (X, Y, Z);
342         MyCView.Orientation.ViewReferencePlane.x        = float (X);
343         MyCView.Orientation.ViewReferencePlane.y        = float (Y);
344         MyCView.Orientation.ViewReferencePlane.z        = float (Z);
345         (MyViewOrientation.ViewReferenceUp ()).Coord (X, Y, Z);
346         MyCView.Orientation.ViewReferenceUp.x           = float (X);
347         MyCView.Orientation.ViewReferenceUp.y           = float (Y);
348         MyCView.Orientation.ViewReferenceUp.z           = float (Z);
349
350 Standard_Real Sx, Sy, Sz;
351
352         MyViewOrientation.AxialScale(Sx, Sy, Sz);
353         MyCView.Orientation.ViewScaleX                  = float (Sx);
354         MyCView.Orientation.ViewScaleY                  = float (Sy);
355         MyCView.Orientation.ViewScaleZ                  = float (Sz);
356
357         // NKV : 23/07/07 - Define custom MODELVIEW matrix
358         if (MyViewOrientation.IsCustomMatrix()) {
359           MyCView.Orientation.IsCustomMatrix = 1;
360           for ( i = 0; i < 4; i++)
361             for ( j = 0; j < 4; j++)
362               MyCView.Orientation.ModelViewMatrix[i][j] =
363                 (Standard_ShortReal)MyViewOrientation.MyModelViewMatrix->Value(i,j);
364         }
365         else {
366           MyCView.Orientation.IsCustomMatrix = 0;
367           memset( (float*)MyCView.Orientation.ModelViewMatrix, 0, 16*sizeof( float ) );
368           MyCView.Orientation.ModelViewMatrix[0][0] =
369           MyCView.Orientation.ModelViewMatrix[1][1] =
370           MyCView.Orientation.ModelViewMatrix[2][2] =
371           MyCView.Orientation.ModelViewMatrix[3][3] = 1.;
372         }
373         //
374
375 Standard_Real um, vm, uM, vM;
376
377         MyCView.Mapping.Projection      = int (MyViewMapping.Projection ());
378         (MyViewMapping.ProjectionReferencePoint ()).Coord (X, Y, Z);
379         MyCView.Mapping.ProjectionReferencePoint.x      = float (X);
380         MyCView.Mapping.ProjectionReferencePoint.y      = float (Y);
381         MyCView.Mapping.ProjectionReferencePoint.z      = float (Z);
382         MyCView.Mapping.ViewPlaneDistance       =
383                         float (MyViewMapping.ViewPlaneDistance ());
384         MyCView.Mapping.BackPlaneDistance       =
385                         float (MyViewMapping.BackPlaneDistance ());
386         MyCView.Mapping.FrontPlaneDistance      =
387                         float (MyViewMapping.FrontPlaneDistance ());
388         MyViewMapping.WindowLimit (um, vm, uM, vM);
389         MyCView.Mapping.WindowLimit.um  = float (um);
390         MyCView.Mapping.WindowLimit.vm  = float (vm);
391         MyCView.Mapping.WindowLimit.uM  = float (uM);
392         MyCView.Mapping.WindowLimit.vM  = float (vM);
393
394         // NKV : 23/07/07 - Define custom MODELVIEW matrix
395         if (MyViewMapping.IsCustomMatrix()) {
396           MyCView.Mapping.IsCustomMatrix = 1;
397           for ( i = 0; i < 4; i++)
398             for ( j = 0; j < 4; j++)
399               MyCView.Mapping.ProjectionMatrix[i][j] =
400                 (Standard_ShortReal)MyViewMapping.MyProjectionMatrix->Value(i,j);
401         }
402         else {
403           MyCView.Mapping.IsCustomMatrix = 0;
404           memset( (float*)MyCView.Mapping.ProjectionMatrix, 0, 16*sizeof( float ) );
405           MyCView.Mapping.ProjectionMatrix[0][0] =
406           MyCView.Mapping.ProjectionMatrix[1][1] =
407           MyCView.Mapping.ProjectionMatrix[2][2] =
408           MyCView.Mapping.ProjectionMatrix[3][3] = 1.;
409         }
410         //
411
412         MyCView.Context.ZBufferActivity = -1;
413
414         MyMatOfMapIsEvaluated   = Standard_False;
415         MyMatOfOriIsEvaluated   = Standard_False;
416
417         IsInitialized = Standard_False;
418 #ifdef G003
419         AnimationModeIsActive     = Standard_False;
420         MyCView.IsDegenerates     = 0;
421         MyCView.IsDegeneratesPrev = 0;
422         ComputedModeIsActive      = Standard_False;
423 #endif  // G003
424
425         MyCView.ptrUnderLayer = 0;
426         MyCView.ptrOverLayer = 0;
427         MyCView.GContext = 0;
428         MyCView.GDisplayCB = 0;
429         MyCView.GClientData = 0;
430
431         MyGraphicDriver = MyViewManager->GraphicDriver();
432
433 }
434
435 //-Destructors
436
437 //-Methods, in order
438 // RIC120302
439 void Visual3d_View::SetWindow (const Handle(Aspect_Window)&      AWindow,
440                                const Aspect_RenderingContext     AContext,
441                                const Aspect_GraphicCallbackProc& ADisplayCB,
442                                const Standard_Address            AClientData)
443 {
444   if (IsDeleted ()) return;
445
446   if (IsDefined ())
447     Visual3d_ViewDefinitionError::Raise ("Window already defined");
448
449   MyCView.GContext        = AContext;
450   MyCView.GDisplayCB      = ADisplayCB;
451   MyCView.GClientData     = AClientData;
452   SetWindow(AWindow);
453 }
454 // RIC120302
455
456 void Visual3d_View::SetWindow (const Handle(Aspect_Window)& theWindow)
457 {
458
459         if (IsDeleted ()) return;
460
461         if (IsDefined ())
462                 Visual3d_ViewDefinitionError::Raise ("Window already defined");
463
464         MyWindow        = theWindow;
465         MyCView.WsId                    = MyCView.ViewId;
466         MyCView.DefWindow.IsDefined     = 1;
467
468 #if (defined(_WIN32) || defined(__WIN32__))
469   const Handle(WNT_Window) aWin   = Handle(WNT_Window)::DownCast (theWindow);
470   MyCView.DefWindow.XWindow       = (HWND )(aWin->HWindow());
471   MyCView.DefWindow.XParentWindow = (HWND )(aWin->HParentWindow());
472   WNT_WindowData* aWinData = (WNT_WindowData* )GetWindowLongPtr ((HWND )(aWin->HWindow()), GWLP_USERDATA);
473   aWinData->WNT_WDriver_Ptr = (void* )this;
474   aWinData->WNT_VMgr        = (void* )MyPtrViewManager;
475 #elif (defined(__APPLE__) && !defined(MACOSX_USE_GLX))
476   const Handle(Cocoa_Window) aWin = Handle(Cocoa_Window)::DownCast (theWindow);
477   MyCView.DefWindow.XWindow       = (Aspect_Drawable )aWin->HView();
478   MyCView.DefWindow.XParentWindow = NULL;
479   //MyCView.DefWindow.XParentWindow = aWin->HParentWindow();
480 #else
481   const Handle(Xw_Window) aWin    = Handle(Xw_Window)::DownCast (theWindow);
482   MyCView.DefWindow.XWindow       = aWin->XWindow();
483   MyCView.DefWindow.XParentWindow = aWin->XParentWindow();
484 #endif
485
486         Standard_Integer Width, Height;
487         theWindow->Size (Width, Height);
488
489         MyCView.DefWindow.dx    = float( Width );
490         MyCView.DefWindow.dy    = float( Height );
491
492         Standard_Real R, G, B;
493         MyBackground    = MyWindow->Background ();
494         (MyBackground.Color ()).Values (R, G, B, Quantity_TOC_RGB);
495         MyCView.DefWindow.Background.r  = float (R);
496         MyCView.DefWindow.Background.g  = float (G);
497         MyCView.DefWindow.Background.b  = float (B);
498
499         UpdateView ();
500         if (! MyGraphicDriver->View (MyCView))
501                 Visual3d_ViewDefinitionError::Raise ("Association failed");
502
503         MyGradientBackground = MyWindow->GradientBackground();
504         SetGradientBackground(MyGradientBackground,1);
505
506         Standard_Boolean AWait = Standard_False;        // => immediate update
507         MyGraphicDriver->SetVisualisation (MyCView);
508         MyGraphicDriver->AntiAliasing (MyCView, MyContext.AliasingIsOn ());
509         MyGraphicDriver->DepthCueing (MyCView, MyContext.DepthCueingIsOn ());
510         MyGraphicDriver->ClipLimit (MyCView, AWait);
511         MyGraphicDriver->Environment(MyCView);
512
513         // Make view manager z layer list consistent with the view's list.
514         MyViewManager->InstallZLayers (this);
515
516         // Update planses of model clipping
517         UpdatePlanes ();
518
519         // Update light sources
520         UpdateLights ();
521
522         /*
523          * Association view-window does not cause the display
524          * of structures that can be displayed in the new view.
525          * In fact, association view-window is done, but the
526          * display is produced only if the view is activated (Activate).
527          */
528
529         SetRatio ();
530
531 }
532
533 Handle(Aspect_Window) Visual3d_View::Window () const {
534
535         if (! IsDefined ())
536                 Visual3d_ViewDefinitionError::Raise ("Window not defined");
537
538         return (MyWindow);
539
540 }
541
542 Standard_Boolean Visual3d_View::IsDefined () const {
543
544         if (MyCView.DefWindow.IsDefined)
545                 return (Standard_True);
546         else
547                 return (Standard_False);
548
549 }
550
551 Standard_Boolean Visual3d_View::IsDeleted () const {
552
553         if (MyCView.IsDeleted)
554                 return (Standard_True);
555         else
556                 return (Standard_False);
557
558 }
559
560 void Visual3d_View::Destroy () {
561
562 #ifdef DESTROY
563         cout << "Visual3d_View::Destroy (" << Identification () << ")\n";
564 #endif
565
566         // Since MyPtrViewManager can be already distroyed,
567         // avoid attempts to access it in SetBackground()
568         MyPtrViewManager = 0;
569         Remove ();
570
571 }
572
573 void Visual3d_View::Remove () {
574
575 #ifdef DESTROY
576         cout << "Visual3d_View::Remove (" << Identification () << ")" << endl;
577 #endif
578
579         if (IsDeleted ()) return;
580         if (! IsDefined ()) return;
581
582         MyTOCOMPUTESequence.Clear ();
583         MyCOMPUTEDSequence.Clear ();
584         MyDisplayedStructure.Clear ();
585
586         Quantity_Color BlackColor (0.0, 0.0, 0.0, Quantity_TOC_RGB);
587         Aspect_Background BlackBackground (BlackColor);
588         SetBackground (BlackBackground);
589
590         Aspect_GradientBackground BlackGradBackground;
591         SetGradientBackground (BlackGradBackground,0);
592
593         if (MyPtrViewManager)
594           MyPtrViewManager->UnIdentification( MyCView.ViewId );
595
596         MyGraphicDriver->RemoveView (MyCView);
597
598         MyCView.WsId            = -1;
599         MyCView.IsDeleted       = 1;
600         MyCView.DefWindow.IsDefined     = 0;
601
602         MyMatOfMapIsEvaluated   = Standard_False;
603         MyMatOfOriIsEvaluated   = Standard_False;
604
605         IsInitialized = Standard_False;
606
607         MyWindow.Nullify ();
608
609 }
610
611 void Visual3d_View::Resized () {
612
613         if (IsDeleted ()) return;
614
615         if (! IsDefined ())
616                 Visual3d_ViewDefinitionError::Raise ("Window not defined");
617         MyWindow->DoResize() ;
618         SetRatio ();
619
620 }
621
622 void Visual3d_View::SetRatio () {
623
624         if (IsDeleted ()) return;
625
626 Aspect_TypeOfUpdate UpdateMode = MyViewManager->UpdateMode ();
627         MyViewManager->SetUpdateMode (Aspect_TOU_WAIT);
628
629 Standard_Real Umin, Vmin, Umax, Vmax;
630 Standard_Integer Dxw, Dyw;
631 Standard_Real Dxv, Dyv;
632 Standard_Real Xc, Yc;
633 Standard_Real Rap;
634
635         Rap     = 0. ;
636         MyWindow->Size (Dxw, Dyw);
637         MyViewMapping.WindowLimit(Umin,Vmin,Umax,Vmax) ;
638         Xc      = (Umin + Umax)/2. ; Yc = (Vmin + Vmax)/2. ;
639         Dxv     = Umax - Umin ; Dyv     = Vmax - Vmin ;
640         if( Dxw > 0 && Dyw > 0 ) Rap = (Standard_Real)Dyw/(Standard_Real)Dxw ;
641         if( Rap > 0.0 ) {
642
643             if( Dxv <= Dyv )
644             {
645                 if (Rap <= 1.0)
646                 {
647                     Dyv = Dxv;
648                     Dxv = Dxv/Rap;
649                 }
650                 else
651                 {
652                     Dxv = Dxv;
653                     Dyv = Dxv*Rap;
654                 }
655             }
656             else
657             {
658                 if (Rap <= 1.0)
659                 {
660                     Dxv = Dyv/Rap;
661                     Dyv = Dyv;
662                 }
663                 else
664                 {
665                     Dxv = Dyv;
666                     Dyv = Dyv*Rap;
667                 }
668             }
669
670             Umin        = Xc - Dxv/2. ; Vmin    = Yc - Dyv/2. ;
671             Umax        = Xc + Dxv/2. ; Vmax    = Yc + Dyv/2. ;
672
673             MyViewMapping.SetWindowLimit(Umin,Vmin,Umax,Vmax) ;
674
675             // Update before SetViewMapping.
676
677             MyCView.DefWindow.dx        = float( Dxw );
678             MyCView.DefWindow.dy        = float( Dyw );
679
680             SetViewMapping (MyViewMapping);
681 //          SetViewMappingDefault ();
682             // FMN+ Update Ratio for MyViewMappingReset
683
684             MyViewMappingReset.WindowLimit(Umin,Vmin,Umax,Vmax) ;
685             Xc  = (Umin + Umax)/2. ; Yc = (Vmin + Vmax)/2. ;
686             Dxv = Umax - Umin ; Dyv     = Vmax - Vmin ;
687
688             if( Dxv <= Dyv )
689             {
690                 if (Rap <= 1.0)
691                 {
692                     Dyv = Dxv;
693                     Dxv = Dxv/Rap;
694                 }
695                 else
696                 {
697                     Dxv = Dxv;
698                     Dyv = Dxv*Rap;
699                 }
700             }
701             else
702             {
703                 if (Rap <= 1.0)
704                 {
705                     Dxv = Dyv/Rap;
706                     Dyv = Dyv;
707                 }
708                 else
709                 {
710                     Dxv = Dyv;
711                     Dyv = Dyv*Rap;
712                 }
713             }
714
715             Umin        = Xc - Dxv/2. ; Vmin    = Yc - Dyv/2. ;
716             Umax        = Xc + Dxv/2. ; Vmax    = Yc + Dyv/2. ;
717
718             MyViewMappingReset.SetWindowLimit(Umin,Vmin,Umax,Vmax) ;
719
720             // FMN- Update Ratio for MyViewMappingReset
721
722             MyGraphicDriver->RatioWindow (MyCView);
723         }
724
725         // Force recalculation of 2 matrices.
726         //
727         // The current view can help to reconstruct a copied view
728         // that is itself. Owing to SetWindow and SetRatio the
729         // recalculation of matrices of this new view is imposed.
730         MyMatOfMapIsEvaluated   = Standard_False;
731         MyMatOfOriIsEvaluated   = Standard_False;
732
733         MyViewManager->SetUpdateMode (UpdateMode);
734         if (UpdateMode == Aspect_TOU_ASAP) Update ();
735
736 }
737
738 void Visual3d_View::UpdateLights () {
739
740 Standard_Integer i, j;
741 CALL_DEF_LIGHT *lights=NULL;
742
743 #ifdef BUC60570
744   if( MyContext.Model() == Visual3d_TOM_NONE ) {
745 // Activates only a white ambient light
746     MyCView.Context.NbActiveLight = 1;
747     lights      = new CALL_DEF_LIGHT [MyCView.Context.NbActiveLight];
748     MyCView.Context.ActiveLight = lights;
749
750     lights[0].WsId              = MyCView.ViewId;
751     lights[0].ViewId    = MyCView.ViewId;
752     lights[0].LightType = int (Visual3d_TOLS_AMBIENT);
753     lights[0].Active    = 1;
754     lights[0].LightId   = 0;
755     lights[0].Headlight = 0;
756     lights[0].Color.r   = lights[0].Color.g = lights[0].Color.b = 1.;
757   } else {
758 #endif
759         i       = MyContext.NumberOfActivatedLights ();
760         j       = MyGraphicDriver->InquireLightLimit ();
761         MyCView.Context.NbActiveLight   = (i > j ? j : i);
762
763         if (MyCView.Context.NbActiveLight > 0) {
764
765                 // Dynamic Allocation
766                 lights  = new CALL_DEF_LIGHT [MyCView.Context.NbActiveLight];
767
768                 MyCView.Context.ActiveLight     = lights;
769
770 Standard_Real X, Y, Z;
771
772 Standard_Real LightConcentration;
773 Standard_Real LightAttenuation1;
774 Standard_Real LightAttenuation2;
775 Standard_Real LightAngle;
776 Quantity_Color LightColor;
777 Graphic3d_Vertex LightPosition;
778 Graphic3d_Vector LightDirection;
779 Visual3d_TypeOfLightSource LightType=Visual3d_TOLS_AMBIENT;
780
781                 // Parcing of light sources
782                 for (j=0; j<MyCView.Context.NbActiveLight; j++) {
783                         LightType       = (MyContext.ActivatedLight (j+1))->LightType ();
784
785                         lights[j].WsId          = MyCView.ViewId;
786                         lights[j].ViewId        = MyCView.ViewId;
787
788                         lights[j].LightType     = int (LightType);
789                         lights[j].Active        = 1;
790                         lights[j].LightId       =
791                                 int ((MyContext.ActivatedLight (j+1))->Identification ());
792                         lights[j].Headlight = (MyContext.ActivatedLight (j+1))->Headlight ()? 1:0;
793
794                         switch (LightType) {
795
796                         case Visual3d_TOLS_AMBIENT :
797                                 (MyContext.ActivatedLight (j+1))->Values (
798                                                         LightColor
799                                                                 );
800                         break;
801
802                         case Visual3d_TOLS_POSITIONAL :
803                                 (MyContext.ActivatedLight (j+1))->Values (
804                                                         LightColor,
805                                                         LightPosition,
806                                                         LightAttenuation1,
807                                                         LightAttenuation2
808                                                                 );
809                         break;
810
811                         case Visual3d_TOLS_DIRECTIONAL :
812                                 (MyContext.ActivatedLight (j+1))->Values (
813                                                         LightColor,
814                                                         LightDirection
815                                                                 );
816                         break;
817
818                         case Visual3d_TOLS_SPOT :
819                                 (MyContext.ActivatedLight (j+1))->Values (
820                                                         LightColor,
821                                                         LightPosition,
822                                                         LightDirection,
823                                                         LightConcentration,
824                                                         LightAttenuation1,
825                                                         LightAttenuation2,
826                                                         LightAngle
827                                                                 );
828                         break;
829
830                         }
831
832                         lights[j].Color.r       = float (LightColor.Red ());
833                         lights[j].Color.g       = float (LightColor.Green ());
834                         lights[j].Color.b       = float (LightColor.Blue ());
835
836                         if ( (LightType == Visual3d_TOLS_POSITIONAL) ||
837                              (LightType == Visual3d_TOLS_SPOT) ) {
838                                 LightPosition.Coord (X, Y, Z);
839                                 lights[j].Position.x    = float (X);
840                                 lights[j].Position.y    = float (Y);
841                                 lights[j].Position.z    = float (Z);
842                         }
843
844                         if ( (LightType == Visual3d_TOLS_DIRECTIONAL) ||
845                              (LightType == Visual3d_TOLS_SPOT) ) {
846                                 LightDirection.Coord (X, Y, Z);
847                                 lights[j].Direction.x   = float (X);
848                                 lights[j].Direction.y   = float (Y);
849                                 lights[j].Direction.z   = float (Z);
850                         }
851
852                         if ( (LightType == Visual3d_TOLS_POSITIONAL) ||
853                              (LightType == Visual3d_TOLS_SPOT) ) {
854                                 lights[j].Attenuation[0] =
855                                         float (LightAttenuation1);
856                                 lights[j].Attenuation[1] =
857                                         float (LightAttenuation2);
858                         }
859
860                         if (LightType == Visual3d_TOLS_SPOT) {
861                                 lights[j].Concentration =
862                                         float (LightConcentration);
863                                 lights[j].Angle         =
864                                         float (LightAngle);
865                         }
866                 }
867
868         }
869 #ifdef BUC60570
870   }
871 #endif
872         // management of light sources
873         if (! IsDeleted ())
874                 if (IsDefined ())
875                         MyGraphicDriver->SetLight (MyCView);
876
877         // Dynamic allocation
878         if (MyCView.Context.NbActiveLight > 0) delete [] lights;
879
880 }
881
882 void Visual3d_View::UpdatePlanes () {
883
884 Standard_Integer i, j;
885 CALL_DEF_PLANE *planes=NULL;
886
887         i       = MyContext.NumberOfActivatedClipPlanes ();
888         j       = MyGraphicDriver->InquirePlaneLimit ();
889         MyCView.Context.NbActivePlane   = (i > j ? j : i);
890
891         if (MyCView.Context.NbActivePlane > 0) {
892
893                 // Dynamic Allocation
894 #ifdef GER61454 //Keep the plane address for the next Update !
895                 if( !MyCView.Context.ActivePlane )
896                    MyCView.Context.ActivePlane = new CALL_DEF_PLANE [j];
897                 planes = MyCView.Context.ActivePlane;
898 #else
899                 planes  = new CALL_DEF_PLANE [MyCView.Context.NbActivePlane];
900
901                 MyCView.Context.ActivePlane     = planes;
902 #endif
903 Standard_Real A, B, C, D;
904
905                 // Parcing of clipping planes
906                 for (j=0; j<MyCView.Context.NbActivePlane; j++) {
907
908                         planes[j].WsId          = MyCView.ViewId;
909                         planes[j].ViewId        = MyCView.ViewId;
910
911                         planes[j].Active        = 1;
912                         planes[j].PlaneId       =
913                                 int ((MyContext.ActivatedClipPlane (j+1))->Identification ());
914
915                         (MyContext.ActivatedClipPlane (j+1))->Plane (A, B, C, D);
916                         planes[j].CoefA         = float (A);
917                         planes[j].CoefB         = float (B);
918                         planes[j].CoefC         = float (C);
919                         planes[j].CoefD         = float (D);
920                 }
921
922         }
923
924         // Management of planes of clipping model
925         if (! IsDeleted ())
926                 if (IsDefined ())
927                         MyGraphicDriver->SetPlane (MyCView);
928
929         // Dynamic allocation
930 #ifdef GER61454
931         if ( MyCView.Context.ActivePlane && (MyCView.Context.NbActivePlane == 0)
932  ) {
933           delete [] MyCView.Context.ActivePlane;
934           MyCView.Context.ActivePlane = NULL;
935         }
936 #else
937         if (MyCView.Context.NbActivePlane > 0) delete [] planes;
938 #endif
939
940 }
941
942 void Visual3d_View::SetBackground (const Aspect_Background& ABack) {
943
944         if (IsDeleted ()) return;
945
946         if (! IsDefined ())
947                 Visual3d_ViewDefinitionError::Raise ("Window not defined");
948
949         // At this level, only GL can update the background.
950         // It is not necessary to call MyWindow->SetBackground (ABack); as
951         // this method starts update of window background by X
952         // (if the windowing is X)
953
954         Standard_Real R, G, B;
955         MyBackground    = ABack;
956         (MyBackground.Color ()).Values (R, G, B, Quantity_TOC_RGB);
957         MyCView.DefWindow.Background.r  = float (R);
958         MyCView.DefWindow.Background.g  = float (G);
959         MyCView.DefWindow.Background.b  = float (B);
960
961         MyGraphicDriver->Background (MyCView);
962
963         if (MyPtrViewManager && MyViewManager->UpdateMode () == Aspect_TOU_ASAP)
964           Update ();
965
966 }
967
968 void Visual3d_View::SetGradientBackground(const Aspect_GradientBackground& ABack, const Standard_Boolean update)
969 {
970
971   if (IsDeleted ()) return;
972
973   if (! IsDefined ())
974     Visual3d_ViewDefinitionError::Raise ("Window not defined");
975
976   MyGradientBackground = ABack;
977   Quantity_Color aCol1,aCol2;
978   MyGradientBackground.Colors(aCol1,aCol2);
979   MyGraphicDriver->GradientBackground(MyCView, aCol1, aCol2, MyGradientBackground.BgGradientFillMethod());
980
981   if ( update )
982      Update ();
983   else if (MyPtrViewManager && MyViewManager->UpdateMode () == Aspect_TOU_ASAP)
984     Update();
985 }
986
987 void Visual3d_View::SetBackgroundImage( const Standard_CString FileName,
988                                         const Aspect_FillMethod FillStyle,
989                                         const Standard_Boolean update )
990 {
991   if ( IsDeleted() )
992     return;
993   if ( !IsDefined() )
994     Visual3d_ViewDefinitionError::Raise ("Window not defined");
995
996   MyGraphicDriver->BackgroundImage( FileName, MyCView, FillStyle );
997
998   if ( update )
999     Update();
1000   else if ( MyViewManager->UpdateMode() == Aspect_TOU_ASAP )
1001     Update();
1002 }
1003
1004 void Visual3d_View::SetBgImageStyle( const Aspect_FillMethod FillStyle,
1005                                      const Standard_Boolean update )
1006 {
1007   if ( IsDeleted() )
1008     return;
1009   if ( !IsDefined() )
1010     Visual3d_ViewDefinitionError::Raise ("Window not defined");
1011
1012   MyGraphicDriver->SetBgImageStyle( MyCView, FillStyle );
1013
1014   if ( update )
1015     Update();
1016   else if ( MyViewManager->UpdateMode() == Aspect_TOU_ASAP )
1017     Update();
1018 }
1019
1020 Aspect_Background Visual3d_View::Background () const {
1021
1022         return (MyBackground);
1023
1024 }
1025
1026 void Visual3d_View::SetBgGradientStyle( const Aspect_GradientFillMethod FillStyle,
1027                                         const Standard_Boolean update )
1028 {
1029   if ( IsDeleted() )
1030     return;
1031   if ( !IsDefined() )
1032     Visual3d_ViewDefinitionError::Raise ("Window not defined");
1033
1034   MyGraphicDriver->SetBgGradientStyle( MyCView, FillStyle );
1035
1036   if ( update )
1037     Update();
1038   else if ( MyViewManager->UpdateMode() == Aspect_TOU_ASAP )
1039     Update();
1040
1041 }
1042
1043 Aspect_GradientBackground Visual3d_View::GradientBackground () const {
1044
1045         return MyGradientBackground;
1046
1047 }
1048
1049 void Visual3d_View::SetTransform (const TColStd_Array2OfReal& AMatrix) {
1050
1051         if (IsDeleted ()) return;
1052
1053 Standard_Integer lr, ur, lc, uc;
1054 Standard_Integer i, j;
1055
1056         // Assign the new transformation in an array [0..3][0..3]
1057         // Avoid problems if the has defined a matrice [1..4][1..4]
1058         //                                                 ou [3..6][-1..2] !!
1059         lr      = AMatrix.LowerRow ();
1060         ur      = AMatrix.UpperRow ();
1061         lc      = AMatrix.LowerCol ();
1062         uc      = AMatrix.UpperCol ();
1063
1064         if ( (ur - lr + 1 != 4) || (uc - lc + 1 != 4) )
1065                 Visual3d_TransformError::Raise ("Transform : not a 4x4 matrix");
1066
1067         for (i=0; i<=3; i++)
1068         for (j=0; j<=3; j++)
1069                 MyTransformation (i, j) = AMatrix (lr + i, lc + j);
1070
1071 Graphic3d_Vector VPN;
1072 Graphic3d_Vertex VRP;
1073 Graphic3d_Vector VUP;
1074 Standard_Real Sx, Sy, Sz;
1075
1076 Visual3d_ViewOrientation NewViewOrientation;
1077
1078         VPN     = MyViewOrientation.ViewReferencePlane ();
1079         VRP     = MyViewOrientation.ViewReferencePoint ();
1080         VUP     = MyViewOrientation.ViewReferenceUp ();
1081         MyViewOrientation.AxialScale(Sx, Sy, Sz);
1082
1083         NewViewOrientation.SetViewReferencePlane
1084                 (Graphic3d_Structure::Transforms (Transform (), VPN));
1085
1086         NewViewOrientation.SetViewReferencePoint
1087                 (Graphic3d_Structure::Transforms (Transform (), VRP));
1088
1089         NewViewOrientation.SetViewReferenceUp
1090                 (Graphic3d_Structure::Transforms (Transform (), VUP));
1091         NewViewOrientation.SetAxialScale(Sx, Sy, Sz);
1092
1093         SetViewOrientation (NewViewOrientation);
1094
1095         MyMatOfOriIsEvaluated   = Standard_False;
1096
1097 }
1098
1099 const TColStd_Array2OfReal& Visual3d_View::Transform () const {
1100
1101         return (MyTransformation);
1102
1103 }
1104
1105 void Visual3d_View::SetViewOrientation (const Visual3d_ViewOrientation& VO) {
1106
1107         if (IsDeleted ()) return;
1108
1109         MyViewOrientation       = VO;
1110         
1111         Standard_Real X, Y, Z;
1112         // Tests on modification of parameters.
1113         Standard_Boolean VUPIsModified  = Standard_False;
1114         Standard_Boolean VRPIsModified  = Standard_False;
1115         Standard_Boolean VRUIsModified  = Standard_False;
1116         Standard_Boolean ScaleIsModified  = Standard_False;
1117         Standard_Boolean CustomIsModified = Standard_False;
1118
1119         (MyViewOrientation.ViewReferencePoint ()).Coord (X, Y, Z);
1120         VUPIsModified =
1121            MyCView.Orientation.ViewReferencePoint.x != float (X)
1122         || MyCView.Orientation.ViewReferencePoint.y != float (Y)
1123         || MyCView.Orientation.ViewReferencePoint.z != float (Z);
1124         MyCView.Orientation.ViewReferencePoint.x        = float (X);
1125         MyCView.Orientation.ViewReferencePoint.y        = float (Y);
1126         MyCView.Orientation.ViewReferencePoint.z        = float (Z);
1127
1128         (MyViewOrientation.ViewReferencePlane ()).Coord (X, Y, Z);
1129         VRPIsModified =
1130            MyCView.Orientation.ViewReferencePlane.x != float (X)
1131         || MyCView.Orientation.ViewReferencePlane.y != float (Y)
1132         || MyCView.Orientation.ViewReferencePlane.z != float (Z);
1133         MyCView.Orientation.ViewReferencePlane.x        = float (X);
1134         MyCView.Orientation.ViewReferencePlane.y        = float (Y);
1135         MyCView.Orientation.ViewReferencePlane.z        = float (Z);
1136
1137         (MyViewOrientation.ViewReferenceUp ()).Coord (X, Y, Z);
1138         VRUIsModified =
1139            MyCView.Orientation.ViewReferenceUp.x != float (X)
1140         || MyCView.Orientation.ViewReferenceUp.y != float (Y)
1141         || MyCView.Orientation.ViewReferenceUp.z != float (Z);
1142         MyCView.Orientation.ViewReferenceUp.x           = float (X);
1143         MyCView.Orientation.ViewReferenceUp.y           = float (Y);
1144         MyCView.Orientation.ViewReferenceUp.z           = float (Z);
1145
1146         MyViewOrientation.AxialScale(X, Y, Z);
1147         ScaleIsModified =
1148            MyCView.Orientation.ViewScaleX != float (X)
1149         || MyCView.Orientation.ViewScaleY != float (Y)
1150         || MyCView.Orientation.ViewScaleZ != float (Z);
1151         MyCView.Orientation.ViewScaleX                  = float (X);
1152         MyCView.Orientation.ViewScaleY                  = float (Y);
1153         MyCView.Orientation.ViewScaleZ                  = float (Z);
1154
1155         CustomIsModified =
1156         MyCView.Orientation.IsCustomMatrix != MyViewOrientation.IsCustomMatrix();
1157         MyCView.Orientation.IsCustomMatrix = MyViewOrientation.IsCustomMatrix();
1158         if ( MyViewOrientation.IsCustomMatrix() ) {
1159           Standard_Integer i, j;
1160           for (i = 0; i < 4; i++)
1161             for (j = 0; j < 4; j++) {
1162              if (!CustomIsModified) CustomIsModified =
1163                MyCView.Orientation.ModelViewMatrix[i][j] != MyViewOrientation.MyModelViewMatrix->Value(i,j);
1164             }
1165         }
1166
1167 #ifdef TRACE_TRSF
1168         cout << "Visual3d_View::SetViewOrientation\n";
1169         if (VUPIsModified || VRPIsModified || VRUIsModified || ScaleIsModified || CustomIsModified)
1170           cout <<   "VUPIsModified : " << VUPIsModified
1171           << ", VRPIsModified : " << VRPIsModified
1172           << ", VRUIsModified : " << VRUIsModified
1173           << ", CustomIsModified : " << CustomIsModified
1174           << ", ScaleIsModified : " << ScaleIsModified << "\n" << flush;
1175         else
1176           cout << "no modification\n" << flush;
1177 #endif
1178
1179         // restart if one of parameters is modified
1180         if (!IsInitialized || VUPIsModified || VRPIsModified
1181             || VRUIsModified || ScaleIsModified || CustomIsModified) {
1182
1183         MyMatOfOriIsEvaluated = !VUPIsModified && !VRPIsModified
1184                               && !VRUIsModified && !ScaleIsModified;
1185     
1186         if (! IsDefined ()) return;
1187         
1188         Standard_Boolean AWait = Standard_False;        // => immediate update
1189         MyGraphicDriver->ViewOrientation (MyCView, AWait);
1190         IsInitialized = Standard_True;
1191         Compute ();
1192
1193         if (MyViewManager->UpdateMode () == Aspect_TOU_ASAP) Update ();
1194         }
1195
1196 }
1197
1198 Visual3d_ViewOrientation Visual3d_View::ViewOrientation () const {
1199
1200         return (MyViewOrientation);
1201
1202 }
1203
1204 Visual3d_ViewOrientation Visual3d_View::ViewOrientationDefault () const {
1205
1206         return (MyViewOrientationReset);
1207
1208 }
1209
1210 void Visual3d_View::SetViewOrientationDefault () {
1211
1212         MyViewOrientationReset.Assign (MyViewOrientation);
1213
1214 }
1215
1216 void Visual3d_View::ViewOrientationReset () {
1217
1218         if (IsDeleted ()) return;
1219
1220         MyViewOrientation       = MyViewOrientationReset;
1221
1222         Standard_Real X, Y, Z;
1223
1224         // Tests on modification of parameters.
1225         Standard_Boolean VUPIsModified  = Standard_False;
1226         Standard_Boolean VRPIsModified  = Standard_False;
1227         Standard_Boolean VRUIsModified  = Standard_False;
1228         Standard_Boolean ScaleIsModified  = Standard_False;
1229         Standard_Boolean CustomIsModified = Standard_False;
1230
1231         (MyViewOrientation.ViewReferencePoint ()).Coord (X, Y, Z);
1232         VUPIsModified =
1233            MyCView.Orientation.ViewReferencePoint.x != float (X)
1234         || MyCView.Orientation.ViewReferencePoint.y != float (Y)
1235         || MyCView.Orientation.ViewReferencePoint.z != float (Z);
1236         MyCView.Orientation.ViewReferencePoint.x        = float (X);
1237         MyCView.Orientation.ViewReferencePoint.y        = float (Y);
1238         MyCView.Orientation.ViewReferencePoint.z        = float (Z);
1239
1240         (MyViewOrientation.ViewReferencePlane ()).Coord (X, Y, Z);
1241         VRPIsModified =
1242            MyCView.Orientation.ViewReferencePlane.x != float (X)
1243         || MyCView.Orientation.ViewReferencePlane.y != float (Y)
1244         || MyCView.Orientation.ViewReferencePlane.z != float (Z);
1245         MyCView.Orientation.ViewReferencePlane.x        = float (X);
1246         MyCView.Orientation.ViewReferencePlane.y        = float (Y);
1247         MyCView.Orientation.ViewReferencePlane.z        = float (Z);
1248
1249         (MyViewOrientation.ViewReferenceUp ()).Coord (X, Y, Z);
1250         VRUIsModified =
1251            MyCView.Orientation.ViewReferenceUp.x != float (X)
1252         || MyCView.Orientation.ViewReferenceUp.y != float (Y)
1253         || MyCView.Orientation.ViewReferenceUp.z != float (Z);
1254         MyCView.Orientation.ViewReferenceUp.x           = float (X);
1255         MyCView.Orientation.ViewReferenceUp.y           = float (Y);
1256         MyCView.Orientation.ViewReferenceUp.z           = float (Z);
1257
1258         MyViewOrientation.AxialScale(X, Y, Z);
1259         ScaleIsModified =
1260            MyCView.Orientation.ViewScaleX != float (X)
1261         || MyCView.Orientation.ViewScaleY != float (Y)
1262         || MyCView.Orientation.ViewScaleZ != float (Z);
1263         MyCView.Orientation.ViewScaleX                  = float (X);
1264         MyCView.Orientation.ViewScaleY                  = float (Y);
1265         MyCView.Orientation.ViewScaleZ                  = float (Z);
1266
1267         CustomIsModified =
1268         MyCView.Orientation.IsCustomMatrix != MyViewOrientation.IsCustomMatrix();
1269         MyCView.Orientation.IsCustomMatrix = MyViewOrientation.IsCustomMatrix();
1270         if ( MyViewOrientation.IsCustomMatrix() ) {
1271           Standard_Integer i, j;
1272           for (i = 0; i < 4; i++)
1273             for (j = 0; j < 4; j++) {
1274              if (!CustomIsModified) CustomIsModified =
1275                MyCView.Orientation.ModelViewMatrix[i][j] != MyViewOrientation.MyModelViewMatrix->Value(i,j);
1276             }
1277         }
1278
1279
1280 #ifdef TRACE_TRSF
1281         cout << "Visual3d_View::ViewOrientationReset\n";
1282         if (VUPIsModified || VRPIsModified || VRUIsModified || ScaleIsModified || CustomIsModified)
1283           cout <<   "VUPIsModified : " << VUPIsModified
1284           << ", VRPIsModified : " << VRPIsModified
1285           << ", VRUIsModified : " << VRUIsModified
1286           << ", CustomIsModified : " << CustomIsModified
1287           << ", ScaleIsModified : " << ScaleIsModified << "\n" << flush;
1288         else
1289           cout << "no modification\n" << flush;
1290 #endif
1291
1292         // Restart if one of parameters is modified
1293         if (!IsInitialized || VUPIsModified || VRPIsModified
1294             || VRUIsModified || ScaleIsModified || CustomIsModified) {
1295               
1296         MyMatOfOriIsEvaluated = !VUPIsModified && !VRPIsModified
1297                               && !VRUIsModified && !ScaleIsModified;
1298
1299         if (! IsDefined ()) return;
1300
1301         Standard_Boolean AWait = Standard_False;        // => immediate update
1302         MyGraphicDriver->ViewOrientation (MyCView, AWait);
1303         IsInitialized = Standard_True;
1304         Compute ();
1305
1306         if (MyViewManager->UpdateMode () == Aspect_TOU_ASAP) Update ();
1307         }
1308 }
1309
1310 void Visual3d_View::SetViewMapping (const Visual3d_ViewMapping& VM) {
1311
1312         if (IsDeleted ()) return;
1313
1314 Visual3d_TypeOfProjection OldType = MyViewMapping.Projection ();
1315 Visual3d_TypeOfProjection NewType = VM.Projection ();
1316
1317         MyViewMapping   = VM;
1318
1319 Standard_Real X, Y, Z;
1320 Standard_Real um, vm, uM, vM;
1321
1322         MyCView.Mapping.Projection      = int (MyViewMapping.Projection ());
1323         (MyViewMapping.ProjectionReferencePoint ()).Coord (X, Y, Z);
1324         MyCView.Mapping.ProjectionReferencePoint.x      = float (X);
1325         MyCView.Mapping.ProjectionReferencePoint.y      = float (Y);
1326         MyCView.Mapping.ProjectionReferencePoint.z      = float (Z);
1327         MyCView.Mapping.ViewPlaneDistance       =
1328                         float (MyViewMapping.ViewPlaneDistance ());
1329         MyCView.Mapping.BackPlaneDistance       =
1330                         float (MyViewMapping.BackPlaneDistance ());
1331         MyCView.Mapping.FrontPlaneDistance      =
1332                         float (MyViewMapping.FrontPlaneDistance ());
1333         MyViewMapping.WindowLimit (um, vm, uM, vM);
1334         MyCView.Mapping.WindowLimit.um  = float (um);
1335         MyCView.Mapping.WindowLimit.vm  = float (vm);
1336         MyCView.Mapping.WindowLimit.uM  = float (uM);
1337         MyCView.Mapping.WindowLimit.vM  = float (vM);
1338
1339         MyCView.Mapping.IsCustomMatrix = MyViewMapping.IsCustomMatrix();
1340         if (MyViewMapping.IsCustomMatrix()) {
1341           Standard_Integer i, j;
1342           for (i = 0; i < 4; i++)
1343             for (j = 0; j < 4; j++)
1344               MyCView.Mapping.ProjectionMatrix[i][j] =
1345                 (Standard_ShortReal)MyViewMapping.MyProjectionMatrix->Value(i,j);
1346         }
1347
1348         MyMatOfMapIsEvaluated   = Standard_False;
1349
1350         if (! IsDefined ()) return;
1351
1352 Standard_Boolean AWait = Standard_False;        // => immediate update
1353         MyGraphicDriver->ViewMapping (MyCView, AWait);
1354
1355         // Passage Parallele/Perspective
1356         if (OldType != NewType)
1357                 Compute ();
1358
1359         if (MyViewManager->UpdateMode () == Aspect_TOU_ASAP) Update ();
1360
1361 }
1362
1363 Visual3d_ViewMapping Visual3d_View::ViewMapping () const {
1364
1365         return (MyViewMapping);
1366
1367 }
1368
1369 Visual3d_ViewMapping Visual3d_View::ViewMappingDefault () const {
1370
1371         return (MyViewMappingReset);
1372
1373 }
1374
1375 void Visual3d_View::SetViewMappingDefault () {
1376
1377         MyViewMappingReset.Assign (MyViewMapping);
1378
1379 }
1380
1381 void Visual3d_View::ViewMappingReset () {
1382
1383         if (IsDeleted ()) return;
1384
1385         MyViewMapping   = MyViewMappingReset;
1386
1387 Standard_Real X, Y, Z;
1388 Standard_Real um, vm, uM, vM;
1389
1390         MyCView.Mapping.Projection      = int (MyViewMapping.Projection ());
1391         (MyViewMapping.ProjectionReferencePoint ()).Coord (X, Y, Z);
1392         MyCView.Mapping.ProjectionReferencePoint.x      = float (X);
1393         MyCView.Mapping.ProjectionReferencePoint.y      = float (Y);
1394         MyCView.Mapping.ProjectionReferencePoint.z      = float (Z);
1395         MyCView.Mapping.ViewPlaneDistance       =
1396                         float (MyViewMapping.ViewPlaneDistance ());
1397         MyCView.Mapping.BackPlaneDistance       =
1398                         float (MyViewMapping.BackPlaneDistance ());
1399         MyCView.Mapping.FrontPlaneDistance      =
1400                         float (MyViewMapping.FrontPlaneDistance ());
1401         MyViewMapping.WindowLimit (um, vm, uM, vM);
1402         MyCView.Mapping.WindowLimit.um  = float (um);
1403         MyCView.Mapping.WindowLimit.vm  = float (vm);
1404         MyCView.Mapping.WindowLimit.uM  = float (uM);
1405         MyCView.Mapping.WindowLimit.vM  = float (vM);
1406
1407         MyCView.Mapping.IsCustomMatrix = MyViewMapping.IsCustomMatrix();
1408         if (MyViewMapping.IsCustomMatrix()) {
1409           Standard_Integer i, j;
1410           for (i = 0; i < 4; i++)
1411             for (j = 0; j < 4; j++)
1412               MyCView.Mapping.ProjectionMatrix[i][j] =
1413                 (Standard_ShortReal)MyViewMapping.MyProjectionMatrix->Value(i,j);
1414         }
1415
1416         MyMatOfMapIsEvaluated   = Standard_False;
1417
1418         if (! IsDefined ()) return;
1419
1420 Standard_Boolean AWait = Standard_False;        // => immediate update
1421         MyGraphicDriver->ViewMapping (MyCView, AWait);
1422
1423         if (MyViewManager->UpdateMode () == Aspect_TOU_ASAP) Update ();
1424
1425 }
1426
1427 void Visual3d_View::SetContext (const Visual3d_ContextView& CTX) {
1428
1429         if (IsDeleted ()) return;
1430
1431 Visual3d_TypeOfVisualization OldVisualMode;
1432 Visual3d_TypeOfVisualization NewVisualMode;
1433
1434         // To manage display only in case of
1435         // change of visualisation mode.
1436         OldVisualMode   = MyContext.Visualization ();
1437         NewVisualMode   = CTX.Visualization ();
1438
1439 Visual3d_TypeOfModel OldModel;
1440 Visual3d_TypeOfModel NewModel;
1441
1442         // To manage change of visualisation only in case
1443         // of change of mode of visualisation or of type of shading.
1444         OldModel        = MyContext.Model ();
1445         NewModel        = CTX.Model ();
1446
1447 Standard_Boolean OldAliasingMode;
1448 Standard_Boolean NewAliasingMode;
1449
1450         // To manage antialiasing only in case of change.
1451         OldAliasingMode = MyContext.AliasingIsOn ();
1452         NewAliasingMode = CTX.AliasingIsOn ();
1453
1454 Standard_Boolean OldDepthCueingMode;
1455 Standard_Boolean NewDepthCueingMode;
1456
1457 Standard_Real OldDepthCueingFrontPlane;
1458 Standard_Real NewDepthCueingFrontPlane;
1459 Standard_Real OldDepthCueingBackPlane;
1460 Standard_Real NewDepthCueingBackPlane;
1461
1462         // To manage the depth cueing only in case of change.
1463         OldDepthCueingMode              = MyContext.DepthCueingIsOn ();
1464         NewDepthCueingMode              = CTX.DepthCueingIsOn ();
1465
1466         OldDepthCueingFrontPlane        = MyContext.DepthCueingFrontPlane ();
1467         NewDepthCueingFrontPlane        = CTX.DepthCueingFrontPlane ();
1468         OldDepthCueingBackPlane         = MyContext.DepthCueingBackPlane ();
1469         NewDepthCueingBackPlane         = CTX.DepthCueingBackPlane ();
1470
1471 Standard_Boolean OldFrontZClippingMode;
1472 Standard_Boolean NewFrontZClippingMode;
1473 Standard_Boolean OldBackZClippingMode;
1474 Standard_Boolean NewBackZClippingMode;
1475
1476 Standard_Real OldZClippingFrontPlane;
1477 Standard_Real NewZClippingFrontPlane;
1478 Standard_Real OldZClippingBackPlane;
1479 Standard_Real NewZClippingBackPlane;
1480
1481         // To manage the Zclipping only in case of change.
1482         OldFrontZClippingMode   = MyContext.FrontZClippingIsOn ();
1483         NewFrontZClippingMode   = CTX.FrontZClippingIsOn ();
1484         OldBackZClippingMode    = MyContext.BackZClippingIsOn ();
1485         NewBackZClippingMode    = CTX.BackZClippingIsOn ();
1486
1487         OldZClippingFrontPlane  = MyContext.ZClippingFrontPlane ();
1488         NewZClippingFrontPlane  = CTX.ZClippingFrontPlane ();
1489         OldZClippingBackPlane   = MyContext.ZClippingBackPlane ();
1490         NewZClippingBackPlane   = CTX.ZClippingBackPlane ();
1491
1492         Handle(Graphic3d_TextureEnv) aTexEnvOld = MyContext.TextureEnv();
1493         Handle(Graphic3d_TextureEnv) aTexEnvNew = CTX.TextureEnv();
1494
1495         Visual3d_TypeOfSurfaceDetail OldSurfaceDetail = MyContext.SurfaceDetail();
1496         Visual3d_TypeOfSurfaceDetail NewSurfaceDetail = CTX.SurfaceDetail();
1497
1498         MyContext       = CTX;
1499
1500         UpdateView ();
1501
1502 Standard_Boolean AWait = Standard_False;        // => immediate update
1503         if (IsDefined ()) {
1504                 // management of visualization modes and types of shading.
1505                 if ((OldVisualMode != NewVisualMode) || (OldModel != NewModel))
1506                         MyGraphicDriver->SetVisualisation (MyCView);
1507
1508                 // management of antialiasing.
1509                 if (OldAliasingMode != NewAliasingMode)
1510                 MyGraphicDriver->AntiAliasing (MyCView, NewAliasingMode);
1511
1512                 // management of depth_cueing.
1513                 if ((OldDepthCueingMode != NewDepthCueingMode) ||
1514                     (OldDepthCueingFrontPlane != NewDepthCueingFrontPlane) ||
1515                     (OldDepthCueingBackPlane != NewDepthCueingBackPlane)) {
1516 #ifdef BUC60572
1517                     if( NewDepthCueingMode &&
1518                         (NewDepthCueingBackPlane >= NewDepthCueingFrontPlane) )
1519                         Visual3d_DepthCueingDefinitionError::Raise
1520                         ("Bad value for DepthCueingPlanes position");
1521 #endif
1522                         MyGraphicDriver->DepthCueing
1523                                 (MyCView, NewDepthCueingMode);
1524                 }
1525
1526                 // management of Zclipping
1527                 if ((OldFrontZClippingMode != NewFrontZClippingMode) ||
1528                     (OldBackZClippingMode != NewBackZClippingMode) ||
1529                     (OldZClippingFrontPlane != NewZClippingFrontPlane) ||
1530                     (OldZClippingBackPlane != NewZClippingBackPlane)) {
1531 #ifdef BUC60572
1532                     if( NewBackZClippingMode && NewFrontZClippingMode &&
1533                         (NewZClippingBackPlane >= NewZClippingFrontPlane) )
1534                         Visual3d_ZClippingDefinitionError::Raise
1535                         ("Bad value for ZClippingPlanes position");
1536 #endif
1537                         MyGraphicDriver->ClipLimit (MyCView, AWait);
1538                 }
1539
1540                 // management of textures
1541                 if ((aTexEnvOld != aTexEnvNew) || (OldSurfaceDetail != NewSurfaceDetail))
1542                 {
1543                   MyGraphicDriver->Environment(MyCView);
1544                 }
1545
1546                 // Update of planes of model clipping
1547                 UpdatePlanes ();
1548
1549                 // Update of light sources
1550                 UpdateLights ();
1551         }
1552
1553         if (OldVisualMode != NewVisualMode) {
1554
1555                 /*
1556                  * Change of context =>
1557                  * Remove structures that cannot be displayed
1558                  * in the new visualisation mode.
1559                  * It is not necessary to warn ViewManager as
1560                  * this structure should not disappear from
1561                  * the list of structures displayed in it.
1562                  */
1563 Graphic3d_MapIteratorOfMapOfStructure S1Iterator (MyDisplayedStructure);
1564 Visual3d_TypeOfAnswer Answer;
1565
1566                 Standard_Integer i      = MyDisplayedStructure.Extent ();
1567
1568 Graphic3d_SequenceOfStructure FooSequence;
1569
1570                 while (S1Iterator.More ()) {
1571                         Answer  = AcceptDisplay (S1Iterator.Key ());
1572                         // If the structure can't be displayed in the
1573                         // new context of the view, it is removed.
1574                         if ((Answer == Visual3d_TOA_NO) ||
1575                             (Answer == Visual3d_TOA_COMPUTE))
1576                                 //Erase (S1Iterator.Key (), Aspect_TOU_WAIT);
1577                                 FooSequence.Append (S1Iterator.Key ());
1578
1579                         // S1Iterator.Next () is located on the next structure
1580                         S1Iterator.Next ();
1581                 }
1582
1583 Standard_Integer Length = FooSequence.Length ();
1584                 // The stored structures are removed
1585                 for (i=1; i<=Length; i++)
1586                         Erase (FooSequence.Value (i), Aspect_TOU_WAIT);
1587                 if (Length != 0) FooSequence.Clear ();
1588
1589                 /*
1590                  * Change of context =>
1591                  * Display structures that can be displayed
1592                  * with the new visualisation mode.
1593                  * All structures with status Displayed are removed from the ViewManager
1594                  * and displayed in the view directly, if the structure is not already
1595                  * displayed and if the view accepts it in its context.
1596                  */
1597
1598                 i       = MyViewManager->NumberOfDisplayedStructures ();
1599                 Graphic3d_MapOfStructure Map;
1600                 MyViewManager->DisplayedStructures(Map);
1601                 Graphic3d_MapIteratorOfMapOfStructure it(Map);
1602
1603                 for (; it.More(); it.Next()) {
1604                   Handle(Graphic3d_Structure) SG = it.Key();
1605                     if (! IsDisplayed (SG)) {
1606                       Answer = AcceptDisplay(SG);
1607                         // If the structure can be displayed in the
1608                         // new context of the view, it is displayed.
1609                         if ((Answer == Visual3d_TOA_YES) ||
1610                             (Answer == Visual3d_TOA_COMPUTE))
1611                             //Display (MyViewManager->DisplayedStructure (j),
1612                                 //Aspect_TOU_WAIT);
1613                         FooSequence.Append (SG);
1614                     }
1615                 }
1616
1617                 Length  = FooSequence.Length ();
1618                 // The stored structures are displayed
1619                 for (i=1; i<=Length; i++)
1620                         Display (FooSequence.Value (i), Aspect_TOU_WAIT);
1621                 if (Length != 0) FooSequence.Clear ();
1622         }
1623
1624         if (MyViewManager->UpdateMode () == Aspect_TOU_ASAP) Update ();
1625
1626 }
1627
1628 const Visual3d_ContextView& Visual3d_View::Context () const {
1629
1630         return (MyContext);
1631
1632 }
1633
1634 void Visual3d_View::DisplayedStructures (Graphic3d_MapOfStructure& SG) const
1635 {
1636
1637   if (IsDeleted ()) return;
1638
1639   Graphic3d_MapIteratorOfMapOfStructure Iterator (MyDisplayedStructure);
1640
1641   while (Iterator.More ()) {
1642     SG.Add (Iterator.Key ());
1643
1644     // Iterator.Next () is located on the next structure
1645     Iterator.Next ();
1646   }
1647
1648 }
1649
1650 void Visual3d_View::Activate () {
1651
1652         if (IsDeleted ()) return;
1653
1654         if (! IsDefined ())
1655                 Visual3d_ViewDefinitionError::Raise ("Window not defined");
1656
1657         if (! IsActive ()) {
1658
1659                 MyGraphicDriver->ActivateView (MyCView);
1660                 MyGraphicDriver->Background (MyCView);
1661                 MyGraphicDriver->Transparency
1662                         (MyCView, MyViewManager->Transparency ());
1663
1664                 MyCView.Active  = 1;
1665
1666                 /*
1667                  * Activation of a new view =>
1668                  * Display structures that can be displayed in this new view.
1669                  * All structures with status
1670                  * Displayed in ViewManager are returned and displayed in
1671                  * the view directly, if the structure is not already
1672                  * displayed and if the view accepts it in its context.
1673                  */
1674
1675                 Visual3d_TypeOfAnswer Answer;
1676                 Graphic3d_MapOfStructure Map;
1677                 MyViewManager->DisplayedStructures(Map);
1678                 Graphic3d_MapIteratorOfMapOfStructure it(Map);
1679
1680                 for (; it.More(); it.Next()) {
1681                   Handle(Graphic3d_Structure) SG = it.Key();
1682                     if (! IsDisplayed (SG)) {
1683                       Answer    = AcceptDisplay(SG);
1684                         // If the structure can be displayed in the
1685                         // new context of the view, it is displayed.
1686                         if ((Answer == Visual3d_TOA_YES) ||
1687                             (Answer == Visual3d_TOA_COMPUTE))
1688                         Display (SG,Aspect_TOU_WAIT);
1689                     }
1690                 }
1691
1692         }
1693
1694         // If the activation/desactivation of ZBuffer should be automatic
1695         // depending on the presence or absence of facets.
1696         if (MyViewManager->ZBufferAuto ()) {
1697 Standard_Boolean BContainsFacet = ContainsFacet ();
1698 Standard_Boolean BZBuffer       = ZBufferIsActivated ();
1699                 // If the view contains facets
1700                 // and if ZBuffer is not active
1701                 if (BContainsFacet && ! BZBuffer)
1702                         SetZBufferActivity (1);
1703                 // If the view does not contain facets
1704                 // and if ZBuffer is active
1705                 if (! BContainsFacet && BZBuffer)
1706                         SetZBufferActivity (0);
1707         }
1708
1709         if (MyViewManager->UpdateMode () == Aspect_TOU_ASAP) Update ();
1710
1711 }
1712
1713 Standard_Boolean Visual3d_View::IsActive () const {
1714
1715         if (IsDeleted ()) return (Standard_False);
1716
1717         if (MyCView.Active)
1718                 return (Standard_True);
1719         else
1720                 return (Standard_False);
1721
1722 }
1723
1724 void Visual3d_View::Deactivate () {
1725
1726         if (IsDeleted ()) return;
1727
1728         if (! IsDefined ())
1729                 Visual3d_ViewDefinitionError::Raise ("Window not defined");
1730
1731         if (IsActive ()) {
1732
1733                 MyGraphicDriver->DeactivateView (MyCView);
1734
1735                 /*
1736                  * Deactivation of a view =>
1737                  * Removal of structures displayed in this view.
1738                  * All structures with status
1739                  * Displayed in ViewManager are returned and removed from
1740                  * the view directly, if the structure is not already
1741                  * displayed and if the view accepts it in its context.
1742                 */
1743
1744                 Visual3d_TypeOfAnswer Answer;
1745                 Graphic3d_MapOfStructure Map;
1746                 MyViewManager->DisplayedStructures(Map);
1747                 Graphic3d_MapIteratorOfMapOfStructure it(Map);
1748
1749                 for (; it.More(); it.Next()) {
1750                   Handle(Graphic3d_Structure) SG = it.Key();
1751                     if (! IsDisplayed (SG)) {
1752                         Answer  = AcceptDisplay(SG);
1753                         // If the structure was displayed it is removed.
1754                         if ((Answer == Visual3d_TOA_YES) ||
1755                             (Answer == Visual3d_TOA_COMPUTE))
1756                                 Erase (SG,Aspect_TOU_WAIT);
1757                     }
1758                 }
1759
1760                 if (MyViewManager->UpdateMode () == Aspect_TOU_ASAP) Update ();
1761
1762                 // No action currently possible in the view
1763                 MyCView.Active  = 0;
1764         }
1765
1766 }
1767
1768 void Visual3d_View::Redraw () {
1769
1770         Redraw (MyViewManager->UnderLayer (), MyViewManager->OverLayer ());
1771
1772 }
1773
1774 void Visual3d_View::Redraw (const Standard_Integer x, const Standard_Integer y, const Standard_Integer width, const Standard_Integer height) {
1775
1776         Redraw (MyViewManager->UnderLayer (), MyViewManager->OverLayer (), x, y, width, height);
1777 }
1778
1779 void Visual3d_View::Redraw (const Handle(Visual3d_Layer)& AnUnderLayer, const Handle(Visual3d_Layer)& AnOverLayer) {
1780
1781         if (IsDeleted ()) return;
1782
1783         if ((! IsDefined ()) || (! IsActive ())) return;
1784
1785         if (! MyWindow->IsMapped ()) return;
1786
1787         // san - 14/04/2004 - set up Z buffer state before redrawing
1788        // If the activation/desactivation of ZBuffer should be automatic
1789         // depending on the presence or absence of facets.
1790         if (MyViewManager->ZBufferAuto ()) {
1791                 Standard_Boolean BContainsFacet = ContainsFacet ();
1792                 Standard_Boolean BZBuffer       = ZBufferIsActivated ();
1793                 // If the view contains facets
1794                 // and if ZBuffer is not active
1795                 if (BContainsFacet && ! BZBuffer)
1796                         SetZBufferActivity (1);
1797                 // If the view contains only facets
1798                 // and if ZBuffer is active
1799                 if (! BContainsFacet && BZBuffer)
1800                         SetZBufferActivity (0);
1801         }
1802
1803         Aspect_CLayer2d OverCLayer;
1804         Aspect_CLayer2d UnderCLayer;
1805         OverCLayer.ptrLayer = UnderCLayer.ptrLayer = NULL;
1806         if (! AnOverLayer.IsNull ()) OverCLayer = AnOverLayer->CLayer ();
1807         if (! AnUnderLayer.IsNull ()) UnderCLayer = AnUnderLayer->CLayer ();
1808         MyGraphicDriver->Redraw (MyCView, UnderCLayer, OverCLayer);
1809
1810 }
1811
1812 void Visual3d_View::Redraw (const Handle(Visual3d_Layer)& AnUnderLayer, const Handle(Visual3d_Layer)& AnOverLayer, const Standard_Integer x, const Standard_Integer y, const Standard_Integer width, const Standard_Integer height) {
1813
1814         if (IsDeleted ()) return;
1815
1816         if ((! IsDefined ()) || (! IsActive ())) return;
1817
1818         if (! MyWindow->IsMapped ()) return;
1819
1820         // san - 14/04/2004 - set up Z buffer state before redrawing
1821           // If activation/desactivation of ZBuffer should be automatic
1822         // depending on the presence or absence of facets.
1823         if (MyViewManager->ZBufferAuto ()) {
1824         Standard_Boolean BContainsFacet = ContainsFacet ();
1825         Standard_Boolean BZBuffer       = ZBufferIsActivated ();
1826                 // If the view contains facets
1827                 // and if ZBuffer is not active
1828                 if (BContainsFacet && ! BZBuffer)
1829                         SetZBufferActivity (1);
1830                 // If the view contains only facets
1831                 // and if ZBuffer is active
1832                 if (! BContainsFacet && BZBuffer)
1833                         SetZBufferActivity (0);
1834         }
1835
1836         Aspect_CLayer2d OverCLayer;
1837         Aspect_CLayer2d UnderCLayer;
1838         OverCLayer.ptrLayer = UnderCLayer.ptrLayer = NULL;
1839         if (! AnOverLayer.IsNull ()) OverCLayer = AnOverLayer->CLayer ();
1840         if (! AnUnderLayer.IsNull ()) UnderCLayer = AnUnderLayer->CLayer ();
1841         MyGraphicDriver->Redraw (MyCView, UnderCLayer, OverCLayer, x, y, width, height);
1842
1843 }
1844
1845 void Visual3d_View::Update () {
1846
1847         Update (MyViewManager->UnderLayer (), MyViewManager->OverLayer ());
1848
1849 }
1850
1851 void Visual3d_View::Update (const Handle(Visual3d_Layer)& AnUnderLayer, const Handle(Visual3d_Layer)& AnOverLayer) {
1852
1853         if (IsDeleted ()) return;
1854
1855         if ((! IsDefined ()) || (! IsActive ())) return;
1856
1857         if (! MyWindow->IsMapped ()) return;
1858
1859         // If activation/desactivation of ZBuffer should be automatic
1860         // depending on the presence or absence of facets.
1861         if (MyViewManager->ZBufferAuto ()) {
1862 Standard_Boolean BContainsFacet = ContainsFacet ();
1863 Standard_Boolean BZBuffer       = ZBufferIsActivated ();
1864                 // If the view contains facets
1865                 // and if ZBuffer is not active
1866                         if (BContainsFacet && ! BZBuffer)
1867                         SetZBufferActivity (1);
1868                    // If the view does not contain facets
1869                 // and if ZBuffer is active
1870                 if (! BContainsFacet && BZBuffer)
1871                         SetZBufferActivity (0);
1872         }
1873
1874 Aspect_CLayer2d OverCLayer;
1875 Aspect_CLayer2d UnderCLayer;
1876         OverCLayer.ptrLayer = UnderCLayer.ptrLayer = NULL;
1877         if (! AnUnderLayer.IsNull ()) UnderCLayer = AnUnderLayer->CLayer ();
1878         if (! AnOverLayer.IsNull ()) OverCLayer = AnOverLayer->CLayer ();
1879         //OSD::SetSignal (Standard_False);
1880         MyGraphicDriver->Update (MyCView, UnderCLayer, OverCLayer);
1881         //OSD::SetSignal (Standard_True);
1882
1883 }
1884
1885 Visual3d_TypeOfAnswer Visual3d_View::AcceptDisplay (const Handle(Graphic3d_Structure)& AStructure) const {
1886
1887 // Return type of visualization of the view
1888 Visual3d_TypeOfVisualization ViewType = MyContext.Visualization ();
1889
1890 // Return type of visualization of the structure
1891 Graphic3d_TypeOfStructure StructType = AStructure->Visual ();
1892
1893 Visual3d_TypeOfAnswer Result = Visual3d_TOA_NO;
1894
1895         if (StructType == Graphic3d_TOS_ALL)
1896                 // The structure accepts any type of view
1897                 Result  = Visual3d_TOA_YES;
1898         else {
1899                 if ((StructType == Graphic3d_TOS_SHADING)
1900                         && (ViewType == Visual3d_TOV_SHADING))
1901                         Result  = Visual3d_TOA_YES;
1902                 if ((StructType == Graphic3d_TOS_WIREFRAME)
1903                         && (ViewType == Visual3d_TOV_WIREFRAME))
1904                         Result  = Visual3d_TOA_YES;
1905                 if ((StructType == Graphic3d_TOS_COMPUTED)
1906                         && (ViewType == Visual3d_TOV_WIREFRAME))
1907                         Result  = Visual3d_TOA_COMPUTE;
1908                 if ((StructType == Graphic3d_TOS_COMPUTED)
1909                         && (ViewType == Visual3d_TOV_SHADING))
1910                         Result  = Visual3d_TOA_COMPUTE;
1911         }
1912
1913 #ifdef TRACE_ACCEPT
1914         if (Result == Visual3d_TOA_YES)
1915         cout << "YES = Visual3d_View" << MyCView.ViewId
1916              << "::AcceptDisplay (" << AStructure->Identification () << ")\n";
1917         if (Result == Visual3d_TOA_NO)
1918         cout << "NO = Visual3d_View" << MyCView.ViewId
1919              << "::AcceptDisplay (" << AStructure->Identification () << ")\n";
1920         if (Result == Visual3d_TOA_COMPUTE)
1921         cout << "COMPUTE = Visual3d_View" << MyCView.ViewId
1922              << "::AcceptDisplay (" << AStructure->Identification () << ")\n";
1923         cout << flush;
1924 #endif
1925
1926         return (Result);
1927
1928 }
1929
1930 void Visual3d_View::ChangeDisplayPriority (const Handle(Graphic3d_Structure)& AStructure, const Standard_Integer OldPriority, const Standard_Integer NewPriority) {
1931
1932         if (IsDeleted ()) return;
1933         if (! IsDefined ()) return;
1934         if (! IsActive ()) return;
1935         if (! IsDisplayed (AStructure)) return;
1936
1937 Standard_Integer Index = IsComputed (AStructure);
1938 #ifdef G003
1939         if (  Index != 0 && ComputedMode () && !DegenerateModeIsOn ()  )
1940 #else
1941         if ((Index != 0) && (! DegenerateModeIsOn ()))
1942 #endif  // G003
1943         {
1944 #ifdef TRACE
1945         Standard_Integer StructId = MyCOMPUTEDSequence.Value (Index)->Identification ();
1946         cout << "Visual3d_View" << MyCView.ViewId << "::ChangeDisplayPriority ("
1947              << AStructure->Identification () << "/" << StructId
1948              << ", " << OldPriority << ", " << NewPriority << ")\n";
1949         cout << flush;
1950 #endif
1951                 MyGraphicDriver->EraseStructure
1952                         (MyCView,
1953                          *(Graphic3d_CStructure *)
1954                             MyCOMPUTEDSequence.Value (Index)->CStructure ());
1955                 MyGraphicDriver->DisplayStructure
1956                         (MyCView,
1957                          *(Graphic3d_CStructure *)
1958                             MyCOMPUTEDSequence.Value (Index)->CStructure (),
1959                          int (NewPriority));
1960         }
1961         else {
1962 #ifdef TRACE
1963         Standard_Integer StructId = AStructure->Identification ();
1964         cout << "Visual3d_View" << MyCView.ViewId << "::ChangeDisplayPriority ("
1965              << AStructure->Identification () << "/" << StructId
1966              << ", " << OldPriority << ", " << NewPriority << ")\n";
1967         cout << flush;
1968 #endif
1969                 MyGraphicDriver->EraseStructure
1970                         (MyCView,
1971                          *(Graphic3d_CStructure *)AStructure->CStructure ());
1972                 MyGraphicDriver->DisplayStructure
1973                         (MyCView,
1974                          *(Graphic3d_CStructure *)AStructure->CStructure (),
1975                          int (NewPriority));
1976         }
1977
1978 }
1979
1980 void Visual3d_View::Clear (const Handle(Graphic3d_Structure)& AStructure, const Standard_Boolean WithDestruction) {
1981
1982 #ifdef TRACE_CLEAR
1983         cout << "Visual3d_View" << MyCView.ViewId << "::Clear ("
1984              << AStructure->Identification () << ")\n";
1985         cout << flush;
1986 #endif
1987
1988 Standard_Integer Index = IsComputed (AStructure);
1989         if (Index != 0) {
1990 #ifdef TRACE_CLEAR
1991         cout << "Structure " << AStructure->Identification ()
1992              << " calculated in the view "
1993              << Identification () << ", by structure "
1994              << MyCOMPUTEDSequence.Value (Index)->Identification ()
1995              << " is emptied.\n";
1996         cout << flush;
1997 #endif
1998                 MyCOMPUTEDSequence.Value (Index)->GraphicClear (WithDestruction);
1999                 MyCOMPUTEDSequence.Value (Index)->SetHLRValidation (Standard_False);
2000         }
2001
2002 }
2003
2004 void Visual3d_View::Connect (const Handle(Graphic3d_Structure)& AMother, const Handle(Graphic3d_Structure)& ADaughter) {
2005
2006 #ifdef TRACE_CONNECT
2007         cout << "Visual3d_View" << MyCView.ViewId << "::Connect ("
2008              << AMother->Identification ()
2009              << ADaughter->Identification () << ")\n";
2010         cout << flush;
2011 #endif
2012
2013 Standard_Integer IndexM = IsComputed (AMother);
2014 Standard_Integer IndexD = IsComputed (ADaughter);
2015
2016         if (IndexM != 0 && IndexD != 0) {
2017 #ifdef TRACE_CONNECT
2018         cout << "Structure " << AMother->Identification ()
2019              << " is connected to structure "
2020              << ADaughter->Identification () << endl;
2021         cout << "These structures are calculated.\n";
2022         cout << "In the view " << Identification ()
2023              << "Structure "
2024              << MyCOMPUTEDSequence.Value (IndexM)->Identification ()
2025              << " is connected to the structure "
2026              << MyCOMPUTEDSequence.Value (IndexD)->Identification ()
2027              << endl;
2028 #endif
2029                 MyCOMPUTEDSequence.Value (IndexM)->GraphicConnect (MyCOMPUTEDSequence.Value (IndexD));
2030         }
2031
2032 }
2033
2034 void Visual3d_View::Disconnect (const Handle(Graphic3d_Structure)& AMother, const Handle(Graphic3d_Structure)& ADaughter) {
2035
2036 #ifdef TRACE_CONNECT
2037         cout << "Visual3d_View" << MyCView.ViewId << "::Disconnect ("
2038              << AMother->Identification ()
2039              << ADaughter->Identification () << ")\n";
2040         cout << flush;
2041 #endif
2042
2043 Standard_Integer IndexM = IsComputed (AMother);
2044 Standard_Integer IndexD = IsComputed (ADaughter);
2045
2046         if (IndexM != 0 && IndexD != 0) {
2047 #ifdef TRACE_CONNECT
2048         cout << "Structure " << AMother->Identification ()
2049              << " is disconnected from the structure "
2050              << ADaughter->Identification () << endl;
2051         cout << "These structures are calculated.\n";
2052         cout << "In the view " << Identification ()
2053              << "Structure "
2054              << MyCOMPUTEDSequence.Value (IndexM)->Identification ()
2055              << " is disconnected from the structure "
2056              << MyCOMPUTEDSequence.Value (IndexD)->Identification ()
2057              << endl;
2058 #endif
2059                 MyCOMPUTEDSequence.Value (IndexM)->GraphicDisconnect (MyCOMPUTEDSequence.Value (IndexD));
2060         }
2061
2062 }
2063
2064 void Visual3d_View::Display (const Handle(Graphic3d_Structure)& AStructure) {
2065
2066         Display (AStructure, MyViewManager->UpdateMode ());
2067
2068 }
2069
2070 void Visual3d_View::Display (const Handle(Graphic3d_Structure)& AStructure, const Aspect_TypeOfUpdate AnUpdateMode) {
2071
2072         if (IsDeleted ()) return;
2073         if (! IsDefined ()) return;
2074         if (! IsActive ()) return;
2075
2076         // If Display on a structure present in the list
2077         // of calculated structures while it is not
2078         // or more, of calculated type =>
2079         // - removes it as well as the associated old computed
2080         // THis happens when hlhsr becomes again of type e
2081         // non computed after SetVisual.
2082 Standard_Integer Index = IsComputed (AStructure);
2083
2084         if ((Index != 0) && (AStructure->Visual () != Graphic3d_TOS_COMPUTED)) {
2085
2086 #ifdef TRACE_LENGTH
2087         if (MyTOCOMPUTESequence.Length () != MyCOMPUTEDSequence.Length ()) {
2088                 cout << "In Visual3d_View::Display, ";
2089                 cout << "TOCOMPUTE " << MyTOCOMPUTESequence.Length ()
2090                      << " != COMPUTED " << MyCOMPUTEDSequence.Length ()
2091                      << "\n" << flush;
2092         }
2093 #endif
2094                 MyTOCOMPUTESequence.Remove (Index);
2095                 MyCOMPUTEDSequence.Remove (Index);
2096
2097 #ifdef TRACE_LENGTH
2098         if (MyTOCOMPUTESequence.Length () != MyCOMPUTEDSequence.Length ())
2099                 cout << "\tTOCOMPUTE " << MyTOCOMPUTESequence.Length ()
2100                      << " != COMPUTED " << MyCOMPUTEDSequence.Length ()
2101                      << "\n" << flush;
2102 #endif
2103                 Index = 0;
2104         }
2105
2106         Visual3d_TypeOfAnswer Answer = AcceptDisplay (AStructure);
2107
2108 #ifdef TRACE_DISPLAY
2109         Standard_Integer StructId = AStructure->Identification ();
2110         cout << "Visual3d_View" << MyCView.ViewId << "::Display ("
2111              << StructId << ");\n";
2112         cout << flush;
2113 #endif
2114
2115         if (Answer == Visual3d_TOA_NO) {
2116 #ifdef TRACE_DISPLAY
2117                 cout << "Answer : Visual3d_TOA_NO\n";
2118                 cout << flush;
2119 #endif
2120                 return;
2121         }
2122
2123         // Mode degenerated active
2124 #ifdef G003
2125         if (  !ComputedMode () || DegenerateModeIsOn ()  )
2126                                         Answer = Visual3d_TOA_YES;
2127 #else
2128         if (DegenerateModeIsOn ()) Answer = Visual3d_TOA_YES;
2129 ;
2130 #endif  // G003
2131
2132         if (Answer == Visual3d_TOA_YES ) {
2133 #ifdef TRACE_DISPLAY
2134                 cout << "Answer : Visual3d_TOA_YES\n";
2135                 cout << flush;
2136 #endif
2137                 if (IsDisplayed (AStructure)) return;
2138                 MyGraphicDriver->DisplayStructure (
2139                         MyCView,
2140                         *(Graphic3d_CStructure *)AStructure->CStructure (),
2141                         int (AStructure->DisplayPriority ())
2142                 );
2143                 MyDisplayedStructure.Add (AStructure);
2144                 if (AnUpdateMode == Aspect_TOU_ASAP) Update ();
2145         }
2146
2147         if (Answer == Visual3d_TOA_COMPUTE) {
2148 #ifdef TRACE_DISPLAY
2149             cout << "Answer : Visual3d_TOA_COMPUTE\n";
2150             cout << "Index : " << Index << "\n" << flush;
2151 #endif
2152             if (Index != 0) {
2153                 // Already computed, is COMPUTED still valid?
2154 #ifdef TRACE_DISPLAY
2155                 if (MyCOMPUTEDSequence.Value (Index)->HLRValidation ()) {
2156                   cout << "Structure "
2157                      << MyTOCOMPUTESequence.Value (Index)->Identification ()
2158                      << "already calculated, in the view "
2159                      << Identification () << ", par la structure "
2160                      << MyCOMPUTEDSequence.Value (Index)->Identification ()
2161                      << "\n was not recalculated as HLR is valid\n";
2162                   cout << flush;
2163                 }
2164                 else {
2165                   cout << "Structure "
2166                      << MyTOCOMPUTESequence.Value (Index)->Identification ()
2167                      << " already calculated, in the view "
2168                      << Identification () << ", by the structure "
2169                      << MyCOMPUTEDSequence.Value (Index)->Identification ()
2170                      << "\n should be recalculated as HLR is invalid\n";
2171                   cout << flush;
2172                 }
2173 #endif
2174 Standard_Integer OldStructId =
2175         MyCOMPUTEDSequence.Value (Index)->Identification ();
2176
2177                 // Case COMPUTED valide
2178                 if (MyCOMPUTEDSequence.Value (Index)->HLRValidation ()) {
2179                     // to be displayed
2180                     if (! IsDisplayed (AStructure)) {
2181                         MyDisplayedStructure.Add (AStructure);
2182                         MyGraphicDriver->DisplayStructure (
2183                             MyCView,
2184                             *(Graphic3d_CStructure *)MyCOMPUTEDSequence.Value (Index)->CStructure (),
2185                             int (AStructure->DisplayPriority ())
2186                         );
2187                         if (AnUpdateMode == Aspect_TOU_ASAP) Update ();
2188                     }
2189                     return;
2190                 }
2191
2192                 // Case COMPUTED invalid
2193                 else {
2194                     // Is there another valid representation ?
2195                     // Find in the sequence of already calculated structures
2196                     // 1/ Structure having the same Owner as <AStructure>
2197                     // 2/ That is not <AStructure>
2198                     // 3/ The COMPUTED which of is valid
2199                     Standard_Integer NewIndex = HaveTheSameOwner (AStructure);
2200
2201                     // Case of COMPUTED invalid, WITH a valid of replacement
2202                     if (NewIndex != 0) {
2203                         // to be displayed
2204                         if (! IsDisplayed (AStructure)) {
2205                             MyCOMPUTEDSequence.SetValue
2206                                 (Index, MyCOMPUTEDSequence.Value (NewIndex));
2207                             OldStructId = MyCOMPUTEDSequence.Value (NewIndex)->
2208                                                         Identification ();
2209                             MyDisplayedStructure.Add (AStructure);
2210                             MyGraphicDriver->DisplayStructure (
2211                                 MyCView,
2212                                 *(Graphic3d_CStructure *)MyCOMPUTEDSequence.Value (NewIndex)->CStructure (),
2213                                 int (AStructure->DisplayPriority ())
2214                             );
2215                             if (AnUpdateMode == Aspect_TOU_ASAP) Update ();
2216                         }
2217                         return;
2218                     }
2219
2220                     // Cas COMPUTED invalid, WITHOUT a valid of replacement
2221                     else {
2222                         // COMPUTED is removed if displayed
2223                         if (IsDisplayed (AStructure))
2224                             MyGraphicDriver->EraseStructure (
2225                                 MyCView,
2226                                 *(Graphic3d_CStructure *)MyCOMPUTEDSequence.Value (Index)->CStructure ()
2227                             );
2228                     }
2229                 }
2230             } // if (Index != 0)
2231
2232             // Compute + Validation
2233 #ifdef OLD
2234 Handle(Graphic3d_Structure) TheStructure = AStructure->Compute (this);
2235 #else
2236 Handle(Graphic3d_Structure) TheStructure;
2237 TColStd_Array2OfReal ATrsf (0, 3, 0, 3);
2238             AStructure->Transform (ATrsf);
2239             if (Index != 0) {
2240 TColStd_Array2OfReal Ident (0, 3, 0, 3);
2241 Standard_Integer ii, jj;
2242         for (ii=0; ii<=3; ii++)
2243             for (jj=0; jj<=3; jj++)
2244                 Ident (ii, jj) = (ii == jj ? 1.0 : 0.0);
2245                 TheStructure = MyCOMPUTEDSequence.Value (Index);
2246                 TheStructure->SetTransform (Ident, Graphic3d_TOC_REPLACE);
2247                 if (AStructure->IsTransformed ()) {
2248                     AStructure->Compute (this, ATrsf, TheStructure);
2249                 }
2250                 else {
2251                     AStructure->Compute (this, TheStructure);
2252                 }
2253             }
2254             else {
2255                 if (AStructure->IsTransformed ()) {
2256                     TheStructure = AStructure->Compute (this, ATrsf);
2257                 }
2258                 else {
2259                     TheStructure = AStructure->Compute (this);
2260                 }
2261             }
2262 #endif
2263             TheStructure->SetHLRValidation (Standard_True);
2264
2265 #ifdef TRACE_LENGTH
2266         if (MyTOCOMPUTESequence.Length () != MyCOMPUTEDSequence.Length ())
2267                 cout << "\tTOCOMPUTE " << MyTOCOMPUTESequence.Length ()
2268                      << " != COMPUTED " << MyCOMPUTEDSequence.Length ()
2269                      << "\n" << flush;
2270 #endif
2271
2272             // TOCOMPUTE and COMPUTED associated to sequences are added
2273             MyTOCOMPUTESequence.Append (AStructure);
2274             MyCOMPUTEDSequence.Append (TheStructure);
2275
2276 #ifdef TRACE_LENGTH
2277         if (MyTOCOMPUTESequence.Length () != MyCOMPUTEDSequence.Length ())
2278                 cout << "\tTOCOMPUTE " << MyTOCOMPUTESequence.Length ()
2279                      << " != COMPUTED " << MyCOMPUTEDSequence.Length ()
2280                      << "\n" << flush;
2281 #endif
2282
2283             // The previous are removed if necessary
2284             if (Index != 0) {
2285                 MyTOCOMPUTESequence.Remove (Index);
2286                 MyCOMPUTEDSequence.Remove (Index);
2287             }
2288
2289 #ifdef TRACE_LENGTH
2290         if (MyTOCOMPUTESequence.Length () != MyCOMPUTEDSequence.Length ())
2291                 cout << "\tTOCOMPUTE " << MyTOCOMPUTESequence.Length ()
2292                      << " != COMPUTED " << MyCOMPUTEDSequence.Length ()
2293                      << "\n" << flush;
2294 #endif
2295
2296 // Return type of visualisation of the view
2297 Visual3d_TypeOfVisualization ViewType = MyContext.Visualization ();
2298
2299 // Of which type will be the computed ?
2300 Standard_Boolean ComputeWireframe = ((ViewType == Visual3d_TOV_WIREFRAME) &&
2301                 (AStructure->ComputeVisual () != Graphic3d_TOS_SHADING));
2302
2303 Standard_Boolean ComputeShading = ((ViewType == Visual3d_TOV_SHADING) &&
2304                 (AStructure->ComputeVisual () != Graphic3d_TOS_WIREFRAME));
2305
2306             if (ComputeWireframe)
2307                 TheStructure->SetVisual (Graphic3d_TOS_WIREFRAME);
2308             if (ComputeShading)
2309                 TheStructure->SetVisual (Graphic3d_TOS_SHADING);
2310
2311             if (! ComputeShading && ! ComputeWireframe)
2312                 Answer = Visual3d_TOA_NO;
2313             else
2314                 Answer = AcceptDisplay (TheStructure);
2315
2316             if (AStructure->IsHighlighted()) {
2317                 TheStructure->SetHighlightColor (AStructure->HighlightColor ());
2318                 TheStructure->GraphicHighlight (Aspect_TOHM_COLOR);
2319             }
2320
2321 #ifdef TRACE_DISPLAY
2322             cout << "Structure " << StructId
2323                  << " in the view " << Identification ()
2324                  << " is calculated by the structure "
2325                  << TheStructure->Identification ();
2326             if (Answer == Visual3d_TOA_YES)
2327                 cout << " and displayed\n";
2328             else
2329                 cout << " but not displayed\n";
2330             cout << flush;
2331 #endif
2332
2333             // It is displayed only if the calculated structure
2334             // has a proper type corresponding to the one of the view.
2335             if (Answer != Visual3d_TOA_NO) {
2336                 if (! IsDisplayed (AStructure))
2337                         MyDisplayedStructure.Add (AStructure);
2338                 MyGraphicDriver->DisplayStructure (
2339                         MyCView,
2340                         *(Graphic3d_CStructure *)TheStructure->CStructure (),
2341                         int (AStructure->DisplayPriority ())
2342                 );
2343                 if (AnUpdateMode == Aspect_TOU_ASAP) Update ();
2344             }
2345         } // Visual3d_TOA_COMPUTE
2346 }
2347
2348 void Visual3d_View::Erase (const Handle(Graphic3d_Structure)& AStructure) {
2349
2350         if (IsDeleted ()) return;
2351
2352         Erase (AStructure, MyViewManager->UpdateMode ());
2353
2354 }
2355
2356 void Visual3d_View::Erase (const Handle(Graphic3d_Structure)& AStructure, const Aspect_TypeOfUpdate AnUpdateMode) {
2357
2358 Standard_Integer StructId;
2359
2360         if (IsDeleted ()) return;
2361
2362         // No test on window as the structure is displayed only if
2363         // the window exists, so only one test is enough.
2364         if (IsDisplayed (AStructure)) {
2365 Visual3d_TypeOfAnswer Answer = AcceptDisplay (AStructure);
2366
2367                 // Degenerated mode is active
2368 #ifdef G003
2369                 if (  !ComputedMode () || DegenerateModeIsOn ()  )
2370                                         Answer = Visual3d_TOA_YES;
2371 #else
2372                 if (DegenerateModeIsOn ()) Answer = Visual3d_TOA_YES;
2373 #endif  // G003
2374
2375                 if (Answer != Visual3d_TOA_COMPUTE) {
2376                         MyGraphicDriver->EraseStructure (
2377                                 MyCView,
2378                                 *(Graphic3d_CStructure *)AStructure->CStructure ()
2379                         );
2380                 }
2381
2382                 if (Answer == Visual3d_TOA_COMPUTE) {
2383 Standard_Integer Index = IsComputed (AStructure);
2384 #ifdef TRACE_COMP
2385         cout << "Visual3d_View" << MyCView.ViewId << "::Erase ("
2386              << AStructure->Identification () << ");\n";
2387         cout << "Index : " << Index << "\n";
2388         cout << flush;
2389 #endif
2390 #ifdef G003
2391                     if (  Index != 0 && ComputedMode () &&
2392                                                 !DegenerateModeIsOn ()  )
2393 #else
2394                     if ((Index != 0) && (! DegenerateModeIsOn ()))
2395 #endif  // G003
2396                     {
2397                         StructId =
2398                         MyCOMPUTEDSequence.Value (Index)->Identification ();
2399 #ifdef TRACE_COMP
2400         cout << "Structure " << AStructure->Identification ()
2401              << " calculated, in the view "
2402              << Identification () << ", by the structure "
2403              << StructId << " is removed. \n";
2404         cout << flush;
2405 #endif
2406                         MyGraphicDriver->EraseStructure
2407                                 (MyCView, *(Graphic3d_CStructure *)MyCOMPUTEDSequence.Value (Index)->CStructure ());
2408                     }
2409                     // else is impossible
2410                 }
2411                 MyDisplayedStructure.Remove (AStructure);
2412                 if (AnUpdateMode == Aspect_TOU_ASAP) Update ();
2413         }
2414
2415 }
2416
2417 void Visual3d_View::Highlight (const Handle(Graphic3d_Structure)& AStructure, const Aspect_TypeOfHighlightMethod AMethod) {
2418
2419 #ifdef TRACE_HIGH
2420         cout << "Visual3d_View" << MyCView.ViewId << "::Highlight ("
2421              << AStructure->Identification () << ")\n";
2422         cout << flush;
2423 #endif
2424
2425 Standard_Integer Index = IsComputed (AStructure);
2426         if (Index != 0) {
2427 #ifdef TRACE_HIGH
2428         cout << "Structure " << AStructure->Identification ()
2429              << " calculated, in the view "
2430              << Identification () << ", by the structure "
2431              << MyCOMPUTEDSequence.Value (Index)->Identification ()
2432              << " passes in highlight mode.\n";
2433         cout << flush;
2434 #endif
2435                 (MyCOMPUTEDSequence.Value (Index))->SetHighlightColor
2436                         (AStructure->HighlightColor ());
2437                 (MyCOMPUTEDSequence.Value (Index))->GraphicHighlight (AMethod);
2438         }
2439
2440 }
2441
2442 void Visual3d_View::SetTransform (const Handle(Graphic3d_Structure)& AStructure, const TColStd_Array2OfReal& ATrsf) {
2443
2444 #ifdef TRACE_TRSF
2445         cout << "Visual3d_View" << MyCView.ViewId << "::Transform ("
2446              << AStructure->Identification () << ")\n";
2447         cout << flush;
2448 #endif
2449
2450 Standard_Integer Index = IsComputed (AStructure);
2451         if (Index != 0) {
2452 #ifdef TRACE_TRSF
2453         cout << "The structure " << AStructure->Identification ()
2454              << " calculated, in the view "
2455              << Identification () << ", by the structure "
2456              << MyCOMPUTEDSequence.Value (Index)->Identification ()
2457              << " is transformed.\n";
2458         cout << flush;
2459 #endif
2460                 // Test is somewhat light !
2461                 // trsf is transferred only if it is :
2462                 // a translation
2463                 // a scale
2464                 if (ATrsf (0, 1) != 0. || ATrsf (0, 2) != 0.
2465                  || ATrsf (1, 0) != 0. || ATrsf (1, 2) != 0.
2466                  || ATrsf (2, 0) != 0. || ATrsf (2, 1) != 0.)
2467                     ReCompute (AStructure);
2468                 else
2469                     MyCOMPUTEDSequence.Value (Index)->GraphicTransform (ATrsf);
2470         }
2471
2472 }
2473
2474 void Visual3d_View::UnHighlight (const Handle(Graphic3d_Structure)& AStructure) {
2475
2476 #ifdef TRACE_HIGH
2477         cout << "Visual3d_View" << MyCView.ViewId << "::UnHighlight ("
2478              << AStructure->Identification () << ")\n";
2479         cout << flush;
2480 #endif
2481
2482 Standard_Integer Index = IsComputed (AStructure);
2483         if (Index != 0) {
2484 #ifdef TRACE_HIGH
2485         cout << "Structure " << AStructure->Identification ()
2486              << " calculated, in the view "
2487              << Identification () << ", by the structure "
2488              << MyCOMPUTEDSequence.Value (Index)->Identification ()
2489              << " passes in unhighlight mode.\n";
2490         cout << flush;
2491 #endif
2492                 MyCOMPUTEDSequence.Value (Index)->GraphicUnHighlight ();
2493         }
2494
2495
2496 }
2497
2498 Standard_Integer Visual3d_View::IsComputed (const Handle(Graphic3d_Structure)& AStructure) const {
2499
2500 Standard_Integer StrId = AStructure->Identification ();
2501
2502 Standard_Integer Result = 0;
2503 Standard_Integer Length = MyTOCOMPUTESequence.Length ();
2504
2505         // Recherche de la structure <AStructure> dans la
2506         // sequence des structures deja calculees
2507         for (Standard_Integer i=1; i<=Length && Result==0; i++)
2508                 if ((MyTOCOMPUTESequence.Value (i))->Identification ()
2509                         == StrId) Result        = i;
2510 #ifdef TRACE_ISCOMP
2511         cout << "\n In the view " << Identification () << " the structure ";
2512         if (Result != 0)
2513                 cout << StrId << " is calculated by "
2514                      << MyCOMPUTEDSequence.Value (Result)->Identification ()
2515                      << "\n" << flush;
2516         else
2517                 cout << StrId << " is not calculated\n" << flush;
2518 #endif
2519
2520 #ifdef TRACE_LENGTH
2521         if (MyTOCOMPUTESequence.Length () != MyCOMPUTEDSequence.Length ()) {
2522                 cout << "In Visual3d_View::IsComputed, ";
2523                 cout << "TOCOMPUTE " << MyTOCOMPUTESequence.Length ()
2524                      << " != COMPUTED " << MyCOMPUTEDSequence.Length ()
2525                      << "\n" << flush;
2526         }
2527 #endif
2528
2529         return (Result);
2530
2531 }
2532
2533 Standard_Boolean Visual3d_View::IsDisplayed (const Handle(Graphic3d_Structure)& AStructure) const {
2534
2535 Standard_Boolean Result = Standard_False;
2536
2537         if (IsDeleted ()) return Result;
2538
2539         Result  = MyDisplayedStructure.Contains (AStructure);
2540
2541         return Result;
2542
2543 }
2544
2545 #ifdef IMPLEMENTED
2546 Standard_Boolean Visual3d_View::ContainsComputedStructure () const {
2547
2548 Standard_Boolean Result = Standard_False;
2549
2550         if (MyDisplayedStructure.IsEmpty ()) return Result;
2551
2552 Graphic3d_MapIteratorOfMapOfStructure Iterator (MyDisplayedStructure);
2553
2554         Standard_Integer i      = MyDisplayedStructure.Extent ();
2555
2556         // Stop at the first structure of type TOS_COMPUTED
2557         while (! Result && Iterator.More ()) {
2558                 Result  =
2559                 (((Iterator.Key ())->Visual ()) == Graphic3d_TOS_COMPUTED);
2560
2561                 // Iterator.Next () is located on the
2562                 // next structure
2563                 Iterator.Next ();
2564         }
2565
2566         return Result;
2567
2568 }
2569 #endif
2570
2571 Standard_Boolean Visual3d_View::ContainsFacet () const {
2572
2573         return ContainsFacet (MyDisplayedStructure);
2574
2575 }
2576
2577 Standard_Boolean Visual3d_View::ContainsFacet (const Graphic3d_MapOfStructure& ASet) const {
2578
2579 Standard_Boolean Result = Standard_False;
2580
2581         if (ASet.IsEmpty ()) return Result;
2582
2583 Graphic3d_MapIteratorOfMapOfStructure Iterator (ASet);
2584
2585         // Stop at the first structure containing a facet
2586         for ( Iterator.Initialize (ASet);
2587               Iterator.More () && ! Result;
2588               Iterator.Next ())
2589                 Result  = (Iterator.Key ())->ContainsFacet ();
2590
2591         return Result;
2592
2593 }
2594
2595 void Visual3d_View::MinMaxValues (Standard_Real& XMin, Standard_Real& YMin, Standard_Real& ZMin, Standard_Real& XMax, Standard_Real& YMax, Standard_Real& ZMax) const {
2596
2597         MinMaxValues
2598         (MyDisplayedStructure, XMin, YMin, ZMin, XMax, YMax, ZMax);
2599
2600 }
2601
2602 void Visual3d_View::MinMaxValues (const Graphic3d_MapOfStructure& ASet, Standard_Real& XMin, Standard_Real& YMin, Standard_Real& ZMin, Standard_Real& XMax, Standard_Real& YMax, Standard_Real& ZMax) const {
2603
2604   if (ASet.IsEmpty ()) {
2605     XMin = RealFirst ();
2606     YMin = RealFirst ();
2607     ZMin = RealFirst ();
2608
2609     XMax = RealLast ();
2610     YMax = RealLast ();
2611     ZMax = RealLast ();
2612   }
2613   else {
2614
2615   Standard_Real Xm, Ym, Zm, XM, YM, ZM;
2616   Graphic3d_MapIteratorOfMapOfStructure Iterator (ASet);
2617
2618   XMin = RealLast ();
2619   YMin = RealLast ();
2620   ZMin = RealLast ();
2621
2622   XMax = RealFirst ();
2623   YMax = RealFirst ();
2624   ZMax = RealFirst ();
2625
2626   for ( Iterator.Initialize (ASet);
2627         Iterator.More ();
2628         Iterator.Next ()) {
2629
2630       if ( (Iterator.Key ())->IsInfinite ()){
2631         //XMin, YMin .... ZMax are initialized by means of infinite line data
2632         (Iterator.Key ())->MinMaxValues (Xm, Ym, Zm, XM, YM, ZM);
2633         if ( Xm != RealFirst() && Xm < XMin )
2634           XMin = Xm ;
2635         if ( Ym != RealFirst() && Ym < YMin )
2636           YMin = Ym ;
2637         if ( Zm != RealFirst() && Zm < ZMin )
2638           ZMin = Zm ;
2639         if ( XM != RealLast()  && XM > XMax )
2640           XMax = XM ;
2641         if ( YM != RealLast()  && YM > YMax )
2642           YMax = YM ;
2643         if ( ZM != RealLast()  && ZM > ZMax )
2644           ZMax = ZM ;
2645       }
2646       // Only non-empty and non-infinite structures
2647       // are taken into account for calculation of MinMax
2648       if (! (Iterator.Key ())->IsInfinite () &&
2649           ! (Iterator.Key ())->IsEmpty ()) {
2650             (Iterator.Key ())->MinMaxValues(Xm, Ym, Zm, XM, YM, ZM);
2651           /* ABD 29/10/04  Transform Persistence of Presentation( pan, zoom, rotate ) */
2652           //"FitAll" operation ignores object with transform persitence parameter
2653           if( (Iterator.Key ())->TransformPersistenceMode() == Graphic3d_TMF_None )
2654           {
2655             if (Xm < XMin) XMin = Xm;
2656             if (Ym < YMin) YMin = Ym;
2657             if (Zm < ZMin) ZMin = Zm;
2658             if (XM > XMax) XMax = XM;
2659             if (YM > YMax) YMax = YM;
2660             if (ZM > ZMax) ZMax = ZM;
2661           }
2662         }
2663     }
2664
2665     // The following cases are relevant
2666     // For exemple if all structures are empty or infinite
2667     if (XMax < XMin) { Xm = XMin; XMin = XMax; XMax = Xm; }
2668     if (YMax < YMin) { Ym = YMin; YMin = YMax; YMax = Ym; }
2669     if (ZMax < ZMin) { Zm = ZMin; ZMin = ZMax; ZMax = Zm; }
2670   }
2671   Standard_Real Sx, Sy, Sz;
2672   MyViewOrientation.AxialScale(Sx, Sy, Sz);
2673   XMin = (Sx > 1. && XMin < RealFirst ()/Sx)?RealFirst (): XMin*Sx;
2674   XMax = (Sx > 1. && XMax > RealLast  ()/Sx)?RealLast  (): XMax*Sx;
2675   YMin = (Sy > 1. && YMin < RealFirst ()/Sy)?RealFirst (): YMin*Sy;
2676   YMax = (Sy > 1. && YMax > RealLast  ()/Sy)?RealLast  (): YMax*Sy;
2677   ZMin = (Sz > 1. && ZMin < RealFirst ()/Sz)?RealFirst (): ZMin*Sz;
2678   ZMax = (Sz > 1. && ZMax > RealLast  ()/Sz)?RealLast  (): ZMax*Sz;
2679 }
2680
2681 void Visual3d_View::MinMaxValues (Standard_Real& XMin, Standard_Real& YMin, Standard_Real& XMax, Standard_Real& YMax) {
2682
2683         MinMaxValues (MyDisplayedStructure, XMin, YMin, XMax, YMax);
2684
2685 }
2686
2687 void Visual3d_View::MinMaxValues (const Graphic3d_MapOfStructure& ASet, Standard_Real& XMin, Standard_Real& YMin, Standard_Real& XMax, Standard_Real& YMax) {
2688
2689 Standard_Real Xm, Ym, Zm, XM, YM, ZM;
2690 Standard_Real Xp, Yp, Zp;
2691
2692         MinMaxValues (ASet, Xm, Ym, Zm, XM, YM, ZM);
2693
2694         Projects (Xm, Ym, Zm, Xp, Yp, Zp);
2695         XMin    = Xp;
2696         YMin    = Yp;
2697
2698         Projects (XM, YM, ZM, Xp, Yp, Zp);
2699         XMax    = Xp;
2700         YMax    = Yp;
2701
2702         if (XMax < XMin) { Xp = XMax; XMax = XMin; XMin = Xp; }
2703         if (YMax < YMin) { Yp = YMax; YMax = YMin; YMin = Yp; }
2704 }
2705
2706 const TColStd_Array2OfReal& Visual3d_View::MatrixOfOrientation () {
2707
2708         if (! MyMatOfOriIsEvaluated) {
2709                 MyGraphicDriver->InquireMat
2710                     (MyCView, MyMatrixOfOrientation, MyMatrixOfMapping);
2711                 MyMatOfMapIsEvaluated   = Standard_True;
2712                 MyMatOfOriIsEvaluated   = Standard_True;
2713         }
2714
2715         return (MyMatrixOfOrientation);
2716
2717 }
2718
2719 const TColStd_Array2OfReal& Visual3d_View::MatrixOfMapping () {
2720
2721         if (! MyMatOfMapIsEvaluated) {
2722                 MyGraphicDriver->InquireMat
2723                     (MyCView, MyMatrixOfOrientation, MyMatrixOfMapping);
2724                 MyMatOfMapIsEvaluated   = Standard_True;
2725                 MyMatOfOriIsEvaluated   = Standard_True;
2726         }
2727
2728         return (MyMatrixOfMapping);
2729
2730 }
2731
2732 Standard_Integer Visual3d_View::NumberOfDisplayedStructures () const {
2733
2734 Standard_Integer Result = MyDisplayedStructure.Extent ();
2735
2736         return (Result);
2737
2738 }
2739
2740 #ifdef OLD_METHOD
2741 void Visual3d_View::Projects (const Standard_Real AX, const Standard_Real AY, const Standard_Real AZ, Standard_Real& APX, Standard_Real& APY, Standard_Real& APZ) const {
2742
2743 math_Vector PtDC (0,3), PtWC (0,3);
2744
2745 // RLE method:
2746 // Otherwise use new on Visual3d_View (constructor+destructor)
2747 // as Projects is a const method or MatrixOfOrientation and
2748 // MatrixOfMapping is not.
2749 Visual3d_View * const newthis = (Visual3d_View * const) this;
2750         newthis->MatrixOfOrientation ();
2751         newthis->MatrixOfMapping ();
2752
2753 // World Coordinate Space
2754         PtWC (0) = AX;
2755         PtWC (1) = AY;
2756         PtWC (2) = AZ;
2757         PtWC (3) = 1.0;
2758
2759         // WCS -> View Reference Coordinate Space
2760         math_Vector PtVRC(0,3);
2761         PtVRC = MyMatrixOfOrientation.Multiplied (PtWC);
2762
2763         // VRCS -> Normalized Projection Coordinate Space
2764         math_Vector PtNPC(0,3);
2765         PtNPC = MyMatrixOfMapping.Multiplied (PtVRC);
2766         for (Standard_Integer i=0; i<3; i++) PtNPC (i) = PtNPC (i) / PtNPC (3);
2767
2768 #ifdef DEBUG
2769         printf("Display coordinates PtNPC: %f,%f,%f,%f\n",
2770                         PtNPC(0),PtNPC(1),PtNPC(2),PtNPC(3));
2771 #endif // DEBUG
2772
2773         Standard_Real Ratio;
2774 #ifdef DEBUG
2775         // NPCS -> Device Coordinate Space
2776         Standard_Real Dx        = Standard_Real (MyCView.DefWindow.dx);
2777         Standard_Real Dy        = Standard_Real (MyCView.DefWindow.dy);
2778
2779         Ratio           = Dx / Dy;
2780         PtDC (0)        = PtNPC (0) * Dx;
2781         PtDC (1)        = Dy - PtNPC (1) * Dy * Ratio;
2782
2783         printf("Display coordinates : %f,%f,%f,%f\n",
2784                         PtDC(0),PtDC(1),PtDC(2),PtDC(3));
2785 #endif // DEBUG
2786
2787         // NPCS -> Window Space
2788 Standard_Real um, vm, uM, vM;
2789         MyViewMapping.WindowLimit (um, vm, uM, vM);
2790
2791         Ratio   = (uM - um) / (vM - vm);
2792         if (Ratio >= 1.0)
2793             PtNPC (1)   = PtNPC (1) * Ratio;
2794         else
2795             PtNPC (0)   = PtNPC (0) / Ratio;
2796
2797 #ifdef DEBUG
2798         printf("Display coordinates PtNPC: %f,%f,%f,%f\n",
2799                         PtNPC(0),PtNPC(1),PtNPC(2),PtNPC(3));
2800 #endif // DEBUG
2801
2802         Standard_Real fpd       = MyViewMapping.FrontPlaneDistance ();
2803         Standard_Real bpd       = MyViewMapping.BackPlaneDistance ();
2804
2805         /*
2806          * Coordinates of PtNPC are described in the space
2807          * [0-1]x[0-1]x[0-1].
2808          * It is necessary to transform x and y in the window space.
2809          * It is necessary to transform z in the space of back and front
2810          * plane, taking into account clipping planes.
2811          * Z clipping planes are defined between 0 and 1.
2812         */
2813
2814         APX     = PtNPC (0) * (uM - um) + um;
2815         APY     = PtNPC (1) * (vM - vm) + vm;
2816         APZ     = PtNPC (2) * (fpd - bpd) + bpd;
2817
2818 #ifdef DEBUG
2819         Standard_Integer l,c;
2820         printf("OrientationMatrix :");
2821         for( l=0 ; l<4 ; l++ ) {
2822           printf("\n    %d->",l);
2823           for( c=0 ; c<4 ; c++ ) {
2824             printf(" %f ,",MyMatrixOfOrientation(c,l));
2825           }
2826         }
2827         printf("\n\n");
2828         printf("MappingMatrix :");
2829         for( l=0 ; l<4 ; l++ ) {
2830           printf("\n    %d->",l);
2831           for( c=0 ; c<4 ; c++ ) {
2832             printf(" %f ,",MyMatrixOfMapping(c,l));
2833           }
2834         }
2835         printf("\n\n");
2836         printf("World coordinates : %f,%f,%f,%f\n",
2837                         PtWC(0),PtWC(1),PtWC(2),PtWC(3));
2838         printf("View coordinates : %f,%f,%f,%f\n",
2839                         PtVRC(0),PtVRC(1),PtVRC(2),PtVRC(3));
2840         printf("Display coordinates : %f,%f,%f,%f\n",
2841                         PtNPC(0),PtNPC(1),PtNPC(2),PtNPC(3));
2842         printf("Window limit : %f,%f,%f,%f\n",um,vm,uM,vM);
2843         printf("Ratio : %f\n",Ratio);
2844         printf("Front-plane : %f back-plane : %f\n",fpd,bpd);
2845         printf("Projection : %f,%f,%f\n \n",APX,APY,APZ);
2846 #endif
2847
2848 }
2849 #endif /* OLD_METHOD */
2850
2851 // OCC18942: This method is likely to duplicate Visual3d_ViewManager::ConvertCoord() one,
2852 // therefore it is necessary to consider merging the two methods or making them call the same
2853 // graphic driver's method after OCCT 6.3.
2854 void Visual3d_View::Projects (const Standard_Real AX, const Standard_Real AY, const Standard_Real AZ, Standard_Real& APX, Standard_Real& APY, Standard_Real& APZ) {
2855
2856 Standard_Real PtX, PtY, PtZ, PtT;
2857 Standard_Real APT;
2858 static Standard_Real Ratio, um, vm, uM, vM;
2859 static Standard_Real fpd, bpd;
2860
2861         if (! MyMatOfOriIsEvaluated || ! MyMatOfMapIsEvaluated) {
2862                 MyGraphicDriver->InquireMat
2863                     (MyCView, MyMatrixOfOrientation, MyMatrixOfMapping);
2864                 MyMatOfOriIsEvaluated = MyMatOfMapIsEvaluated = Standard_True;
2865         }
2866
2867         // WCS -> View Reference Coordinate Space
2868         PtX     = MyMatrixOfOrientation (0, 0) * AX
2869                 + MyMatrixOfOrientation (0, 1) * AY
2870                 + MyMatrixOfOrientation (0, 2) * AZ
2871                 + MyMatrixOfOrientation (0, 3);
2872         PtY     = MyMatrixOfOrientation (1, 0) * AX
2873                 + MyMatrixOfOrientation (1, 1) * AY
2874                 + MyMatrixOfOrientation (1, 2) * AZ
2875                 + MyMatrixOfOrientation (1, 3);
2876         PtZ     = MyMatrixOfOrientation (2, 0) * AX
2877                 + MyMatrixOfOrientation (2, 1) * AY
2878                 + MyMatrixOfOrientation (2, 2) * AZ
2879                 + MyMatrixOfOrientation (2, 3);
2880         PtT     = MyMatrixOfOrientation (3, 0) * AX
2881                 + MyMatrixOfOrientation (3, 1) * AY
2882                 + MyMatrixOfOrientation (3, 2) * AZ
2883                 + MyMatrixOfOrientation (3, 3);
2884
2885         // VRCS -> Normalized Projection Coordinate Space
2886         APX     = MyMatrixOfMapping (0, 0) * PtX
2887                 + MyMatrixOfMapping (0, 1) * PtY
2888                 + MyMatrixOfMapping (0, 2) * PtZ
2889                 + MyMatrixOfMapping (0, 3) * PtT;
2890         APY     = MyMatrixOfMapping (1, 0) * PtX
2891                 + MyMatrixOfMapping (1, 1) * PtY
2892                 + MyMatrixOfMapping (1, 2) * PtZ
2893                 + MyMatrixOfMapping (1, 3) * PtT;
2894         APZ     = MyMatrixOfMapping (2, 0) * PtX
2895                 + MyMatrixOfMapping (2, 1) * PtY
2896                 + MyMatrixOfMapping (2, 2) * PtZ
2897                 + MyMatrixOfMapping (2, 3) * PtT;
2898         APT     = MyMatrixOfMapping (3, 0) * PtX
2899                 + MyMatrixOfMapping (3, 1) * PtY
2900                 + MyMatrixOfMapping (3, 2) * PtZ
2901                 + MyMatrixOfMapping (3, 3) * PtT;
2902
2903         APX /= APT;
2904         APY /= APT;
2905         APZ /= APT;
2906
2907         // NPCS -> Window Space
2908         MyViewMapping.WindowLimit (um, vm, uM, vM);
2909         fpd     = MyViewMapping.FrontPlaneDistance ();
2910         bpd     = MyViewMapping.BackPlaneDistance ();
2911
2912         if(MyCView.Mapping.IsCustomMatrix) {
2913                 // OCC18942: SAN - If orientation and mapping matrices are those used by OpenGL
2914                 // visualization, then X, Y and Z coordinates normally vary between -1 and 1
2915                 APX     = ( APX + 1 ) * 0.5 * (uM - um) + um;
2916                 APY     = ( APY + 1 ) * 0.5 * (vM - vm) + vm;
2917         } else {
2918                 Ratio   = (uM - um) / (vM - vm);
2919                 if (Ratio >= 1.0)
2920                         APY *= Ratio;
2921                 else
2922                         APX /= Ratio;
2923
2924                 /*
2925          * Coordinates of APX, APY, APZ are described in the space
2926          * [0-1]x[0-1]x[0-1].
2927          * It is necessary to transform x and y in the window space.
2928          * It is necessary to transform z in the space of back and front
2929          * plane, taking into account clipping planes.
2930          * Z clipping planes are defined between 0 and 1.
2931                 */
2932             APX     = APX * (uM - um) + um;
2933             APY     = APY * (vM - vm) + vm;
2934         }
2935         APZ     = APZ * (fpd - bpd) + bpd;
2936 }
2937
2938 Standard_Integer Visual3d_View::Identification () const {
2939
2940         return (Standard_Integer (MyCView.ViewId));
2941
2942 }
2943
2944
2945 Standard_Boolean Visual3d_View::ZBufferIsActivated () const {
2946
2947         if (IsDeleted ()) return (Standard_False);
2948
2949         if ((! IsDefined ()) || (! IsActive ())) return (Standard_False);
2950
2951 // -1 => not forced by the programmer => depends on the type of visualisation
2952 //  0 ou 1 => forced by the programmer
2953
2954         if (MyCView.Context.ZBufferActivity == -1)
2955                 if (MyContext.Visualization () == Visual3d_TOV_SHADING)
2956                         return (Standard_True);
2957                 else
2958                         return (Standard_False);
2959         else
2960                 if (MyCView.Context.ZBufferActivity)
2961                         return (Standard_True);
2962                 else
2963                         return (Standard_False);
2964
2965 }
2966
2967 void Visual3d_View::SetTransparency (const Standard_Boolean AnActivity) {
2968
2969         if (IsDeleted ()) return;
2970
2971         if ((! IsDefined ()) || (! IsActive ())) return;
2972
2973         MyGraphicDriver->Transparency (MyCView, AnActivity);
2974
2975 }
2976
2977 void Visual3d_View::SetZBufferActivity (const Standard_Integer AnActivity) {
2978
2979         if (MyCView.Context.ZBufferActivity == AnActivity) return;
2980
2981         if (IsDeleted ()) return;
2982
2983         if ((! IsDefined ()) || (! IsActive ())) return;
2984
2985         MyCView.Context.ZBufferActivity = AnActivity;
2986         MyGraphicDriver->SetVisualisation (MyCView);
2987
2988 }
2989
2990 void Visual3d_View::UpdateView () {
2991
2992         MyCView.Context.Aliasing        = (MyContext.AliasingIsOn () ? 1:0);
2993         MyCView.Context.BackZClipping   =
2994                 (MyContext.BackZClippingIsOn () ? 1:0);
2995         MyCView.Context.FrontZClipping  =
2996                 (MyContext.FrontZClippingIsOn() ? 1:0);
2997         MyCView.Context.DepthCueing     =
2998                 (MyContext.DepthCueingIsOn () ? 1:0);
2999
3000         MyCView.Context.ZClipFrontPlane =
3001                                 float (MyContext.ZClippingFrontPlane ());
3002         MyCView.Context.ZClipBackPlane          =
3003                                 float (MyContext.ZClippingBackPlane ());
3004         MyCView.Context.DepthFrontPlane =
3005                                 float (MyContext.DepthCueingFrontPlane ());
3006         MyCView.Context.DepthBackPlane          =
3007                                 float (MyContext.DepthCueingBackPlane ());
3008
3009         MyCView.Context.Model           = int (MyContext.Model ());
3010         MyCView.Context.Visualization   = int (MyContext.Visualization ());
3011
3012         MyCView.Context.TextureEnv    = MyContext.TextureEnv();
3013         MyCView.Context.SurfaceDetail = MyContext.SurfaceDetail();
3014
3015 }
3016
3017 void Visual3d_View::Compute () {
3018
3019 Standard_Integer i;
3020 Standard_Integer Length = MyCOMPUTEDSequence.Length ();
3021         for (i=1; i<=Length; i++)
3022             (MyCOMPUTEDSequence.Value (i))->SetHLRValidation (Standard_False);
3023
3024         // if the degenerated node is active, nothing is recomputed
3025 #ifdef G003
3026         if (  DegenerateModeIsOn () || !ComputedMode ()  ) return;
3027 #else
3028         if (DegenerateModeIsOn ()) return;
3029 #endif  // G003
3030
3031         /*
3032          * Force HLRValidation to False on all structures
3033          * calculated in the view.
3034          */
3035 #ifdef TRACE_LENGTH
3036         if (MyTOCOMPUTESequence.Length () != MyCOMPUTEDSequence.Length ()) {
3037                 cout << "In Visual3d_View::Compute, ";
3038                 cout << "TOCOMPUTE " << MyTOCOMPUTESequence.Length ()
3039                      << " != COMPUTED " << MyCOMPUTEDSequence.Length ()
3040                      << "\n" << flush;
3041         }
3042 #endif
3043
3044         /*
3045          * Change of orientation or of projection type =>
3046          * Remove structures that were calculated for the
3047          * previous orientation.
3048          * Recalculation of new structures.
3049          * Passage of the degenerated mode ON to OFF =>
3050          * Remove structures that were calculated before
3051          * the degenerated mode passed to ON.
3052          * Recalculate new structures.
3053          */
3054 Graphic3d_MapIteratorOfMapOfStructure S1Iterator (MyDisplayedStructure);
3055 Visual3d_TypeOfAnswer Answer;
3056
3057         i       = MyDisplayedStructure.Extent ();
3058
3059 Graphic3d_SequenceOfStructure FooSequence;
3060
3061         while (S1Iterator.More ()) {
3062                 Answer  = AcceptDisplay (S1Iterator.Key ());
3063                 // If the structure was calculated, it is recalculated.
3064                 if (Answer == Visual3d_TOA_COMPUTE) {
3065 #ifdef TRACE
3066                         cout << "AcceptDisplay ("
3067                              << (S1Iterator.Key ())->Identification ()
3068                              << ") == Visual3d_TOA_COMPUTE;\n";
3069                         cout << flush;
3070 #endif
3071                         //Display (S1Iterator.Key (), Aspect_TOU_WAIT);
3072                         FooSequence.Append (S1Iterator.Key ());
3073                 }
3074
3075                 // S1Iterator.Next () is located on the next structure
3076                 S1Iterator.Next ();
3077         }
3078
3079         Length  = FooSequence.Length ();
3080         // All stored structures are displayed
3081         for (i=1; i<=Length; i++)
3082                 Display (FooSequence.Value (i), Aspect_TOU_WAIT);
3083         if (Length != 0) FooSequence.Clear ();
3084
3085 }
3086
3087 void Visual3d_View::ReCompute (const Handle(Graphic3d_Structure)& AStructure) {
3088 #ifdef G003
3089         if ( DegenerateModeIsOn () || !ComputedMode () ) return;
3090 #else
3091         if (DegenerateModeIsOn()) return;
3092 #endif  // G003
3093
3094         if (IsDeleted ()) return;
3095
3096         if ((! IsDefined ()) || (! IsActive ())) return;
3097
3098         if (! MyWindow->IsMapped ()) return;
3099
3100         if (! AStructure->IsDisplayed ()) return;
3101
3102 Visual3d_TypeOfAnswer Answer;
3103
3104         Answer  = AcceptDisplay (AStructure);
3105
3106         if (Answer == Visual3d_TOA_COMPUTE) {
3107 Standard_Integer Index = IsComputed (AStructure);
3108                 if (Index == 0) {
3109 #ifdef TRACE_COMP
3110         cout << "Structure " << AStructure->Identification ()
3111              << " is not calculated in the view "
3112              << Identification () << "\n";
3113         cout << flush;
3114 #endif
3115                 }
3116                 else {
3117                   Standard_Integer OldStructId, NewStructId;
3118                         OldStructId =
3119                         MyCOMPUTEDSequence.Value (Index)->Identification ();
3120 #ifdef TRACE_COMP
3121         Standard_Integer StructId = AStructure->Identification ();
3122         cout << "Structure " << StructId
3123              << " calculated, in the view "
3124              << Identification () << ", by the structure "
3125              << OldStructId << " is recalculated.\n";
3126         cout << flush;
3127 #endif
3128
3129         // Compute + Validation
3130 #ifdef OLD
3131 Handle(Graphic3d_Structure) TheStructure = AStructure->Compute (this);
3132 #else
3133 Handle(Graphic3d_Structure) TheStructure;
3134 TColStd_Array2OfReal ATrsf (0, 3, 0, 3);
3135         AStructure->Transform (ATrsf);
3136         if (Index != 0) {
3137 TColStd_Array2OfReal Ident (0, 3, 0, 3);
3138 Standard_Integer ii, jj;
3139         for (ii=0; ii<=3; ii++)
3140             for (jj=0; jj<=3; jj++)
3141                 Ident (ii, jj) = (ii == jj ? 1.0 : 0.0);
3142             TheStructure = MyCOMPUTEDSequence.Value (Index);
3143             TheStructure->SetTransform (Ident, Graphic3d_TOC_REPLACE);
3144             if (AStructure->IsTransformed ()) {
3145                 AStructure->Compute (this, ATrsf, TheStructure);
3146             }
3147             else {
3148                 AStructure->Compute (this, TheStructure);
3149             }
3150         }
3151         else {
3152             if (AStructure->IsTransformed ()) {
3153                 TheStructure = AStructure->Compute (this, ATrsf);
3154             }
3155             else {
3156                 TheStructure = AStructure->Compute (this);
3157             }
3158         }
3159 #endif
3160         TheStructure->SetHLRValidation (Standard_True);
3161
3162 // Return type of visualisation of the view
3163 Visual3d_TypeOfVisualization ViewType = MyContext.Visualization ();
3164
3165 // Of which type will be the computed ?
3166 Standard_Boolean ComputeWireframe = ((ViewType == Visual3d_TOV_WIREFRAME) &&
3167         (AStructure->ComputeVisual () != Graphic3d_TOS_SHADING));
3168
3169 Standard_Boolean ComputeShading = ((ViewType == Visual3d_TOV_SHADING) &&
3170         (AStructure->ComputeVisual () != Graphic3d_TOS_WIREFRAME));
3171
3172                         if (ComputeWireframe)
3173                             TheStructure->SetVisual (Graphic3d_TOS_WIREFRAME);
3174                         if (ComputeShading)
3175                             TheStructure->SetVisual (Graphic3d_TOS_SHADING);
3176
3177                         if (AStructure->IsHighlighted ()) {
3178                             TheStructure->SetHighlightColor
3179                                 (AStructure->HighlightColor ());
3180                             TheStructure->GraphicHighlight (Aspect_TOHM_COLOR);
3181                         }
3182
3183                         // Ot is ranged
3184                         // Find structure <AStructure>
3185                         // in the sequence of structures to be calculated.
3186                         NewStructId = TheStructure->Identification ();
3187
3188                         // The previous calculation is removed and the new one is dislayed
3189                         MyGraphicDriver->EraseStructure (
3190                                 MyCView,
3191                                 *(Graphic3d_CStructure *)MyCOMPUTEDSequence.Value (Index)->CStructure ());
3192                         MyGraphicDriver->DisplayStructure (
3193                                 MyCView,
3194                                 *(Graphic3d_CStructure *)TheStructure->CStructure (),
3195                                 int (AStructure->DisplayPriority ())
3196                         );
3197
3198 #ifdef TRACE_LENGTH
3199         if (MyTOCOMPUTESequence.Length () != MyCOMPUTEDSequence.Length ()) {
3200                 cout << "In Visual3d_View::ReCompute, ";
3201                 cout << "TOCOMPUTE " << MyTOCOMPUTESequence.Length ()
3202                      << " != COMPUTED " << MyCOMPUTEDSequence.Length ()
3203                      << "\n" << flush;
3204         }
3205 #endif
3206
3207                           // hlhsr and the new associated compute are added
3208                           MyTOCOMPUTESequence.Append (AStructure);
3209                           MyCOMPUTEDSequence.Append (TheStructure);
3210
3211 #ifdef TRACE_LENGTH
3212         if (MyTOCOMPUTESequence.Length () != MyCOMPUTEDSequence.Length ())
3213                 cout << "\tTOCOMPUTE " << MyTOCOMPUTESequence.Length ()
3214                      << " != COMPUTED " << MyCOMPUTEDSequence.Length ()
3215                      << "\n" << flush;
3216 #endif
3217
3218                           // hlhsr and the new associated compute are removed
3219
3220                           MyTOCOMPUTESequence.Remove (Index);
3221                           MyCOMPUTEDSequence.Remove (Index);
3222
3223 #ifdef TRACE_LENGTH
3224         if (MyTOCOMPUTESequence.Length () != MyCOMPUTEDSequence.Length ())
3225                 cout << "\tTOCOMPUTE " << MyTOCOMPUTESequence.Length ()
3226                      << " != COMPUTED " << MyCOMPUTEDSequence.Length ()
3227                      << "\n" << flush;
3228 #endif
3229                 }
3230         }
3231
3232 }
3233
3234 void
3235 #ifdef G003
3236 Visual3d_View::SetAnimationModeOn ( const Standard_Boolean degenerate ) {
3237 #else
3238 Visual3d_View::SetAnimationModeOn () {
3239 #endif
3240
3241         if (AnimationModeIsOn ()) return;
3242
3243         AnimationModeIsActive   = Standard_True;
3244 #ifdef G003
3245         if ( degenerate )
3246           SetDegenerateModeOn ();
3247         else
3248           SetDegenerateModeOff ();
3249 #endif  // G003
3250         MyGraphicDriver->BeginAnimation (MyCView);
3251
3252 }
3253
3254 void Visual3d_View::SetAnimationModeOff () {
3255
3256         if (! AnimationModeIsOn ()) return;
3257
3258         AnimationModeIsActive   = Standard_False;
3259 #ifdef G003
3260         SetDegenerateModeOff ();
3261 #endif  // G003
3262         MyGraphicDriver->EndAnimation (MyCView);
3263
3264 }
3265
3266 Standard_Boolean Visual3d_View::AnimationModeIsOn () const {
3267
3268         return AnimationModeIsActive;
3269
3270 }
3271
3272 void Visual3d_View::SetDegenerateModeOn () {
3273
3274 #ifdef TRACE
3275         cout << "Visual3d_View" << MyCView.ViewId
3276              << "::SetDegenerateModeOn ();\n";
3277         cout << flush;
3278 #endif
3279
3280         // If the degenerated mode is already active, nothing is recalculated
3281         if (DegenerateModeIsOn ()) return;
3282         DegenerateModeIsActive = Standard_True;
3283
3284 #ifdef G003
3285         MyCView.IsDegenerates  = 1;
3286 #else
3287         /*
3288          * Change of activity of the degenerated mode
3289          * Remove structures that were calculated
3290          * and displayed when the mode was off.
3291          * Display of non-calculated structures.
3292          */
3293 Graphic3d_MapIteratorOfMapOfStructure S1Iterator (MyDisplayedStructure);
3294 Visual3d_TypeOfAnswer Answer;
3295 Standard_Integer StructId;
3296
3297         while (S1Iterator.More ()) {
3298
3299                 Answer  = AcceptDisplay (S1Iterator.Key ());
3300                 // If the structure was calculated, the previous one is
3301                 // removed and the new one is displayed
3302                 // (This is the role of passage into degenerated mode)
3303
3304                 if (Answer == Visual3d_TOA_COMPUTE) {
3305 Standard_Integer Index = IsComputed (S1Iterator.Key ());
3306                     if (Index != 0) {
3307                         StructId =
3308                         MyCOMPUTEDSequence.Value (Index)->Identification ();
3309 #ifdef TRACE_COMP
3310         cout << "Structure " << S1Iterator.Key ()->Identification ()
3311              << " calculated, in the view "
3312              << Identification () << ", by structure "
3313              << StructId << " passes in degenerated mode.\n";
3314         cout << "Remove" << StructId <