Index

abstract classes
Extender Macros

abstract node classes
Creating an Abstract Node Class

abstract types
node kit parts
Adding an Entry of Abstract Type

abstracts viewer classes
compared
Creating a New Viewer

accessing elements
Getting Elements in the State

accumulated elements
Pushing and Popping Elements

action behavior
typical
. See doAction()
The doAction() Method

action classes
example
creating
Creating a New Action
using
Using New Action Classes

actions
adding
Adding Nodes and Actions to Inventor
and manipulators
Implementing Actions for the Manipulator
applying
Using the Path Code
constructor
Defining the Constructor
creating
Creating an Action
destructor
Defining the Destructor
elements enabled in
Elements and Actions
implementing
Implementing Actions
initializing
Using New Action Classes
Initializing the Action Class
macros
Overview
nodes and elements
Setting Elements in the State
terminating
Using the Path Code

addConverter()
Initializing the Field Converter Class
The getInput() and getOutput() Methods

addExtensionEventHandler()
Enable Method

addVisibilityChangeCallback()
Visibility-Changed Callback Function

affectsState()
The affectsState() Method

Alternate group class
Alternate Node

Alternate group node
Creating a Group Node
Using New Node Classes

alternate representation
Creating an Alternate Representation

animation
Visibility-Changed Callback Function

antialiasing
Traversal Behavior

antisquish
Step f: Creating the Parts

antisquish node
SoAntiSquish Node

apply()
Traversal Behavior
The apply() Method

applying actions
Using the Path Code

arithmetic engines
Creating an Engine with Multiple Inputs

autoclipping
Creating a New Viewer

beginShape()
SoPrimitiveVertex

beginTraversal()
Traversal Behavior
Overview

bitmaps
for defining cursors
Using the Cursor for Feedback

blocking notification
Blocking Notification

bounding box
Step l: Setting Up Connections
Getting a Bounding Box

browser viewers
Defining the Constructor
Defining the Constructor

buffering types
viewer support for
Creating a New Viewer

building
widget tree
Defining the Constructor

building widgets
The buildWidget() Method

buildNow flag
Defining Public and Protected Constructors
Defining Public and Protected Constructors

buildViewerButtons()
Adding Push Buttons

buildWidget()
Defining Public and Protected Constructors
The buildWidget() Method

button box
Creating a Dial Event

ButtonBoxEvent
Creating a Dial Event
Translate Event Method

caching
Special Considerations for Caching
Creating a Highlight in the Overlay Planes
Deriving a Class from an Existing Element
Overview
Element Bundles
The apply() Method
Pushing and Popping Elements
Defining New Dragger Catalog Entries
Steps a through e
invalidation
Uncacheable Nodes
See also uncacheable nodes
Uncacheable Nodes

callback action
Overview

callback function
Visibility-Changed Callback Function
Creating a Simple Component

callback functions
Overview
Defining the Callback Functions
Callback Functions
Step l: Setting Up Connections
About This Book
for manipulators
Continue Dragging
generating primitives
Generating Primitives
selection
Overview
value-changed
Value-Changed Callback
Step j: Value-Changed Callback Function
Adding a Value-Changed Callback
visibility changed
Overview

camera
viewer methods for changing
Creating a New Viewer

camera orientation
Implementing the Seek Function

camera position
Implementing the Seek Function

cameras
viewers
Defining the Constructor

capture()
Pushing and Popping Elements

capturing state
for caching
Pushing and Popping Elements

catalog
Overview

catalog entries
adding
Adding a Catalog Entry
naming
Defining and Naming Catalog Entries

child draggers
Step l: Setting Up Connections
registering
Step l: Setting Up Connections

child list
Child List

child widgets
Defining Public and Protected Constructors

children
hidden
Hidden Children
Creating a Manipulator
Defining and Naming Catalog Entries
traversing
Using the Path Code

class tree
elements
Deriving a Class from an Existing Element

color editor
The show() and hide() Methods

compiling dragger geometry
Creating the Compiled-in Default Geometry

compiling in manipulator geometry
Creating the Compiled-in Default Geometry

components
constructor
Overview
example
Creating a Simple Component
hiding
The show() and hide() Methods
icon
Defining Public and Protected Constructors
iconifying
The show() and hide() Methods
showing
The show() and hide() Methods

composing vectors
Creating an Engine with Multiple Inputs

compound draggers
Creating a Compound Dragger
designing parts
Defining the Parts

computeBBox()
Getting a Bounding Box

computeCoordBBox()
Getting a Bounding Box

computeSeekVariables variable
Implementing the Seek Function

computing volumes
Creating a New Action

constrained viewer
creating
Creating a Constrained Viewer

constrained viewers
Creating a New Viewer

constructing a new viewer
Defining the Constructor

constructor
abstract classes
Creating an Abstract Node Class
actions
Defining the Constructor
components
Overview
compound dragger
Constructor
devices
Constructor
draggers
Constructor
engines
Defining the Constructor
node kits
JumpingJackKit
Defining the Constructor
Defining a Node-Kit Part
nodes
Defining the Constructor

constructorCommon()
Defining Public and Protected Constructors

constructors
for manipulators
Constructor

ConvertSFShortToSFFloat engine class
Sample Field Converter

Coord3Manip
Overview

copy()
The setUpConnections() Method
Defining the Constructor
The copy() Method

copying
viewers and
Creating a New Viewer

copyMatchInfo()
Special Considerations for Caching
Additional Methods

createLineDetail()
Picking

createPathToPart()
Anatomy of a Part

createPointDetail()
Picking

createPrefSheet()
Changing the Preference Sheet

createTriangleDetail()
Picking

createViewerButtons()
Adding Push Buttons

creating a constrained viewer
Creating a Constrained Viewer

creating actions
Creating an Action

