SoSelection — manages a list of selected objects

SoSelection  defines  a  node  which  can  be  inserted into a scene graph and will generate and manage a
       selection list from picks on any node in the subgraph below it. Nodes are selected  based  on  a  current
       selection  policy.   Callback  functions  report back to the application when a path has been selected or
       deselected. The selection list can also be managed programmatically.

       When handling events, SoSelection makes sure that the mouse release event was over the same object as the
       mouse press event before changing the list of selected objects. This allows users to  mouse  down  on  an
       object,  change  their  mind  and  move  the cursor off the object, then release the mouse button without
       altering the selection.

       The selection can be highlighted automatically through the SoXtRenderArea, or the application can provide
       custom highlights. Please see the  chapter  "Creating  a  Selection  Highlight  Style"  in  the  InventorToolmaker.

SoSFEnumpolicy
          Selection   policy   that   is  followed  in  response  to  user  interaction.  This  can  be  set  to
          SoSelection::SINGLE, SoSelection::TOGGLE, or SoSelection::SHIFT.

Selection{renderCachingAUTOboundingBoxCachingAUTOrenderCullingAUTOpickCullingAUTOpolicySHIFT}

       SoBase > SoFieldContainer > SoNode > SoGroup > SoSeparator > SoSelection

SoSelection()
          Creates a selection node with the default settings.

                         SoSelection(intnChildren)
          Constructor that specifies the approximate number of children.

     staticSoTypegetClassTypeId()
          Return the type id for the SoSelection class.

     voidselect(constSoPath*path)
          Select the passed path by adding it to the selection list. The selection node must lie  in  the  path.
          The  path  is  copied  and  truncated  such  that  the  selection node is the head of the path. If the
          selection node does not lie in the path, the selection list remains unchanged. This method ignores the
          current selection policy.

     voidselect(SoNode*node)
          Select the passed node by creating a path to it, and adding the path to the selection list by  calling
          select(path).  If there is more than one instance of node beneath the selection node, the created path
          will be the first instance found.

     voiddeselect(constSoPath*path)
          Deselect the passed path by removing it from the selection list.

     voiddeselect(intwhich)
          Deselect a path by removing it from the selection list. The argument which specifies which path in the
          list to be removed.

     voiddeselect(SoNode*node)
          Deselect the passed node by creating a path to it, and removing the node from the  selection  list  by
          calling  deselect(path).  If  there  is more than one instance of node beneath the selection node, the
          created path will be the first instance found.

     voidtoggle(constSoPath*path)
          Toggle the selection status of the passed path — if the path is in the selection list, it is  removed;
          if not in the list, it is added.

     voidtoggle(SoNode*node)
          Toggle the selection status of the passed node by creating a path to it, then calling toggle(path). If
          there is more than one instance of node beneath the selection node, the created path will be the first
          instance found.

     SbBoolisSelected(constSoPath*path)const
          Returns TRUE if the passed path is selected, that is, if it is in the selection list.

     SbBoolisSelected(SoNode*node)const
          Returns  TRUE  if  the passed node is selected by creating a path to it, then calling isSelected(). If
          there is more than one instance of node beneath the selection node, the created path will be the first
          instance found.

     voiddeselectAll()
          Deselect all paths in the selection list, that is, clear the list.

     intgetNumSelected()const
          Return the number of paths in the selection list.

     constSoPathList*getList()const
          Return the list of selected paths.

     SoPath*getPath(intindex)constSoPath*operator[](inti)const
          Return the ith path in the selection list.

     voidaddSelectionCallback(SoSelectionPathCB*f,void*userData=NULL)voidremoveSelectionCallback(SoSelectionPathCB*f,void*userData=NULL)
          The selection callbacks are invoked every time  an  object  is  selected,  whether  it  be  from  user
          interaction  or  from  method  call.  The callbacks are invoked after the object has been added to the
          selection list.

     voidaddDeselectionCallback(SoSelectionPathCB*f,void*userData=NULL)voidremoveDeselectionCallback(SoSelectionPathCB*f,void*userData=NULL)
          The deselection callbacks are invoked every time an object is deselected,  whether  it  be  from  user
          interaction  or from method call. This is invoked after the object has been removed from the selection
          list.

     voidaddStartCallback(SoSelectionClassCB*f,void*userData=NULL)voidremoveStartCallback(SoSelectionClassCB*f,void*userData=NULL)
          The start callbacks are invoked when the user has initiated an interactive  change  to  the  selection
          list  (by  picking  objects).  This  will  be  followed  by  invocations of the select and/or deselect
          callbacks, finally followed by each finish callback. A start callback can be used,  for  instance,  to
          save  the current selection for later restoration (e.g. undo/redo). The start callbacks are not called
          when the selection list is changed programmatically.

     voidaddFinishCallback(SoSelectionClassCB*f,void*userData=NULL)voidremoveFinishCallback(SoSelectionClassCB*f,void*userData=NULL)
          The finish callbacks are invoked when the user has finished interactively changing the selection  list
          (by  picking  objects).  This was preceded by an invocation of each start callback, and invocations of
          the select and/or deselect callbacks. The finish callbacks are not called when the selection  list  is
          changed programmatically.

     voidsetPickFilterCallback(SoSelectionPickCB*f,void*userData=NULL,SbBoolcallOnlyIfSelectable=TRUE)
          The pick filter callback is invoked when a pick has occurred and the selection node is about to change
          the selection list. The callback function returns the path that the selection  node  should  use  when
          selecting  and  deselecting.  If no pick callback is registered (the default), the selection node will
          use the path returned by SoPickedPoint::getPath() on the picked point associated with the event  being
          processed.  The  returned  path  should  not  be  ref'd  -  selection  will ref() and unref() it. (See
          SoPath::unrefNoDelete().)

          Note that a picked object may or may not be a child of the selection node. A selection node will  only
          select paths that pass through it. Possible return values from the callback:

          [a] NULL — selection behaves as if nothing was picked (i.e. for SINGLE and SHIFT policies, this clears
          the selection list). Handle event action traversal halts.

          [b]  Path — this path will be selected/deselected according to the selection policy (it must lie under
          the selection node). Handle event action traversal halts.

          [c] Path containing only the selection node — apply the selection policy as  if  nothing  was  picked.
          Handle event action traversal continues.

          [d]  Path  not passing through the selection node — selection ignores this pick event and no change is
          made to the selection list. Handle event action traversal continues.

          A simple way to tell selection to ignore the pick is to return an SoPath with no nodes  in  it.  (i.e.
          returnnewSoPath;)  Selection will always ref the path returned by the callback, make a copy of the
          path, then unref the path.

          The callOnlyIfSelectable argument, when set to TRUE, means the pick callback  function  will  only  be
          invoked  on  picks  which pass through the selection node. When FALSE, all picks will be passed to the
          callback whether they pass through the selection or not.

     voidsetPickMatching(SbBoolpickTwice)SbBoolgetPickMatching()constSoSelection will pick once on mouse down and once on mouse up, and make sure the  picks  match  before
          changing  the  selection  list.  This allows the user to pick down on an object, change their mind and
          drag off the object, release the mouse button and not affect the selection. Pass TRUE to  enable  this
          behavior.  Pass  FALSE  to  disable  this,  meaning  whatever  is  picked  on a mouse release is added
          to/removed from the selection list. Default is pick-matching on.

       SoSelection — manages a list of selected objects

