This class defines a layout that can be applied to a scene view. The layout class determines how objects should be laid out, and can apply that layout configuration.
Layout configuration can be done either through setters, or automatically through the CYILayout::Configure method.
This class is expected to be subclassed to implement actual layouts.
Container View Template Comments Specification
These values are applied to the comment field of the container composition. All properties are optional.
Label | Default value | Accepted values | Description |
---|---|---|---|
padding | 0.0 | floating point | A value subtracted from the container's size when layout out children. The padding effectively reduces the size of the container. Padding can be used to leave an 'empty' border around laid-out elements. Using this property sets the padding-front and padding-back values to 0. |
padding-top | 0.0 | floating point | The container's top padding value. |
padding-bottom | 0.0 | floating point | The container's bottom padding value. |
padding-left | 0.0 | floating point | The container's left padding value. |
padding-right | 0.0 | floating point | The container's right padding value. |
padding-front | 0.0 | floating point | The container's front padding value. |
padding-back | 0.0 | floating point | The container's back padding value. |
reverse-order | true | true, false | Reverses the order in which children are laid out: if set to false, the first laid-out child will be the last layer. |
gravity | top-left-front | special* | Specifies the direction that children should align when the layout does not specify an alignment. See Gravity Values further down for details. Can be overridden in children by using the 'item-gravity' property. |
Children View Template Comments Specification
These values are applied to the comment field of the to-be-laid-out children. All properties are optional.
Label | Default value | Accepted values | Description |
---|---|---|---|
layoutable | true | true, false | If set to false, the child will be ignored by the layout and its size/position will not be changed. |
margin | 0.0 | floating point | A value that increases the space left around a specific child in its parent when laying out elements. Similar to padding, but controls the space left 'outside' of the child. Using this property sets the margin-front and margin-back values to 0. |
margin-top | 0.0 | floating point | The child's top margin value. |
margin-bottom | 0.0 | floating point | The child's bottom margin value. |
margin-left | 0.0 | floating point | The child's left margin value. |
margin-right | 0.0 | floating point | The child's right margin value. |
margin-front | 0.0 | floating point | The child's front margin value. Used for 3D layouts. |
margin-back | 0.0 | floating point | The child's back margin value. Used for 3D layouts. |
width | actual | (see notes) | The child's preferred width. Cannot be negative. |
min-width | none | (see notes) | The child's minimum width. Cannot be negative. |
max-width | none | (see notes) | The child's maximum width. Cannot be negative. |
height | actual | (see notes) | The child's preferred height. Cannot be negative. |
min-height | none | (see notes) | The child's minimum height. Cannot be negative |
max-height | none | (see notes) | The child's maximum height. Cannot be negative. |
depth | actual | (see notes) | The child's preferred depth. Cannot be negative. |
min-depth | none | (see notes) | The child's minimum depth. Cannot be negative. |
max-depth | none | (see notes) | The child's maximum depth. Cannot be negative. |
maintain-aspect-ratio | false | true, false | If true, the layout system will try to preserve the child's width/height aspect ratio. See Maintain Aspect Ratio further down for details. |
fill-parent | false | true, false | Setting to true is the equivalent to width=fill; height=fill; depth=fill. Setting to false has no effect. |
fit-content | false | true, false | Setting to true is the equivalent of width=fit; height=fit; depth=fit. Setting to false has no effect. |
item-gravity | none | (see gravity values section) | Specifies the direction that an object should align when the associated layout does not specify an alignment. See Gravity Values further down for details. |
background | false | true, false | If set to true, this child will not be considered part of the layout but will be laid out to fill its parent. The padding value of the layout will be ignored. |
Gravity Values
Allowed 'raw' values:
Common combined values:
Maintain Aspect Ratio
The maintainAspectRatio from CYILayoutConfig::SizeConstraints (and from the 'maintain-aspect-ratio' child comment) can be used to indicate to the layout system that the width/height aspect ratio of the child should be constrainted to a specific aspect ratio.
In most cases, the current size of the child is used to determine this aspect ratio, but other values can be used. The following list indicates the order in which alternate values are used:
If either of the examined width and height is zero or negative, that pair of values is rejected for calculation of the target aspect ratio and the next entry in the list is used.
During layout, the target aspect ratio is used to decrease the 'default size' of measured scene nodes to respect the target aspect ratio. For scene views configured to 'fit content' in width and/or height, the content size is subsequently increased to respect the target aspect ratio.
Writing Custom Layouts
In some cases, it may be necessary or desired to write a custom CYILayout class. This section gives an overview of things that must or should be done to do this.
If animations are desired, the CYIAnimatingLayout class should be used as base class for custom layouts instead of CYILayout. This is because many of the animation features are implemented only in CYIAnimatingLayout.
When anything happens to a scene node that would cause it to need to be relaid out, that node (and potentially its children and/or parent) will be flagged as 'layout dirty'. Things that would cause a node be be 'layout dirty'ed include, but is not limited to, having children added or removed, being added to the scene tree, having its size or scale changed, having a layout assigned to the node, or having the node shown or hidden. Users can also manually request a relayout.
The actual laying out of children happens during the 'update' cycle. First, the system 'updates' the scene tree. Once that's done, the system checks if any of the nodes are flagged as 'layout dirty'. If so, those nodes are measured, and then the measurements are applied. If any of the nodes are dirtied during that process, the system 'updates' the scene tree again.
Two types of layout configuration exists: per-layout configuration, and per-child configuration. The latter is set directly on the layout itself (or as properties on the associated node). The former is set in CYILayoutConfig objects on the children of the node associated with the layout. For example, the padding is a layout configuration value (since it applies to all children of the layout's associated node), while the margin is a per-child configuration value (since each child of the associate node could have a different margin value).
When a layout is associated with a node, the layout is configured from properties present in the node. This is done by calling the Configure function. Custom layouts that add custom configuration values should override the Configure function. It is important that the parent class' Configure function be called. Failure to do so will result in some layout configuration values not being read properly.
If a custom layout needs to provide custom per-child configuration values, a few steps are required. First, a new sub-class of CYILayoutConfig must be made for the custom layout. That sub-class must use as parent the layout config class associated with the parent layout. For example, if a custom layout subclasses CYIAnimatingLayout, then the custom layout's layout config class must subclass CYIAnimatingLayoutConfig . The CYILayoutConfig::ConfigureFrom function should be overridden. Do not forget to call the parent class' ConfigureFrom function. Finally, the CYILayout::GetLayoutConfigType function must be overridden to return the type of CYILayoutConfig object to create for the layout if the layout uses a different layout config type.
In some cases, a layout may need to save per-child layout state. This is similar to providing custom per-child configuration values: a custom CYILayoutState class must be created, and the CYILayout::CreateLayoutStateInstance function must be overridden to create an instance of the proper type. Instances will automatically be created and assigned to all children of the associated scene node.
Custom layouts will typically want to implement both the OnMeasure and OnApplyMeasurements functions. OnMeasure is used to measure a node and all of its children. OnApplyMeasurements is used to 'apply' the measured sizes positions to the child nodes. Both functions are recursive.
Most of the 'work' in a layout is performed in the OnMeasure function. The implementation of that function is responsible for analyzing the provided width, height and depth MeasureSpec values, combining it with the layout constraints, and coming up with a measured size for the associated node. The measured size may also depend on the measured size of the children of the associated node. Whether it does or not, the OnMeasure function is required to call the CYISceneNode::Measure function of all of the associated node's children.
The implementation of the OnApplyMeasurements function is used to 'apply' the measured sizes. This involves setting the size and position of the children of the associated node. Note that the OnApplyMeasurements function is not responsible for setting its own size. This is done in the parent layout (or parent node) in order to allow for animating sizes.
The base layout class provides configuration for padding, margin and gravity. Whenever possible, custom layouts should respect those configuration values in order to provide a consistent API.
Some child nodes can be marked as 'non-layoutable'. This should be checked for and respected by custom layouts. These non-layoutable nodes still need to be measured and have their measurements applied, but they should not have a size or position set by the layout. The IsLayoutable utility function can be used to check if a node is layoutable.
Some child nodes can be marked as 'background' nodes. This can be checked by using the CYILayoutConfig::IsBackground function on the child node's layout configuration. Background nodes are nodes whose size will match that of their parent, ignoring the parent's padding values. The MeasureBackgroundChildren function can be used to facilitate measurement of background nodes. When measurements are applied, all configuration values of the layout and child node (except for padding) should be used.
Some of the layout constraints need special handling. One of these is the 'fit content' constraint: when this is enabled, the MeasureSpec that is passed down to children should be marked as CYISceneNode::MeasureMode::MeasureMode::Unspecified . Once all children have been measured, the measured size of the associated node would be calculated based on the measured size of the children.
Another constraint that needs special handling is the 'fill parent' property of children. If a child has one of its size constraints set to 'fill parent', then that child will typically be measured 'last' and will get however much space remains after all other children have been measured.
Multiple utility functions are available to facilitate implementation of custom layouts.
#include <layout/YiLayout.h>
Public Types | |
enum | PositioningMode { PositioningMode::SetPositionDirectly, PositioningMode::DoNotSetPositionDirectly } |
typedef CYILayoutConfig::CubeOffset | Padding |
Public Member Functions | |
CYILayout () | |
virtual | ~CYILayout () |
void | AttachTo (CYISceneView *pView) |
void | ConfigureFromAttachedNode () |
void | DetachFromNode () |
CYISceneNode * | GetAssociatedSceneNode () const |
void | Measure (const CYISceneNode::MeasureSpec &widthSpec, const CYISceneNode::MeasureSpec &heightSpec, const CYISceneNode::MeasureSpec &depthSpec) |
void | ApplyMeasurements () |
void | SetPositioningMode (PositioningMode positioningMode) |
PositioningMode | GetPositioningMode () const |
virtual void | ChildAdded (CYISceneNode *pChild) |
virtual void | ChildRemoved (CYISceneNode *pChild) |
virtual void | ChildVisibilityChanged (CYISceneNode *pChild) |
void | SetPadding (const Padding &padding) |
const Padding & | GetPadding () const |
void | SetUseReverseChildrenOrder (bool useReverseChildrenOrder) |
bool | IsUsingReverseChildrenOrder () const |
void | SetGravity (const glm::vec3 &layoutGravity) |
void | SetGravity (CYILayoutConfig::Gravity gravity) |
const glm::vec3 & | GetGravity () const |
Static Public Member Functions | |
static void | RegisterAllLayouts () |
static bool | IsLayoutable (const CYISceneNode *pNode) |
static glm::vec3 | GetDefaultSize (const CYISceneNode *pNode, const CYISceneNode::MeasureSpec &widthSpec, const CYISceneNode::MeasureSpec &heightSpec, const CYISceneNode::MeasureSpec &depthSpec) |
static void | UpdateMeasuredSizeForFitContent (const CYISceneNode *pNode, glm::vec3 *pMeasuredSize, const glm::vec3 &contentSize, const Padding &padding, const CYISceneNode::MeasureSpec &widthSpec, const CYISceneNode::MeasureSpec &heightSpec, const CYISceneNode::MeasureSpec &depthSpec) |
static void | UnscaleMeasureSpecs (const glm::vec3 &scale, CYISceneNode::MeasureSpec *pWidthSpec, CYISceneNode::MeasureSpec *pHeightSpec, CYISceneNode::MeasureSpec *pDepthSpec) |
static float | CalculateDimension (const CYISceneNode::MeasureSpec &spec, const CYILayoutConfig::SizeConstraint &constraint, float currentValue) |
Protected Types | |
enum | Dimensions { Dimensions::None = 0x0, Dimensions::X = 0x1, Dimensions::Y = 0x2, Dimensions::Z = 0x4, Dimensions::AllButX = Y | Z, Dimensions::AllButY = X | Z, Dimensions::AllButZ = X | Y, Dimensions::All = X | Y | Z } |
Protected Member Functions | |
virtual void | Configure () |
virtual void | OnSceneViewAttached () |
virtual void | OnMeasure (const CYISceneNode::MeasureSpec &widthSpec, const CYISceneNode::MeasureSpec &heightSpec, const CYISceneNode::MeasureSpec &depthSpec)=0 |
virtual void | OnApplyMeasurements ()=0 |
virtual void | OnMeasurementsCalculated (const CYISceneNode::MeasureSpec &widthSpec, const CYISceneNode::MeasureSpec &heightSpec, const CYISceneNode::MeasureSpec &depthSpec) |
virtual void | OnMeasurementsApplied () |
virtual const CYIRuntimeTypeInfo & | GetLayoutConfigType () const |
virtual std::unique_ptr< CYILayoutState > | CreateLayoutStateInstance () const |
virtual void | ApplyPosition (CYISceneNode *pChild, const glm::vec3 &position) |
virtual void | ApplySize (CYISceneNode *pChild, const glm::vec3 &size) |
void | CreateLayoutObjectsFor (CYISceneNode *pNode) const |
CYISceneNode * | GetChild (size_t index) const |
void | ApplyMeasurementsToBackgroundChildren () |
const Padding & | GetPaddingForChild (const CYISceneNode *pChild) const |
Static Protected Member Functions | |
static void | MeasureChildWithMargins (CYISceneNode *pChild, const CYISceneNode::MeasureSpec &parentWidthSpec, const CYISceneNode::MeasureSpec &parentHeightSpec, const CYISceneNode::MeasureSpec &parentDepthSpec, const Padding &padding) |
static void | MeasureChildWithMargins (CYISceneNode *pChild, const CYISceneNode::MeasureSpec &parentWidthSpec, const CYISceneNode::MeasureSpec &parentHeightSpec, const CYISceneNode::MeasureSpec &parentDepthSpec, const Padding &padding, const glm::vec3 &childScale) |
static CYISceneNode::MeasureSpec | CalculateChildMeasureSpec (const CYISceneNode::MeasureSpec &parentMeasureSpec, float padding, const CYILayoutConfig::SizeConstraint &childConstraint, float childScale) |
static bool | UpdateMeasureSpecsForFitContent (const CYISceneNode *pNode, CYISceneNode::MeasureSpec *widthSpec, CYISceneNode::MeasureSpec *heightSpec, CYISceneNode::MeasureSpec *depthSpec) |
static void | RemeasureChildrenForFillParent (const CYISceneNode *pNode, const glm::vec3 &parentMeasuredSize, const Padding &padding, Dimensions dimensionsToRemeasure) |
static glm::vec3 | GetAdjustedPosition (const glm::vec3 &desiredTopLeftPosition, const CYISceneNode *pChild) |
static glm::vec3 | GetUnadjustedPosition (const glm::vec3 ¤tTopLeftPosition, const CYISceneNode *pChild) |
static glm::vec3 | GetAdjustedMeasuredSize (const CYISceneNode *pChild) |
static glm::vec3 | GetTopLeftPositionWithGravity (const glm::vec3 &layoutGravity, const glm::vec3 &childGravity, const glm::vec3 &containerTopLeft, const glm::vec3 &containerSize, const CYILayout::Padding &padding, const glm::vec3 &childSize, const CYILayoutConfig::Margin &margin, const glm::vec3 ¤tChildPosition) |
static void | MeasureBackgroundChildren (CYISceneNode *pNode, const glm::vec3 &size) |
Protected Attributes | |
CYISceneView * | m_pNode |
In most cases, this variable is used as a node (thus the name m_pNode ) More... | |
Padding | m_padding |
bool | m_reverseChildrenOrder |
glm::vec3 | m_gravity |
PositioningMode | m_positioningMode |
|
strongprotected |
|
strong |
Declares the possible positioning modes for a layout.
Enumerator | |
---|---|
SetPositionDirectly | The position should be set directly by calling CYISceneNode::SetPosition |
DoNotSetPositionDirectly | The position should not be set by calling CYISceneNode::SetPosition |
CYILayout::CYILayout | ( | ) |
|
virtual |
void CYILayout::ApplyMeasurements | ( | ) |
Applies the measured sizes of the associated node's children.
|
protected |
Applies the measurements for all of the background children of the node associated with this layout. Non-background children are ignored. This function ignores the configured layout padding.
This function can be used to simplify the implementation of the OnApplyMeasurements function on some layouts. On some layout implementations, it is more efficient to apply measurements to background children in the same 'pass', while other children have their measurements applied. For those cases, the use of this function is not recommended.
|
protectedvirtual |
Applies the position position to the scene node pChild. This function, by default, simply calls CYISceneNode::SetPosition. It can be overridden in subclasses to support animating position changes for child scene nodes.
Reimplemented in CYIAnimatingLayout, and CYIAutoLayout.
|
protectedvirtual |
Applies the size size to the scene node pChild. This function, by default, simply calls CYISceneNode::SetSize. It can be overridden in subclasses to support animating size changes for child scene nodes.
Reimplemented in CYIAnimatingLayout.
void CYILayout::AttachTo | ( | CYISceneView * | pView | ) |
'Attaches' this layout to pView. Calling this function will save a reference to pView in this layout object and will create (if necessary) CYILayoutConfig and CYILayoutState objects in pView's children.
|
staticprotected |
Creates an adjusted measure specification for a single dimension, given an existing measure specification parentMeasureSpec, a padding value padding and a size constraint childConstraint.
|
static |
Calculates a desired size (in a single dimension), given the measure specification spec, the constraint constraint and the current size currentValue.
|
virtual |
Called when a child (pChild) is added to the scene node associated with this layout instance.
Reimplemented in CYIAnimatingLayout, and CYIAutoLayout.
|
virtual |
Called when a child (pChild) is removed from the scene node associated with this layout instance.
Reimplemented in CYIAnimatingLayout.
|
virtual |
Called when the local visibility of a child (pChild) has changed in the scene node associated with this layout instance.
Reimplemented in CYIAnimatingLayout.
|
protectedvirtual |
Extracts relevant properties the associated scene node and configures this layout with said properties.
Reimplemented in CYIGridLayout, CYILinearLayout, CYIAnimatingLayout, CYIAutoLinearLayout, CYIAutoLayout, CYIScalingLayout, CYIColumnLayout, CYIRowLayout, and CYIShaftLayout.
void CYILayout::ConfigureFromAttachedNode | ( | ) |
Configures this layout using the properties contained in the attached node. If this layout currently does not have an attached node, an error is logged.
|
protected |
Creates instances of subclasses of CYILayoutConfig and CYILayoutState and assigns them to pNode (if necessary).
|
protectedvirtual |
Creates a 'blank' layout state object.
void CYILayout::DetachFromNode | ( | ) |
'Detaches' this layout from its associated scene node. This involves deleting layout config and layout state objects from the associated scene node's children, and clearing the associated scene node in this layout object.
|
inlinestaticprotected |
Calculates the actual measured size of pChild in its parent space. This is simply the result of the multiplication of the child's measured size and scale.
|
staticprotected |
Calculates the position that, when assigned to child pChild, results in the top-left-front of the child to be at position desiredTopLeftPosition.
|
inline |
Returns the scene node associated with this layout. May be nullptr if this layout currently does not have an associated scene node.
|
protected |
Fetches and returns the child of the associated scene node at index index. If this layout is configured to use the reverse children order, this function will instead return the item at index (m_pNode->GetChildCount() - index - 1).
|
static |
Calculates and returns the default size of scene node pNode, given a set of measure specifications. The default size of a node is used when the node does not make any 'intelligent' decisions about what its size should be, and instead relies on its constraints and the provided measure specifications only.
const glm::vec3& CYILayout::GetGravity | ( | ) | const |
|
protectedvirtual |
Returns the type of layout config objects used by this layout.
Reimplemented in CYIGridLayout, and CYIAnimatingLayout.
const Padding& CYILayout::GetPadding | ( | ) | const |
|
inlineprotected |
Fetches and returns the padding value to use for child pChild.
Some children ignore the padding value configured in their parent (for example background nodes). To make the code cleaner, this function can be used to fetch the 'proper' padding value to use for a given child.
PositioningMode CYILayout::GetPositioningMode | ( | ) | const |
|
staticprotected |
Calculates the top-left-front position of a child within a container, given a layout gravity value layoutGravity and a child gravity value childGravity.
Padding can be specified for the container by using the padding parameter. Non-zero padding values will result in the containerTopLeft and containerSize values to be modified.
Margin can be specified for the child using the margin parameter, and will result in the child's childSize and position to be modified.
In order to support 'none' gravity values, the current child position currentChildPosition must be provided as well. To compute the 'effective' gravity value, the layoutGravity value is used and each component is replaced by the component from childGravity if that component is non-negative.
|
inlinestaticprotected |
Performs the opposite of the calculation performed in GetAdjustedPosition.
|
inlinestatic |
Checks if scene node pNode can be laid out by the layout system.
bool CYILayout::IsUsingReverseChildrenOrder | ( | ) | const |
void CYILayout::Measure | ( | const CYISceneNode::MeasureSpec & | widthSpec, |
const CYISceneNode::MeasureSpec & | heightSpec, | ||
const CYISceneNode::MeasureSpec & | depthSpec | ||
) |
Measures the associated scene node, considering its layout configuration constraints (if available) and the provided measure specifications.
|
staticprotected |
Measures children of the associated scene node that are marked as 'background' nodes in their layout configuration. Uses size size as measure bounds.
|
staticprotected |
Measures scene node pChild using the provided measure specifications, adjusted for the padding value padding (for example the specifications will be reduced, if possible, by the padding amount).
|
staticprotected |
Measures scene node pChild using the provided measure specifications, adjusted for the padding value padding (for example the specifications will be reduced, if possible, by the padding amount).
|
protectedpure virtual |
Applies the measured sizes of the associate scene node's children.
Implemented in CYIGridLayout, CYILinearLayout, CYIScalingLayout, and CYIStackLayout.
|
protectedpure virtual |
Measures the associated scene node, considering its layout configuration constraints (if available) and the provided measure specifications.
Implemented in CYIGridLayout, CYILinearLayout, CYIAutoLinearLayout, CYIScalingLayout, and CYIStackLayout.
|
protectedvirtual |
A function called after OnApplyMeasurements has been called. This can be used in abstract classes to do post-measurements-application handling.
Reimplemented in CYIAnimatingLayout.
|
protectedvirtual |
A function called after OnMeasure has been called. This can be used in abstract classes to do post-measurement handling.
|
protectedvirtual |
A function called after a scene view has been attached to this layout.
Reimplemented in CYIAutoLinearLayout.
|
static |
Called once by the framework to register all Layout RTTI classes with the linker.
|
staticprotected |
Remeasures the children of pNode in order to make them 'fill parent' in specified dimensions.
This function is used to remeasure children that have 'fill parent' size constraints. Normally, this is done within the main 'measure' phase of the layout. However, if a child is configured to 'fill parent' while the parent is configured to 'fit children', a second measurement pass is needed.
void CYILayout::SetGravity | ( | const glm::vec3 & | layoutGravity | ) |
Sets the gravity to gravity. Each component of the provided vector specifies a gravity value for the given dimension. A value of 0.0 means 'align to the start of the container', a value of 1.0 means 'align to the end of the container', and a value of 0.5 means 'center on the container'. The special value -1.0 means 'keep the existing position within the container'.
void CYILayout::SetGravity | ( | CYILayoutConfig::Gravity | gravity | ) |
Sets the gravity to one of the pre-defined gravity values.
void CYILayout::SetPadding | ( | const Padding & | padding | ) |
Sets the padding to padding. The padding of a layout is a blank area left around the content. The padding effectively reduces the 'available' area in a container that can be filled with children.
void CYILayout::SetPositioningMode | ( | PositioningMode | positioningMode | ) |
Sets the positioning mode for this layout to positioningMode. The positioning mode is used to determine how the position of a laid-out child should be set. By default, the layout will call CYISceneNode::SetPosition on laid-out children. If this function is called with PositioningMode::DoNotSetPositionDirectly, the position of laid-out children will not be set by this layout.
void CYILayout::SetUseReverseChildrenOrder | ( | bool | useReverseChildrenOrder | ) |
Sets the order in which children are laid out. When useReverseChildrenOrder is true, children will be laid out in the reverse of their natural order in the scene node. For example, the child at index 0 in the scene node will be laid out last, the child at index 1 will be laid out second-to-last, and so on. The reverse order is used by default so that the order of layers in After Effects is the order in which children will be laid out.
|
static |
Unscales the measure specs pWidthSpec, pHeightSpec and pDepthSpec by scale. If one of the provided measure specs is nullptr, it will be ignored. If one of the components of scale is zero, the associated measure spec size will be set to 0. This function is used to transform a set of measure specs into a child's coordinates space.
|
static |
Updates the measured size pMeasuredSize, taking into consideration the constraints of pNode, the padding padding and the content size contentSize.
|
staticprotected |
Updates the measure specs widthSpec, heightSpec and depthSpec, considering the 'fit content' constraints of pNode.
If one or more of the components in the size constraints of pNode is set to true, the associated measure spec is set to 'undefined'.
Implementations of CYILayout that make use of 'fit content' should use this function to update their measure specs prior to using them to measure their children.
|
protected |
|
protected |
|
protected |
In most cases, this variable is used as a node (thus the name m_pNode )
|
protected |
|
protected |