Coin Logo http://www.coin3d.org/
http://www.kongsberg.com/kogt/

SoBaseKit.h
1 #ifndef COIN_SOBASEKIT_H
2 #define COIN_SOBASEKIT_H
3 
4 /**************************************************************************\
5  * Copyright (c) Kongsberg Oil & Gas Technologies AS
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions are
10  * met:
11  *
12  * Redistributions of source code must retain the above copyright notice,
13  * this list of conditions and the following disclaimer.
14  *
15  * Redistributions in binary form must reproduce the above copyright
16  * notice, this list of conditions and the following disclaimer in the
17  * documentation and/or other materials provided with the distribution.
18  *
19  * Neither the name of the copyright holder nor the names of its
20  * contributors may be used to endorse or promote products derived from
21  * this software without specific prior written permission.
22  *
23  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
24  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
25  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
26  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
27  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
28  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
29  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
30  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
31  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
32  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
33  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34 \**************************************************************************/
35 
36 #include <Inventor/nodekits/SoSubKit.h>
37 #include <Inventor/nodes/SoNode.h>
38 #ifdef COIN_INTERNAL
39 class SoNodeKitPath;
40 #else // !COIN_INTERNAL
41 // Include these header files for better Open Inventor compatibility.
42 #include <Inventor/SoNodeKitPath.h>
43 #include <Inventor/misc/SoChildList.h>
44 #endif // !COIN_INTERNAL
45 
46 class SoGroup;
47 class SoNodekitParts;
48 class SoNodekitCatalog;
49 class SoPath;
50 
51 // Convenience macros. FIXME: document. 20000113 mortene.
52 
53 #define SO_GET_PART(_kit_, _name_, _classname_) \
54  ((_classname_ *)_kit_->getPart(_name_, TRUE))
55 
56 #define SO_CHECK_PART(_kit_, _name_, _classname_) \
57  (static_cast<_classname_ *>(_kit_->getPart(_name_, FALSE)))
58 
59 #define SO_GET_ANY_PART(_kit_, _name_, _classname_) \
60  (static_cast<_classname_ *>(_kit_->getAnyPart(_name_, TRUE, FALSE, FALSE)))
61 
62 #define SO_CHECK_ANY_PART(_kit_, _name_, _classname_) \
63  (static_cast<_classname_ *>(_kit_->getAnyPart(_name_, FALSE, FALSE, FALSE)))
64 
65 
66 class COIN_DLL_API SoBaseKit : public SoNode {
67  typedef SoNode inherited;
68 
70 
71  SO_KIT_CATALOG_ENTRY_HEADER(callbackList);
72 
73 public:
74  static void initClass(void);
75  SoBaseKit(void);
76 
77  static const SoNodekitCatalog * getClassNodekitCatalog(void);
78  virtual const SoNodekitCatalog * getNodekitCatalog(void) const;
79 
80  virtual SoNode * getPart(const SbName & partname, SbBool makeifneeded);
81  SbString getPartString(const SoBase * part);
82  virtual SoNodeKitPath * createPathToPart(const SbName & partname,
83  SbBool makeifneeded,
84  const SoPath * pathtoextend = NULL);
85  virtual SbBool setPart(const SbName & partname, SoNode * from);
86  SbBool set(const char * namevaluepairliststring);
87  SbBool set(const char * partnamestring, const char * parameterstring);
88 
89  virtual void doAction(SoAction * action);
90  virtual void callback(SoCallbackAction * action);
91  virtual void GLRender(SoGLRenderAction * action);
92  virtual void getBoundingBox(SoGetBoundingBoxAction * action);
93  virtual void getMatrix(SoGetMatrixAction * action);
94  virtual void handleEvent(SoHandleEventAction * action);
95  virtual void rayPick(SoRayPickAction * action);
96  virtual void search(SoSearchAction * action);
97  virtual void write(SoWriteAction * action);
98  virtual void getPrimitiveCount(SoGetPrimitiveCountAction * action);
99 
100  virtual SoChildList * getChildren(void) const;
101 
102  void printDiagram(void);
103  void printSubDiagram(const SbName & rootname, int level);
104  void printTable(void);
105 
106  virtual void addWriteReference(SoOutput * out, SbBool isfromfield = FALSE);
107  SbBool forceChildDrivenWriteRefs(SoOutput * out);
108 
109  static SbBool isSearchingChildren(void);
110  static void setSearchingChildren(const SbBool newval);
111 
112 protected:
113  virtual ~SoBaseKit();
114 
115  static const SoNodekitCatalog ** getClassNodekitCatalogPtr(void);
116 
117  virtual SoNode * addToCopyDict(void) const;
118  virtual void copyContents(const SoFieldContainer * fromfc,
119  SbBool copyconnections);
120 
121  SoGroup * getContainerNode(const SbName & listname,
122  SbBool makeifneeded = TRUE);
123  virtual SoNode * getAnyPart(const SbName & partname, SbBool makeifneeded,
124  SbBool leafcheck = FALSE,
125  SbBool publiccheck = FALSE);
126  virtual SoNodeKitPath * createPathToAnyPart(const SbName & partname,
127  SbBool makeifneeded,
128  SbBool leafcheck = FALSE,
129  SbBool publiccheck = FALSE,
130  const SoPath * pathtoextend = NULL);
131  virtual SbBool setAnyPart(const SbName & partname, SoNode * from,
132  SbBool anypart = TRUE);
133  void createNodekitPartsList(void); // not part of Coin
134  void createFieldList(void); // replaces above method
135  virtual void createDefaultParts(void);
136  const SoNodekitParts * getNodekitPartsList(void) const; // not part of Coin
137  const SbList<SoSFNode*> & getCatalogInstances(void) const; // replaces above method
138 
139  void catalogError(void);
140  virtual SbBool setUpConnections(SbBool onoff, SbBool doitalways = FALSE);
141  virtual SbBool readInstance(SoInput * in, unsigned short flags);
142  virtual void setDefaultOnNonWritingFields(void);
143  void countMyFields(SoOutput * out);
144 
145  virtual SbBool setPart(const int partNum, SoNode * node);
146 
149 
150 private:
151  friend class SoInteractionKit;
152  static SbBool findPart(const SbString & partname, SoBaseKit *& kit,
153  int & partnum, SbBool & islist, int & listidx,
154  const SbBool makeifneeded, SoPath * path = NULL,
155  const SbBool recsearch = FALSE);
156  static void atexit_cleanupkit(void);
157 
158  SbBool makePart(const int partnum);
159  int getRightSiblingIndex(const int partnum);
160  int findNodeInThisKit(SoNode *node, const int parentnum = -1) const;
161 
162  static SoNodekitCatalog * classcatalog;
163  static const SoNodekitCatalog ** parentcatalogptr;
164  static SbBool searchchildren;
165 
166  class SoBaseKitP * pimpl;
167  friend class SoBaseKitP;
168 };
169 
170 #endif // !COIN_SOBASEKIT_H
The SoBase class is the top-level superclass for a number of class-hierarchies.SoBase provides the ba...
Definition: SoBase.h:45
virtual void copyContents(const SoFieldContainer *from, SbBool copyconnections)
Definition: SoNode.cpp:1420
The SoBaseKit class is the toplevel superclass for nodekits.Node kits are collections of nodes and ot...
Definition: SoBaseKit.h:66
virtual SoNode * addToCopyDict(void) const
Definition: SoNode.cpp:1372
The SoRayPickAction class does ray intersection with scene graphs.For interaction with the scene grap...
Definition: SoRayPickAction.h:50
virtual void getPrimitiveCount(SoGetPrimitiveCountAction *action)
Definition: SoNode.cpp:880
The SoOutput class is an abstraction of an output stream.SoOutput offers the ability to write basic t...
Definition: SoOutput.h:51
The SoGetMatrixAction class is an action for accumulating the transformation matrix of a subgraph...
Definition: SoGetMatrixAction.h:46
#define SO_NODE_HEADER(classname)
SoChildList * children
Definition: SoBaseKit.h:147
The SoFieldContainer class is a base class for all classes that contain fields.The classes containing...
Definition: SoFieldContainer.h:43
virtual void addWriteReference(SoOutput *out, SbBool isfromfield=FALSE)
Definition: SoFieldContainer.cpp:689
The SoSearchAction class provides methods for searching through scene graphs.Nodes can be searched fo...
Definition: SoSearchAction.h:44
virtual void search(SoSearchAction *action)
Definition: SoNode.cpp:1158
virtual SoChildList * getChildren(void) const
Definition: SoNode.cpp:1303
SbBool connectionsSetUp
Definition: SoBaseKit.h:148
The SoNodeKitPath class is a path that contains only nodekit nodes.All other nodes are hidden from th...
Definition: SoNodeKitPath.h:42
The SoNode class is the base class for nodes used in scene graphs.Coin is a retained mode 3D visualiz...
Definition: SoNode.h:56
The SoInteractionKit class is a base class for draggers.This nodekit class makes it possible to set s...
Definition: SoInteractionKit.h:50
virtual void rayPick(SoRayPickAction *action)
Definition: SoNode.cpp:1125
The SoChildList class is a container for node children.This class does automatic notification on the ...
Definition: SoChildList.h:42
The SoPath class is a container class for traversal path descriptions.SoPath objects contain a list o...
Definition: SoPath.h:52
The SoNodekitCatalog class is a container for nodekit layouts.Nodekits store all their hierarchical l...
Definition: SoNodekitCatalog.h:45
virtual SbBool readInstance(SoInput *in, unsigned short flags)
Definition: SoNode.cpp:1476
virtual void getMatrix(SoGetMatrixAction *action)
Definition: SoNode.cpp:1039
The SoAction class is the base class for all traversal actions.Applying actions is the basic mechanis...
Definition: SoAction.h:77
The SoGroup class is a node which managed other node instances.The internal scene data structures in ...
Definition: SoGroup.h:40
virtual void doAction(SoAction *action)
Definition: SoNode.cpp:795
The SoHandleEventAction class distributes user events to the scene.This is the action used by the GUI...
Definition: SoHandleEventAction.h:46
The SoGetPrimitiveCountAction class counts the primitives in a scene.Apply this action to a scene if ...
Definition: SoGetPrimitiveCountAction.h:44
The SoGetBoundingBoxAction class calculates bounding boxes for nodes and subgraphs.If this action is applied to a path or scene graph root, it will calculate the bounding box and the center point of the geometry contained within the scene.
Definition: SoGetBoundingBoxAction.h:45
The SoCallbackAction class invokes callbacks at specific nodes.This action has mechanisms for trackin...
Definition: SoCallbackAction.h:80
The SoWriteAction class writes a scene graph to file.When applied to a scene, this action writes its ...
Definition: SoWriteAction.h:42
The SoInput class is an abstraction of file import functionality.This class takes care of most of the...
Definition: SoInput.h:61
virtual void getBoundingBox(SoGetBoundingBoxAction *action)
Definition: SoNode.cpp:851
virtual void GLRender(SoGLRenderAction *action)
Definition: SoNode.cpp:940
The SbString class is a string class with convenience functions for string operations.This is the class used for storing and working with character strings. It automatically takes care of supporting all the "bookkeeping" tasks usually associated with working with character strings, like memory allocation and deallocation etc.
Definition: SbString.h:52
virtual void write(SoWriteAction *action)
Definition: SoNode.cpp:1227
virtual void callback(SoCallbackAction *action)
Definition: SoNode.cpp:1012
virtual void handleEvent(SoHandleEventAction *action)
Definition: SoNode.cpp:1069
The SbName class stores strings by reference.The class is used by Coin for storing keywords...
Definition: SbName.h:40
The SoGLRenderAction class renders the scene graph with OpenGL calls.Applying this method at a root n...
Definition: SoGLRenderAction.h:50

Copyright © by Kongsberg Oil & Gas Technologies. All rights reserved.

Generated for Coin by Doxygen