creating compound draggers
Creating a Compound Dragger

creating details
Creating Details

creating devices
Overview

creating elements
Creating an Element

creating engines
Creating an Engine

creating events
Creating an Event

creating field converters
Creating a New Field Converter

creating fields
Creating a Field

creating group classes
Creating a Group Node

creating highlight styles
Creating a Selection Highlight Style

creating manipulators
Creating a Manipulator

creating node kits
Creating a Node Kit

creating nodes
Creating a Node

creating shape classes
Creating a Shape Node

creating simple draggers
Creating a Simple Dragger

creating viewers
Creating a New Viewer

cursor
Translating Events
defining for viewers
Using the Cursor for Feedback
viewers
Defining the Event-Processing Routines

cursors
where to define
Using the Cursor for Feedback

debugging
The print() Method

debugging library
Enabling Elements in the State
Enabling Elements

decomposing vectors
Creating an Engine with Multiple Outputs

decoration
viewers
Using the SoXtFullViewer Trim Decoration
example of building
Changing the Decoration Layout

decoration layout
viewers
Changing the Decoration Layout

defaults
elements
The init() Method

defineCursors()
Using the Cursor for Feedback

defining parts
Defining a Node-Kit Part

deriving new classes. See creating nodes, creating elements, etc.
Key Concepts

deriving new elements
Special Behavior for Derived Elements

designing draggers
Overview

destroying draggers
Destructor

destructor
actions
Defining the Destructor
draggers
Destructor
elements
Destructor

destructors
for mani
Constructor

detail seek
Implementing the Seek Function

details
creating
Creating Details

DeviceButtonPress()
Constructor

DeviceButtonRelease()
Constructor

DeviceMotionNotify()
Constructor

devices
constructor
Constructor
creating
Overview
example
Translate Event Method
registering
Translating an Event

DialEvent
Translate Event Method
Creating a Dial Event

disable()
Overview

disabling outputs
Notification and Evaluation
Creating a Second-Ticker Engine

dispatching events
Dispatching Events

doAction()
Creating a Property Node
Implementing Static Methods
The doAction() Method
Implementing Actions for the Manipulator

drag()
Dragging Callback Functions

dragFinish()
Dragging Callback Functions

dragger class
initializing
Initializing the Dragger Class

dragger switches
Setting the Switches
Begin Dragging

draggers
and manipulators
Creating a Manipulator
child and parent
Step l: Setting Up Connections
compound
children
Step l: Setting Up Connections
constructor
Constructor
creating
Creating a Compound Dragger
designing parts
Defining the Parts
example
Defining the Parts
constructor
Constructor
creating simple
Creating a Simple Dragger
designing
Overview
destroying
Destructor
destructor
Destructor
parts
default geometry
Defining the Parts
Creating the Default Geometry File
Creating the Compiled-in Default Geometry
designing
Creating the Default Geometry File
Designing the Parts
feedback
Designing the Parts
resources
Defining the Parts
simple
creating
Creating a Simple Dragger
example
The setUpConnections() Method
structure
Overview
uniform scaling
SoAntiSquish Node
writing to file
Creating the Parts

dragging
Dragging Callback Functions
Defining the Callback Functions

dragStart()
Dragging Callback Functions

editor viewers
Defining the Constructor
Defining the Constructor

element bundles
Element Bundles

element classes
example
Creating a New Element

element stacks
Setting Elements in the State

elements
accessing
Changing and Examining State Elements
Getting Elements in the State
actions
Elements and Actions
actions and nodes
Setting Elements in the State
class tree
Deriving a Class from an Existing Element
creating
Creating an Element
defaults
The init() Method
deriving from existing
Special Behavior for Derived Elements
destructor
Destructor
enabling
Enabling Elements in the State
Creating a New Action
Enabling Elements in the State
Enabling Elements
GL versions
State Elements
Special Behavior for Derived Elements
Deriving a Class from an Existing Element
initializing
The initClass() Method
Deriving a Class from an Existing Element
listed
State Elements
macros
Overview
pushing and popping
Pushing and Popping Elements
setting
Changing and Examining State Elements
Setting Elements in the State

enable field
Blocking Notification

enable()
Enable Method
Overview

enabling elements
Enabling Elements in the State
Enabling Elements in the State
Creating a New Action
Enabling Elements

enabling outputs
Notification and Evaluation

endShape()
SoPrimitiveVertex

engines
simple
example
Creating a Simple Engine

engine network
Notification and Evaluation
Notification and Evaluation

engines
arithmetic
Creating an Engine with Multiple Inputs
constructor
Defining the Constructor
controlling notification
example
Creating a Second-Ticker Engine
creating
Creating an Engine
defining inputs
Defining Inputs and Outputs
defining outputs
Defining Inputs and Outputs
fan-in
example
Creating a Fan-in Engine
initializing
Initializing the Engine Class
inputs
Overview
macros
Overview
multiple inputs
example
Creating an Engine with Multiple Inputs
multiple outputs
example
Creating an Engine with Multiple Outputs
outputs
Overview
replicating field values
Creating an Engine with Multiple Inputs
See also field converters
Creating a New Field Converter

enumerated values
Defining Enumerated Values for a Field

evaluate()
The evaluate() Method
Blocking Notification
Notification and Evaluation
What Inventor Does behind the Scenes

evaluation
Notification and Evaluation
sequence
What Inventor Does behind the Scenes

event callbacks
JumpingJackKit

event handler
Translating an Event

event processing
viewers
Defining the Event-Processing Routines

event translator
Translating Events

events
common to all viewers
Defining the Event-Processing Routines
creating
Creating an Event
dispatching
Dispatching Events
example
Creating a Dial Event
extender
and manipulators
Creating an Event and Device
translating
Creating an Event
illustration
Translating an Event

