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_EntityOwner) anOwner = theObject->GlobalSelOwner();
1039
1040   if (anOwner.IsNull() || !anOwner->HasSelectable())
1041     return;
1042
1043   AddOrRemoveSelected (anOwner, theToUpdateViewer);
1044 }
1045 //=======================================================================
1046 //function : AddOrRemoveSelected
1047 //purpose  :
1048 //=======================================================================
1049
1050 void AIS_InteractiveContext::AddOrRemoveSelected (const TopoDS_Shape& aShap,
1051                                             const Standard_Boolean updateviewer)
1052 {
1053   if(!HasOpenedContext()) {
1054 #ifdef OCCT_DEBUG
1055     cout<<" Attempt to remove a selected shape with no opened local context"<<endl;
1056 #endif
1057     return;
1058   }
1059
1060   myLocalContexts(myCurLocalIndex)->AddOrRemoveSelected(aShap,updateviewer);
1061   if(updateviewer) UpdateCurrentViewer();
1062
1063 }
1064
1065 //=======================================================================
1066 //function : AddOrRemoveSelected
1067 //purpose  : Allows to highlight or unhighlight the owner given depending on
1068 //           its selection status
1069 //=======================================================================
1070 void AIS_InteractiveContext::AddOrRemoveSelected (const Handle(SelectMgr_EntityOwner)& theOwner,
1071                                                   const Standard_Boolean theToUpdateViewer)
1072 {
1073   if (HasOpenedContext())
1074     return myLocalContexts(myCurLocalIndex)->AddOrRemoveSelected (theOwner, theToUpdateViewer);
1075
1076   if (theOwner.IsNull() || !theOwner->HasSelectable())
1077     return;
1078
1079   AIS_Selection::SetCurrentSelection (myCurrentName.ToCString());
1080   Handle(AIS_Selection) aCurSel = AIS_Selection::Selection (myCurrentName.ToCString());
1081
1082   AIS_SelectStatus aSelStat = AIS_Selection::Select (theOwner);
1083
1084   Standard_Integer aState = aSelStat == AIS_SS_Added ?  1 : 0;
1085   theOwner->State (aState);
1086   const Handle(AIS_InteractiveObject) anObj =
1087     Handle(AIS_InteractiveObject)::DownCast (theOwner->Selectable());
1088   const Standard_Boolean isGlobal = anObj->GlobalSelOwner() == theOwner;
1089   Handle(AIS_GlobalStatus)& aStatus = myObjects.ChangeFind (anObj);
1090   const Standard_Integer aHiMode = anObj->HasHilightMode() ? anObj->HilightMode() : 0;
1091   if (aState == 1)
1092   {
1093     highlightSelected (theOwner, mySelectionColor);
1094     if (isGlobal)
1095     {
1096       aStatus->SetHilightStatus (Standard_True);
1097       aStatus->SetHilightColor (mySelectionColor);
1098     }
1099   }
1100   else
1101   {
1102     if (theOwner->IsAutoHilight())
1103       theOwner->Unhilight (myMainPM, aHiMode);
1104     else
1105       anObj->ClearSelected();
1106     aStatus->SetHilightStatus (Standard_False);
1107     aStatus->SetHilightColor (Quantity_NOC_WHITE);
1108   }
1109
1110   if (theToUpdateViewer)
1111     UpdateCurrentViewer();
1112 }
1113
1114
1115 //=======================================================================
1116 //function : IsSelected
1117 //purpose  :
1118 //=======================================================================
1119 Standard_Boolean AIS_InteractiveContext::IsSelected (const Handle(AIS_InteractiveObject)& theObj) const
1120 {
1121   if(HasOpenedContext())
1122     return myLocalContexts(myCurLocalIndex)->IsSelected (theObj);
1123
1124   if (theObj.IsNull() || !myObjects.IsBound (theObj))
1125     return Standard_False;
1126
1127   const Standard_Integer aGlobalSelMode = theObj->GlobalSelectionMode();
1128   const TColStd_ListOfInteger& anActivatedModes = myObjects (theObj)->SelectionModes();
1129   Standard_Boolean isGlobalModeActivated = Standard_False;
1130   for (TColStd_ListIteratorOfListOfInteger aModeIter (anActivatedModes); aModeIter.More(); aModeIter.Next())
1131   {
1132     if (aModeIter.Value() == aGlobalSelMode)
1133     {
1134       isGlobalModeActivated = Standard_True;
1135       break;
1136     }
1137   }
1138   if (!theObj->HasSelection (aGlobalSelMode) || !isGlobalModeActivated || theObj->GlobalSelOwner().IsNull())
1139     return Standard_False;
1140
1141   return theObj->GlobalSelOwner()->State() == 1;
1142 }
1143
1144 //=======================================================================
1145 //function : IsSelected
1146 //purpose  : Returns true is the owner given is selected
1147 //=======================================================================
1148 Standard_Boolean AIS_InteractiveContext::IsSelected (const Handle(SelectMgr_EntityOwner)& theOwner) const
1149 {
1150   if (HasOpenedContext())
1151     return myLocalContexts(myCurLocalIndex)->IsSelected (theOwner);
1152
1153   if (theOwner.IsNull())
1154     return Standard_False;
1155
1156   return theOwner->IsSelected();
1157 }
1158
1159 //=======================================================================
1160 //function : InitSelected
1161 //purpose  :
1162 //=======================================================================
1163 void AIS_InteractiveContext::InitSelected()
1164 {
1165   if (HasOpenedContext())
1166   {
1167     myLocalContexts (myCurLocalIndex)->InitSelected();
1168     return;
1169   }
1170
1171   AIS_Selection::Selection (myCurrentName.ToCString())->Init();
1172 }
1173
1174 //=======================================================================
1175 //function : MoreSelected
1176 //purpose  :
1177 //=======================================================================
1178 Standard_Boolean AIS_InteractiveContext::MoreSelected() const
1179 {
1180   if (HasOpenedContext())
1181     return myLocalContexts (myCurLocalIndex)->MoreSelected();
1182
1183   return AIS_Selection::Selection (myCurrentName.ToCString())->More();
1184 }
1185
1186 //=======================================================================
1187 //function : NextSelected
1188 //purpose  :
1189 //=======================================================================
1190 void AIS_InteractiveContext::NextSelected()
1191 {
1192   if(HasOpenedContext())
1193   {
1194     return myLocalContexts (myCurLocalIndex)->NextSelected();
1195     return;
1196   }
1197
1198   AIS_Selection::Selection (myCurrentName.ToCString())->Next();
1199 }
1200
1201 //=======================================================================
1202 //function : HasSelectedShape
1203 //purpose  :
1204 //=======================================================================
1205 Standard_Boolean AIS_InteractiveContext::HasSelectedShape() const
1206 {
1207   if(HasOpenedContext())
1208   {
1209     return myLocalContexts(myCurLocalIndex)->HasSelectedShape();
1210   }
1211
1212   Handle(AIS_Shape) aShape = Handle(AIS_Shape)::DownCast (SelectedInteractive());
1213   return !aShape.IsNull();
1214 }
1215
1216 //=======================================================================
1217 //function : SelectedShape
1218 //purpose  :
1219 //=======================================================================
1220 TopoDS_Shape AIS_InteractiveContext::SelectedShape() const
1221 {
1222   if (HasOpenedContext())
1223   {
1224     return myLocalContexts (myCurLocalIndex)->SelectedShape();
1225   }
1226
1227   if (AIS_Selection::Selection (myCurrentName.ToCString())->Extent() == 0)
1228     return TopoDS_Shape();
1229
1230   const Handle(StdSelect_BRepOwner) anOwner =
1231     Handle(StdSelect_BRepOwner)::DownCast (AIS_Selection::Selection (myCurrentName.ToCString())->Value());
1232   if (!anOwner->HasSelectable())
1233     return TopoDS_Shape();
1234
1235   return anOwner->Shape().Located (anOwner->Location() * anOwner->Shape().Location());
1236 }
1237
1238 //=======================================================================
1239 //function : SelectedInteractive
1240 //purpose  :
1241 //=======================================================================
1242 Handle(AIS_InteractiveObject) AIS_InteractiveContext::SelectedInteractive() const
1243 {
1244   if (HasOpenedContext())
1245   {
1246     return myLocalContexts(myCurLocalIndex)->SelectedInteractive();
1247   }
1248
1249   const Handle(SelectMgr_EntityOwner) anOwner =
1250     Handle(SelectMgr_EntityOwner)::DownCast (AIS_Selection::Selection (myCurrentName.ToCString())->Value());
1251   if (anOwner.IsNull() || !anOwner->HasSelectable())
1252     return NULL;
1253
1254   return Handle(AIS_InteractiveObject)::DownCast (anOwner->Selectable());
1255 }
1256 //=======================================================================
1257 //function : SelectedOwner
1258 //purpose  :
1259 //=======================================================================
1260 Handle(SelectMgr_EntityOwner) AIS_InteractiveContext::SelectedOwner() const
1261 {
1262   if(HasOpenedContext())
1263   {
1264     return myLocalContexts(myCurLocalIndex)->SelectedOwner();
1265   }
1266
1267   Handle(AIS_Selection) aCurSel = AIS_Selection::Selection (myCurrentName.ToCString());
1268
1269   return aCurSel->Extent() > 0 ?
1270     Handle(SelectMgr_EntityOwner)::DownCast (aCurSel->Value()) : NULL;
1271 }
1272
1273 //=======================================================================
1274 //function : EntityOwners
1275 //purpose  :
1276 //=======================================================================
1277 void AIS_InteractiveContext::EntityOwners(Handle(SelectMgr_IndexedMapOfOwner)& theOwners,
1278                                           const Handle(AIS_InteractiveObject)& theIObj,
1279                                           const Standard_Integer theMode) const
1280 {
1281   if ( theIObj.IsNull() )
1282       return;
1283
1284   TColStd_ListOfInteger aModes;
1285   if ( theMode == -1 )
1286     ActivatedModes( theIObj, aModes );
1287   else
1288     aModes.Append( theMode );
1289
1290   if (theOwners.IsNull())
1291     theOwners = new SelectMgr_IndexedMapOfOwner();
1292
1293   TColStd_ListIteratorOfListOfInteger anItr( aModes );
1294   for (; anItr.More(); anItr.Next() )
1295   {
1296     int aMode = anItr.Value();
1297     if ( !theIObj->HasSelection( aMode ) )
1298       continue;
1299
1300     Handle(SelectMgr_Selection) aSel = theIObj->Selection(aMode);
1301
1302     for ( aSel->Init(); aSel->More(); aSel->Next() )
1303     {
1304       Handle(SelectBasics_SensitiveEntity) aEntity = aSel->Sensitive()->BaseSensitive();
1305       if ( aEntity.IsNull() )
1306         continue;
1307
1308       Handle(SelectMgr_EntityOwner) aOwner =
1309         Handle(SelectMgr_EntityOwner)::DownCast(aEntity->OwnerId());
1310       if ( !aOwner.IsNull() )
1311         theOwners->Add( aOwner );
1312     }
1313   }
1314 }
1315
1316 //=======================================================================
1317 //function : NbSelected
1318 //purpose  :
1319 //=======================================================================
1320 Standard_Integer AIS_InteractiveContext::NbSelected()
1321 {
1322   Standard_Integer aNbSelected = 0;
1323   for (InitSelected(); MoreSelected(); NextSelected())
1324   {
1325     aNbSelected++;
1326   }
1327
1328   return aNbSelected;
1329 }
1330
1331 //=======================================================================
1332 //function : HasApplicative
1333 //purpose  :
1334 //=======================================================================
1335   Standard_Boolean AIS_InteractiveContext::HasApplicative() const
1336 {
1337   return SelectedInteractive()->HasOwner();
1338 }
1339
1340 //=======================================================================
1341 //function : Applicative
1342 //purpose  :
1343 //=======================================================================
1344 Handle(Standard_Transient) AIS_InteractiveContext::Applicative() const
1345 {
1346   return SelectedInteractive()->GetOwner();
1347 }
1348
1349 //==================================================
1350 // Function: HasDetected
1351 // Purpose :
1352 //==================================================
1353 Standard_Boolean AIS_InteractiveContext::HasDetected() const
1354 {
1355   if(HasOpenedContext())
1356     return myLocalContexts(myCurLocalIndex)->HasDetected();
1357
1358   return !myLastPicked.IsNull();
1359 }
1360
1361 //=======================================================================
1362 //function : HasDetectedShape
1363 //purpose  :
1364 //=======================================================================
1365
1366 Standard_Boolean AIS_InteractiveContext::HasDetectedShape() const
1367 {
1368   if(HasOpenedContext())
1369     return myLocalContexts(myCurLocalIndex)->HasDetectedShape();
1370   return Standard_False;
1371 }
1372
1373 //=======================================================================
1374 //function : DetectedShape
1375 //purpose  :
1376 //=======================================================================
1377
1378 const TopoDS_Shape&
1379 AIS_InteractiveContext::DetectedShape() const
1380 {
1381   return myLocalContexts(myCurLocalIndex)->DetectedShape();
1382 }
1383
1384 //=======================================================================
1385 //function : DetectedInteractive
1386 //purpose  :
1387 //=======================================================================
1388 Handle(AIS_InteractiveObject) AIS_InteractiveContext::DetectedInteractive() const
1389 {
1390   if (HasOpenedContext())
1391     return myLocalContexts(myCurLocalIndex)->DetectedInteractive();
1392
1393   return Handle(AIS_InteractiveObject)::DownCast (myLastPicked->Selectable());
1394 }
1395
1396
1397 Standard_Boolean AIS_InteractiveContext::HasNextDetected() const
1398 {
1399   if(!HasOpenedContext())
1400     return Standard_False; // temporaire
1401   else
1402     return myLocalContexts(myCurLocalIndex)->HasNextDetected();
1403
1404 }
1405
1406
1407 //=======================================================================
1408 //function : DetectedOwner
1409 //purpose  :
1410 //=======================================================================
1411 Handle(SelectMgr_EntityOwner) AIS_InteractiveContext::DetectedOwner() const
1412 {
1413   if (HasOpenedContext())
1414     return myLocalContexts(myCurLocalIndex)->DetectedOwner();
1415
1416   return myLastPicked;
1417 }
1418
1419 //=======================================================================
1420 //function : HilightNextDetected
1421 //purpose  :
1422 //=======================================================================
1423 Standard_Integer AIS_InteractiveContext::HilightNextDetected (const Handle(V3d_View)& theView,
1424                                                               const Standard_Boolean  theToRedrawImmediate)
1425 {
1426   return HasOpenedContext()
1427        ? myLocalContexts (myCurLocalIndex)->HilightNextDetected (theView, theToRedrawImmediate)
1428        : 0;
1429
1430 }
1431
1432 //=======================================================================
1433 //function : HilightNextDetected
1434 //purpose  :
1435 //=======================================================================
1436 Standard_Integer AIS_InteractiveContext::HilightPreviousDetected (const Handle(V3d_View)& theView,
1437                                                                   const Standard_Boolean  theToRedrawImmediate)
1438 {
1439   return HasOpenedContext()
1440        ? myLocalContexts (myCurLocalIndex)->HilightPreviousDetected (theView, theToRedrawImmediate)
1441        : 0;
1442
1443 }
1444
1445 //=======================================================================
1446 //function : InitDetected
1447 //purpose  :
1448 //=======================================================================
1449 void AIS_InteractiveContext::InitDetected()
1450 {
1451   if (HasOpenedContext())
1452   {
1453     myLocalContexts(myCurLocalIndex)->InitDetected();
1454     return;
1455   }
1456
1457   if(myAISDetectedSeq.Length() != 0)
1458   {
1459     myAISCurDetected = 1;
1460   }
1461 }
1462
1463 //=======================================================================
1464 //function : MoreDetected
1465 //purpose  :
1466 //=======================================================================
1467 Standard_Boolean AIS_InteractiveContext::MoreDetected() const
1468 {
1469   if (HasOpenedContext())
1470   {
1471     return myLocalContexts(myCurLocalIndex)->MoreDetected();
1472   }
1473
1474   return (myAISCurDetected > 0 && myAISCurDetected <= myAISDetectedSeq.Length()) ?
1475           Standard_True : Standard_False;
1476 }
1477
1478 //=======================================================================
1479 //function : NextDetected
1480 //purpose  :
1481 //=======================================================================
1482 void AIS_InteractiveContext::NextDetected()
1483 {
1484   if(HasOpenedContext())
1485   {
1486     myLocalContexts(myCurLocalIndex)->NextDetected();
1487     return;
1488   }
1489
1490   myAISCurDetected++;
1491 }
1492
1493 //=======================================================================
1494 //function : DetectedCurrentShape
1495 //purpose  :
1496 //=======================================================================
1497 const TopoDS_Shape& AIS_InteractiveContext::DetectedCurrentShape() const
1498 {
1499   if (HasOpenedContext())
1500   {
1501     return myLocalContexts(myCurLocalIndex)->DetectedCurrentShape();
1502   }
1503
1504   static TopoDS_Shape aDummyShape;
1505
1506   Handle(AIS_Shape) aCurrentShape = Handle(AIS_Shape)::DownCast (DetectedCurrentObject());
1507
1508   if (aCurrentShape.IsNull())
1509   {
1510     return aDummyShape;
1511   }
1512
1513   return aCurrentShape->Shape();
1514 }
1515
1516 //=======================================================================
1517 //function : DetectedCurrentObject
1518 //purpose  :
1519 //=======================================================================
1520 Handle(AIS_InteractiveObject) AIS_InteractiveContext::DetectedCurrentObject() const
1521 {
1522   if (HasOpenedContext())
1523   {
1524     return myLocalContexts(myCurLocalIndex)->DetectedCurrentObject();
1525   }
1526
1527   return MoreDetected() ? myAISDetectedSeq(myAISCurDetected) : NULL;
1528 }
1529
1530 //=======================================================================
1531 //function : FirstSelectedObject
1532 //purpose  :
1533 //=======================================================================
1534 Handle(AIS_InteractiveObject) AIS_InteractiveContext::FirstSelectedObject()
1535 {
1536   Handle(AIS_InteractiveObject) anObject;
1537
1538   if (HasOpenedContext())
1539     return anObject;
1540
1541   InitSelected();
1542   if (MoreSelected())
1543   {
1544     return SelectedInteractive();
1545   }
1546   return anObject;
1547 }
1548
1549 //=======================================================================
1550 //function : RedrawImmediate
1551 //purpose  : Redisplays immediate strucures of the viewer given according to their visibility
1552 //=======================================================================
1553 void AIS_InteractiveContext::RedrawImmediate (const Handle(V3d_Viewer)& theViewer)
1554 {
1555   myMainPM->RedrawImmediate (theViewer);
1556 }