OCC22150 Problem with GetWindowLong function on 64-bit platform
[occt.git] / src / Visual3d / Visual3d_View.cxx
1 /***********************************************************************
2
3      FONCTION :
4      ----------
5         Classe Visual3d_View.cxx :
6
7
8         Declaration des variables specifiques aux vues.
9
10         Une vue est definie par :
11                 - un ViewManager
12                 - un ContextView
13                 - un ViewMapping
14                 - une ViewOrientation
15
16      HISTORIQUE DES MODIFICATIONS   :
17      --------------------------------
18       Mars 1992 : NW,JPB,CAL ; Creation.
19       04-02-97  : FMN ; Suppression de PSOutput, XWDOutput ...
20       22-04-97  : CAL ; Ajout du Plot.
21       03-06-97  : FMN ; Correction calcul SetRatio
22       06-05-97  : CAL ; Ajout du Clear sur les TOS_COMPUTED.
23       28-07-97  : PCT ; Ajout lumiere frontale headlight.
24       19-09-97  : CAL ; Remplacement de Window->Position par Window->Size;
25       17-10-97  : CAL ; Le Projects nouveau est arrive. (NewProjects)
26       24-10-97  : CAL ; Retrait de DownCast.
27       24-10-97  : CAL ; Retrait des DataStructure (Vieille maquette inutilisee).
28       17-11-97  : FMN ; Ajout DoResize dans Resized()
29       20-11-97  : CAL ; Disparition de la dependance avec math
30       ??-11-97  : CAL ; Retrait de la dependance avec math. Calcul developpe.
31       ??-11-97  : CAL ; Ajout de NumberOfDisplayedStructures
32       07-08-97  : PCT ; ajout support texture mapping
33       05-01-98  : CAL ; Ajout de AnimationMode
34       15-01-98  : FMN ; FRA60019 calcul Ratio pour MyViewMappingReset
35       15-01-98  : CAL ; Ajout de la transformation d'une TOS_COMPUTED
36       26-01-98  : CAL ; Ajout de la methode HaveTheSameOwner
37       06-02-98  : FMN ; CTS19079: TOP TEN: Probleme de highlight dans EDesigner.
38       05-03-98  : CAL ; GraphicTransform que si Trsf non invalidante
39       27-03-98  : CAL ; Ajout de TheStructure = devant Compute (...) !!!!
40       16-04-98  : CAL ; Remise a ID de la Trsf sur la COMPUTED
41       20-05-98  : CAL ; Perfs. Connection entre structures COMPUTED.
42       24-06-98  : CAL ; PRO14526 SetTransparency sur une vue non active.
43       17-07-98  : CAL ; PRO14872 test sur aTrsf dans ::SetTransform.
44       16-09-98  : BGN ; Points d'entree du Triedre (S3819, Phase 1)
45       22-09-98  : BGN ; S3989 (anciennement S3819)
46                         TypeOfTriedron* from Aspect (pas Visual3d)
47       06-10-98  : CAL ; Ajout d'un TIMER si CSF_GraphicTimer est definie.
48       16-10-98  : CAL ; Ajout d'un TIMER si CSF_GraphicTimer est definie.
49       02-11-98  : CAL ; Retrait de OSD::SetSignal.
50       18-11-98  : FMN ; Correction sur la gestion de la perspective
51       02-12-98  : CAL ; S4062. Ajout des layers.
52       13-09-99  : GG  ; GER61454 Adds LightLimit() and PlaneLimit() methods
53       10-11-99  : GG  ; PRO19603 Add Redraw( area ) method
54       14-01-00  : GG  ; IMP140100 Add ViewManager( ) method
55       22-10-01  : SAV ; Added EnableDepthTest() method.
56       30-04-02  : JMB ; MyDisplayStructure : use a Map instead of a Set (very bad performance
57                         in data access when a lot of objects are used)
58                         Will improve performance of selection mechanisms
59
60 ************************************************************************/
61
62 #define BUC60572        //GG_03-08-99    Add protection on Zclipping & Zcueing planes
63 //              positions.
64
65 #define BUC60570        //GG 14-09-99 Don't activates lighting
66 //                      when the view shading model is NONE.
67
68 #define GER61454        //GG 14-09-99 Activates model clipping planes
69
70 #define IMP140100       //GG14-01-00 Add ViewManager( ) method
71
72 #define G003            //EUG 30-09-00 Degeneration management
73 //                                     Backfacing management
74
75 #define RIC120302       //GG Add a NEW SetWindow method which enable
76 //                      to connect a graphic widget and context to OGL.
77
78 #define  BUC61044    /* 25/10/01 SAV ; added functionality to control gl depth testing
79                         from higher API */
80 #define  BUC61045    /* 25/10/01 SAV ; added functionality to control gl lighting
81                         from higher API */
82
83 #define OCC1188         //SAV Added methods to set background image
84
85 /*----------------------------------------------------------------------*/
86 /*
87  * Constantes
88  */
89
90 #define NO_DEBUG
91 #define NO_DESTROY
92 #define NO_TRACE
93 #define NO_TRACE_ACCEPT
94 #define NO_TRACE_CLEAR
95 #define NO_TRACE_CONNECT
96 #define NO_TRACE_HIGH
97 #define NO_TRACE_COMP
98 #define NO_TRACE_TRSF
99 #define NO_TRACE_DISPLAY
100 #define NO_TRACE_ISCOMP
101 #define NO_TRACE_LENGTH
102 #define NO_TRACE_LAYER
103
104 /*----------------------------------------------------------------------*/
105 /*
106  * Includes
107  */
108
109 #ifdef WNT
110 #include <windows.h>
111 #endif
112
113 // for the class
114 #include <Visual3d_View.ixx>
115 #include <Visual3d_View.pxx>
116 #include <Visual3d_DepthCueingDefinitionError.hxx>
117 #include <Visual3d_ZClippingDefinitionError.hxx>
118
119 #ifdef OLD_METHOD
120 #include <math_Vector.hxx>
121 #endif /* OLD_METHOD */
122
123 #include <OSD.hxx>
124
125 #include <Graphic3d_Structure.hxx>
126 #include <Graphic3d_MapOfStructure.hxx>
127 #include <Graphic3d_MapIteratorOfMapOfStructure.hxx>
128 #include <Graphic3d_DataStructureManager.hxx>
129
130 #include <Graphic3d_GraphicDriver.hxx>
131 #include <Graphic3d_GraphicDevice.hxx>
132
133 #include <Graphic3d_Vector.hxx>
134 #include <Graphic3d_Vertex.hxx>
135
136 #include <Visual3d_Light.hxx>
137 #include <Visual3d_SetOfLight.hxx>
138 #include <Visual3d_HSetOfLight.hxx>
139 #include <Visual3d_SetIteratorOfSetOfLight.hxx>
140
141 #include <Visual3d_ClipPlane.hxx>
142 #include <Visual3d_SetOfClipPlane.hxx>
143 #include <Visual3d_HSetOfClipPlane.hxx>
144 #include <Visual3d_SetIteratorOfSetOfClipPlane.hxx>
145
146 #include <Visual3d_SetIteratorOfSetOfView.hxx>
147
148 #include <Graphic3d_TextureEnv.hxx>
149
150 #include <TColStd_HArray2OfReal.hxx>
151
152 #ifndef WNT
153 # include <Xw_Window.hxx>
154 #else
155 # include <WNT_Window.hxx>
156 #endif  // WNT
157
158 #include <float.h>
159
160 //-Aliases
161
162 //-Global data definitions
163
164 //-Constructors
165
166 Visual3d_View::Visual3d_View (const Handle(Visual3d_ViewManager)& AManager):
167 MyContext (),
168 MyViewMapping (),
169 MyViewMappingReset (),
170 MyViewOrientation (),
171 MyViewOrientationReset (),
172 MyTransformation (0, 3, 0, 3),
173 MyMatrixOfMapping (0, 3, 0, 3),
174 MyMatrixOfOrientation (0, 3, 0, 3),
175 MyTOCOMPUTESequence (),
176 MyCOMPUTEDSequence (),
177 MyDisplayedStructure ()
178 {
179 Standard_Integer i, j;
180
181 #ifdef IMP140100
182         MyPtrViewManager        = AManager.operator->();
183 #else
184         MyPtrViewManager        = (void *) AManager.operator->();
185 #endif
186
187         memset (&MyCView, 0, sizeof(MyCView));
188         MyCView.ViewId          = int (AManager->Identification (this));
189         MyCView.Active          = 0;
190         MyCView.IsDeleted       = 0;
191
192         MyCView.WsId    = -1;
193         MyCView.DefWindow.IsDefined     = 0;
194
195         MyCView.Context.NbActiveLight   = 0;
196         MyCView.Context.NbActivePlane   = 0;
197 #ifdef GER61454
198         MyCView.Context.ActivePlane = NULL;
199 #endif
200
201         for (i=0; i<=3; i++)
202                 for (j=0; j<=3; j++)
203                         if (i == j)     MyTransformation (i, j) = 1.0;
204                         else            MyTransformation (i, j) = 0.0;
205
206 Standard_Real X, Y, Z;
207
208         (MyViewOrientation.ViewReferencePoint ()).Coord (X, Y, Z);
209         MyCView.Orientation.ViewReferencePoint.x        = float (X);
210         MyCView.Orientation.ViewReferencePoint.y        = float (Y);
211         MyCView.Orientation.ViewReferencePoint.z        = float (Z);
212         (MyViewOrientation.ViewReferencePlane ()).Coord (X, Y, Z);
213         MyCView.Orientation.ViewReferencePlane.x        = float (X);
214         MyCView.Orientation.ViewReferencePlane.y        = float (Y);
215         MyCView.Orientation.ViewReferencePlane.z        = float (Z);
216         (MyViewOrientation.ViewReferenceUp ()).Coord (X, Y, Z);
217         MyCView.Orientation.ViewReferenceUp.x           = float (X);
218         MyCView.Orientation.ViewReferenceUp.y           = float (Y);
219         MyCView.Orientation.ViewReferenceUp.z           = float (Z);
220
221 Standard_Real Sx, Sy, Sz;
222
223         MyViewOrientation.AxialScale(Sx, Sy, Sz);
224         MyCView.Orientation.ViewScaleX                  = float (Sx);
225         MyCView.Orientation.ViewScaleY                  = float (Sy);
226         MyCView.Orientation.ViewScaleZ                  = float (Sz);
227
228         // NKV : 23/07/07 - Define custom MODELVIEW matrix
229         MyCView.Orientation.IsCustomMatrix = 0;
230         memset( (float*)MyCView.Orientation.ModelViewMatrix, 0, 16*sizeof( float ) );
231         MyCView.Orientation.ModelViewMatrix[0][0] =
232         MyCView.Orientation.ModelViewMatrix[1][1] =
233         MyCView.Orientation.ModelViewMatrix[2][2] =
234         MyCView.Orientation.ModelViewMatrix[3][3] = 1.;
235         //
236
237 Standard_Real um, vm, uM, vM;
238
239         MyCView.Mapping.Projection      = int (MyViewMapping.Projection ());
240         (MyViewMapping.ProjectionReferencePoint ()).Coord (X, Y, Z);
241         MyCView.Mapping.ProjectionReferencePoint.x      = float (X);
242         MyCView.Mapping.ProjectionReferencePoint.y      = float (Y);
243         MyCView.Mapping.ProjectionReferencePoint.z      = float (Z);
244         MyCView.Mapping.ViewPlaneDistance       =
245                         float (MyViewMapping.ViewPlaneDistance ());
246         MyCView.Mapping.BackPlaneDistance       =
247                         float (MyViewMapping.BackPlaneDistance ());
248         MyCView.Mapping.FrontPlaneDistance      =
249                         float (MyViewMapping.FrontPlaneDistance ());
250         MyViewMapping.WindowLimit (um, vm, uM, vM);
251         MyCView.Mapping.WindowLimit.um  = float (um);
252         MyCView.Mapping.WindowLimit.vm  = float (vm);
253         MyCView.Mapping.WindowLimit.uM  = float (uM);
254         MyCView.Mapping.WindowLimit.vM  = float (vM);
255
256         // NKV : 23/07/07 - Define custom MODELVIEW matrix
257         MyCView.Mapping.IsCustomMatrix = 0;
258         memset( (float*)MyCView.Mapping.ProjectionMatrix, 0, 16*sizeof( float ) );
259         MyCView.Mapping.ProjectionMatrix[0][0] =
260         MyCView.Mapping.ProjectionMatrix[1][1] =
261         MyCView.Mapping.ProjectionMatrix[2][2] =
262         MyCView.Mapping.ProjectionMatrix[3][3] = 1.;
263         //
264
265         MyCView.Context.ZBufferActivity = -1;
266
267         MyMatOfMapIsModified    = Standard_True;
268         MyMatOfOriIsModified    = Standard_True;
269         MyMatOfMapIsEvaluated   = Standard_False;
270         MyMatOfOriIsEvaluated   = Standard_False;
271
272         DegenerateModeIsActive  = Standard_False;
273         AnimationModeIsActive   = Standard_False;
274 #ifdef G003
275         MyCView.IsDegenerates     = 0;
276         MyCView.IsDegeneratesPrev = 0;
277         ComputedModeIsActive      = Standard_False;
278         MyCView.Backfacing        = 0;
279 #endif  // G003
280
281         MyCView.DefBitmap.bitmap = 0;
282         MyCView.ptrUnderLayer = 0;
283         MyCView.ptrOverLayer = 0;
284         MyCView.GContext = 0;
285         MyCView.GDisplayCB = 0;
286         MyCView.GClientData = 0;
287
288 Handle(Aspect_GraphicDriver) agd =
289         (MyViewManager->GraphicDevice ())->GraphicDriver ();
290
291         MyGraphicDriver = *(Handle(Graphic3d_GraphicDriver) *) &agd;
292
293 }
294
295 Visual3d_View::Visual3d_View (const Handle(Visual3d_ViewManager)& AManager, const Visual3d_ViewOrientation& VO, const Visual3d_ViewMapping& VM, const Visual3d_ContextView& CTX):
296 MyTransformation (0, 3, 0, 3),
297 MyMatrixOfMapping (0, 3, 0, 3),
298 MyMatrixOfOrientation (0, 3, 0, 3),
299 MyTOCOMPUTESequence (),
300 MyCOMPUTEDSequence (),
301 MyDisplayedStructure ()
302 {
303 Standard_Integer i, j;
304
305 #ifdef IMP140100
306         MyPtrViewManager        = AManager.operator->();
307 #else
308         MyPtrViewManager        = (void *) AManager.operator->();
309 #endif
310
311         MyViewOrientation       = VO;
312         MyViewMapping           = VM;
313         MyContext               = CTX;
314         MyViewOrientationReset  = VO;
315         MyViewMappingReset      = VM;
316
317         memset (&MyCView, 0, sizeof(MyCView));
318         MyCView.ViewId          = int (AManager->Identification (this));
319         MyCView.Active          = 0;
320         MyCView.IsDeleted       = 0;
321
322         MyCView.WsId    = -1;
323         MyCView.DefWindow.IsDefined     = 0;
324
325         MyCView.Context.NbActiveLight   = 0;
326         MyCView.Context.NbActivePlane   = 0;
327 #ifdef GER61454
328         MyCView.Context.ActivePlane = NULL;
329 #endif
330
331         for (i=0; i<=3; i++)
332                 for (j=0; j<=3; j++)
333                         if (i == j)     MyTransformation (i, j) = 1.0;
334                         else            MyTransformation (i, j) = 0.0;
335
336 Standard_Real X, Y, Z;
337
338         (MyViewOrientation.ViewReferencePoint ()).Coord (X, Y, Z);
339         MyCView.Orientation.ViewReferencePoint.x        = float (X);
340         MyCView.Orientation.ViewReferencePoint.y        = float (Y);
341         MyCView.Orientation.ViewReferencePoint.z        = float (Z);
342         (MyViewOrientation.ViewReferencePlane ()).Coord (X, Y, Z);
343         MyCView.Orientation.ViewReferencePlane.x        = float (X);
344         MyCView.Orientation.ViewReferencePlane.y        = float (Y);
345         MyCView.Orientation.ViewReferencePlane.z        = float (Z);
346         (MyViewOrientation.ViewReferenceUp ()).Coord (X, Y, Z);
347         MyCView.Orientation.ViewReferenceUp.x           = float (X);
348         MyCView.Orientation.ViewReferenceUp.y           = float (Y);
349         MyCView.Orientation.ViewReferenceUp.z           = float (Z);
350
351 Standard_Real Sx, Sy, Sz;
352
353         MyViewOrientation.AxialScale(Sx, Sy, Sz);
354         MyCView.Orientation.ViewScaleX                  = float (Sx);
355         MyCView.Orientation.ViewScaleY                  = float (Sy);
356         MyCView.Orientation.ViewScaleZ                  = float (Sz);
357
358         // NKV : 23/07/07 - Define custom MODELVIEW matrix
359         if (MyViewOrientation.IsCustomMatrix()) {
360           MyCView.Orientation.IsCustomMatrix = 1;
361           for ( i = 0; i < 4; i++)
362             for ( j = 0; j < 4; j++)
363               MyCView.Orientation.ModelViewMatrix[i][j] = 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] = MyViewMapping.MyProjectionMatrix->Value(i,j);
400         }
401         else {
402           MyCView.Mapping.IsCustomMatrix = 0;
403           memset( (float*)MyCView.Mapping.ProjectionMatrix, 0, 16*sizeof( float ) );
404           MyCView.Mapping.ProjectionMatrix[0][0] =
405           MyCView.Mapping.ProjectionMatrix[1][1] =
406           MyCView.Mapping.ProjectionMatrix[2][2] =
407           MyCView.Mapping.ProjectionMatrix[3][3] = 1.;
408         }
409         //
410
411         MyCView.Context.ZBufferActivity = -1;
412
413         MyMatOfMapIsModified    = Standard_True;
414         MyMatOfOriIsModified    = Standard_True;
415         MyMatOfMapIsEvaluated   = Standard_False;
416         MyMatOfOriIsEvaluated   = Standard_False;
417 #ifdef G003
418         AnimationModeIsActive     = Standard_False;
419         MyCView.IsDegenerates     = 0;
420         MyCView.IsDegeneratesPrev = 0;
421         ComputedModeIsActive      = Standard_False;
422 #endif  // G003
423
424         MyCView.DefBitmap.bitmap = 0;
425         MyCView.ptrUnderLayer = 0;
426         MyCView.ptrOverLayer = 0;
427         MyCView.GContext = 0;
428         MyCView.GDisplayCB = 0;
429         MyCView.GClientData = 0;
430
431 Handle(Aspect_GraphicDriver) agd =
432         (MyViewManager->GraphicDevice ())->GraphicDriver ();
433
434         MyGraphicDriver = *(Handle(Graphic3d_GraphicDriver) *) &agd;
435
436 }
437
438 //-Destructors
439
440 //-Methods, in order
441 // RIC120302
442 void Visual3d_View::SetWindow (const Handle(Aspect_Window)&      AWindow,
443                                const Aspect_RenderingContext     AContext,
444                                const Aspect_GraphicCallbackProc& ADisplayCB,
445                                const Standard_Address            AClientData)
446 {
447   if (IsDeleted ()) return;
448
449   if (IsDefined ())
450     Visual3d_ViewDefinitionError::Raise ("Window already defined");
451
452   MyCView.GContext        = AContext;
453   MyCView.GDisplayCB      = ADisplayCB;
454   MyCView.GClientData     = AClientData;
455   SetWindow(AWindow);
456 }
457 // RIC120302
458
459 void Visual3d_View::SetWindow (const Handle(Aspect_Window)& AWindow) {
460
461         if (IsDeleted ()) return;
462
463         if (IsDefined ())
464                 Visual3d_ViewDefinitionError::Raise ("Window already defined");
465
466         MyWindow        = AWindow;
467         MyCView.WsId                    = MyCView.ViewId;
468         MyCView.DefWindow.IsDefined     = 1;
469 #ifndef WNT
470 const Handle(Xw_Window) theWindow = *(Handle(Xw_Window) *) &AWindow;
471         MyCView.DefWindow.XWindow       = theWindow->XWindow ();
472 #ifdef RIC120302
473         MyCView.DefWindow.XParentWindow = theWindow->XParentWindow ();
474 #endif
475 #else
476 WNT_WindowData* wd;
477 const Handle(WNT_Window) theWindow = *(Handle(WNT_Window) *) &AWindow;
478         MyCView.DefWindow.XWindow       = ( HWND )(theWindow->HWindow());
479 #ifdef RIC120302
480         MyCView.DefWindow.XParentWindow = ( HWND )(theWindow->HParentWindow());
481 #endif
482         wd = ( WNT_WindowData* )GetWindowLongPtr (( HWND )(theWindow->HWindow()), GWLP_USERDATA);
483         wd -> WNT_WDriver_Ptr = ( void* )this;
484         wd -> WNT_VMgr        = ( void* )MyPtrViewManager;
485 #endif  /* WNT */
486
487         Standard_Integer Width, Height;
488         AWindow->Size (Width, Height);
489
490         MyCView.DefWindow.dx    = float( Width );
491         MyCView.DefWindow.dy    = float( Height );
492
493         Standard_Real R, G, B;
494         MyBackground    = MyWindow->Background ();
495         (MyBackground.Color ()).Values (R, G, B, Quantity_TOC_RGB);
496         MyCView.DefWindow.Background.r  = float (R);
497         MyCView.DefWindow.Background.g  = float (G);
498         MyCView.DefWindow.Background.b  = float (B);
499
500         UpdateView ();
501         if (! MyGraphicDriver->View (MyCView))
502                 Visual3d_ViewDefinitionError::Raise ("Association failed");
503
504         MyGradientBackground = MyWindow->GradientBackground();
505         SetGradientBackground(MyGradientBackground,1);
506
507         Standard_Boolean AWait = Standard_False;        // => mise a jour immediate
508         MyGraphicDriver->SetVisualisation (MyCView);
509         MyGraphicDriver->AntiAliasing (MyCView, MyContext.AliasingIsOn ());
510         MyGraphicDriver->DepthCueing (MyCView, MyContext.DepthCueingIsOn ());
511         MyGraphicDriver->ClipLimit (MyCView, AWait);
512         MyGraphicDriver->Environment(MyCView);
513
514         // Mise a jour des plans de model clipping
515         UpdatePlanes ();
516
517         // Mise a jour des sources lumineuses
518         UpdateLights ();
519
520         /*
521          * Association view-window n'entraine pas le display
522          * des structures qui peuvent etre affichees dans la
523          * nouvelle vue.
524          * En effet, l'association vue-fenetre est faite, mais
525          * l'affichage ne sera realise que lorsque la vue sera
526          * activee (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         MyMatOfMapIsModified    = Standard_True;
603         MyMatOfOriIsModified    = Standard_True;
604         MyMatOfMapIsEvaluated   = Standard_False;
605         MyMatOfOriIsEvaluated   = 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             // Mise a jour avant le SetViewMapping.
676
677             MyCView.DefWindow.dx        = float( Dxw );
678             MyCView.DefWindow.dy        = float( Dyw );
679
680             SetViewMapping (MyViewMapping);
681 //          SetViewMappingDefault ();
682             // FMN+ Mise a jout Ratio pour le 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- Mise a jout Ratio pour le MyViewMappingReset
721
722             MyGraphicDriver->RatioWindow (MyCView);
723         }
724
725         // On force a recalculer les 2 matrices.
726         //
727         // La vue courante peut servir a reconstruire une vue copie
728         // qui est elle meme. Grace au SetWindow et au SetRatio on
729         // impose le recalcul des matrices de cette nouvelle vue.
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                 // Allocation dynamique
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                 // Parcours des sources lumineuses
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         // gestion des sources lumineuses
873         if (! IsDeleted ())
874                 if (IsDefined ())
875                         MyGraphicDriver->SetLight (MyCView);
876
877         // Desallocation dynamique
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                 // Allocation dynamique
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                 // Parcours des plans de clipping
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         // gestion des plans de model clipping
925         if (! IsDeleted ())
926                 if (IsDefined ())
927                         MyGraphicDriver->SetPlane (MyCView);
928
929         // Desallocation dynamique
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         // A ce niveau, seule la GL peut mettre a jour le background.
950         // Il ne faut pas appeler MyWindow->SetBackground (ABack); car
951         // cette methode lance une mise a jour du fond de fenetre par X
952         // (si le fenetrage est X bien-sur)
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 #ifdef OCC1188
992   if ( IsDeleted() )
993     return;
994   if ( !IsDefined() )
995     Visual3d_ViewDefinitionError::Raise ("Window not defined");
996
997   MyGraphicDriver->BackgroundImage( FileName, MyCView, FillStyle );
998
999   if ( update )
1000     Update();
1001   else if ( MyViewManager->UpdateMode() == Aspect_TOU_ASAP )
1002     Update();
1003 #endif
1004 }
1005
1006 void Visual3d_View::SetBgImageStyle( const Aspect_FillMethod FillStyle,
1007                                      const Standard_Boolean update )
1008 {
1009 #ifdef OCC1188
1010   if ( IsDeleted() )
1011     return;
1012   if ( !IsDefined() )
1013     Visual3d_ViewDefinitionError::Raise ("Window not defined");
1014
1015   MyGraphicDriver->SetBgImageStyle( MyCView, FillStyle );
1016
1017   if ( update )
1018     Update();
1019   else if ( MyViewManager->UpdateMode() == Aspect_TOU_ASAP )
1020     Update();
1021 #endif
1022 }
1023
1024 Aspect_Background Visual3d_View::Background () const {
1025
1026         return (MyBackground);
1027
1028 }
1029
1030 void Visual3d_View::SetBgGradientStyle( const Aspect_GradientFillMethod FillStyle,
1031                                         const Standard_Boolean update )
1032 {
1033   if ( IsDeleted() )
1034     return;
1035   if ( !IsDefined() )
1036     Visual3d_ViewDefinitionError::Raise ("Window not defined");
1037
1038   MyGraphicDriver->SetBgGradientStyle( MyCView, FillStyle );
1039
1040   if ( update )
1041     Update();
1042   else if ( MyViewManager->UpdateMode() == Aspect_TOU_ASAP )
1043     Update();
1044
1045 }
1046
1047 Aspect_GradientBackground Visual3d_View::GradientBackground () const {
1048
1049         return MyGradientBackground;
1050
1051 }
1052
1053 void Visual3d_View::SetTransform (const TColStd_Array2OfReal& AMatrix) {
1054
1055         if (IsDeleted ()) return;
1056
1057 Standard_Integer lr, ur, lc, uc;
1058 Standard_Integer i, j;
1059
1060         // Assign the new transformation in an array [0..3][0..3]
1061         // Evite des problemes si le user a defini sa matrice [1..4][1..4]
1062         //                                                 ou [3..6][-1..2] !!
1063         lr      = AMatrix.LowerRow ();
1064         ur      = AMatrix.UpperRow ();
1065         lc      = AMatrix.LowerCol ();
1066         uc      = AMatrix.UpperCol ();
1067
1068         if ( (ur - lr + 1 != 4) || (uc - lc + 1 != 4) )
1069                 Visual3d_TransformError::Raise ("Transform : not a 4x4 matrix");
1070
1071         for (i=0; i<=3; i++)
1072         for (j=0; j<=3; j++)
1073                 MyTransformation (i, j) = AMatrix (lr + i, lc + j);
1074
1075 Graphic3d_Vector VPN;
1076 Graphic3d_Vertex VRP;
1077 Graphic3d_Vector VUP;
1078 Standard_Real Sx, Sy, Sz;
1079
1080 Visual3d_ViewOrientation NewViewOrientation;
1081
1082         VPN     = MyViewOrientation.ViewReferencePlane ();
1083         VRP     = MyViewOrientation.ViewReferencePoint ();
1084         VUP     = MyViewOrientation.ViewReferenceUp ();
1085         MyViewOrientation.AxialScale(Sx, Sy, Sz);
1086
1087         NewViewOrientation.SetViewReferencePlane
1088                 (Graphic3d_Structure::Transforms (Transform (), VPN));
1089
1090         NewViewOrientation.SetViewReferencePoint
1091                 (Graphic3d_Structure::Transforms (Transform (), VRP));
1092
1093         NewViewOrientation.SetViewReferenceUp
1094                 (Graphic3d_Structure::Transforms (Transform (), VUP));
1095         NewViewOrientation.SetAxialScale(Sx, Sy, Sz);
1096
1097         SetViewOrientation (NewViewOrientation);
1098
1099         MyMatOfOriIsModified    = Standard_True;
1100         MyMatOfOriIsEvaluated   = Standard_False;
1101
1102 }
1103
1104 const TColStd_Array2OfReal& Visual3d_View::Transform () const {
1105
1106         return (MyTransformation);
1107
1108 }
1109
1110 void Visual3d_View::SetViewOrientation (const Visual3d_ViewOrientation& VO) {
1111
1112         if (IsDeleted ()) return;
1113
1114         MyViewOrientation       = VO;
1115
1116 Standard_Real X, Y, Z;
1117
1118         // Tests sur la modification des parametres.
1119 Standard_Boolean VUPIsModified  = Standard_False;
1120 Standard_Boolean VRPIsModified  = Standard_False;
1121 Standard_Boolean VRUIsModified  = Standard_False;
1122 Standard_Boolean ScaleIsModified  = Standard_False;
1123 Standard_Boolean CustomIsModified = Standard_False;
1124
1125         (MyViewOrientation.ViewReferencePoint ()).Coord (X, Y, Z);
1126         VUPIsModified =
1127             MyCView.Orientation.ViewReferencePoint.x != float (X)
1128          || MyCView.Orientation.ViewReferencePoint.y != float (Y)
1129          || MyCView.Orientation.ViewReferencePoint.z != float (Z);
1130         MyCView.Orientation.ViewReferencePoint.x        = float (X);
1131         MyCView.Orientation.ViewReferencePoint.y        = float (Y);
1132         MyCView.Orientation.ViewReferencePoint.z        = float (Z);
1133
1134         (MyViewOrientation.ViewReferencePlane ()).Coord (X, Y, Z);
1135         VRPIsModified =
1136             MyCView.Orientation.ViewReferencePlane.x != float (X)
1137          || MyCView.Orientation.ViewReferencePlane.y != float (Y)
1138          || MyCView.Orientation.ViewReferencePlane.z != float (Z);
1139         MyCView.Orientation.ViewReferencePlane.x        = float (X);
1140         MyCView.Orientation.ViewReferencePlane.y        = float (Y);
1141         MyCView.Orientation.ViewReferencePlane.z        = float (Z);
1142
1143         (MyViewOrientation.ViewReferenceUp ()).Coord (X, Y, Z);
1144         VRUIsModified =
1145             MyCView.Orientation.ViewReferenceUp.x != float (X)
1146          || MyCView.Orientation.ViewReferenceUp.y != float (Y)
1147          || MyCView.Orientation.ViewReferenceUp.z != float (Z);
1148         MyCView.Orientation.ViewReferenceUp.x           = float (X);
1149         MyCView.Orientation.ViewReferenceUp.y           = float (Y);
1150         MyCView.Orientation.ViewReferenceUp.z           = float (Z);
1151
1152 Standard_Real Sx, Sy, Sz;
1153
1154         MyViewOrientation.AxialScale(Sx, Sy, Sz);
1155         ScaleIsModified =
1156             MyCView.Orientation.ViewScaleX != float (X)
1157          || MyCView.Orientation.ViewScaleY != float (Y)
1158          || MyCView.Orientation.ViewScaleZ != float (Z);
1159         MyCView.Orientation.ViewScaleX                  = float (Sx);
1160         MyCView.Orientation.ViewScaleY                  = float (Sy);
1161         MyCView.Orientation.ViewScaleZ                  = float (Sz);
1162
1163         CustomIsModified =
1164           MyCView.Orientation.IsCustomMatrix != MyViewOrientation.IsCustomMatrix();
1165         MyCView.Orientation.IsCustomMatrix = MyViewOrientation.IsCustomMatrix();
1166         if ( MyViewOrientation.IsCustomMatrix() ) {
1167           Standard_Integer i, j;
1168           for (i = 0; i < 4; i++)
1169             for (j = 0; j < 4; j++) {
1170               if (!CustomIsModified) CustomIsModified =
1171                 MyCView.Orientation.ModelViewMatrix[i][j] != MyViewOrientation.MyModelViewMatrix->Value(i,j);
1172               MyCView.Orientation.ModelViewMatrix[i][j] = MyViewOrientation.MyModelViewMatrix->Value(i,j);
1173             }
1174         }
1175
1176 #ifdef TRACE_TRSF
1177 cout << "Visual3d_View::SetViewOrientation\n";
1178         if (VUPIsModified || VRPIsModified || VRUIsModified || CustomIsModified)
1179                 cout <<   "VUPIsModified : " << VUPIsModified
1180                      << ", VRPIsModified : " << VRPIsModified
1181                      << ", VRUIsModified : " << VRUIsModified
1182                      << ", CustomIsModified : " << CustomIsModified << "\n" << flush;
1183         else
1184                 cout << "no modification\n" << flush;
1185 #endif
1186
1187         // Mise en route que si l'un des parametres est modifie
1188         if (VUPIsModified || VRPIsModified || VRUIsModified || ScaleIsModified || CustomIsModified) {
1189
1190           if (VUPIsModified || VRPIsModified || VRUIsModified || CustomIsModified) {
1191                 MyMatOfOriIsModified    = Standard_True;
1192                 MyMatOfOriIsEvaluated   = Standard_False;
1193               }
1194
1195                 if (! IsDefined ()) return;
1196
1197 Standard_Boolean AWait = Standard_False;        // => mise a jour immediate
1198                 MyGraphicDriver->ViewOrientation (MyCView, AWait);
1199
1200                 Compute ();
1201
1202                 if (MyViewManager->UpdateMode () == Aspect_TOU_ASAP) Update ();
1203         }
1204
1205 }
1206
1207 Visual3d_ViewOrientation Visual3d_View::ViewOrientation () const {
1208
1209         return (MyViewOrientation);
1210
1211 }
1212
1213 Visual3d_ViewOrientation Visual3d_View::ViewOrientationDefault () const {
1214
1215         return (MyViewOrientationReset);
1216
1217 }
1218
1219 void Visual3d_View::SetViewOrientationDefault () {
1220
1221         MyViewOrientationReset.Assign (MyViewOrientation);
1222
1223 }
1224
1225 void Visual3d_View::ViewOrientationReset () {
1226
1227         if (IsDeleted ()) return;
1228
1229         MyViewOrientation       = MyViewOrientationReset;
1230
1231 Standard_Real X, Y, Z;
1232
1233         // Tests sur la modification des parametres.
1234 Standard_Boolean VUPIsModified  = Standard_False;
1235 Standard_Boolean VRPIsModified  = Standard_False;
1236 Standard_Boolean VRUIsModified  = Standard_False;
1237 Standard_Boolean ScaleIsModified  = Standard_False;
1238 Standard_Boolean CustomIsModified = Standard_False;
1239
1240         (MyViewOrientation.ViewReferencePoint ()).Coord (X, Y, Z);
1241         VUPIsModified =
1242             MyCView.Orientation.ViewReferencePoint.x != float (X)
1243          || MyCView.Orientation.ViewReferencePoint.y != float (Y)
1244          || MyCView.Orientation.ViewReferencePoint.y != float (Y);
1245         MyCView.Orientation.ViewReferencePoint.x        = float (X);
1246         MyCView.Orientation.ViewReferencePoint.y        = float (Y);
1247         MyCView.Orientation.ViewReferencePoint.z        = float (Z);
1248
1249         (MyViewOrientation.ViewReferencePlane ()).Coord (X, Y, Z);
1250         VRPIsModified =
1251             MyCView.Orientation.ViewReferencePlane.x != float (X)
1252          || MyCView.Orientation.ViewReferencePlane.y != float (Y)
1253          || MyCView.Orientation.ViewReferencePlane.y != float (Y);
1254         MyCView.Orientation.ViewReferencePlane.x        = float (X);
1255         MyCView.Orientation.ViewReferencePlane.y        = float (Y);
1256         MyCView.Orientation.ViewReferencePlane.z        = float (Z);
1257
1258         (MyViewOrientation.ViewReferenceUp ()).Coord (X, Y, Z);
1259         VRUIsModified =
1260             MyCView.Orientation.ViewReferenceUp.x != float (X)
1261          || MyCView.Orientation.ViewReferenceUp.y != float (Y)
1262          || MyCView.Orientation.ViewReferenceUp.y != float (Y);
1263         MyCView.Orientation.ViewReferenceUp.x           = float (X);
1264         MyCView.Orientation.ViewReferenceUp.y           = float (Y);
1265         MyCView.Orientation.ViewReferenceUp.z           = float (Z);
1266
1267 Standard_Real Sx, Sy, Sz;
1268
1269         MyViewOrientation.AxialScale(Sx, Sy, Sz);
1270         ScaleIsModified =
1271             MyCView.Orientation.ViewScaleX != float (X)
1272          || MyCView.Orientation.ViewScaleY != float (Y)
1273          || MyCView.Orientation.ViewScaleZ != float (Z);
1274         MyCView.Orientation.ViewScaleX                  = float (Sx);
1275         MyCView.Orientation.ViewScaleY                  = float (Sy);
1276         MyCView.Orientation.ViewScaleZ                  = float (Sz);
1277
1278         CustomIsModified =
1279           MyCView.Orientation.IsCustomMatrix != MyViewOrientation.IsCustomMatrix();
1280         MyCView.Orientation.IsCustomMatrix = MyViewOrientation.IsCustomMatrix();
1281         if ( MyViewOrientation.IsCustomMatrix() ) {
1282           Standard_Integer i, j;
1283           for (i = 0; i < 4; i++)
1284             for (j = 0; j < 4; j++) {
1285               if (!CustomIsModified) CustomIsModified =
1286                 MyCView.Orientation.ModelViewMatrix[i][j] != MyViewOrientation.MyModelViewMatrix->Value(i,j);
1287               MyCView.Orientation.ModelViewMatrix[i][j] = MyViewOrientation.MyModelViewMatrix->Value(i,j);
1288             }
1289         }
1290
1291 #ifdef TRACE_TRSF
1292 cout << "Visual3d_View::ViewOrientationReset\n";
1293 if (VUPIsModified || VRPIsModified || VRUIsModified || CustomIsModified)
1294 cout <<   "VUPIsModified : " << VUPIsModified
1295      << ", VRPIsModified : " << VRPIsModified
1296      << ", VRUIsModified : " << VRUIsModified
1297      << ", CustomIsModified : " << CustomIsModified << "\n" << flush;
1298 else
1299 cout << "no modification\n" << flush;
1300 #endif
1301
1302         // Mise en route que si l'un des parametres est modifie
1303         if (VUPIsModified || VRPIsModified || VRUIsModified || CustomIsModified) {
1304
1305           if (VUPIsModified || VRPIsModified || VRUIsModified || CustomIsModified) {
1306                 MyMatOfOriIsModified    = Standard_True;
1307                 MyMatOfOriIsEvaluated   = Standard_False;
1308               }
1309
1310                 if (! IsDefined ()) return;
1311
1312 Standard_Boolean AWait = Standard_False;        // => mise a jour immediate
1313                 MyGraphicDriver->ViewOrientation (MyCView, AWait);
1314
1315                 Compute ();
1316
1317                 if (MyViewManager->UpdateMode () == Aspect_TOU_ASAP) Update ();
1318         }
1319
1320 }
1321
1322 void Visual3d_View::SetViewMapping (const Visual3d_ViewMapping& VM) {
1323
1324         if (IsDeleted ()) return;
1325
1326 Visual3d_TypeOfProjection OldType = MyViewMapping.Projection ();
1327 Visual3d_TypeOfProjection NewType = VM.Projection ();
1328
1329         MyViewMapping   = VM;
1330
1331 Standard_Real X, Y, Z;
1332 Standard_Real um, vm, uM, vM;
1333
1334         MyCView.Mapping.Projection      = int (MyViewMapping.Projection ());
1335         (MyViewMapping.ProjectionReferencePoint ()).Coord (X, Y, Z);
1336         MyCView.Mapping.ProjectionReferencePoint.x      = float (X);
1337         MyCView.Mapping.ProjectionReferencePoint.y      = float (Y);
1338         MyCView.Mapping.ProjectionReferencePoint.z      = float (Z);
1339         MyCView.Mapping.ViewPlaneDistance       =
1340                         float (MyViewMapping.ViewPlaneDistance ());
1341         MyCView.Mapping.BackPlaneDistance       =
1342                         float (MyViewMapping.BackPlaneDistance ());
1343         MyCView.Mapping.FrontPlaneDistance      =
1344                         float (MyViewMapping.FrontPlaneDistance ());
1345         MyViewMapping.WindowLimit (um, vm, uM, vM);
1346         MyCView.Mapping.WindowLimit.um  = float (um);
1347         MyCView.Mapping.WindowLimit.vm  = float (vm);
1348         MyCView.Mapping.WindowLimit.uM  = float (uM);
1349         MyCView.Mapping.WindowLimit.vM  = float (vM);
1350
1351         MyCView.Mapping.IsCustomMatrix = MyViewMapping.IsCustomMatrix();
1352         if (MyViewMapping.IsCustomMatrix()) {
1353           Standard_Integer i, j;
1354           for (i = 0; i < 4; i++)
1355             for (j = 0; j < 4; j++)
1356               MyCView.Mapping.ProjectionMatrix[i][j] =
1357                 MyViewMapping.MyProjectionMatrix->Value(i,j);
1358         }
1359
1360         MyMatOfMapIsModified    = Standard_True;
1361         MyMatOfMapIsEvaluated   = Standard_False;
1362
1363         if (! IsDefined ()) return;
1364
1365 Standard_Boolean AWait = Standard_False;        // => mise a jour immediate
1366         MyGraphicDriver->ViewMapping (MyCView, AWait);
1367
1368         // Passage Parallele/Perspective
1369         if (OldType != NewType)
1370                 Compute ();
1371
1372         if (MyViewManager->UpdateMode () == Aspect_TOU_ASAP) Update ();
1373
1374 }
1375
1376 Visual3d_ViewMapping Visual3d_View::ViewMapping () const {
1377
1378         return (MyViewMapping);
1379
1380 }
1381
1382 Visual3d_ViewMapping Visual3d_View::ViewMappingDefault () const {
1383
1384         return (MyViewMappingReset);
1385
1386 }
1387
1388 void Visual3d_View::SetViewMappingDefault () {
1389
1390         MyViewMappingReset.Assign (MyViewMapping);
1391
1392 }
1393
1394 void Visual3d_View::ViewMappingReset () {
1395
1396         if (IsDeleted ()) return;
1397
1398         MyViewMapping   = MyViewMappingReset;
1399
1400 Standard_Real X, Y, Z;
1401 Standard_Real um, vm, uM, vM;
1402
1403         MyCView.Mapping.Projection      = int (MyViewMapping.Projection ());
1404         (MyViewMapping.ProjectionReferencePoint ()).Coord (X, Y, Z);
1405         MyCView.Mapping.ProjectionReferencePoint.x      = float (X);
1406         MyCView.Mapping.ProjectionReferencePoint.y      = float (Y);
1407         MyCView.Mapping.ProjectionReferencePoint.z      = float (Z);
1408         MyCView.Mapping.ViewPlaneDistance       =
1409                         float (MyViewMapping.ViewPlaneDistance ());
1410         MyCView.Mapping.BackPlaneDistance       =
1411                         float (MyViewMapping.BackPlaneDistance ());
1412         MyCView.Mapping.FrontPlaneDistance      =
1413                         float (MyViewMapping.FrontPlaneDistance ());
1414         MyViewMapping.WindowLimit (um, vm, uM, vM);
1415         MyCView.Mapping.WindowLimit.um  = float (um);
1416         MyCView.Mapping.WindowLimit.vm  = float (vm);
1417         MyCView.Mapping.WindowLimit.uM  = float (uM);
1418         MyCView.Mapping.WindowLimit.vM  = float (vM);
1419
1420         MyCView.Mapping.IsCustomMatrix = MyViewMapping.IsCustomMatrix();
1421         if (MyViewMapping.IsCustomMatrix()) {
1422           Standard_Integer i, j;
1423           for (i = 0; i < 4; i++)
1424             for (j = 0; j < 4; j++)
1425               MyCView.Mapping.ProjectionMatrix[i][j] =
1426                 MyViewMapping.MyProjectionMatrix->Value(i,j);
1427         }
1428
1429         MyMatOfMapIsModified    = Standard_True;
1430         MyMatOfMapIsEvaluated   = Standard_False;
1431
1432         if (! IsDefined ()) return;
1433
1434 Standard_Boolean AWait = Standard_False;        // => mise a jour immediate
1435         MyGraphicDriver->ViewMapping (MyCView, AWait);
1436
1437         if (MyViewManager->UpdateMode () == Aspect_TOU_ASAP) Update ();
1438
1439 }
1440
1441 void Visual3d_View::SetContext (const Visual3d_ContextView& CTX) {
1442
1443         if (IsDeleted ()) return;
1444
1445 Visual3d_TypeOfVisualization OldVisualMode;
1446 Visual3d_TypeOfVisualization NewVisualMode;
1447
1448         // Pour gerer l'affichage uniquement en cas de
1449         // changement de mode de visualisation.
1450         OldVisualMode   = MyContext.Visualization ();
1451         NewVisualMode   = CTX.Visualization ();
1452
1453 Visual3d_TypeOfModel OldModel;
1454 Visual3d_TypeOfModel NewModel;
1455
1456         // Pour gerer le changement de visualisation uniquement
1457         // en cas de changement de mode de visualisation ou de
1458         // type de shading.
1459         OldModel        = MyContext.Model ();
1460         NewModel        = CTX.Model ();
1461
1462 Standard_Boolean OldAliasingMode;
1463 Standard_Boolean NewAliasingMode;
1464
1465         // Pour gerer l'antialiasing uniquement en cas de changement.
1466         OldAliasingMode = MyContext.AliasingIsOn ();
1467         NewAliasingMode = CTX.AliasingIsOn ();
1468
1469 Standard_Boolean OldDepthCueingMode;
1470 Standard_Boolean NewDepthCueingMode;
1471
1472 Standard_Real OldDepthCueingFrontPlane;
1473 Standard_Real NewDepthCueingFrontPlane;
1474 Standard_Real OldDepthCueingBackPlane;
1475 Standard_Real NewDepthCueingBackPlane;
1476
1477         // Pour gerer le depth cueing uniquement en cas de changement.
1478         OldDepthCueingMode              = MyContext.DepthCueingIsOn ();
1479         NewDepthCueingMode              = CTX.DepthCueingIsOn ();
1480
1481         OldDepthCueingFrontPlane        = MyContext.DepthCueingFrontPlane ();
1482         NewDepthCueingFrontPlane        = CTX.DepthCueingFrontPlane ();
1483         OldDepthCueingBackPlane         = MyContext.DepthCueingBackPlane ();
1484         NewDepthCueingBackPlane         = CTX.DepthCueingBackPlane ();
1485
1486 Standard_Boolean OldFrontZClippingMode;
1487 Standard_Boolean NewFrontZClippingMode;
1488 Standard_Boolean OldBackZClippingMode;
1489 Standard_Boolean NewBackZClippingMode;
1490
1491 Standard_Real OldZClippingFrontPlane;
1492 Standard_Real NewZClippingFrontPlane;
1493 Standard_Real OldZClippingBackPlane;
1494 Standard_Real NewZClippingBackPlane;
1495
1496         // Pour gerer le Zclipping uniquement en cas de changement.
1497         OldFrontZClippingMode   = MyContext.FrontZClippingIsOn ();
1498         NewFrontZClippingMode   = CTX.FrontZClippingIsOn ();
1499         OldBackZClippingMode    = MyContext.BackZClippingIsOn ();
1500         NewBackZClippingMode    = CTX.BackZClippingIsOn ();
1501
1502         OldZClippingFrontPlane  = MyContext.ZClippingFrontPlane ();
1503         NewZClippingFrontPlane  = CTX.ZClippingFrontPlane ();
1504         OldZClippingBackPlane   = MyContext.ZClippingBackPlane ();
1505         NewZClippingBackPlane   = CTX.ZClippingBackPlane ();
1506
1507 Standard_Integer OldTexEnvId;
1508 Standard_Integer NewTexEnvId;
1509 Visual3d_TypeOfSurfaceDetail OldSurfaceDetail;
1510 Visual3d_TypeOfSurfaceDetail NewSurfaceDetail;
1511
1512         Handle(Graphic3d_TextureEnv)    TempTextureEnv1 = MyContext.TextureEnv();
1513         if (! TempTextureEnv1.IsNull()) OldTexEnvId = TempTextureEnv1->TextureId();
1514         else                            OldTexEnvId = -1;
1515
1516         Handle(Graphic3d_TextureEnv)    TempTextureEnv2 = CTX.TextureEnv();
1517
1518         if (! TempTextureEnv2.IsNull()) NewTexEnvId = TempTextureEnv2->TextureId();
1519         else                            NewTexEnvId = -1;
1520
1521         OldSurfaceDetail = MyContext.SurfaceDetail();
1522         NewSurfaceDetail = CTX.SurfaceDetail();
1523
1524         MyContext       = CTX;
1525
1526         UpdateView ();
1527
1528 Standard_Boolean AWait = Standard_False;        // => mise a jour immediate
1529         if (IsDefined ()) {
1530                 // gestion des modes de visualisation et des types de shading.
1531                 if ((OldVisualMode != NewVisualMode) || (OldModel != NewModel))
1532                         MyGraphicDriver->SetVisualisation (MyCView);
1533
1534                 // gestion de l'antialiasing.
1535                 if (OldAliasingMode != NewAliasingMode)
1536                 MyGraphicDriver->AntiAliasing (MyCView, NewAliasingMode);
1537
1538                 // gestion du depth_cueing.
1539                 if ((OldDepthCueingMode != NewDepthCueingMode) ||
1540                     (OldDepthCueingFrontPlane != NewDepthCueingFrontPlane) ||
1541                     (OldDepthCueingBackPlane != NewDepthCueingBackPlane)) {
1542 #ifdef BUC60572
1543                     if( NewDepthCueingMode &&
1544                         (NewDepthCueingBackPlane >= NewDepthCueingFrontPlane) )
1545                         Visual3d_DepthCueingDefinitionError::Raise
1546                         ("Bad value for DepthCueingPlanes position");
1547 #endif
1548                         MyGraphicDriver->DepthCueing
1549                                 (MyCView, NewDepthCueingMode);
1550                 }
1551
1552                 // gestion du Zclipping
1553                 if ((OldFrontZClippingMode != NewFrontZClippingMode) ||
1554                     (OldBackZClippingMode != NewBackZClippingMode) ||
1555                     (OldZClippingFrontPlane != NewZClippingFrontPlane) ||
1556                     (OldZClippingBackPlane != NewZClippingBackPlane)) {
1557 #ifdef BUC60572
1558                     if( NewBackZClippingMode && NewFrontZClippingMode &&
1559                         (NewZClippingBackPlane >= NewZClippingFrontPlane) )
1560                         Visual3d_ZClippingDefinitionError::Raise
1561                         ("Bad value for ZClippingPlanes position");
1562 #endif
1563                         MyGraphicDriver->ClipLimit (MyCView, AWait);
1564                 }
1565
1566                 // gestion des textures
1567                 if ( (OldTexEnvId != NewTexEnvId) ||
1568                      (OldSurfaceDetail != NewSurfaceDetail) )
1569                   MyGraphicDriver->Environment(MyCView);
1570
1571                 // Mise a jour des plans de model clipping
1572                 UpdatePlanes ();
1573
1574                 // Mise a jour des sources lumineuses
1575                 UpdateLights ();
1576         }
1577
1578         if (OldVisualMode != NewVisualMode) {
1579
1580                 /*
1581                  * Changement de contexte =>
1582                  * Erase des structures qui ne peuvent pas etre affichees
1583                  * avec le nouveau mode de visualisation.
1584                  * On ne doit pas prevenir le ViewManager car
1585                  * cette structure ne doit pas disparaitre de la
1586                  * liste des structures affichees chez celui-ci.
1587                  */
1588 Graphic3d_MapIteratorOfMapOfStructure S1Iterator (MyDisplayedStructure);
1589 Visual3d_TypeOfAnswer Answer;
1590
1591                 Standard_Integer i      = MyDisplayedStructure.Extent ();
1592
1593 Graphic3d_SequenceOfStructure FooSequence;
1594
1595                 while (S1Iterator.More ()) {
1596                         Answer  = AcceptDisplay (S1Iterator.Key ());
1597                         // Si la structure n'est plus affichable dans le
1598                         // nouveau contexte de la vue, on l'efface.
1599                         if ((Answer == Visual3d_TOA_NO) ||
1600                             (Answer == Visual3d_TOA_COMPUTE))
1601                                 //Erase (S1Iterator.Key (), Aspect_TOU_WAIT);
1602                                 FooSequence.Append (S1Iterator.Key ());
1603
1604                         // S1Iterator.Next () se positionne sur la
1605                         // prochaine structure
1606                         S1Iterator.Next ();
1607                 }
1608
1609 Standard_Integer Length = FooSequence.Length ();
1610                 // On efface les structures stockees
1611                 for (i=1; i<=Length; i++)
1612                         Erase (FooSequence.Value (i), Aspect_TOU_WAIT);
1613                 if (Length != 0) FooSequence.Clear ();
1614
1615                 /*
1616                  * Changement de contexte =>
1617                  * Display des structures qui  peuvent etre affichees
1618                  * avec le nouveau mode de visualisation.
1619                  * On recupere toutes  les structures ayant le statut
1620                  * Displayed dans le ViewManager et on l'affiche dans
1621                  * la vue directement, si la structure n'est pas deja
1622                  * affichee et si la vue l'accepte dans son contexte.
1623                  */
1624
1625                 i       = MyViewManager->NumberOfDisplayedStructures ();
1626                 Graphic3d_MapOfStructure Map;
1627                 MyViewManager->DisplayedStructures(Map);
1628                 Graphic3d_MapIteratorOfMapOfStructure it(Map);
1629
1630                 for (; it.More(); it.Next()) {
1631                   Handle(Graphic3d_Structure) SG = it.Key();
1632                     if (! IsDisplayed (SG)) {
1633                       Answer = AcceptDisplay(SG);
1634                         // Si la structure est affichable dans le
1635                         // nouveau contexte de la vue, on l'affiche.
1636                         if ((Answer == Visual3d_TOA_YES) ||
1637                             (Answer == Visual3d_TOA_COMPUTE))
1638                             //Display (MyViewManager->DisplayedStructure (j),
1639                                 //Aspect_TOU_WAIT);
1640                         FooSequence.Append (SG);
1641                     }
1642                 }
1643
1644                 Length  = FooSequence.Length ();
1645                 // On affiche les structures stockees
1646                 for (i=1; i<=Length; i++)
1647                         Display (FooSequence.Value (i), Aspect_TOU_WAIT);
1648                 if (Length != 0) FooSequence.Clear ();
1649         }
1650
1651         if (MyViewManager->UpdateMode () == Aspect_TOU_ASAP) Update ();
1652
1653 }
1654
1655 const Visual3d_ContextView& Visual3d_View::Context () const {
1656
1657         return (MyContext);
1658
1659 }
1660
1661 void Visual3d_View::DisplayedStructures (Graphic3d_MapOfStructure& SG) const
1662 {
1663
1664   if (IsDeleted ()) return;
1665
1666   Graphic3d_MapIteratorOfMapOfStructure Iterator (MyDisplayedStructure);
1667
1668   while (Iterator.More ()) {
1669     SG.Add (Iterator.Key ());
1670
1671     // Iterator.Next () se positionne sur la
1672     // prochaine structure
1673     Iterator.Next ();
1674   }
1675
1676 }
1677
1678 void Visual3d_View::Activate () {
1679
1680         if (IsDeleted ()) return;
1681
1682         if (! IsDefined ())
1683                 Visual3d_ViewDefinitionError::Raise ("Window not defined");
1684
1685         if (! IsActive ()) {
1686
1687                 MyGraphicDriver->ActivateView (MyCView);
1688                 MyGraphicDriver->Background (MyCView);
1689                 MyGraphicDriver->Transparency
1690                         (MyCView, MyViewManager->Transparency ());
1691
1692                 MyCView.Active  = 1;
1693
1694                 /*
1695                  * Activation d'une nouvelle vue =>
1696                  * Display des structures qui  peuvent etre affichees
1697                  * dans cette nouvelle vue.
1698                  * On recupere toutes  les structures ayant le statut
1699                  * Displayed dans le ViewManager et on l'affiche dans
1700                  * la vue directement, si la structure n'est pas deja
1701                  * affichee et si la vue l'accepte dans son contexte.
1702                  */
1703
1704                 Visual3d_TypeOfAnswer Answer;
1705                 Graphic3d_MapOfStructure Map;
1706                 MyViewManager->DisplayedStructures(Map);
1707                 Graphic3d_MapIteratorOfMapOfStructure it(Map);
1708
1709                 for (; it.More(); it.Next()) {
1710                   Handle(Graphic3d_Structure) SG = it.Key();
1711                     if (! IsDisplayed (SG)) {
1712                       Answer    = AcceptDisplay(SG);
1713                         // Si la structure est affichable dans le
1714                         // nouveau contexte de la vue, on l'affiche.
1715                         if ((Answer == Visual3d_TOA_YES) ||
1716                             (Answer == Visual3d_TOA_COMPUTE))
1717                         Display (SG,Aspect_TOU_WAIT);
1718                     }
1719                 }
1720
1721         }
1722
1723         // Si l'activation/desactivation du ZBuffer doit etre automatique
1724         // en fonction de la presence de facettes ou pas
1725         if (MyViewManager->ZBufferAuto ()) {
1726 Standard_Boolean BContainsFacet = ContainsFacet ();
1727 Standard_Boolean BZBuffer       = ZBufferIsActivated ();
1728                 // Si la vue contient des facettes
1729                 // et si le ZBuffer n'est pas actif
1730                 if (BContainsFacet && ! BZBuffer)
1731                         SetZBufferActivity (1);
1732                 // Si la vue ne contient pas des facettes
1733                 // et si le ZBuffer est actif
1734                 if (! BContainsFacet && BZBuffer)
1735                         SetZBufferActivity (0);
1736         }
1737
1738         if (MyViewManager->UpdateMode () == Aspect_TOU_ASAP) Update ();
1739
1740 }
1741
1742 Standard_Boolean Visual3d_View::IsActive () const {
1743
1744         if (IsDeleted ()) return (Standard_False);
1745
1746         if (MyCView.Active)
1747                 return (Standard_True);
1748         else
1749                 return (Standard_False);
1750
1751 }
1752
1753 void Visual3d_View::Deactivate () {
1754
1755         if (IsDeleted ()) return;
1756
1757         if (! IsDefined ())
1758                 Visual3d_ViewDefinitionError::Raise ("Window not defined");
1759
1760         if (IsActive ()) {
1761
1762                 MyGraphicDriver->DeactivateView (MyCView);
1763
1764                 /*
1765                  * Deactivation d'une vue =>
1766                  * Effacement des structures qui sont affichees
1767                  * dans cette vue.
1768                  * On recupere toute structure ayant le statut
1769                  * Displayed dans le ViewManager et on l'efface dans
1770                  * la vue directement, si la structure n'est pas deja
1771                  * effacee et si la vue l'accepte dans son contexte.
1772                  */
1773
1774                 Visual3d_TypeOfAnswer Answer;
1775                 Graphic3d_MapOfStructure Map;
1776                 MyViewManager->DisplayedStructures(Map);
1777                 Graphic3d_MapIteratorOfMapOfStructure it(Map);
1778
1779                 for (; it.More(); it.Next()) {
1780                   Handle(Graphic3d_Structure) SG = it.Key();
1781                     if (! IsDisplayed (SG)) {
1782                         Answer  = AcceptDisplay(SG);
1783                         // Si la structure etait affichable, on l'efface.
1784                         if ((Answer == Visual3d_TOA_YES) ||
1785                             (Answer == Visual3d_TOA_COMPUTE))
1786                                 Erase (SG,Aspect_TOU_WAIT);
1787                     }
1788                 }
1789
1790                 if (MyViewManager->UpdateMode () == Aspect_TOU_ASAP) Update ();
1791
1792                 // Plus d'action possible sur la vue maintenant
1793                 MyCView.Active  = 0;
1794         }
1795
1796 }
1797
1798 void Visual3d_View::Redraw () {
1799
1800         Redraw (MyViewManager->UnderLayer (), MyViewManager->OverLayer ());
1801
1802 }
1803
1804 void Visual3d_View::Redraw (const Standard_Integer x, const Standard_Integer y, const Standard_Integer width, const Standard_Integer height) {
1805
1806         Redraw (MyViewManager->UnderLayer (), MyViewManager->OverLayer (), x, y, width, height);
1807 }
1808
1809 void Visual3d_View::Redraw (const Handle(Visual3d_Layer)& AnUnderLayer, const Handle(Visual3d_Layer)& AnOverLayer) {
1810
1811         if (IsDeleted ()) return;
1812
1813         if ((! IsDefined ()) || (! IsActive ())) return;
1814
1815         if (! MyWindow->IsMapped ()) return;
1816
1817         // san - 14/04/2004 - set up Z buffer state before redrawing
1818         // Si l'activation/desactivation du ZBuffer doit etre automatique
1819         // en fonction de la presence de facettes ou pas
1820         if (MyViewManager->ZBufferAuto ()) {
1821                 Standard_Boolean BContainsFacet = ContainsFacet ();
1822                 Standard_Boolean BZBuffer       = ZBufferIsActivated ();
1823                 // Si la vue contient des facettes
1824                 // et si le ZBuffer n'est pas actif
1825                 if (BContainsFacet && ! BZBuffer)
1826                         SetZBufferActivity (1);
1827                 // Si la vue ne contient pas des facettes
1828                 // et si le ZBuffer est actif
1829                 if (! BContainsFacet && BZBuffer)
1830                         SetZBufferActivity (0);
1831         }
1832
1833         Aspect_CLayer2d OverCLayer;
1834         Aspect_CLayer2d UnderCLayer;
1835         OverCLayer.ptrLayer = UnderCLayer.ptrLayer = NULL;
1836         if (! AnOverLayer.IsNull ()) OverCLayer = AnOverLayer->CLayer ();
1837         if (! AnUnderLayer.IsNull ()) UnderCLayer = AnUnderLayer->CLayer ();
1838         MyGraphicDriver->Redraw (MyCView, UnderCLayer, OverCLayer);
1839
1840 }
1841
1842 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) {
1843
1844         if (IsDeleted ()) return;
1845
1846         if ((! IsDefined ()) || (! IsActive ())) return;
1847
1848         if (! MyWindow->IsMapped ()) return;
1849
1850         // san - 14/04/2004 - set up Z buffer state before redrawing
1851         // Si l'activation/desactivation du ZBuffer doit etre automatique
1852         // en fonction de la presence de facettes ou pas
1853         if (MyViewManager->ZBufferAuto ()) {
1854         Standard_Boolean BContainsFacet = ContainsFacet ();
1855         Standard_Boolean BZBuffer       = ZBufferIsActivated ();
1856                 // Si la vue contient des facettes
1857                 // et si le ZBuffer n'est pas actif
1858                 if (BContainsFacet && ! BZBuffer)
1859                         SetZBufferActivity (1);
1860                 // Si la vue ne contient pas des facettes
1861                 // et si le ZBuffer est actif
1862                 if (! BContainsFacet && BZBuffer)
1863                         SetZBufferActivity (0);
1864         }
1865
1866         Aspect_CLayer2d OverCLayer;
1867         Aspect_CLayer2d UnderCLayer;
1868         OverCLayer.ptrLayer = UnderCLayer.ptrLayer = NULL;
1869         if (! AnOverLayer.IsNull ()) OverCLayer = AnOverLayer->CLayer ();
1870         if (! AnUnderLayer.IsNull ()) UnderCLayer = AnUnderLayer->CLayer ();
1871         MyGraphicDriver->Redraw (MyCView, UnderCLayer, OverCLayer, x, y, width, height);
1872
1873 }
1874
1875 void Visual3d_View::Update () {
1876
1877         Update (MyViewManager->UnderLayer (), MyViewManager->OverLayer ());
1878
1879 }
1880
1881 void Visual3d_View::Update (const Handle(Visual3d_Layer)& AnUnderLayer, const Handle(Visual3d_Layer)& AnOverLayer) {
1882
1883         if (IsDeleted ()) return;
1884
1885         if ((! IsDefined ()) || (! IsActive ())) return;
1886
1887         if (! MyWindow->IsMapped ()) return;
1888
1889         // Si l'activation/desactivation du ZBuffer doit etre automatique
1890         // en fonction de la presence de facettes ou pas
1891         if (MyViewManager->ZBufferAuto ()) {
1892 Standard_Boolean BContainsFacet = ContainsFacet ();
1893 Standard_Boolean BZBuffer       = ZBufferIsActivated ();
1894                 // Si la vue contient des facettes
1895                 // et si le ZBuffer n'est pas actif
1896                 if (BContainsFacet && ! BZBuffer)
1897                         SetZBufferActivity (1);
1898                 // Si la vue ne contient pas des facettes
1899                 // et si le ZBuffer est actif
1900                 if (! BContainsFacet && BZBuffer)
1901                         SetZBufferActivity (0);
1902         }
1903
1904 Aspect_CLayer2d OverCLayer;
1905 Aspect_CLayer2d UnderCLayer;
1906         OverCLayer.ptrLayer = UnderCLayer.ptrLayer = NULL;
1907         if (! AnUnderLayer.IsNull ()) UnderCLayer = AnUnderLayer->CLayer ();
1908         if (! AnOverLayer.IsNull ()) OverCLayer = AnOverLayer->CLayer ();
1909         //OSD::SetSignal (Standard_False);
1910         MyGraphicDriver->Update (MyCView, UnderCLayer, OverCLayer);
1911         //OSD::SetSignal (Standard_True);
1912
1913         MyMatOfMapIsModified    = Standard_False;
1914         MyMatOfOriIsModified    = Standard_False;
1915
1916 }
1917
1918 Visual3d_TypeOfAnswer Visual3d_View::AcceptDisplay (const Handle(Graphic3d_Structure)& AStructure) const {
1919
1920 // Recuperation type de visualisation de la vue
1921 Visual3d_TypeOfVisualization ViewType = MyContext.Visualization ();
1922
1923 // Recuperation type de visualisation de la structure
1924 Graphic3d_TypeOfStructure StructType = AStructure->Visual ();
1925
1926 Visual3d_TypeOfAnswer Result = Visual3d_TOA_NO;
1927
1928         if (StructType == Graphic3d_TOS_ALL)
1929                 // La structure accepte tout type de vue
1930                 Result  = Visual3d_TOA_YES;
1931         else {
1932                 if ((StructType == Graphic3d_TOS_SHADING)
1933                         && (ViewType == Visual3d_TOV_SHADING))
1934                         Result  = Visual3d_TOA_YES;
1935                 if ((StructType == Graphic3d_TOS_WIREFRAME)
1936                         && (ViewType == Visual3d_TOV_WIREFRAME))
1937                         Result  = Visual3d_TOA_YES;
1938                 if ((StructType == Graphic3d_TOS_COMPUTED)
1939                         && (ViewType == Visual3d_TOV_WIREFRAME))
1940                         Result  = Visual3d_TOA_COMPUTE;
1941                 if ((StructType == Graphic3d_TOS_COMPUTED)
1942                         && (ViewType == Visual3d_TOV_SHADING))
1943                         Result  = Visual3d_TOA_COMPUTE;
1944         }
1945
1946 #ifdef TRACE_ACCEPT
1947         if (Result == Visual3d_TOA_YES)
1948         cout << "YES = Visual3d_View" << MyCView.ViewId
1949              << "::AcceptDisplay (" << AStructure->Identification () << ")\n";
1950         if (Result == Visual3d_TOA_NO)
1951         cout << "NO = Visual3d_View" << MyCView.ViewId
1952              << "::AcceptDisplay (" << AStructure->Identification () << ")\n";
1953         if (Result == Visual3d_TOA_COMPUTE)
1954         cout << "COMPUTE = Visual3d_View" << MyCView.ViewId
1955              << "::AcceptDisplay (" << AStructure->Identification () << ")\n";
1956         cout << flush;
1957 #endif
1958
1959         return (Result);
1960
1961 }
1962
1963 void Visual3d_View::ChangeDisplayPriority (const Handle(Graphic3d_Structure)& AStructure, const Standard_Integer OldPriority, const Standard_Integer NewPriority) {
1964
1965         if (IsDeleted ()) return;
1966         if (! IsDefined ()) return;
1967         if (! IsActive ()) return;
1968         if (! IsDisplayed (AStructure)) return;
1969
1970 Standard_Integer Index = IsComputed (AStructure);
1971 #ifdef G003
1972         if (  Index != 0 && ComputedMode () && !DegenerateModeIsOn ()  )
1973 #else
1974         if ((Index != 0) && (! DegenerateModeIsOn ()))
1975 #endif  // G003
1976         {
1977 #ifdef TRACE
1978         Standard_Integer StructId = MyCOMPUTEDSequence.Value (Index)->Identification ();
1979         cout << "Visual3d_View" << MyCView.ViewId << "::ChangeDisplayPriority ("
1980              << AStructure->Identification () << "/" << StructId
1981              << ", " << OldPriority << ", " << NewPriority << ")\n";
1982         cout << flush;
1983 #endif
1984                 MyGraphicDriver->EraseStructure
1985                         (MyCView,
1986                          *(Graphic3d_CStructure *)
1987                             MyCOMPUTEDSequence.Value (Index)->CStructure ());
1988                 MyGraphicDriver->DisplayStructure
1989                         (MyCView,
1990                          *(Graphic3d_CStructure *)
1991                             MyCOMPUTEDSequence.Value (Index)->CStructure (),
1992                          int (NewPriority));
1993         }
1994         else {
1995 #ifdef TRACE
1996         Standard_Integer StructId = AStructure->Identification ();
1997         cout << "Visual3d_View" << MyCView.ViewId << "::ChangeDisplayPriority ("
1998              << AStructure->Identification () << "/" << StructId
1999              << ", " << OldPriority << ", " << NewPriority << ")\n";
2000         cout << flush;
2001 #endif
2002                 MyGraphicDriver->EraseStructure
2003                         (MyCView,
2004                          *(Graphic3d_CStructure *)AStructure->CStructure ());
2005                 MyGraphicDriver->DisplayStructure
2006                         (MyCView,
2007                          *(Graphic3d_CStructure *)AStructure->CStructure (),
2008                          int (NewPriority));
2009         }
2010
2011 }
2012
2013 void Visual3d_View::Clear (const Handle(Graphic3d_Structure)& AStructure, const Standard_Boolean WithDestruction) {
2014
2015 #ifdef TRACE_CLEAR
2016         cout << "Visual3d_View" << MyCView.ViewId << "::Clear ("
2017              << AStructure->Identification () << ")\n";
2018         cout << flush;
2019 #endif
2020
2021 Standard_Integer Index = IsComputed (AStructure);
2022         if (Index != 0) {
2023 #ifdef TRACE_CLEAR
2024         cout << "La structure " << AStructure->Identification ()
2025              << " calculee, dans la view "
2026              << Identification () << ", par la structure "
2027              << MyCOMPUTEDSequence.Value (Index)->Identification ()
2028              << " est videe.\n";
2029         cout << flush;
2030 #endif
2031                 MyCOMPUTEDSequence.Value (Index)->GraphicClear (WithDestruction);
2032                 MyCOMPUTEDSequence.Value (Index)->SetHLRValidation (Standard_False);
2033         }
2034
2035 }
2036
2037 void Visual3d_View::Connect (const Handle(Graphic3d_Structure)& AMother, const Handle(Graphic3d_Structure)& ADaughter) {
2038
2039 #ifdef TRACE_CONNECT
2040         cout << "Visual3d_View" << MyCView.ViewId << "::Connect ("
2041              << AMother->Identification ()
2042              << ADaughter->Identification () << ")\n";
2043         cout << flush;
2044 #endif
2045
2046 Standard_Integer IndexM = IsComputed (AMother);
2047 Standard_Integer IndexD = IsComputed (ADaughter);
2048
2049         if (IndexM != 0 && IndexD != 0) {
2050 #ifdef TRACE_CONNECT
2051         cout << "La structure " << AMother->Identification ()
2052              << " est connectee a la structure "
2053              << ADaughter->Identification () << endl;
2054         cout << "Ces structures sont calculees.\n";
2055         cout << "Dans la view " << Identification ()
2056              << "La structure "
2057              << MyCOMPUTEDSequence.Value (IndexM)->Identification ()
2058              << " est connectee a la structure "
2059              << MyCOMPUTEDSequence.Value (IndexD)->Identification ()
2060              << endl;
2061 #endif
2062                 MyCOMPUTEDSequence.Value (IndexM)->GraphicConnect (MyCOMPUTEDSequence.Value (IndexD));
2063         }
2064
2065 }
2066
2067 void Visual3d_View::Disconnect (const Handle(Graphic3d_Structure)& AMother, const Handle(Graphic3d_Structure)& ADaughter) {
2068
2069 #ifdef TRACE_CONNECT
2070         cout << "Visual3d_View" << MyCView.ViewId << "::Disconnect ("
2071              << AMother->Identification ()
2072              << ADaughter->Identification () << ")\n";
2073         cout << flush;
2074 #endif
2075
2076 Standard_Integer IndexM = IsComputed (AMother);
2077 Standard_Integer IndexD = IsComputed (ADaughter);
2078
2079         if (IndexM != 0 && IndexD != 0) {
2080 #ifdef TRACE_CONNECT
2081         cout << "La structure " << AMother->Identification ()
2082              << " est disconnectee de la structure "
2083              << ADaughter->Identification () << endl;
2084         cout << "Ces structures sont calculees.\n";
2085         cout << "Dans la view " << Identification ()
2086              << "La structure "
2087              << MyCOMPUTEDSequence.Value (IndexM)->Identification ()
2088              << " est disconnectee de la structure "
2089              << MyCOMPUTEDSequence.Value (IndexD)->Identification ()
2090              << endl;
2091 #endif
2092                 MyCOMPUTEDSequence.Value (IndexM)->GraphicDisconnect (MyCOMPUTEDSequence.Value (IndexD));
2093         }
2094
2095 }
2096
2097 void Visual3d_View::Display (const Handle(Graphic3d_Structure)& AStructure) {
2098
2099         Display (AStructure, MyViewManager->UpdateMode ());
2100
2101 }
2102
2103 void Visual3d_View::Display (const Handle(Graphic3d_Structure)& AStructure, const Aspect_TypeOfUpdate AnUpdateMode) {
2104
2105         if (IsDeleted ()) return;
2106         if (! IsDefined ()) return;
2107         if (! IsActive ()) return;
2108
2109         // Si Display sur une structure qui est dans la liste
2110         // des structures calculees alors qu'elle n'est pas
2111         // ou plus, du type calcule =>
2112         // On l'enleve ainsi que l'ancienne compute associee
2113         // Ceci arrive lorsque la hlhsr redevient du type
2114         // non computed apres un SetVisual.
2115 Standard_Integer Index = IsComputed (AStructure);
2116
2117         if ((Index != 0) && (AStructure->Visual () != Graphic3d_TOS_COMPUTED)) {
2118
2119 #ifdef TRACE_LENGTH
2120         if (MyTOCOMPUTESequence.Length () != MyCOMPUTEDSequence.Length ()) {
2121                 cout << "In Visual3d_View::Display, ";
2122                 cout << "TOCOMPUTE " << MyTOCOMPUTESequence.Length ()
2123                      << " != COMPUTED " << MyCOMPUTEDSequence.Length ()
2124                      << "\n" << flush;
2125         }
2126 #endif
2127                 MyTOCOMPUTESequence.Remove (Index);
2128                 MyCOMPUTEDSequence.Remove (Index);
2129
2130 #ifdef TRACE_LENGTH
2131         if (MyTOCOMPUTESequence.Length () != MyCOMPUTEDSequence.Length ())
2132                 cout << "\tTOCOMPUTE " << MyTOCOMPUTESequence.Length ()
2133                      << " != COMPUTED " << MyCOMPUTEDSequence.Length ()
2134                      << "\n" << flush;
2135 #endif
2136                 Index = 0;
2137         }
2138
2139         Visual3d_TypeOfAnswer Answer = AcceptDisplay (AStructure);
2140
2141 #ifdef TRACE_DISPLAY
2142         Standard_Integer StructId = AStructure->Identification ();
2143         cout << "Visual3d_View" << MyCView.ViewId << "::Display ("
2144              << StructId << ");\n";
2145         cout << flush;
2146 #endif
2147
2148         if (Answer == Visual3d_TOA_NO) {
2149 #ifdef TRACE_DISPLAY
2150                 cout << "Answer : Visual3d_TOA_NO\n";
2151                 cout << flush;
2152 #endif
2153                 return;
2154         }
2155
2156         // Mode degenere actif
2157 #ifdef G003
2158         if (  !ComputedMode () || DegenerateModeIsOn ()  )
2159                                         Answer = Visual3d_TOA_YES;
2160 #else
2161         if (DegenerateModeIsOn ()) Answer = Visual3d_TOA_YES;
2162 ;
2163 #endif  // G003
2164
2165         if (Answer == Visual3d_TOA_YES ) {
2166 #ifdef TRACE_DISPLAY
2167                 cout << "Answer : Visual3d_TOA_YES\n";
2168                 cout << flush;
2169 #endif
2170                 if (IsDisplayed (AStructure)) return;
2171                 MyGraphicDriver->DisplayStructure (
2172                         MyCView,
2173                         *(Graphic3d_CStructure *)AStructure->CStructure (),
2174                         int (AStructure->DisplayPriority ())
2175                 );
2176                 MyDisplayedStructure.Add (AStructure);
2177                 if (AnUpdateMode == Aspect_TOU_ASAP) Update ();
2178         }
2179
2180         if (Answer == Visual3d_TOA_COMPUTE) {
2181 #ifdef TRACE_DISPLAY
2182             cout << "Answer : Visual3d_TOA_COMPUTE\n";
2183             cout << "Index : " << Index << "\n" << flush;
2184 #endif
2185             if (Index != 0) {
2186                 // Deja calculee, mais la COMPUTED est-elle encore valide ?
2187 #ifdef TRACE_DISPLAY
2188                 if (MyCOMPUTEDSequence.Value (Index)->HLRValidation ()) {
2189                   cout << "La structure "
2190                      << MyTOCOMPUTESequence.Value (Index)->Identification ()
2191                      << " deja calculee, dans la view "
2192                      << Identification () << ", par la structure "
2193                      << MyCOMPUTEDSequence.Value (Index)->Identification ()
2194                      << "\n n'a pas a etre recalculee car HLR est valide\n";
2195                   cout << flush;
2196                 }
2197                 else {
2198                   cout << "La structure "
2199                      << MyTOCOMPUTESequence.Value (Index)->Identification ()
2200                      << " deja calculee, dans la view "
2201                      << Identification () << ", par la structure "
2202                      << MyCOMPUTEDSequence.Value (Index)->Identification ()
2203                      << "\n doit etre recalculee car HLR est invalide\n";
2204                   cout << flush;
2205                 }
2206 #endif
2207 Standard_Integer OldStructId =
2208         MyCOMPUTEDSequence.Value (Index)->Identification ();
2209
2210                 // Cas COMPUTED valide
2211                 if (MyCOMPUTEDSequence.Value (Index)->HLRValidation ()) {
2212                     // a afficher
2213                     if (! IsDisplayed (AStructure)) {
2214                         MyDisplayedStructure.Add (AStructure);
2215                         MyGraphicDriver->DisplayStructure (
2216                             MyCView,
2217                             *(Graphic3d_CStructure *)MyCOMPUTEDSequence.Value (Index)->CStructure (),
2218                             int (AStructure->DisplayPriority ())
2219                         );
2220                         if (AnUpdateMode == Aspect_TOU_ASAP) Update ();
2221                     }
2222                     return;
2223                 }
2224
2225                 // Cas COMPUTED invalide
2226                 else {
2227                     // Existe-t-il une autre representation valide ?
2228                     // Recherche dans la sequence des structures deja calculees
2229                     // 1/ D'une structure ayant le meme Owner que <AStructure>
2230                     // 2/ Qui ne soit pas <AStructure>
2231                     // 3/ Dont la COMPUTED soit valide
2232                     Standard_Integer NewIndex = HaveTheSameOwner (AStructure);
2233
2234                     // Cas COMPUTED invalide, AVEC une valide de remplacement
2235                     if (NewIndex != 0) {
2236                         // a afficher
2237                         if (! IsDisplayed (AStructure)) {
2238                             MyCOMPUTEDSequence.SetValue
2239                                 (Index, MyCOMPUTEDSequence.Value (NewIndex));
2240                             OldStructId = MyCOMPUTEDSequence.Value (NewIndex)->
2241                                                         Identification ();
2242                             MyDisplayedStructure.Add (AStructure);
2243                             MyGraphicDriver->DisplayStructure (
2244                                 MyCView,
2245                                 *(Graphic3d_CStructure *)MyCOMPUTEDSequence.Value (NewIndex)->CStructure (),
2246                                 int (AStructure->DisplayPriority ())
2247                             );
2248                             if (AnUpdateMode == Aspect_TOU_ASAP) Update ();
2249                         }
2250                         return;
2251                     }
2252
2253                     // Cas COMPUTED invalide, SANS une valide de remplacement
2254                     else {
2255                         // On efface la COMPUTED si affichee
2256                         if (IsDisplayed (AStructure))
2257                             MyGraphicDriver->EraseStructure (
2258                                 MyCView,
2259                                 *(Graphic3d_CStructure *)MyCOMPUTEDSequence.Value (Index)->CStructure ()
2260                             );
2261                     }
2262                 }
2263             } // if (Index != 0)
2264
2265             // Compute + Validation
2266 #ifdef OLD
2267 Handle(Graphic3d_Structure) TheStructure = AStructure->Compute (this);
2268 #else
2269 Handle(Graphic3d_Structure) TheStructure;
2270 TColStd_Array2OfReal ATrsf (0, 3, 0, 3);
2271             AStructure->Transform (ATrsf);
2272             if (Index != 0) {
2273 TColStd_Array2OfReal Ident (0, 3, 0, 3);
2274 Standard_Integer ii, jj;
2275         for (ii=0; ii<=3; ii++)
2276             for (jj=0; jj<=3; jj++)
2277                 Ident (ii, jj) = (ii == jj ? 1.0 : 0.0);
2278                 TheStructure = MyCOMPUTEDSequence.Value (Index);
2279                 TheStructure->SetTransform (Ident, Graphic3d_TOC_REPLACE);
2280                 if (AStructure->IsTransformed ()) {
2281                     AStructure->Compute (this, ATrsf, TheStructure);
2282                 }
2283                 else {
2284                     AStructure->Compute (this, TheStructure);
2285                 }
2286             }
2287             else {
2288                 if (AStructure->IsTransformed ()) {
2289                     TheStructure = AStructure->Compute (this, ATrsf);
2290                 }
2291                 else {
2292                     TheStructure = AStructure->Compute (this);
2293                 }
2294             }
2295 #endif
2296             TheStructure->SetHLRValidation (Standard_True);
2297
2298 #ifdef TRACE_LENGTH
2299         if (MyTOCOMPUTESequence.Length () != MyCOMPUTEDSequence.Length ())
2300                 cout << "\tTOCOMPUTE " << MyTOCOMPUTESequence.Length ()
2301                      << " != COMPUTED " << MyCOMPUTEDSequence.Length ()
2302                      << "\n" << flush;
2303 #endif
2304
2305             // On ajoute la TOCOMPUTE et la COMPUTED associee aux sequences
2306             MyTOCOMPUTESequence.Append (AStructure);
2307             MyCOMPUTEDSequence.Append (TheStructure);
2308
2309 #ifdef TRACE_LENGTH
2310         if (MyTOCOMPUTESequence.Length () != MyCOMPUTEDSequence.Length ())
2311                 cout << "\tTOCOMPUTE " << MyTOCOMPUTESequence.Length ()
2312                      << " != COMPUTED " << MyCOMPUTEDSequence.Length ()
2313                      << "\n" << flush;
2314 #endif
2315
2316             // On enleve, si necessaire, les anciennes
2317             if (Index != 0) {
2318                 MyTOCOMPUTESequence.Remove (Index);
2319                 MyCOMPUTEDSequence.Remove (Index);
2320             }
2321
2322 #ifdef TRACE_LENGTH
2323         if (MyTOCOMPUTESequence.Length () != MyCOMPUTEDSequence.Length ())
2324                 cout << "\tTOCOMPUTE " << MyTOCOMPUTESequence.Length ()
2325                      << " != COMPUTED " << MyCOMPUTEDSequence.Length ()
2326                      << "\n" << flush;
2327 #endif
2328
2329 // Recuperation type de visualisation de la vue
2330 Visual3d_TypeOfVisualization ViewType = MyContext.Visualization ();
2331
2332 // De quel type sera la computed ?
2333 Standard_Boolean ComputeWireframe = ((ViewType == Visual3d_TOV_WIREFRAME) &&
2334                 (AStructure->ComputeVisual () != Graphic3d_TOS_SHADING));
2335
2336 Standard_Boolean ComputeShading = ((ViewType == Visual3d_TOV_SHADING) &&
2337                 (AStructure->ComputeVisual () != Graphic3d_TOS_WIREFRAME));
2338
2339             if (ComputeWireframe)
2340                 TheStructure->SetVisual (Graphic3d_TOS_WIREFRAME);
2341             if (ComputeShading)
2342                 TheStructure->SetVisual (Graphic3d_TOS_SHADING);
2343
2344             if (! ComputeShading && ! ComputeWireframe)
2345                 Answer = Visual3d_TOA_NO;
2346             else
2347                 Answer = AcceptDisplay (TheStructure);
2348
2349             if (AStructure->IsHighlighted()) {
2350                 TheStructure->SetHighlightColor (AStructure->HighlightColor ());
2351                 TheStructure->GraphicHighlight (Aspect_TOHM_COLOR);
2352             }
2353
2354 #ifdef TRACE_DISPLAY
2355             cout << "La structure " << StructId
2356                  << " dans la view " << Identification ()
2357                  << " est calculee par la structure "
2358                  << TheStructure->Identification ();
2359             if (Answer == Visual3d_TOA_YES)
2360                 cout << " et affichee\n";
2361             else
2362                 cout << " mais pas affichee\n";
2363             cout << flush;
2364 #endif
2365
2366             // On ne l'affiche que si la structure calculee
2367             // est du bon type par rapport a celui de la vue.
2368             if (Answer != Visual3d_TOA_NO) {
2369                 if (! IsDisplayed (AStructure))
2370                         MyDisplayedStructure.Add (AStructure);
2371                 MyGraphicDriver->DisplayStructure (
2372                         MyCView,
2373                         *(Graphic3d_CStructure *)TheStructure->CStructure (),
2374                         int (AStructure->DisplayPriority ())
2375                 );
2376                 if (AnUpdateMode == Aspect_TOU_ASAP) Update ();
2377             }
2378         } // Visual3d_TOA_COMPUTE
2379 }
2380
2381 void Visual3d_View::Erase (const Handle(Graphic3d_Structure)& AStructure) {
2382
2383         if (IsDeleted ()) return;
2384
2385         Erase (AStructure, MyViewManager->UpdateMode ());
2386
2387 }
2388
2389 void Visual3d_View::Erase (const Handle(Graphic3d_Structure)& AStructure, const Aspect_TypeOfUpdate AnUpdateMode) {
2390
2391 Standard_Integer StructId;
2392
2393         if (IsDeleted ()) return;
2394
2395         // Pas de test sur window car la structure est affichee que
2396         // si la window existe, donc un seul test suffit.
2397         if (IsDisplayed (AStructure)) {
2398 Visual3d_TypeOfAnswer Answer = AcceptDisplay (AStructure);
2399
2400                 // Mode degenere actif
2401 #ifdef G003
2402                 if (  !ComputedMode () || DegenerateModeIsOn ()  )
2403                                         Answer = Visual3d_TOA_YES;
2404 #else
2405                 if (DegenerateModeIsOn ()) Answer = Visual3d_TOA_YES;
2406 #endif  // G003
2407
2408                 if (Answer != Visual3d_TOA_COMPUTE) {
2409                         MyGraphicDriver->EraseStructure (
2410                                 MyCView,
2411                                 *(Graphic3d_CStructure *)AStructure->CStructure ()
2412                         );
2413                 }
2414
2415                 if (Answer == Visual3d_TOA_COMPUTE) {
2416 Standard_Integer Index = IsComputed (AStructure);
2417 #ifdef TRACE_COMP
2418         cout << "Visual3d_View" << MyCView.ViewId << "::Erase ("
2419              << AStructure->Identification () << ");\n";
2420         cout << "Index : " << Index << "\n";
2421         cout << flush;
2422 #endif
2423 #ifdef G003
2424                     if (  Index != 0 && ComputedMode () &&
2425                                                 !DegenerateModeIsOn ()  )
2426 #else
2427                     if ((Index != 0) && (! DegenerateModeIsOn ()))
2428 #endif  // G003
2429                     {
2430                         StructId =
2431                         MyCOMPUTEDSequence.Value (Index)->Identification ();
2432 #ifdef TRACE_COMP
2433         cout << "Structure " << AStructure->Identification ()
2434              << " calculee, dans la view "
2435              << Identification () << ", par la structure "
2436              << StructId << " est effacee. \n";
2437         cout << flush;
2438 #endif
2439                         MyGraphicDriver->EraseStructure
2440                                 (MyCView, *(Graphic3d_CStructure *)MyCOMPUTEDSequence.Value (Index)->CStructure ());
2441                     }
2442                     // Le else est impossible
2443                 }
2444                 MyDisplayedStructure.Remove (AStructure);
2445                 if (AnUpdateMode == Aspect_TOU_ASAP) Update ();
2446         }
2447
2448 }
2449
2450 void Visual3d_View::Highlight (const Handle(Graphic3d_Structure)& AStructure, const Aspect_TypeOfHighlightMethod AMethod) {
2451
2452 #ifdef TRACE_HIGH
2453         cout << "Visual3d_View" << MyCView.ViewId << "::Highlight ("
2454              << AStructure->Identification () << ")\n";
2455         cout << flush;
2456 #endif
2457
2458 Standard_Integer Index = IsComputed (AStructure);
2459         if (Index != 0) {
2460 #ifdef TRACE_HIGH
2461         cout << "La structure " << AStructure->Identification ()
2462              << " calculee, dans la view "
2463              << Identification () << ", par la structure "
2464              << MyCOMPUTEDSequence.Value (Index)->Identification ()
2465              << " passe en mode highlight.\n";
2466         cout << flush;
2467 #endif
2468                 (MyCOMPUTEDSequence.Value (Index))->SetHighlightColor
2469                         (AStructure->HighlightColor ());
2470                 (MyCOMPUTEDSequence.Value (Index))->GraphicHighlight (AMethod);
2471         }
2472
2473 }
2474
2475 void Visual3d_View::SetTransform (const Handle(Graphic3d_Structure)& AStructure, const TColStd_Array2OfReal& ATrsf) {
2476
2477 #ifdef TRACE_TRSF
2478         cout << "Visual3d_View" << MyCView.ViewId << "::Transform ("
2479              << AStructure->Identification () << ")\n";
2480         cout << flush;
2481 #endif
2482
2483 Standard_Integer Index = IsComputed (AStructure);
2484         if (Index != 0) {
2485 #ifdef TRACE_TRSF
2486         cout << "La structure " << AStructure->Identification ()
2487              << " calculee, dans la view "
2488              << Identification () << ", par la structure "
2489              << MyCOMPUTEDSequence.Value (Index)->Identification ()
2490              << " est transformee.\n";
2491         cout << flush;
2492 #endif
2493                 // Test un peu leger !
2494                 // On ne transmet la trsf que si c'est :
2495                 // une translation
2496                 // un scale
2497                 if (ATrsf (0, 1) != 0. || ATrsf (0, 2) != 0.
2498                  || ATrsf (1, 0) != 0. || ATrsf (1, 2) != 0.
2499                  || ATrsf (2, 0) != 0. || ATrsf (2, 1) != 0.)
2500                     ReCompute (AStructure);
2501                 else
2502                     MyCOMPUTEDSequence.Value (Index)->GraphicTransform (ATrsf);
2503         }
2504
2505 }
2506
2507 void Visual3d_View::UnHighlight (const Handle(Graphic3d_Structure)& AStructure) {
2508
2509 #ifdef TRACE_HIGH
2510         cout << "Visual3d_View" << MyCView.ViewId << "::UnHighlight ("
2511              << AStructure->Identification () << ")\n";
2512         cout << flush;
2513 #endif
2514
2515 Standard_Integer Index = IsComputed (AStructure);
2516         if (Index != 0) {
2517 #ifdef TRACE_HIGH
2518         cout << "La structure " << AStructure->Identification ()
2519              << " calculee, dans la view "
2520              << Identification () << ", par la structure "
2521              << MyCOMPUTEDSequence.Value (Index)->Identification ()
2522              << " passe en mode unhighlight.\n";
2523         cout << flush;
2524 #endif
2525                 MyCOMPUTEDSequence.Value (Index)->GraphicUnHighlight ();
2526         }
2527
2528
2529 }
2530
2531 Standard_Integer Visual3d_View::IsComputed (const Handle(Graphic3d_Structure)& AStructure) const {
2532
2533 Standard_Integer StrId = AStructure->Identification ();
2534
2535 Standard_Integer Result = 0;
2536 Standard_Integer Length = MyTOCOMPUTESequence.Length ();
2537
2538         // Recherche de la structure <AStructure> dans la
2539         // sequence des structures deja calculees
2540         for (Standard_Integer i=1; i<=Length && Result==0; i++)
2541                 if ((MyTOCOMPUTESequence.Value (i))->Identification ()
2542                         == StrId) Result        = i;
2543 #ifdef TRACE_ISCOMP
2544         cout << "\nDans la vue " << Identification () << " la structure ";
2545         if (Result != 0)
2546                 cout << StrId << " est calculee par "
2547                      << MyCOMPUTEDSequence.Value (Result)->Identification ()
2548                      << "\n" << flush;
2549         else
2550                 cout << StrId << " n'est pas calculee\n" << flush;
2551 #endif
2552
2553 #ifdef TRACE_LENGTH
2554         if (MyTOCOMPUTESequence.Length () != MyCOMPUTEDSequence.Length ()) {
2555                 cout << "In Visual3d_View::IsComputed, ";
2556                 cout << "TOCOMPUTE " << MyTOCOMPUTESequence.Length ()
2557                      << " != COMPUTED " << MyCOMPUTEDSequence.Length ()
2558                      << "\n" << flush;
2559         }
2560 #endif
2561
2562         return (Result);
2563
2564 }
2565
2566 Standard_Boolean Visual3d_View::IsDisplayed (const Handle(Graphic3d_Structure)& AStructure) const {
2567
2568 Standard_Boolean Result = Standard_False;
2569
2570         if (IsDeleted ()) return Result;
2571
2572         Result  = MyDisplayedStructure.Contains (AStructure);
2573
2574         return Result;
2575
2576 }
2577
2578 #ifdef IMPLEMENTED
2579 Standard_Boolean Visual3d_View::ContainsComputedStructure () const {
2580
2581 Standard_Boolean Result = Standard_False;
2582
2583         if (MyDisplayedStructure.IsEmpty ()) return Result;
2584
2585 Graphic3d_MapIteratorOfMapOfStructure Iterator (MyDisplayedStructure);
2586
2587         Standard_Integer i      = MyDisplayedStructure.Extent ();
2588
2589         // On s'arrette a la premiere structure qui est du type TOS_COMPUTED
2590         while (! Result && Iterator.More ()) {
2591                 Result  =
2592                 (((Iterator.Key ())->Visual ()) == Graphic3d_TOS_COMPUTED);
2593
2594                 // Iterator.Next () se positionne sur la
2595                 // prochaine structure
2596                 Iterator.Next ();
2597         }
2598
2599         return Result;
2600
2601 }
2602 #endif
2603
2604 Standard_Boolean Visual3d_View::ContainsFacet () const {
2605
2606         return ContainsFacet (MyDisplayedStructure);
2607
2608 }
2609
2610 Standard_Boolean Visual3d_View::ContainsFacet (const Graphic3d_MapOfStructure& ASet) const {
2611
2612 Standard_Boolean Result = Standard_False;
2613
2614         if (ASet.IsEmpty ()) return Result;
2615
2616 Graphic3d_MapIteratorOfMapOfStructure Iterator (ASet);
2617
2618         // On s'arrette a la premiere structure qui contient une facette
2619         for ( Iterator.Initialize (ASet);
2620               Iterator.More () && ! Result;
2621               Iterator.Next ())
2622                 Result  = (Iterator.Key ())->ContainsFacet ();
2623
2624         return Result;
2625
2626 }
2627
2628 void Visual3d_View::MinMaxValues (Standard_Real& XMin, Standard_Real& YMin, Standard_Real& ZMin, Standard_Real& XMax, Standard_Real& YMax, Standard_Real& ZMax) const {
2629
2630         MinMaxValues
2631         (MyDisplayedStructure, XMin, YMin, ZMin, XMax, YMax, ZMax);
2632
2633 }
2634
2635 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 {
2636
2637   if (ASet.IsEmpty ()) {
2638     XMin = RealFirst ();
2639     YMin = RealFirst ();
2640     ZMin = RealFirst ();
2641
2642     XMax = RealLast ();
2643     YMax = RealLast ();
2644     ZMax = RealLast ();
2645   }
2646   else {
2647
2648   Standard_Real Xm, Ym, Zm, XM, YM, ZM;
2649   Graphic3d_MapIteratorOfMapOfStructure Iterator (ASet);
2650
2651   XMin = RealLast ();
2652   YMin = RealLast ();
2653   ZMin = RealLast ();
2654
2655   XMax = RealFirst ();
2656   YMax = RealFirst ();
2657   ZMax = RealFirst ();
2658
2659   for ( Iterator.Initialize (ASet);
2660         Iterator.More ();
2661         Iterator.Next ()) {
2662
2663       if ( (Iterator.Key ())->IsInfinite ()){
2664         //XMin, YMin .... ZMax are initialized by means of infinite line data
2665         (Iterator.Key ())->MinMaxValues (Xm, Ym, Zm, XM, YM, ZM);
2666         if ( Xm != RealFirst() && Xm < XMin )
2667           XMin = Xm ;
2668         if ( Ym != RealFirst() && Ym < YMin )
2669           YMin = Ym ;
2670         if ( Zm != RealFirst() && Zm < ZMin )
2671           ZMin = Zm ;
2672         if ( XM != RealLast()  && XM > XMax )
2673           XMax = XM ;
2674         if ( YM != RealLast()  && YM > YMax )
2675           YMax = YM ;
2676         if ( ZM != RealLast()  && ZM > ZMax )
2677           ZMax = ZM ;
2678       }
2679       // Seules les structures non vides et non infinies
2680       // sont prises en compte pour le calcul des MinMax
2681       if (! (Iterator.Key ())->IsInfinite () &&
2682           ! (Iterator.Key ())->IsEmpty ()) {
2683             (Iterator.Key ())->MinMaxValues(Xm, Ym, Zm, XM, YM, ZM);
2684           /* ABD 29/10/04  Transform Persistence of Presentation( pan, zoom, rotate ) */
2685           //"FitAll" operation ignores object with transform persitence parameter
2686           if( (Iterator.Key ())->TransformPersistenceMode() == Graphic3d_TMF_None )
2687           {
2688             if (Xm < XMin) XMin = Xm;
2689             if (Ym < YMin) YMin = Ym;
2690             if (Zm < ZMin) ZMin = Zm;
2691             if (XM > XMax) XMax = XM;
2692             if (YM > YMax) YMax = YM;
2693             if (ZM > ZMax) ZMax = ZM;
2694           }
2695         }
2696     }
2697
2698     // Les cas suivants ne sont pas debiles
2699     // Par exemple si toutes les structures sont vides ou infinies
2700     if (XMax < XMin) { Xm = XMin; XMin = XMax; XMax = Xm; }
2701     if (YMax < YMin) { Ym = YMin; YMin = YMax; YMax = Ym; }
2702     if (ZMax < ZMin) { Zm = ZMin; ZMin = ZMax; ZMax = Zm; }
2703   }
2704   Standard_Real Sx, Sy, Sz;
2705   MyViewOrientation.AxialScale(Sx, Sy, Sz);
2706   XMin = (Sx > 1. && XMin < RealFirst ()/Sx)?RealFirst (): XMin*Sx;
2707   XMax = (Sx > 1. && XMax > RealLast  ()/Sx)?RealLast  (): XMax*Sx;
2708   YMin = (Sy > 1. && YMin < RealFirst ()/Sy)?RealFirst (): YMin*Sy;
2709   YMax = (Sy > 1. && YMax > RealLast  ()/Sy)?RealLast  (): YMax*Sy;
2710   ZMin = (Sz > 1. && ZMin < RealFirst ()/Sz)?RealFirst (): ZMin*Sz;
2711   ZMax = (Sz > 1. && ZMax > RealLast  ()/Sz)?RealLast  (): ZMax*Sz;
2712 }
2713
2714 void Visual3d_View::MinMaxValues (Standard_Real& XMin, Standard_Real& YMin, Standard_Real& XMax, Standard_Real& YMax) {
2715
2716         MinMaxValues (MyDisplayedStructure, XMin, YMin, XMax, YMax);
2717
2718 }
2719
2720 void Visual3d_View::MinMaxValues (const Graphic3d_MapOfStructure& ASet, Standard_Real& XMin, Standard_Real& YMin, Standard_Real& XMax, Standard_Real& YMax) {
2721
2722 Standard_Real Xm, Ym, Zm, XM, YM, ZM;
2723 Standard_Real Xp, Yp, Zp;
2724
2725         MinMaxValues (ASet, Xm, Ym, Zm, XM, YM, ZM);
2726
2727         Projects (Xm, Ym, Zm, Xp, Yp, Zp);
2728         XMin    = Xp;
2729         YMin    = Yp;
2730
2731         Projects (XM, YM, ZM, Xp, Yp, Zp);
2732         XMax    = Xp;
2733         YMax    = Yp;
2734
2735         if (XMax < XMin) { Xp = XMax; XMax = XMin; XMin = Xp; }
2736         if (YMax < YMin) { Yp = YMax; YMax = YMin; YMin = Yp; }
2737 }
2738
2739 const TColStd_Array2OfReal& Visual3d_View::MatrixOfOrientation () {
2740
2741         if (! MyMatOfOriIsEvaluated) {
2742                 MyGraphicDriver->InquireMat
2743                     (MyCView, MyMatrixOfOrientation, MyMatrixOfMapping);
2744                 MyMatOfMapIsEvaluated   = Standard_True;
2745                 MyMatOfOriIsEvaluated   = Standard_True;
2746         }
2747
2748         return (MyMatrixOfOrientation);
2749
2750 }
2751
2752 const TColStd_Array2OfReal& Visual3d_View::MatrixOfMapping () {
2753
2754         if (! MyMatOfMapIsEvaluated) {
2755                 MyGraphicDriver->InquireMat
2756                     (MyCView, MyMatrixOfOrientation, MyMatrixOfMapping);
2757                 MyMatOfMapIsEvaluated   = Standard_True;
2758                 MyMatOfOriIsEvaluated   = Standard_True;
2759         }
2760
2761         return (MyMatrixOfMapping);
2762
2763 }
2764
2765 Standard_Integer Visual3d_View::NumberOfDisplayedStructures () const {
2766
2767 Standard_Integer Result = MyDisplayedStructure.Extent ();
2768
2769         return (Result);
2770
2771 }
2772
2773 #ifdef OLD_METHOD
2774 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 {
2775
2776 math_Vector PtDC (0,3), PtWC (0,3);
2777
2778 // RLE method:
2779 // Sinon utiliser un new sur une Visual3d_View (constructeur+destructeur)
2780 // car Projects est une const methode or MatrixOfOrientation et
2781 // MatrixOfMapping ne le sont pas.
2782 Visual3d_View * const newthis = (Visual3d_View * const) this;
2783         newthis->MatrixOfOrientation ();
2784         newthis->MatrixOfMapping ();
2785
2786 // World Coordinate Space
2787         PtWC (0) = AX;
2788         PtWC (1) = AY;
2789         PtWC (2) = AZ;
2790         PtWC (3) = 1.0;
2791
2792         // WCS -> View Reference Coordinate Space
2793         math_Vector PtVRC(0,3);
2794         PtVRC = MyMatrixOfOrientation.Multiplied (PtWC);
2795
2796         // VRCS -> Normalized Projection Coordinate Space
2797         math_Vector PtNPC(0,3);
2798         PtNPC = MyMatrixOfMapping.Multiplied (PtVRC);
2799         for (Standard_Integer i=0; i<3; i++) PtNPC (i) = PtNPC (i) / PtNPC (3);
2800
2801 #ifdef DEBUG
2802         printf("Display coordinates PtNPC: %f,%f,%f,%f\n",
2803                         PtNPC(0),PtNPC(1),PtNPC(2),PtNPC(3));
2804 #endif // DEBUG
2805
2806         Standard_Real Ratio;
2807 #ifdef DEBUG
2808         // NPCS -> Device Coordinate Space
2809         Standard_Real Dx        = Standard_Real (MyCView.DefWindow.dx);
2810         Standard_Real Dy        = Standard_Real (MyCView.DefWindow.dy);
2811
2812         Ratio           = Dx / Dy;
2813         PtDC (0)        = PtNPC (0) * Dx;
2814         PtDC (1)        = Dy - PtNPC (1) * Dy * Ratio;
2815
2816         printf("Display coordinates : %f,%f,%f,%f\n",
2817                         PtDC(0),PtDC(1),PtDC(2),PtDC(3));
2818 #endif // DEBUG
2819
2820         // NPCS -> Window Space
2821 Standard_Real um, vm, uM, vM;
2822         MyViewMapping.WindowLimit (um, vm, uM, vM);
2823
2824         Ratio   = (uM - um) / (vM - vm);
2825         if (Ratio >= 1.0)
2826             PtNPC (1)   = PtNPC (1) * Ratio;
2827         else
2828             PtNPC (0)   = PtNPC (0) / Ratio;
2829
2830 #ifdef DEBUG
2831         printf("Display coordinates PtNPC: %f,%f,%f,%f\n",
2832                         PtNPC(0),PtNPC(1),PtNPC(2),PtNPC(3));
2833 #endif // DEBUG
2834
2835         Standard_Real fpd       = MyViewMapping.FrontPlaneDistance ();
2836         Standard_Real bpd       = MyViewMapping.BackPlaneDistance ();
2837
2838         /*
2839          * Les coordonnees de PtNPC sont decrites dans l'espace
2840          * [0-1]x[0-1]x[0-1].
2841          * Il faut transformer x et y dans le window space.
2842          * Il faut transformer z dans l'espace du back et front
2843          * plane, en pensant aux plans de clipping.
2844          * Ces plans de z clipping sont definis entre 0 et 1.
2845         */
2846
2847         APX     = PtNPC (0) * (uM - um) + um;
2848         APY     = PtNPC (1) * (vM - vm) + vm;
2849         APZ     = PtNPC (2) * (fpd - bpd) + bpd;
2850
2851 #ifdef DEBUG
2852         Standard_Integer l,c;
2853         printf("OrientationMatrix :");
2854         for( l=0 ; l<4 ; l++ ) {
2855           printf("\n    %d->",l);
2856           for( c=0 ; c<4 ; c++ ) {
2857             printf(" %f ,",MyMatrixOfOrientation(c,l));
2858           }
2859         }
2860         printf("\n\n");
2861         printf("MappingMatrix :");
2862         for( l=0 ; l<4 ; l++ ) {
2863           printf("\n    %d->",l);
2864           for( c=0 ; c<4 ; c++ ) {
2865             printf(" %f ,",MyMatrixOfMapping(c,l));
2866           }
2867         }
2868         printf("\n\n");
2869         printf("World coordinates : %f,%f,%f,%f\n",
2870                         PtWC(0),PtWC(1),PtWC(2),PtWC(3));
2871         printf("View coordinates : %f,%f,%f,%f\n",
2872                         PtVRC(0),PtVRC(1),PtVRC(2),PtVRC(3));
2873         printf("Display coordinates : %f,%f,%f,%f\n",
2874                         PtNPC(0),PtNPC(1),PtNPC(2),PtNPC(3));
2875         printf("Window limit : %f,%f,%f,%f\n",um,vm,uM,vM);
2876         printf("Ratio : %f\n",Ratio);
2877         printf("Front-plane : %f back-plane : %f\n",fpd,bpd);
2878         printf("Projection : %f,%f,%f\n \n",APX,APY,APZ);
2879 #endif
2880
2881 }
2882 #endif /* OLD_METHOD */
2883
2884 // OCC18942: This method is likely to duplicate Visual3d_ViewManager::ConvertCoord() one,
2885 // therefore it is necessary to consider merging the two methods or making them call the same
2886 // graphic driver's method after OCCT 6.3.
2887 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) {
2888
2889 Standard_Real PtX, PtY, PtZ, PtT;
2890 Standard_Real APT;
2891 static Standard_Real Ratio, um, vm, uM, vM;
2892 static Standard_Real fpd, bpd;
2893
2894         if (! MyMatOfOriIsEvaluated || ! MyMatOfMapIsEvaluated) {
2895                 MyGraphicDriver->InquireMat
2896                     (MyCView, MyMatrixOfOrientation, MyMatrixOfMapping);
2897                 MyMatOfOriIsEvaluated = MyMatOfMapIsEvaluated = Standard_True;
2898         }
2899
2900         // WCS -> View Reference Coordinate Space
2901         PtX     = MyMatrixOfOrientation (0, 0) * AX
2902                 + MyMatrixOfOrientation (0, 1) * AY
2903                 + MyMatrixOfOrientation (0, 2) * AZ
2904                 + MyMatrixOfOrientation (0, 3);
2905         PtY     = MyMatrixOfOrientation (1, 0) * AX
2906                 + MyMatrixOfOrientation (1, 1) * AY
2907                 + MyMatrixOfOrientation (1, 2) * AZ
2908                 + MyMatrixOfOrientation (1, 3);
2909         PtZ     = MyMatrixOfOrientation (2, 0) * AX
2910                 + MyMatrixOfOrientation (2, 1) * AY
2911                 + MyMatrixOfOrientation (2, 2) * AZ
2912                 + MyMatrixOfOrientation (2, 3);
2913         PtT     = MyMatrixOfOrientation (3, 0) * AX
2914                 + MyMatrixOfOrientation (3, 1) * AY
2915                 + MyMatrixOfOrientation (3, 2) * AZ
2916                 + MyMatrixOfOrientation (3, 3);
2917
2918         // VRCS -> Normalized Projection Coordinate Space
2919         APX     = MyMatrixOfMapping (0, 0) * PtX
2920                 + MyMatrixOfMapping (0, 1) * PtY
2921                 + MyMatrixOfMapping (0, 2) * PtZ
2922                 + MyMatrixOfMapping (0, 3) * PtT;
2923         APY     = MyMatrixOfMapping (1, 0) * PtX
2924                 + MyMatrixOfMapping (1, 1) * PtY
2925                 + MyMatrixOfMapping (1, 2) * PtZ
2926                 + MyMatrixOfMapping (1, 3) * PtT;
2927         APZ     = MyMatrixOfMapping (2, 0) * PtX
2928                 + MyMatrixOfMapping (2, 1) * PtY
2929                 + MyMatrixOfMapping (2, 2) * PtZ
2930                 + MyMatrixOfMapping (2, 3) * PtT;
2931         APT     = MyMatrixOfMapping (3, 0) * PtX
2932                 + MyMatrixOfMapping (3, 1) * PtY
2933                 + MyMatrixOfMapping (3, 2) * PtZ
2934                 + MyMatrixOfMapping (3, 3) * PtT;
2935
2936         APX /= APT;
2937         APY /= APT;
2938         APZ /= APT;
2939
2940         // NPCS -> Window Space
2941         MyViewMapping.WindowLimit (um, vm, uM, vM);
2942         fpd     = MyViewMapping.FrontPlaneDistance ();
2943         bpd     = MyViewMapping.BackPlaneDistance ();
2944
2945         if(MyCView.Mapping.IsCustomMatrix) {
2946                 // OCC18942: SAN - If orientation and mapping matrices are those used by OpenGL
2947                 // visualization, then X, Y and Z coordinates normally vary between -1 and 1
2948                 APX     = ( APX + 1 ) * 0.5 * (uM - um) + um;
2949                 APY     = ( APY + 1 ) * 0.5 * (vM - vm) + vm;
2950         } else {
2951                 Ratio   = (uM - um) / (vM - vm);
2952                 if (Ratio >= 1.0)
2953                         APY *= Ratio;
2954                 else
2955                         APX /= Ratio;
2956
2957                 /*
2958                 * Les coordonnees de APX, APY, APZ sont decrites dans
2959                 * l'espace [0-1]x[0-1]x[0-1].
2960                 * Il faut transformer x et y dans le window space.
2961                 * Il faut transformer z dans l'espace du back et front
2962                 * plane, en pensant aux plans de clipping.
2963                 * Ces plans de z clipping sont definis entre 0 et 1.
2964                 */
2965             APX     = APX * (uM - um) + um;
2966             APY     = APY * (vM - vm) + vm;
2967         }
2968         APZ     = APZ * (fpd - bpd) + bpd;
2969 }
2970
2971 Standard_Integer Visual3d_View::Identification () const {
2972
2973         return (Standard_Integer (MyCView.ViewId));
2974
2975 }
2976
2977 void Visual3d_View::Exploration () const {
2978
2979         if (IsDeleted ()) return;
2980
2981         MyGraphicDriver->DumpView (MyCView);
2982
2983 }
2984
2985 Standard_Boolean Visual3d_View::ZBufferIsActivated () const {
2986
2987         if (IsDeleted ()) return (Standard_False);
2988
2989         if ((! IsDefined ()) || (! IsActive ())) return (Standard_False);
2990
2991 // -1 => non force par le programmeur => depend du type de visualisation
2992 //  0 ou 1 => force par le programmeur
2993
2994         if (MyCView.Context.ZBufferActivity == -1)
2995                 if (MyContext.Visualization () == Visual3d_TOV_SHADING)
2996                         return (Standard_True);
2997                 else
2998                         return (Standard_False);
2999         else
3000                 if (MyCView.Context.ZBufferActivity)
3001                         return (Standard_True);
3002                 else
3003                         return (Standard_False);
3004
3005 }
3006
3007 void Visual3d_View::SetTransparency (const Standard_Boolean AnActivity) {
3008
3009         if (IsDeleted ()) return;
3010
3011         if ((! IsDefined ()) || (! IsActive ())) return;
3012
3013         MyGraphicDriver->Transparency (MyCView, AnActivity);
3014
3015 }
3016
3017 void Visual3d_View::SetZBufferActivity (const Standard_Integer AnActivity) {
3018
3019         if (MyCView.Context.ZBufferActivity == AnActivity) return;
3020
3021         if (IsDeleted ()) return;
3022
3023         if ((! IsDefined ()) || (! IsActive ())) return;
3024
3025         MyCView.Context.ZBufferActivity = AnActivity;
3026         MyGraphicDriver->SetVisualisation (MyCView);
3027
3028 }
3029
3030 void Visual3d_View::UpdateView () {
3031
3032         MyCView.Context.Aliasing        = (MyContext.AliasingIsOn () ? 1:0);
3033         MyCView.Context.BackZClipping   =
3034                 (MyContext.BackZClippingIsOn () ? 1:0);
3035         MyCView.Context.FrontZClipping  =
3036                 (MyContext.FrontZClippingIsOn() ? 1:0);
3037         MyCView.Context.DepthCueing     =
3038                 (MyContext.DepthCueingIsOn () ? 1:0);
3039
3040         MyCView.Context.ZClipFrontPlane =
3041                                 float (MyContext.ZClippingFrontPlane ());
3042         MyCView.Context.ZClipBackPlane          =
3043                                 float (MyContext.ZClippingBackPlane ());
3044         MyCView.Context.DepthFrontPlane =
3045                                 float (MyContext.DepthCueingFrontPlane ());
3046         MyCView.Context.DepthBackPlane          =
3047                                 float (MyContext.DepthCueingBackPlane ());
3048
3049         MyCView.Context.Model           = int (MyContext.Model ());
3050         MyCView.Context.Visualization   = int (MyContext.Visualization ());
3051
3052         Handle(Graphic3d_TextureEnv)   TempTextureEnv = MyContext.TextureEnv();
3053         if (! TempTextureEnv.IsNull()) MyCView.Context.TexEnvId = TempTextureEnv->TextureId();
3054         else                           MyCView.Context.TexEnvId = -1;
3055         MyCView.Context.SurfaceDetail = MyContext.SurfaceDetail();
3056
3057 }
3058
3059 void Visual3d_View::Compute () {
3060
3061 Standard_Integer i;
3062 Standard_Integer Length = MyCOMPUTEDSequence.Length ();
3063         for (i=1; i<=Length; i++)
3064             (MyCOMPUTEDSequence.Value (i))->SetHLRValidation (Standard_False);
3065
3066         // Si le mode degenere est actif, on ne recalcule rien
3067 #ifdef G003
3068         if (  DegenerateModeIsOn () || !ComputedMode ()  ) return;
3069 #else
3070         if (DegenerateModeIsOn ()) return;
3071 #endif  // G003
3072
3073         /*
3074          * Forcer le HLRValidation a False sur toutes les structures
3075          * calculees dans la vue.
3076          */
3077 #ifdef TRACE_LENGTH
3078         if (MyTOCOMPUTESequence.Length () != MyCOMPUTEDSequence.Length ()) {
3079                 cout << "In Visual3d_View::Compute, ";
3080                 cout << "TOCOMPUTE " << MyTOCOMPUTESequence.Length ()
3081                      << " != COMPUTED " << MyCOMPUTEDSequence.Length ()
3082                      << "\n" << flush;
3083         }
3084 #endif
3085
3086         /*
3087          * Changement d'orientation ou de type de projection =>
3088          * Erase des structures qui ont ete calculees pour
3089          * l'orientation precedente.
3090          * Recalcul des nouvelles structures.
3091          * Passage du mode degenere ON a OFF =>
3092          * Erase des structures qui ont ete calculees avant que
3093          * le mode degenere passe a ON.
3094          * Recalcul des nouvelles structures.
3095          */
3096 Graphic3d_MapIteratorOfMapOfStructure S1Iterator (MyDisplayedStructure);
3097 Visual3d_TypeOfAnswer Answer;
3098
3099         i       = MyDisplayedStructure.Extent ();
3100
3101 Graphic3d_SequenceOfStructure FooSequence;
3102
3103         while (S1Iterator.More ()) {
3104                 Answer  = AcceptDisplay (S1Iterator.Key ());
3105                 // Si la structure etait calculee, on la recalcule.
3106                 if (Answer == Visual3d_TOA_COMPUTE) {
3107 #ifdef TRACE
3108                         cout << "AcceptDisplay ("
3109                              << (S1Iterator.Key ())->Identification ()
3110                              << ") == Visual3d_TOA_COMPUTE;\n";
3111                         cout << flush;
3112 #endif
3113                         //Display (S1Iterator.Key (), Aspect_TOU_WAIT);
3114                         FooSequence.Append (S1Iterator.Key ());
3115                 }
3116
3117                 // S1Iterator.Next () se positionne sur la
3118                 // prochaine structure
3119                 S1Iterator.Next ();
3120         }
3121
3122         Length  = FooSequence.Length ();
3123         // On affiche les structures stockees
3124         for (i=1; i<=Length; i++)
3125                 Display (FooSequence.Value (i), Aspect_TOU_WAIT);
3126         if (Length != 0) FooSequence.Clear ();
3127
3128 }
3129
3130 void Visual3d_View::ReCompute (const Handle(Graphic3d_Structure)& AStructure) {
3131 #ifdef G003
3132         if ( DegenerateModeIsOn () || !ComputedMode () ) return;
3133 #else
3134         if (DegenerateModeIsOn()) return;
3135 #endif  // G003
3136
3137         if (IsDeleted ()) return;
3138
3139         if ((! IsDefined ()) || (! IsActive ())) return;
3140
3141         if (! MyWindow->IsMapped ()) return;
3142
3143         if (! AStructure->IsDisplayed ()) return;
3144
3145 Visual3d_TypeOfAnswer Answer;
3146
3147         Answer  = AcceptDisplay (AStructure);
3148
3149         if (Answer == Visual3d_TOA_COMPUTE) {
3150 Standard_Integer Index = IsComputed (AStructure);
3151                 if (Index == 0) {
3152 #ifdef TRACE_COMP
3153         cout << "La structure " << AStructure->Identification ()
3154              << " n'est pas calculee dans la view "
3155              << Identification () << "\n";
3156         cout << flush;
3157 #endif
3158                 }
3159                 else {
3160                   Standard_Integer OldStructId, NewStructId;
3161                         OldStructId =
3162                         MyCOMPUTEDSequence.Value (Index)->Identification ();
3163 #ifdef TRACE_COMP
3164         Standard_Integer StructId = AStructure->Identification ();
3165         cout << "La structure " << StructId
3166              << " calculee, dans la view "
3167              << Identification () << ", par la structure "
3168              << OldStructId << " est recalculee.\n";
3169         cout << flush;
3170 #endif
3171
3172         // Compute + Validation
3173 #ifdef OLD
3174 Handle(Graphic3d_Structure) TheStructure = AStructure->Compute (this);
3175 #else
3176 Handle(Graphic3d_Structure) TheStructure;
3177 TColStd_Array2OfReal ATrsf (0, 3, 0, 3);
3178         AStructure->Transform (ATrsf);
3179         if (Index != 0) {
3180 TColStd_Array2OfReal Ident (0, 3, 0, 3);
3181 Standard_Integer ii, jj;
3182         for (ii=0; ii<=3; ii++)
3183             for (jj=0; jj<=3; jj++)
3184                 Ident (ii, jj) = (ii == jj ? 1.0 : 0.0);
3185             TheStructure = MyCOMPUTEDSequence.Value (Index);
3186             TheStructure->SetTransform (Ident, Graphic3d_TOC_REPLACE);
3187             if (AStructure->IsTransformed ()) {
3188                 AStructure->Compute (this, ATrsf, TheStructure);
3189             }
3190             else {
3191                 AStructure->Compute (this, TheStructure);
3192             }
3193         }
3194         else {
3195             if (AStructure->IsTransformed ()) {
3196                 TheStructure = AStructure->Compute (this, ATrsf);
3197             }
3198             else {
3199                 TheStructure = AStructure->Compute (this);
3200             }
3201         }
3202 #endif
3203         TheStructure->SetHLRValidation (Standard_True);
3204
3205 // Recuperation type de visualisation de la vue
3206 Visual3d_TypeOfVisualization ViewType = MyContext.Visualization ();
3207
3208 // De quel type sera la computed ?
3209 Standard_Boolean ComputeWireframe = ((ViewType == Visual3d_TOV_WIREFRAME) &&
3210         (AStructure->ComputeVisual () != Graphic3d_TOS_SHADING));
3211
3212 Standard_Boolean ComputeShading = ((ViewType == Visual3d_TOV_SHADING) &&
3213         (AStructure->ComputeVisual () != Graphic3d_TOS_WIREFRAME));
3214
3215                         if (ComputeWireframe)
3216                             TheStructure->SetVisual (Graphic3d_TOS_WIREFRAME);
3217                         if (ComputeShading)
3218                             TheStructure->SetVisual (Graphic3d_TOS_SHADING);
3219
3220                         if (AStructure->IsHighlighted ()) {
3221                             TheStructure->SetHighlightColor
3222                                 (AStructure->HighlightColor ());
3223                             TheStructure->GraphicHighlight (Aspect_TOHM_COLOR);
3224                         }
3225
3226                         // On la range
3227                         // Recherche de la structure <AStructure>
3228                         // dans la sequence des structures a calculer
3229                         NewStructId = TheStructure->Identification ();
3230
3231                         // On efface l'ancienne calculee et on affiche la nouvelle
3232                         MyGraphicDriver->EraseStructure (
3233                                 MyCView,
3234                                 *(Graphic3d_CStructure *)MyCOMPUTEDSequence.Value (Index)->CStructure ());
3235                         MyGraphicDriver->DisplayStructure (
3236                                 MyCView,
3237                                 *(Graphic3d_CStructure *)TheStructure->CStructure (),
3238                                 int (AStructure->DisplayPriority ())
3239                         );
3240
3241 #ifdef TRACE_LENGTH
3242         if (MyTOCOMPUTESequence.Length () != MyCOMPUTEDSequence.Length ()) {
3243                 cout << "In Visual3d_View::ReCompute, ";
3244                 cout << "TOCOMPUTE " << MyTOCOMPUTESequence.Length ()
3245                      << " != COMPUTED " << MyCOMPUTEDSequence.Length ()
3246                      << "\n" << flush;
3247         }
3248 #endif
3249
3250                           // On ajoute la hlhsr et
3251                           // la nouvelle compute associee
3252                           MyTOCOMPUTESequence.Append (AStructure);
3253                           MyCOMPUTEDSequence.Append (TheStructure);
3254
3255 #ifdef TRACE_LENGTH
3256         if (MyTOCOMPUTESequence.Length () != MyCOMPUTEDSequence.Length ())
3257                 cout << "\tTOCOMPUTE " << MyTOCOMPUTESequence.Length ()
3258                      << " != COMPUTED " << MyCOMPUTEDSequence.Length ()
3259                      << "\n" << flush;
3260 #endif
3261
3262                           // On enleve la hlhsr et
3263                           // l'ancienne compute associee
3264
3265                           MyTOCOMPUTESequence.Remove (Index);
3266                           MyCOMPUTEDSequence.Remove (Index);
3267
3268 #ifdef TRACE_LENGTH
3269         if (MyTOCOMPUTESequence.Length () != MyCOMPUTEDSequence.Length ())
3270                 cout << "\tTOCOMPUTE " << MyTOCOMPUTESequence.Length ()
3271                      << " != COMPUTED " << MyCOMPUTEDSequence.Length ()
3272                      << "\n" << flush;
3273 #endif
3274                 }
3275         }
3276
3277 }
3278
3279 void
3280 #ifdef G003
3281 Visual3d_View::SetAnimationModeOn ( const Standard_Boolean degenerate ) {
3282 #else
3283 Visual3d_View::SetAnimationModeOn () {
3284 #endif
3285
3286         if (AnimationModeIsOn ()) return;
3287
3288         AnimationModeIsActive   = Standard_True;
3289 #ifdef G003
3290         if ( degenerate )
3291           SetDegenerateModeOn ();
3292         else
3293           SetDegenerateModeOff ();
3294 #endif  // G003
3295         MyGraphicDriver->BeginAnimation (MyCView);
3296
3297 }
3298
3299 void Visual3d_View::SetAnimationModeOff () {
3300
3301         if (! AnimationModeIsOn ()) return;
3302
3303         AnimationModeIsActive   = Standard_False;
3304 #ifdef G003
3305         SetDegenerateModeOff ();
3306 #endif  // G003
3307         MyGraphicDriver->EndAnimation (MyCView);
3308
3309 }
3310
3311 Standard_Boolean Visual3d_View::AnimationModeIsOn () const {
3312
3313         return AnimationModeIsActive;
3314
3315 }
3316
3317 void Visual3d_View::SetDegenerateModeOn () {
3318
3319 #ifdef TRACE
3320         cout << "Visual3d_View" << MyCView.ViewId
3321              << "::SetDegenerateModeOn ();\n";
3322         cout << flush;
3323 #endif
3324
3325         // Si le mode degenere est deja actif, on ne recalcule rien
3326         if (DegenerateModeIsOn ()) return;
3327         DegenerateModeIsActive = Standard_True;
3328
3329 #ifdef G003
3330         MyCView.IsDegenerates  = 1;
3331 #else
3332         /*
3333          * Changement d'activite du mode degenere
3334          * Erase des structures qui ont ete calculees
3335          * et affichees quand le mode etait off.
3336          * Affichage des structures non calculees.
3337          */
3338 Graphic3d_MapIteratorOfMapOfStructure S1Iterator (MyDisplayedStructure);
3339 Visual3d_TypeOfAnswer Answer;
3340 Standard_Integer StructId;
3341
3342         while (S1Iterator.More ()) {
3343
3344                 Answer  = AcceptDisplay (S1Iterator.Key ());
3345                 // Si la structure etait a calculer, on efface la
3346                 // structure calculee et l'on l'affiche
3347                 // (C'est le role du passage en mode degenere)
3348
3349                 if (Answer == Visual3d_TOA_COMPUTE) {
3350 Standard_Integer Index = IsComputed (S1Iterator.Key ());
3351                     if (Index != 0) {
3352                         StructId =
3353                         MyCOMPUTEDSequence.Value (Index)->Identification ();
3354 #ifdef TRACE_COMP
3355         cout << "La structure " << S1Iterator.Key ()->Identification ()
3356              << " calculee, dans la view "
3357              << Identification () << ", par la structure "
3358              << StructId << " passe en mode degenere.\n";
3359         cout << "On efface " << StructId << " puis on affiche "
3360              << S1Iterator.Key ()->Identification () << "\n";
3361         cout << flush;
3362 #endif
3363                         MyGraphicDriver->EraseStructure
3364                                 (MyCView, *(Graphic3d_CStructure *)MyCOMPUTEDSequence.Value (Index)->CStructure ());
3365                         MyGraphicDriver->DisplayStructure (
3366                                 MyCView,
3367                                 *(Graphic3d_CStructure *)S1Iterator.Key ()->CStructure (),
3368                                 int (S1Iterator.Key ()->DisplayPriority ())
3369                         );
3370                     }
3371                     else {
3372                         // Le else est impossible (OUI !)
3373                         // Si le mode etait non degenere avant alors la
3374                         // structure calculee associee a S1Iterator.Key ()
3375                         // existe vraiment et donc Index != 0
3376                     }
3377                 }
3378
3379                 // S1Iterator.Next () se positionne sur la
3380                 // prochaine structure
3381                 S1Iterator.Next ();
3382         }
3383 #endif  //G003
3384 }
3385
3386 void Visual3d_View::SetDegenerateModeOff () {
3387
3388 #ifdef TRACE
3389         cout << "Visual3d_View" << MyCView.ViewId
3390              << "::SetDegenerateModeOff ();\n";
3391         cout << flush;
3392 #endif
3393
3394         // Si le mode degenere est deja inactif, on ne recalcule rien
3395         if (! DegenerateModeIsOn ()) return;
3396
3397         DegenerateModeIsActive  = Standard_False;
3398
3399 #ifdef G003
3400         MyCView.IsDegenerates  = 0;
3401 #else
3402         /*
3403          * Changement d'activite du mode degenere
3404          * Erase des structures qui ont ete affichees
3405          * quand le mode etait on.
3406          * Calcul des structures.
3407          */
3408 Graphic3d_MapIteratorOfMapOfStructure S1Iterator (MyDisplayedStructure);
3409 Visual3d_TypeOfAnswer Answer;
3410 Standard_Integer StructId;
3411
3412         Standard_Integer i      = MyDisplayedStructure.Extent ();
3413
3414         while (S1Iterator.More ()) {
3415
3416                 Answer  = AcceptDisplay (S1Iterator.Key ());
3417                 // Si la structure etait a calculer, on l'efface
3418                 // et on affiche la structure calculee
3419                 // (C'est le role du passage en mode non degenere)
3420
3421                 if (Answer == Visual3d_TOA_COMPUTE) {
3422 Standard_Integer Index = IsComputed (S1Iterator.Key ());
3423                     if (Index != 0) {
3424                         StructId =
3425                         MyCOMPUTEDSequence.Value (Index)->Identification ();
3426 #ifdef TRACE_COMP
3427         cout << "La structure " << S1Iterator.Key ()->Identification ()
3428              << " calculee, dans la view "
3429              << Identification () << ", par la structure "
3430              << StructId << " passe en mode normal.\n";
3431         cout << "On efface " << S1Iterator.Key ()->Identification ()
3432              << " puis on affiche " << StructId << "\n";
3433         cout << flush;
3434 #endif
3435                         MyGraphicDriver->EraseStructure
3436                                 (MyCView,
3437                                 *(Graphic3d_CStructure *)S1Iterator.Key ()->CStructure ());
3438                         MyGraphicDriver->DisplayStructure (
3439                                 MyCView,
3440                                 *(Graphic3d_CStructure *)MyCOMPUTEDSequence.Value (Index)->CStructure (),
3441                                 int (S1Iterator.Key ()->DisplayPriority ())
3442                         );
3443
3444                         Display (S1Iterator.Key (), Aspect_TOU_WAIT);
3445
3446                         if ((S1Iterator.Key ())->IsHighlighted()) {
3447                            if (! (MyCOMPUTEDSequence.Value (Index))->IsHighlighted()) {
3448                                 (MyCOMPUTEDSequence.Value (Index))->SetHighlightColor
3449                                         ((S1Iterator.Key ())->HighlightColor ());
3450                                 (MyCOMPUTEDSequence.Value (Index))->GraphicHighlight (Aspect_TOHM_COLOR);
3451                             }
3452                         }
3453                     }
3454                     else {
3455                         // Le else est impossible (NON !)
3456                         // Le mode degenere a ete active avant l'affichage
3457                         // de la structure. La structure a donc ete ensuite
3458                         // affichee dans le mode degenere et donc sans que la
3459                         // structure calculee existe.
3460                         // On la calcule
3461
3462         // Compute + Validation
3463 Handle(Graphic3d_Structure) AStructure = (S1Iterator.Key ());
3464 #ifdef OLD
3465 Handle(Graphic3d_Structure) TheStructure = AStructure->Compute (this);
3466 #else
3467 Handle(Graphic3d_Structure) TheStructure;
3468 TColStd_Array2OfReal ATrsf (0, 3, 0, 3);
3469         AStructure->Transform (ATrsf);
3470         if (Index != 0) {
3471 TColStd_Array2OfReal Ident (0, 3, 0, 3);
3472 Standard_Integer ii, jj;
3473         for (ii=0; ii<=3; ii++)
3474             for (jj=0; jj<=3; jj++)
3475                 Ident (ii, jj) = (ii == jj ? 1.0 : 0.0);
3476             TheStructure = MyCOMPUTEDSequence.Value (Index);
3477             TheStructure->SetTransform (Ident, Graphic3d_TOC_REPLACE);
3478             if (AStructure->IsTransformed ()) {
3479                 AStructure->Compute (this, ATrsf, TheStructure);
3480             }
3481             else {
3482                 AStructure->Compute (this, TheStructure);
3483             }
3484         }
3485         else {
3486             if (AStructure->IsTransformed ()) {
3487                 TheStructure = AStructure->Compute (this, ATrsf);
3488             }
3489             else {
3490                 TheStructure = AStructure->Compute (this);
3491             }
3492         }
3493 #endif
3494         TheStructure->SetHLRValidation (Standard_True);
3495
3496 // Recuperation type de visualisation de la vue
3497 Visual3d_TypeOfVisualization ViewType = MyContext.Visualization ();
3498
3499 // De quel type sera la computed ?
3500 Standard_Boolean ComputeWireframe = ((ViewType == Visual3d_TOV_WIREFRAME) &&
3501         ((S1Iterator.Key ())->ComputeVisual () != Graphic3d_TOS_SHADING));
3502
3503 Standard_Boolean ComputeShading = ((ViewType == Visual3d_TOV_SHADING) &&
3504         ((S1Iterator.Key ())->ComputeVisual () != Graphic3d_TOS_WIREFRAME));
3505
3506                         if (ComputeWireframe)
3507                             TheStructure->SetVisual (Graphic3d_TOS_WIREFRAME);
3508                         if (ComputeShading)
3509                             TheStructure->SetVisual (Graphic3d_TOS_SHADING);
3510
3511                         if ((S1Iterator.Key ())->IsHighlighted()) {
3512                             TheStructure->SetHighlightColor
3513                                 ((S1Iterator.Key ())->HighlightColor ());
3514                             TheStructure->GraphicHighlight (Aspect_TOHM_COLOR);
3515                         }
3516
3517                         // On la range
3518 Standard_Integer Result = 0;
3519 Standard_Integer Length = MyTOCOMPUTESequence.Length ();
3520                         // Recherche de la structure <S1Iterator.Key ()>
3521                         // dans la sequence des structures a calculer
3522                         StructId = (S1Iterator.Key ())->Identification ();
3523                         for (i=1; i<=Length && Result==0; i++)
3524                           if ((MyTOCOMPUTESequence.Value (i))->Identification () ==
3525                             StructId) Result    = i;
3526                         if (Result != 0)
3527                           MyCOMPUTEDSequence.ChangeValue (Result) = TheStructure;
3528                         else {
3529                           // On ajoute la hlhsr et la nouvelle compute associee
3530 #ifdef TRACE_LENGTH
3531         if (MyTOCOMPUTESequence.Length () != MyCOMPUTEDSequence.Length ()) {
3532                 cout << "In Visual3d_View::SetDegenerateModeOff, ";
3533                 cout << "TOCOMPUTE " << MyTOCOMPUTESequence.Length ()
3534                      << " != COMPUTED " << MyCOMPUTEDSequence.Length ()
3535                      << "\n" << flush;
3536         }
3537 #endif
3538                           MyTOCOMPUTESequence.Append (S1Iterator.Key ());
3539                           MyCOMPUTEDSequence.Append (TheStructure);
3540 #ifdef TRACE_LENGTH
3541         if (MyTOCOMPUTESequence.Length () != MyCOMPUTEDSequence.Length ())
3542                 cout << "\tTOCOMPUTE " << MyTOCOMPUTESequence.Length ()
3543                      << " != COMPUTED " << MyCOMPUTEDSequence.Length ()
3544                      << "\n" << flush;
3545 #endif
3546                         }
3547
3548                         // On efface la degeneree et on affiche la calculee
3549                         MyGraphicDriver->EraseStructure
3550                                 (MyCView,
3551                                 *(Graphic3d_CStructure *)(S1Iterator.Key ()->CStructure ()));
3552                         MyGraphicDriver->DisplayStructure (
3553                                 MyCView,
3554                                 *(Graphic3d_CStructure *)TheStructure->CStructure (),
3555                                 int (S1Iterator.Key ()->DisplayPriority ())
3556                         );
3557                     }
3558                 }
3559
3560                 // S1Iterator.Next () se positionne sur la
3561                 // prochaine structure
3562                 S1Iterator.Next ();
3563         }
3564
3565         if (MyViewManager->UpdateMode () == Aspect_TOU_ASAP) Update ();
3566 #endif  //G003
3567 }
3568
3569 Standard_Boolean Visual3d_View::DegenerateModeIsOn () const {
3570
3571         return DegenerateModeIsActive;
3572
3573 }
3574
3575 Handle(Aspect_GraphicDriver) Visual3d_View::GraphicDriver () const {
3576
3577         return MyGraphicDriver;
3578
3579 }
3580
3581 void Visual3d_View::Plot (const Handle(Graphic3d_Plotter)& APlotter) const {
3582
3583 Graphic3d_MapIteratorOfMapOfStructure S1Iterator (MyDisplayedStructure);
3584
3585         while (S1Iterator.More ()) {
3586
3587                 if (DegenerateModeIsOn ())
3588                         // Le mode etant degenere on plotte la structure
3589                         // affichee sans s'occuper si elle est calculee
3590                         (S1Iterator.Key ())->Plot (APlotter);
3591                 else {
3592 Standard_Integer Index = IsComputed (S1Iterator.Key ());
3593                         // Le mode n'etant pas degenere on plotte la structure
3594                         // affichee si elle n'est pas calculee sinon
3595                         // on plotte la structure calculee associee
3596                         if (Index == 0)
3597                             (S1Iterator.Key ())->Plot (APlotter);
3598                         else
3599                             (MyCOMPUTEDSequence.Value (Index))->Plot (APlotter);
3600                 }
3601
3602                 // S1Iterator.Next () se positionne sur la
3603                 // prochaine structure
3604                 S1Iterator.Next ();
3605         }
3606
3607 }
3608
3609 Standard_Integer Visual3d_View::HaveTheSameOwner (const Handle(Graphic3d_Structure)& AStructure) const {
3610
3611 Standard_Integer Result = 0;
3612 Standard_Integer Length = MyTOCOMPUTESequence.Length ();
3613
3614         // Recherche dans la sequence des structures deja calculees
3615         // 1/ D'une structure ayant le meme Owner que <AStructure>
3616         // 2/ Qui ne soit pas <AStructure>
3617         // 3/ Dont la COMPUTED soit valide
3618         for (Standard_Integer i=1; i<=Length && Result==0; i++)
3619            if ((MyTOCOMPUTESequence.Value (i)->Owner () == AStructure->Owner ())
3620             && (MyTOCOMPUTESequence.Value (i)->Identification () !=
3621                                                 AStructure->Identification ())
3622             && (MyCOMPUTEDSequence.Value (i)->HLRValidation ())) Result   = i;
3623
3624         return (Result);
3625
3626 }
3627
3628 Standard_Address Visual3d_View::CView () const {
3629
3630         return Standard_Address (&MyCView);
3631
3632 }
3633
3634
3635 // Triedron methods : the Triedron is a non-zoomable object.
3636
3637 void Visual3d_View::ZBufferTriedronSetup(const Quantity_NameOfColor XColor,
3638                                     const Quantity_NameOfColor YColor,
3639                                     const Quantity_NameOfColor ZColor,
3640                                     const Standard_Real        SizeRatio,
3641                                     const Standard_Real        AxisDiametr,
3642                                     const Standard_Integer     NbFacettes) {
3643   MyGraphicDriver->ZBufferTriedronSetup(XColor, YColor, ZColor,
3644                                         SizeRatio, AxisDiametr, NbFacettes);
3645 }
3646
3647
3648
3649 void Visual3d_View::TriedronDisplay (const Aspect_TypeOfTriedronPosition APosition,
3650  const Quantity_NameOfColor AColor, const Standard_Real AScale, const Standard_Boolean AsWireframe ) {
3651
3652         MyGraphicDriver->TriedronDisplay (MyCView,APosition, AColor, AScale, AsWireframe);
3653
3654 }
3655
3656 void Visual3d_View::TriedronErase () {
3657
3658         MyGraphicDriver->TriedronErase (MyCView);
3659
3660
3661 }
3662
3663 void Visual3d_View::TriedronEcho (const Aspect_TypeOfTriedronEcho AType ) {
3664
3665         MyGraphicDriver->TriedronEcho (MyCView,AType);
3666
3667 }
3668
3669 Standard_Boolean checkFloat(const Standard_Real value)
3670 {
3671     return value > -FLT_MAX && value < FLT_MAX;
3672 }
3673
3674 void SetMinMaxValuesCallback(void* Visual3dView)
3675 {
3676     Standard_Real xmin, ymin, zmin, xmax, ymax, zmax;
3677
3678     Handle(Visual3d_View) view = (Handle(Visual3d_View)&) Visual3dView;
3679     view->MinMaxValues(xmin, ymin, zmin, xmax, ymax, zmax);
3680
3681     if (checkFloat(xmin) && checkFloat(ymin) && checkFloat(zmin) &&
3682         checkFloat(xmax) && checkFloat(ymax) && checkFloat(zmax))
3683     {
3684         Handle(Graphic3d_GraphicDriver) driver = Handle(Graphic3d_GraphicDriver)::DownCast(view->GraphicDriver());
3685         driver->GraduatedTrihedronMinMaxValues((Standard_ShortReal)xmin, (Standard_ShortReal)ymin, (Standard_ShortReal)zmin,
3686                                                (Standard_ShortReal)xmax, (Standard_ShortReal)ymax, (Standard_ShortReal)zmax);
3687     }
3688 }
3689
3690 void Visual3d_View::GetGraduatedTrihedron(/* Names of axes */
3691                                           Standard_CString& xname,
3692                                           Standard_CString& yname,
3693                                           Standard_CString& zname,
3694                                           /* Draw names */
3695                                           Standard_Boolean& xdrawname,
3696                                           Standard_Boolean& ydrawname,
3697                                           Standard_Boolean& zdrawname,
3698                                           /* Draw values */
3699                                           Standard_Boolean& xdrawvalues,
3700                                           Standard_Boolean& ydrawvalues,
3701                                           Standard_Boolean& zdrawvalues,
3702                                           /* Draw grid */
3703                                           Standard_Boolean& drawgrid,
3704                                           /* Draw axes */
3705                                           Standard_Boolean& drawaxes,
3706                                           /* Number of splits along axes */
3707                                           Standard_Integer& nbx,
3708                                           Standard_Integer& nby,
3709                                           Standard_Integer& nbz,
3710                                           /* Offset for drawing values */
3711                                           Standard_Integer& xoffset,
3712                                           Standard_Integer& yoffset,
3713                                           Standard_Integer& zoffset,
3714                                           /* Offset for drawing names of axes */
3715                                           Standard_Integer& xaxisoffset,
3716                                           Standard_Integer& yaxisoffset,
3717                                           Standard_Integer& zaxisoffset,
3718                                           /* Draw tickmarks */
3719                                           Standard_Boolean& xdrawtickmarks,
3720                                           Standard_Boolean& ydrawtickmarks,
3721                                           Standard_Boolean& zdrawtickmarks,
3722                                           /* Length of tickmarks */
3723                                           Standard_Integer& xtickmarklength,
3724                                           Standard_Integer& ytickmarklength,
3725                                           Standard_Integer& ztickmarklength,
3726                                           /* Grid color */
3727                                           Quantity_Color& gridcolor,
3728                                           /* X name color */
3729                                           Quantity_Color& xnamecolor,
3730                                           /* Y name color */
3731                                           Quantity_Color& ynamecolor,
3732                                           /* Z name color */
3733                                           Quantity_Color& znamecolor,
3734                                           /* X color of axis and values */
3735                                           Quantity_Color& xcolor,
3736                                           /* Y color of axis and values */
3737                                           Quantity_Color& ycolor,
3738                                           /* Z color of axis and values */
3739                                           Quantity_Color& zcolor,
3740                                           /* Name of font for names of axes */
3741                                           Standard_CString& fontOfNames,
3742                                           /* Style of names of axes */
3743                                           OSD_FontAspect& styleOfNames,
3744                                           /* Size of names of axes */
3745                                           Standard_Integer& sizeOfNames,
3746                                           /* Name of font for values */
3747                                           Standard_CString& fontOfValues,
3748                                           /* Style of values */
3749                                           OSD_FontAspect& styleOfValues,
3750                                           /* Size of values */
3751                                           Standard_Integer& sizeOfValues) const
3752 {
3753     MyGraphicDriver->GetGraduatedTrihedron(MyCView,
3754                                            /* Names of axes */
3755                                            xname,
3756                                            yname,
3757                                            zname,
3758                                            /* Draw names */
3759                                            xdrawname,
3760                                            ydrawname,
3761                                            zdrawname,
3762                                            /* Draw values */
3763                 &nbs