Esempio n. 1
0
		public XamlObjectWriter (XamlSchemaContext schemaContext, XamlObjectWriterSettings settings)
		{
			if (schemaContext == null)
				throw new ArgumentNullException ("schemaContext");
			this.sctx = schemaContext;
			this.settings = settings ?? new XamlObjectWriterSettings ();
		}
Esempio n. 2
0
 public static object LoadDeferredContent(System.Xaml.XamlReader xamlReader, IXamlObjectWriterFactory writerFactory, 
     bool skipJournaledProperties, Object rootObject, XamlObjectWriterSettings parentSettings, Uri baseUri) 
 {
     XamlObjectWriterSettings settings = XamlReader.CreateObjectWriterSettings(parentSettings); 
     // Don't set settings.RootObject because this isn't the real root
     return Load(xamlReader, writerFactory, skipJournaledProperties, rootObject, settings, baseUri);
 }
 public XamlObjectWriter(XamlSchemaContext schemaContext, XamlObjectWriterSettings settings)
 {
     if (schemaContext == null)
     {
         throw new ArgumentNullException("schemaContext");
     }
     this.Initialize(schemaContext, null, settings);
 }
Esempio n. 4
0
		public XamlObjectWriter (XamlSchemaContext schemaContext, XamlObjectWriterSettings settings)
		{
			if (schemaContext == null)
				throw new ArgumentNullException ("schemaContext");
			this.sctx = schemaContext;
			this.settings = settings ?? new XamlObjectWriterSettings ();
			var manager = new XamlWriterStateManager<XamlObjectWriterException, XamlObjectWriterException> (false);
			intl = new XamlObjectWriterInternal (this, sctx, manager);
		}
Esempio n. 5
0
		public XamlObjectWriter (XamlSchemaContext schemaContext, XamlObjectWriterSettings settings)
		{
			if (schemaContext == null)
				throw new ArgumentNullException ("schemaContext");
			this.sctx = schemaContext;
			this.settings = settings ?? new XamlObjectWriterSettings ();

			var p = new PrefixLookup (sctx);
			service_provider = new ValueSerializerContext (p, sctx);
			namespaces = p.Namespaces;
		}
 internal XamlObjectWriter(XamlSavedContext savedContext, XamlObjectWriterSettings settings)
 {
     if (savedContext == null)
     {
         throw new ArgumentNullException("savedContext");
     }
     if (savedContext.SchemaContext == null)
     {
         throw new ArgumentException(System.Xaml.SR.Get("SavedContextSchemaContextNull"), "savedContext");
     }
     this.Initialize(savedContext.SchemaContext, savedContext, settings);
 }
        internal XamlObjectWriterSettings StripDelegates()
        {
            XamlObjectWriterSettings result = new XamlObjectWriterSettings(this);

            // We need better protection against leaking out these delegates
            result.AfterBeginInitHandler   = null;
            result.AfterEndInitHandler     = null;
            result.AfterPropertiesHandler  = null;
            result.BeforePropertiesHandler = null;
#if !TARGETTING35SP1
            result.XamlSetValueHandler = null;
#endif
            return(result);
        }
