src/AIS/AIS_InteractiveContext_1.cxx

   1 // Created on: 1997-01-29
   2 // Created by: Robert COUBLANC
   3 // Copyright (c) 1997-1999 Matra Datavision
   4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
   5 //
   6 // This file is part of Open CASCADE Technology software library.
   7 //
   8 // This library is free software; you can redistribute it and/or modify it under
   9 // the terms of the GNU Lesser General Public License version 2.1 as published
  10 // by the Free Software Foundation, with special exception defined in the file
  11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
  12 // distribution for complete text of the license and disclaimer of any warranty.
  13 //
  14 // Alternatively, this file may be used under the terms of Open CASCADE
  15 // commercial license or contractual agreement.
  16
  17
  18 #include <AIS_DataMapIteratorOfDataMapOfIOStatus.hxx>
  19 #include <AIS_GlobalStatus.hxx>
  20 #include <AIS_InteractiveContext.hxx>
  21 #include <AIS_InteractiveObject.hxx>
  22 #include <AIS_LocalContext.hxx>
  23 #include <AIS_MapIteratorOfMapOfInteractive.hxx>
  24 #include <AIS_MapOfInteractive.hxx>
  25 #include <AIS_Selection.hxx>
  26 #include <AIS_Shape.hxx>
  27 #include <AIS_StatusOfDetection.hxx>
  28 #include <AIS_StatusOfPick.hxx>
  29 #include <Aspect_Grid.hxx>
  30 #include <Prs3d_BasicAspect.hxx>
  31 #include <Prs3d_LineAspect.hxx>
  32 #include <Prs3d_Presentation.hxx>
  33 #include <Quantity_Color.hxx>
  34 #include <SelectBasics_SensitiveEntity.hxx>
  35 #include <SelectMgr_EntityOwner.hxx>
  36 #include <SelectMgr_Filter.hxx>
  37 #include <SelectMgr_OrFilter.hxx>
  38 #include <SelectMgr_Selection.hxx>
  39 #include <SelectMgr_SelectionManager.hxx>
  40 #include <Standard_Transient.hxx>
  41 #include <StdSelect_BRepOwner.hxx>
  42 #include <StdSelect_ViewerSelector3d.hxx>
  43 #include <TCollection_AsciiString.hxx>
  44 #include <TCollection_ExtendedString.hxx>
  45 #include <TColStd_ListIteratorOfListOfInteger.hxx>
  46 #include <TopLoc_Location.hxx>
  47 #include <TopoDS_Shape.hxx>
  48 #include <V3d_AmbientLight.hxx>
  49 #include <V3d_DirectionalLight.hxx>
  50 #include <V3d_Light.hxx>
  51 #include <V3d_PositionalLight.hxx>
  52 #include <V3d_SpotLight.hxx>
  53 #include <V3d_View.hxx>
  54 #include <V3d_Viewer.hxx>
  55
  56 typedef NCollection_DataMap<Handle(AIS_InteractiveObject), NCollection_Handle<SelectMgr_SequenceOfOwner> > AIS_MapOfObjSelectedOwners;
  57
  58 //=======================================================================
  59 //function : highlightWithColor
  60 //purpose  :
  61 //=======================================================================
  62 void AIS_InteractiveContext::highlightWithColor (const Handle(SelectMgr_EntityOwner)& theOwner,
  63                                                  const Quantity_NameOfColor theColor,
  64                                                  const Handle(V3d_Viewer)& theViewer)
  65 {
  66   const Handle(AIS_InteractiveObject) anObj =
  67     Handle(AIS_InteractiveObject)::DownCast (theOwner->Selectable());
  68   if (anObj.IsNull())
  69     return;
  70   const Standard_Integer aHiMode = anObj->HasHilightMode() ? anObj->HilightMode() : 0;
  71
  72   myMainPM->BeginImmediateDraw();
  73   theOwner->HilightWithColor (myMainPM, theColor, aHiMode);
  74   myMainPM->EndImmediateDraw (theViewer.IsNull() ? myMainVwr : theViewer);
  75 }
  76
  77 //=======================================================================
  78 //function : highlightSelected
  79 //purpose  :
  80 //=======================================================================
  81 void AIS_InteractiveContext::highlightSelected (const Handle(SelectMgr_EntityOwner)& theOwner,
  82                                                 const Quantity_NameOfColor theSelColor)
  83 {
  84   const Handle(AIS_InteractiveObject) anObj =
  85     Handle(AIS_InteractiveObject)::DownCast (theOwner->Selectable());
  86   if (anObj.IsNull())
  87     return;
  88   const Standard_Integer aHiMode = anObj->HasHilightMode() ? anObj->HilightMode() : 0;
  89
  90   if (!theOwner->IsAutoHilight())
  91   {
  92     AIS_Selection::SetCurrentSelection (myCurrentName.ToCString());
  93     const Handle(AIS_Selection)& aCurSel = AIS_Selection::CurrentSelection();
  94     SelectMgr_SequenceOfOwner aSeq;
  95     for (aCurSel->Init(); aCurSel->More(); aCurSel->Next())
  96     {
  97       const Handle(SelectMgr_EntityOwner) aSelOwnr =
  98         Handle(SelectMgr_EntityOwner)::DownCast (aCurSel->Value());
  99       if (aSelOwnr->Selectable() != anObj)
 100         continue;
 101       aSeq.Append (aSelOwnr);
 102     }
 103     anObj->HilightSelected (myMainPM, aSeq);
 104   }
 105   else
 106   {
 107     theOwner->HilightWithColor (myMainPM, theSelColor, aHiMode);
 108   }
 109 }
 110
 111 //=======================================================================
 112 //function : unhighlightSelected
 113 //purpose  :
 114 //=======================================================================
 115 void AIS_InteractiveContext::unhighlightSelected (const Standard_Boolean theIsToHilightSubIntensity)
 116 {
 117   AIS_Selection::SetCurrentSelection (myCurrentName.ToCString());
 118   Handle(AIS_Selection) aCurSel = AIS_Selection::Selection (myCurrentName.ToCString());
 119   NCollection_IndexedMap<Handle(AIS_InteractiveObject)> anObjToClear;
 120   for (aCurSel->Init(); aCurSel->More(); aCurSel->Next())
 121   {
 122     const Handle(SelectMgr_EntityOwner) anOwner =
 123       Handle(SelectMgr_EntityOwner)::DownCast (aCurSel->Value());
 124     if (anOwner.IsNull() || !anOwner->HasSelectable())
 125       continue;
 126
 127     const Handle(AIS_InteractiveObject) anInteractive =
 128       Handle(AIS_InteractiveObject)::DownCast (anOwner->Selectable());
 129     if (anOwner->IsAutoHilight())
 130     {
 131       const Standard_Integer aHiMode = anInteractive->HasHilightMode() ? anInteractive->HilightMode() : 0;
 132       anOwner->Unhilight (myMainPM, aHiMode);
 133       if (theIsToHilightSubIntensity)
 134       {
 135         if (myObjects.IsBound (anInteractive) && myObjects (anInteractive)->IsSubIntensityOn())
 136         {
 137           anOwner->HilightWithColor (myMainPM, mySubIntensity, aHiMode);
 138         }
 139       }
 140     }
 141     else
 142     {
 143       if (!anObjToClear.Contains (anInteractive))
 144         anObjToClear.Add (anInteractive);
 145     }
 146     anOwner->State (0);
 147     if (anOwner == anInteractive->GlobalSelOwner())
 148     {
 149       myObjects.ChangeFind (anInteractive)->SetHilightStatus (Standard_False);
 150     }
 151   }
 152   for (NCollection_IndexedMap<Handle(AIS_InteractiveObject)>::Iterator anIter (anObjToClear); anIter.More(); anIter.Next())
 153   {
 154     const Handle(AIS_InteractiveObject)& anObj = anIter.Value();
 155     const Standard_Integer aHiMode = anObj->HasHilightMode() ? anObj->HilightMode() : 0;
 156     myMainPM->Unhighlight (anObj, aHiMode);
 157     anObj->ClearSelected();
 158   }
 159 }
 160
 161 //=======================================================================
 162 //function : MoveTo
 163 //purpose  :
 164 //=======================================================================
 165 AIS_StatusOfDetection AIS_InteractiveContext::MoveTo (const Standard_Integer  theXPix,
 166                                                       const Standard_Integer  theYPix,
 167                                                       const Handle(V3d_View)& theView,
 168                                                       const Standard_Boolean  theToRedrawOnUpdate)
 169 {
 170   if (HasOpenedContext())
 171   {
 172     myWasLastMain = Standard_True;
 173     return myLocalContexts (myCurLocalIndex)->MoveTo (theXPix, theYPix, theView, theToRedrawOnUpdate);
 174   }
 175
 176   myAISCurDetected = 0;
 177   myAISDetectedSeq.Clear();
 178
 179   if (theView->Viewer() != myMainVwr)
 180   {
 181     return AIS_SOD_Error;
 182   }
 183
 184   // preliminaires
 185   myLastPicked  = myLastinMain;
 186   myWasLastMain = Standard_True;
 187   AIS_StatusOfDetection aStatus        = AIS_SOD_Nothing;
 188   Standard_Boolean      toUpdateViewer = Standard_False;
 189
 190   myFilters->SetDisabledObjects (theView->View()->HiddenObjects());
 191   myMainSel->Pick (theXPix, theYPix, theView);
 192
 193   // filling of myAISDetectedSeq sequence storing information about detected AIS objects
 194   // (the objects must be AIS_Shapes)
 195   const Standard_Integer aDetectedNb = myMainSel->NbPicked();
 196   Standard_Integer aNewDetected = 0;
 197   for (Standard_Integer aDetIter = 1; aDetIter <= aDetectedNb; ++aDetIter)
 198   {
 199     Handle(SelectMgr_EntityOwner) anOwner = myMainSel->Picked (aDetIter);
 200     if (anOwner.IsNull()
 201      || !myFilters->IsOk (anOwner))
 202     {
 203       continue;
 204     }
 205
 206     if (aNewDetected < 1)
 207     {
 208       aNewDetected = aDetIter;
 209     }
 210     Handle(AIS_InteractiveObject) anObj = Handle(AIS_InteractiveObject)::DownCast (anOwner->Selectable());
 211     if (!anObj.IsNull())
 212     {
 213       myAISDetectedSeq.Append (anObj);
 214     }
 215   }
 216
 217   if (aNewDetected >= 1)
 218   {
 219     // does nothing if previously detected object is equal to the current one
 220     Handle(SelectMgr_EntityOwner) aNewPickedOwner = myMainSel->Picked (aNewDetected);
 221     if (aNewPickedOwner == myLastPicked)
 222     {
 223       return myLastPicked->IsSelected()
 224            ? AIS_SOD_Selected
 225            : AIS_SOD_OnlyOneDetected;
 226     }
 227
 228     // Previously detected object is unhilighted if it is not selected or hilighted
 229     // with selection color if it is selected. Such highlighting with selection color
 230     // is needed only if myToHilightSelected flag is true. In this case previously detected
 231     // object has been already highlighted with myHilightColor during previous MoveTo()
 232     // method call. As result it is necessary to rehighligt it with mySelectionColor.
 233     if (!myLastPicked.IsNull() && myLastPicked->HasSelectable())
 234     {
 235       myMainPM->ClearImmediateDraw();
 236       const Handle(AIS_InteractiveObject) aLastPickedAIS = Handle(AIS_InteractiveObject)::DownCast (myLastPicked->Selectable());
 237       const Standard_Integer aHiMod = aLastPickedAIS->HasHilightMode() ? aLastPickedAIS->HilightMode() : 0;
 238       if (!myLastPicked->IsSelected())
 239       {
 240         myLastPicked->Unhilight (myMainPM, aHiMod);
 241         toUpdateViewer = Standard_True;
 242       }
 243       else if (myToHilightSelected)
 244       {
 245         highlightWithColor (aNewPickedOwner, mySelectionColor, theView->Viewer());
 246         toUpdateViewer = Standard_True;
 247       }
 248     }
 249
 250     // initialize myLastPicked field with currently detected object
 251     myLastPicked = aNewPickedOwner;
 252     myLastinMain = myLastPicked;
 253
 254     // highlight detected object if it is not selected or myToHilightSelected flag is true
 255     if (myLastPicked->HasSelectable())
 256     {
 257       if (!myLastPicked->IsSelected() || myToHilightSelected)
 258       {
 259         highlightWithColor (myLastPicked, myHilightColor, theView->Viewer());
 260         toUpdateViewer = Standard_True;
 261       }
 262
 263       aStatus = myLastPicked->IsSelected()
 264               ? AIS_SOD_Selected
 265               : AIS_SOD_OnlyOneDetected;
 266     }
 267   }
 268   else
 269   {
 270     // previously detected object is unhilighted if it is not selected or hilighted
 271     // with selection color if it is selected
 272     aStatus = AIS_SOD_Nothing;
 273     if (!myLastPicked.IsNull() && myLastPicked->HasSelectable())
 274     {
 275       myMainPM->ClearImmediateDraw();
 276       const Handle(AIS_InteractiveObject) aLastPickedAIS = Handle(AIS_InteractiveObject)::DownCast (myLastPicked->Selectable());
 277       Standard_Integer aHiMod = aLastPickedAIS->HasHilightMode() ? aLastPickedAIS->HilightMode() : 0;
 278       if (!myLastPicked->IsSelected())
 279       {
 280         if (myLastPicked->IsAutoHilight())
 281         {
 282           myLastPicked->Unhilight (myMainPM, aHiMod);
 283         }
 284         toUpdateViewer = Standard_True;
 285       }
 286       else if (myToHilightSelected)
 287       {
 288         highlightSelected (myLastPicked, mySelectionColor);
 289         toUpdateViewer = Standard_True;
 290       }
 291     }
 292
 293     myLastinMain.Nullify();
 294     myLastPicked.Nullify();
 295   }
 296
 297   if (toUpdateViewer
 298    && theToRedrawOnUpdate)
 299   {
 300     theView->Viewer()->Update();
 301   }
 302
 303   mylastmoveview = theView;
 304   return aStatus;
 305 }
 306
 307 //=======================================================================
 308 //function : Select
 309 //purpose  :
 310 //=======================================================================
 311 AIS_StatusOfPick AIS_InteractiveContext::Select (const Standard_Integer  theXPMin,
 312                                                  const Standard_Integer  theYPMin,
 313                                                  const Standard_Integer  theXPMax,
 314                                                  const Standard_Integer  theYPMax,
 315                                                  const Handle(V3d_View)& theView,
 316                                                  const Standard_Boolean  toUpdateViewer)
 317 {
 318   // all objects detected by the selector are taken, previous current objects are emptied,
 319   // new objects are put...
 320
 321   if (HasOpenedContext())
 322   {
 323     return myLocalContexts(myCurLocalIndex)->Select (theXPMin, theYPMin,
 324                                                      theXPMax, theYPMax,
 325                                                      theView, toUpdateViewer);
 326   }
 327
 328   ClearSelected (Standard_False);
 329
 330   Handle(StdSelect_ViewerSelector3d) aSelector;
 331
 332   if (theView->Viewer() == myMainVwr)
 333   {
 334     aSelector = myMainSel;
 335     myWasLastMain = Standard_True;
 336   }
 337
 338   aSelector->Pick (theXPMin, theYPMin, theXPMax, theYPMax, theView);
 339   AIS_Selection::SetCurrentSelection (myCurrentName.ToCString());
 340
 341   for (aSelector->Init(); aSelector->More(); aSelector->Next())
 342   {
 343     const Handle(SelectMgr_EntityOwner)& aCurOwner = aSelector->Picked();
 344     if (aCurOwner.IsNull() || !aCurOwner->HasSelectable() || !myFilters->IsOk (aCurOwner))
 345       continue;
 346
 347     AIS_Selection::Select (aCurOwner);
 348     aCurOwner->State (1);
 349   }
 350
 351   HilightSelected (toUpdateViewer);
 352
 353   Standard_Integer aSelNum = NbSelected();
 354
 355   return (aSelNum == 0) ? AIS_SOP_NothingSelected
 356                         : (aSelNum == 1) ? AIS_SOP_OneSelected
 357                                          : AIS_SOP_SeveralSelected;
 358
 359 }
 360
 361 //=======================================================================
 362 //function : Select
 363 //purpose  : Selection by polyline
 364 //=======================================================================
 365 AIS_StatusOfPick AIS_InteractiveContext::Select (const TColgp_Array1OfPnt2d& thePolyline,
 366                                                  const Handle(V3d_View)&     theView,
 367                                                  const Standard_Boolean      toUpdateViewer)
 368 {
 369   // all objects detected by the selector are taken, previous current objects are emptied,
 370   // new objects are put...
 371
 372   if (HasOpenedContext())
 373   {
 374     return myLocalContexts(myCurLocalIndex)->Select (thePolyline, theView, toUpdateViewer);
 375   }
 376
 377   ClearSelected (Standard_False);
 378
 379   Handle(StdSelect_ViewerSelector3d) aSelector;
 380
 381   if (theView->Viewer() == myMainVwr)
 382   {
 383     aSelector = myMainSel;
 384     myWasLastMain = Standard_True;
 385   }
 386
 387   aSelector->Pick (thePolyline, theView);
 388   AIS_Selection::SetCurrentSelection (myCurrentName.ToCString());
 389
 390   for (aSelector->Init(); aSelector->More(); aSelector->Next())
 391   {
 392     const Handle(SelectMgr_EntityOwner) anOwner = aSelector->Picked();
 393     if (anOwner.IsNull() || !anOwner->HasSelectable() || !myFilters->IsOk (anOwner))
 394       continue;
 395
 396     AIS_Selection::Select (anOwner);
 397     anOwner->State (1);
 398   }
 399
 400   HilightSelected (toUpdateViewer);
 401
 402   Standard_Integer aSelNum = NbSelected();
 403
 404   return (aSelNum == 0) ? AIS_SOP_NothingSelected
 405                         : (aSelNum == 1) ? AIS_SOP_OneSelected
 406                                          : AIS_SOP_SeveralSelected;
 407
 408 }
 409
 410 //=======================================================================
 411 //function : Select
 412 //purpose  :
 413 //=======================================================================
 414 AIS_StatusOfPick AIS_InteractiveContext::Select (const Standard_Boolean toUpdateViewer)
 415 {
 416   if (HasOpenedContext())
 417   {
 418     if(myWasLastMain)
 419     {
 420       return myLocalContexts(myCurLocalIndex)->Select (toUpdateViewer);
 421     }
 422     else
 423     {
 424       myLocalContexts(myCurLocalIndex)->SetSelected (Handle(AIS_InteractiveObject)::DownCast (myLastPicked->Selectable()), toUpdateViewer);
 425       return AIS_SOP_OneSelected;
 426     }
 427   }
 428
 429   myMainPM->ClearImmediateDraw();
 430   if (myWasLastMain && !myLastinMain.IsNull())
 431   {
 432     if(!myLastinMain->IsSelected())
 433     {
 434       SetSelected (myLastinMain, Standard_False);
 435       if(toUpdateViewer)
 436       {
 437         UpdateCurrentViewer();
 438       }
 439     }
 440   }
 441   else
 442   {
 443     unhighlightSelected (Standard_True);
 444
 445     AIS_Selection::Select();
 446     if (toUpdateViewer && myWasLastMain)
 447     {
 448         UpdateCurrentViewer();
 449     }
 450   }
 451
 452   Standard_Integer aSelNum = NbSelected();
 453
 454   return (aSelNum == 0) ? AIS_SOP_NothingSelected
 455                         : (aSelNum == 1) ? AIS_SOP_OneSelected
 456                                          : AIS_SOP_SeveralSelected;
 457 }
 458
 459 //=======================================================================
 460 //function : ShiftSelect
 461 //purpose  :
 462 //=======================================================================
 463 AIS_StatusOfPick AIS_InteractiveContext::ShiftSelect (const Standard_Boolean toUpdateViewer)
 464 {
 465   if (HasOpenedContext())
 466   {
 467     if(myWasLastMain)
 468     {
 469       return myLocalContexts (myCurLocalIndex)->ShiftSelect (toUpdateViewer);
 470     }
 471     else
 472     {
 473       myLocalContexts (myCurLocalIndex)->AddOrRemoveSelected (myLastPicked, toUpdateViewer);
 474
 475       Standard_Integer aSelNum = NbSelected();
 476       return (aSelNum == 0) ? AIS_SOP_NothingSelected
 477                             : (aSelNum == 1) ? AIS_SOP_OneSelected
 478                                              : AIS_SOP_SeveralSelected;
 479     }
 480   }
 481
 482   myMainPM->ClearImmediateDraw();
 483   if (myWasLastMain && !myLastinMain.IsNull())
 484   {
 485     AddOrRemoveSelected (myLastinMain, toUpdateViewer);
 486   }
 487
 488   Standard_Integer aSelNum = NbSelected();
 489
 490   return (aSelNum == 0) ? AIS_SOP_NothingSelected
 491                         : (aSelNum == 1) ? AIS_SOP_OneSelected
 492                         : AIS_SOP_SeveralSelected;
 493 }
 494
 495 //=======================================================================
 496 //function : ShiftSelect
 497 //purpose  :
 498 //=======================================================================
 499 AIS_StatusOfPick AIS_InteractiveContext::ShiftSelect (const Standard_Integer theXPMin,
 500                                                       const Standard_Integer theYPMin,
 501                                                       const Standard_Integer theXPMax,
 502                                                       const Standard_Integer theYPMax,
 503                                                       const Handle(V3d_View)& theView,
 504                                                       const Standard_Boolean toUpdateViewer)
 505 {
 506   if (HasOpenedContext())
 507   {
 508     return myLocalContexts(myCurLocalIndex)->ShiftSelect (theXPMin, theYPMin, theXPMax, theYPMax,
 509                                                           theView, toUpdateViewer);
 510   }
 511
 512   UnhilightSelected (Standard_False);
 513
 514   Handle(StdSelect_ViewerSelector3d) aSelector;
 515   if (theView->Viewer() == myMainVwr)
 516   {
 517     aSelector = myMainSel;
 518     myWasLastMain = Standard_True;
 519   }
 520   else
 521   {
 522     return AIS_SOP_NothingSelected;
 523   }
 524
 525   aSelector->Pick (theXPMin, theYPMin, theXPMax, theYPMax, theView);
 526   AIS_Selection::SetCurrentSelection (myCurrentName.ToCString());
 527   for (aSelector->Init(); aSelector->More(); aSelector->Next())
 528   {
 529     const Handle(SelectMgr_EntityOwner) anOwner = aSelector->Picked();
 530     if (anOwner.IsNull() || !anOwner->HasSelectable() || !myFilters->IsOk (anOwner))
 531       continue;
 532
 533     AIS_SelectStatus aSelStatus = AIS_Selection::Select (anOwner);
 534     Standard_Integer aState = (aSelStatus == AIS_SS_Added) ? 1 : 0;
 535     anOwner->State (aState);
 536   }
 537
 538   HilightSelected (toUpdateViewer);
 539
 540   Standard_Integer aSelNum = NbSelected();
 541
 542   return (aSelNum == 0) ? AIS_SOP_NothingSelected
 543                         : (aSelNum == 1) ? AIS_SOP_OneSelected
 544                                          : AIS_SOP_SeveralSelected;
 545
 546 }
 547
 548 //=======================================================================
 549 //function : ShiftSelect
 550 //purpose  :
 551 //=======================================================================
 552 AIS_StatusOfPick AIS_InteractiveContext::ShiftSelect (const TColgp_Array1OfPnt2d& thePolyline,
 553                                                       const Handle(V3d_View)& theView,
 554                                                       const Standard_Boolean toUpdateViewer)
 555 {
 556   if (HasOpenedContext())
 557   {
 558     return myLocalContexts(myCurLocalIndex)->ShiftSelect (thePolyline, theView, toUpdateViewer);
 559   }
 560
 561   UnhilightSelected (Standard_False);
 562
 563   Handle(StdSelect_ViewerSelector3d) aSelector;
 564
 565   if (theView->Viewer() == myMainVwr)
 566   {
 567     aSelector= myMainSel;
 568     myWasLastMain = Standard_True;
 569   }
 570   else
 571   {
 572     return AIS_SOP_NothingSelected;
 573   }
 574
 575   aSelector->Pick (thePolyline, theView);
 576
 577   AIS_Selection::SetCurrentSelection (myCurrentName.ToCString());
 578   for (aSelector->Init(); aSelector->More(); aSelector->Next())
 579   {
 580     const Handle(SelectMgr_EntityOwner) anOwner = aSelector->Picked();
 581     if (anOwner.IsNull() || !anOwner->HasSelectable() || !myFilters->IsOk (anOwner))
 582       continue;
 583
 584     AIS_SelectStatus aSelStatus = AIS_Selection::Select (anOwner);
 585     Standard_Integer aState = (aSelStatus == AIS_SS_Added) ? 1 : 0;
 586     anOwner->State (aState);
 587   }
 588
 589   HilightSelected (toUpdateViewer);
 590
 591   Standard_Integer aSelNum = NbSelected();
 592
 593   return (aSelNum == 0) ? AIS_SOP_NothingSelected
 594                         : (aSelNum == 1) ? AIS_SOP_OneSelected
 595                                          : AIS_SOP_SeveralSelected;
 596 }
 597
 598 //=======================================================================
 599 //function : SetCurrentObject
 600 //purpose  : OBSOLETE, please use SetSelected() instead
 601 //TODO     : Remove in process of local context deletion
 602 //=======================================================================
 603 void AIS_InteractiveContext::SetCurrentObject (const Handle(AIS_InteractiveObject)& theObject,
 604                                                const Standard_Boolean theToUpdateViewer)
 605 {
 606   if (HasOpenedContext())
 607     return;
 608
 609   SetSelected (theObject, theToUpdateViewer);
 610 }
 611
 612 //=======================================================================
 613 //function : AddOrRemoveCurrentObject
 614 //purpose  : OBSOLETE, please use AddOrRemoveSelected() instead
 615 //TODO     : Remove in process of local context deletion
 616 //=======================================================================
 617 void AIS_InteractiveContext::AddOrRemoveCurrentObject (const Handle(AIS_InteractiveObject)& theObj,
 618                                                        const Standard_Boolean theIsToUpdateViewer)
 619 {
 620   if (HasOpenedContext())
 621     return;
 622
 623   AddOrRemoveSelected (theObj, theIsToUpdateViewer);
 624 }
 625 //=======================================================================
 626 //function : UpdateCurrent
 627 //purpose  : OBSOLETE, please use UpdateSelected() instead
 628 //TODO     : Remove in process of local context deletion
 629 //=======================================================================
 630 void AIS_InteractiveContext::UpdateCurrent()
 631 {
 632   UpdateSelected();
 633 }
 634
 635 //=======================================================================
 636 //function : IsCurrent
 637 //purpose  : OBSOLETE, please use IsSelected() instead
 638 //TODO     : Remove in process of local context deletion
 639 //=======================================================================
 640 Standard_Boolean AIS_InteractiveContext::IsCurrent (const Handle(AIS_InteractiveObject)& theObject) const
 641 {
 642   return IsSelected (theObject);
 643 }
 644
 645 //=======================================================================
 646 //function : InitCurrent
 647 //purpose  : OBSOLETE, please use InitSelected() instead
 648 //TODO     : Remove in process of local context deletion
 649 //=======================================================================
 650 void AIS_InteractiveContext::InitCurrent()
 651 {
 652   if (HasOpenedContext())
 653     return;
 654
 655   InitSelected();
 656 }
 657
 658 //=======================================================================
 659 //function : MoreCurrent
 660 //purpose  : OBSOLETE, please use MoreSelected() instead
 661 //TODO     : Remove in process of local context deletion
 662 //=======================================================================
 663 Standard_Boolean AIS_InteractiveContext::MoreCurrent() const
 664 {
 665   return !HasOpenedContext() && MoreSelected();
 666 }
 667
 668 //=======================================================================
 669 //function : NextCurrent
 670 //purpose  : OBSOLETE, please use NextSelected() instead
 671 //TODO     : Remove in process of local context deletion
 672 //=======================================================================
 673 void AIS_InteractiveContext::NextCurrent()
 674 {
 675   if (HasOpenedContext())
 676     return;
 677
 678   NextSelected();
 679 }
 680
 681 //=======================================================================
 682 //function : Current
 683 //purpose  : OBSOLETE, please use SelectedInteractive() instead
 684 //TODO     : Remove in process of local context deletion
 685 //=======================================================================
 686 Handle(AIS_InteractiveObject) AIS_InteractiveContext::Current() const
 687 {
 688   return HasOpenedContext() ? NULL : SelectedInteractive();
 689 }
 690
 691 //=======================================================================
 692 //function : NbCurrents
 693 //purpose  : OBSOLETE, please use NbSelected() instead
 694 //TODO     : Remove in process of local context deletion
 695 //=======================================================================
 696 Standard_Integer AIS_InteractiveContext::NbCurrents()
 697 {
 698   return HasOpenedContext() ? -1 : NbSelected();
 699 }
 700
 701 //=======================================================================
 702 //function : HilightCurrents
 703 //purpose  : OBSOLETE, please use HilightSelected() instead
 704 //TODO     : Remove in process of local context deletion
 705 //=======================================================================
 706 void AIS_InteractiveContext::HilightCurrents (const Standard_Boolean theToUpdateViewer)
 707 {
 708   if (HasOpenedContext())
 709     return;
 710
 711   HilightSelected (theToUpdateViewer);
 712 }
 713
 714 //=======================================================================
 715 //function : UnhilightCurrents
 716 //purpose  : OBSOLETE, please use UnhilightSelected() instead
 717 //TODO     : Remove in process of local context deletion
 718 //=======================================================================
 719 void AIS_InteractiveContext::UnhilightCurrents (const Standard_Boolean theToUpdateViewer)
 720 {
 721   if (HasOpenedContext())
 722     return;
 723
 724   UnhilightSelected (theToUpdateViewer);
 725 }
 726
 727 //=======================================================================
 728 //function : ClearCurrents
 729 //purpose  : OBSOLETE, please use ClearCurrents() instead
 730 //TODO     : Remove in process of local context deletion
 731 //=======================================================================
 732 void AIS_InteractiveContext::ClearCurrents(const Standard_Boolean theToUpdateViewer)
 733 {
 734   if (HasOpenedContext())
 735     return;
 736
 737   ClearSelected (theToUpdateViewer);
 738 }
 739
 740
 741 //=======================================================================
 742 //function : HilightSelected
 743 //purpose  :
 744 //=======================================================================
 745 void AIS_InteractiveContext::HilightSelected (const Standard_Boolean theToUpdateViewer)
 746 {
 747   if (HasOpenedContext())
 748   {
 749     return myLocalContexts (myCurLocalIndex)->HilightPicked (theToUpdateViewer);
 750   }
 751
 752   // In case of selection without using local context
 753   myMainPM->ClearImmediateDraw();
 754   AIS_Selection::SetCurrentSelection (myCurrentName.ToCString());
 755   Handle(AIS_Selection) aSel = AIS_Selection::Selection (myCurrentName.ToCString());
 756   AIS_MapOfObjSelectedOwners anObjOwnerMap;
 757   for (aSel->Init(); aSel->More(); aSel->Next())
 758   {
 759     const Handle(SelectMgr_EntityOwner) anOwner =
 760       Handle(SelectMgr_EntityOwner)::DownCast (aSel->Value());
 761     if (!anOwner.IsNull() && anOwner->HasSelectable())
 762     {
 763       const Handle(AIS_InteractiveObject) anObj =
 764         Handle(AIS_InteractiveObject)::DownCast (anOwner->Selectable());
 765       if (anOwner == anObj->GlobalSelOwner())
 766       {
 767         Handle(AIS_GlobalStatus)& aState = myObjects.ChangeFind (anObj);
 768         aState->SetHilightStatus (Standard_True);
 769         aState->SetHilightColor (mySelectionColor);
 770       }
 771       anOwner->State (1);
 772       if (!anOwner->IsAutoHilight())
 773       {
 774         NCollection_Handle<SelectMgr_SequenceOfOwner> aSeq;
 775         if (anObjOwnerMap.Find (anObj, aSeq))
 776         {
 777           aSeq->Append (anOwner);
 778         }
 779         else
 780         {
 781           aSeq = new SelectMgr_SequenceOfOwner();
 782           aSeq->Append (anOwner);
 783           anObjOwnerMap.Bind (anObj, aSeq);
 784         }
 785       }
 786       else
 787       {
 788         const Standard_Integer aHiMode = anObj->HasHilightMode() ? anObj->HilightMode() : 0;
 789         anOwner->HilightWithColor (myMainPM, mySelectionColor, aHiMode);
 790       }
 791     }
 792   }
 793
 794   if (!anObjOwnerMap.IsEmpty())
 795   {
 796     for (AIS_MapOfObjSelectedOwners::Iterator anIter (anObjOwnerMap); anIter.More(); anIter.Next())
 797     {
 798       anIter.Key()->HilightSelected (myMainPM, *anIter.Value());
 799     }
 800     anObjOwnerMap.Clear();
 801   }
 802
 803   if (theToUpdateViewer)
 804     UpdateCurrentViewer();
 805 }
 806
 807 //=======================================================================
 808 //function : UnhilightSelected
 809 //purpose  :
 810 //=======================================================================
 811 void AIS_InteractiveContext::UnhilightSelected (const Standard_Boolean theToUpdateViewer)
 812 {
 813   if (HasOpenedContext())
 814   {
 815     return myLocalContexts (myCurLocalIndex)->UnhilightPicked (theToUpdateViewer);
 816   }
 817
 818   AIS_Selection::SetCurrentSelection (myCurrentName.ToCString());
 819   Handle(AIS_Selection) aSel = AIS_Selection::Selection (myCurrentName.ToCString());
 820   for (aSel->Init(); aSel->More(); aSel->Next())
 821   {
 822     const Handle(SelectMgr_EntityOwner) anOwner =
 823       Handle(SelectMgr_EntityOwner)::DownCast (aSel->Value());
 824     if (!anOwner.IsNull() && anOwner->HasSelectable())
 825     {
 826       const Handle(AIS_InteractiveObject) anObj =
 827         Handle(AIS_InteractiveObject)::DownCast (anOwner->Selectable());
 828       if (anOwner == anObj->GlobalSelOwner())
 829       {
 830         myObjects.ChangeFind (anObj)->SetHilightStatus (Standard_False);
 831       }
 832       anOwner->State (0);
 833       const Standard_Integer aHiMode = anObj->HasHilightMode() ? anObj->HasHilightMode() : 0;
 834       anOwner->Unhilight (myMainPM, aHiMode);
 835     }
 836   }
 837
 838   if (theToUpdateViewer)
 839     UpdateCurrentViewer();
 840 }
 841
 842
 843 //=======================================================================
 844 //function : ClearSelected
 845 //purpose  :
 846 //=======================================================================
 847 void AIS_InteractiveContext::ClearSelected (const Standard_Boolean theToUpdateViewer)
 848 {
 849   if (HasOpenedContext())
 850     return myLocalContexts (myCurLocalIndex)->ClearSelected (theToUpdateViewer);
 851
 852   if (NbSelected() == 0)
 853     return;
 854
 855   unhighlightSelected();
 856
 857   AIS_Selection::Select();
 858   myMainPM->ClearImmediateDraw();
 859
 860   if (theToUpdateViewer)
 861     UpdateCurrentViewer();
 862 }
 863
 864 //=======================================================================
 865 //function : UpdateSelected
 866 //purpose  :
 867 //=======================================================================
 868 void AIS_InteractiveContext::UpdateSelected (const Standard_Boolean theToUpdateViewer)
 869 {
 870   if (HasOpenedContext())
 871   {
 872     return myLocalContexts(myCurLocalIndex)->UpdateSelected (theToUpdateViewer);
 873   }
 874
 875   HilightSelected (theToUpdateViewer);
 876 }
 877
 878 //=======================================================================
 879 //function : SetSelected
 880 //purpose  : Sets the whole object as selected and highlights it with selection color
 881 //=======================================================================
 882 void AIS_InteractiveContext::SetSelected (const Handle(AIS_InteractiveObject)& theObject,
 883                                           const Standard_Boolean theToUpdateViewer)
 884 {
 885   if(HasOpenedContext())
 886   {
 887     return myLocalContexts (myCurLocalIndex)->SetSelected (theObject, theToUpdateViewer);
 888   }
 889
 890   if (theObject.IsNull())
 891     return;
 892   if(!myObjects.IsBound (theObject))
 893     Display (theObject, Standard_False);
 894   if (theObject->HasSelection (0))
 895     return;
 896
 897   if (NbSelected() == 1 && myObjects (theObject)->IsHilighted())
 898   {
 899     Quantity_NameOfColor aHiCol;
 900     Standard_Boolean hasHiCol = Standard_False;
 901     if (IsHilighted (theObject, hasHiCol, aHiCol))
 902     {
 903       if (hasHiCol && aHiCol!= mySelectionColor)
 904       {
 905         HilightWithColor (theObject, mySelectionColor, theToUpdateViewer);
 906       }
 907     }
 908     return;
 909   }
 910
 911   AIS_Selection::SetCurrentSelection (myCurrentName.ToCString());
 912   Handle(AIS_Selection) aCurSel = AIS_Selection::Selection (myCurrentName.ToCString());
 913   for (aCurSel->Init(); aCurSel->More(); aCurSel->Next())
 914   {
 915     const Handle(SelectMgr_EntityOwner) anOwner =
 916       Handle(SelectMgr_EntityOwner)::DownCast (aCurSel->Value());
 917     if (anOwner.IsNull() || !anOwner->HasSelectable() || !myFilters->IsOk (anOwner))
 918       continue;
 919
 920     Handle(AIS_InteractiveObject) aSelectable =
 921       Handle(AIS_InteractiveObject)::DownCast (anOwner->Selectable());
 922     Unhilight (aSelectable, Standard_False);
 923     anOwner->State (0);
 924     if (anOwner == aSelectable->GlobalSelOwner())
 925     {
 926       myObjects.ChangeFind (aSelectable)->SetHilightStatus (Standard_False);
 927     }
 928   }
 929
 930   // added to avoid untimely viewer update...
 931   const Handle(SelectMgr_Selection)& aSel = theObject->Selection (0);
 932   if (aSel->IsEmpty())
 933     return;
 934   aSel->Init();
 935   Handle(SelectMgr_EntityOwner) anOwner =
 936     Handle(SelectMgr_EntityOwner)::DownCast (aSel->Sensitive()->BaseSensitive()->OwnerId());
 937   AIS_Selection::ClearAndSelect (anOwner);
 938   anOwner->State (1);
 939   if (anOwner == theObject->GlobalSelOwner())
 940   {
 941     Handle(AIS_GlobalStatus)& aState = myObjects.ChangeFind (theObject);
 942     aState->SetHilightStatus (Standard_True);
 943     aState->SetHilightColor (mySelectionColor);
 944   }
 945   Quantity_NameOfColor aHiCol;
 946   Standard_Boolean hasHiCol = Standard_False;
 947   if (IsHilighted (theObject, hasHiCol, aHiCol))
 948   {
 949     if (hasHiCol && aHiCol!= mySelectionColor)
 950     {
 951       HilightWithColor (theObject, mySelectionColor, Standard_False);
 952     }
 953   }
 954   else
 955   {
 956     HilightWithColor (theObject, mySelectionColor, Standard_False);
 957   }
 958
 959   if (theToUpdateViewer)
 960     UpdateCurrentViewer();
 961 }
 962
 963 //=======================================================================
 964 //function : SetSelected
 965 //purpose  : Sets the whole object as selected and highlights it with selection color
 966 //=======================================================================
 967 void AIS_InteractiveContext::SetSelected (const Handle(SelectMgr_EntityOwner)& theOwner,
 968                                           const Standard_Boolean theToUpdateViewer)
 969 {
 970   if (theOwner.IsNull() || !theOwner->HasSelectable() || !myFilters->IsOk (theOwner))
 971     return;
 972
 973   const Handle(AIS_InteractiveObject) anObject =
 974     Handle(AIS_InteractiveObject)::DownCast (theOwner->Selectable());
 975
 976   if (NbSelected() == 1 && theOwner->IsSelected())
 977   {
 978     Quantity_NameOfColor aCustomColor;
 979     Standard_Boolean isCustomColorSet;
 980     if (IsHilighted (theOwner, isCustomColorSet, aCustomColor))
 981     {
 982       if (isCustomColorSet && aCustomColor != mySelectionColor)
 983       {
 984         const Standard_Integer aHiMode = anObject->HasHilightMode() ? anObject->HilightMode() : 0;
 985         theOwner->HilightWithColor (myMainPM, mySelectionColor, aHiMode);
 986       }
 987     }
 988     return;
 989   }
 990
 991   if (!myObjects.IsBound (anObject))
 992     Display (anObject, Standard_False);
 993
 994   unhighlightSelected();
 995
 996   AIS_Selection::ClearAndSelect (theOwner);
 997   theOwner->State (1);
 998   Quantity_NameOfColor aCustomColor;
 999   Standard_Boolean isCustomColorSet;
1000   if (!IsHilighted (theOwner, isCustomColorSet, aCustomColor) || (isCustomColorSet && aCustomColor!= mySelectionColor))
1001   {
1002     highlightSelected (theOwner, mySelectionColor);
1003   }
1004
1005   if (theOwner == anObject->GlobalSelOwner())
1006   {
1007     Handle(AIS_GlobalStatus)& aState = myObjects.ChangeFind (anObject);
1008     aState->SetHilightStatus (Standard_True);
1009     aState->SetHilightColor (mySelectionColor);
1010   }
1011
1012   if (theToUpdateViewer)
1013     UpdateCurrentViewer();
1014 }
1015
1016 //=======================================================================
1017 //function : AddOrRemoveSelected
1018 //purpose  : Adds or removes current object from AIS selection and highlights/unhighlights it.
1019 //           Since this method makes sence only for neutral point selection of a whole object,
1020 //           if 0 selection of the object is empty this method simply does nothing.
1021 //=======================================================================
1022 void AIS_InteractiveContext::AddOrRemoveSelected (const Handle(AIS_InteractiveObject)& theObject,
1023                                                   const Standard_Boolean theToUpdateViewer)
1024 {
1025   if (theObject.IsNull())
1026     return;
1027
1028   if (HasOpenedContext())
1029     return myLocalContexts (myCurLocalIndex)->AddOrRemoveSelected (theObject, theToUpdateViewer);
1030
1031   const Standard_Integer aGlobalSelMode = theObject->GlobalSelectionMode();
1032   if (!myObjects.IsBound (theObject) || !theObject->HasSelection (aGlobalSelMode))
1033     return;
1034
1035   if (!theObject->HasInteractiveContext())
1036     theObject->SetContext (this);
1037
1038   const Handle(SelectMgr_Selection)& aSel = theObject->Selection (aGlobalSelMode);
1039
1040   if (aSel->IsEmpty())
1041     return;
1042
1043   aSel->Init();
1044   const Handle(SelectMgr_EntityOwner) anOwner =
1045     Handle(SelectMgr_EntityOwner)::DownCast (aSel->Sensitive()->BaseSensitive()->OwnerId());
1046
1047   if (anOwner.IsNull() || !anOwner->HasSelectable())
1048     return;
1049
1050   AddOrRemoveSelected (anOwner, theToUpdateViewer);
1051 }
1052 //=======================================================================
1053 //function : AddOrRemoveSelected
1054 //purpose  :
1055 //=======================================================================
1056
1057 void AIS_InteractiveContext::AddOrRemoveSelected (const TopoDS_Shape& aShap,
1058                                             const Standard_Boolean updateviewer)
1059 {
1060   if(!HasOpenedContext()) {
1061 #ifdef OCCT_DEBUG
1062     cout<<" Attempt to remove a selected shape with no opened local context"<<endl;
1063 #endif
1064     return;
1065   }
1066
1067   myLocalContexts(myCurLocalIndex)->AddOrRemoveSelected(aShap,updateviewer);
1068   if(updateviewer) UpdateCurrentViewer();
1069
1070 }
1071
1072 //=======================================================================
1073 //function : AddOrRemoveSelected
1074 //purpose  : Allows to highlight or unhighlight the owner given depending on
1075 //           its selection status
1076 //=======================================================================
1077 void AIS_InteractiveContext::AddOrRemoveSelected (const Handle(SelectMgr_EntityOwner)& theOwner,
1078                                                   const Standard_Boolean theToUpdateViewer)
1079 {
1080   if (HasOpenedContext())
1081     return myLocalContexts(myCurLocalIndex)->AddOrRemoveSelected (theOwner, theToUpdateViewer);
1082
1083   if (theOwner.IsNull() || !theOwner->HasSelectable())
1084     return;
1085
1086   AIS_Selection::SetCurrentSelection (myCurrentName.ToCString());
1087   Handle(AIS_Selection) aCurSel = AIS_Selection::Selection (myCurrentName.ToCString());
1088
1089   AIS_SelectStatus aSelStat = AIS_Selection::Select (theOwner);
1090
1091   Standard_Integer aState = aSelStat == AIS_SS_Added ?  1 : 0;
1092   theOwner->State (aState);
1093   const Handle(AIS_InteractiveObject) anObj =
1094     Handle(AIS_InteractiveObject)::DownCast (theOwner->Selectable());
1095   const Standard_Boolean isGlobal = anObj->GlobalSelOwner() == theOwner;
1096   Handle(AIS_GlobalStatus)& aStatus = myObjects.ChangeFind (anObj);
1097   const Standard_Integer aHiMode = anObj->HasHilightMode() ? anObj->HilightMode() : 0;
1098   if (aState == 1)
1099   {
1100     highlightSelected (theOwner, mySelectionColor);
1101     if (isGlobal)
1102     {
1103       aStatus->SetHilightStatus (Standard_True);
1104       aStatus->SetHilightColor (mySelectionColor);
1105     }
1106   }
1107   else
1108   {
1109     if (theOwner->IsAutoHilight())
1110       theOwner->Unhilight (myMainPM, aHiMode);
1111     else
1112       anObj->ClearSelected();
1113     aStatus->SetHilightStatus (Standard_False);
1114     aStatus->SetHilightColor (Quantity_NOC_WHITE);
1115   }
1116
1117   if (theToUpdateViewer)
1118     UpdateCurrentViewer();
1119 }
1120
1121
1122 //=======================================================================
1123 //function : IsSelected
1124 //purpose  :
1125 //=======================================================================
1126 Standard_Boolean AIS_InteractiveContext::IsSelected (const Handle(AIS_InteractiveObject)& theObj) const
1127 {
1128   if(HasOpenedContext())
1129     return myLocalContexts(myCurLocalIndex)->IsSelected (theObj);
1130
1131   if (theObj.IsNull() || !myObjects.IsBound (theObj))
1132     return Standard_False;
1133
1134   const Standard_Integer aGlobalSelMode = theObj->GlobalSelectionMode();
1135   const TColStd_ListOfInteger& anActivatedModes = myObjects (theObj)->SelectionModes();
1136   Standard_Boolean isGlobalModeActivated = Standard_False;
1137   for (TColStd_ListIteratorOfListOfInteger aModeIter (anActivatedModes); aModeIter.More(); aModeIter.Next())
1138   {
1139     if (aModeIter.Value() == aGlobalSelMode)
1140     {
1141       isGlobalModeActivated = Standard_True;
1142       break;
1143     }
1144   }
1145   if (!theObj->HasSelection (aGlobalSelMode) || !isGlobalModeActivated || theObj->GlobalSelOwner().IsNull())
1146     return Standard_False;
1147
1148   return theObj->GlobalSelOwner()->State() == 1;
1149 }
1150
1151 //=======================================================================
1152 //function : IsSelected
1153 //purpose  : Returns true is the owner given is selected
1154 //=======================================================================
1155 Standard_Boolean AIS_InteractiveContext::IsSelected (const Handle(SelectMgr_EntityOwner)& theOwner) const
1156 {
1157   if (HasOpenedContext())
1158     return myLocalContexts(myCurLocalIndex)->IsSelected (theOwner);
1159
1160   if (theOwner.IsNull())
1161     return Standard_False;
1162
1163   return theOwner->IsSelected();
1164 }
1165
1166 //=======================================================================
1167 //function : InitSelected
1168 //purpose  :
1169 //=======================================================================
1170 void AIS_InteractiveContext::InitSelected()
1171 {
1172   if (HasOpenedContext())
1173   {
1174     myLocalContexts (myCurLocalIndex)->InitSelected();
1175     return;
1176   }
1177
1178   AIS_Selection::Selection (myCurrentName.ToCString())->Init();
1179 }
1180
1181 //=======================================================================
1182 //function : MoreSelected
1183 //purpose  :
1184 //=======================================================================
1185 Standard_Boolean AIS_InteractiveContext::MoreSelected() const
1186 {
1187   if (HasOpenedContext())
1188     return myLocalContexts (myCurLocalIndex)->MoreSelected();
1189
1190   return AIS_Selection::Selection (myCurrentName.ToCString())->More();
1191 }
1192
1193 //=======================================================================
1194 //function : NextSelected
1195 //purpose  :
1196 //=======================================================================
1197 void AIS_InteractiveContext::NextSelected()
1198 {
1199   if(HasOpenedContext())
1200   {
1201     return myLocalContexts (myCurLocalIndex)->NextSelected();
1202     return;
1203   }
1204
1205   AIS_Selection::Selection (myCurrentName.ToCString())->Next();
1206 }
1207
1208 //=======================================================================
1209 //function : HasSelectedShape
1210 //purpose  :
1211 //=======================================================================
1212 Standard_Boolean AIS_InteractiveContext::HasSelectedShape() const
1213 {
1214   if(HasOpenedContext())
1215   {
1216     return myLocalContexts(myCurLocalIndex)->HasSelectedShape();
1217   }
1218
1219   Handle(AIS_Shape) aShape = Handle(AIS_Shape)::DownCast (SelectedInteractive());
1220   return !aShape.IsNull();
1221 }
1222
1223 //=======================================================================
1224 //function : SelectedShape
1225 //purpose  :
1226 //=======================================================================
1227 TopoDS_Shape AIS_InteractiveContext::SelectedShape() const
1228 {
1229   if (HasOpenedContext())
1230   {
1231     return myLocalContexts (myCurLocalIndex)->SelectedShape();
1232   }
1233
1234   if (AIS_Selection::Selection (myCurrentName.ToCString())->Extent() == 0)
1235     return TopoDS_Shape();
1236
1237   const Handle(StdSelect_BRepOwner) anOwner =
1238     Handle(StdSelect_BRepOwner)::DownCast (AIS_Selection::Selection (myCurrentName.ToCString())->Value());
1239   if (!anOwner->HasSelectable())
1240     return TopoDS_Shape();
1241
1242   return anOwner->Shape().Located (anOwner->Location() * anOwner->Shape().Location());
1243 }
1244
1245 //=======================================================================
1246 //function : SelectedInteractive
1247 //purpose  :
1248 //=======================================================================
1249 Handle(AIS_InteractiveObject) AIS_InteractiveContext::SelectedInteractive() const
1250 {
1251   if (HasOpenedContext())
1252   {
1253     return myLocalContexts(myCurLocalIndex)->SelectedInteractive();
1254   }
1255
1256   const Handle(SelectMgr_EntityOwner) anOwner =
1257     Handle(SelectMgr_EntityOwner)::DownCast (AIS_Selection::Selection (myCurrentName.ToCString())->Value());
1258   if (anOwner.IsNull() || !anOwner->HasSelectable())
1259     return NULL;
1260
1261   return Handle(AIS_InteractiveObject)::DownCast (anOwner->Selectable());
1262 }
1263 //=======================================================================
1264 //function : SelectedOwner
1265 //purpose  :
1266 //=======================================================================
1267 Handle(SelectMgr_EntityOwner) AIS_InteractiveContext::SelectedOwner() const
1268 {
1269   if(HasOpenedContext())
1270   {
1271     return myLocalContexts(myCurLocalIndex)->SelectedOwner();
1272   }
1273
1274   Handle(AIS_Selection) aCurSel = AIS_Selection::Selection (myCurrentName.ToCString());
1275
1276   return aCurSel->Extent() > 0 ?
1277     Handle(SelectMgr_EntityOwner)::DownCast (aCurSel->Value()) : NULL;
1278 }
1279
1280 //=======================================================================
1281 //function : EntityOwners
1282 //purpose  :
1283 //=======================================================================
1284 void AIS_InteractiveContext::EntityOwners(Handle(SelectMgr_IndexedMapOfOwner)& theOwners,
1285                                           const Handle(AIS_InteractiveObject)& theIObj,
1286                                           const Standard_Integer theMode) const
1287 {
1288   if ( theIObj.IsNull() )
1289       return;
1290
1291   TColStd_ListOfInteger aModes;
1292   if ( theMode == -1 )
1293     ActivatedModes( theIObj, aModes );
1294   else
1295     aModes.Append( theMode );
1296
1297   if (theOwners.IsNull())
1298     theOwners = new SelectMgr_IndexedMapOfOwner();
1299
1300   TColStd_ListIteratorOfListOfInteger anItr( aModes );
1301   for (; anItr.More(); anItr.Next() )
1302   {
1303     int aMode = anItr.Value();
1304     if ( !theIObj->HasSelection( aMode ) )
1305       continue;
1306
1307     Handle(SelectMgr_Selection) aSel = theIObj->Selection(aMode);
1308
1309     for ( aSel->Init(); aSel->More(); aSel->Next() )
1310     {
1311       Handle(SelectBasics_SensitiveEntity) aEntity = aSel->Sensitive()->BaseSensitive();
1312       if ( aEntity.IsNull() )
1313         continue;
1314
1315       Handle(SelectMgr_EntityOwner) aOwner =
1316         Handle(SelectMgr_EntityOwner)::DownCast(aEntity->OwnerId());
1317       if ( !aOwner.IsNull() )
1318         theOwners->Add( aOwner );
1319     }
1320   }
1321 }
1322
1323 //=======================================================================
1324 //function : NbSelected
1325 //purpose  :
1326 //=======================================================================
1327 Standard_Integer AIS_InteractiveContext::NbSelected()
1328 {
1329   Standard_Integer aNbSelected = 0;
1330   for (InitSelected(); MoreSelected(); NextSelected())
1331   {
1332     aNbSelected++;
1333   }
1334
1335   return aNbSelected;
1336 }
1337
1338 //=======================================================================
1339 //function : HasApplicative
1340 //purpose  :
1341 //=======================================================================
1342   Standard_Boolean AIS_InteractiveContext::HasApplicative() const
1343 {
1344   return SelectedInteractive()->HasOwner();
1345 }
1346
1347 //=======================================================================
1348 //function : Applicative
1349 //purpose  :
1350 //=======================================================================
1351 Handle(Standard_Transient) AIS_InteractiveContext::Applicative() const
1352 {
1353   return SelectedInteractive()->GetOwner();
1354 }
1355
1356 //==================================================
1357 // Function: HasDetected
1358 // Purpose :
1359 //==================================================
1360 Standard_Boolean AIS_InteractiveContext::HasDetected() const
1361 {
1362   if(HasOpenedContext())
1363     return myLocalContexts(myCurLocalIndex)->HasDetected();
1364
1365   return !myLastPicked.IsNull();
1366 }
1367
1368 //=======================================================================
1369 //function : HasDetectedShape
1370 //purpose  :
1371 //=======================================================================
1372
1373 Standard_Boolean AIS_InteractiveContext::HasDetectedShape() const
1374 {
1375   if(HasOpenedContext())
1376     return myLocalContexts(myCurLocalIndex)->HasDetectedShape();
1377   return Standard_False;
1378 }
1379
1380 //=======================================================================
1381 //function : DetectedShape
1382 //purpose  :
1383 //=======================================================================
1384
1385 const TopoDS_Shape&
1386 AIS_InteractiveContext::DetectedShape() const
1387 {
1388   return myLocalContexts(myCurLocalIndex)->DetectedShape();
1389 }
1390
1391 //=======================================================================
1392 //function : DetectedInteractive
1393 //purpose  :
1394 //=======================================================================
1395 Handle(AIS_InteractiveObject) AIS_InteractiveContext::DetectedInteractive() const
1396 {
1397   if (HasOpenedContext())
1398     return myLocalContexts(myCurLocalIndex)->DetectedInteractive();
1399
1400   return Handle(AIS_InteractiveObject)::DownCast (myLastPicked->Selectable());
1401 }
1402
1403
1404 Standard_Boolean AIS_InteractiveContext::HasNextDetected() const
1405 {
1406   if(!HasOpenedContext())
1407     return Standard_False; // temporaire
1408   else
1409     return myLocalContexts(myCurLocalIndex)->HasNextDetected();
1410
1411 }
1412
1413
1414 //=======================================================================
1415 //function : DetectedOwner
1416 //purpose  :
1417 //=======================================================================
1418 Handle(SelectMgr_EntityOwner) AIS_InteractiveContext::DetectedOwner() const
1419 {
1420   if (HasOpenedContext())
1421     return myLocalContexts(myCurLocalIndex)->DetectedOwner();
1422
1423   return myLastPicked;
1424 }
1425
1426 //=======================================================================
1427 //function : HilightNextDetected
1428 //purpose  :
1429 //=======================================================================
1430 Standard_Integer AIS_InteractiveContext::HilightNextDetected (const Handle(V3d_View)& theView,
1431                                                               const Standard_Boolean  theToRedrawImmediate)
1432 {
1433   return HasOpenedContext()
1434        ? myLocalContexts (myCurLocalIndex)->HilightNextDetected (theView, theToRedrawImmediate)
1435        : 0;
1436
1437 }
1438
1439 //=======================================================================
1440 //function : HilightNextDetected
1441 //purpose  :
1442 //=======================================================================
1443 Standard_Integer AIS_InteractiveContext::HilightPreviousDetected (const Handle(V3d_View)& theView,
1444                                                                   const Standard_Boolean  theToRedrawImmediate)
1445 {
1446   return HasOpenedContext()
1447        ? myLocalContexts (myCurLocalIndex)->HilightPreviousDetected (theView, theToRedrawImmediate)
1448        : 0;
1449
1450 }
1451
1452 //=======================================================================
1453 //function : InitDetected
1454 //purpose  :
1455 //=======================================================================
1456 void AIS_InteractiveContext::InitDetected()
1457 {
1458   if (HasOpenedContext())
1459   {
1460     myLocalContexts(myCurLocalIndex)->InitDetected();
1461     return;
1462   }
1463
1464   if(myAISDetectedSeq.Length() != 0)
1465   {
1466     myAISCurDetected = 1;
1467   }
1468 }
1469
1470 //=======================================================================
1471 //function : MoreDetected
1472 //purpose  :
1473 //=======================================================================
1474 Standard_Boolean AIS_InteractiveContext::MoreDetected() const
1475 {
1476   if (HasOpenedContext())
1477   {
1478     return myLocalContexts(myCurLocalIndex)->MoreDetected();
1479   }
1480
1481   return (myAISCurDetected > 0 && myAISCurDetected <= myAISDetectedSeq.Length()) ?
1482           Standard_True : Standard_False;
1483 }
1484
1485 //=======================================================================
1486 //function : NextDetected
1487 //purpose  :
1488 //=======================================================================
1489 void AIS_InteractiveContext::NextDetected()
1490 {
1491   if(HasOpenedContext())
1492   {
1493     myLocalContexts(myCurLocalIndex)->NextDetected();
1494     return;
1495   }
1496
1497   myAISCurDetected++;
1498 }
1499
1500 //=======================================================================
1501 //function : DetectedCurrentShape
1502 //purpose  :
1503 //=======================================================================
1504 const TopoDS_Shape& AIS_InteractiveContext::DetectedCurrentShape() const
1505 {
1506   if (HasOpenedContext())
1507   {
1508     return myLocalContexts(myCurLocalIndex)->DetectedCurrentShape();
1509   }
1510
1511   static TopoDS_Shape aDummyShape;
1512
1513   Handle(AIS_Shape) aCurrentShape = Handle(AIS_Shape)::DownCast (DetectedCurrentObject());
1514
1515   if (aCurrentShape.IsNull())
1516   {
1517     return aDummyShape;
1518   }
1519
1520   return aCurrentShape->Shape();
1521 }
1522
1523 //=======================================================================
1524 //function : DetectedCurrentObject
1525 //purpose  :
1526 //=======================================================================
1527 Handle(AIS_InteractiveObject) AIS_InteractiveContext::DetectedCurrentObject() const
1528 {
1529   if (HasOpenedContext())
1530   {
1531     return myLocalContexts(myCurLocalIndex)->DetectedCurrentObject();
1532   }
1533
1534   return MoreDetected() ? myAISDetectedSeq(myAISCurDetected) : NULL;
1535 }
1536
1537 //=======================================================================
1538 //function : FirstSelectedObject
1539 //purpose  :
1540 //=======================================================================
1541 Handle(AIS_InteractiveObject) AIS_InteractiveContext::FirstSelectedObject()
1542 {
1543   Handle(AIS_InteractiveObject) anObject;
1544
1545   if (HasOpenedContext())
1546     return anObject;
1547
1548   InitSelected();
1549   if (MoreSelected())
1550   {
1551     return SelectedInteractive();
1552   }
1553   return anObject;
1554 }
1555
1556 //=======================================================================
1557 //function : RedrawImmediate
1558 //purpose  : Redisplays immediate strucures of the viewer given according to their visibility
1559 //=======================================================================
1560 void AIS_InteractiveContext::RedrawImmediate (const Handle(V3d_Viewer)& theViewer)
1561 {
1562   myMainPM->RedrawImmediate (theViewer);
1563 }