Coin Logo http://www.sim.no
http://www.coin3d.org

SoField.h
1 #ifndef COIN_SOFIELD_H
2 #define COIN_SOFIELD_H
3 
4 /**************************************************************************\
5  *
6  * This file is part of the Coin 3D visualization library.
7  * Copyright (C) 1998-2007 by Systems in Motion. All rights reserved.
8  *
9  * This library is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU General Public License
11  * ("GPL") version 2 as published by the Free Software Foundation.
12  * See the file LICENSE.GPL at the root directory of this source
13  * distribution for additional information about the GNU GPL.
14  *
15  * For using Coin with software that can not be combined with the GNU
16  * GPL, and for taking advantage of the additional benefits of our
17  * support services, please contact Systems in Motion about acquiring
18  * a Coin Professional Edition License.
19  *
20  * See http://www.coin3d.org/ for more information.
21  *
22  * Systems in Motion, Postboks 1283, Pirsenteret, 7462 Trondheim, NORWAY.
23  * http://www.sim.no/ sales@sim.no coin-support@coin3d.org
24  *
25 \**************************************************************************/
26 
27 #include <Inventor/SoType.h>
28 #include <Inventor/misc/SoNotification.h>
29 
30 class SbString;
31 class SoEngineOutput;
32 class SoFieldContainer;
33 class SoFieldConverter;
34 class SoFieldList;
35 class SoInput;
36 class SoOutput;
37 
38 class COIN_DLL_API SoField {
39 
40 public:
41  virtual ~SoField();
42 
43  static void initClass(void);
44  static void initClasses(void);
45 
46  void setIgnored(SbBool ignore);
47  SbBool isIgnored(void) const;
48 
49  void setDefault(SbBool def);
50  SbBool isDefault(void) const;
51 
52  virtual SoType getTypeId(void) const = 0;
53 
54  static SoType getClassTypeId(void);
55  SbBool isOfType(const SoType type) const;
56 
57  void enableConnection(SbBool flag);
58  SbBool isConnectionEnabled(void) const;
59 
60  // Field<-Engine connection stuff.
61  SbBool connectFrom(SoEngineOutput * master,
62  SbBool notnotify = FALSE, SbBool append = FALSE);
63  SbBool appendConnection(SoEngineOutput * master, SbBool notnotify = FALSE);
64  void disconnect(SoEngineOutput * engineoutput);
65  SbBool isConnectedFromEngine(void) const;
66  SbBool getConnectedEngine(SoEngineOutput *& master) const;
67 
68  // Field<->Field connection stuff.
69  SbBool connectFrom(SoField * master,
70  SbBool notnotify = FALSE, SbBool append = FALSE);
71  SbBool appendConnection(SoField * master, SbBool notnotify = FALSE);
72  void disconnect(SoField * field);
73  SbBool isConnectedFromField(void) const;
74  SbBool getConnectedField(SoField *& master) const;
75  int getNumConnections(void) const;
76  int getForwardConnections(SoFieldList & slavelist) const;
77  int getConnections(SoFieldList & masterlist) const;
78 
79  void disconnect(void);
80  SbBool isConnected(void) const;
81 
82  void setContainer(SoFieldContainer * cont);
83  SoFieldContainer * getContainer(void) const;
84 
85  SbBool set(const char * valuestring);
86  void get(SbString & valuestring);
87 
88  SbBool shouldWrite(void) const;
89 
90  virtual void touch(void);
91  virtual void startNotify(void);
92  virtual void notify(SoNotList * nlist);
93  SbBool enableNotify(SbBool on);
94  SbBool isNotifyEnabled(void) const;
95 
96  void addAuditor(void * f, SoNotRec::Type type);
97  void removeAuditor(void * f, SoNotRec::Type type);
98 
99  int operator ==(const SoField & f) const;
100  int operator !=(const SoField & f) const;
101 
102  virtual void connectionStatusChanged(int numconnections);
103  SbBool isReadOnly(void) const;
104  virtual SbBool isSame(const SoField & f) const = 0;
105  virtual void copyFrom(const SoField & f) = 0;
106 
107  virtual void fixCopy(SbBool copyconnections);
108  virtual SbBool referencesCopy(void) const;
109  void copyConnection(const SoField * fromfield);
110 
111  virtual SbBool read(SoInput * in, const SbName & name);
112  virtual void write(SoOutput * out, const SbName & name) const;
113 
114  virtual void countWriteRefs(SoOutput * out) const;
115 
116  // enums for setFieldType()/getFieldType()
117  enum FieldType {
118  NORMAL_FIELD = 0,
119  EVENTIN_FIELD,
120  EVENTOUT_FIELD,
121  EXPOSED_FIELD
122  };
123 
124  void setFieldType(int type);
125  int getFieldType(void) const;
126 
127  SbBool getDirty(void) const;
128  void setDirty(SbBool dirty);
129 
130  void evaluate(void) const {
131  if ((this->statusbits & (FLAG_EXTSTORAGE|FLAG_NEEDEVALUATION)) ==
132  (FLAG_EXTSTORAGE|FLAG_NEEDEVALUATION)) this->evaluateField();
133  }
134 
135 protected:
136  SoField(void);
137 
138  void valueChanged(SbBool resetdefault = TRUE);
139  virtual void evaluateConnection(void) const;
140  virtual SbBool readValue(SoInput * in) = 0;
141  virtual void writeValue(SoOutput * out) const = 0;
142  virtual SbBool readConnection(SoInput * in);
143  virtual void writeConnection(SoOutput * out) const;
144 
145  SbBool isDestructing(void) const;
146 
147 private:
148 
149  enum FieldFlags {
150  FLAG_TYPEMASK = 0x0007, // need 3 bits for values [0-5]
151  FLAG_ISDEFAULT = 0x0008,
152  FLAG_IGNORE = 0x0010,
153  FLAG_EXTSTORAGE = 0x0020,
154  FLAG_ENABLECONNECTS = 0x0040,
155  FLAG_NEEDEVALUATION = 0x0080,
156  FLAG_READONLY = 0x0100,
157  FLAG_DONOTIFY = 0x0200,
158  FLAG_ISDESTRUCTING = 0x0400,
159  FLAG_ISEVALUATING = 0x0800,
160  FLAG_ISNOTIFIED = 0x1000
161  };
162 
163  void evaluateField(void) const;
164  void extendStorageIfNecessary(void);
165  SoFieldConverter * createConverter(SoType from) const;
166  SoFieldContainer * resolveWriteConnection(SbName & mastername) const;
167 
168  void notifyAuditors(SoNotList * l);
169 
170  static SoType classTypeId;
171 
172  // These are bit flags.
173  enum FileFormatFlags {
174  IGNORED = 0x01,
175  CONNECTED = 0x02,
176  DEFAULT = 0x04,
177  ALLFILEFLAGS = IGNORED|CONNECTED|DEFAULT
178  };
179 
180  SbBool changeStatusBits(const unsigned int bits, const SbBool onoff);
181  void clearStatusBits(const unsigned int bits);
182  void setStatusBits(const unsigned int bits);
183  SbBool getStatus(const unsigned int bits) const;
184  unsigned int statusbits;
185  union {
186  SoFieldContainer * container;
187  class SoConnectStorage * storage;
188  };
189 
190  SbBool hasExtendedStorage(void) const;
191 };
192 
193 
194 #ifndef COIN_INTERNAL
195 // Added to be Inventor compliant.
196 #include <Inventor/fields/SoSField.h>
197 #include <Inventor/fields/SoMField.h>
198 #endif // !COIN_INTERNAL
199 
200 #endif // !COIN_SOFIELD_H
The SoOutput class is an abstraction of an output stream.SoOutput offers the ability to write basic t...
Definition: SoOutput.h:42
The SoFieldContainer class is a base class for all classes that contain fields.The classes containing...
Definition: SoFieldContainer.h:35
The SoField class is the top-level abstract base class for fields.Fields is the mechanism used throug...
Definition: SoField.h:38
The SoFieldConverter class is the abstract base class for field converters.When fields of different t...
Definition: SoFieldConverter.h:32
void evaluate(void) const
Definition: SoField.h:130
The SoEngineOutput class is the output slots in SoEngine instances.SoEngineOutput has methods for con...
Definition: SoEngineOutput.h:36
The SoInput class is an abstraction of file import functionality.This class takes care of most of the...
Definition: SoInput.h:55
The SoFieldList class is a container for pointers to SoField objects.
Definition: SoFieldList.h:31
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:42
The SoNotList class is a list of SoNotRec notification records.
Definition: SoNotification.h:34
The SoType class is the basis for the run-time type system in Coin.Many of the classes in the Coin li...
Definition: SoType.h:50
The SbName class stores strings by reference.The class is used by Coin for storing keywords...
Definition: SbName.h:31
Type
Definition: SoNotRec.h:35

Copyright © 1998-2007 by Systems in Motion AS. All rights reserved.

Generated on Fri Feb 17 2017 for Coin by Doxygen. 1.8.13