Esempio n. 8
0
        public XamlObjectWriterSettings(XamlObjectWriterSettings settings)
        {
            var s = settings;

            AfterBeginInitHandler            = s.AfterBeginInitHandler;
            AfterEndInitHandler              = s.AfterEndInitHandler;
            AfterPropertiesHandler           = s.AfterPropertiesHandler;
            BeforePropertiesHandler          = s.BeforePropertiesHandler;
            ExternalNameScope                = s.ExternalNameScope;
            IgnoreCanConvert                 = s.IgnoreCanConvert;
            PreferUnconvertedDictionaryKeys  = s.PreferUnconvertedDictionaryKeys;
            RegisterNamesOnExternalNamescope = s.RegisterNamesOnExternalNamescope;
            RootObjectInstance               = s.RootObjectInstance;
            SkipDuplicatePropertyCheck       = s.SkipDuplicatePropertyCheck;
            SkipProvideValueOnRoot           = s.SkipProvideValueOnRoot;
            XamlSetValueHandler              = s.XamlSetValueHandler;
        }
		public void DefaultValues ()
		{
			var s = new XamlObjectWriterSettings ();
			Assert.IsNull (s.AccessLevel, "#1");
			Assert.IsNull (s.AfterBeginInitHandler, "#2");
			Assert.IsNull (s.AfterEndInitHandler, "#3");
			Assert.IsNull (s.AfterPropertiesHandler, "#4");
			Assert.IsNull (s.BeforePropertiesHandler, "#5");
			Assert.IsNull (s.ExternalNameScope, "#6");
			Assert.IsFalse (s.IgnoreCanConvert, "#7");
			Assert.IsFalse (s.PreferUnconvertedDictionaryKeys, "#8");
			Assert.IsFalse (s.RegisterNamesOnExternalNamescope, "#9");
			Assert.IsNull (s.RootObjectInstance, "#10");
			Assert.IsFalse (s.SkipDuplicatePropertyCheck, "#11");
			Assert.IsFalse (s.SkipProvideValueOnRoot, "#12");
			Assert.IsNull (s.XamlSetValueHandler, "#13");
		}
Esempio n. 10
0
        /// <summary>
        /// Loads XAML from the specified XamlXmlReader and returns the deserialized object.  Any event handlers
        /// are bound to methods defined in the provided Scope and converted using the provided DynamicOperations
        /// object.
        /// </summary>
        public static object LoadComponent(dynamic scope, DynamicOperations operations, XamlXmlReader reader) {
            var settings = new XamlObjectWriterSettings();
            settings.RootObjectInstance = scope;

            var myWriter = new DynamicWriter((object)scope, operations, reader.SchemaContext, settings);
            while (reader.Read()) {
                myWriter.WriteNode(reader);
            }

            foreach (string name in myWriter.Names) {
                object value = myWriter.RootNameScope.FindName(name);
                if (value != null) {
                    operations.SetMember((object)scope, name, value);
                }
            }
            
            return myWriter.Result;
        }
Esempio n. 11
0
		public XamlObjectWriterSettings (XamlObjectWriterSettings settings)
			: base (settings)
		{
			var s = settings;
			AccessLevel = s.AccessLevel;
			AfterBeginInitHandler = s.AfterBeginInitHandler;
			AfterEndInitHandler = s.AfterEndInitHandler;
			AfterPropertiesHandler = s.AfterPropertiesHandler;
			BeforePropertiesHandler = s.BeforePropertiesHandler;
			ExternalNameScope = s.ExternalNameScope;
			IgnoreCanConvert = s.IgnoreCanConvert;
			PreferUnconvertedDictionaryKeys = s.PreferUnconvertedDictionaryKeys;
			RegisterNamesOnExternalNamescope = s.RegisterNamesOnExternalNamescope;
			RootObjectInstance = s.RootObjectInstance;
			SkipDuplicatePropertyCheck = s.SkipDuplicatePropertyCheck;
			SkipProvideValueOnRoot = s.SkipProvideValueOnRoot;
			XamlSetValueHandler = s.XamlSetValueHandler;
		}
 public XamlObjectWriterSettings(XamlObjectWriterSettings settings)
 {
     if (settings == null)
     {
         throw new ArgumentNullException("settings");
     }
     this.AfterBeginInitHandler = settings.AfterBeginInitHandler;
     this.BeforePropertiesHandler = settings.BeforePropertiesHandler;
     this.AfterPropertiesHandler = settings.AfterPropertiesHandler;
     this.AfterEndInitHandler = settings.AfterEndInitHandler;
     this.XamlSetValueHandler = settings.XamlSetValueHandler;
     this.RootObjectInstance = settings.RootObjectInstance;
     this.IgnoreCanConvert = settings.IgnoreCanConvert;
     this.ExternalNameScope = settings.ExternalNameScope;
     this.SkipDuplicatePropertyCheck = settings.SkipDuplicatePropertyCheck;
     this.RegisterNamesOnExternalNamescope = settings.RegisterNamesOnExternalNamescope;
     this.AccessLevel = settings.AccessLevel;
     this.SkipProvideValueOnRoot = settings.SkipProvideValueOnRoot;
     this.PreferUnconvertedDictionaryKeys = settings.PreferUnconvertedDictionaryKeys;
 }
