Esempio n. 1
0
        public YogaNode(
            YogaPrint print,
            bool hasNewLayout,
            YogaNodeType nodeType,
            YogaMeasure measure,
            YogaBaseline baseline,
            YogaDirtied dirtied,
            YogaStyle style,
            YogaLayout layout,
            int lineIndex,
            YogaNode owner,
            List <YogaNode> children,
            YogaNode nextChild,
            YogaConfig config,
            bool isDirty,
            YogaValue[] resolvedDimensions)
        {
            _print              = print;
            _hasNewLayout       = hasNewLayout;
            _nodeType           = nodeType;
            _measure            = measure;
            _baseline           = baseline;
            _dirtied            = dirtied;
            _style              = style;
            _layout             = layout;
            _lineIndex          = lineIndex;
            _owner              = owner;
            _children           = new List <YogaNode>(children);
            _nextChild          = nextChild;
            _config             = config;
            _isDirty            = isDirty;
            _resolvedDimensions = YogaArray.From(resolvedDimensions);

            Interlocked.Increment(ref _instanceCount);
        }
Esempio n. 2
0
        public YogaNode(YogaNode node)
        {
            _print              = node._print;
            _hasNewLayout       = node._hasNewLayout;
            _nodeType           = node._nodeType;
            _measure            = node._measure;
            _baseline           = node._baseline;
            _dirtied            = node._dirtied;
            _style              = node._style;
            _layout             = node._layout;
            _lineIndex          = node._lineIndex;
            _owner              = node._owner;
            _children           = new List <YogaNode>(node._children);
            _nextChild          = node._nextChild;
            _config             = node._config;
            _isDirty            = node._isDirty;
            _resolvedDimensions = YogaArray.From(node._resolvedDimensions);

            Interlocked.Increment(ref _instanceCount);
        }
Esempio n. 3
0
        private YogaArray <YogaValue> _resolvedDimensions; // [2]

        public YogaNode()
        {
            _print              = null;
            _hasNewLayout       = true;
            _nodeType           = YogaNodeType.Default;
            _measure            = null;
            _baseline           = null;
            _dirtied            = null;
            _style              = new YogaStyle();
            _layout             = new YogaLayout();
            _lineIndex          = 0;
            _owner              = null;
            _children           = new List <YogaNode>();
            _nextChild          = null;
            _config             = new YogaConfig();
            _isDirty            = false;
            _resolvedDimensions = new YogaArray <YogaValue>(new YogaValue[] { YogaValue.Undefined, YogaValue.Undefined });

            Interlocked.Increment(ref _instanceCount);
        }
Esempio n. 4
0
        public YogaNode(
            YogaPrint print,
            bool hasNewLayout,
            YogaNodeType nodeType,
            YogaMeasure measure,
            YogaBaseline baseline,
            YogaDirtied dirtied,
            YogaStyle style,
            YogaLayout layout,
            int lineIndex,
            YogaNode owner,
            List <YogaNode> children,
            YogaNode nextChild,
            YogaConfig config,
            bool isDirty,
            YogaValue[] resolvedDimensions)
        {
            PrintFunction      = print;
            HasNewLayout       = hasNewLayout;
            NodeType           = nodeType;
            _measure           = measure;
            Baseline           = baseline;
            Dirtied            = dirtied;
            _style             = style;
            _layout            = layout;
            LineIndex          = lineIndex;
            Owner              = owner;
            _children          = new List <YogaNode>(children);
            NextChild          = nextChild;
            Config             = config;
            _isDirty           = isDirty;
            ResolvedDimensions = YogaArray.From(resolvedDimensions);

#if DEBUG
            Interlocked.Increment(ref s_dbuginstanceCount);
#endif
        }