examples
action class
Creating a New Action
components
Creating a Simple Component
devices
Translate Event Method
draggers
compound
Defining the Parts
simple
The setUpConnections() Method
element class
Creating a New Element
engines
controlling notification
Creating a Second-Ticker Engine
fan-in
Creating a Fan-in Engine
multiple inputs
Creating an Engine with Multiple Inputs
multiple outputs
Creating an Engine with Multiple Outputs
simple
Creating a Simple Engine
event
Creating a Dial Event
field class
Creating a Single-Value Field
Creating a Multiple-Value Field
field converter
Sample Field Converter
group class
Alternate Node
highlights
overlay planes
Creating a Highlight in the Overlay Planes
selected objects
Rendering Only Selected Objects
manipulators
Coord3Manip
Deriving a Class from SoCoordinate3
transform
Deriving a Class from SoTransformManip
node kits
JumpingJackKit
JumpingJackKit
PyramidKit
PyramidKit
SoAppearanceKit
SoAppearanceKit
property class
Creating a Property Node
shape class
Pyramid Node
simple viewer
Using the Cursor for Feedback

extender classes
summary
Adding Nodes and Actions to Inventor

extender macros
Extender Macros

FanIn engine class
Creating a Fan-in Engine

feedback
from cursor
Using the Cursor for Feedback

feedback geometry
Begin Dragging

feedback parts
draggers
Designing the Parts
Defining the Parts

field classes
example
Creating a Single-Value Field
Creating a Multiple-Value Field

field converters
creating
Creating a New Field Converter
example
Sample Field Converter
initializing
Initializing the Field Converter Class

field sensor
Field Sensor
Adding a Field Sensor
Overview

field sensors
Step k: Field Sensors

field types
writing
Using New Node Classes

fields
Setting Up the Node's Fields
creating
Creating a Field
initializing
Initializing the Field Class
macros
Overview
multiple-value
creating
Creating a Multiple-Value Field
reading
Creating a Single-Value Field
single-value
creating
Creating a Single-Value Field
touching
Notification and Evaluation
writing
Creating a Single-Value Field

fieldSensorCB()
Callback Functions

file format
Creating the Default Geometry File
unknown nodes
Using New Node Classes

finishing manipulation
Finish Dragging

flags
buildNow
Defining Public and Protected Constructors
Defining Public and Protected Constructors
isBuiltIn
Using New Node Classes
Override
Changing and Examining State Elements
Setting Elements in the State

form widget
Changing the Preference Sheet
Defining Public and Protected Constructors

free()
Creating a Multiple-Value Field

freeing memory
Destructor

gate engines
Blocking Notification

generatePrimitives()
Creating a Shape Node
SoPrimitiveVertex
Picking

generating primitives
Generating Primitives

geometry
dragger parts
Creating the Default Geometry File
Defining the Parts
feedback
Begin Dragging
for manipulators
Creating the Compiled-in Default Geometry

geomSeparator
Overview

get()
Changing and Examining State Elements
The set() and get() Methods
Changing and Examining State Elements

getAnyPart()
Step l: Setting Up Connections

getBoundingBox()
Creating a Shape Node
Getting a Bounding Box
Getting a Bounding Box

getCamera()
Creating a New Viewer

getChildren()
Hidden Children

getClassTypeId()
Runtime Types

getElement()
SoReplacedElement

getInput()
The getInput() and getOutput() Methods

getInstance()
Changing and Examining State Elements

getLocalStartingPoint()
Begin Dragging

getLocalToWorldMatrix()
Overview
Begin Dragging

getNodekitCatalog()
Overview

getNum()
Creating an Engine with Multiple Outputs
Changing and Examining State Elements

getOutput()
The getInput() and getOutput() Methods

getParentWidget()
Defining Public and Protected Constructors

getPart()
Anatomy of a Part

getPathCode()
Using the Path Code

getSeekTime()
Implementing the Seek Function

getTypeId()
Runtime Types

getValue()
Notification and Evaluation
Blocking Notification
What Inventor Does behind the Scenes

getViewVolume()
Begin Dragging

GetVolumeAction
Creating a New Action

GL elements
State Elements

GL versions
elements
Special Behavior for Derived Elements
Deriving a Class from an Existing Element

global dictionary
Putting Default Parts into the Global Dictionary
Steps a through e

Glow property class
Creating a Property Node

Glow property node
Using New Node Classes
Creating a Property Node

glPushMatrix()
Pushing and Popping Elements

GLRender()
Creating a Shape Node
Rendering

group classes
creating
Creating a Group Node
example
Alternate Node

groups
hidden children
Hidden Children
path code
Using the Path Code

handle box
Creating a Manipulator

headlight
Creating a New Viewer

help card
for components
Overview

hidden children
Defining and Naming Catalog Entries
Hidden Children
Creating a Manipulator

hide()
The show() and hide() Methods
Overview

hiding components
The show() and hide() Methods

hierarchy
widget
The buildWidget() Method

highlight path
The apply() Method

highlight styles
creating
Creating a Selection Highlight Style

highlights
appearance
Overview
overlay planes
Creating a Highlight in the Overlay Planes
example
Creating a Highlight in the Overlay Planes
selected objects
example
Rendering Only Selected Objects

iconifying components
Defining Public and Protected Constructors
The show() and hide() Methods

icons
key to
Key to Scene Graph Diagrams

identification number
nodes
Caching

implementing actions
Implementing Actions

implementing static methods
actions
Implementing Static Methods

inheritance
Adding Nodes and Actions to Inventor
element stack
Inheritance within the Element Stack

init() method
Destructor

initClass()
Enabling Elements
Defining the Constructor
JumpingJackKit
Runtime Types
Initializing the Field Converter Class
Enabling Elements in the State
Initializing the Node Class
Initializing the Node-Kit Class