Esempio n. 13
0
 public XamlObjectWriterSettings(XamlObjectWriterSettings settings)
 {
     if (settings == null)
     {
         throw new ArgumentNullException("settings");
     }
     this.AfterBeginInitHandler            = settings.AfterBeginInitHandler;
     this.BeforePropertiesHandler          = settings.BeforePropertiesHandler;
     this.AfterPropertiesHandler           = settings.AfterPropertiesHandler;
     this.AfterEndInitHandler              = settings.AfterEndInitHandler;
     this.XamlSetValueHandler              = settings.XamlSetValueHandler;
     this.RootObjectInstance               = settings.RootObjectInstance;
     this.IgnoreCanConvert                 = settings.IgnoreCanConvert;
     this.ExternalNameScope                = settings.ExternalNameScope;
     this.SkipDuplicatePropertyCheck       = settings.SkipDuplicatePropertyCheck;
     this.RegisterNamesOnExternalNamescope = settings.RegisterNamesOnExternalNamescope;
     this.AccessLevel                     = settings.AccessLevel;
     this.SkipProvideValueOnRoot          = settings.SkipProvideValueOnRoot;
     this.PreferUnconvertedDictionaryKeys = settings.PreferUnconvertedDictionaryKeys;
 }
Esempio n. 14
0
		public void RootObjectInstance ()
		{
			// bug #689548
			var obj = new RootObjectInstanceTestClass ();
			RootObjectInstanceTestClass result;
			
			var rsettings = new XamlXmlReaderSettings ();
			
			var xml = String.Format (@"<RootObjectInstanceTestClass Property=""Test"" xmlns=""clr-namespace:MonoTests.System.Xaml;assembly={0}""></RootObjectInstanceTestClass>", GetType ().Assembly.GetName ().Name);
			using (var reader = new XamlXmlReader (new StringReader (xml), rsettings)) {
				var wsettings = new XamlObjectWriterSettings ();
				wsettings.RootObjectInstance = obj;
				using (var writer = new XamlObjectWriter (reader.SchemaContext, wsettings)) {
					XamlServices.Transform (reader, writer, false);
					result = (RootObjectInstanceTestClass) writer.Result;
				}
			}
			
			Assert.AreEqual (obj, result, "#1");
			Assert.AreEqual ("Test", obj.Property, "#2");
		}
Esempio n. 15
0
        public XamlObjectWriterSettings(XamlObjectWriterSettings settings)
        {
            if (settings == null)
            {
                throw new ArgumentNullException("settings");
            }
            AfterBeginInitHandler   = settings.AfterBeginInitHandler;
            BeforePropertiesHandler = settings.BeforePropertiesHandler;
            AfterPropertiesHandler  = settings.AfterPropertiesHandler;
            AfterEndInitHandler     = settings.AfterEndInitHandler;
#if !TARGETTING35SP1
            XamlSetValueHandler = settings.XamlSetValueHandler;
#endif
            RootObjectInstance               = settings.RootObjectInstance;
            IgnoreCanConvert                 = settings.IgnoreCanConvert;
            ExternalNameScope                = settings.ExternalNameScope;
            SkipDuplicatePropertyCheck       = settings.SkipDuplicatePropertyCheck;
            RegisterNamesOnExternalNamescope = settings.RegisterNamesOnExternalNamescope;
            AccessLevel                     = settings.AccessLevel;
            SkipProvideValueOnRoot          = settings.SkipProvideValueOnRoot;
            PreferUnconvertedDictionaryKeys = settings.PreferUnconvertedDictionaryKeys;
            SourceBamlUri                   = settings.SourceBamlUri;
        }
 private XamlRuntime CreateRuntime(XamlObjectWriterSettings settings, XamlSchemaContext schemaContext)
 {
     XamlRuntime runtime = null;
     XamlRuntimeSettings runtimeSettings = null;
     if (settings != null)
     {
         runtimeSettings = new XamlRuntimeSettings {
             IgnoreCanConvert = settings.IgnoreCanConvert
         };
         if (settings.AccessLevel != null)
         {
             runtime = new PartialTrustTolerantRuntime(runtimeSettings, settings.AccessLevel, schemaContext);
         }
     }
     if (runtime == null)
     {
         runtime = new ClrObjectRuntime(runtimeSettings, true);
     }
     runtime.LineInfo = this;
     return runtime;
 }
