Provided by: libcoin60-doc_3.1.3-2_all bug

NAME

       SoSearchAction -

       The SoSearchAction class provides methods for searching through scene graphs.

       Nodes can be searched for by pointer, type, and name, or a combination of those criteria.
       Types can be interpreted as exact types, or the type can match nodes derived from it.
       Every single node can be searched, or normal traversal rules can be followed when
       searching (this is especially important to note with regard to switch nodes).

SYNOPSIS

       #include <Inventor/actions/SoSearchAction.h>

       Inherits SoAction.

   Public Types
       enum LookFor { NODE =  1, TYPE =  2, NAME =  4 }
       enum Interest { FIRST, LAST, ALL }

   Public Member Functions
       SoSearchAction (void)
       virtual ~SoSearchAction (void)
       void setNode (SoNode *const node)
       SoNode * getNode (void) const
       void setType (const SoType type, const SbBool chkderived=TRUE)
       SoType getType (SbBool &chkderived) const
       void setName (const SbName name)
       SbName getName (void) const
       void setFind (const int what)
       int getFind (void) const
       void setInterest (const Interest interest)
       Interest getInterest (void) const
       void setSearchingAll (const SbBool searchall)
       SbBool isSearchingAll (void) const
       SoPath * getPath (void) const
       SoPathList & getPaths (void)
       void reset (void)
       void setFound (void)
       SbBool isFound (void) const
       void addPath (SoPath *const path)

   Static Public Member Functions
       static void initClass (void)

   Static Public Attributes
       static SbBool duringSearchAll = FALSE

   Protected Member Functions
       virtual void beginTraversal (SoNode *node)

Detailed Description

       The SoSearchAction class provides methods for searching through scene graphs.

       Nodes can be searched for by pointer, type, and name, or a combination of those criteria.
       Types can be interpreted as exact types, or the type can match nodes derived from it.
       Every single node can be searched, or normal traversal rules can be followed when
       searching (this is especially important to note with regard to switch nodes).

       When using more than one of the setNode(), setType() and setName() calls, note that the
       action will search for node(s) with an 'AND' combination of the given search criteria.

       One of the most common pitfalls when using the SoSearchAction class is to call the
       function isFound() after doing a search. It does not return what you would expect it to
       return if you haven't read the documentation for that function.

       Be aware that if you do search operations on an SoSearchAction created on the stack, you
       can get some unfortunate side effects if you're not careful. Since SoSearchAction keeps a
       list of the path(s) found in the latest search, the nodes in these paths will be unref'ed
       when the SoSearchAction stack instance is destructed at the end of your function. If the
       root of your scene-graph then has ref-count zero (it is often useful to do a
       unrefNoDelete() before returning a node from a function to leave the referencing to the
       caller), the root node will be destructed! It might be better to create a heap instance of
       the search action in those cases, since you'll then be able to destruct the search action
       before calling unrefNoDelete(). Another solution would be to call reset() before calling
       unrefNoDelete() on your object, since reset() truncates the path list.

       See the documentation of SoTexture2 for a full usage example of SoSearchAction.

Member Enumeration Documentation

   enum SoSearchAction::LookFor Specify the search criterion. This can be a bitwise combination
       of the available values.
   enum SoSearchAction::Interest Values used when specifiying what node(s) we are interested in:
       the first one found, the last one or all of them.

Constructor & Destructor Documentation

   SoSearchAction::SoSearchAction (void) Initializes internal settings with default values. With
       the default settings, the SoSearchAction will ignore all nodes.
   SoSearchAction::~SoSearchAction (void) [virtual] Destructor.