initClass() method
actions
Initializing the Action Class
for draggers
Initializing the Dragger Class
for events
Overview
nodes
Creating an Abstract Node Class

initialization
node classes
Using New Node Classes

initializing actions
Using New Action Classes
Initializing the Action Class

initializing elements
The initClass() Method
Deriving a Class from an Existing Element

initializing engines
Initializing the Engine Class

initializing field converters
Initializing the Field Converter Class

initializing fields
Initializing the Field Class

initializing node kits
Initializing the Node-Kit Class

initializing nodes
Initializing the Node Class

initializing SoXt
Overview

inputChanged()
What Inventor Does behind the Scenes
Notification and Evaluation
Notification and Evaluation
Blocking Notification
Creating a Fan-in Engine

inputs
engines
Overview
multiple-value
Creating an Engine with Multiple Inputs

interaction
viewers
callback functions for
Defining the Event-Processing Routines

interactiveCountDec()
Defining the Event-Processing Routines

interactiveCountInc()
Defining the Event-Processing Routines

internal parts
Anatomy of a Part
Anatomy of a Part

interpolateSeekAnimation()
Implementing the Seek Function

invalidate()
Uncacheable Nodes
Step l: Setting Up Connections

invalidateSurroundScaleCB()
Callback Functions
Step l: Setting Up Connections

Inventor Component Library
Creating an Event and Device

Inventor events
translating X events into
Translating Events

invokeLineSegmentCallbacks()
SoPrimitiveVertex

invokePointCallbacks()
SoPrimitiveVertex

invokeTriangleCallbacks()
SoPrimitiveVertex

isBuiltIn flag
Using New Node Classes

isDetailSeek()
Implementing the Seek Function

isDialEvent()
Overview

isList parameter
node kit parts
Anatomy of a Part

isOfType()
Runtime Types

isPublic parameter
node kit parts
Anatomy of a Part

ivToIncludeFile utility
Creating the Compiled-in Default Geometry
Defining the Parts

JumpingJackKit
JumpingJackKit

keyboard
Translating an Event

layoutPartsAndMapPrefSheet()
Changing the Preference Sheet

lazy evaluation
Notification and Evaluation

leaf parts
Anatomy of a Part

line segment callback function
SoPrimitiveVertex

line segments
Generating Primitives

list parts
Anatomy of a Part
adding to node kits
Adding a List Entry

listContainerType parameter
node kit parts
Anatomy of a Part

listItemType parameter
node kit parts
Anatomy of a Part

local space
Overview
Begin Dragging

macros
abstract versions
Creating an Abstract Node Class
actions
Overview
elements
Overview
engines
Overview
extender
Extender Macros
fields
Overview
node kits
Overview
Defining a Node-Kit Part
nodes
Overview

main loop
SoXt
Dispatching Events
code for
SoXt Main Loop

malloc()
Creating a Multiple-Value Field

manipulation
finishing
Finish Dragging

manipulators
and actions
Implementing Actions for the Manipulator
and draggers
Creating a Manipulator
and extender events
Creating an Event and Device
and selection
Overview
constructors
Constructor
Coord3Manip
example
Deriving a Class from SoCoordinate3
creating
Creating a Manipulator
destructors
Constructor
transform
example
Deriving a Class from SoTransformManip
uniform scaling
SoAntiSquish Node
user interface
Creating a Manipulator

matches()
Additional Methods
Caching
Special Considerations for Caching

material editor
The show() and hide() Methods

matrix
motion
Overview

memory
freeing
Destructor

method list
Adding Nodes and Actions to Inventor
Registering Static Methods
Deriving a Class from an Existing Element
Adding Nodes and Actions to Inventor

methods
virtual
Adding Nodes and Actions to Inventor

MFDouble field class
Creating a Multiple-Value Field

Motif-compliant widgets
Changing the Pop-up Menu

motion matrix
Continue Dragging
Callback Functions
Step j: Value-Changed Callback Function
Overview

motionMatrix
Adding a Value-Changed Callback

mouse
Begin Dragging
Creating the Projector
Defining the Event-Processing Routines
Translating an Event
movement of
Defining the Callback Functions

multiple-value fields
Creating a Multiple-Value Field

multiple-value inputs
Creating an Engine with Multiple Inputs

multiple-value outputs
Creating an Engine with Multiple Outputs

names
part
Anatomy of a Part

naming catalog entries
Defining and Naming Catalog Entries

network
engine
Notification and Evaluation

newCamOrientation variable
Implementing the Seek Function

newCamPosition variable
Implementing the Seek Function

node classes
abstract
Creating an Abstract Node Class
extender
using
Using New Node Classes
initializing
Using New Node Classes
Using New Node Classes

node ID
Caching
SoAccumulatedElement

node kits
catalogs
Overview
parts
structure
Anatomy of a Part

node kit macros
Defining a Node-Kit Part

node kit path
The apply() Method

node kits
and selection
The apply() Method
catalog
abstract entries
Adding an Entry of Abstract Type
catalogs
defining
Overview
inheriting
Changing the Type of a Part
constructor
Defining a Node-Kit Part
Defining the Constructor
creating
Creating a Node Kit
example
JumpingJackKit
JumpingJackKit
PyramidKit
PyramidKit
SoAppearanceKit
SoAppearanceKit
using
JumpingJackKit
hidden children
Hidden Children
initializing
Initializing the Node-Kit Class
list parts
Anatomy of a Part
Anatomy of a Part
Anatomy of a Part
Adding a List Entry
Anatomy of a Part
macros
Defining a Node-Kit Part
Overview
parts
Overview
SoAppearanceKit
SoAppearanceKit
access to
Anatomy of a Part
default types
Anatomy of a Part
names
Anatomy of a Part
Anatomy of a Part
Anatomy of a Part
parameters for defining
Anatomy of a Part
public
Anatomy of a Part
structure
Anatomy of a Part
Anatomy of a Part
types
Anatomy of a Part
Changing the Type of a Part
parts list
Defining the Constructor
See alsocatalog, parts
Overview
subclassing
macros
Defining the Constructor