Esempio n. 17
0
        private object LoadAsync(XmlReader reader, ParserContext parserContext)
        {
            if (reader == null)
            {
                throw new ArgumentNullException("reader");
            }

            if (parserContext == null)
            {
                parserContext = new ParserContext();
            }

            _xmlReader = reader;
            object rootObject = null;

            if (parserContext.BaseUri == null ||
                String.IsNullOrEmpty(parserContext.BaseUri.ToString()))
            {
                if (reader.BaseURI == null ||
                    String.IsNullOrEmpty(reader.BaseURI.ToString()))
                {
                    parserContext.BaseUri = BaseUriHelper.PackAppBaseUri;
                }
                else
                {
                    parserContext.BaseUri = new Uri(reader.BaseURI);
                }
            }
            _baseUri = parserContext.BaseUri;
            System.Xaml.XamlXmlReaderSettings settings = new System.Xaml.XamlXmlReaderSettings();
            settings.IgnoreUidsOnPropertyElements = true;
            settings.BaseUri         = parserContext.BaseUri;
            settings.ProvideLineInfo = true;
            XamlSchemaContext schemaContext = parserContext.XamlTypeMapper != null ?
                                              parserContext.XamlTypeMapper.SchemaContext : GetWpfSchemaContext();

            try
            {
                _textReader = new System.Xaml.XamlXmlReader(reader, schemaContext, settings);

                _stack = new XamlContextStack <WpfXamlFrame>(() => new WpfXamlFrame());

                System.Xaml.XamlObjectWriterSettings objectSettings = XamlReader.CreateObjectWriterSettings();
                objectSettings.AfterBeginInitHandler = delegate(object sender, System.Xaml.XamlObjectEventArgs args)
                {
                    if (rootObject == null)
                    {
                        rootObject      = args.Instance;
                        _styleConnector = rootObject as IStyleConnector;
                    }

                    UIElement uiElement = args.Instance as UIElement;
                    if (uiElement != null)
                    {
                        uiElement.SetPersistId(_persistId++);
                    }

                    DependencyObject dObject = args.Instance as DependencyObject;
                    if (dObject != null && _stack.CurrentFrame.XmlnsDictionary != null)
                    {
                        XmlnsDictionary dictionary = _stack.CurrentFrame.XmlnsDictionary;
                        dictionary.Seal();

                        XmlAttributeProperties.SetXmlnsDictionary(dObject, dictionary);
                    }
                };

                _objectWriter            = new System.Xaml.XamlObjectWriter(_textReader.SchemaContext, objectSettings);
                _parseCancelled          = false;
                _skipJournaledProperties = parserContext.SkipJournaledProperties;

                XamlMember synchronousModeProperty   = _textReader.SchemaContext.GetXamlDirective("http://schemas.microsoft.com/winfx/2006/xaml", "SynchronousMode");
                XamlMember synchronousRecordProperty = _textReader.SchemaContext.GetXamlDirective("http://schemas.microsoft.com/winfx/2006/xaml", "AsyncRecords");

                System.Xaml.XamlReader xamlReader = _textReader;

                IXamlLineInfo         xamlLineInfo         = xamlReader as IXamlLineInfo;
                IXamlLineInfoConsumer xamlLineInfoConsumer = _objectWriter as IXamlLineInfoConsumer;
                bool shouldPassLineNumberInfo = false;
                if ((xamlLineInfo != null && xamlLineInfo.HasLineInfo) &&
                    (xamlLineInfoConsumer != null && xamlLineInfoConsumer.ShouldProvideLineInfo))
                {
                    shouldPassLineNumberInfo = true;
                }

                bool async = false;
                bool lastPropWasSyncMode    = false;
                bool lastPropWasSyncRecords = false;

                while (!_textReader.IsEof)
                {
                    WpfXamlLoader.TransformNodes(xamlReader, _objectWriter, true /*onlyLoadOneNode*/, _skipJournaledProperties, shouldPassLineNumberInfo, xamlLineInfo, xamlLineInfoConsumer, _stack, _styleConnector);

                    if (xamlReader.NodeType == System.Xaml.XamlNodeType.StartMember)
                    {
                        if (xamlReader.Member == synchronousModeProperty)
                        {
                            lastPropWasSyncMode = true;
                        }
                        else if (xamlReader.Member == synchronousRecordProperty)
                        {
                            lastPropWasSyncRecords = true;
                        }
                    }
                    else if (xamlReader.NodeType == System.Xaml.XamlNodeType.Value)
                    {
                        if (lastPropWasSyncMode == true)
                        {
                            if (xamlReader.Value as String == "Async")
                            {
                                async = true;
                            }
                        }
                        else if (lastPropWasSyncRecords == true)
                        {
                            if (xamlReader.Value is int)
                            {
                                _maxAsynxRecords = (int)xamlReader.Value;
                            }
                            else if (xamlReader.Value is String)
                            {
                                _maxAsynxRecords = Int32.Parse(xamlReader.Value as String, TypeConverterHelper.InvariantEnglishUS);
                            }
                        }
                    }
                    else if (xamlReader.NodeType == System.Xaml.XamlNodeType.EndMember)
                    {
                        lastPropWasSyncMode    = false;
                        lastPropWasSyncRecords = false;
                    }

                    if (async && rootObject != null)
                    {
                        break;
                    }
                }
            }
            catch (Exception e)
            {
                // Don't wrap critical exceptions or already-wrapped exceptions.
                if (MS.Internal.CriticalExceptions.IsCriticalException(e) || !ShouldReWrapException(e, parserContext.BaseUri))
                {
                    throw;
                }
                RewrapException(e, parserContext.BaseUri);
            }

            if (!_textReader.IsEof)
            {
                Post();
                //ThreadStart threadStart = new ThreadStart(ReadXamlAsync);
                //Thread thread = new Thread(threadStart);
                //thread.Start();
            }
            else
            {
                TreeBuildComplete();
            }

            if (rootObject is DependencyObject)
            {
                if (parserContext.BaseUri != null && !String.IsNullOrEmpty(parserContext.BaseUri.ToString()))
                {
                    (rootObject as DependencyObject).SetValue(BaseUriHelper.BaseUriProperty, parserContext.BaseUri);
                }
                //else
                //    (rootObject as DependencyObject).SetValue(BaseUriHelper.BaseUriProperty, BaseUriHelper.PackAppBaseUri);
                WpfXamlLoader.EnsureXmlNamespaceMaps(rootObject, schemaContext);
            }

            Application app = rootObject as Application;

            if (app != null)
            {
                app.ApplicationMarkupBaseUri = GetBaseUri(settings.BaseUri);
            }

            return(rootObject);
        }
 public XamlObjectWriter GetXamlObjectWriter(XamlObjectWriterSettings settings)
 {
     return new XamlObjectWriter(new XamlSchemaContext());
 }
