SoSelection(3)

📦
version 2.5.0 · 2 versions
, in fedora 43

💖 SoSelection(3) 💖 — Library Functions Manual

okay bestie, sit down, hydrate, because we're about to get into SoSelection and honestly? she's iconic. this is the Library Functions Manual entry, part 1 of 4, so don't go anywhere — we're just doing the setup right now. 🎀

🌸 NAME 🌸

SoSelection — the SoSelection class manages a list of selected nodes.

like, that's it, that's her whole job, and she does it flawlessly. 💅

✨ SYNOPSIS ✨

first things first, the include. you need this, no skipping:

#include <Inventor/nodes/SoSelection.h>

She inherits SoSeparator.

She's inherited by SoExtSelection. (yes, the family tree is giving legacy, we love a lineage 👑)

🎀 Public Types

enum Policy { SINGLE, TOGGLE, SHIFT }

three whole moods. SINGLE, TOGGLE, SHIFT. remember them, they come back later, fr fr.

🦋 Public Types inherited from SoSeparator

enum CacheEnabled { OFF, ON, AUTO }

🦋 Public Types inherited from SoNode

enum NodeType { INVENTOR = 0x0000, VRML1 = 0x0001, VRML2 = 0x0002,
    INVENTOR_1 = 0x0004, INVENTOR_2_0 = 0x0008, INVENTOR_2_1 = 0x0010,
    INVENTOR_2_5 = 0x0020, INVENTOR_2_6 = 0x0040, COIN_1_0 = 0x0080,
    COIN_2_0 = 0x0100, EXTENSION = 0x0200, COIN_2_2 = 0x0400, COIN_2_3 =
    0x0800, COIN_2_4 = 0x1000, INVENTOR_5_0 = 0x2000, COIN_2_5 = 0x4000
    }

look at all those hex values, the vintage of it all. ✨

💜 Public Member Functions

here's the whole roster, every single one, no crumbs left behind:

virtual SoType getTypeId (void) const
SoSelection (void)
SoSelection (const int nChildren)
void select (const SoPath *path)
void select (SoNode *node)
void deselect (const SoPath *path)
void deselect (const int which)
void deselect (SoNode *node)
void toggle (const SoPath *path)
void toggle (SoNode *node)
SbBool isSelected (const SoPath *path) const
SbBool isSelected (SoNode *node) const
void deselectAll (void)
int getNumSelected (void) const
const SoPathList * getList (void) const
SoPath * getPath (const int index) const
SoPath * operator[] (const int i) const
void addSelectionCallback (SoSelectionPathCB *f, void *userData=NULL)
void removeSelectionCallback (SoSelectionPathCB *f, void *userData=NULL)
void addDeselectionCallback (SoSelectionPathCB *f, void *userData=NULL)
void removeDeselectionCallback (SoSelectionPathCB *f, void
    *userData=NULL)
void addStartCallback (SoSelectionClassCB *f, void *userData=NULL)
void removeStartCallback (SoSelectionClassCB *f, void *userData=NULL)
void addFinishCallback (SoSelectionClassCB *f, void *userData=NULL)
void removeFinishCallback (SoSelectionClassCB *f, void *userData=NULL)
void setPickFilterCallback (SoSelectionPickCB *f, void *userData=NULL,
    const SbBool callOnlyIfSelectable=1)
void setPickMatching (const SbBool pickMatching)
SbBool isPickMatching (void) const
SbBool getPickMatching (void) const
void addChangeCallback (SoSelectionClassCB *f, void *userData=NULL)
void removeChangeCallback (SoSelectionClassCB *f, void *userData=NULL)
👀 notice the userData=NULL defaults everywhere — she's generous like that.

🌈 Public Member Functions inherited from SoSeparator

SoSeparator (void)
SoSeparator (const int nchildren)
virtual void doAction (SoAction *action)
virtual void GLRender (SoGLRenderAction *action)
virtual void GLRenderBelowPath (SoGLRenderAction *action)
virtual void GLRenderInPath (SoGLRenderAction *action)
virtual void GLRenderOffPath (SoGLRenderAction *action)
virtual void callback (SoCallbackAction *action)
virtual void getBoundingBox (SoGetBoundingBoxAction *action)
virtual void getMatrix (SoGetMatrixAction *action)
virtual void rayPick (SoRayPickAction *action)
virtual void search (SoSearchAction *action)
virtual void getPrimitiveCount (SoGetPrimitiveCountAction *action)
virtual void audioRender (SoAudioRenderAction *action)
virtual void notify (SoNotList *nl)
virtual SbBool affectsState (void) const