nodekitCatalog
Overview

nodes
adding
Adding Nodes and Actions to Inventor
antisquish
SoAntiSquish Node
constructor
Defining the Constructor
creating
Creating a Node
elements and actions
Setting Elements in the State
icons for
Key to Scene Graph Diagrams
initializing
Initializing the Node Class
macros
Overview
property
Creating a Property Node
surround-scale
Creating a Manipulator
SoSurroundScale Node
switch
Designing the Parts
uncacheable
Uncacheable Nodes

notification
Notification and Evaluation
blocking
Blocking Notification
sequence
What Inventor Does behind the Scenes

nullAction()
Implementing Static Methods

nullByDefault parameter
node kits parts
Anatomy of a Part

oldCamOrientation variable
Implementing the Seek Function

oldCamPosition variable
Implementing the Seek Function

Open Inventor C++ Reference Manual
The buildWidget() Method
Creating the Projector
About This Book

OpenGL
Inheritance within the Element Stack
Rendering

openHelpCard()
Overview

orientFeedbackGeometry()
Begin Dragging

outputs
disabling
Notification and Evaluation
Creating a Second-Ticker Engine
enabling
Notification and Evaluation
engines
Overview
multiple-value
Creating an Engine with Multiple Outputs

overlay planes
Creating a Highlight in the Overlay Planes

OverlayHighlightRenderAction
Creating a Highlight in the Overlay Planes

Override flag
Changing and Examining State Elements
Setting Elements in the State

parent widget
Defining Public and Protected Constructors

parentName parameter
node kit parts
Anatomy of a Part

part names
Anatomy of a Part

part types
Anatomy of a Part

parts
defining
Defining a Node-Kit Part
draggers
Designing the Parts
internal
Anatomy of a Part
Anatomy of a Part
list
Anatomy of a Part
lists
Anatomy of a Part
node kit
Overview
Defining a Node-Kit Part
public
Anatomy of a Part
types of
Changing the Type of a Part

pasting
viewers and
Creating a New Viewer

path code
Using the Path Code

paths
and selection highlighting
The apply() Method

picked point
Picking

picking
Picking

point callback function
SoPrimitiveVertex

points
Generating Primitives

pop()
Additional Methods
Pushing and Popping Elements

pop-up menu
Creating a New Viewer

popping elements
Pushing and Popping Elements

popup menu
viewers
viewers:changing the popup menu
Changing the Pop-up Menu

preference sheet
The show() and hide() Methods
Creating a New Viewer
example of creating
Changing the Preference Sheet
viewer
Changing the Preference Sheet

primitives
generating
Generating Primitives

print()
The print() Method

processCommonEvents()
Defining the Event-Processing Routines

processEvent()
Defining the Event-Processing Routines
Using the Cursor for Feedback

processEvent() method
for viewers
Defining the Event-Processing Routines

projector
Begin Dragging

projectors
Overview
for manipulators
Creating the Projector

property classes
creating
Creating a Property Node
example
Creating a Property Node

property nodes
Creating a Property Node

protected constructor
components
Defining Public and Protected Constructors

prototyping
Creating a Shape Node

public constructor
components
Defining the Constructor

public parts
Anatomy of a Part

push buttons
Creating a New Viewer
adding to a viewer
Adding Push Buttons
size of
Adding Push Buttons

push()
Pushing and Popping Elements
Additional Methods

push() method
Destructor

pushing elements
Pushing and Popping Elements

Pyramid shape node
Pyramid Node
Using New Node Classes

PyramidKit
PyramidKit

rayPick()
Picking
Creating a Shape Node

read()
Creating a Group Node
Creating a Single-Value Field

readDefaultParts()
Putting Default Parts into the Global Dictionary

reading fields
Creating a Single-Value Field

readInstance()
The setUpConnections() Method
Defining the Constructor

realloc()
Creating a Multiple-Value Field

realTime global field
Creating a Second-Ticker Engine

redraw sensor
Notification and Evaluation

registerChildDragger()
Step l: Setting Up Connections

registerChildDraggerCallbacksOnly()
Step l: Setting Up Connections

registerDevice()
Translating an Event

registering child draggers
Step l: Setting Up Connections

registering devices
Translating an Event

registering static methods
Registering Static Methods

registering widgets
The buildWidget() Method

registerWidget()
The buildWidget() Method

render area
Visibility-Changed Callback Function
Translating an Event

rendering
Rendering

replaceManip()
Overview

replaceNode()
Overview

replicating field values
engines
Creating an Engine with Multiple Inputs

reset node
SoSurroundScale Node

resetToHomePosition()
Creating a New Viewer

resources
draggers
Defining the Parts
X
The buildWidget() Method

rightSiblingName parameter
node kit parts
Anatomy of a Part

root
scene graph
The apply() Method
widget tree
Defining Public and Protected Constructors

RotTransDragger
Creating a Compound Dragger

RotTransManip
Creating a Manipulator

run-time type-checking
The initClass() Method

runtime type checking
Initializing the Field Class
The initClass() Method

runtime types
Runtime Types

saveHomePosition()
Creating a New Viewer

SbLineProjector
Creating the Projector

SbPList
Adding Push Buttons

SbProjector
Creating the Projector

scaling
draggers and manipulators
SoAntiSquish Node

scene graph
Actions, State, and Elements
changes in
Notification and Evaluation
icons for nodes in
Key to Scene Graph Diagrams
traversing
Traversal Behavior

scene graph root
The apply() Method

search action
The apply() Method

search()
Adding Nodes and Actions to Inventor