Esempio n. 19
0
        private void ExtractBAML(string name, Stream stream)
        {
            var reader = new Baml2006Reader(stream);
            var settings = new XamlObjectWriterSettings ();

            settings.BeforePropertiesHandler += (sender, e) =>
            {
                Trace("properties for {0}", e.Instance);
            };

            settings.XamlSetValueHandler += (sender, e) =>
            {
                //TraceTarget.Trace("set value {0} = {1}", e.Member.Name, e.Value);

                /*if (e.Member.Name == "DeferrableContent")
                {
                    e.Handled = true;
                }*/
            };

            var writer = new XamlObjectWriter(reader.SchemaContext, settings);
            while (reader.Read())
            {
                writer.WriteNode(reader);
            }
            var x = writer.Result;

            var ms = new MemoryStream();
            using (var xwriter = XmlWriter.Create(ms, new XmlWriterSettings { Indent = true }))
            {
                System.Windows.Markup.XamlWriter.Save(x, xwriter);
            }

            var xamlname = Path.ChangeExtension(name, ".xaml");

            ms.Position = 0;
            AddResource(xamlname, ms);
        }
 public XamlObjectWriterFactory(ObjectWriterContext context)
 {
     this._savedContext = context.GetSavedContext(SavedContextType.Template);
     this._parentSettings = context.ServiceProvider_GetSettings();
 }