SoEventCallback,SoXtRenderArea,SoBoxHighlightRenderAction,SoLineHighlightRenderActionSoSelection(3IV)()

#include<Inventor/nodes/SoSelection.h>typedefvoidSoSelectionPathCB(void*userData,SoPath*path)typedefvoidSoSelectionClassCB(void*userData,SoSelection*sel)typedefSoPath*SoSelectionPickCB(void*userData,constSoPickedPoint*pick)enumPolicy{SoSelection::SINGLE  Left  mouse pick on object clears selection, then selects object. Left mouse pick
                                    on nothing clears selection. Only one object may be selected at a time.
          SoSelection::TOGGLE  Left mouse pick on object toggles  its  selection  status.  Left  mouse  pick  on
                                    nothing does nothing. Multiple objects may be selected.
          SoSelection::SHIFT   When  shift  key  is  down,  selection  policy  is  TOGGLE. When shift key is up,
                                    selection policy is SINGLE. Multiple objects may be selected.
     }

          Fields from class SoSelection:

     SoSFEnumpolicy

          Fields from class SoSeparator:

     SoSFEnumrenderCachingSoSFEnumboundingBoxCachingSoSFEnumrenderCullingSoSFEnumpickCulling

          Methods from class SoSelection:

                         SoSelection()SoSelection(intnChildren)staticSoTypegetClassTypeId()voidselect(constSoPath*path)voidselect(SoNode*node)voiddeselect(constSoPath*path)voiddeselect(intwhich)voiddeselect(SoNode*node)voidtoggle(constSoPath*path)voidtoggle(SoNode*node)SbBoolisSelected(constSoPath*path)constSbBoolisSelected(SoNode*node)constvoiddeselectAll()intgetNumSelected()constconstSoPathList*getList()constSoPath*getPath(intindex)constSoPath*operator[](inti)constvoidaddSelectionCallback(SoSelectionPathCB*f,void*userData=NULL)voidremoveSelectionCallback(SoSelectionPathCB*f,void*userData=NULL)voidaddDeselectionCallback(SoSelectionPathCB*f,void*userData=NULL)voidremoveDeselectionCallback(SoSelectionPathCB*f,void*userData=NULL)voidaddStartCallback(SoSelectionClassCB*f,void*userData=NULL)voidremoveStartCallback(SoSelectionClassCB*f,void*userData=NULL)voidaddFinishCallback(SoSelectionClassCB*f,void*userData=NULL)voidremoveFinishCallback(SoSelectionClassCB*f,void*userData=NULL)voidsetPickFilterCallback(SoSelectionPickCB*f,void*userData=NULL,SbBoolcallOnlyIfSelectable=TRUE)voidsetPickMatching(SbBoolpickTwice)SbBoolgetPickMatching()const

          Methods from class SoSeparator:

     staticvoidsetNumRenderCaches(inthowMany)staticintgetNumRenderCaches()

          Methods from class SoGroup:

     voidaddChild(SoNode*child)voidinsertChild(SoNode*child,intnewChildIndex)SoNode*getChild(intindex)constintfindChild(constSoNode*child)constintgetNumChildren()constvoidremoveChild(intindex)voidremoveChild(SoNode*child)voidremoveAllChildren()voidreplaceChild(intindex,SoNode*newChild)voidreplaceChild(SoNode*oldChild,SoNode*newChild)

          Methods from class SoNode:

     voidsetOverride(SbBoolstate)SbBoolisOverride()constSoNode*copy(SbBoolcopyConnections=FALSE)constvirtualSbBoolaffectsState()conststaticSoNode*getByName(constSbName&name)staticintgetByName(constSbName&name,SoNodeList&list)

          Methods from class SoFieldContainer:

     voidsetToDefaults()SbBoolhasDefaultValues()constSbBoolfieldsAreEqual(constSoFieldContainer*fc)constvoidcopyFieldValues(constSoFieldContainer*fc,SbBoolcopyConnections=FALSE)SbBoolset(constchar*fieldDataString)voidget(SbString&fieldDataString)virtualintgetFields(SoFieldList&resultList)constvirtualSoField*getField(constSbName&fieldName)constSbBoolgetFieldName(constSoField*field,SbName&fieldName)constSbBoolisNotifyEnabled()constSbBoolenableNotify(SbBoolflag)

          Methods from class SoBase:

     voidref()voidunref()constvoidunrefNoDelete()constvoidtouch()virtualSoTypegetTypeId()constSbBoolisOfType(SoTypetype)constvirtualvoidsetName(constSbName&name)virtualSbNamegetName()const