Member Function Documentation

   void SoSearchAction::initClass (void) [static] Initializes the run-time type system for this
       class, and sets up the enabled elements and action method list.
       Reimplemented from SoAction.

   void SoSearchAction::setNode (SoNode *constnodeptr) Sets the node pointer to search for.
       The action will be configured to set the search 'interest' to LookFor NODE, so there is no
       need to call SoSearchAction::setFind().

   SoNode * SoSearchAction::getNode (void) const Returns the node the SoSearchAction instance is
       configured to search for.
       Note that this method does not return what was found when you applied the action - it only
       returns what was specifically set by the user with setNode(). What the action found is
       returned by getPath() and getPaths().

   void SoSearchAction::setType (const SoTypetypearg, const SbBoolchkderivedarg = TRUE)
       Configures the SoSearchAction instance to search for nodes of the given type, and nodes of
       classes derived from the given type if chkderived is TRUE.
       The action will be configured to set the search 'interest' to LookFor TYPE, so there is no
       need to call SoSearchAction::setFind().

   SoType SoSearchAction::getType (SbBool &chkderivedref) const Returns the node type which is
       searched for, and whether derived classes of that type also returns a match.
   void SoSearchAction::setName (const SbNamenamearg) Configures the SoSearchAction instance to
       search for nodes with the given name.
       The action will be configured to set the search 'interest' to LookFor NAME, so there is no
       need to call SoSearchAction::setFind().

       See also:
           SoNode::getByName()

   SbName SoSearchAction::getName (void) const Returns the name the SoSearchAction instance is
       configured to search for.
   void SoSearchAction::setFind (const intwhat) Configures what to search for in the scene graph.
       what is a bitmask of LookFor flags.
       Default find configuration is to ignore all nodes, but the setFind() configuration is
       updated automatically when any one of SoSearchAction::setNode(), SoSearchAction::setType()
       or SoSearchAction::setName() is called.

   int SoSearchAction::getFind (void) const Returns the search configuration of the action
       instance.
   void SoSearchAction::setInterest (const Interestinterestarg) Configures whether only the
       first, the last, or all the searching matches are of interest. Default configuration is
       FIRST.
   SoSearchAction::Interest SoSearchAction::getInterest (void) const Returns whether only the
       first, the last, or all the searching matches will be saved.
   void SoSearchAction::setSearchingAll (const SbBoolsearchallarg) Specifies whether normal graph
       traversal should be done (searchall is FALSE, which is the default setting), or if every
       single node should be searched (searchall is TRUE).
       If the searchall flag is TRUE, even nodes considered 'hidden' by other actions are
       searched (like for instance the disabled children of SoSwitch nodes).

       SoBaseKit::setSearchingChildren() must be used to search for nodes under node kits.

   SbBool SoSearchAction::isSearchingAll (void) const Returns the traversal method configuration
       of the action.
   SoPath * SoSearchAction::getPath (void) const Returns the path to the node of interest that
       matched the search criterions. If no match was found, NULL is returned.
       Note that if ALL matches are of interest, the result of a search action must be fetched
       through SoSearchAction::getPaths().

       There is one frequently asked question about the paths that are returned from either this
       method or the getPaths() method below: 'why am I not getting the complete path as
       expected?'

       Well, then you probably have to cast the path to a SoFullPath, since certain nodes
       (nodekits, many VRML97 nodes) have hidden children. SoPath::getTail() will return the
       first node that has hidden children, or the tail if none of the nodes have hidden
       children. SoFullPath::getTail() will always return the actual tail. Just do like this:

           SoFullPath * path = (SoFullPath *) searchaction->getPath();
           SoVRMLCoordinate * vrmlcord = (SoVRMLCoordinate *) path->getTail();

   SoPathList & SoSearchAction::getPaths (void) Returns a pathlist of all nodes that matched the
       search criterions.
       Note that if interest were only FIRST or LAST, SoSearchAction::getPath() should be used
       instead of this method.

       See also:
           getPath()

   void SoSearchAction::reset (void) Resets all the SoSearchAction internals back to their
       default values.
   void SoSearchAction::setFound (void) This API member is considered internal to the library, as
       it is not likely to be of interest to the application programmer.
       Marks the SoSearchAction instance as terminated.

   SbBool SoSearchAction::isFound (void) const This API member is considered internal to the
       library, as it is not likely to be of interest to the application programmer.
       Returns whether the search action was terminated.

       Note that this value does not reflect whether the node(s) that was searched for was found
       or not. Use the result of getPath() / getPaths() if that is what you really are looking
       for.

   void SoSearchAction::addPath (SoPath *constpathptr) This API member is considered internal to
       the library, as it is not likely to be of interest to the application programmer.
       Sets the path, or adds the path to the path list, depending on the interest configuration.
       The path is not copied, so it can not be modified after being added without side effects.

   void SoSearchAction::beginTraversal (SoNode *node) [protected, virtual] This virtual method is
       called from SoAction::apply(), and is the entry point for the actual scenegraph traversal.
       It can be overridden to initialize the action at traversal start, for specific
       initializations in the action subclasses inheriting SoAction.

       Default method just calls traverse(), which any overridden implementation of the method
       must do too (or call SoAction::beginTraversal()) to trigger the scenegraph traversal.

       Reimplemented from SoAction.

Member Data Documentation

   SbBool SoSearchAction::duringSearchAll = FALSE [static] Obsoleted global flag, only present
       for compatibility reasons with old SGI / TGS Inventor application code.
       It's set to TRUE when an SoSearchAction traversal with SoSearchAction::isSearchingAll()
       equal to TRUE is started, and is reset to FALSE again after traversal has finished.

       (The flag is used by SGI / TGS Inventor in SoSwitch::affectsState() to know when
       SoSwitch::whichChild should behave as SoSwitch::SO_SWITCH_ALL. We have a better solution
       for this problem in Coin.)

Author

       Generated automatically by Doxygen for Coin from the source code.