Esempio n. 21
0
 public XamlObjectWriter(XamlSchemaContext schemaContext, XamlObjectWriterSettings settings)
     : this(schemaContext, settings, null)
 {
 }
Esempio n. 22
0
 public DynamicWriter(object scope, DynamicOperations operations, XamlSchemaContext context, XamlObjectWriterSettings settings)
     : base(context, settings) {
     _scope = scope;
     _operations = operations;
 }
Esempio n. 23
0
 internal static XamlObjectWriterSettings CreateObjectWriterSettings() 
 {
     XamlObjectWriterSettings owSettings = new XamlObjectWriterSettings(); 
     owSettings.IgnoreCanConvert = true; 
     owSettings.PreferUnconvertedDictionaryKeys = true;
     return owSettings; 
 }
Esempio n. 24
0
 internal static XamlObjectWriterSettings CreateObjectWriterSettings(XamlObjectWriterSettings parentSettings)
 { 
     XamlObjectWriterSettings owSettings = CreateObjectWriterSettings();
     if (parentSettings != null) 
     { 
         owSettings.SkipDuplicatePropertyCheck = parentSettings.SkipDuplicatePropertyCheck;
         owSettings.AccessLevel = parentSettings.AccessLevel; 
         owSettings.SkipProvideValueOnRoot = parentSettings.SkipProvideValueOnRoot;
     }
     return owSettings;
 } 
 private void Initialize(XamlSchemaContext schemaContext, XamlSavedContext savedContext, XamlObjectWriterSettings settings)
 {
     this._inDispose = false;
     if (schemaContext == null)
     {
         throw new ArgumentNullException("schemaContext");
     }
     if ((savedContext != null) && (schemaContext != savedContext.SchemaContext))
     {
         throw new ArgumentException(System.Xaml.SR.Get("SavedContextSchemaContextMismatch"), "schemaContext");
     }
     if (settings != null)
     {
         this._afterBeginInitHandler = settings.AfterBeginInitHandler;
         this._beforePropertiesHandler = settings.BeforePropertiesHandler;
         this._afterPropertiesHandler = settings.AfterPropertiesHandler;
         this._afterEndInitHandler = settings.AfterEndInitHandler;
         this._xamlSetValueHandler = settings.XamlSetValueHandler;
         this._rootObjectInstance = settings.RootObjectInstance;
         this._skipDuplicatePropertyCheck = settings.SkipDuplicatePropertyCheck;
         this._skipProvideValueOnRoot = settings.SkipProvideValueOnRoot;
         this._preferUnconvertedDictionaryKeys = settings.PreferUnconvertedDictionaryKeys;
     }
     INameScope rootNameScope = (settings != null) ? settings.ExternalNameScope : null;
     XamlRuntime runtime = this.CreateRuntime(settings, schemaContext);
     if (savedContext != null)
     {
         this._context = new ObjectWriterContext(savedContext, settings, rootNameScope, runtime);
     }
     else
     {
         if (schemaContext == null)
         {
             throw this.WithLineInfo(new XamlInternalException());
         }
         this._context = new ObjectWriterContext(schemaContext, settings, rootNameScope, runtime);
         this._context.AddNamespacePrefix("xml", "http://www.w3.org/XML/1998/namespace");
     }
     this._context.IsInitializedCallback = this;
     this._deferringWriter = new DeferringWriter(this._context);
     this._rootNamescope = null;
 }
Esempio n. 26
0
 public XamlObjectWriter GetXamlObjectWriter(XamlObjectWriterSettings settings)
 {
     return(new XamlObjectWriter(sctx, settings));
 }
 public XamlObjectWriter GetXamlObjectWriter(XamlObjectWriterSettings settings)
 {
     return new XamlObjectWriter(this._savedContext, settings);
 }