🌈 Public Member Functions inherited from SoGroup

SoGroup (void)
SoGroup (int nchildren)
virtual void addChild (SoNode *node)
virtual void insertChild (SoNode *child, int newchildindex)
virtual SoNode * getChild (int index) const
virtual int findChild (const SoNode *node) const
virtual int getNumChildren (void) const
virtual void removeChild (int childindex)
virtual void removeChild (SoNode *child)
virtual void removeAllChildren (void)
virtual void replaceChild (int index, SoNode *newchild)
virtual void replaceChild (SoNode *oldchild, SoNode *newchild)
virtual void pick (SoPickAction *action)
virtual void write (SoWriteAction *action)
virtual SoChildList * getChildren (void) const

🌈 Public Member Functions inherited from SoNode

void setOverride (const SbBool state)
SbBool isOverride (void) const
void setNodeType (const NodeType type)
NodeType getNodeType (void) const
virtual SoNode * copy (SbBool copyconnections=0) const
virtual void grabEventsSetup (void)
virtual void grabEventsCleanup (void)
virtual void startNotify (void)
uint32_t getNodeId (void) const
virtual void writeInstance (SoOutput *out)
virtual SoNode * addToCopyDict (void) const
virtual SoFieldContainer * copyThroughConnection (void) const

🌈 Public Member Functions inherited from SoFieldContainer

void setToDefaults (void)
SbBool hasDefaultValues (void) const
SbBool fieldsAreEqual (const SoFieldContainer *container) const
void copyFieldValues (const SoFieldContainer *container, SbBool
    copyconnections=0)
SbBool set (const char *const fielddata)
void get (SbString &fielddata)
virtual int getFields (SoFieldList &l) const
virtual int getAllFields (SoFieldList &l) const
virtual SoField * getField (const SbName &name) const
virtual SoField * getEventIn (const SbName &name) const
virtual SoField * getEventOut (const SbName &name) const
SbBool getFieldName (const SoField *const field, SbName &name) const
SbBool enableNotify (const SbBool flag)
SbBool isNotifyEnabled (void) const
SbBool set (const char *fielddata, SoInput *in)
void get (SbString &fielddata, SoOutput *out)
virtual SbBool validateNewFieldValue (SoField *field, void *newval)
virtual void addWriteReference (SoOutput *out, SbBool isfromfield=0)
SbBool getIsBuiltIn (void) const
void setUserData (void *userdata) const
void * getUserData (void) const

🌈 Public Member Functions inherited from SoBase

void ref (void) const
void unref (void) const
void unrefNoDelete (void) const
int32_t getRefCount (void) const
void touch (void)
SbBool isOfType (SoType type) const
virtual SbName getName (void) const
virtual void setName (const SbName &newname)
void addAuditor (void *const auditor, const SoNotRec::Type type)
void removeAuditor (void *const auditor, const SoNotRec::Type type)
const SoAuditorList & getAuditors (void) const
SbBool shouldWrite (void)
void assertAlive (void) const

⭐ Static Public Member Functions

static SoType getClassTypeId (void)
static void initClass (void)

💫 Static Public Member Functions inherited from SoSeparator

static SoType getClassTypeId (void)
static void initClass (void)
static void setNumRenderCaches (const int howmany)
static int getNumRenderCaches (void)

💫 Static Public Member Functions inherited from SoGroup

static SoType getClassTypeId (void)
static void initClass (void)

💫 Static Public Member Functions inherited from SoNode

static uint32_t getCompatibilityTypes (const SoType &nodetype)
static SoType getClassTypeId (void)
static SoNode * getByName (const SbName &name)
static int getByName (const SbName &name, SoNodeList &l)
static void initClass (void)
static void initClasses (void)
static uint32_t getNextNodeId (void)
static int getActionMethodIndex (const SoType type)
static void getBoundingBoxS (SoAction *action, SoNode *node)
static void GLRenderS (SoAction *action, SoNode *node)
static void callbackS (SoAction *action, SoNode *node)
static void getMatrixS (SoAction *action, SoNode *node)
static void handleEventS (SoAction *action, SoNode *node)
static void pickS (SoAction *action, SoNode *node)
static void rayPickS (SoAction *action, SoNode *node)
static void searchS (SoAction *action, SoNode *node)
static void writeS (SoAction *action, SoNode *node)
static void audioRenderS (SoAction *action, SoNode *node)
static void getPrimitiveCountS (SoAction *action, SoNode *node)

