87ba9e8b25ae76971bc9c896259961dcf4434455
[occt.git] / src / Graphic3d / Graphic3d_Structure.cxx
1 // Created by: NW,JPB,CAL
2 // Copyright (c) 1991-1999 Matra Datavision
3 // Copyright (c) 1999-2012 OPEN CASCADE SAS
4 //
5 // The content of this file is subject to the Open CASCADE Technology Public
6 // License Version 6.5 (the "License"). You may not use the content of this file
7 // except in compliance with the License. Please obtain a copy of the License
8 // at http://www.opencascade.org and read it completely before using this file.
9 //
10 // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
11 // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
12 //
13 // The Original Code and all software distributed under the License is
14 // distributed on an "AS IS" basis, without warranty of any kind, and the
15 // Initial Developer hereby disclaims all such warranties, including without
16 // limitation, any warranties of merchantability, fitness for a particular
17 // purpose or non-infringement. Please see the License for the specific terms
18 // and conditions governing the rights and limitations under the License.
19
20 // Modified      1/08/97 ; PCT : ajout texture mapping
21 //              20/08/97 ; PCT : ajout transparence pour texture
22 //              11/97 ; CAL : gestion du GraphicClear
23 //              11/97 ; CAL : ajout pointer StructPtr
24 //              11/97 ; CAL : amelioration de l'effacement SetManager
25 //      CAL : 15 janvier 1998
26 //              Ajout de la methode IsTransformed dans une Structure.
27 //                      (Permet la transmission de cette Trsf vers
28 //                      la structure COMPUTED si necessaire)
29 //              Ajout de la methode IsRotated dans une Structure.
30 //                      (Permet de connaitre le type de transformation
31 //                      pour declencher le calcul des parties cachees
32 //                      de maniere plus sioux)
33 //              Ajout de 3 nouvelles methodes Compute virtual dans Structure.
34 //                      (Permet des Compute un peu plus specialises)
35 //              Ajout des 2 methodes sur Owner dans Structure.
36 //                      (evite de calculer 2 fois les parties cachees
37 //                      pour 2 representations differentes affichees
38 //                      d'un meme Presentable Object (Owner))
39 //              Ajout des 2 methodes sur HLRValidation dans Structure.
40 //                      (permet de valider ou d'invalider le calcul des
41 //                      parties cachees sur certaines representations)
42 //              Ajout de la transmission de la transformation d'une structure
43 //              vers sa COMPUTED.
44 //              24/2/98 ; CAL : Modification de la gestion des champs
45 //      CAL : 26 mars 1998
46 //              Patch, erreur dans la gestion du nombre de Group avec
47 //              facettes dans Graphic3d_Structure avec une operation
48 //              de Clear. (PRO12795)
49 //      FGU : 30 Avril 1998
50 //              Ajout emission
51 //      CAL : 20 mai 1998
52 //              Perfs. Connection entre structures COMPUTED.
53 //      30/11/98 ; FMN : S4069. Textes always visible.
54 //      22/03/04 ; SAN : OCC4895 High-level interface for controlling polygon offsets
55
56 #define BUC60918        //GG 31/05/01 A transparente structure priority must have the
57 //                      MAX_PRIORITY value so, the highlighted structure must have
58 //                      MAX_PRIORITY-1 value.
59 //                      Add ResetDisplayPriority() method.
60
61 #define OCC1174 // SAV 08/01/03 Added back face interior color controling
62
63
64
65 //-Version
66
67 //-Design       Declaration of variables specific to graphic structures
68
69 //-Warning      A structure is defined in a manager
70 //              This is a sequence of groups of primitives
71
72 //-References
73
74 //-Language     C++ 2.0
75
76 //-Declarations
77
78 // for the class
79
80 #define XDOWNCAST
81 #define XDESTROY
82 #define XDEBUG
83 #define XTRACE
84 #define XTRACE_ISTRSF
85
86 #include <stdio.h>
87
88 #include <Graphic3d_Structure.ixx>
89 #include <Graphic3d_Structure.pxx>
90
91 #include <Graphic3d_GraphicDriver.hxx>
92 #include <Graphic3d_MaterialAspect.hxx>
93
94 #include <Graphic3d_MapOfStructure.hxx>
95 #include <Graphic3d_MapIteratorOfMapOfStructure.hxx>
96
97 #include <Quantity_Color.hxx>
98 #include <TColStd_Array2OfReal.hxx>
99 #include <Graphic3d_TextureMap.hxx>
100
101 // OCC4895 SAN 22/03/04 High-level interface for controlling polygon offsets
102 #include <Aspect_PolygonOffsetMode.hxx>
103 // OCC4895 SAN 22/03/04 High-level interface for controlling polygon offsets
104
105 //-Aliases
106
107 //-Global data definitions
108
109 //-Constructors
110
111 Graphic3d_Structure::Graphic3d_Structure (const Handle(Graphic3d_StructureManager)& AManager):
112 MyAncestors (),
113 MyDescendants (),
114 MyGroups (),
115 MyHighlightColor (Quantity_NOC_WHITE)
116 {
117
118   Standard_Integer i, j;
119
120   MyOwner = NULL;
121
122   Handle(Graphic3d_AspectLine3d) aAspectLine3d =
123     new Graphic3d_AspectLine3d ();
124   Handle(Graphic3d_AspectText3d) aAspectText3d =
125     new Graphic3d_AspectText3d ();
126   Handle(Graphic3d_AspectMarker3d) aAspectMarker3d =
127     new Graphic3d_AspectMarker3d ();
128   Handle(Graphic3d_AspectFillArea3d) aAspectFillArea3d =
129     new Graphic3d_AspectFillArea3d ();
130
131   // Return default values
132   AManager->PrimitivesAspect (aAspectLine3d, aAspectText3d,
133     aAspectMarker3d, aAspectFillArea3d);
134
135   // OCC4895 SAN 22/03/04 High-level interface for controlling polygon offsets
136   // It is necessary to set default polygon offsets for a new presentation
137   aAspectFillArea3d->SetPolygonOffsets( Aspect_POM_Fill, 1., 0. );
138   // OCC4895 SAN 22/03/04 High-level interface for controlling polygon offsets
139
140   // Update the associated CStructure
141   UpdateStructure (aAspectLine3d, aAspectText3d,
142     aAspectMarker3d, aAspectFillArea3d);
143
144   MyFirstPtrStructureManager = MyPtrStructureManager =
145     (void *) AManager.operator->();
146   MyCStructure.Id         = int (AManager->NewIdentification ());
147
148   MyCStructure.IsOpen     = 0;
149   MyCStructure.IsDeleted  = 0;
150
151   MyCStructure.Composition        = 0; /* Graphic3d_TOC_REPLACE */
152
153   for (i=0; i<=3; i++)
154     for (j=0; j<=3; j++)
155       if (i == j)
156         MyCStructure.Transformation[i][j] = float (1.0);
157       else
158         MyCStructure.Transformation[i][j] = float (0.0);
159
160   MyCStructure.Priority           = int (Structure_MAX_PRIORITY / 2);
161   MyCStructure.PreviousPriority   = MyCStructure.Priority;
162   MyCStructure.stick              = 0,
163   MyCStructure.highlight          = 0,
164   MyCStructure.visible            = 1,
165   MyCStructure.pick               = 1;
166   MyCStructure.ContainsFacet      = 0,
167   MyCStructure.IsInfinite         = 0,
168   MyCStructure.HLRValidation      = 0;
169
170   MyCStructure.ContextLine.IsDef         = 1,
171   MyCStructure.ContextFillArea.IsDef     = 1,
172   MyCStructure.ContextMarker.IsDef       = 1,
173   MyCStructure.ContextText.IsDef         = 1;
174
175   MyCStructure.ContextLine.IsSet         = 0,
176   MyCStructure.ContextFillArea.IsSet     = 0,
177   MyCStructure.ContextMarker.IsSet       = 0,
178   MyCStructure.ContextText.IsSet         = 0;
179
180   MyVisual        = Graphic3d_TOS_ALL;
181   MyComputeVisual = Graphic3d_TOS_ALL;
182
183   /* ABD 29/10/04  Transform Persistence of Presentation( pan, zoom, rotate ) */
184   /*MyCStructure.TransformPersistence.IsDef = 1;*/
185   MyCStructure.TransformPersistence.IsSet = 0;
186   MyCStructure.TransformPersistence.Flag = Graphic3d_TMF_None;
187   MyCStructure.TransformPersistence.Point.x = 0.0;
188   MyCStructure.TransformPersistence.Point.y = 0.0;
189   MyCStructure.TransformPersistence.Point.z = 0.0;
190   /* ABD 29/10/04  Transform Persistence of Presentation( pan, zoom, rotate ) */
191
192   MyGraphicDriver = AManager->GraphicDriver();
193   MyGraphicDriver->Structure (MyCStructure);
194
195 #ifdef TRACE
196   cout << "Graphic3d_Structure::Create (" << MyCStructure.Id << ")\n";
197 #endif
198
199 }
200
201 //-Destructors
202
203 void Graphic3d_Structure::Destroy () {
204
205 #ifdef DESTROY
206   cout << "Graphic3d_Structure::Destroy (" << MyCStructure.Id << ")\n";
207 #endif
208
209   // as MyFirstPtrStructureManager can be already destroyed,
210   // avoid attempts to access it
211   MyFirstPtrStructureManager = 0;
212   Remove ();
213
214 }
215
216 //-Methods, in order
217
218 void Graphic3d_Structure::Clear (const Standard_Boolean WithDestruction)
219 {
220   if (IsDeleted()) return;
221
222   MyCStructure.ContainsFacet = 0;
223
224   // clean groups in graphics driver at first
225   GraphicClear (WithDestruction);
226
227   // only then remove group references
228   if (WithDestruction)
229     MyGroups.Clear();
230
231   MyStructureManager->Clear (this, WithDestruction);
232
233   Update();
234 }
235
236 void Graphic3d_Structure::Remove () {
237
238   if (IsDeleted ()) return;
239
240 #ifdef DESTROY
241   if (MyDescendants.Length () != 0) {
242     cout << "The structure " << MyCStructure.Id << " have "
243       << MyDescendants.Length () << " descendants.\n" << flush;
244   }
245   if (MyAncestors.Length () != 0) {
246     cout << "The structure " << MyCStructure.Id << " have "
247       << MyAncestors.Length () << " ancestors.\n" << flush;
248   }
249 #endif
250
251   Standard_Integer i, Length;
252
253   // clean groups in graphics driver at first; this is also should be done
254   // to avoid unwanted group cleaning in group's destructor
255   // Pass Standard_False to Clear(..) method to avoid updating in
256   // structure manager, it isn't necessary, besides of it structure manager
257   // could be already destroyed and invalid pointers used in structure;
258   Length = MyGroups.Length();
259   for (Standard_Integer aGrId = 1; aGrId <= Length; ++aGrId)
260     MyGroups.ChangeValue (aGrId)->Clear (Standard_False);
261
262   //        Standard_Address APtr = (void *) This ().operator->();
263   Standard_Address APtr = (void *) this;
264   // It is necessary to remove the eventual pointer on the structure
265   // that can be destroyed, in the list of descendants
266   // of ancesters of this structure and in the list of ancesters
267   // of descendants of the same structure.
268
269   Length  = MyDescendants.Length ();
270   for (i=1; i<=Length; i++)
271     ((Graphic3d_Structure *)
272     (MyDescendants.Value (i)))->Remove (APtr, Graphic3d_TOC_ANCESTOR);
273
274   Length  = MyAncestors.Length ();
275   for (i=1; i<=Length; i++)
276     ((Graphic3d_Structure *)
277     (MyAncestors.Value (i)))->Remove (APtr, Graphic3d_TOC_DESCENDANT);
278
279   MyCStructure.ContainsFacet      = 0;
280   MyCStructure.IsDeleted  = 1;
281
282   // Destruction of me in the graphic library
283   MyGraphicDriver->RemoveStructure (MyCStructure);
284
285   // Liberation of the identification if the destroyed structure
286   // in the first manager that performs creation of the structure.
287   if ( MyFirstPtrStructureManager )
288     MyFirstStructureManager->Remove (Standard_Integer (MyCStructure.Id));
289
290 }
291
292 void Graphic3d_Structure::Display () {
293
294   if (IsDeleted ()) return;
295
296   if (! MyCStructure.stick) {
297     MyCStructure.stick      = 1;
298     MyStructureManager->Display (this);
299   }
300
301 }
302
303 void Graphic3d_Structure::Display (const Standard_Integer Priority) {
304
305   if (IsDeleted ()) return;
306
307   SetDisplayPriority (Priority);
308
309   if (! MyCStructure.stick) {
310     MyCStructure.stick      = 1;
311     MyStructureManager->Display (this);
312   }
313
314 }
315
316 void Graphic3d_Structure::SetDisplayPriority (const Standard_Integer Priority) {
317
318   if (IsDeleted ()) return;
319
320 #ifdef BUC60918
321   if( Priority == MyCStructure.Priority ) return;
322 #endif
323
324   MyCStructure.PreviousPriority   = MyCStructure.Priority;
325   MyCStructure.Priority   = int (Priority);
326
327   if (MyCStructure.Priority != MyCStructure.PreviousPriority) {
328     if ( (MyCStructure.Priority > Structure_MAX_PRIORITY) ||
329       (MyCStructure.Priority < Structure_MIN_PRIORITY) )
330       Graphic3d_PriorityDefinitionError::Raise
331       ("Bad value for StructurePriority");
332
333     if (MyCStructure.stick)
334       MyStructureManager->ChangeDisplayPriority (this,
335       Standard_Integer (MyCStructure.PreviousPriority),
336       Standard_Integer (MyCStructure.Priority));
337   }
338
339 }
340
341 #ifdef BUC60918
342 void Graphic3d_Structure::ResetDisplayPriority () {
343
344   if (IsDeleted ()) return;
345
346   if (MyCStructure.Priority != MyCStructure.PreviousPriority) {
347     Standard_Integer priority = MyCStructure.Priority;
348     MyCStructure.Priority = MyCStructure.PreviousPriority;
349
350     if (MyCStructure.stick)
351       MyStructureManager->ChangeDisplayPriority (this,
352       priority,
353       Standard_Integer (MyCStructure.Priority));
354   }
355
356 }
357 #endif
358
359 Standard_Integer Graphic3d_Structure::DisplayPriority () const {
360
361   return Standard_Integer (MyCStructure.Priority);
362
363 }
364
365 void Graphic3d_Structure::Erase () {
366
367   if (IsDeleted ()) return;
368
369   if (MyCStructure.stick) {
370     MyCStructure.stick = 0;
371     MyStructureManager->Erase (this);
372   }
373
374 }
375
376 void Graphic3d_Structure::Highlight (const Aspect_TypeOfHighlightMethod AMethod) {
377
378   if (IsDeleted ()) return;
379
380   // Highlight on already Highlighted structure.
381   if (MyCStructure.highlight) {
382
383     Aspect_TypeOfUpdate UpdateMode = MyStructureManager->UpdateMode ();
384     if (UpdateMode == Aspect_TOU_WAIT)
385       UnHighlight ();
386     else {
387       // To avoid call of method : Update ()
388       // Not useful and can be costly.
389       MyStructureManager->SetUpdateMode (Aspect_TOU_WAIT);
390       UnHighlight ();
391       MyStructureManager->SetUpdateMode (UpdateMode);
392     }
393   }
394
395 #ifdef BUC60918
396   SetDisplayPriority (Standard_Integer (Structure_MAX_PRIORITY)-1);
397 #else
398   SetDisplayPriority (Standard_Integer (Structure_MAX_PRIORITY));
399 #endif
400
401   GraphicHighlight (AMethod);
402   MyStructureManager->Highlight (this, AMethod);
403
404   Update ();
405
406 }
407
408 void Graphic3d_Structure::SetHighlightColor (const Quantity_Color& AColor) {
409
410   if (IsDeleted ()) return;
411
412   if (! MyCStructure.highlight)
413     MyHighlightColor = AColor;
414   else {
415     // Change highlight color on already Highlighted structure.
416
417     Aspect_TypeOfUpdate UpdateMode  = MyStructureManager->UpdateMode ();
418     if (UpdateMode == Aspect_TOU_WAIT)
419       UnHighlight ();
420     else {
421       // To avoid call of method : Update ()
422       // Not useful and can be costly.
423       MyStructureManager->SetUpdateMode (Aspect_TOU_WAIT);
424       UnHighlight ();
425       MyStructureManager->SetUpdateMode (UpdateMode);
426     }
427     MyHighlightColor = AColor;
428     Highlight (MyHighlightMethod);
429   }
430
431 }
432
433 void Graphic3d_Structure::SetVisible (const Standard_Boolean AValue) {
434
435   if (IsDeleted ()) return;
436
437   MyCStructure.visible = AValue ? 1:0;
438
439   MyGraphicDriver->NameSetStructure (MyCStructure);
440
441   if (AValue)
442     MyStructureManager->Visible (this);
443   else
444     MyStructureManager->Invisible (this);
445
446   Update ();
447
448 }
449
450 void Graphic3d_Structure::SetPick (const Standard_Boolean AValue) {
451
452   if (IsDeleted ()) return;
453
454   MyCStructure.pick = AValue ? 1:0;
455
456   MyGraphicDriver->NameSetStructure (MyCStructure);
457
458   if (AValue)
459     MyStructureManager->Detectable (this);
460   else
461     MyStructureManager->Undetectable (this);
462
463   Update ();
464
465 }
466
467 void Graphic3d_Structure::UnHighlight () {
468
469   if (IsDeleted ()) return;
470
471   if (MyCStructure.highlight) {
472     MyCStructure.highlight = 0;
473
474     GraphicUnHighlight ();
475     MyStructureManager->UnHighlight (this);
476 #ifdef BUC60918
477     ResetDisplayPriority();
478 #else
479     SetDisplayPriority
480       (Standard_Integer (MyCStructure.PreviousPriority));
481 #endif
482     Update ();
483   }
484
485 }
486
487 Quantity_Color Graphic3d_Structure::HighlightColor () const {
488
489   return (MyHighlightColor);
490
491 }
492
493 Standard_Boolean Graphic3d_Structure::IsDisplayed () const {
494
495   if (MyCStructure.stick)
496     return (Standard_True);
497   else
498     return (Standard_False);
499
500 }
501
502 Standard_Boolean Graphic3d_Structure::IsDeleted () const {
503
504   if (MyCStructure.IsDeleted)
505     return (Standard_True);
506   else
507     return (Standard_False);
508
509 }
510
511 Standard_Boolean Graphic3d_Structure::IsHighlighted () const {
512
513   if (MyCStructure.highlight)
514     return (Standard_True);
515   else
516     return (Standard_False);
517
518 }
519
520 Standard_Boolean Graphic3d_Structure::IsSelectable () const {
521
522   if (MyCStructure.pick)
523     return (Standard_True);
524   else
525     return (Standard_False);
526
527 }
528
529 Standard_Boolean Graphic3d_Structure::IsVisible () const {
530
531   if (MyCStructure.visible)
532     return (Standard_True);
533   else
534     return (Standard_False);
535
536 }
537
538 Standard_Boolean Graphic3d_Structure::IsRotated () const {
539
540   // A somewhat light test !
541   return   ( MyCStructure.Transformation[0][1] != 0.
542     || MyCStructure.Transformation[0][2] != 0.
543     || MyCStructure.Transformation[1][0] != 0.
544     || MyCStructure.Transformation[1][2] != 0.
545     || MyCStructure.Transformation[2][0] != 0.
546     || MyCStructure.Transformation[2][1] != 0. );
547
548 }
549
550 Standard_Boolean Graphic3d_Structure::IsTransformed () const {
551
552   Standard_Boolean Result = Standard_False;
553   Standard_Integer i, j;
554
555   for (i=0; i<=3 && ! Result; i++)
556     for (j=0; j<=3 && ! Result; j++)
557       if (i == j)
558         Result = MyCStructure.Transformation[i][j] != 1.;
559       else
560         Result = MyCStructure.Transformation[i][j] != 0.;
561
562 #ifdef TRACE_ISTRSF
563   cout << "Structure " << Identification ();
564   if (Result)
565     cout << " is transformed\n" << flush;
566   else
567     cout << " is not transformed\n" << flush;
568 #endif
569
570   return Result;
571
572 }
573
574 Standard_Boolean Graphic3d_Structure::ContainsFacet () const {
575
576   if (IsDeleted ()) return (Standard_False);
577
578   // A structure contains at least one facet :
579   // if one of these groups contains at least one facet.
580
581   Standard_Boolean Result1 = Standard_False;
582   Standard_Boolean Result2 = Standard_False;
583   Standard_Integer i, Length;
584
585   Result1 = (MyCStructure.ContainsFacet > 0);
586
587   // If one of groups contains at least one facet, the structure contains it too.
588   if (Result1) return (Result1);
589
590   Length  = MyDescendants.Length ();
591
592   // Stop at the first descendant  containing at least one facet.
593   for (i=1; i<=Length && ! Result2; i++)
594     Result2 = ((Graphic3d_Structure *)
595     (MyDescendants.Value (i)))->ContainsFacet ();
596
597   return (Result2);
598
599 }
600
601 Standard_Boolean Graphic3d_Structure::IsEmpty () const {
602
603   if (IsDeleted ()) return (Standard_True);
604
605   // A structure is empty :
606   // if all these groups are empty or if all
607   // groups are empty and all their descendants
608   // are empty or if all its descendants are empty.
609
610   Standard_Boolean Result1   = Standard_True;
611   Standard_Integer i, Length = MyGroups.Length ();
612
613   // Stop at the first non-empty group
614   for (i=1; i<=Length && Result1; i++)
615     Result1 = (MyGroups.Value (i))->IsEmpty ();
616
617   // If a group is non-empty the structure is also non-empty.
618   if (! Result1) return (Standard_False);
619
620   Standard_Boolean Result2 = Standard_True;
621
622   Length  = MyDescendants.Length ();
623
624   // Stop at the first non-empty descendant
625   for (i=1; i<=Length && Result2; i++)
626     Result2 = ((Graphic3d_Structure *)
627     (MyDescendants.Value (i)))->IsEmpty ();
628
629   return (Result2);
630
631 }
632
633 void Graphic3d_Structure::PrimitivesAspect (Handle(Graphic3d_AspectLine3d)& CTXL, Handle(Graphic3d_AspectText3d)& CTXT, Handle(Graphic3d_AspectMarker3d)& CTXM, Handle(Graphic3d_AspectFillArea3d)& CTXF) const {
634
635   CTXL     = Line3dAspect ();
636   CTXT     = Text3dAspect ();
637   CTXM     = Marker3dAspect ();
638   CTXF     = FillArea3dAspect ();
639
640 }
641
642 void Graphic3d_Structure::GroupsWithFacet (const Standard_Integer ADelta) {
643
644   MyCStructure.ContainsFacet = MyCStructure.ContainsFacet + ADelta;
645   if (MyCStructure.ContainsFacet < 0) MyCStructure.ContainsFacet = 0;
646
647 #ifdef DEBUG
648   cout << "MyCStructure.ContainsFacet " << MyCStructure.ContainsFacet;
649   cout << endl << flush;
650 #endif
651
652 }
653
654 Handle(Graphic3d_Structure) Graphic3d_Structure::Compute (const Handle(Graphic3d_DataStructureManager)& ) {
655
656   // Implemented by Presentation
657   return this;
658 }
659
660 Handle(Graphic3d_Structure) Graphic3d_Structure::Compute (const Handle(Graphic3d_DataStructureManager)& , const TColStd_Array2OfReal& ) {
661
662   // Implemented by Presentation
663   return this;
664 }
665
666 void Graphic3d_Structure::Compute (const Handle(Graphic3d_DataStructureManager)& , Handle(Graphic3d_Structure)& ) {
667
668   // Implemented by Presentation
669 }
670
671 void Graphic3d_Structure::Compute (const Handle(Graphic3d_DataStructureManager)& , const TColStd_Array2OfReal& , Handle(Graphic3d_Structure)& ) {
672
673   // Implemented by Presentation
674 }
675
676 void Graphic3d_Structure::ReCompute () {
677
678   MyStructureManager->ReCompute (this);
679
680 }
681
682 void Graphic3d_Structure::ReCompute (const Handle(Graphic3d_DataStructureManager)& aProjector) {
683
684   MyStructureManager->ReCompute (this, aProjector);
685
686 }
687
688 void Graphic3d_Structure::SetInfiniteState (const Standard_Boolean AValue) {
689
690   MyCStructure.IsInfinite = AValue ? 1:0;
691
692 }
693
694 Standard_Boolean Graphic3d_Structure::IsInfinite () const {
695
696   if (IsDeleted ()) return (Standard_True);
697
698   if (MyCStructure.IsInfinite)
699     return (Standard_True);
700   else
701     return (Standard_False);
702
703 }
704
705 void Graphic3d_Structure::GraphicClear (const Standard_Boolean WithDestruction)
706 {
707   // clean and empty each group
708   Standard_Integer Length = MyGroups.Length();
709   for (Standard_Integer aGrId = 1; aGrId <= Length; ++aGrId)
710   {
711     MyGroups.ChangeValue (aGrId)->Clear();
712   }
713
714   if (WithDestruction)
715   {
716     while (!MyGroups.IsEmpty())
717     {
718       Handle(Graphic3d_Group) aGroup = MyGroups.First();
719       aGroup->Remove();
720     }
721
722     MyGraphicDriver->ClearStructure (MyCStructure);
723   }
724 }
725
726 void Graphic3d_Structure::GraphicConnect (const Handle(Graphic3d_Structure)& theDaughter)
727 {
728   MyGraphicDriver->Connect (MyCStructure, theDaughter->MyCStructure);
729 }
730
731 void Graphic3d_Structure::GraphicDisconnect (const Handle(Graphic3d_Structure)& theDaughter)
732 {
733   MyGraphicDriver->Disconnect (MyCStructure, theDaughter->MyCStructure);
734 }
735
736 Handle(Graphic3d_AspectLine3d) Graphic3d_Structure::Line3dAspect () const {
737
738   Standard_Real           R, G, B;
739   Standard_Real           AWidth;
740   Quantity_Color          AColor;
741   Aspect_TypeOfLine       ALType;
742
743   // ContextLine
744   R       = Standard_Real (MyCStructure.ContextLine.Color.r);
745   G       = Standard_Real (MyCStructure.ContextLine.Color.g);
746   B       = Standard_Real (MyCStructure.ContextLine.Color.b);
747   AColor.SetValues (R, G, B, Quantity_TOC_RGB);
748   ALType  = Aspect_TypeOfLine (MyCStructure.ContextLine.LineType);
749   AWidth  = Standard_Real (MyCStructure.ContextLine.Width);
750
751   Handle(Graphic3d_AspectLine3d) CTXL =
752     new Graphic3d_AspectLine3d (AColor, ALType, AWidth);
753
754   return CTXL;
755
756 }
757
758 Handle(Graphic3d_AspectText3d) Graphic3d_Structure::Text3dAspect () const {
759
760   Standard_Real             R, G, B;
761   Standard_CString          AFont;
762   Standard_Real             ASpace;
763   Standard_Real             AnExpansion;
764   Quantity_Color            AColor;
765   Aspect_TypeOfStyleText    AStyle;
766   Aspect_TypeOfDisplayText  ADisplayType;
767
768   // ContextText
769   R       = Standard_Real (MyCStructure.ContextText.Color.r);
770   G       = Standard_Real (MyCStructure.ContextText.Color.g);
771   B       = Standard_Real (MyCStructure.ContextText.Color.b);
772   AColor.SetValues (R, G, B, Quantity_TOC_RGB);
773   AFont   = Standard_CString (MyCStructure.ContextText.Font);
774   AnExpansion     = Standard_Real (MyCStructure.ContextText.Expan);
775   ASpace  = Standard_Real (MyCStructure.ContextText.Space);
776   AStyle  = Aspect_TypeOfStyleText (MyCStructure.ContextText.Style);
777   ADisplayType = Aspect_TypeOfDisplayText (MyCStructure.ContextText.DisplayType);
778
779   Handle(Graphic3d_AspectText3d) CTXT =
780     new Graphic3d_AspectText3d (AColor, AFont, AnExpansion, ASpace,AStyle,ADisplayType);
781
782   return CTXT;
783
784 }
785
786 Handle(Graphic3d_AspectMarker3d) Graphic3d_Structure::Marker3dAspect () const {
787
788   Standard_Real           R, G, B;
789   Standard_Real           AScale;
790   Quantity_Color          AColor;
791   Aspect_TypeOfMarker     AMType;
792
793   // ContextMarker
794   R       = Standard_Real (MyCStructure.ContextMarker.Color.r);
795   G       = Standard_Real (MyCStructure.ContextMarker.Color.g);
796   B       = Standard_Real (MyCStructure.ContextMarker.Color.b);
797   AColor.SetValues (R, G, B, Quantity_TOC_RGB);
798   AMType  = MyCStructure.ContextMarker.MarkerType;
799   AScale  = Standard_Real (MyCStructure.ContextMarker.Scale);
800
801   Handle(Graphic3d_AspectMarker3d) CTXM =
802     new Graphic3d_AspectMarker3d (AMType, AColor, AScale);
803
804   return CTXM;
805
806 }
807
808 Handle(Graphic3d_AspectFillArea3d) Graphic3d_Structure::FillArea3dAspect () const {
809
810   Standard_Real             R, G, B;
811   Standard_Real             AWidth;
812   Quantity_Color            AColor;
813   Quantity_Color            AnIntColor;
814   Quantity_Color            AnEdgeColor;
815   Aspect_TypeOfLine         ALType;
816   Aspect_InteriorStyle      AStyle;
817   Standard_Boolean          EdgeOn = Standard_False;
818   Graphic3d_MaterialAspect  Front;
819   Graphic3d_MaterialAspect  Back;
820
821   // ContextFillArea
822   AStyle  = Aspect_InteriorStyle (MyCStructure.ContextFillArea.Style);
823   R       = Standard_Real (MyCStructure.ContextFillArea.IntColor.r);
824   G       = Standard_Real (MyCStructure.ContextFillArea.IntColor.g);
825   B       = Standard_Real (MyCStructure.ContextFillArea.IntColor.b);
826   AnIntColor.SetValues (R, G, B, Quantity_TOC_RGB);
827   // Edges
828   if (MyCStructure.ContextFillArea.Edge == 1) EdgeOn = Standard_True;
829   R       = Standard_Real (MyCStructure.ContextFillArea.EdgeColor.r);
830   G       = Standard_Real (MyCStructure.ContextFillArea.EdgeColor.g);
831   B       = Standard_Real (MyCStructure.ContextFillArea.EdgeColor.b);
832   AnEdgeColor.SetValues (R, G, B, Quantity_TOC_RGB);
833   ALType  = Aspect_TypeOfLine (MyCStructure.ContextFillArea.LineType);
834   AWidth  = Standard_Real (MyCStructure.ContextFillArea.Width);
835   // Back Material
836   Back.SetShininess (
837     Standard_Real (MyCStructure.ContextFillArea.Back.Shininess));
838   Back.SetAmbient (
839     Standard_Real (MyCStructure.ContextFillArea.Back.Ambient));
840   Back.SetDiffuse (
841     Standard_Real (MyCStructure.ContextFillArea.Back.Diffuse));
842   Back.SetSpecular (
843     Standard_Real (MyCStructure.ContextFillArea.Back.Specular));
844   Back.SetTransparency (
845     Standard_Real (MyCStructure.ContextFillArea.Back.Transparency));
846   Back.SetEmissive (
847     Standard_Real (MyCStructure.ContextFillArea.Back.Emission));
848   if (MyCStructure.ContextFillArea.Back.IsAmbient == 1)
849     Back.SetReflectionModeOn (Graphic3d_TOR_AMBIENT);
850   else
851     Back.SetReflectionModeOff (Graphic3d_TOR_AMBIENT);
852   if (MyCStructure.ContextFillArea.Back.IsDiffuse == 1)
853     Back.SetReflectionModeOn (Graphic3d_TOR_DIFFUSE);
854   else
855     Back.SetReflectionModeOff (Graphic3d_TOR_DIFFUSE);
856   if (MyCStructure.ContextFillArea.Back.IsSpecular == 1)
857     Back.SetReflectionModeOn (Graphic3d_TOR_SPECULAR);
858   else
859     Back.SetReflectionModeOff (Graphic3d_TOR_SPECULAR);
860   if (MyCStructure.ContextFillArea.Back.IsEmission == 1)
861     Back.SetReflectionModeOn (Graphic3d_TOR_EMISSION);
862   else
863     Back.SetReflectionModeOff (Graphic3d_TOR_EMISSION);
864
865   R       = Standard_Real (MyCStructure.ContextFillArea.Back.ColorSpec.r);
866   G       = Standard_Real (MyCStructure.ContextFillArea.Back.ColorSpec.g);
867   B       = Standard_Real (MyCStructure.ContextFillArea.Back.ColorSpec.b);
868   AColor.SetValues (R, G, B, Quantity_TOC_RGB);
869   Back.SetSpecularColor (AColor);
870
871   R       = Standard_Real (MyCStructure.ContextFillArea.Back.ColorAmb.r);
872   G       = Standard_Real (MyCStructure.ContextFillArea.Back.ColorAmb.g);
873   B       = Standard_Real (MyCStructure.ContextFillArea.Back.ColorAmb.b);
874   AColor.SetValues (R, G, B, Quantity_TOC_RGB);
875   Back.SetAmbientColor (AColor);
876
877   R       = Standard_Real (MyCStructure.ContextFillArea.Back.ColorDif.r);
878   G       = Standard_Real (MyCStructure.ContextFillArea.Back.ColorDif.g);
879   B       = Standard_Real (MyCStructure.ContextFillArea.Back.ColorDif.b);
880   AColor.SetValues (R, G, B, Quantity_TOC_RGB);
881   Back.SetDiffuseColor (AColor);
882
883   R       = Standard_Real (MyCStructure.ContextFillArea.Back.ColorEms.r);
884   G       = Standard_Real (MyCStructure.ContextFillArea.Back.ColorEms.g);
885   B       = Standard_Real (MyCStructure.ContextFillArea.Back.ColorEms.b);
886   AColor.SetValues (R, G, B, Quantity_TOC_RGB);
887   Back.SetEmissiveColor (AColor);
888
889   Back.SetEnvReflexion (MyCStructure.ContextFillArea.Back.EnvReflexion);
890
891   Graphic3d_TypeOfMaterial mType =
892     MyCStructure.ContextFillArea.Back.IsPhysic ?
893 Graphic3d_MATERIAL_PHYSIC : Graphic3d_MATERIAL_ASPECT;
894   Back.SetMaterialType(mType);
895
896   // Front Material
897   Front.SetShininess (
898     Standard_Real (MyCStructure.ContextFillArea.Front.Shininess));
899   Front.SetAmbient (
900     Standard_Real (MyCStructure.ContextFillArea.Front.Ambient));
901   Front.SetDiffuse (
902     Standard_Real (MyCStructure.ContextFillArea.Front.Diffuse));
903   Front.SetSpecular (
904     Standard_Real (MyCStructure.ContextFillArea.Front.Specular));
905   Front.SetTransparency (
906     Standard_Real (MyCStructure.ContextFillArea.Front.Transparency));
907   Front.SetEmissive (
908     Standard_Real (MyCStructure.ContextFillArea.Front.Emission));
909   if (MyCStructure.ContextFillArea.Front.IsAmbient == 1)
910     Front.SetReflectionModeOn (Graphic3d_TOR_AMBIENT);
911   else
912     Front.SetReflectionModeOff (Graphic3d_TOR_AMBIENT);
913   if (MyCStructure.ContextFillArea.Front.IsDiffuse == 1)
914     Front.SetReflectionModeOn (Graphic3d_TOR_DIFFUSE);
915   else
916     Front.SetReflectionModeOff (Graphic3d_TOR_DIFFUSE);
917   if (MyCStructure.ContextFillArea.Front.IsSpecular == 1)
918     Front.SetReflectionModeOn (Graphic3d_TOR_SPECULAR);
919   else
920     Front.SetReflectionModeOff (Graphic3d_TOR_SPECULAR);
921   if (MyCStructure.ContextFillArea.Front.Emission == 1)
922     Front.SetReflectionModeOn (Graphic3d_TOR_EMISSION);
923   else
924     Front.SetReflectionModeOff (Graphic3d_TOR_EMISSION);
925
926   R       = Standard_Real (MyCStructure.ContextFillArea.Front.ColorSpec.r);
927   G       = Standard_Real (MyCStructure.ContextFillArea.Front.ColorSpec.g);
928   B       = Standard_Real (MyCStructure.ContextFillArea.Front.ColorSpec.b);
929   AColor.SetValues (R, G, B, Quantity_TOC_RGB);
930   Front.SetSpecularColor (AColor);
931
932   R       = Standard_Real (MyCStructure.ContextFillArea.Front.ColorAmb.r);
933   G       = Standard_Real (MyCStructure.ContextFillArea.Front.ColorAmb.g);
934   B       = Standard_Real (MyCStructure.ContextFillArea.Front.ColorAmb.b);
935   AColor.SetValues (R, G, B, Quantity_TOC_RGB);
936   Front.SetAmbientColor (AColor);
937
938   R       = Standard_Real (MyCStructure.ContextFillArea.Front.ColorDif.r);
939   G       = Standard_Real (MyCStructure.ContextFillArea.Front.ColorDif.g);
940   B       = Standard_Real (MyCStructure.ContextFillArea.Front.ColorDif.b);
941   AColor.SetValues (R, G, B, Quantity_TOC_RGB);
942   Front.SetDiffuseColor (AColor);
943
944   R       = Standard_Real (MyCStructure.ContextFillArea.Front.ColorEms.r);
945   G       = Standard_Real (MyCStructure.ContextFillArea.Front.ColorEms.g);
946   B       = Standard_Real (MyCStructure.ContextFillArea.Front.ColorEms.b);
947   AColor.SetValues (R, G, B, Quantity_TOC_RGB);
948   Front.SetEmissiveColor (AColor);
949
950   Front.SetEnvReflexion (MyCStructure.ContextFillArea.Front.EnvReflexion);
951
952   mType = MyCStructure.ContextFillArea.Front.IsPhysic ? Graphic3d_MATERIAL_PHYSIC : Graphic3d_MATERIAL_ASPECT;
953   Front.SetMaterialType(mType);
954
955   Handle(Graphic3d_AspectFillArea3d) CTXF =
956     new Graphic3d_AspectFillArea3d (AStyle, AnIntColor, AnEdgeColor, ALType, AWidth, Front, Back);
957
958   // Edges
959   if (EdgeOn)
960     CTXF->SetEdgeOn ();
961   else
962     CTXF->SetEdgeOff ();
963   // Hatch
964   CTXF->SetHatchStyle(Aspect_HatchStyle (MyCStructure.ContextFillArea.Hatch));
965   // Materials
966   // Front and Back face
967   if (MyCStructure.ContextFillArea.Distinguish == 1)
968     CTXF->SetDistinguishOn ();
969   else
970     CTXF->SetDistinguishOff ();
971   if (MyCStructure.ContextFillArea.BackFace == 1)
972     CTXF->SuppressBackFace ();
973   else
974     CTXF->AllowBackFace ();
975   // Texture
976   CTXF->SetTextureMap (MyCStructure.ContextFillArea.Texture.TextureMap);
977   if (MyCStructure.ContextFillArea.Texture.doTextureMap == 1)
978   {
979     CTXF->SetTextureMapOn();
980   }
981   else
982   {
983     CTXF->SetTextureMapOff();
984   }
985
986   // OCC4895 SAN 22/03/04 High-level interface for controlling polygon offsets
987   CTXF->SetPolygonOffsets(MyCStructure.ContextFillArea.PolygonOffsetMode,
988     MyCStructure.ContextFillArea.PolygonOffsetFactor,
989     MyCStructure.ContextFillArea.PolygonOffsetUnits);
990   // OCC4895 SAN 22/03/04 High-level interface for controlling polygon offsets
991
992   return CTXF;
993
994 }
995
996 const Graphic3d_SequenceOfGroup& Graphic3d_Structure::Groups() const {
997   return MyGroups;
998 }
999
1000 Standard_Integer Graphic3d_Structure::NumberOfGroups () const {
1001   return (MyGroups.Length ());
1002 }
1003
1004 void Graphic3d_Structure::SetPrimitivesAspect (const Handle(Graphic3d_AspectLine3d)& CTX) {
1005
1006   if (IsDeleted ()) return;
1007
1008   Standard_Real           R, G, B;
1009   Standard_Real           AWidth;
1010   Quantity_Color          AColor;
1011   Aspect_TypeOfLine       ALType;
1012
1013   CTX->Values (AColor, ALType, AWidth);
1014   AColor.Values (R, G, B, Quantity_TOC_RGB);
1015
1016   MyCStructure.ContextLine.Color.r        = float (R);
1017   MyCStructure.ContextLine.Color.g        = float (G);
1018   MyCStructure.ContextLine.Color.b        = float (B);
1019   MyCStructure.ContextLine.LineType       = int (ALType);
1020   MyCStructure.ContextLine.Width          = float (AWidth);
1021   MyCStructure.ContextLine.IsDef          = 1;
1022
1023   MyGraphicDriver->ContextStructure (MyCStructure);
1024
1025   // CAL 14/04/95
1026   // Attributes are "IsSet" during the first update
1027   // of context (line, marker...)
1028   MyCStructure.ContextLine.IsSet          = 1;
1029   MyCStructure.ContextFillArea.IsSet      = 1;
1030   MyCStructure.ContextMarker.IsSet        = 1;
1031   MyCStructure.ContextText.IsSet          = 1;
1032
1033   Update ();
1034
1035 }
1036
1037 void Graphic3d_Structure::SetPrimitivesAspect (const Handle(Graphic3d_AspectFillArea3d)& CTX) {
1038
1039   if (IsDeleted ()) return;
1040
1041   Standard_Real           R, G, B;
1042   Standard_Real           AWidth;
1043   Quantity_Color          AnIntColor;
1044   Quantity_Color          BackIntColor;
1045   Quantity_Color          AnEdgeColor;
1046   Aspect_TypeOfLine       ALType;
1047   Aspect_InteriorStyle    AStyle;
1048
1049   CTX->Values (AStyle, AnIntColor, BackIntColor, AnEdgeColor, ALType, AWidth);
1050   AnIntColor.Values (R, G, B, Quantity_TOC_RGB);
1051
1052   MyCStructure.ContextFillArea.Style      = int (AStyle);
1053   MyCStructure.ContextFillArea.IntColor.r = float (R);
1054   MyCStructure.ContextFillArea.IntColor.g = float (G);
1055   MyCStructure.ContextFillArea.IntColor.b = float (B);
1056
1057 #ifdef OCC1174
1058   if ( CTX->Distinguish() )
1059     BackIntColor.Values( R, G, B, Quantity_TOC_RGB );
1060 #endif
1061   MyCStructure.ContextFillArea.BackIntColor.r     = float( R );
1062   MyCStructure.ContextFillArea.BackIntColor.g     = float( G );
1063   MyCStructure.ContextFillArea.BackIntColor.b     = float( B );
1064
1065
1066   // Edges
1067   MyCStructure.ContextFillArea.Edge       = CTX->Edge () ? 1:0;
1068   AnEdgeColor.Values (R, G, B, Quantity_TOC_RGB);
1069   MyCStructure.ContextFillArea.EdgeColor.r        = float (R);
1070   MyCStructure.ContextFillArea.EdgeColor.g        = float (G);
1071   MyCStructure.ContextFillArea.EdgeColor.b        = float (B);
1072   MyCStructure.ContextFillArea.LineType           = int (ALType);
1073   MyCStructure.ContextFillArea.Width              = float (AWidth);
1074   MyCStructure.ContextFillArea.Hatch              = int (CTX->HatchStyle ());
1075
1076   /*** Front and Back face ***/
1077   MyCStructure.ContextFillArea.Distinguish        = CTX->Distinguish () ? 1:0;
1078   MyCStructure.ContextFillArea.BackFace           = CTX->BackFace () ? 1:0;
1079
1080   /*** Back Material ***/
1081   // Light specificity
1082   MyCStructure.ContextFillArea.Back.Shininess     =
1083     float ((CTX->BackMaterial ()).Shininess ());
1084   MyCStructure.ContextFillArea.Back.Ambient       =
1085     float ((CTX->BackMaterial ()).Ambient ());
1086   MyCStructure.ContextFillArea.Back.Diffuse       =
1087     float ((CTX->BackMaterial ()).Diffuse ());
1088   MyCStructure.ContextFillArea.Back.Specular      =
1089     float ((CTX->BackMaterial ()).Specular ());
1090   MyCStructure.ContextFillArea.Back.Transparency  =
1091     float ((CTX->BackMaterial ()).Transparency ());
1092   MyCStructure.ContextFillArea.Back.Emission      =
1093     float ((CTX->BackMaterial ()).Emissive ());
1094
1095   // Reflection mode
1096   MyCStructure.ContextFillArea.Back.IsAmbient     =
1097     ( (CTX->BackMaterial ()).ReflectionMode (Graphic3d_TOR_AMBIENT) ? 1 : 0 );
1098   MyCStructure.ContextFillArea.Back.IsDiffuse     =
1099     ( (CTX->BackMaterial ()).ReflectionMode (Graphic3d_TOR_DIFFUSE) ? 1 : 0 );
1100   MyCStructure.ContextFillArea.Back.IsSpecular    =
1101     ( (CTX->BackMaterial ()).ReflectionMode (Graphic3d_TOR_SPECULAR) ? 1 : 0 );
1102   MyCStructure.ContextFillArea.Back.IsEmission    =
1103     ( (CTX->BackMaterial ()).ReflectionMode (Graphic3d_TOR_EMISSION) ? 1 : 0 );
1104
1105   // Material type
1106   //JR/Hp
1107   const Graphic3d_MaterialAspect ama = CTX->BackMaterial () ;
1108   Standard_Boolean amt = ama.MaterialType(Graphic3d_MATERIAL_PHYSIC) ;
1109   MyCStructure.ContextFillArea.Back.IsPhysic = ( amt ? 1 : 0 );
1110
1111   // Specular Color
1112   MyCStructure.ContextFillArea.Back.ColorSpec.r   =
1113     float (((CTX->BackMaterial ()).SpecularColor ()).Red ());
1114   MyCStructure.ContextFillArea.Back.ColorSpec.g   =
1115     float (((CTX->BackMaterial ()).SpecularColor ()).Green ());
1116   MyCStructure.ContextFillArea.Back.ColorSpec.b   =
1117     float (((CTX->BackMaterial ()).SpecularColor ()).Blue ());
1118
1119   // Ambient color
1120   MyCStructure.ContextFillArea.Back.ColorAmb.r    =
1121     float (((CTX->BackMaterial ()).AmbientColor ()).Red ());
1122   MyCStructure.ContextFillArea.Back.ColorAmb.g    =
1123     float (((CTX->BackMaterial ()).AmbientColor ()).Green ());
1124   MyCStructure.ContextFillArea.Back.ColorAmb.b    =
1125     float (((CTX->BackMaterial ()).AmbientColor ()).Blue ());
1126
1127   // Diffuse color
1128   MyCStructure.ContextFillArea.Back.ColorDif.r    =
1129     float (((CTX->BackMaterial ()).DiffuseColor ()).Red ());
1130   MyCStructure.ContextFillArea.Back.ColorDif.g    =
1131     float (((CTX->BackMaterial ()).DiffuseColor ()).Green ());
1132   MyCStructure.ContextFillArea.Back.ColorDif.b    =
1133     float (((CTX->BackMaterial ()).DiffuseColor ()).Blue ());
1134
1135   // Emissive color
1136   MyCStructure.ContextFillArea.Back.ColorEms.r    =
1137     float (((CTX->BackMaterial ()).EmissiveColor ()).Red ());
1138   MyCStructure.ContextFillArea.Back.ColorEms.g    =
1139     float (((CTX->BackMaterial ()).EmissiveColor ()).Green ());
1140   MyCStructure.ContextFillArea.Back.ColorEms.b    =
1141     float (((CTX->BackMaterial ()).EmissiveColor ()).Blue ());
1142
1143   MyCStructure.ContextFillArea.Back.EnvReflexion =
1144     float ((CTX->BackMaterial ()).EnvReflexion());
1145
1146   /*** Front Material ***/
1147   // Light specificity
1148   MyCStructure.ContextFillArea.Front.Shininess    =
1149     float ((CTX->FrontMaterial ()).Shininess ());
1150   MyCStructure.ContextFillArea.Front.Ambient      =
1151     float ((CTX->FrontMaterial ()).Ambient ());
1152   MyCStructure.ContextFillArea.Front.Diffuse      =
1153     float ((CTX->FrontMaterial ()).Diffuse ());
1154   MyCStructure.ContextFillArea.Front.Specular     =
1155     float ((CTX->FrontMaterial ()).Specular ());
1156   MyCStructure.ContextFillArea.Front.Transparency =
1157     float ((CTX->FrontMaterial ()).Transparency ());
1158   MyCStructure.ContextFillArea.Front.Emission     =
1159     float ((CTX->FrontMaterial ()).Emissive ());
1160
1161   // Reflection mode
1162   MyCStructure.ContextFillArea.Front.IsAmbient    =
1163     ( (CTX->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_AMBIENT) ? 1 : 0 );
1164   MyCStructure.ContextFillArea.Front.IsDiffuse    =
1165     ( (CTX->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_DIFFUSE) ? 1 : 0 );
1166   MyCStructure.ContextFillArea.Front.IsSpecular   =
1167     ( (CTX->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_SPECULAR) ? 1 : 0 );
1168   MyCStructure.ContextFillArea.Front.IsEmission   =
1169     ( (CTX->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_EMISSION) ? 1 : 0 );
1170
1171   // Materail type
1172   //JR/Hp
1173   const Graphic3d_MaterialAspect amas = CTX->FrontMaterial () ;
1174   Standard_Boolean amty = amas.MaterialType(Graphic3d_MATERIAL_PHYSIC) ;
1175   MyCStructure.ContextFillArea.Front.IsPhysic = ( amty ? 1 : 0 );
1176
1177   // Specular Color
1178   MyCStructure.ContextFillArea.Front.ColorSpec.r  =
1179     float (((CTX->FrontMaterial ()).SpecularColor ()).Red ());
1180   MyCStructure.ContextFillArea.Front.ColorSpec.g  =
1181     float (((CTX->FrontMaterial ()).SpecularColor ()).Green ());
1182   MyCStructure.ContextFillArea.Front.ColorSpec.b  =
1183     float (((CTX->FrontMaterial ()).SpecularColor ()).Blue ());
1184
1185   // Ambient color
1186   MyCStructure.ContextFillArea.Front.ColorAmb.r   =
1187     float (((CTX->FrontMaterial ()).AmbientColor ()).Red ());
1188   MyCStructure.ContextFillArea.Front.ColorAmb.g   =
1189     float (((CTX->FrontMaterial ()).AmbientColor ()).Green ());
1190   MyCStructure.ContextFillArea.Front.ColorAmb.b   =
1191     float (((CTX->FrontMaterial ()).AmbientColor ()).Blue ());
1192
1193   // Diffuse color
1194   MyCStructure.ContextFillArea.Front.ColorDif.r   =
1195     float (((CTX->FrontMaterial ()).DiffuseColor ()).Red ());
1196   MyCStructure.ContextFillArea.Front.ColorDif.g   =
1197     float (((CTX->FrontMaterial ()).DiffuseColor ()).Green ());
1198   MyCStructure.ContextFillArea.Front.ColorDif.b   =
1199     float (((CTX->FrontMaterial ()).DiffuseColor ()).Blue ());
1200
1201   // Emissive color
1202   MyCStructure.ContextFillArea.Front.ColorEms.r   =
1203     float (((CTX->FrontMaterial ()).EmissiveColor ()).Red ());
1204   MyCStructure.ContextFillArea.Front.ColorEms.g   =
1205     float (((CTX->FrontMaterial ()).EmissiveColor ()).Green ());
1206   MyCStructure.ContextFillArea.Front.ColorEms.b   =
1207     float (((CTX->FrontMaterial ()).EmissiveColor ()).Blue ());
1208
1209   MyCStructure.ContextFillArea.Front.EnvReflexion =
1210     float ((CTX->FrontMaterial ()).EnvReflexion());
1211
1212   MyCStructure.ContextFillArea.IsDef      = 1; // Definition material ok
1213
1214   MyCStructure.ContextFillArea.Texture.TextureMap   = CTX->TextureMap();
1215   MyCStructure.ContextFillArea.Texture.doTextureMap = CTX->TextureMapState() ? 1 : 0;
1216
1217   // OCC4895 SAN 22/03/04 High-level interface for controlling polygon offsets
1218   Standard_Integer aPolyMode;
1219   Standard_ShortReal    aPolyFactor, aPolyUnits;
1220   CTX->PolygonOffsets(aPolyMode, aPolyFactor, aPolyUnits);
1221   MyCStructure.ContextFillArea.PolygonOffsetMode   = aPolyMode;
1222   MyCStructure.ContextFillArea.PolygonOffsetFactor = (Standard_ShortReal)aPolyFactor;
1223   MyCStructure.ContextFillArea.PolygonOffsetUnits  = (Standard_ShortReal)aPolyUnits;
1224   // OCC4895 SAN 22/03/04 High-level interface for controlling polygon offsets
1225
1226   MyGraphicDriver->ContextStructure (MyCStructure);
1227
1228   // CAL 14/04/95
1229   // Attributes are "IsSet" during the first update
1230   // of context (line, marker...)
1231   MyCStructure.ContextLine.IsSet          = 1;
1232   MyCStructure.ContextFillArea.IsSet      = 1;
1233   MyCStructure.ContextMarker.IsSet        = 1;
1234   MyCStructure.ContextText.IsSet          = 1;
1235
1236   Update ();
1237
1238 }
1239
1240 void Graphic3d_Structure::SetPrimitivesAspect (const Handle(Graphic3d_AspectText3d)& CTX) {
1241
1242   if (IsDeleted ()) return;
1243
1244   Standard_Real             R, G, B;
1245   Standard_Real             Rs, Gs, Bs;
1246   Standard_CString          AFont;
1247   Standard_Real             ASpace;
1248   Standard_Real             AnExpansion;
1249   Quantity_Color            AColor;
1250   Aspect_TypeOfStyleText    AStyle;
1251   Aspect_TypeOfDisplayText  ADisplayType;
1252   Quantity_Color            AColorSubTitle;
1253   Standard_Boolean          ATextZoomable;
1254   Standard_Real             ATextAngle;
1255   Font_FontAspect            ATextFontAspect;
1256
1257   CTX->Values (AColor, AFont, AnExpansion, ASpace, AStyle, ADisplayType,AColorSubTitle,ATextZoomable,ATextAngle,ATextFontAspect);
1258   AColor.Values (R, G, B, Quantity_TOC_RGB);
1259   AColorSubTitle.Values (Rs, Gs, Bs, Quantity_TOC_RGB);
1260
1261   MyCStructure.ContextText.Color.r          = float (R);
1262   MyCStructure.ContextText.Color.g          = float (G);
1263   MyCStructure.ContextText.Color.b          = float (B);
1264   MyCStructure.ContextText.Font             = (char*) (AFont);
1265   MyCStructure.ContextText.Expan            = float (AnExpansion);
1266   MyCStructure.ContextText.Space            = float (ASpace);
1267   MyCStructure.ContextText.Style            = int (AStyle);
1268   MyCStructure.ContextText.DisplayType      = int (ADisplayType);
1269   MyCStructure.ContextText.ColorSubTitle.r  = float (Rs);
1270   MyCStructure.ContextText.ColorSubTitle.g  = float (Gs);
1271   MyCStructure.ContextText.ColorSubTitle.b  = float (Bs);
1272   MyCStructure.ContextText.TextZoomable     = ATextZoomable;
1273   MyCStructure.ContextText.TextAngle        = float (ATextAngle);
1274   MyCStructure.ContextText.TextFontAspect   = int (ATextFontAspect);
1275
1276   MyCStructure.ContextText.IsDef          = 1;
1277
1278   MyGraphicDriver->ContextStructure (MyCStructure);
1279
1280   // CAL 14/04/95
1281   // Attributes are "IsSet" during the first update of a context (line, marker...)
1282   MyCStructure.ContextLine.IsSet          = 1;
1283   MyCStructure.ContextFillArea.IsSet      = 1;
1284   MyCStructure.ContextMarker.IsSet        = 1;
1285   MyCStructure.ContextText.IsSet          = 1;
1286
1287   Update ();
1288
1289 }
1290
1291 void Graphic3d_Structure::SetPrimitivesAspect (const Handle(Graphic3d_AspectMarker3d)& CTX) {
1292
1293   if (IsDeleted ()) return;
1294
1295   Standard_Real           R, G, B;
1296   Standard_Real           AScale;
1297   Quantity_Color          AColor;
1298   Aspect_TypeOfMarker     AMType;
1299
1300   CTX->Values (AColor, AMType, AScale);
1301   AColor.Values (R, G, B, Quantity_TOC_RGB);
1302
1303   MyCStructure.ContextMarker.Color.r      = float (R);
1304   MyCStructure.ContextMarker.Color.g      = float (G);
1305   MyCStructure.ContextMarker.Color.b      = float (B);
1306   MyCStructure.ContextMarker.MarkerType   = AMType;
1307   MyCStructure.ContextMarker.Scale        = float (AScale);
1308   MyCStructure.ContextMarker.IsDef        = 1;
1309
1310   MyGraphicDriver->ContextStructure (MyCStructure);
1311
1312   // Attributes are "IsSet" during the first update of a context (line, marker...)
1313   MyCStructure.ContextLine.IsSet          = 1;
1314   MyCStructure.ContextFillArea.IsSet      = 1;
1315   MyCStructure.ContextMarker.IsSet        = 1;
1316   MyCStructure.ContextText.IsSet          = 1;
1317
1318   Update ();
1319
1320 }
1321
1322 void Graphic3d_Structure::SetVisual (const Graphic3d_TypeOfStructure AVisual) {
1323
1324   if (IsDeleted ()) return;
1325   if (MyVisual == AVisual) return;
1326
1327   if (! MyCStructure.stick) {
1328     MyVisual        = AVisual;
1329     SetComputeVisual (AVisual);
1330   }
1331   else {
1332
1333     Aspect_TypeOfUpdate UpdateMode  = MyStructureManager->UpdateMode ();
1334     if (UpdateMode == Aspect_TOU_WAIT) {
1335       Erase ();
1336       MyVisual        = AVisual;
1337       SetComputeVisual (AVisual);
1338       Display ();
1339     }
1340     else {
1341       // To avoid calling method : Update ()
1342       // Not useful and can be costly.
1343       MyStructureManager->SetUpdateMode (Aspect_TOU_WAIT);
1344       Erase ();
1345       MyVisual        = AVisual;
1346       SetComputeVisual (AVisual);
1347       MyStructureManager->SetUpdateMode (UpdateMode);
1348       Display ();
1349     }
1350   }
1351
1352 }
1353
1354 void Graphic3d_Structure::SetZoomLimit (const Standard_Real LimitInf, const Standard_Real LimitSup) {
1355
1356   if (LimitInf <= 0.0)
1357     Graphic3d_StructureDefinitionError::Raise
1358     ("Bad value for ZoomLimit inf");
1359
1360   if (LimitSup <= 0.0)
1361     Graphic3d_StructureDefinitionError::Raise
1362     ("Bad value for ZoomLimit sup");
1363
1364   if (LimitSup < LimitInf)
1365     Graphic3d_StructureDefinitionError::Raise
1366     ("ZoomLimit sup < ZoomLimit inf");
1367
1368 }
1369
1370 Graphic3d_TypeOfStructure Graphic3d_Structure::Visual () const {
1371
1372   return (MyVisual);
1373
1374 }
1375
1376 Standard_Boolean Graphic3d_Structure::AcceptConnection (const Handle(Graphic3d_Structure)& AStructure1, const Handle(Graphic3d_Structure)& AStructure2, const Graphic3d_TypeOfConnection AType) {
1377
1378   Graphic3d_MapOfStructure ASet;
1379
1380   // cycle detection
1381   Graphic3d_Structure::Network (AStructure2, AType, ASet);
1382
1383   return (! ASet.Contains (AStructure1));
1384
1385 }
1386
1387 void Graphic3d_Structure::Ancestors (Graphic3d_MapOfStructure &SG) const {
1388
1389   Standard_Integer i, Length = MyAncestors.Length ();
1390
1391   for (i=1; i<=Length; i++)
1392     SG.Add ((Graphic3d_Structure *) (MyAncestors.Value (i)));
1393
1394
1395 }
1396
1397 void Graphic3d_Structure::SetOwner (const Standard_Address Owner) {
1398
1399   MyOwner = Owner;
1400
1401 }
1402
1403 Standard_Address Graphic3d_Structure::Owner () const {
1404
1405   return MyOwner;
1406
1407 }
1408
1409 void Graphic3d_Structure::Descendants (Graphic3d_MapOfStructure& SG) const {
1410
1411   Standard_Integer i, Length = MyDescendants.Length ();
1412
1413   for (i=1; i<=Length; i++)
1414     SG.Add ((Graphic3d_Structure *) (MyDescendants.Value (i)));
1415
1416 }
1417
1418 void Graphic3d_Structure::Connect (const Handle(Graphic3d_Structure)& AStructure, const Graphic3d_TypeOfConnection AType, const Standard_Boolean WithCheck) {
1419
1420   if (IsDeleted ()) return;
1421
1422   if (WithCheck)
1423     // cycle detection
1424     if (! Graphic3d_Structure::AcceptConnection
1425       (this, AStructure, AType))
1426       return;
1427
1428   // connection
1429   Standard_Integer i;
1430   switch (AType)
1431   {
1432
1433   case Graphic3d_TOC_DESCENDANT :
1434     {
1435       Standard_Integer indexD = 0;
1436       Standard_Integer LengthD = MyDescendants.Length ();
1437       for (i=1; i<=LengthD && indexD==0; i++)
1438         if ((void *) (MyDescendants.Value (i)) ==
1439           (void *) (AStructure.operator->())) indexD  = i;
1440
1441       if (indexD == 0) {
1442         MyDescendants.Append ((void *) AStructure.operator->());
1443         AStructure->Connect (this, Graphic3d_TOC_ANCESTOR);
1444
1445         GraphicConnect (AStructure);
1446         MyStructureManager->Connect (this, AStructure);
1447
1448         Update ();
1449       }
1450     }
1451     break;
1452
1453   case Graphic3d_TOC_ANCESTOR :
1454     {
1455       Standard_Integer indexA = 0;
1456       Standard_Integer LengthA        = MyAncestors.Length ();
1457       for (i=1; i<=LengthA && indexA==0; i++)
1458         if ((void *) (MyAncestors.Value (i)) ==
1459           (void *) (AStructure.operator->())) indexA  = i;
1460
1461       if (indexA == 0) {
1462         MyAncestors.Append ((void *) AStructure.operator->());
1463         AStructure->Connect (this, Graphic3d_TOC_DESCENDANT);
1464
1465         // MyGraphicDriver->Connect is called in case
1466         // if connection between parent and child
1467       }
1468     }
1469     break;
1470   }
1471
1472 }
1473
1474 void Graphic3d_Structure::Disconnect (const Handle(Graphic3d_Structure)& AStructure) {
1475
1476   if (IsDeleted ()) return;
1477
1478   Standard_Integer i;
1479
1480   Standard_Integer indexD = 0;
1481   Standard_Integer LengthD        = MyDescendants.Length ();
1482   for (i=1; i<=LengthD && indexD==0; i++)
1483     if ((void *) (MyDescendants.Value (i)) ==
1484       (void *) (AStructure.operator->())) indexD  = i;
1485
1486   // Search in the Descendants
1487   if (indexD != 0) {
1488     MyDescendants.Remove (indexD);
1489     AStructure->Disconnect (this);
1490
1491     GraphicDisconnect (AStructure);
1492     MyStructureManager->Disconnect (this, AStructure);
1493
1494     Update ();
1495   }
1496   else {
1497     Standard_Integer indexA = 0;
1498     Standard_Integer LengthA        = MyAncestors.Length ();
1499     for (i=1; i<=LengthA && indexA==0; i++)
1500       if ((void *) (MyAncestors.Value (i)) ==
1501         (void *) (AStructure.operator->())) indexA  = i;
1502
1503     // Search in the Ancestors
1504     if (indexA != 0) {
1505       MyAncestors.Remove (indexA);
1506       AStructure->Disconnect (this);
1507
1508       // No call of MyGraphicDriver->Disconnect
1509       // in case of an ancestor
1510     }
1511   }
1512
1513 }
1514
1515 void Graphic3d_Structure::DisconnectAll (const Graphic3d_TypeOfConnection AType) {
1516
1517   if (IsDeleted ()) return;
1518
1519   Standard_Integer i, Length;
1520
1521   // disconnection
1522   switch (AType)
1523   {
1524   case Graphic3d_TOC_DESCENDANT :
1525     Length      = MyDescendants.Length ();
1526     for (i=1; i<=Length; i++)
1527       // Value (1) instead of Value (i) as MyDescendants
1528       // is modified by :
1529       // Graphic3d_Structure::Disconnect (AStructure)
1530       // that takes AStructure from MyDescendants
1531       ((Graphic3d_Structure *)
1532       (MyDescendants.Value (1)))->Disconnect (this);
1533     break;
1534   case Graphic3d_TOC_ANCESTOR :
1535     Length      = MyAncestors.Length ();
1536     for (i=1; i<=Length; i++)
1537       // Value (1) instead of Value (i) as MyAncestors
1538       // is modified by :
1539       // Graphic3d_Structure::Disconnect (AStructure)
1540       // that takes AStructure from MyAncestors
1541       ((Graphic3d_Structure *)
1542       (MyAncestors.Value (1)))->Disconnect (this);
1543     break;
1544   }
1545
1546 }
1547
1548 Graphic3d_TypeOfComposition Graphic3d_Structure::Composition () const {
1549
1550   if (MyCStructure.Composition)
1551     return (Graphic3d_TOC_POSTCONCATENATE);
1552   else
1553     return (Graphic3d_TOC_REPLACE);
1554
1555 }
1556
1557 void Graphic3d_Structure::SetTransform (const TColStd_Array2OfReal& AMatrix, const Graphic3d_TypeOfComposition AType) {
1558
1559   if (IsDeleted ()) return;
1560
1561   Standard_Integer lr, ur, lc, uc;
1562   Standard_Real valuetrsf;
1563   Standard_Real valueoldtrsf;
1564   Standard_Real valuenewtrsf;
1565   Standard_Integer i, j, k;
1566   TColStd_Array2OfReal TheTrsf (0, 3, 0, 3);
1567   TColStd_Array2OfReal NewTrsf (0, 3, 0, 3);
1568   TColStd_Array2OfReal AMatrix44 (0, 3, 0, 3);
1569
1570   // Assign the new transformation in an array [0..3][0..3]
1571   // Avoid problemes if the user has defined matrice [1..4][1..4]
1572   //                                              or [3..6][-1..2] !!
1573   lr      = AMatrix.LowerRow ();
1574   ur      = AMatrix.UpperRow ();
1575   lc      = AMatrix.LowerCol ();
1576   uc      = AMatrix.UpperCol ();
1577
1578   if ( (ur - lr + 1 != 4) || (uc - lc + 1 != 4) )
1579     Graphic3d_TransformError::Raise
1580     ("Transform : not a 4x4 matrix");
1581
1582   if (AType == Graphic3d_TOC_REPLACE) {
1583     MyCStructure.Composition = 0;
1584     // Update of CStructure
1585     for (i=0; i<=3; i++)
1586       for (j=0; j<=3; j++) {
1587         MyCStructure.Transformation[i][j] =
1588           float (AMatrix (lr + i, lc + j));
1589         NewTrsf (i, j) = AMatrix (lr + i, lc + j);
1590       }
1591   }
1592
1593   if (AType == Graphic3d_TOC_POSTCONCATENATE) {
1594     MyCStructure.Composition = 1;
1595     // To simplify management of indices
1596     for (i=0; i<=3; i++)
1597       for (j=0; j<=3; j++)
1598         AMatrix44 (i, j) = AMatrix (lr + i, lc + j);
1599     // Calculation of the product of matrices
1600     for (i=0; i<=3; i++)
1601       for (j=0; j<=3; j++) {
1602         NewTrsf (i, j) = 0.0;
1603         for (k=0; k<=3; k++) {
1604           valueoldtrsf = MyCStructure.Transformation[i][k];
1605           valuetrsf    = AMatrix44 (k, j);
1606           valuenewtrsf = NewTrsf (i, j) +
1607             valueoldtrsf * valuetrsf;
1608           NewTrsf (i, j) = valuenewtrsf;
1609         }
1610       }
1611       // Update of CStructure
1612       for (i=0; i<=3; i++)
1613         for (j=0; j<=3; j++)
1614           MyCStructure.Transformation[i][j] = float (NewTrsf (i, j));
1615   }
1616
1617   // If transformation, no validation of hidden already calculated parts.
1618   if (IsRotated ())
1619     ReCompute ();
1620
1621   GraphicTransform (NewTrsf);
1622   MyStructureManager->SetTransform (this, NewTrsf);
1623
1624   Update ();
1625
1626 }
1627
1628 void Graphic3d_Structure::Transform (TColStd_Array2OfReal& AMatrix) const {
1629
1630   Standard_Integer lr     = AMatrix.LowerRow ();
1631   Standard_Integer ur     = AMatrix.UpperRow ();
1632   Standard_Integer lc     = AMatrix.LowerCol ();
1633   Standard_Integer uc     = AMatrix.UpperCol ();
1634
1635   if ( (ur - lr + 1 != 4) || (uc - lc + 1 != 4) )
1636     Graphic3d_TransformError::Raise
1637     ("Transform : not a 4x4 matrix");
1638
1639   for (Standard_Integer i=0; i<=3; i++)
1640     for (Standard_Integer j=0; j<=3; j++)
1641       AMatrix (lr + i, lc + j) = MyCStructure.Transformation[i][j];
1642
1643 }
1644
1645 void Graphic3d_Structure::MinMaxValues (Standard_Real& XMin, Standard_Real& YMin, Standard_Real& ZMin, Standard_Real& XMax, Standard_Real& YMax, Standard_Real& ZMax) const {
1646
1647   Standard_Real RL = RealLast ();
1648   Standard_Real RF = RealFirst ();
1649
1650   Standard_Real XTMin, YTMin, ZTMin, XTMax, YTMax, ZTMax, U, V, W;
1651
1652   MinMaxCoord (XTMin, YTMin, ZTMin, XTMax, YTMax, ZTMax);
1653   if ((XTMin == RF) && (YTMin == RF) &&
1654       (ZTMin == RF) && (XTMax == RL) &&
1655       (YTMax == RL) && (ZTMax == RL)) {
1656       // Case impossible as it would mean that
1657       // the structure is empty
1658       XMin = RF;
1659       YMin = RF;
1660       ZMin = RF;
1661
1662       XMax = RL;
1663       YMax = RL;
1664       ZMax = RL;
1665     }
1666   else {
1667     Standard_Integer i, j;
1668     TColStd_Array2OfReal TheTrsf (0, 3, 0, 3);
1669
1670     for (i=0; i<=3; i++)
1671       for (j=0; j<=3; j++)
1672         TheTrsf (i, j) = MyCStructure.Transformation[i][j];
1673
1674     Graphic3d_Structure::Transforms
1675       (TheTrsf, XTMin, YTMin, ZTMin, XMin, YMin, ZMin);
1676     Graphic3d_Structure::Transforms
1677       (TheTrsf, XTMax, YTMax, ZTMax, XMax, YMax, ZMax);
1678     Graphic3d_Structure::Transforms
1679       (TheTrsf, XTMin, YTMin, ZTMax, U, V, W);
1680     XMin = Min(U,XMin) ; XMax = Max(U,XMax) ;
1681     YMin = Min(V,YMin) ; YMax = Max(V,YMax) ;
1682     ZMin = Min(W,ZMin) ; ZMax = Max(W,ZMax) ;
1683     Graphic3d_Structure::Transforms
1684       (TheTrsf, XTMax, YTMin, ZTMax, U, V, W);
1685     XMin = Min(U,XMin) ; XMax = Max(U,XMax) ;
1686     YMin = Min(V,YMin) ; YMax = Max(V,YMax) ;
1687     ZMin = Min(W,ZMin) ; ZMax = Max(W,ZMax) ;
1688     Graphic3d_Structure::Transforms
1689       (TheTrsf, XTMax, YTMin, ZTMin, U, V, W);
1690     XMin = Min(U,XMin) ; XMax = Max(U,XMax) ;
1691     YMin = Min(V,YMin) ; YMax = Max(V,YMax) ;
1692     ZMin = Min(W,ZMin) ; ZMax = Max(W,ZMax) ;
1693     Graphic3d_Structure::Transforms
1694       (TheTrsf, XTMax, YTMax, ZTMin, U, V, W);
1695     XMin = Min(U,XMin) ; XMax = Max(U,XMax) ;
1696     YMin = Min(V,YMin) ; YMax = Max(V,YMax) ;
1697     ZMin = Min(W,ZMin) ; ZMax = Max(W,ZMax) ;
1698     Graphic3d_Structure::Transforms
1699       (TheTrsf, XTMin, YTMax, ZTMax, U, V, W);
1700     XMin = Min(U,XMin) ; XMax = Max(U,XMax) ;
1701     YMin = Min(V,YMin) ; YMax = Max(V,YMax) ;
1702     ZMin = Min(W,ZMin) ; ZMax = Max(W,ZMax) ;
1703     Graphic3d_Structure::Transforms
1704       (TheTrsf, XTMin, YTMax, ZTMin, U, V, W);
1705     XMin = Min(U,XMin) ; XMax = Max(U,XMax) ;
1706     YMin = Min(V,YMin) ; YMax = Max(V,YMax) ;
1707     ZMin = Min(W,ZMin) ; ZMax = Max(W,ZMax) ;
1708   }
1709 }
1710
1711 Standard_Integer Graphic3d_Structure::Identification () const {
1712
1713   Standard_Integer Result = MyCStructure.Id;
1714
1715   return Result;
1716
1717 }
1718
1719 void Graphic3d_Structure::SetTransformPersistence( const Graphic3d_TransModeFlags& AFlag )
1720 {
1721   SetTransformPersistence( AFlag, gp_Pnt( 0, 0, 0 ) );
1722 }
1723
1724 void Graphic3d_Structure::SetTransformPersistence( const Graphic3d_TransModeFlags& AFlag,
1725                                                   const gp_Pnt& APoint )
1726 {
1727   if (IsDeleted ()) return;
1728
1729   MyCStructure.TransformPersistence.Flag = AFlag;
1730   MyCStructure.TransformPersistence.Point.x = float (APoint.X());
1731   MyCStructure.TransformPersistence.Point.y = float (APoint.Y());
1732   MyCStructure.TransformPersistence.Point.z = float (APoint.Z());
1733   //MyStructureManager->Update ();
1734   //Update();
1735   MyGraphicDriver->ContextStructure( MyCStructure );
1736
1737   MyCStructure.TransformPersistence.IsSet = 1;
1738 }
1739
1740 Graphic3d_TransModeFlags Graphic3d_Structure::TransformPersistenceMode() const
1741 {
1742   return MyCStructure.TransformPersistence.Flag;
1743 }
1744
1745 gp_Pnt Graphic3d_Structure::TransformPersistencePoint() const
1746 {
1747   gp_Pnt aPnt( 0., 0., 0. );
1748   aPnt.SetX( MyCStructure.TransformPersistence.Point.x );
1749   aPnt.SetY( MyCStructure.TransformPersistence.Point.y );
1750   aPnt.SetZ( MyCStructure.TransformPersistence.Point.z );
1751
1752   return aPnt;
1753 }
1754
1755 void Graphic3d_Structure::Add (const Handle(Graphic3d_Group)& AGroup) {
1756
1757   // Method called only by the constructor of Graphic3d_Group
1758   // It is easy to check presence of <AGroup>
1759   // in sequence MyGroups.
1760   MyGroups.Append (AGroup);
1761
1762 }
1763
1764 void Graphic3d_Structure::Remove (const Standard_Address APtr, const Graphic3d_TypeOfConnection AType) {
1765
1766   Standard_Integer i, index, length;
1767
1768   switch (AType)
1769   {
1770   case Graphic3d_TOC_DESCENDANT :
1771     index   = 0;
1772     length  = MyDescendants.Length ();
1773     for (i=1; i<=length && index==0; i++)
1774       if ((void *) (MyDescendants.Value (i)) == APtr)
1775         index   = i;
1776     if (index != 0)
1777       MyDescendants.Remove (index);
1778 #ifdef TRACE
1779     else
1780       cout << "Error, Graphic3d_Structure::Remove\n";
1781 #endif
1782     break;
1783
1784   case Graphic3d_TOC_ANCESTOR :
1785     index   = 0;
1786     length  = MyAncestors.Length ();
1787     for (i=1; i<=length && index==0; i++)
1788       if ((void *) (MyAncestors.Value (i)) == APtr)
1789         index   = i;
1790     if (index != 0)
1791       MyAncestors.Remove (index);
1792 #ifdef TRACE
1793     else
1794       cout << "Error, Graphic3d_Structure::Remove\n";
1795 #endif
1796     break;
1797   }
1798
1799 }
1800
1801 void Graphic3d_Structure::Remove (const Handle(Graphic3d_Group)& AGroup) {
1802
1803   const Standard_Integer Length = MyGroups.Length ();
1804   // Search in Groups
1805   for (Standard_Integer i=1; i<=Length; i++)
1806     if (MyGroups.Value (i) == AGroup)
1807     {
1808       MyGroups.Remove (i);
1809       return;
1810     }
1811 }
1812
1813 Handle(Graphic3d_StructureManager) Graphic3d_Structure::StructureManager () const {
1814
1815 #ifdef DOWNCAST
1816   return
1817     (Handle(Graphic3d_StructureManager)::DownCast(Handle(Standard_Transient)
1818     ((Standard_Transient*) MyPtrStructureManager)));
1819 #else
1820   return MyStructureManager;
1821 #endif
1822
1823 }
1824
1825
1826 void Graphic3d_Structure::MinMaxCoord (Standard_Real& XMin, Standard_Real& YMin, Standard_Real& ZMin, Standard_Real& XMax, Standard_Real& YMax, Standard_Real& ZMax) const {
1827
1828   Standard_Real RL = RealLast ();
1829   Standard_Real RF = RealFirst ();
1830
1831   Standard_Real Xm, Ym, Zm, XM, YM, ZM;
1832
1833   //Bounding borders of infinite line has been calculated as own point
1834   //in center of this line
1835   if (IsEmpty () || IsInfinite ()) {
1836     if( IsInfinite ()){
1837       for (int i=1; i<=MyGroups.Length (); i++)
1838         if (! (MyGroups.Value (i))->IsEmpty () ) {
1839           (MyGroups.Value (i))->MinMaxValues(Xm, Ym, Zm, XM, YM, ZM);
1840           Graphic3d_Vertex vertex1(Xm, Ym, Zm);
1841           Graphic3d_Vertex vertex2(XM, YM, ZM);
1842           const Standard_Real distance = vertex1.Distance( vertex2 );
1843           if( distance >= 500000.0){
1844             XMin = XMax = 0.5*(Xm+ XM);
1845             YMin = YMax = 0.5*(Ym+ YM);
1846             ZMin = ZMax = 0.5*(Zm+ ZM);
1847             return;
1848           }
1849         }
1850     }
1851     XMin = RF;
1852     YMin = RF;
1853     ZMin = RF;
1854
1855     XMax = RL;
1856     YMax = RL;
1857     ZMax = RL;
1858   }
1859   else {
1860     XMin = RL;
1861     YMin = RL;
1862     ZMin = RL;
1863
1864     XMax = RF;
1865     YMax = RF;
1866     ZMax = RF;
1867     Standard_Integer i, Length;
1868
1869     Length  = MyGroups.Length ();
1870     for (i=1; i<=Length; i++)
1871       if (! (MyGroups.Value (i))->IsEmpty () ) {
1872         (MyGroups.Value (i))->MinMaxValues(Xm, Ym, Zm, XM, YM, ZM);
1873         if (Xm < XMin) XMin = Xm;
1874         if (Ym < YMin) YMin = Ym;
1875         if (Zm < ZMin) ZMin = Zm;
1876         if (XM > XMax) XMax = XM;
1877         if (YM > YMax) YMax = YM;
1878         if (ZM > ZMax) ZMax = ZM;
1879       }
1880
1881       Length  = MyDescendants.Length ();
1882       for (i=1; i<=Length; i++)
1883         if (! ((Graphic3d_Structure *)
1884           (MyDescendants.Value (i)))->IsEmpty () ) {
1885             ((Graphic3d_Structure *)
1886               (MyDescendants.Value (i)))->MinMaxValues (Xm, Ym, Zm, XM, YM, ZM);
1887
1888             if (Xm < XMin) XMin = Xm;
1889             if (Ym < YMin) YMin = Ym;
1890             if (Zm < ZMin) ZMin = Zm;
1891             if (XM > XMax) XMax = XM;
1892             if (YM > YMax) YMax = YM;
1893             if (ZM > ZMax) ZMax = ZM;
1894           }
1895
1896           if ((XMin == RL) && (YMin == RL) &&
1897               (ZMin == RL) && (XMax == RF) &&
1898               (YMax == RF) && (ZMax == RF)) {
1899               // Case impossible as it would mean
1900               // that the structure is empty
1901               XMin    = RF;
1902               YMin    = RF;
1903               ZMin    = RF;
1904
1905               XMax    = RL;
1906               YMax    = RL;
1907               ZMax    = RL;
1908             }
1909
1910   }
1911
1912 }
1913
1914 void Graphic3d_Structure::Transforms (const TColStd_Array2OfReal& ATrsf, const Standard_Real X, const Standard_Real Y, const Standard_Real Z, Standard_Real& NewX, Standard_Real& NewY, Standard_Real& NewZ) {
1915
1916   Standard_Real A, B, C, D;
1917
1918   Standard_Real RL        = RealLast ();
1919   Standard_Real RF        = RealFirst ();
1920
1921   if ((X == RF) || (Y == RF) || (Z == RF) ||
1922     (X == RL) || (Y == RL) || (Z == RL)) {
1923       NewX    = X;
1924       NewY    = Y;
1925       NewZ    = Z;
1926     }
1927   else {
1928     A       = ATrsf (0, 0);
1929     B       = ATrsf (0, 1);
1930     C       = ATrsf (0, 2);
1931     D       = ATrsf (0, 3);
1932     NewX    = A * X + B * Y + C * Z + D;
1933     A       = ATrsf (1, 0);
1934     B       = ATrsf (1, 1);
1935     C       = ATrsf (1, 2);
1936     D       = ATrsf (1, 3);
1937     NewY    = A * X + B * Y + C * Z + D;
1938     A       = ATrsf (2, 0);
1939     B       = ATrsf (2, 1);
1940     C       = ATrsf (2, 2);
1941     D       = ATrsf (2, 3);
1942     NewZ    = A * X + B * Y + C * Z + D;
1943   }
1944
1945 }
1946
1947 Graphic3d_Vector Graphic3d_Structure::Transforms (const TColStd_Array2OfReal& ATrsf, const Graphic3d_Vector& Coord) {
1948
1949   Standard_Real NewX, NewY, NewZ;
1950   Graphic3d_Vector Result;
1951
1952   Graphic3d_Structure::Transforms
1953     (ATrsf, Coord.X (), Coord.Y (), Coord.Z (), NewX, NewY, NewZ);
1954   Result.SetCoord (NewX, NewY, NewZ);
1955
1956   return (Result);
1957
1958 }
1959
1960 Graphic3d_Vertex Graphic3d_Structure::Transforms (const TColStd_Array2OfReal& ATrsf, const Graphic3d_Vertex& Coord) {
1961
1962   Standard_Real NewX, NewY, NewZ;
1963   Graphic3d_Vertex Result;
1964
1965   Graphic3d_Structure::Transforms
1966     (ATrsf, Coord.X (), Coord.Y (), Coord.Z (), NewX, NewY, NewZ);
1967   Result.SetCoord (NewX, NewY, NewZ);
1968
1969   return (Result);
1970
1971 }
1972
1973 void Graphic3d_Structure::Network (const Handle(Graphic3d_Structure)& AStructure, const Graphic3d_TypeOfConnection AType, Graphic3d_MapOfStructure& ASet) {
1974
1975
1976   Graphic3d_MapOfStructure h1;
1977   Graphic3d_MapOfStructure h2;
1978   AStructure->Descendants (h1);
1979   AStructure->Ancestors (h2);
1980
1981   Graphic3d_MapIteratorOfMapOfStructure IteratorD (h1);
1982   Graphic3d_MapIteratorOfMapOfStructure IteratorA (h2);
1983
1984   ASet.Add (AStructure);
1985
1986   // exploration
1987   switch (AType)
1988   {
1989
1990   case Graphic3d_TOC_DESCENDANT :
1991     while (IteratorD.More ()) {
1992       Graphic3d_Structure::Network
1993         (IteratorD.Key (), AType, ASet);
1994       // IteratorD.Next () is located on the next structure
1995       IteratorD.Next ();
1996     }
1997     break;
1998
1999   case Graphic3d_TOC_ANCESTOR :
2000     while (IteratorA.More ()) {
2001       Graphic3d_Structure::Network
2002         (IteratorA.Key (), AType, ASet);
2003       // IteratorA.Next () is located on the next structure
2004       IteratorA.Next ();
2005     }
2006     break;
2007   }
2008
2009 }
2010
2011 void Graphic3d_Structure::PrintNetwork (const Handle(Graphic3d_Structure)& AStructure, const Graphic3d_TypeOfConnection AType)
2012 {
2013
2014   Graphic3d_MapOfStructure ASet;
2015
2016   Graphic3d_MapIteratorOfMapOfStructure IteratorASet (ASet);
2017
2018   Graphic3d_Structure::Network (AStructure, AType, ASet);
2019
2020   while (IteratorASet.More ()) {
2021     cout << "\tIdent "
2022       << (IteratorASet.Key ())->Identification () << "\n";
2023     IteratorASet.Next ();
2024   }
2025   cout << flush;
2026
2027 }
2028
2029 void Graphic3d_Structure::Update () const
2030 {
2031
2032   if (IsDeleted ()) return;
2033
2034   if (MyStructureManager->UpdateMode () == Aspect_TOU_ASAP)
2035     MyStructureManager->Update ();
2036
2037 }
2038
2039 void Graphic3d_Structure::UpdateStructure (const Handle(Graphic3d_AspectLine3d)& CTXL, const Handle(Graphic3d_AspectText3d)& CTXT, const Handle(Graphic3d_AspectMarker3d)& CTXM, const Handle(Graphic3d_AspectFillArea3d)& CTXF)
2040 {
2041
2042   Standard_Real             R, G, B;
2043   Standard_Real             Rs, Gs, Bs;
2044   Standard_CString          AFont;
2045   Standard_Real             ASpace;
2046   Standard_Real             AnExpansion;
2047   Standard_Real             AWidth;
2048   Standard_Real             AScale;
2049   Quantity_Color            AColor;
2050   Quantity_Color            AnIntColor;
2051   Quantity_Color            BackIntColor;
2052   Quantity_Color            AnEdgeColor;
2053   Aspect_TypeOfLine         ALType;
2054   Aspect_TypeOfMarker       AMType;
2055   Aspect_InteriorStyle      AStyle;
2056   Aspect_TypeOfStyleText    AStyleT;
2057   Aspect_TypeOfDisplayText  ADisplayType;
2058   Quantity_Color            AColorSubTitle;
2059   Standard_Boolean          ATextZoomable;
2060   Standard_Real             ATextAngle;
2061   Font_FontAspect            ATextFontAspect;
2062
2063
2064   CTXL->Values (AColor, ALType, AWidth);
2065   AColor.Values (R, G, B, Quantity_TOC_RGB);
2066
2067   MyCStructure.ContextLine.Color.r        = float (R);
2068   MyCStructure.ContextLine.Color.g        = float (G);
2069   MyCStructure.ContextLine.Color.b        = float (B);
2070   MyCStructure.ContextLine.LineType       = int (ALType);
2071   MyCStructure.ContextLine.Width          = float (AWidth);
2072
2073   CTXM->Values (AColor, AMType, AScale);
2074   AColor.Values (R, G, B, Quantity_TOC_RGB);
2075
2076   MyCStructure.ContextMarker.Color.r      = float (R);
2077   MyCStructure.ContextMarker.Color.g      = float (G);
2078   MyCStructure.ContextMarker.Color.b      = float (B);
2079   MyCStructure.ContextMarker.MarkerType   = AMType;
2080   MyCStructure.ContextMarker.Scale        = float (AScale);
2081
2082   CTXT->Values (AColor, AFont, AnExpansion, ASpace,AStyleT,ADisplayType,AColorSubTitle,ATextZoomable,ATextAngle,ATextFontAspect);
2083   AColor.Values (R, G, B, Quantity_TOC_RGB);
2084   AColorSubTitle.Values (Rs, Gs, Bs, Quantity_TOC_RGB);
2085
2086   MyCStructure.ContextText.Color.r          = float (R);
2087   MyCStructure.ContextText.Color.g          = float (G);
2088   MyCStructure.ContextText.Color.b          = float (B);
2089   MyCStructure.ContextText.Font             = (char*) (AFont);
2090   MyCStructure.ContextText.Expan            = float (AnExpansion);
2091   MyCStructure.ContextText.Style            = int (AStyleT);
2092   MyCStructure.ContextText.DisplayType      = int (ADisplayType);
2093   MyCStructure.ContextText.Space            = float (ASpace);
2094   MyCStructure.ContextText.ColorSubTitle.r  = float (Rs);
2095   MyCStructure.ContextText.ColorSubTitle.g  = float (Gs);
2096   MyCStructure.ContextText.ColorSubTitle.b  = float (Bs);
2097   MyCStructure.ContextText.TextZoomable     = ATextZoomable;
2098   MyCStructure.ContextText.TextAngle        = float (ATextAngle);
2099   MyCStructure.ContextText.TextFontAspect   = int (ATextFontAspect);
2100
2101
2102
2103   CTXF->Values (AStyle, AnIntColor, BackIntColor, AnEdgeColor, ALType, AWidth);
2104   AnIntColor.Values (R, G, B, Quantity_TOC_RGB);
2105
2106   MyCStructure.ContextFillArea.Style      = int (AStyle);
2107   MyCStructure.ContextFillArea.IntColor.r = float (R);
2108   MyCStructure.ContextFillArea.IntColor.g = float (G);
2109   MyCStructure.ContextFillArea.IntColor.b = float (B);
2110 #ifdef OCC1174
2111   if ( CTXF->Distinguish() )
2112     BackIntColor.Values( R, G, B, Quantity_TOC_RGB );
2113 #endif
2114   MyCStructure.ContextFillArea.BackIntColor.r     = float( R );
2115   MyCStructure.ContextFillArea.BackIntColor.g     = float( G );
2116   MyCStructure.ContextFillArea.BackIntColor.b     = float( B );
2117
2118   // Edges
2119   MyCStructure.ContextFillArea.Edge       = CTXF->Edge () ? 1:0;
2120   AnEdgeColor.Values (R, G, B, Quantity_TOC_RGB);
2121   MyCStructure.ContextFillArea.EdgeColor.r        = float (R);
2122   MyCStructure.ContextFillArea.EdgeColor.g        = float (G);
2123   MyCStructure.ContextFillArea.EdgeColor.b        = float (B);
2124   MyCStructure.ContextFillArea.LineType           = int (ALType);
2125   MyCStructure.ContextFillArea.Width              = float (AWidth);
2126   MyCStructure.ContextFillArea.Hatch              = int (CTXF->HatchStyle ());
2127
2128   /*** Front and Back face ***/
2129   MyCStructure.ContextFillArea.Distinguish = CTXF->Distinguish () ? 1:0;
2130   MyCStructure.ContextFillArea.BackFace    = CTXF->BackFace () ? 1:0;
2131   /*** Back Material ***/
2132   // Light specificity
2133   MyCStructure.ContextFillArea.Back.Shininess     =
2134     float ((CTXF->BackMaterial ()).Shininess ());
2135   MyCStructure.ContextFillArea.Back.Ambient       =
2136     float ((CTXF->BackMaterial ()).Ambient ());
2137   MyCStructure.ContextFillArea.Back.Diffuse       =
2138     float ((CTXF->BackMaterial ()).Diffuse ());
2139   MyCStructure.ContextFillArea.Back.Specular      =
2140     float ((CTXF->BackMaterial ()).Specular ());
2141   MyCStructure.ContextFillArea.Back.Transparency  =
2142     float ((CTXF->BackMaterial ()).Transparency ());
2143   MyCStructure.ContextFillArea.Back.Emission      =
2144     float ((CTXF->BackMaterial ()).Emissive ());
2145
2146   // Reflection mode
2147   MyCStructure.ContextFillArea.Back.IsAmbient     =
2148     ( (CTXF->BackMaterial ()).ReflectionMode (Graphic3d_TOR_AMBIENT) ? 1 : 0 );
2149   MyCStructure.ContextFillArea.Back.IsDiffuse     =
2150     ( (CTXF->BackMaterial ()).ReflectionMode (Graphic3d_TOR_DIFFUSE) ? 1 : 0 );
2151   MyCStructure.ContextFillArea.Back.IsSpecular    =
2152     ( (CTXF->BackMaterial ()).ReflectionMode (Graphic3d_TOR_SPECULAR) ? 1 : 0 );
2153   MyCStructure.ContextFillArea.Back.IsEmission    =
2154     ( (CTXF->BackMaterial ()).ReflectionMode (Graphic3d_TOR_EMISSION) ? 1 : 0 );
2155
2156   // Material type
2157   //JR/Hp
2158   const Graphic3d_MaterialAspect ama = CTXF->BackMaterial () ;
2159   Standard_Boolean amt = ama.MaterialType(Graphic3d_MATERIAL_PHYSIC) ;
2160   MyCStructure.ContextFillArea.Back.IsPhysic = ( amt ? 1 : 0 );
2161
2162   // Specular color
2163   MyCStructure.ContextFillArea.Back.ColorSpec.r   =
2164     float (((CTXF->BackMaterial ()).SpecularColor ()).Red ());
2165   MyCStructure.ContextFillArea.Back.ColorSpec.g   =
2166     float (((CTXF->BackMaterial ()).SpecularColor ()).Green ());
2167   MyCStructure.ContextFillArea.Back.ColorSpec.b   =
2168     float (((CTXF->BackMaterial ()).SpecularColor ()).Blue ());
2169
2170   // Ambient color
2171   MyCStructure.ContextFillArea.Back.ColorAmb.r    =
2172     float (((CTXF->BackMaterial ()).AmbientColor ()).Red ());
2173   MyCStructure.ContextFillArea.Back.ColorAmb.g    =
2174     float (((CTXF->BackMaterial ()).AmbientColor ()).Green ());
2175   MyCStructure.ContextFillArea.Back.ColorAmb.b    =
2176     float (((CTXF->BackMaterial ()).AmbientColor ()).Blue ());
2177
2178   // Diffuse color
2179   MyCStructure.ContextFillArea.Back.ColorDif.r    =
2180     float (((CTXF->BackMaterial ()).DiffuseColor ()).Red ());
2181   MyCStructure.ContextFillArea.Back.ColorDif.g    =
2182     float (((CTXF->BackMaterial ()).DiffuseColor ()).Green ());
2183   MyCStructure.ContextFillArea.Back.ColorDif.b    =
2184     float (((CTXF->BackMaterial ()).DiffuseColor ()).Blue ());
2185
2186   // Emissive color
2187   MyCStructure.ContextFillArea.Back.ColorEms.r    =
2188     float (((CTXF->BackMaterial ()).EmissiveColor ()).Red ());
2189   MyCStructure.ContextFillArea.Back.ColorEms.g    =
2190     float (((CTXF->BackMaterial ()).EmissiveColor ()).Green ());
2191   MyCStructure.ContextFillArea.Back.ColorEms.b    =
2192     float (((CTXF->BackMaterial ()).EmissiveColor ()).Blue ());
2193
2194   MyCStructure.ContextFillArea.Back.EnvReflexion =
2195     float ((CTXF->BackMaterial ()).EnvReflexion());
2196
2197   /*** Front Material ***/
2198   // Light specificity
2199   MyCStructure.ContextFillArea.Front.Shininess    =
2200     float ((CTXF->FrontMaterial ()).Shininess ());
2201   MyCStructure.ContextFillArea.Front.Ambient      =
2202     float ((CTXF->FrontMaterial ()).Ambient ());
2203   MyCStructure.ContextFillArea.Front.Diffuse      =
2204     float ((CTXF->FrontMaterial ()).Diffuse ());
2205   MyCStructure.ContextFillArea.Front.Specular     =
2206     float ((CTXF->FrontMaterial ()).Specular ());
2207   MyCStructure.ContextFillArea.Front.Transparency =
2208     float ((CTXF->FrontMaterial ()).Transparency ());
2209   MyCStructure.ContextFillArea.Front.Emission     =
2210     float ((CTXF->FrontMaterial ()).Emissive ());
2211
2212   // Reflection mode
2213   MyCStructure.ContextFillArea.Front.IsAmbient    =
2214     ( (CTXF->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_AMBIENT) ? 1 : 0 );
2215   MyCStructure.ContextFillArea.Front.IsDiffuse    =
2216     ( (CTXF->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_DIFFUSE) ? 1 : 0 );
2217   MyCStructure.ContextFillArea.Front.IsSpecular   =
2218     ( (CTXF->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_SPECULAR) ? 1 : 0 );
2219   MyCStructure.ContextFillArea.Front.IsEmission   =
2220     ( (CTXF->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_EMISSION) ? 1 : 0 );
2221
2222   // Material type
2223   //JR/Hp
2224   const Graphic3d_MaterialAspect amas = CTXF->FrontMaterial () ;
2225   Standard_Boolean amty = amas.MaterialType(Graphic3d_MATERIAL_PHYSIC) ;
2226   MyCStructure.ContextFillArea.Front.IsPhysic = ( amty ? 1 : 0 );
2227
2228   // Specular color
2229   MyCStructure.ContextFillArea.Front.ColorSpec.r  =
2230     float (((CTXF->FrontMaterial ()).SpecularColor ()).Red ());
2231   MyCStructure.ContextFillArea.Front.ColorSpec.g  =
2232     float (((CTXF->FrontMaterial ()).SpecularColor ()).Green ());
2233   MyCStructure.ContextFillArea.Front.ColorSpec.b  =
2234     float (((CTXF->FrontMaterial ()).SpecularColor ()).Blue ());
2235
2236   // Ambient color
2237   MyCStructure.ContextFillArea.Front.ColorAmb.r   =
2238     float (((CTXF->FrontMaterial ()).AmbientColor ()).Red ());
2239   MyCStructure.ContextFillArea.Front.ColorAmb.g   =
2240     float (((CTXF->FrontMaterial ()).AmbientColor ()).Green ());
2241   MyCStructure.ContextFillArea.Front.ColorAmb.b   =
2242     float (((CTXF->FrontMaterial ()).AmbientColor ()).Blue ());
2243
2244   // Diffuse color
2245   MyCStructure.ContextFillArea.Front.ColorDif.r   =
2246     float (((CTXF->FrontMaterial ()).DiffuseColor ()).Red ());
2247   MyCStructure.ContextFillArea.Front.ColorDif.g   =
2248     float (((CTXF->FrontMaterial ()).DiffuseColor ()).Green ());
2249   MyCStructure.ContextFillArea.Front.ColorDif.b   =
2250     float (((CTXF->FrontMaterial ()).DiffuseColor ()).Blue ());
2251
2252   // Emissive color
2253   MyCStructure.ContextFillArea.Front.ColorEms.r   =
2254     float (((CTXF->FrontMaterial ()).EmissiveColor ()).Red ());
2255   MyCStructure.ContextFillArea.Front.ColorEms.g   =
2256     float (((CTXF->FrontMaterial ()).EmissiveColor ()).Green ());
2257   MyCStructure.ContextFillArea.Front.ColorEms.b   =
2258     float (((CTXF->FrontMaterial ()).EmissiveColor ()).Blue ());
2259
2260   MyCStructure.ContextFillArea.Front.EnvReflexion =
2261     float ((CTXF->FrontMaterial ()).EnvReflexion());
2262
2263   MyCStructure.ContextFillArea.Texture.TextureMap   = CTXF->TextureMap();
2264   MyCStructure.ContextFillArea.Texture.doTextureMap = CTXF->TextureMapState() ? 1 : 0;
2265
2266   // OCC4895 SAN 22/03/04 High-level interface for controlling polygon offsets
2267   Standard_Integer aPolyMode;
2268   Standard_ShortReal    aPolyFactor, aPolyUnits;
2269   CTXF->PolygonOffsets(aPolyMode, aPolyFactor, aPolyUnits);
2270   MyCStructure.ContextFillArea.PolygonOffsetMode   = aPolyMode;
2271   MyCStructure.ContextFillArea.PolygonOffsetFactor = (Standard_ShortReal)aPolyFactor;
2272   MyCStructure.ContextFillArea.PolygonOffsetUnits  = (Standard_ShortReal)aPolyUnits;
2273   // OCC4895 SAN 22/03/04 High-level interface for controlling polygon offsets
2274 }
2275
2276 void Graphic3d_Structure::GraphicHighlight (const Aspect_TypeOfHighlightMethod AMethod) {
2277
2278   Standard_Real XMin, YMin, ZMin, XMax, YMax, ZMax;
2279   Standard_Real R, G, B;
2280
2281   MyCStructure.highlight  = 1;
2282   MyHighlightMethod       = AMethod;
2283
2284   switch (AMethod)
2285   {
2286   case Aspect_TOHM_COLOR :
2287     MyHighlightColor.Values (R, G, B, Quantity_TOC_RGB);
2288     MyGraphicDriver->HighlightColor
2289       (MyCStructure, float (R), float (G),
2290       float (B) , Standard_True);
2291     MyGraphicDriver->NameSetStructure (MyCStructure);
2292     break;
2293   case Aspect_TOHM_BLINK :
2294     MyGraphicDriver->Blink (MyCStructure, Standard_True);
2295     MyGraphicDriver->NameSetStructure (MyCStructure);
2296     break;
2297   case Aspect_TOHM_BOUNDBOX :
2298     if (IsEmpty () || IsInfinite ()) {
2299       // Empty or infinite structure
2300       XMin = YMin = ZMin = 0.;
2301       XMax = YMax = ZMax = 0.;
2302     }
2303     else {
2304       MinMaxCoord
2305         (XMin, YMin, ZMin, XMax, YMax, ZMax);
2306     }
2307     MyCStructure.BoundBox.Pmin.x    = float (XMin);
2308     MyCStructure.BoundBox.Pmin.y    = float (YMin);
2309     MyCStructure.BoundBox.Pmin.z    = float (ZMin);
2310     MyCStructure.BoundBox.Pmax.x    = float (XMax);
2311     MyCStructure.BoundBox.Pmax.y    = float (YMax);
2312     MyCStructure.BoundBox.Pmax.z    = float (ZMax);
2313     MyHighlightColor.Values (R, G, B, Quantity_TOC_RGB);
2314     MyCStructure.BoundBox.Color.r   = float (R);
2315     MyCStructure.BoundBox.Color.g   = float (G);
2316     MyCStructure.BoundBox.Color.b   = float (B);
2317     MyGraphicDriver->BoundaryBox (MyCStructure, Standard_True);
2318     break;
2319   }
2320
2321 }
2322
2323 void Graphic3d_Structure::GraphicTransform (const TColStd_Array2OfReal& AMatrix) {
2324
2325   Standard_Integer i, j;
2326
2327   for (i=0; i<=3; i++)
2328     for (j=0; j<=3; j++)
2329       MyCStructure.Transformation[i][j] = float (AMatrix (i, j));
2330
2331   MyGraphicDriver->TransformStructure (MyCStructure);
2332
2333 }
2334
2335 void Graphic3d_Structure::GraphicUnHighlight () {
2336
2337   MyCStructure.highlight  = 0;
2338
2339   switch (MyHighlightMethod)
2340   {
2341   case Aspect_TOHM_COLOR :
2342     MyGraphicDriver->HighlightColor
2343       (MyCStructure, 0.0, 0.0, 0.0 , Standard_False);
2344     MyGraphicDriver->NameSetStructure (MyCStructure);
2345     break;
2346   case Aspect_TOHM_BLINK :
2347     MyGraphicDriver->Blink (MyCStructure, Standard_False);
2348     MyGraphicDriver->NameSetStructure (MyCStructure);
2349     break;
2350   case Aspect_TOHM_BOUNDBOX :
2351     MyGraphicDriver->BoundaryBox
2352       (MyCStructure, Standard_False);
2353     MyGraphicDriver->NameSetStructure (MyCStructure);
2354     break;
2355   }
2356
2357 }
2358
2359 Graphic3d_TypeOfStructure Graphic3d_Structure::ComputeVisual () const {
2360
2361   return (MyComputeVisual);
2362
2363 }
2364
2365 void Graphic3d_Structure::SetComputeVisual (const Graphic3d_TypeOfStructure AVisual) {
2366
2367   // The ComputeVisual is saved only if the structure is
2368   // declared TOS_ALL, TOS_WIREFRAME or TOS_SHADING.
2369   // This declaration permits to calculate
2370   // proper representation of the structure calculated by Compute
2371   // instead of passage to TOS_COMPUTED.
2372   if (AVisual != Graphic3d_TOS_COMPUTED)
2373     MyComputeVisual = AVisual;
2374
2375 }
2376
2377 void Graphic3d_Structure::Plot (const Handle(Graphic3d_Plotter)& ) {
2378
2379 }
2380
2381 void Graphic3d_Structure::SetManager (const Handle(Graphic3d_StructureManager)& AManager, 
2382                                       const Standard_Boolean 
2383                                       #ifdef IMPLEMENTED
2384                                         WithPropagation
2385                                       #endif
2386                                       )
2387
2388 {
2389   // All connected structures should follow ?
2390 #ifdef IMPLEMENTED
2391   if (WithPropagation) {
2392     Standard_Integer i, Length;
2393     Length  = MyDescendants.Length ();
2394     for (i=1; i<=Length; i++)
2395       ((Graphic3d_Structure *)
2396       (MyDescendants.Value (i)))->SetStructureManager (AManager);
2397
2398     Length  = MyAncestors.Length ();
2399     for (i=1; i<=Length; i++)
2400       ((Graphic3d_Structure *)
2401       (MyAncestors.Value (i)))->SetStructureManager (AManager);
2402   }
2403 #endif
2404
2405   // change of identification ?
2406   // MyStructureManager->Remove (Standard_Integer (MyCStructure.Id));
2407   // AManager->NewIdentification ();
2408   // MyCStructure.Id      = int (AManager->NewIdentification ());
2409
2410   Aspect_TypeOfUpdate UpdateMode = MyStructureManager->UpdateMode ();
2411   Aspect_TypeOfUpdate NewUpdateMode = AManager->UpdateMode ();
2412   MyStructureManager->SetUpdateMode (Aspect_TOU_WAIT);
2413   AManager->SetUpdateMode (Aspect_TOU_WAIT);
2414
2415   if (MyCStructure.stick) {
2416     MyStructureManager->Erase (this);
2417     AManager->Display (this);
2418   }
2419
2420   if (MyCStructure.highlight) {
2421   }
2422
2423   if (MyCStructure.visible) {
2424     MyStructureManager->Invisible (this);
2425     AManager->Visible (this);
2426   }
2427
2428   if (MyCStructure.pick) {
2429     MyStructureManager->Undetectable (this);
2430     AManager->Detectable (this);
2431   }
2432
2433   MyStructureManager->SetUpdateMode (UpdateMode);
2434   AManager->SetUpdateMode (NewUpdateMode);
2435
2436   // New manager
2437   MyPtrStructureManager   = (void *) AManager.operator->();
2438
2439 }
2440
2441 void Graphic3d_Structure::SetHLRValidation (const Standard_Boolean AFlag) {
2442
2443   MyCStructure.HLRValidation      = AFlag ? 1:0;
2444
2445 }
2446
2447 Standard_Boolean Graphic3d_Structure::HLRValidation () const {
2448
2449   // Hidden parts stored in <me> are valid if :
2450   // 1/ the owner is defined.
2451   // 2/ they are not invalid.
2452
2453   Standard_Boolean Result = MyOwner != NULL && MyCStructure.HLRValidation != 0;
2454
2455   return Result;
2456
2457 }
2458
2459 //=======================================================================
2460 //function : CStructure
2461 //purpose  :
2462 //=======================================================================
2463
2464 Graphic3d_CStructure* Graphic3d_Structure::CStructure()
2465 {
2466   return &MyCStructure;
2467 }
2468
2469 //=======================================================================
2470 //function : SetZLayer
2471 //purpose  :
2472 //=======================================================================
2473
2474 void Graphic3d_Structure::SetZLayer (const Standard_Integer theLayerId)
2475 {
2476   // if the structure is not displayed, unable to change its display layer
2477   if (IsDeleted ())
2478     return;
2479
2480   MyStructureManager->ChangeZLayer (this, theLayerId);
2481 }
2482
2483 //=======================================================================
2484 //function : GetZLayer
2485 //purpose  :
2486 //=======================================================================
2487
2488 Standard_Integer Graphic3d_Structure::GetZLayer () const
2489 {
2490   return MyStructureManager->GetZLayer (this);
2491 }