second-ticker engine
Creating a Second-Ticker Engine

seek function
Implementing the Seek Function

seekDistance variable
Implementing the Seek Function

seekDistAsPercentage variable
Implementing the Seek Function

seeking
viewers
Creating a New Viewer

seekNormal variable
Implementing the Seek Function

seekPoint variable
Implementing the Seek Function

seekToPoint()
Implementing the Seek Function

selection
and manipulators
Overview
and node kits
The apply() Method

selection callback functions
Overview

selection highlight styles. See highlight styles
Creating a Selection Highlight Style

selection list
The apply() Method

selection node
Translating an Event

selection path
The apply() Method

sensor
redraw
Notification and Evaluation

sensors
attaching and detaching
The setUpConnections() Method
field
Field Sensor
Adding a Field Sensor
Step k: Field Sensors
Overview

separators
Deriving a Class from an Existing Element

sequence
notification
What Inventor Does behind the Scenes

set()
Setting Elements in the State
Changing and Examining State Elements
The set() and get() Methods

setBaseWidget()
Defining Public and Protected Constructors
Defining the Constructor

setCamera()
Creating a New Viewer

setClassName()
Defining Public and Protected Constructors

setColor()
Overview

setDetail()
Creating Details

setDetailSeek()
Implementing the Seek Function

setDragger()
Overview

setElt()
Special Behavior for Derived Elements
Additional Methods

setIconTitle()
Defining Public and Protected Constructors

setLinePattern()
Overview

setLineWidth()
Overview

setNum()
Creating an Engine with Multiple Outputs

setPart()
Anatomy of a Part
Creating the Parts

setPartAsDefault()
Creating the Parts
Step l: Setting Up Connections

setSeekMode()
Using the Cursor for Feedback

setSeekTime()
Implementing the Seek Function

setSwitchValue()
Setting the Switches

setting elements
Setting Elements in the State

setTitle()
Defining Public and Protected Constructors

setUpConnections()
The setUpConnections() Method
Step l: Setting Up Connections
Defining the Constructor

setValue()
What Inventor Does behind the Scenes

setViewing()
Using the Cursor for Feedback

SFDouble class
Creating a Single-Value Field

shape classes
creating
Creating a Shape Node
example
Pyramid Node

shapes
computing volume
Creating a New Action

shapeVertex()
SoPrimitiveVertex

shouldGLRender()
SoShape method
Rendering

shouldRayPick()
SoShape method
Picking

show()
The show() and hide() Methods
Overview

showing components
The show() and hide() Methods

side effects
elements
Pushing and Popping Elements

single-value fields
Creating a Single-Value Field

SO_ACTION_ADD_METHOD()
Registering Static Methods

SO_ACTION_CONSTRUCTOR()
Defining the Constructor

SO_ACTION_HEADER()
Overview

SO_ACTION_INIT_CLASS()
Initializing the Action Class

SO_ACTION_SOURCE()
Overview

SO_ELEMENT_HEADER()
Overview

SO_ELEMENT_INIT_ABSTRACT_CLASS()
The initClass() Method

SO_ELEMENT_INIT_CLASS()
The initClass() Method

SO_ELEMENT_SOURCE()
Overview

SO_ENABLE()
Enabling Elements
Enabling Elements in the State

SO_ENGINE_ADD_INPUT()
Defining the Constructor

SO_ENGINE_ADD_OUTPUT()
Defining the Constructor

SO_ENGINE_CONSTRUCTOR()
Defining the Constructor

SO_ENGINE_HEADER()
Overview

SO_ENGINE_INIT_CLASS()
Initializing the Engine Class
Initializing the Field Converter Class

SO_ENGINE_OUTPUT()
Implementing an evaluate() Method

SO_ENGINE_SOURCE()
Overview

SO_EVENT_HEADER()
Overview

SO_EVENT_INIT_CLASS()
Overview

SO_EVENT_SOURCE()
Overview

SO_KIT_ADD_CATALOG_ABSTRACT_ENTRY()
Adding an Entry of Abstract Type

SO_KIT_ADD_CATALOG_ENTRY
Adding a Catalog Entry

SO_KIT_ADD_CATALOG_ENTRY()
Steps a through e
Defining New Dragger Catalog Entries

SO_KIT_ADD_CATALOG_LIST_ENTRY()
Adding a List Entry

SO_KIT_ADD_LIST_ITEM_TYPE()
Adding a Type to a List Entry

SO_KIT_CATALOG_ENTRY_HEADER()
Defining and Naming Catalog Entries

SO_KIT_CHANGE_ENTRY_TYPE()
Changing the Type of a Part

SO_KIT_CONSTRUCTOR()
Steps a through e
Constructor
Constructor

SO_KIT_HEADER()
Overview

SO_KIT_INIT_CLASS()
Initializing the Dragger Class
Initializing the Node-Kit Class

SO_KIT_INIT_INSTANCE()
Defining the Constructor
Steps a through e
Constructor

SO_KIT_IS_FIRST_INSTANCE()
Putting Default Parts into the Global Dictionary

SO_KIT_SOURCE()
Overview

SO_MFIELD_DERIVED_HEADER()
Creating a Multiple-Value Field
Creating a Multiple-Value Field

SO_MFIELD_DERIVED_SOURCE()
Creating a Multiple-Value Field

SO_MFIELD_HEADER()
Creating a Multiple-Value Field
Creating a Multiple-Value Field

SO_MFIELD_INIT()
Initializing the Field Class

SO_MFIELD_SOURCE()
Creating a Multiple-Value Field

SO_MFIELD_SOURCE_MALLOC()
Creating a Multiple-Value Field

SO_NODE_ADD_FIELD()
Setting Up the Node's Fields
Overview

SO_NODE_CONSTRUCTOR()
Defining the Constructor