💫 Static Public Member Functions inherited from SoFieldContainer

static void initClass (void)
static SoType getClassTypeId (void)
static void initCopyDict (void)
static void addCopy (const SoFieldContainer *orig, const
    SoFieldContainer *copy)
static SoFieldContainer * checkCopy (const SoFieldContainer *orig)
static SoFieldContainer * findCopy (const SoFieldContainer *orig, const
    SbBool copyconnections)
static void copyDone (void)

💫 Static Public Member Functions inherited from SoBase

static void initClass (void)
static SoType getClassTypeId (void)
static void addName (SoBase *const base, const char *const name)
static void removeName (SoBase *const base, const char *const name)
static void incrementCurrentWriteCounter (void)
static void decrementCurrentWriteCounter (void)
static SoBase * getNamedBase (const SbName &name, SoType type)
static int getNamedBases (const SbName &name, SoBaseList &baselist,
    SoType type)
static SbBool read (SoInput *in, SoBase *&base, SoType expectedtype)
static void setInstancePrefix (const SbString &c)
static void setTraceRefs (SbBool trace)
static SbBool getTraceRefs (void)
static SbBool connectRoute (SoInput *in, const SbName &fromnodename,
    const SbName &fromfieldname, const SbName &tonodename, const SbName
    &tofieldname)
static SbBool readRoute (SoInput *in)

🍓 Public Attributes

SoSFEnum policy

one field. one. and she's running the entire selection vibe with it. main character energy honestly. 💅

🍓 Public Attributes inherited from SoSeparator

SoSFEnum renderCaching
SoSFEnum boundingBoxCaching
SoSFEnum renderCulling
SoSFEnum pickCulling

🧚 Protected Member Functions

virtual const SoFieldData * getFieldData (void) const
virtual ~SoSelection ()
void invokeSelectionPolicy (SoPath *path, SbBool shiftDown)
void performSingleSelection (SoPath *path)
void performToggleSelection (SoPath *path)
SoPath * copyFromThis (const SoPath *path) const
void addPath (SoPath *path)
void removePath (const int which)
int findPath (const SoPath *path) const
virtual void handleEvent (SoHandleEventAction *action)
🔒 protected means hands off unless you're subclassing, bestie. no touching.

🧚 Protected Member Functions inherited from SoSeparator

virtual ~SoSeparator ()
virtual SbBool cullTest (SoState *state)
virtual SbBool cullTest (SoGLRenderAction *action, int &cullresults)
virtual SbBool readInstance (SoInput *in, unsigned short flags)

🧚 Protected Member Functions inherited from SoGroup

virtual ~SoGroup ()
virtual SbBool readChildren (SoInput *in)
virtual void copyContents (const SoFieldContainer *from, SbBool
    copyconnections)

🧚 Protected Member Functions inherited from SoNode

SoNode (void)
virtual ~SoNode ()

🧚 Protected Member Functions inherited from SoFieldContainer

SoFieldContainer (void)
~SoFieldContainer ()

🧚 Protected Member Functions inherited from SoBase

SoBase (void)
virtual ~SoBase ()
virtual void destroy (void)
SbBool hasMultipleWriteRefs (void) const
SbBool writeHeader (SoOutput *out, SbBool isgroup, SbBool isengine)
    const
void writeFooter (SoOutput *out) const
virtual const char * getFileFormatName (void) const

okay so that's the whole synopsis dump — every single signature, every inherited one, all of it, nothing skipped. that was the ✨layout✨. the actual tea (description, options, the callbacks, the policies, the examples) is coming in the next parts, so hold that thought bestie, we're not done yet 🫶

Static Protected Member Functions

  • static const SoFieldData ** getFieldDataPtr(void) — the static hook that gives you the pointer to this class's field-data blob. 💫

Static Protected Member Functions inherited from SoSeparator

  • static const SoFieldData ** getFieldDataPtr(void)

Static Protected Member Functions inherited from SoGroup

  • static const SoFieldData ** getFieldDataPtr(void)

Static Protected Member Functions inherited from SoNode

  • static const SoFieldData ** getFieldDataPtr(void)
  • static void setNextActionMethodIndex(int index)
  • static int getNextActionMethodIndex(void)
  • static void incNextActionMethodIndex(void)
  • static void setCompatibilityTypes(const SoType &nodetype, const uint32_t bitmask)

Static Protected Member Functions inherited from SoBase

  • static uint32_t getCurrentWriteCounter(void)
  • static void staticDataLock(void)
  • static void staticDataUnlock(void)

