GL Studio API
group.h
Go to the documentation of this file.
1 /*! \file
2  \brief The disti::Group class. Implements groups of objects.
3 
4  \par Copyright Information
5 
6  Copyright (c) 2015 by The DiSTI Corporation.<br>
7  11301 Corporate Blvd; Suite 100<br>
8  Orlando, Florida 32817<br>
9  USA<br>
10  <br>
11  All rights reserved.<br>
12 
13  This Software contains proprietary trade secrets of DiSTI and may not be
14 reproduced, in whole or part, in any form, or by any means of electronic,
15 mechanical, or otherwise, without the written permission of DiSTI. Said
16 permission may be derived through the purchase of applicable DiSTI product
17 licenses which detail the distribution rights of this content and any
18 Derivative Works based on this or other copyrighted DiSTI Software.
19 
20  NO WARRANTY. THE SOFTWARE IS PROVIDED "AS-IS," WITHOUT WARRANTY OF ANY KIND,
21 AND ANY USE OF THIS SOFTWARE PRODUCT IS AT YOUR OWN RISK. TO THE MAXIMUM EXTENT
22 PERMITTED BY APPLICABLE LAW, DISTI AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES
23 AND CONDITIONS, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
24 IMPLIED WARRANTIES AND CONDITIONS OF MERCHANTABILITY AND/OR FITNESS FOR A
25 PARTICULAR PURPOSE, TITLE, AND NON-INFRINGEMENT, WITH REGARD TO THE SOFTWARE.
26 
27  LIMITATION OF LIABILITY. TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW,
28 IN NO EVENT SHALL DISTI OR ITS SUPPLIERS BE LIABLE FOR ANY SPECIAL, INCIDENTAL,
29 INDIRECT, OR CONSEQUENTIAL DAMAGES WHATSOEVER (INCLUDING, WITHOUT LIMITATION,
30 DAMAGES FOR LOSS OF BUSINESS PROFITS, BUSINESS INTERRUPTION, LOSS OF BUSINESS
31 INFORMATION, OR ANY OTHER PECUNIARY LOSS) ARISING OUT OF THE USE OF OR
32 INABILITY TO USE THE SOFTWARE, EVEN IF DISTI HAS BEEN ADVISED OF THE POSSIBILITY
33 OF SUCH DAMAGES. DISTI'S ENTIRE LIABILITY AND YOUR EXCLUSIVE REMEDY SHALL NOT
34 EXCEED FIVE DOLLARS (US$5.00).
35 
36  The aforementioned terms and restrictions are governed by the laws of the
37 State of Florida and the United States of America.
38 
39 */
40 #ifndef _GROUP_H
41 #define _GROUP_H
42 
43 #include "display.h"
44 #include "dynamic_array.h"
45 #include "gls_cpp_lang_support.h"
46 
47 namespace disti
48 {
49 
50 /**
51  * The Group class. Implements groups of objects
52  */
53 class Group : public DisplayObject
54 {
55 public:
56  typedef DisplayObject _BaseClass;
57 
58 private:
59 
60  /** If true, this object will be eligible for culling based on its static extents.
61  * IMPORTANT: The cull will only be acturate within the STATIC extents of the group
62  * If any child moves outside the static extents using Dynamic operations, it will
63  * be over-culled.
64  * The default is false, and only leaf nodes (non-groups) will cull.
65  */
66  bool _performGroupCullCheck;
67 
68  /** If true, cull checking will pass on to children of this group.
69  * If false, children will not be culled (if this group is not culled) */
70  bool _cullTestChildren;
71 
72 
73  DisplayObject *BestPick(const Vector& winLoc,const Vector& logicalCoords,float scale,const Vector& directionVector,Vector& collisionWinLoc /*Returned*/,const OpenGLMatrices& drawnMatrices);
74  DisplayObject *FirstPick(const Vector& winLoc,const Vector& logicalCoords,float scale,const Vector& directionVector,Vector& collisionWinLoc /*Returned*/,const OpenGLMatrices& drawnMatrices);
75 
76  virtual GLS_EXPORT void onVertexchanged(void);
77 
78  Group& operator=( const Group& ) DISTI_SPECIAL_MEM_FUN_DELETE;
79  Group( const Group& that ) DISTI_SPECIAL_MEM_FUN_DELETE;
80 
81 protected:
82  DisplayObjectArray _objects; /** The objects contained in this group */
83 
84  /** Helper method for child classes of group that don't want to call Group::SetAvailableAttributes */
85  virtual GLS_EXPORT void AddAvailableAttributes(unsigned int availableAttributes);
86 
87  /** Grow bounding box to accomodate new object
88  * \param obj The new object in the group
89  * \pre obj Must already be added to the group
90  */
91  void GrowBoundingBox(DisplayObject *obj);
92 
93 public:
94  friend class GroupEditor;
95 
96 #ifndef GLES
97  /* See base class */
98  virtual GLS_EXPORT InterfaceListType* GetCppInterfaceDescription(InterfaceListType* addToThisList= NULL );
99 
100  /* See base class */
101  virtual GLS_EXPORT void GetCppInterfaceDescriptionFree(InterfaceListType* array);
102 #endif
103 
104  /** Finds a pointer to the display object in the group, using the object's
105  * instance name as a key.
106  * \note If there are multiple DisplayObjects within the group with the same name,
107  * only the first instance will be found. This can be an issue if a sub-component
108  * contains objects with the same name as the object you are searching for.
109  * \param name Instance name of the object to find
110  * \return A pointer to the object if it is in the group, otherwise NULL
111  */
112  GLS_EXPORT DisplayObject *FindByName(const char *name);
113 
114  /** Finds a pointer to the display object in the group, using the object's
115  * instance name as a key.
116  * This does not desend into components, as they are different frames
117  * with possibility for duplicate names as the current frame.
118  * \param name Instance name of the object to find
119  * \return A pointer to the object if it is in the group, otherwise NULL
120  */
121  virtual GLS_EXPORT DisplayObject *FindByNameSameFrame(const char *name);
122 
123  /** Finds a pointer to the display object in the group, using the object's
124  * instance name as a key.
125  * \param obj Pointer to the object to find
126  * \return A pointer to the object if it is in the group, otherwise NULL
127  */
129 
130  /** Finds a pointer to the DisplayObject in the group using a qualified instance name.
131  * This allows precise searches for an object contained within a sub-component.
132  * (e.g. "cockpit.altimeter.needle"). To find an object in the same DisplayFrame
133  * use just the instance name. (e.g. "cockpit")
134  * The dot denotes crossing of DisplayFrame boundaries.
135  * \sa GetQualifiedInstanceName
136  * \param name Qualified instance name of the object to find
137  * \returns A pointer to the object if it is in the group, otherwise NULL
138  */
139  GLS_EXPORT DisplayObject *FindByQualifiedName(const char *name);
140 
141  /** Finds a pointer to the display object in the group, using the object's address as a key
142  * \param obj Pointer to the object to find
143  * \return A pointer to the object if it is in the group, otherwise NULL
144  */
145  GLS_EXPORT DisplayObject *FindNonRecursive(DisplayObject *obj);
146 
147  /** Returns a reference to the object array for this group */
148  DisplayObjectArray& Objects(void) { return _objects; }
149 
150  /** Returns the DisplayObject at the given group index */
151  DisplayObject *Item(unsigned int index) { return _objects[index]; }
152 
153  /** Returns whether or not this group should be considered for culling */
154  bool PerformGroupCullCheck(void) const { return _performGroupCullCheck; }
155 
156  /** Sets whether or not this group should be considered for culling */
157  GLS_EXPORT void PerformGroupCullCheck(bool mode);
158 
159  /** Returns whether or not this group's children should be considered for culling */
160  bool CullTestChildren(void) const { return _cullTestChildren; }
161 
162  /** Sets whether or not this group's children should be considered for culling */
163  GLS_EXPORT void CullTestChildren(bool mode);
164 
165  /** \return The number of objects in this group. (Non recursive count) */
166  unsigned int Count(void) const { return _objects.Count(); }
167 
168  /** Overload of the array index operator to allow you to treat this Group as an array of objects */
169  DisplayObjectPtr operator[] (unsigned int index) { return _objects[index]; }
170 
171  /** \return pointer to the first element in the group, or NULL if it doesn't exist */
172  GLS_EXPORT DisplayObject *FirstObject();
173 
174  /** \return pointer to the last element in the group, or NULL if it doesn't exist */
175  GLS_EXPORT DisplayObject *LastObject(void);
176 
177  /** \return True if this group is empty */
178  bool IsEmpty() const { return (Count()==0); }
179 
180  /** Get the index position of the specified object in the list
181  * \param obj The object to find
182  * \return The index of the object in the list, -1 if it isn't in the list
183  */
184  GLS_EXPORT int Position(DisplayObject *obj);
185 
186  /** Construct a new group.
187  * \param generateInstance Whether or not to generate an instance name for this group
188  */
189  GLS_EXPORT explicit Group( int generateInstance = FALSE );
190 
191  /** Copy construct a new group, performing a "deep copy" by cloning objects in the group.
192  * \param group The group to clone.
193  * \param generateNames Whether or not to generate a new instance name for this group and its children.
194  */
195  GLS_EXPORT Group( const Group& group, bool generateNames );
196 
197  /** Sets the initial number of entries in a group
198  * \param cnt The initial number of entries
199  */
200  GLS_EXPORT void InitialGroupCount(unsigned int cnt);
201 
202  static GLS_EXPORT DisplayObject *CreateInstance();
203 
204  /** Destroy a group object */
205  virtual GLS_EXPORT ~Group();
206 
207  /** Actually delete all the children of the group.
208  * This does a recursive "delete" on all the children.
209  * This does NOT just remove them from the group.
210  */
211  virtual GLS_EXPORT void DeleteAllChildren();
212 
213  virtual GLS_EXPORT void SetAvailableAttributes(unsigned int value);
214 
215  /* See base class */
216  virtual GLS_EXPORT DisplayObject* CloneObject( bool generateNames = false );
217 
218  /* See base class */
219  virtual GLS_EXPORT void CopyGeometry(DisplayObject *src);
220 
221  /* See base class */
222  virtual GLS_EXPORT void CopyProperties(DisplayObject *src);
223 
224  /* See base class */
225  virtual GLS_EXPORT void Draw(void);
226 
227  /* See base class */
228  virtual GLS_EXPORT void PreDraw(const OpenGLMatrices& current,Culler& culler);
229 
230  /* See base class */
231  virtual GLS_EXPORT bool Hit(float x,float y,float z,float scale,const Vector& directionVector, Vector *collisionPoint);
232 
233  /* See base class */
234  virtual GLS_EXPORT DisplayObject *Pick3D(const Vector& winLoc,
235  const Vector& logicalCoords,
236  float scale,
237  const Vector& directionVector,
238  Vector& collisionWinLoc /*Returned*/,
239  const OpenGLMatrices& drawnMatrices);
240 
241 
242  using _BaseClass::Parent;
243 
244  /* See base class */
245  virtual GLS_EXPORT void Parent(DisplayFrame *par);
246 
247  /* See base class */
248  virtual GLS_EXPORT void CalculateBoundingBox(void);
249 
250  /* Unhides base class implementation. */
251  using _BaseClass::Location;
252 
253  /* See base class */
254  virtual GLS_EXPORT void Location(const Vertex &v) DISTI_METHOD_OVERRIDE;
255  virtual GLS_EXPORT void Location(float x,float y,float z);
256 
257  /* See base class */
258  virtual GLS_EXPORT void Translate(float x,float y,float z);
259 
260  /* See base class */
261  virtual GLS_EXPORT void Translate(float transAmount[]);
262 
263  /* See base class */
264  virtual GLS_EXPORT void TranslateVertices(float x, float y, float z);
265 
266  /* See base class */
267  virtual GLS_EXPORT void TranslateVertices(float transAmount[]);
268 
269  /* See base class */
270  virtual GLS_EXPORT void GetExtents(float &x,float &y,float &z,float &x1,float &y1,float &z1);
271 
272  /* See base class */
273  virtual GLS_EXPORT void GetTransformedExtents(Vector& min, Vector& max, const GlsMatrixType& matrix, bool resetMinMax = true);
274 
275  /* Unhides base class implementation. */
276  using _BaseClass::Rotate;
277 
278  /* See base class */
279  virtual GLS_EXPORT void Rotate(const Vector &orig, float angle, const Vector &axis);
280 
281  /* Unhides base class implementation. */
282  using _BaseClass::Scale;
283 
284  /* See base class */
285  virtual GLS_EXPORT void Scale(const float scale_x, const float scale_y);
286 
287  /* See base class */
288  virtual GLS_EXPORT void Scale(float scale_x,float scale_y,float scale_z, Vertex *anchor = NULL, int handle = 0);
289 
290  /** Adds the specified object into the group, at the end of the list
291  * \param obj A pointer to the object to add
292  * \param reparent Whether or not the object parent should be set to this group
293  * \param recalculateBoundingbox Whether or not to recalculate the bounding box
294  * \param loc Where to insert it (defaults to -1 which means at the end of the list)
295  */
296  virtual GLS_EXPORT void InsertObject(DisplayObject *obj,bool reparent=true,bool recalculateBoundingbox = true,int loc=-1);
297 
298  /** Removes the specified object from this group. Does not delete it.
299  * \param obj The display object to removed
300  * \param recalculateBoundingbox
301  * \return True if the object was found and removed from this group
302  */
303  virtual GLS_EXPORT bool DeleteObject(DisplayObject *obj,bool recalculateBoundingbox = true);
304 
305  /** Change the draw order of a child object within this group
306  * \param oldIndex The old index of the object
307  * \param newIndex The new index of the object
308  * \pre oldIndex and newIndex must be valid indices
309  */
310  virtual GLS_EXPORT void ReorderObject(unsigned int oldIndex,unsigned int newIndex);
311 
312  /** Adds the specified object into the group, at the head of the list
313  * Treats the list like a stack, hence the name Push
314  * \param obj A pointer to the object to add
315  */
316  virtual GLS_EXPORT void PushObject(DisplayObject *obj);
317 
318  /* Unhides base class implementation. */
320 
321  /** DeleteVertex is overloaded in group to disable it. It is not possible
322  * to delete a Group's Vertices
323  */
324  virtual GLS_EXPORT void DeleteVertex(unsigned int index);
325 
326  /* Unhides base class implementation. */
328 
329  /** InsertVertex is overloaded in group to disable it. It is not possible
330  * to insert into a Group's Vertices
331  */
332  virtual GLS_EXPORT void InsertVertex(unsigned int index);
333 
334  /** Copies the given vertex data into the group's location vertex
335  * thereby moving the group's location member without affecting
336  * its child objects.
337  * \param v - Given vertex
338  */
339  virtual GLS_EXPORT void SetGroupLocation(const Vertex& v);
340 
341  /* See base class */
342  virtual GLS_EXPORT void GetResources(std::ostream& outstr, GlsResourceFilter* filter= NULL) DISTI_METHOD_OVERRIDE;
343 
344  /* See base class */
345  virtual GLS_EXPORT void CalculateTextureCoordinates(void) DISTI_METHOD_OVERRIDE;
346 
347  virtual GLS_EXPORT void LineWidth(float width) DISTI_METHOD_OVERRIDE;
348  virtual GLS_EXPORT float LineWidth(void) DISTI_METHOD_OVERRIDE;
349 
350  virtual GLS_EXPORT void LineStipplePattern(int pattern) DISTI_METHOD_OVERRIDE;
351  virtual GLS_EXPORT int LineStipplePattern(void) DISTI_METHOD_OVERRIDE;
352 
353  virtual GLS_EXPORT void LineStippleMultiplier(int mult) DISTI_METHOD_OVERRIDE;
354  virtual GLS_EXPORT int LineStippleMultiplier(void) DISTI_METHOD_OVERRIDE;
355 
356  virtual GLS_EXPORT int PolygonMode(void) DISTI_METHOD_OVERRIDE;
357  virtual GLS_EXPORT void PolygonMode(int mode) DISTI_METHOD_OVERRIDE;
358 
359  virtual GLS_EXPORT void PolygonEnd(const int mode) DISTI_METHOD_OVERRIDE;
360  virtual GLS_EXPORT int PolygonEnd(void) DISTI_METHOD_OVERRIDE;
361 
362  virtual GLS_EXPORT void Shading(const int mode) DISTI_METHOD_OVERRIDE;
363  virtual GLS_EXPORT int Shading(void) DISTI_METHOD_OVERRIDE;
364 
365  virtual GLS_EXPORT void DepthTest( unsigned char mode) DISTI_METHOD_OVERRIDE;
366  virtual GLS_EXPORT int DepthTest(void) DISTI_METHOD_OVERRIDE;
367 
368  virtual GLS_EXPORT void AntiAlias(bool mode) DISTI_METHOD_OVERRIDE;
369  virtual GLS_EXPORT bool AntiAlias(void) DISTI_METHOD_OVERRIDE;
370 
371  virtual GLS_EXPORT void AlphaMode(int mode) DISTI_METHOD_OVERRIDE;
372  virtual GLS_EXPORT int AlphaMode(void) DISTI_METHOD_OVERRIDE;
373 
374  virtual GLS_EXPORT void CullBackFace(const bool mode) DISTI_METHOD_OVERRIDE;
375  virtual GLS_EXPORT bool CullBackFace(void) DISTI_METHOD_OVERRIDE;
376 
377  virtual GLS_EXPORT bool LightingEnabled() DISTI_METHOD_OVERRIDE;
378  virtual GLS_EXPORT void LightingEnabled(bool lighting) DISTI_METHOD_OVERRIDE;
379 
380  /* Unhides base class implementation. */
381  using _BaseClass::SetBlendColor;
382 
383  virtual GLS_EXPORT void SetBlendColor(const glsColor &color);
384 
385  /* Unhides base class implementation. */
386  using _BaseClass::GetBlendColor;
387 
388  virtual GLS_EXPORT glsColor GetBlendColor(void);
389 
390  /* Unhides base class implementation. */
391  using _BaseClass::SetColor;
392 
393  virtual GLS_EXPORT void SetColor(const glsColor &color);
394 
395  /* Unhides base class implementation. */
396  using _BaseClass::GetColor;
397 
398  virtual GLS_EXPORT glsColor GetColor(void);
399 
400  /* Unhides base class implementation. */
401  using _BaseClass::SetFillColor;
402 
403  virtual GLS_EXPORT void SetFillColor(const glsColor &color);
404 
405  /* Unhides base class implementation. */
406  using _BaseClass::GetFillColor;
407 
408  virtual GLS_EXPORT glsColor GetFillColor(void);
409 
410  virtual GLS_EXPORT void TextureRepeat(const int rep);
411  virtual GLS_EXPORT bool TextureRepeat(void);
412 
413  virtual GLS_EXPORT void TextureMappingTechnique(const int map);
414  virtual GLS_EXPORT int TextureMappingTechnique(void);
415 
416  virtual GLS_EXPORT void TextureMinificationFilter(const int filter);
417  virtual GLS_EXPORT int TextureMinificationFilter(void);
418 
419  virtual GLS_EXPORT void TextureMagnificationFilter(const int filter);
420  virtual GLS_EXPORT int TextureMagnificationFilter(void);
421 
422  /** Call the Calculate method for all children
423  * \param time The current time
424  */
425  virtual GLS_EXPORT void Calculate(double time);
426 
427  /** The following class is provided for GL Studio 2.1 backward compatibility.
428  * This interface is deprecated and should only be used to support legacy code.
429  */
431  {
432  protected:
433  unsigned int _index;
434  Group *_parentGroup;
435  public:
436 
437  GLS_EXPORT CompatabilityListItem();
438 
439  GLS_EXPORT CompatabilityListItem* Next();
440 
441  GLS_EXPORT CompatabilityListItem* Prev();
442 
443  GLS_EXPORT DisplayObject* DataPtr();
444 
445  static GLS_EXPORT void RecalcCompatabilityList(Group* whichGroup);
446  };
447 
448  /** \return The first object in this group
449  */
450  GLS_EXPORT CompatabilityListItem* First();
451 
452  /** \return The last object in this group
453  */
454  GLS_EXPORT CompatabilityListItem* Last();
455 
456  DynamicArray<CompatabilityListItem> _compatList; /** Use for 2.1 compatibility only */
457 };
458 
459 } // namespace disti
460 
461 #endif
Definition: cull.h:50
DisplayObject * FindNonRecursive(DisplayObject *obj)
Definition: display_frame.h:83
virtual int PolygonEnd(void)
virtual const Vertex & Location(void) const
unsigned int Count(void) const
Definition: group.h:166
Definition: vertex.h:365
virtual void InsertVertex(unsigned int index)
virtual float LineWidth(void)
virtual void GetTransformedExtents(Vector &min, Vector &max, const GlsMatrixType &matrix, bool resetMinMax=true)
virtual bool CullBackFace(void)
bool IsEmpty() const
Definition: group.h:178
virtual void InsertObject(DisplayObject *obj, bool reparent=true, bool recalculateBoundingbox=true, int loc=-1)
The disti::DynamicArray class. A templated array of objects capable of dynamically growing...
Class to contain current OpenGL view, projection and draw matrices.
Definition: util.h:281
void GrowBoundingBox(DisplayObject *obj)
virtual void Calculate(double time)
virtual int DepthTest(void)
virtual int TextureMagnificationFilter(void)
virtual glsColor GetBlendColor(void)
virtual void GetExtents(float &x, float &y, float &z, float &x1, float &y1, float &z1)
DisplayFrame * Parent(void) const
Definition: display.h:897
Definition: display.h:98
DisplayObject * Item(unsigned int index)
Definition: group.h:151
virtual int TextureMappingTechnique(void)
virtual int PolygonMode(void)
virtual DisplayObject * CloneObject(bool generateNames=false)
virtual void DeleteAllChildren()
virtual bool TextureRepeat(void)
DisplayObject * FirstObject()
virtual bool Hit(float x, float y, float z, float scale, const Vector &directionVector, Vector *collisionPoint)
virtual DisplayObject * Pick3D(const Vector &winLoc, const Vector &logicalCoords, float scale, const Vector &directionVector, Vector &collisionWinLoc, const OpenGLMatrices &drawnMatrices)
virtual void CopyGeometry(DisplayObject *src)
The disti::DisplayObject class and global enumerations.
virtual ~Group()
virtual InterfaceListType * GetCppInterfaceDescription(InterfaceListType *addToThisList=NULL)
virtual int AlphaMode(void)
virtual void DeleteVertex(unsigned int index)
DisplayObjectPtr operator[](unsigned int index)
Definition: group.h:169
virtual void ReorderObject(unsigned int oldIndex, unsigned int newIndex)
virtual void PushObject(DisplayObject *obj)
virtual int Shading(void)
void Count(const unsigned int count)
Definition: dynamic_array.h:120
CompatabilityListItem * First()
virtual bool DeleteObject(DisplayObject *obj, bool recalculateBoundingbox=true)
virtual void PreDraw(const OpenGLMatrices &current, Culler &culler)
virtual int TextureMinificationFilter(void)
int Position(DisplayObject *obj)
CompatabilityListItem * Last()
bool CullTestChildren(void) const
Definition: group.h:160
DisplayObject * FindByName(const char *name)
void InitialGroupCount(unsigned int cnt)
virtual void InsertVertex(unsigned int index)
virtual void Translate(float x, float y, float z)
bool PerformGroupCullCheck(void) const
Definition: group.h:154
virtual bool AntiAlias(void)
virtual void GetCppInterfaceDescriptionFree(InterfaceListType *array)
virtual void Rotate(float angle, int axis=Z_AXIS)
char * InstanceName(void)
virtual bool LightingEnabled()
virtual void SetAvailableAttributes(unsigned int value)
Definition: gls_color.h:54
virtual void SetGroupLocation(const Vertex &v)
DisplayObject * LastObject(void)
virtual void DeleteVertex(unsigned int index)
virtual void CalculateTextureCoordinates(void)
DisplayObject * FindByName(DisplayObject *obj)
Definition: group.h:128
DisplayObject * FindByQualifiedName(const char *name)
Definition: group.h:53
void Scale(int handleBar, float px, float py, Vertex *anchor=NULL)
Definition: display.h:1111
virtual glsColor GetFillColor(void)
Definition: vertex.h:84
virtual int LineStipplePattern(void)
virtual void Draw(void)
virtual void GetResources(std::ostream &outstr, GlsResourceFilter *filter=NULL)
virtual void TranslateVertices(float x, float y, float z)
virtual void Rotate(const Vector &orig, float angle, const Vector &axis)
virtual DisplayObject * FindByNameSameFrame(const char *name)
virtual glsColor GetColor(void)
virtual void SetFillColor(const glsColor &color)
Definition: gls_resources.h:50
virtual void SetColor(const glsColor &color)
Macros and helper code to determine what subset of C++11/14/17 is available.
Definition: bmpimage.h:46
virtual int LineStippleMultiplier(void)
virtual void AddAvailableAttributes(unsigned int availableAttributes)
DisplayObjectArray & Objects(void)
Definition: group.h:148
virtual void SetBlendColor(const glsColor &color)
virtual void CopyProperties(DisplayObject *src)
virtual DisplayObject * handle(DisplayEvent *ev)