Esempio n. 28
0
        private static object Load(System.Xaml.XamlReader xamlReader, IXamlObjectWriterFactory writerFactory,
            bool skipJournaledProperties, Object rootObject, XamlObjectWriterSettings settings, Uri baseUri) 
        {
            XamlObjectWriter xamlWriter = null; 
            XamlContextStack<WpfXamlFrame> stack = new XamlContextStack<WpfXamlFrame>(() => new WpfXamlFrame()); 
            int persistId = 1;
 
            settings.AfterBeginInitHandler = delegate(object sender, System.Xaml.XamlObjectEventArgs args)
            {
                if (EventTrace.IsEnabled(EventTrace.Keyword.KeywordXamlBaml | EventTrace.Keyword.KeywordPerf, EventTrace.Level.Verbose))
                { 
                    IXamlLineInfo ixli = xamlReader as IXamlLineInfo;
 
                    int lineNumber = -1; 
                    int linePosition = -1;
 
                    if (ixli != null && ixli.HasLineInfo)
                    {
                        lineNumber = ixli.LineNumber;
                        linePosition = ixli.LinePosition; 
                    }
 
                    EventTrace.EventProvider.TraceEvent( 
                        EventTrace.Event.WClientParseXamlBamlInfo,
                        EventTrace.Keyword.KeywordXamlBaml | EventTrace.Keyword.KeywordPerf, EventTrace.Level.Verbose, 
                        args.Instance == null ? 0 : PerfService.GetPerfElementID(args.Instance),
                        lineNumber,
                        linePosition);
                } 

                UIElement uiElement = args.Instance as UIElement; 
                if (uiElement != null) 
                {
                    uiElement.SetPersistId(persistId++); 
                }

                DependencyObject dObject = args.Instance as DependencyObject;
                if (dObject != null && stack.CurrentFrame.XmlnsDictionary != null) 
                {
                    XmlnsDictionary dictionary = stack.CurrentFrame.XmlnsDictionary; 
                    dictionary.Seal(); 

                    XmlAttributeProperties.SetXmlnsDictionary(dObject, dictionary); 
                }

                stack.CurrentFrame.Instance = args.Instance;
            }; 
            if (writerFactory != null)
            { 
                xamlWriter = writerFactory.GetXamlObjectWriter(settings); 
            }
            else 
            {
                xamlWriter = new System.Xaml.XamlObjectWriter(xamlReader.SchemaContext, settings);
            }
 
            IXamlLineInfo xamlLineInfo = null;
            try 
            { 
                //Handle Line Numbers
                xamlLineInfo = xamlReader as IXamlLineInfo; 
                IXamlLineInfoConsumer xamlLineInfoConsumer = xamlWriter as IXamlLineInfoConsumer;
                bool shouldPassLineNumberInfo = false;
                if ((xamlLineInfo != null && xamlLineInfo.HasLineInfo)
                    && (xamlLineInfoConsumer != null && xamlLineInfoConsumer.ShouldProvideLineInfo)) 
                {
                    shouldPassLineNumberInfo = true; 
                } 

                IStyleConnector styleConnector = rootObject as IStyleConnector; 
                TransformNodes(xamlReader, xamlWriter,
                    false /*onlyLoadOneNode*/,
                    skipJournaledProperties,
                    shouldPassLineNumberInfo, xamlLineInfo, xamlLineInfoConsumer, 
                    stack, styleConnector);
                xamlWriter.Close(); 
                return xamlWriter.Result; 
            }
            catch (Exception e) 
            {
                // Don't wrap critical exceptions or already-wrapped exceptions.
                if (MS.Internal.CriticalExceptions.IsCriticalException(e) || !XamlReader.ShouldReWrapException(e, baseUri))
                { 
                    throw;
                } 
                XamlReader.RewrapException(e, xamlLineInfo, baseUri); 
                return null;    // this should never be executed
            } 
        }
Esempio n. 29
0
 public XamlObjectWriter GetXamlObjectWriter(XamlObjectWriterSettings settings)
 {
     var xamlSchemaContext = new XamlSchemaContext();
     var xamlObjectWriter = new XamlObjectWriter(xamlSchemaContext, settings);
     return xamlObjectWriter;
 }