🔐 Protected Attributes

  • SoPathList selectionList — bestie, this is THE list. The actual pile of selected paths. 💖
  • SoCallbackList * selCBList — the callbacks that fire when something gets selected.
  • SoCallbackList * deselCBList — the callbacks that fire when something gets deselected.
  • SoCallbackList * startCBList — callbacks for when a selection interaction starts.
  • SoCallbackList * finishCBList — callbacks for when a selection interaction finishes.
  • SoSelectionPickCB * pickCBFunc — the pick callback function pointer.
  • void * pickCBData — user data that gets passed along with pickCBFunc.
  • SbBool callPickCBOnlyIfSelectable — flag controlling whether the pick callback fires only when the thing is actually selectable.
  • SoCallbackList * changeCBList — callbacks for whenever the selection list changes at all.
  • SoPath * mouseDownPickPath — the path that was picked when the mouse went down. 🖱️
  • SbBool pickMatching — the pick-matching flag.

Protected Attributes inherited from SoGroup

  • SoChildList * children

Protected Attributes inherited from SoNode

  • uint32_t uniqueId

Protected Attributes inherited from SoFieldContainer

  • SbBool isBuiltIn

🌈 Additional Inherited Members

Protected Types inherited from SoBase

  • enum BaseFlags { IS_ENGINE = 0x01, IS_GROUP = 0x02 }

Static Protected Attributes inherited from SoNode

  • static uint32_t nextUniqueId = 0
  • static int nextActionMethodIndex = 0

📖 Detailed Description

The SoSelection class manages a list of selected nodes. periodt. 👑

Drop an SoSelection node into your scene graph and boom — the user can now "pick" with the left mouse button to select/deselect the objects living below that SoSelection node. It's giving interactive. ✨

If you wanna give your user actual visual feedback about what's selected (and honestly, why wouldn't you), use an SoBoxHighlightRenderAction or an SoLineHighlightRenderAction to render scenegraphs containing SoSelection nodes. Convenient, lowkey iconic. 🎀

⚠️ Beware, bestie. There's one common faulty assumption people make about this node: they think the scene will automatically re-render whenever the user picks an object. It will not. Nope. Not happening. The application programmer must schedule a redraw themselves. The straightforward way to do that is to call SoNode::touch() on the SoSelection node inside the selection / deselection callback. That's the move. 💅

A "skeleton" for basic use of SoSelection nodes is given below:

extern SoSeparator * make_scenegraph( void );
static SoSelection * selection = NULL;

// Callback function triggered for selection / deselection.
void made_selection( void * userdata, SoPath * path )
{
  (void)fprintf( stdout, "%sselected %s\n",
                 userdata == (void *)1L ? "" : "de",
                 path->getTail()->getTypeId().getName().getString() );

  selection->touch(); // to redraw
}

// *************************************************************************

// Print a quick instructions notice on stdout.
void show_instructions( void )
{
  (void)fprintf( stdout, "\nThis example program demonstrates the use of the SoSelection node type.\n" );
  (void)fprintf( stdout, "\nQuick instructions:\n\n" );
  (void)fprintf( stdout, "  * pick with left mouse button\n" );
  (void)fprintf( stdout, "  * hold SHIFT to select multiple objects\n" );
  (void)fprintf( stdout, "  * hit ESC to toggle back and forth to view mode\n" );
  (void)fprintf( stdout, "\n" );
}

// *************************************************************************

int main( int argc, char ** argv )
{
  QWidget * window = SoQt::init( argv[0] );
  show_instructions();

  selection = new SoSelection;
  selection->policy = SoSelection::SHIFT;
  selection->ref();

  selection->addChild( make_scenegraph() );
  selection->addSelectionCallback( made_selection, (void *)1L );
  selection->addDeselectionCallback( made_selection, (void *)0L );

  SoQtExaminerViewer * examinerviewer = new SoQtExaminerViewer( window );
  examinerviewer->setSceneGraph( selection );
  examinerviewer->setGLRenderAction( new SoBoxHighlightRenderAction );
  examinerviewer->setViewing( FALSE );
  examinerviewer->show();

  SoQt::show( window );
  SoQt::mainLoop();

  delete examinerviewer;
  selection->unref();

  return 0;
}

Okay so important: this node is not initialized in SoDB::init(), because it's part of the interaction kit "add-on". So before you use this node, you should call SoInteraction::init(). 🙈 If you're using one of the standard GUI toolkits (SoXt / SoQt / SoWin), then SoInteraction::init() gets called for you from the So[Xt|Qt|Win]init() method, and you literally don't have to worry about it. Slay. 💖