SO_NODE_DEFINE_ENUM_VALUE()
Defining Enumerated Values for a Field

SO_NODE_HEADER()
Overview

SO_NODE_INIT_CLASS()
Overview
Initializing the Node Class

SO_NODE_IS_FIRST_INSTANCE()
Defining the Constructor

SO_NODE_SET_SF_ENUM_TYPE()
Defining Enumerated Values for a Field

SO_NODE_SOURCE()
Overview

SO_SFIELD_DERIVED_HEADER()
Creating a Single-Value Field

SO_SFIELD_DERIVED_SOURCE()
Creating a Single-Value Field

SO_SFIELD_HEADER()
Creating a Single-Value Field
Creating a Single-Value Field

SO_SFIELD_INIT()
Creating a Single-Value Field
Initializing the Field Class

SO_SFIELD_SOURCE()
Creating a Single-Value Field

SoAccumulatedElement
Deriving a Class from an Existing Element
SoAccumulatedElement

SoAction.h
Enabling Elements in the State

SoAntiSquish
SoAntiSquish Node
Step f: Creating the Parts

SoAppearanceKit
SoAppearanceKit
SoAppearanceKit
SoAppearanceKit
catalog diagram
SoAppearanceKit

SoBaseKit
Overview
Overview

SoBoxHighlightRenderAction
Built-in Highlighting

SoButtonEvent
Translating Events

SoCalculator
Creating a Simple Engine

SoCallback
About This Book
Uncacheable Nodes

SoCallbackAction
Generating Primitives
About This Book

SoCenterBallDragger
Creating a Compound Dragger

SoChildList
Child List

SoComposeVec2f
Creating an Engine with Multiple Inputs
Implementing an evaluate() Method

SoCoordinate3
Overview

SoDecomposeVec2f
Creating an Engine with Multiple Outputs

SoDetail
SoPrimitiveVertex

SoDirectionalLightManip
Creating a Manipulator

SoDragger
Overview
Begin Dragging
Overview

SoEvent
Translating an Event
subclasses
Translating Events

SoEventCallback
About This Book
JumpingJackKit

SoEXTENDER
About This Book
summary of classes
Adding Nodes and Actions to Inventor

SoFieldContainer
Using New Node Classes

SoFloatElement
Deriving a Class from an Existing Element
SoFloatElement and SoLongElement
Creating an Element

SoGate
Blocking Notification

SoGLRenderAction
Overview
Creating a Highlight in the Overlay Planes
Built-in Highlighting

SoGroup
Adding a List Entry
Child List

SoHandleEventAction
Creating an Event and Device

SoHighlight
creating a subclass
Overview
rendering
Overview

SoIndexedShape
Getting a Bounding Box

SoInput
Creating a Single-Value Field

SoINTERNAL
About This Book

SoLineHighlightRenderAction
Built-in Highlighting

SoLocation2Event
Translating Events

SoLongElement
SoFloatElement and SoLongElement
Deriving a Class from an Existing Element

SoMaterialBundle
Element Bundles

SoMotion3Event
Translating Events

SoNode
Overview
Adding Nodes and Actions to Inventor

SoNonIndexedShape
Getting a Bounding Box

SoNormalBundle
Element Bundles

SoOutput
Creating a Single-Value Field

SoPickedPoint
Picking

SoPointLightManip
Creating a Manipulator
Creating a Manipulator

SoPrimitiveVertex
SoPrimitiveVertex

SoReplacedElement
SoReplacedElement
Deriving a Class from an Existing Element

SoRotateCylindricalDragger
Creating a Compound Dragger
Defining the Parts

SoRotateDiscDragger
Defining the Parts

SoSelection
highlight rendering
Overview

SoSeparatorKit
Case Study: The Parts of SoSeparatorKit
behavior parameters
Case Study: The Parts of SoSeparatorKit
catalog diagram
Case Study: The Parts of SoSeparatorKit
catalog layout
Case Study: The Parts of SoSeparatorKit

SoSFNode
Defining and Naming Catalog Entries

SoShape
Generating Primitives

SoShapeKit
Case Study: The Parts of SoSeparatorKit
derived class
PyramidKit

SoSpotLightManip
Creating a Manipulator

SoState
Enabling Elements
Actions, State, and Elements

SoSubAction.h
Overview

SoSubElement.h
Overview

SoSubEngine.h
Overview

SoSubEvent.h
Overview

SoSubField.h
Overview
Creating a Single-Value Field

SoSubKit.h
Overview

SoSubNode.h
Overview

SoSurroundScale
SoSurroundScale Node
Step l: Setting Up Connections
Defining the Parts

SoSwitchElement
Creating a New Action

SoTextureCoordinateBundle
Element Bundles

SoTransformBoxDragger
Creating a Compound Dragger

SoTransformManip
SoSurroundScale Node
Creating a Manipulator

SoType
Runtime Types

SoWrapperKit
Case Study: The Parts of SoSeparatorKit

SoXt
initializing
Overview

SoXt main loop
Dispatching Events
code for
SoXt Main Loop

SoXtConstrainedViewer
Creating a New Viewer
Creating a New Viewer
creating a subclass of
Creating a Constrained Viewer

SoXtCursors.h
Using the Cursor for Feedback

SoXtFlyViewer
Creating a Constrained Viewer
Implementing the Seek Function

SoXtFullViewer
Changing the Decoration Layout
Creating a New Viewer
Creating a New Viewer

SoXtRenderArea
Defining the Event-Processing Routines
Creating a Simple Component
Creating a New Viewer
Built-in Highlighting
Creating a Highlight in the Overlay Planes

SoXtViewer
Defining the Event-Processing Routines
Implementing the Seek Function
Creating a New Viewer
Creating a New Viewer

SoXtWalkViewer
Implementing the Seek Function
Changing the Decoration Layout
Changing the Decoration Layout
Creating a Constrained Viewer