Esempio n. 30
0
        /// <summary>
        /// Gets a <see cref="FrameworkTemplate"/> based on the specified parameters.
        /// </summary>
        /// <param name="xmlElement">The xml element to get template xaml from.</param>
        /// <param name="parentObject">The <see cref="XamlObject"/> to use as source for resources and contextual information.</param>
        /// <returns>A <see cref="FrameworkTemplate"/> based on the specified parameters.</returns>
        public static FrameworkTemplate GetFrameworkTemplate(XmlElement xmlElement, XamlObject parentObject)
        {
            var nav = xmlElement.CreateNavigator();

            var ns = new Dictionary<string, string>();
            while (true)
            {
                var nsInScope = nav.GetNamespacesInScope(XmlNamespaceScope.ExcludeXml);
                foreach (var ak in nsInScope)
                {
                    if (!ns.ContainsKey(ak.Key) && ak.Key != "")
                        ns.Add(ak.Key, ak.Value);
                }
                if (!nav.MoveToParent())
                    break;
            }

            xmlElement = (XmlElement)xmlElement.CloneNode(true);

            foreach (var dictentry in ns.ToList())
            {
                var value = dictentry.Value;
                if (value.StartsWith("clr-namespace") && !value.Contains(";assembly=")) {
                    if (!string.IsNullOrEmpty(parentObject.OwnerDocument.CurrentProjectAssemblyName)) {
                        value += ";assembly=" + parentObject.OwnerDocument.CurrentProjectAssemblyName;
                    }
                }
                xmlElement.SetAttribute("xmlns:" + dictentry.Key, value);
            }

            var keyAttrib = xmlElement.GetAttribute("Key", XamlConstants.XamlNamespace);

            if (string.IsNullOrEmpty(keyAttrib)) {
                xmlElement.SetAttribute("Key", XamlConstants.XamlNamespace, "$$temp&&§§%%__");
            }

            var xaml = xmlElement.OuterXml;
            xaml = "<ResourceDictionary xmlns=\"http://schemas.microsoft.com/netfx/2007/xaml/presentation\" xmlns:x=\"http://schemas.microsoft.com/winfx/2006/xaml\">" + xaml + "</ResourceDictionary>";
            StringReader stringReader = new StringReader(xaml);
            XmlReader xmlReader = XmlReader.Create(stringReader);
            var xamlReader = new XamlXmlReader(xmlReader, parentObject.ServiceProvider.SchemaContext);

            var seti = new XamlObjectWriterSettings();

            var resourceDictionary = new ResourceDictionary();
            var obj = parentObject;
            while (obj != null)
            {
                if (obj.Instance is ResourceDictionary)
                {
                    var r = obj.Instance as ResourceDictionary;
                    foreach (var k in r.Keys)
                    {
                        if (!resourceDictionary.Contains(k))
                            resourceDictionary.Add(k, r[k]);
                    }
                }
                else if (obj.Instance is FrameworkElement)
                {
                    var r = ((FrameworkElement)obj.Instance).Resources;
                    foreach (var k in r.Keys)
                    {
                        if (!resourceDictionary.Contains(k))
                            resourceDictionary.Add(k, r[k]);
                    }
                }

                obj = obj.ParentObject;
            }

            seti.BeforePropertiesHandler = (s, e) =>
            {
                if (seti.BeforePropertiesHandler != null)
                {
                    var rr = e.Instance as ResourceDictionary;
                    rr.MergedDictionaries.Add(resourceDictionary);
                    seti.BeforePropertiesHandler = null;
                }
            };

            var writer = new XamlObjectWriter(parentObject.ServiceProvider.SchemaContext, seti);

            XamlServices.Transform(xamlReader, writer);

            var result = (ResourceDictionary)writer.Result;

            var enr = result.Keys.GetEnumerator();
            enr.MoveNext();
            var rdKey = enr.Current;

            var template = result[rdKey] as FrameworkTemplate;

            result.Remove(rdKey);
            return template;
        }