Now, about running multiple SoSelection nodes at the same time in the same scene graph: it's possible, but it is not straightforward. The standard viewers from SoQt, SoWin, et al. will only snoop on one SoSelection node (that's part of the legacy API from SGI's InventorXt), so selection changes on the others don't trigger redraws. Translation: you don't necessarily see what's happening. 😭 You'll have to hook things up manually and trigger redraws yourself.

Also be aware that when you have multiple SoSelection nodes active in the scene graph at the same time, the SoHandleEventAction traversals you intend for a selection-change on one SoSelection node will also affect all the other SoSelection nodes in the scene — usually deselecting everything below them, since you'll be clicking outside the selectable objects. So you'll have to manually override that behaviour too, if you want a selection change on one SoSelection node to not affect the others. no cap. 💀

FILE FORMAT/DEFAULTS:

Selection {
    renderCaching AUTO
    boundingBoxCaching AUTO
    renderCulling AUTO
    pickCulling AUTO
    policy SHIFT
}

🎯 Member Enumeration Documentation

enum SoSelection::Policy

Enum for different pick policies. Pick your fighter. 🥊

Enumerator

  • SINGLE — Only one object can be selected at any time. When the user picks a new object, the previous selection will be unselected. If the user picks on nothing, the current selection will be unselected.
📌 Note that if a new selection matches one already present in the selection list, neither a deselect nor a select notification callback will be made about that selection path. So don't sit there waiting for a callback that isn't coming, bestie.
  • TOGGLE — Picking an object toggles its selection state. On and off, on and off. 🦋
  • SHIFT — Same as SINGLE, but when the shift key is pressed the selection policy will be changed to TOGGLE.

🛠️ Constructor & Destructor Documentation

SoSelection::SoSelection(void)

Default constructor. It's giving brand new. ✨

Referenced by getFieldData().

SoSelection::SoSelection(const int nChildren)

Constructor.

The argument should be the approximate number of children which is expected to be inserted below this node. The number need not be exact — it's only used as a hint for better memory resource allocation. So like, a vibe, not a contract. 💫

SoSelection::~SoSelection() [protected], [virtual]

Destructor. Cleanup era. 🧹

References changeCBList, deselCBList, finishCBList, mouseDownPickPath, selCBList, and startCBList.

📚 Member Function Documentation

SoType SoSelection::getTypeId(void) const [virtual]

Returns the type identification of an object derived from a class inheriting SoBase. This is used for run-time type checking and "downward" casting. Basically: who am I, really? 🪞

Usage example:

void foo(SoNode * node)
{
  if (node->getTypeId() == SoFile::getClassTypeId()) {
    SoFile * filenode = (SoFile *)node;  // safe downward cast, knows the type
  }
  else if (node->getTypeId().isOfType(SoGroup::getClassTypeId())) {
    SoGroup * group = (SoGroup *)node;  // safe downward cast, knows the type
  }
}

For application programmers wanting to extend the library with new nodes, engines, nodekits, draggers or others: this method needs to be overridden in all subclasses. This is typically done as part of setting up the full type system for extension classes, which is usually accomplished by using the pre-defined macros available through for instance Inventor/nodes/SoSubNode.h (SO_NODE_INIT_CLASS and SO_NODE_CONSTRUCTOR for node classes), Inventor/engines/SoSubEngine.h (for engine classes) and so on.

For more information on writing Coin extensions, see the class documentation of the toplevel superclasses for the various class groups.

Reimplemented from SoSeparator.

Reimplemented in SoExtSelection.

Referenced by SoBoxHighlightRenderAction::apply(), and SoLineHighlightRenderAction::apply().

const SoFieldData * SoSelection::getFieldData(void) const [protected], [virtual]

Returns a pointer to the class-wide field data storage object for this instance. If no fields are present, returns NULL. 💅

Reimplemented from SoSeparator.

Reimplemented in SoExtSelection.

References SoSelection().

void SoSelection::select(const SoPath * path)

Adds path to the list of selected objects. Welcome to the club, bestie. 🫶

References addPath(), copyFromThis(), findPath(), SoBase::ref(), and SoBase::unrefNoDelete().

Referenced by performSingleSelection(), performToggleSelection(), and toggle().

void SoSelection::select(SoNode * node)

Adds node to the list of selected objects. The scene graph below the Selection node will be searched, and the path to node will be added if found. 🔍

