Example #1
0
        /// <summary>
        /// Write end of a list complex property
        /// </summary> 
        /// <remarks>
        /// For template parsing, treat complex property tags as 
        /// xml element tags for the purpose of validity checking when we're counting 
        /// element tags.
        /// </remarks> 
        public override void WritePropertyIListEnd(XamlPropertyIListEndNode xamlNode)
        {
            if (_styleModeStack.Mode == StyleMode.VisualTree)
            { 
                _visualTreeComplexPropertyDepth--;
            } 
            else if (_styleModeStack.Mode == StyleMode.TriggerBase) 
            {
                _triggerComplexPropertyDepth--; 
            }

            base.WritePropertyIListEnd(xamlNode);
            _styleModeStack.Pop(); 
        }
Example #2
0
 /// <summary>
 /// Write Property IList End
 /// </summary>
 public virtual void WritePropertyIListEnd(XamlPropertyIListEndNode xamlPropertyIListEndNode)
 {
     if (BamlRecordWriter != null)
     {
         BamlRecordWriter.WritePropertyIListEnd(xamlPropertyIListEndNode);
     }
 }
        // Write the end of a complex property that implements IList
        internal virtual void WritePropertyIListEnd(
                XamlPropertyIListEndNode xamlPropertyIListEndNode)
        {
            // initialize the element and add to the stack
            BamlPropertyIListEndRecord bamlPropertyIListEndRecord =
                (BamlPropertyIListEndRecord) BamlRecordManager.GetWriteRecord(BamlRecordType.PropertyIListEnd);

            WriteAndReleaseRecord(bamlPropertyIListEndRecord, xamlPropertyIListEndNode);
        }
Example #4
0
        /// <summary>
        /// Create nodes for a complex property that surrounds an element tree.
        /// Note that this is for general properties and not def attributes.
        /// </summary>
        internal void CompileAttribute(
            ArrayList xamlNodes,
            AttributeData data)
        {
            // For MarkupExtension syntax, treat PropertyInfo as a CLR property, but MethodInfo
            // and DependencyProperty as a DependencyProperty.  Note that the MarkupCompiler
            // will handle the case where a DependencyProperty callback is made if it gets
            // a MethodInfo for the attached property setter.
            string declaringTypeAssemblyName = data.DeclaringType.Assembly.FullName;
            string declaringTypeFullName = data.DeclaringType.FullName;

            // Find the PropertyRecordType to use in this case

            Type propertyType;
            bool propertyCanWrite;
            XamlTypeMapper.GetPropertyType(data.Info, out propertyType, out propertyCanWrite);
            BamlRecordType propertyRecordType = BamlRecordManager.GetPropertyStartRecordType(propertyType, propertyCanWrite);

            // Create the property start and end records

            XamlNode propertyStart;
            XamlNode propertyEnd;

            switch (propertyRecordType)
            {
                case BamlRecordType.PropertyArrayStart:
                {
                    propertyStart = new XamlPropertyArrayStartNode(
                                                                data.LineNumber,
                                                                data.LinePosition,
                                                                data.Depth,
                                                                data.Info,
                                                                declaringTypeAssemblyName,
                                                                declaringTypeFullName,
                                                                data.PropertyName);

                    propertyEnd = new XamlPropertyArrayEndNode(
                                          data.LineNumber,
                                          data.LinePosition,
                                          data.Depth);
                    break;
                }
                case BamlRecordType.PropertyIDictionaryStart:
                {
                    propertyStart = new XamlPropertyIDictionaryStartNode(
                                                                data.LineNumber,
                                                                data.LinePosition,
                                                                data.Depth,
                                                                data.Info,
                                                                declaringTypeAssemblyName,
                                                                declaringTypeFullName,
                                                                data.PropertyName);
                    propertyEnd = new XamlPropertyIDictionaryEndNode(
                                          data.LineNumber,
                                          data.LinePosition,
                                          data.Depth);
                    break;
                }
                case BamlRecordType.PropertyIListStart:
                {
                    propertyStart = new XamlPropertyIListStartNode(
                                                                data.LineNumber,
                                                                data.LinePosition,
                                                                data.Depth,
                                                                data.Info,
                                                                declaringTypeAssemblyName,
                                                                declaringTypeFullName,
                                                                data.PropertyName);
                    propertyEnd = new XamlPropertyIListEndNode(
                                          data.LineNumber,
                                          data.LinePosition,
                                          data.Depth);
                    break;
                }
                default: // PropertyComplexStart
                {
                    propertyStart = new XamlPropertyComplexStartNode(
                                                                data.LineNumber,
                                                                data.LinePosition,
                                                                data.Depth,
                                                                data.Info,
                                                                declaringTypeAssemblyName,
                                                                declaringTypeFullName,
                                                                data.PropertyName);
                    propertyEnd = new XamlPropertyComplexEndNode(
                                          data.LineNumber,
                                          data.LinePosition,
                                          data.Depth);
                    break;
                }
            }

            // NOTE:  Add duplicate property checking here as is done in XamlReaderHelper
            xamlNodes.Add(propertyStart);

            CompileAttributeCore(xamlNodes, data);

            xamlNodes.Add(propertyEnd);
        }
Example #5
0
        /// <summary> 
        /// Write end of a list complex property 
        /// </summary>
        /// <remarks> 
        /// For style parsing, treat complex property tags as
        /// xml element tags for the purpose of validity checking when we're counting
        /// element tags.
        /// </remarks> 
        public override void WritePropertyIListEnd(XamlPropertyIListEndNode xamlNode)
        { 
#if PBTCOMPILER 
            if (_styleModeStack.Mode == StyleMode.Setters)
            { 
                _isSameScope = false;
            }
#endif
 
            base.WritePropertyIListEnd(xamlNode);
            _styleModeStack.Pop(); 
        }