src/Visual3d/Visual3d_View.cxx

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