References addPath(), findPath(), SoNode::SoNode(), and SoBase::unref().

void SoSelection::deselect(const SoPath * path)

Remove path from the list of selected objects. bye bestie 😭

References findPath(), and removePath().

Referenced by deselect().

void SoSelection::deselect(const int which)

Remove objects which from the list of selected objects.

References removePath().

void SoSelection::deselect(SoNode * node)

Remove node from the list of selected objects. The scene graph below the Selection node will be searched, and the path to node will be removed if found.

References deselect(), SoNode::SoNode(), and SoBase::unref().

void SoSelection::toggle(const SoPath * path)

If path is not already selected, add path to the list of selected objects. Otherwise remove path from the list of selected objects. Flip-flop behaviour, we love her. 🔥

References findPath(), removePath(), and select().

Referenced by invokeSelectionPolicy(), and toggle().

void SoSelection::toggle(SoNode * node)

If node is not already selected, add path to the list of selected objects. Otherwise remove node from the list of selected objects.

References SoNode::SoNode(), toggle(), and SoBase::unref().

SbBool SoSelection::isSelected(const SoPath * path) const

Return TRUE if path is in the list of selected objects. ✅

References findPath().

Referenced by isSelected().

SbBool SoSelection::isSelected (SoNode * node) const

okay so bestie, you hand it a node, and it hands you back TRUE if the path to that node is chillin' in the list of selected objects. that's the whole vibe check. 💅

References: isSelected(), SoNode::SoNode(), and SoBase::unref().

void SoSelection::deselectAll (void )

nukes the whole selection list. everything gone. clear slate energy. 🧹✨

References: getNumSelected(), and removePath().

int SoSelection::getNumSelected (void ) const

tells you how many objects are currently selected. a little headcount of your chosen ones. 👑

References: selectionList.

Referenced by: SoBoxHighlightRenderAction::apply(), SoLineHighlightRenderAction::apply(), deselectAll(), and performSingleSelection().

const SoPathList * SoSelection::getList (void ) const

gives you back the actual list of selected objects, like handing over the whole group chat. 📋

References: selectionList.

Referenced by: SoBoxHighlightRenderAction::apply(), and SoLineHighlightRenderAction::apply().

SoPath * SoSelection::getPath (const int index) const

returns the index'th selected object. zero-indexed bestie, you know the drill. 🔢

References: selectionList.

Referenced by: performSingleSelection().

SoPath * SoSelection::operator[] (const int i) const

the fancy operator version for reaching into the selected objects — same energy, cuter syntax. ✨

References: selectionList.

void SoSelection::addSelectionCallback (SoSelectionPathCB * f, void * userData = NULL)

drops in a callback that gets called every single time an object gets selected. like a lil notification ping, but make it code. 🔔

See also: removeSelectionCallback()

References: selCBList.

void SoSelection::removeSelectionCallback (SoSelectionPathCB * f, void * userData = NULL)

takes one of those selection callbacks back out. unfollowed. 🫶

See also: addSelectionCallback()

References: selCBList.

void SoSelection::addDeselectionCallback (SoSelectionPathCB * f, void * userData = NULL)

same idea but for deselecting — this callback fires every time an object gets deselected. the breakup notification. 💔

See also: removeDeselectionCallback()

References: deselCBList.

void SoSelection::removeDeselectionCallback (SoSelectionPathCB * f, void * userData = NULL)

removes one of the deselection callbacks. bye bestie 👋

See also: addDeselctionCallback()

References: deselCBList.

void SoSelection::addStartCallback (SoSelectionClassCB * f, void * userData = NULL)

adds a callback that gets invoked when the user starts an interactive change to the list of selected objects.

this one is lowkey iconic for undo/redo, because it lets you stash the old selection list before anything gets messed with. 🧠✨

See also: addFinishCallback()

References: startCBList.

void SoSelection::removeStartCallback (SoSelectionClassCB * f, void * userData = NULL)

removes f from the list of start callbacks. simple as. 💅

See also: addStartCallback()

References: startCBList.

void SoSelection::addFinishCallback (SoSelectionClassCB * f, void * userData = NULL)

adds a callback that fires once the user has finished an interactive change to the list of selected objects. the closing credits callback. 🎬

See also: addStartCallback()

References: finishCBList.

void SoSelection::removeFinishCallback (SoSelectionClassCB * f, void * userData = NULL)

removes f from the list of finish callbacks. and that's a wrap. 🎀

See also: addFinishCallback()

