+  AIS_SelectionScheme SelectionScheme (const AIS_SelectionType theType) const
+  { return mySelectionSchemes.Find (theType); }
+

+{
+  AIS_SelectionScheme_Empty         = 0x0000, // do nothing
+  AIS_SelectionScheme_Clear         = 0x0001, // clears current selection
+  AIS_SelectionScheme_Add           = 0x0002, // add detected object to current selection
+  AIS_SelectionScheme_Switch        = 0x0004, // switch selection state in values selected/deselected
+  AIS_SelectionScheme_PickedIfEmpty = 0x0008, // if after switch, result selection is empty, select picked objects
+  AIS_SelectionScheme_ClearAndSwitch = AIS_SelectionScheme_Clear | AIS_SelectionScheme_Switch,
+  AIS_SelectionScheme_ClearAndAdd = AIS_SelectionScheme_Clear | AIS_SelectionScheme_Add,
+  AIS_SelectionScheme_ClearAndSwitchAndPicked = AIS_SelectionScheme_ClearAndSwitch | AIS_SelectionScheme_PickedIfEmpty,
+  AIS_SelectionScheme_Custom // reserved item for custom selection scheme

+  Standard_EXPORT AIS_StatusOfPick Select (const Standard_Integer  theXPMin,
+                                           const Standard_Integer  theYPMin,
+                                           const Standard_Integer  theXPMax,
+                                           const Standard_Integer  theYPMax,
+                                           const Handle(V3d_View)& theView,
+                                           const AIS_SelectionScheme theSelScheme);

+  //! Sets list of owner selected/deselected using selection scheme
+  //! It is possible that selection of other objects is changed relatively selection scheme   .
+  //! \param theOwner owners to change selection state
+  //! \param theSelScheme selection scheme
+  Standard_EXPORT AIS_StatusOfPick Select (const AIS_NListOfEntityOwner& theOwners,
+                                           const AIS_SelectionScheme theSelScheme);

+//function : SelectOwners
+//purpose  : .

+AIS_StatusOfPick AIS_InteractiveContext::Select (const Standard_Boolean)
+{
+  return Select (AIS_SelectionScheme_ClearAndAdd);

+  AIS_NListOfEntityOwner aPickedOwners;
+  for (Standard_Integer aPickIter = 1; aPickIter <= myMainSel->NbPicked(); ++aPickIter)
   {
-    HilightSelected (toUpdateViewer);
+    aPickedOwners.Append (myMainSel->Picked (aPickIter));

+  AIS_NListOfEntityOwner aPrevSelected = Objects();
...
+    if (thePreviousSelected.Contains (theOwner)) // was selected, should not be now

-    if (!myLastPicked->IsSelected()
-      || myLastPicked->IsForcedHilight()
-      || NbSelected() > 1)
-    {
-      SetSelected (myLastPicked, Standard_False);

--- a/dox/dev_guides/upgrade/upgrade.md
+++ b/dox/dev_guides/upgrade/upgrade.md
@@ -1241,7 +1241,7 @@ The following AIS_InteractiveContext methods have been changed:
-  SetHLRDeviationAngle, SetHLRAngleAndDeviation, SetSelectedAspect, MoveTo, Select, ShiftSelect, SetSelected,
+  SetHLRDeviationAngle, SetHLRAngleAndDeviation, SetSelectedAspect, MoveTo, Select, SetSelected,

+  //! XPMin, YPMin, XPMax, and YPMax in the view.
+  //! The objects detected are passed to the main viewer, which is then updated.
+  Standard_EXPORT AIS_StatusOfPick SelectRectangle (const Graphic3d_Vec2i& thePntMin,
+                                                    const Graphic3d_Vec2i& thePntMax,

+AIS_StatusOfPick AIS_InteractiveContext::SelectRectangle (const Graphic3d_Vec2i&    thePntMin,
...
+    if (myLastPicked->HandleMouseClick (aMousePos, Aspect_VKeyMouse_LeftButton, Aspect_VKeyFlags_NONE, false))

+  AIS_SelectionScheme_ReplaceExtra, //!< replace with one difference: if result of replace is an empty,
+                                    //!< and current selection contains detected element, it will be selected

+                                                    const AIS_SelectionScheme theSelScheme);

/// TODO handle mess with IsForcedHilight()
bool SelectMgr_EntityOwner::Select (const AIS_SelectionScheme theSelScheme,
                                    const Standard_Boolean theIsDetected)
{
  switch (theSelScheme)
  {
    case AIS_SelectionScheme_UNKNOWN:
    {
      return myIsSelected;
    }
    case AIS_SelectionScheme_Replace:
    {
      return theIsDetected;
    }
    case AIS_SelectionScheme_Add:
    {
      return myIsSelected || theIsDetected;
    }
    case AIS_SelectionScheme_Remove:
    {
      return myIsSelected && !theIsDetected;
    }
    case AIS_SelectionScheme_XOR:
    {
      if (theIsDetected)
      {
        return !myIsSelected;
      }
      return myIsSelected;
    }
    case AIS_SelectionScheme_Clear:
    {
      return false;
    }
  }
  return false;
}

...
AIS_SelectStatus AIS_Selection::Select (const Handle(SelectMgr_EntityOwner)& theOwner,
                                        const Handle(SelectMgr_Filter)& theFilter,
                                        const AIS_SelectionScheme theSelScheme,
                                        const Standard_Boolean theIsDetected)
{
  if (theOwner.IsNull()
  || !theOwner->HasSelectable())
  {
    return AIS_SS_NotDone;
  }

  const bool isDetected  = theIsDetected && (theFilter.IsNull() || theFilter->IsOk (theOwner));
  const bool wasSelected = theOwner->IsSelected();
  const bool toSelect    = theOwner->Select (theSelScheme, theIsDetected);
  if (toSelect && !wasSelected)
  {
    AIS_NListOfEntityOwner::Iterator aListIter;
    myresult.Append  (theOwner, aListIter);
    myResultMap.Bind (theOwner, aListIter);
    theOwner->SetSelected (true);
    return AIS_SS_Added;
  }

  if (!(!toSelect && wasSelected))
  {
    return AIS_SS_NotDone;
  }

  AIS_NListOfEntityOwner::Iterator aListIter = myResultMap.Find (theOwner);
  if (myIterator == aListIter)
  {
    if (myIterator.More())
    {
      myIterator.Next();
    }
    else
    {
      myIterator = AIS_NListOfEntityOwner::Iterator();
    }
  }

  //if (theOwner->IsForcedHilight()) {return AIS_SS_Added;} /// TODO handle IsForcedHilight somehow
  myresult.Remove (aListIter);
  myResultMap.UnBind (theObject);
  theOwner->SetSelected (false);

  // update list iterator for next object in myresult list if any
  if (aListIter.More())
  {
    const Handle(SelectMgr_EntityOwner)& aNextObject = aListIter.Value();
    if (myResultMap.IsBound (aNextObject))
    {
      myResultMap (aNextObject) = aListIter;
    }
    else
    {
      myResultMap.Bind (aNextObject, aListIter);
    }
  }
  return AIS_SS_Removed;
}

void AIS_Selection::SelectOwners (const AIS_NListOfEntityOwner& thePickedOwners,
                                  const AIS_SelectionScheme theSelScheme,
                                  const Handle(SelectMgr_Filter)& theFilter)
{
  if (theSelScheme == AIS_SelectionScheme_Replace || theSelScheme == AIS_SelectionScheme_Clear)
  {
    Clear();
  }
  for (AIS_NListOfEntityOwner::Iterator aPickedIter (thePickedOwners); aPickedIter.More(); aPickedIter.Next())
  {
    const Handle(SelectMgr_EntityOwner)& anOwner = aPickedIter.Value();
    Select (anOwner, theFilter, theSelScheme, true);
  }
}