spaceball
Translating Events

sphere
rayPick()
Picking

stacks
elements
Setting Elements in the State

starting manipulation
Begin Dragging

state
capturing for caching
Pushing and Popping Elements

state elements
Element Bundles
State Elements
Actions, State, and Elements
get() method
The set() and get() Methods
pop() method
Additional Methods
push() method
Additional Methods
set() method
The set() and get() Methods

state. See traversal state
Actions, State, and Elements

static methods
implementing
Implementing Static Methods
registering
Registering Static Methods

subclassing
. See creating nodes, creating elements, etc.
Key Concepts

subclassing. See creating actions, creating elements, creating fields, creating nodes
Extender Macros

surround-scale node
Creating a Manipulator
SoSurroundScale Node

surrounding objects
SoSurroundScale Node

switch nodes
Designing the Parts

switches
dragger
Begin Dragging
Setting the Switches

switchMode()
Defining the Event-Processing Routines

TemperatureElement class
Creating a New Element

terminating actions
Using the Path Code

The Inventor Mentor
Creating an Engine
Creating a Node Kit
Creating an Alternate Representation
Creating Details
Creating the Default Geometry File
Creating the Compiled-in Default Geometry
Actions, State, and Elements
Creating Draggers and Manipulators
Creating an Event and Device
Creating a Selection Highlight Style
Overview
Creating a Simple Dragger
Creating a Component

thumbwheel
viewer trim
Using the SoXtFullViewer Trim Decoration

thumbwheels
Creating a New Viewer

Ticker class
Creating a Second-Ticker Engine

touching fields
Notification and Evaluation

trackball
Creating a Manipulator

translateButtonEvent()
Translate Event Method

translateCamera()
Defining the Event-Processing Routines

translateEvent()
Translate Event Method
Overview

translateMotionEvent()
Translate Event Method

TranslateRadialDragger
Overview

translating events
illustration
Translating an Event

translation field
TranslateRadialDragger
Overview
Value-Changed Callback

traversal behavior
Traversal Behavior

traversal state
Deriving a Class from an Existing Element
Actions, State, and Elements
enabling elements
Enabling Elements in the State

traverse()
Child List

traverseChildren()
Creating a Group Node

triangle callback function
Generating Primitives

triangle fans
SoPrimitiveVertex

triangle strips
SoPrimitiveVertex

triangles
Generating Primitives

trim decoration
for viewers
Using the SoXtFullViewer Trim Decoration

type checking
Runtime Types
Anatomy of a Part
runtime
Initializing the Field Class
The initClass() Method

type-checking
run-time
The initClass() Method

types
of parts
Changing the Type of a Part
parts
Anatomy of a Part
viewers
Defining the Constructor

uncacheable nodes
Uncacheable Nodes

uniform scaling
SoAntiSquish node
SoAntiSquish Node

unknown nodes
file format
Using New Node Classes

up-direction
constrained viewers
Creating a Constrained Viewer
viewers
Creating a New Viewer

user interaction
Begin Dragging

user interface
manipulators
Creating a Manipulator

value-changed callback
Overview

value-changed callback function
Adding a Value-Changed Callback
Value-Changed Callback
Step j: Value-Changed Callback Function

valueChangedCB()
Callback Functions

vectors
composing
Creating an Engine with Multiple Inputs
decomposing
Creating an Engine with Multiple Outputs

view volume
Continue Dragging

viewAll()
Creating a New Viewer

viewer classes
abstract
compared
Creating a New Viewer

viewer type
Defining the Constructor

viewerButtonWidgets variable
Adding Push Buttons

viewers
changing the decoration layout
Changing the Decoration Layout
constrained
Creating a New Viewer
constructing
Defining the Constructor
creating
Creating a New Viewer
cursor
Defining the Event-Processing Routines
decoration
Using the SoXtFullViewer Trim Decoration
event processing
Defining the Event-Processing Routines
example of creating simple
Overview
preference sheet
Changing the Preference Sheet
simple
example
Using the Cursor for Feedback
subclassed from SoXtConstrainedViewer
Overview
subclassed from SoXtFullViewer
Overview
subclassed from SoXtViewer
Overview

viewport region
Creating a Highlight in the Overlay Planes

virtual methods
Adding Nodes and Actions to Inventor

visibility-changed callback function
Overview

visibilityChangeCB()
Visibility-Changed Callback Function

volumes
computing
Creating a New Action

widget hierarchy
The buildWidget() Method

widget tree
building
Defining the Constructor
root
Defining Public and Protected Constructors

widgets
building
The buildWidget() Method
form
Changing the Preference Sheet
Defining Public and Protected Constructors
parent
Defining Public and Protected Constructors
parent and child
Defining Public and Protected Constructors
registering
The buildWidget() Method

Window Manager
Overview

windowCloseAction()
Overview

world space
Overview

world up-direction
viewers
Creating a Constrained Viewer

write()
Adding Nodes and Actions to Inventor
Creating a Single-Value Field
Creating a Group Node

writing fields
Creating a Single-Value Field

writing to file
draggers
Creating the Parts

X cursor
Using the Cursor for Feedback

X events
Creating a Dial Event
translating into Inventor events
Translating Events

X input extension
Dispatching Events

X resources
The buildWidget() Method

X Server
Constructor
Dispatching Events

X Window System
Dispatching Events

XDeviceButtonEvent
Creating a Dial Event

XDeviceMotionEvent
Translate Event Method
Creating a Dial Event

Xlib Programming Manual
The buildWidget() Method

XmPushButton widget
Adding Push Buttons

XOpenDevice
Constructor

XSelectExtensionEvent()
Enable Method

Xt Library
Dispatching Events
Defining Public and Protected Constructors

zoom slider
Creating a New Viewer