References: finishCBList.

void SoSelection::setPickFilterCallback (SoSelectionPickCB * f, void * userData = NULL, const SbBool callOnlyIfSelectable = 1)

sets the pick filter callback. this one gets called whenever a path is about to be added to or removed from the list of selected objects. the callback function is supposed to return a replacement path that gets used instead of the picked path. and here's the tea: the returned path will be ref'ed, copied, and then unref'ed again by the SoSelection node. 🫠

if no callback is set (that's the default), the picked path itself gets used for selecting/deselecting. no middleman.

possible return values from the callback, bestie:

  • NULL — simulate that nothing was picked. this will clear the selection for the SINGLE policy. the handle event action will be halted. 🛑
  • a path — the path will be selected/deselected. the handle event action will be halted. 🛑
  • a path containing only the Selection node — as NULL, but the action will not be halted. 🤔
  • an empty path, or a path not containing the Selection node — the pick will be ignored. 🙈

and if callOnlyIfSelectable is TRUE, the callback will only be called if the Selection node is in the picked path.

References: callPickCBOnlyIfSelectable, pickCBData, and pickCBFunc.

void SoSelection::setPickMatching (const SbBool pickmatchflag)

when pickmatchflag is TRUE (which is the default, bestie), the mouse button release pick has to match the mouse button press pick before an object actually gets selected/deselected. no mismatched picks allowed. 🖱️✨

this flag should normally not be of interest to application programmers. fr fr, stay out of it.

References: pickMatching.

SbBool SoSelection::isPickMatching (void ) const

returns TRUE if pick matching is enabled. 💅

See also: setPickMatching()

References: pickMatching.

SbBool SoSelection::getPickMatching (void ) const

also returns TRUE if pick matching is enabled. yes it's basically the same thing as the one above, iconic twins. 👯

See also: setPickMatching()

References: pickMatching.

void SoSelection::addChangeCallback (SoSelectionClassCB * f, void * userData = NULL)

this API member is considered internal to the library, as it is not likely to be of interest to the application programmer. 🔒

used by the render area to receive notification when the selection list changes.

References: changeCBList.

void SoSelection::removeChangeCallback (SoSelectionClassCB * f, void * userData = NULL)

this API member is considered internal to the library, as it is not likely to be of interest to the application programmer. 🔒

used by the render area to receive notification when the selection list changes.

References: changeCBList.

void SoSelection::invokeSelectionPolicy (SoPath * path, SbBool shiftdown) [protected]

this API member is considered internal to the library, as it is not likely to be of interest to the application programmer. 🔒

References: performSingleSelection(), performToggleSelection(), policy, SHIFT, TOGGLE, and toggle().

Referenced by: handleEvent().

void SoSelection::performSingleSelection (SoPath * path) [protected]

this API member is considered internal to the library, as it is not likely to be of interest to the application programmer. 🔒

References: copyFromThis(), getNumSelected(), getPath(), SoBase::ref(), removePath(), select(), and SoBase::unref().

Referenced by: invokeSelectionPolicy().

void SoSelection::performToggleSelection (SoPath * path) [protected]

this API member is considered internal to the library, as it is not likely to be of interest to the application programmer. 🔒

References: SoPath::findNode(), findPath(), removePath(), and select().

Referenced by: invokeSelectionPolicy().

SoPath * SoSelection::copyFromThis (const SoPath * path) const [protected]

this API member is considered internal to the library, as it is not likely to be of interest to the application programmer. 🔒

References: SoPath::copy(), SoPath::findNode(), SoBase::ref(), and SoBase::unrefNoDelete().

Referenced by: findPath(), performSingleSelection(), and select().

void SoSelection::addPath (SoPath * path) [protected]

this API member is considered internal to the library, as it is not likely to be of interest to the application programmer. 🔒

References: changeCBList, selCBList, and selectionList.

Referenced by: select(), and select().

void SoSelection::removePath (const int which) [protected]

this API member is considered internal to the library, as it is not likely to be of interest to the application programmer. 🔒

References: changeCBList, deselCBList, SoBase::ref(), selectionList, and SoBase::unref().

Referenced by: deselect(), deselect(), deselectAll(), performSingleSelection(), performToggleSelection(), and toggle().

int SoSelection::findPath (const SoPath * path) const [protected]

this API member is considered internal to the library, as it is not likely to be of interest to the application programmer. 🔒

References: copyFromThis(), SoPath::getHead(), SoBase::ref(), selectionList, SoNode::SoNode(), and SoBase::unref().

Referenced by: deselect(), isSelected(), performToggleSelection(), select(), select(), and toggle().

void SoSelection::handleEvent (SoHandleEventAction * action) [protected], [virtual]

action method for SoHandleEventAction. 🎯

it inspects the event data from action, and processes it if it's something this node should actually react to.

nodes that influence the relevant state variables for how event handling is done also override this method, iykyk.

Reimplemented from: SoSeparator.

Reimplemented in: SoExtSelection.

References: callPickCBOnlyIfSelectable, SoPath::findNode(), finishCBList, SoHandleEventAction::getEvent(), SoPickedPoint::getPath(), SoHandleEventAction::getPickedPoint(), SoSeparator::handleEvent(), invokeSelectionPolicy(), SoHandleEventAction::isHandled(), mouseDownPickPath, pickCBData, pickCBFunc, SoBase::ref(), SoHandleEventAction::setHandled(), startCBList, and SoBase::unref().

Referenced by: SoExtSelection::handleEvent().

🎀 Member Data Documentation 🎀

Okay so bestie, this is the part where we spill the tea on the actual data members — the fields and pointers chillin' inside SoSelection. Most of them are [protected], and the docs keep saying "this is internal, not for you." But we still list every single one, because completeness is the vibe. 💅

  • SoSFEnum SoSelection::policy — this is the field for the selection policy. Default value? SHIFT, bestie. It's referenced by invokeSelectionPolicy(). ✨
  • SoPathList SoSelection::selectionList [protected] — the docs say this API member is considered internal to the library, as it is not likely to be of interest to the application programmer. It's referenced by addPath(), findPath(), getList(), getNumSelected(), getPath(), operator[](), and removePath(). 🦋
  • SoCallbackList* SoSelection::selCBList [protected] — the docs say this API member is considered internal to the library, as it is not likely to be of interest to the application programmer. It's referenced by addPath(), addSelectionCallback(), removeSelectionCallback(), and ~SoSelection(). 💖
  • SoCallbackList* SoSelection::deselCBList [protected] — the docs say this API member is considered internal to the library, as it is not likely to be of interest to the application programmer. It's referenced by addDeselectionCallback(), removeDeselectionCallback(), removePath(), and ~SoSelection(). 🌸
  • SoCallbackList* SoSelection::startCBList [protected] — the docs say this API member is considered internal to the library, as it is not likely to be of interest to the application programmer. It's referenced by addStartCallback(), handleEvent(), removeStartCallback(), and ~SoSelection(). ✨
  • SoCallbackList* SoSelection::finishCBList [protected] — the docs say this API member is considered internal to the library, as it is not likely to be of interest to the application programmer. It's referenced by addFinishCallback(), handleEvent(), removeFinishCallback(), and ~SoSelection(). 🎀
  • SoSelectionPickCB* SoSelection::pickCBFunc [protected] — the docs say this API member is considered internal to the library, as it is not likely to be of interest to the application programmer. It's referenced by handleEvent(), and setPickFilterCallback(). 👑
  • void* SoSelection::pickCBData [protected] — the docs say this API member is considered internal to the library, as it is not likely to be of interest to the application programmer. It's referenced by handleEvent(), and setPickFilterCallback(). 🫶
  • SbBool SoSelection::callPickCBOnlyIfSelectable [protected] — the docs say this API member is considered internal to the library, as it is not likely to be of interest to the application programmer. It's referenced by handleEvent(), and setPickFilterCallback(). 💜
  • SoCallbackList* SoSelection::changeCBList [protected] — the docs say this API member is considered internal to the library, as it is not likely to be of interest to the application programmer. It's referenced by addChangeCallback(), addPath(), removeChangeCallback(), removePath(), and ~SoSelection(). 🔥
  • SoPath* SoSelection::mouseDownPickPath [protected] — the docs say this API member is considered internal to the library, as it is not likely to be of interest to the application programmer. It's referenced by handleEvent(), and ~SoSelection(). 🌈
  • SbBool SoSelection::pickMatching [protected] — the docs say this API member is considered internal to the library, as it is not likely to be of interest to the application programmer. It's referenced by getPickMatching(), isPickMatching(), and setPickMatching(). ⭐

📝 Author 📝

This page was generated automatically by Doxygen for Coin from the source code. So no human author, just robot magic. It ate, honestly. 👑

And that's a wrap, bestie! Footer says Coin, Version 2.5.0, SoSelection(3) — that's your source, version, and page. Periodt. 💖

📦 where this page comes from