Code:
/ DotNET / DotNET / 8.0 / untmp / WIN_WINDOWS / lh_tools_devdiv_wpf / Windows / wcp / Framework / MS / Internal / IO / Packaging / XamlFilter.cs / 1 / XamlFilter.cs
//---------------------------------------------------------------------------- // //// Copyright (C) Microsoft Corporation. All rights reserved. // // // Description: // Implements an indexing filter for XAML streams. // Invoked by the PackageFilter. // // History: // 02/02/2004: [....]: Stubs // 02/16/2004: [....]: Initial implementation // 08/26/2004: [....]: Removed access to indexing filters from managed code. // 07/18/2005: [....]: Moved from XamlFilterImpl to XamlFilter, which // implements IManagedFilter instead of ManagedFilterBase. //--------------------------------------------------------------------------- #if DEBUG // #define TRACE #endif using System; using System.IO; using System.Xml; using MS.Win32; // For SafeNativeMethods using System.Globalization; // For CultureInfo using System.Diagnostics; // For Assert using System.Collections; // For Stack and Hashtable using System.Collections.Generic; // For List<> using System.Runtime.InteropServices; // For COMException using System.Runtime.InteropServices.ComTypes; // For IStream, etc. using System.Windows; // for ExceptionStringTable using MS.Internal.PresentationFramework; // for SecurityHelper using MS.Internal.Interop; // for CHUNK_BREAKTYPE (and other IFilter-related definitions) using MS.Internal; // for Invariant namespace MS.Internal.IO.Packaging { #region XamlFilter ////// The class that supports content extraction from XAML files for indexing purposes. /// Note: It would be nice to have fixed page content extractor look for flow elements in a fixed page. /// This however, is not really doable: FixedPageContentExtractor is XSLT-based, not reader-based. /// It cannot do anything more efficiently than what XamlFilter is currently doing. /// The "flow pass" on a DOM reader for a fixed page does not entail any redundant IO or DOM building. /// internal partial class XamlFilter : IManagedFilter { #region Nested Types ////// The following enumeration makes it easier to keep track of the filter's multi-modal behavior. /// /// Each state implements a distinct method for collecting the next content unit, as follows: /// /// Uninitialized Return appropriate errors from GetChunk and GetText. /// FindNextUnit Standard mode. Return content as it is discovered in markup. /// UseContentExtractor Retrieve content from a FixedPageContentExtractor object (expected to /// perform adjacency analysis). /// FindNextFlowUnit Look for content in markup ignoring fixed-format markup (second pass over a /// fixed page). /// EndOfStream Return appropriate errors from GetChunk and GetText. /// /// /// Transitions between these states are handled as follows: /// /// state | transition | action | next state /// -------- | ------------ | -------- | ------------ /// Uninitialized | constructor | create an XML reader | FindNextUnit /// | | | /// FindNextUnit | end of reader | clean up | EndOfStream /// | | | /// FindNextUnit | FixedPage tag | create FixedPageContentExtractor, | UseContentExtractor /// | | save a DOM of the FixedPage | /// | | | /// UseContentExtractor | end of extractor | create sub-reader from FixedPage DOM,| FindNextFlowUnit /// | | save top-level reader | /// | | | /// FindNextFlowUnit | end of reader | restore top-level reader | FindNextUnit /// | | | /// /// internal enum FilterState { Uninitialized =1, FindNextUnit, FindNextFlowUnit, UseContentExtractor, EndOfStream }; ////// A single reader position on an element start may correspond to 3 distinct states depending on /// whether the title and/or content property in the start tag has already been processed. /// [Flags] internal enum AttributesToIgnore { None =0, Title =1, Content =2 }; #endregion Nested Types #region Internal Constructors ////// The class constructor initializes trace and event logging. /// static XamlFilter() { #if TRACE EventLog xamlFilterEventLog = new EventLog(); xamlFilterEventLog.Log = "Application"; xamlFilterEventLog.Source = "XAML filter"; Trace.Listeners.Add(new EventLogTraceListener(xamlFilterEventLog)); #endif } ////// Constructor. Does initialization. /// /// xaml stream to filter internal XamlFilter(Stream stream) { #if TRACE System.Diagnostics.Trace.TraceInformation("New Xaml filter created."); #endif _lcidDictionary = new Dictionary(StringComparer.OrdinalIgnoreCase); _contextStack = new Stack(32); InitializeDeclaredFields(); _xamlStream = stream; // Create a XAML reader (field _xamlReader) on the stream. CreateXmlReader(); // Reflect load in filter's state. _filterState = FilterState.FindNextUnit; } /// /// This function is called from the constructor. It makes the object re-initializable, /// which would come in handy if the XamlFilter is ever made visible to unmanaged code /// and Load is allowed to be called multiple times. /// private void InitializeDeclaredFields() { // Initialize context variables. ClearStack(); _filterState = FilterState.Uninitialized; // Initialize current ID. _currentChunkID = 0; // Initialize the content model dictionary. // Note: Hashtable is not IDisposable. LoadContentDescriptorDictionary(); // Misc. initializations. _countOfCharactersReturned = 0; _currentContent = null; _indexingContentUnit = null; _expectingBlockStart = true; // If text data occurred at top level, it would be a block start. _topLevelReader = null; _fixedPageContentExtractor = null; _fixedPageDomTree = null; } #endregion Internal Constructors #region Managed IFilter API ////// Managed counterpart of IFilter.Init. /// /// Usage flags. Only IFILTER_INIT_CANON_PARAGRAPHS can be meaningfully /// honored by the XAML filter. /// array of Managed FULLPROPSPEC structs to restrict responses ///IFILTER_FLAGS_NONE, meaning the caller should not try to retrieve OLE property using /// IPropertyStorage on the Xaml part. ///Input parameters are ignored because this filter never returns any property value. public IFILTER_FLAGS Init( IFILTER_INIT grfFlags, // IFILTER_INIT value ManagedFullPropSpec[] aAttributes) // restrict responses to the specified attributes { // // Content is filtered either if no attributes are specified, // or if there are attributes specified, the attribute with PSGUID_STORAGE // property set and PID_STG_CONTENTS property id is present. // _filterContents = true; if (aAttributes != null && aAttributes.Length > 0) { _filterContents = false; for (int i = 0; i < aAttributes.Length; i++) { if (aAttributes[i].Guid == IndexingFilterMarshaler.PSGUID_STORAGE && aAttributes[i].Property.PropType == PropSpecType.Id && aAttributes[i].Property.PropId == (uint)MS.Internal.Interop.PID_STG.CONTENTS) { _filterContents = true; break; } } } // The only flag in grfFlags that makes sense to honor is IFILTER_INIT_CANON_PARAGRAPHS _returnCanonicalParagraphBreaks = ((grfFlags & IFILTER_INIT.IFILTER_INIT_CANON_PARAGRAPHS) != 0); // Return zero value to indicate that the client code should not take any special steps // to retrieve OLE properties. This might have to change if filtering loose Xaml is supported. return IFILTER_FLAGS.IFILTER_FLAGS_NONE; } ////// Managed counterpart of IFilter.GetChunk. /// ////// Chunk descriptor. /// ////// On end of stream, this function will return null. /// public ManagedChunk GetChunk() { if (!_filterContents) { // Contents not being filtered, no chunks to return in that case. _currentContent = null; // End of chunks. return null; } IndexingContentUnit contentUnit; // If client code forgot to load the stream, throw appropriate exception. if (_xamlReader == null) { throw new COMException(SR.Get(SRID.FilterGetChunkNoStream), (int)FilterErrorCode.FILTER_E_ACCESS); } // If at end of chunks, report the condition. if (_filterState == FilterState.EndOfStream) { //Ensure _xamlReader has been closed EnsureXmlReaderIsClosed(); // End of chunks. return null; } try { contentUnit = NextContentUnit(); } catch (XmlException xmlException) { //Ensure _xamlReader has been closed EnsureXmlReaderIsClosed(); // Return FILTER_E_UNKNOWNFORMAT for ill-formed documents. throw new COMException(xmlException.Message, (int)FilterErrorCode.FILTER_E_UNKNOWNFORMAT); } if (contentUnit == null) { // Update text information. _currentContent = null; //Ensure _xamlReader has been closed EnsureXmlReaderIsClosed(); // Report end of stream by indicating end of chunks. return null; } // Store the text for returning in GetText. _currentContent = contentUnit.Text; // Record the fact that GetText hasn't been called on this chunk. _countOfCharactersReturned = 0; return contentUnit; } ////// Return a maximum of bufferCharacterCount characters (*not* bytes) from the current content unit. /// public String GetText(int bufferCharacterCount) { //BufferCharacterCount should be non-negative Debug.Assert(bufferCharacterCount >= 0); if (_currentContent == null) { SecurityHelper.ThrowExceptionForHR((int)FilterErrorCode.FILTER_E_NO_TEXT); } int numCharactersToReturn = _currentContent.Length - _countOfCharactersReturned; if (numCharactersToReturn <= 0) { SecurityHelper.ThrowExceptionForHR((int)FilterErrorCode.FILTER_E_NO_MORE_TEXT); } // Return at most bufferCharacterCount characters. The marshaler makes sure it can add a terminating // NULL beyond the end of the string that is returned. if (numCharactersToReturn > bufferCharacterCount) { numCharactersToReturn = bufferCharacterCount; } String result = _currentContent.Substring(_countOfCharactersReturned, numCharactersToReturn); _countOfCharactersReturned += numCharactersToReturn; return result; } ////// The XAML indexing filter never returns property values. /// public Object GetValue() { SecurityHelper.ThrowExceptionForHR((int)FilterErrorCode.FILTER_E_NO_VALUES); return null; } #endregion Managed IFilter API #region Internal Methods #if DEBUG internal string DumpElementTable() { ICollection keys = _xamlElementContentDescriptorDictionary.Keys; ICollection values = _xamlElementContentDescriptorDictionary.Values; int length = keys.Count; ElementTableKey[] keyList = new ElementTableKey[length]; ContentDescriptor[] valueList = new ContentDescriptor[length]; keys.CopyTo(keyList, 0); values.CopyTo(valueList,0); string result = ""; for (int i = 0; i < length; ++i) { result += string.Format("{0}: [{1} -> {2}]\n", i, keyList[i], valueList[i]); } return result; } #endif ///Return the next text chunk, or null at end of stream. internal IndexingContentUnit NextContentUnit() { // Loop until we are able to return some content or encounter an end of file. IndexingContentUnit nextContentUnit = null; while (nextContentUnit == null) { // If we have a content extractor delivering content units for us, use it. if (_filterState == FilterState.UseContentExtractor) { Debug.Assert(_fixedPageContentExtractor != null); // If we've consumed all the glyph run info, switch to a mode in which only the flow content // of the fixed page just scanned will be returned. if (_fixedPageContentExtractor.AtEndOfPage) { // Discard extractor. _fixedPageContentExtractor = null; // Set up reader. _topLevelReader = _xamlReader; _xamlReader = new XmlNodeReader(_fixedPageDomTree.DocumentElement); // Transition to flow-only mode. _filterState = FilterState.FindNextFlowUnit; } else { bool chunkIsInline; uint lcid; string chunk = _fixedPageContentExtractor.NextGlyphContent(out chunkIsInline, out lcid); _expectingBlockStart = !chunkIsInline; return BuildIndexingContentUnit(chunk, lcid); } } if (_xamlReader.EOF) { switch (_filterState) { // If in standard mode, return a null chunk to signal the end of all chunks. case FilterState.FindNextUnit: // A non-empty stack at this point could only be attributable to an internal error, // for an early EOF would have been reported as an XML exception by the XML reader. Debug.Assert(_contextStack.Count == 0); _filterState = FilterState.EndOfStream; return null; // If processing a fixed page, revert to top-level XML reader. case FilterState.FindNextFlowUnit: Debug.Assert(_topLevelReader != null); _xamlReader.Close(); _xamlReader = _topLevelReader; _filterState = FilterState.FindNextUnit; break; default: Debug.Assert(false); break; } } switch (_xamlReader.NodeType) { // If current token is a text element, // if it can be part of its parent's content, return a chunk; // else, skip. case XmlNodeType.Text: case XmlNodeType.SignificantWhitespace: case XmlNodeType.CDATA: nextContentUnit = HandleTextData(); continue; // If current token is an element start, then, // if appropriate, extract chunk text from an attribute // else, record content information and recurse. case XmlNodeType.Element: nextContentUnit = HandleElementStart(); continue; // On end of element, restore context data (pop, etc.) and look further. case XmlNodeType.EndElement: nextContentUnit = HandleElementEnd(); continue; // Default action is to ignore current token and look further. // Note that non-significant whitespace is handled here. default: _xamlReader.Read(); // Consume current token. continue; } } return nextContentUnit; } ////// Load a hash table to map qualified element names to content descriptors. /// private void LoadContentDescriptorDictionary() { // Invoke init function that is generated at build time. InitElementDictionary(); } #endregion Internal Methods #region Private Methods ///Ancillary function of NextContentUnit(). Create new chunk, taking _contextStack into /// account, and updating it if needed. private IndexingContentUnit BuildIndexingContentUnit(string text, uint lcid) { CHUNK_BREAKTYPE breakType = CHUNK_BREAKTYPE.CHUNK_NO_BREAK; // If a paragraph break is expected, reflect this in the new chunk. if (_expectingBlockStart) { breakType = CHUNK_BREAKTYPE.CHUNK_EOP; if (_returnCanonicalParagraphBreaks) text = _paragraphSeparator + text; } if (_indexingContentUnit == null) { _indexingContentUnit = new IndexingContentUnit(text, AllocateChunkID(), breakType, _propSpec, lcid); } else { // Optimization: reuse indexing content unit. _indexingContentUnit.InitIndexingContentUnit(text, AllocateChunkID(), breakType, _propSpec, lcid); } // Until proven separated (by the occurrence of a block tag), right neighbors are contiguous. _expectingBlockStart = false; return _indexingContentUnit; } ///Obtain a content descriptor for a custom element not found in the dictionary. ////// There is currently no general way of extracting information about custom elements, /// so the default descriptor is systematically returned. /// private ContentDescriptor GetContentInformationAboutCustomElement(ElementTableKey customElement) { return _defaultContentDescriptor; } ////// If current token is a text element, /// assume it can be part of its parent's content and return a chunk. /// ////// Ancillary function of NextContentUnit. /// private IndexingContentUnit HandleTextData() { ContentDescriptor topOfStack = TopOfStack(); if (topOfStack != null) { // The descendants of elements with HasIndexableContent set to false get skipped. Debug.Assert(topOfStack.HasIndexableContent); // Return a chunk with appropriate block-break information. IndexingContentUnit result = BuildIndexingContentUnit(_xamlReader.Value, GetCurrentLcid()); _xamlReader.Read(); // Move past data just processed. return result; } else { // Bad Xaml (no top-level element). The Xaml filter should at some point raise an exception. // Just to be safe, ignore all content when in this state. _xamlReader.Read(); // Skip data. return null; } } ////// If current token is an element start, then, /// if appropriate, extract chunk text from an attribute /// else, record content information and recurse. /// ////// Ancillary function of NextContentUnit. /// private IndexingContentUnit HandleElementStart() { ElementTableKey elementFullName = new ElementTableKey(_xamlReader.NamespaceURI, _xamlReader.LocalName); string propertyName; // Handle the case of a complex property (e.g. Button.Content). if (IsPrefixedPropertyName(elementFullName.BaseName, out propertyName)) { ContentDescriptor topOfStack = TopOfStack(); // Handle the semantically incorrect case of a compound property occurring at the root // by ignoring it totally. if (topOfStack == null) { SkipCurrentElement(); return null; } // Index the text children of property elements only if they are content or title properties. bool elementIsIndexable = ( elementFullName.XmlNamespace.Equals(ElementTableKey.XamlNamespace, StringComparison.Ordinal) && ( propertyName == topOfStack.ContentProp || propertyName == topOfStack.TitleProp )); if (!elementIsIndexable) { // Skip element together with all its descendants. SkipCurrentElement(); return null; } // Push descriptor, advance reader, and have caller look further. Push( new ContentDescriptor( elementIsIndexable, TopOfStack().IsInline, String.Empty, // has potential text content, but no content property null)); // no title property _xamlReader.Read(); return null; } // Handle fixed-format markup in a special way (because assumptions for building // content descriptors don't work for these and they require actions beyond what // is stated in content descriptors). // Note: The elementFullyHandled boolean is required as the nextUnit returned can // be null in both cases - when element is fully handled and when its not. bool elementFullyHandled; IndexingContentUnit nextUnit = HandleFixedFormatTag(elementFullName, out elementFullyHandled); if (elementFullyHandled) return nextUnit; else { // When HandleFixedFormatTag declines to handle a tag because it is not fixed-format, it // will return null. Invariant.Assert(nextUnit == null); } // Obtain a content descriptor for the current element. ContentDescriptor elementDescriptor = (ContentDescriptor) _xamlElementContentDescriptorDictionary[elementFullName]; if (elementDescriptor == null) { if (elementFullName.XmlNamespace.Equals(ElementTableKey.XamlNamespace, StringComparison.Ordinal)) { elementDescriptor = _defaultContentDescriptor; } else if (elementFullName.XmlNamespace.Equals(_inDocumentCodeURI, StringComparison.Ordinal)) { elementDescriptor = _nonIndexableElementDescriptor; } else { elementDescriptor = GetContentInformationAboutCustomElement(elementFullName); } _xamlElementContentDescriptorDictionary.Add(elementFullName, elementDescriptor); } // If the element has no indexable content, skip all its descendants. if (!elementDescriptor.HasIndexableContent) { SkipCurrentElement(); return null; } // If appropriate, retrieve title from an attribute. string title = null; if ( elementDescriptor.TitleProp != null && (_attributesToIgnore & AttributesToIgnore.Title) == 0 ) { title = GetPropertyAsAttribute(elementDescriptor.TitleProp); if (title != null && title.Length > 0) { // Leave the reader in its present state, but return the title as a block chunk, // and mark this attribute as processed. _attributesToIgnore |= AttributesToIgnore.Title; _expectingBlockStart = true; IndexingContentUnit titleContent = BuildIndexingContentUnit(title, GetCurrentLcid()); _expectingBlockStart = true; // Simulate a stack pop for a block element. return titleContent; } } // If appropriate, retrieve content from an attribute. string content = null; if ( elementDescriptor.ContentProp != null && (_attributesToIgnore & AttributesToIgnore.Content) == 0 ) { content = GetPropertyAsAttribute(elementDescriptor.ContentProp); if (content != null && content.Length > 0) { // Leave the reader in its present state, but mark the content attribute // as processed. _attributesToIgnore |= AttributesToIgnore.Content; // Create a new chunk with appropriate break data. if (!elementDescriptor.IsInline) { _expectingBlockStart = true; } IndexingContentUnit result = BuildIndexingContentUnit(content, GetCurrentLcid()); // Emulate a stack pop for the content attribute (which never gets pushed on the stack). _expectingBlockStart = !elementDescriptor.IsInline; return result; } } // Reset the attribute flag, since we are going to change the reader's state. _attributesToIgnore = AttributesToIgnore.None; // Handle the special case of an empty element: no descendants, but a possible paragraph break. if (_xamlReader.IsEmptyElement) { if (!elementDescriptor.IsInline) _expectingBlockStart = true; // Have caller search for content past the tag. _xamlReader.Read(); return null; } // Have caller look for content in descendants. Push(elementDescriptor); _xamlReader.Read(); // skip start-tag return null; } ////// On end of element, restore context data (pop, etc.) and look further. /// ////// Ancillary function of NextContentUnit. /// private IndexingContentUnit HandleElementEnd() { // Pop current descriptor. ContentDescriptor item = Pop(); // Consume end-tag. _xamlReader.Read(); return null; } ////// If the current tag is one of Glyphs, FixedPage or PageContent, process it adequately /// and return the next content unit or null (if not supposed to return content from fixed format). /// Otherwise, set 'handled' to false to tell the caller we didn't do anything useful. /// private IndexingContentUnit HandleFixedFormatTag(ElementTableKey elementFullName, out bool handled) { handled = true; // Not true until we return, but this is the most convenient default. if (!elementFullName.XmlNamespace.Equals(ElementTableKey.FixedMarkupNamespace, StringComparison.Ordinal)) { handled = false; // Let caller handle that tag. return null; } if (String.CompareOrdinal(elementFullName.BaseName, _glyphRunName) == 0) { // Ignore glyph runs during flow pass over a FixedPage. if (_filterState == FilterState.FindNextFlowUnit) { SkipCurrentElement(); return null; } else { return ProcessGlyphRun(); } } if (String.CompareOrdinal(elementFullName.BaseName, _fixedPageName) == 0) { // Ignore FixedPage element (i.e. root element) during flow pass over a fixed page. if (_filterState == FilterState.FindNextFlowUnit) { Push(_defaultContentDescriptor); _xamlReader.Read(); return null; } else { return ProcessFixedPage(); } } if (String.CompareOrdinal(elementFullName.BaseName, _pageContentName) == 0) { // If the element has a Source attribute, any inlined content should be ignored. string sourceUri = _xamlReader.GetAttribute(_pageContentSourceAttribute); if (sourceUri != null) { SkipCurrentElement(); return null; } else { // Have NextContentUnit() look for content in descendants. Push( _defaultContentDescriptor); _xamlReader.Read(); return null; } } // No useful work was done. Report 'unhandled'. handled = false; return null; } ////// Handle the presence of a glyph run in the middle of flow markup by extracting /// its UnicodeString attribute and considering it a separate paragraph. /// ////// The handling of glyph runs inside fixed pages is performed in ProcessFixedPage. /// private IndexingContentUnit ProcessGlyphRun() { Debug.Assert(_xamlReader != null); string textContent = _xamlReader.GetAttribute(_unicodeStringAttribute); if (textContent == null || textContent.Length == 0) { SkipCurrentElement(); return null; } _expectingBlockStart = true; // Read Lcid at current position and advance reader to next element before returning. uint lcid = GetCurrentLcid(); SkipCurrentElement(); return BuildIndexingContentUnit(textContent, lcid); } ////// Load FixedPage element into a DOM tree to initialize a FixedPageContentExtractor. /// The content extractor will then be used to incrementally return the content of the fixed page. /// private IndexingContentUnit ProcessFixedPage() { // Reader is positioned on the start-tag for a FixedPage element. Debug.Assert(String.CompareOrdinal(_xamlReader.LocalName, _fixedPageName) == 0); // A FixedPage nested in a FixedPage is invalid. // XmlException gets handled inside this class (see GetChunk). if (_filterState == FilterState.FindNextFlowUnit) { throw new XmlException(SR.Get(SRID.XamlFilterNestedFixedPage)); } // Create a DOM for the current FixedPage. string fixedPageMarkup = _xamlReader.ReadOuterXml(); XmlDocument fixedPageTree = new XmlDocument(); fixedPageTree.LoadXml(fixedPageMarkup); // Preserve the current language ID if (_xamlReader.XmlLang.Length > 0) { fixedPageTree.DocumentElement.SetAttribute(_xmlLangAttribute, _xamlReader.XmlLang); } // Initialize a content extractor with this DOM tree. _fixedPageContentExtractor = new FixedPageContentExtractor(fixedPageTree.DocumentElement); // Save the DOM (to search for flow elements in it once the extractor is done) // and switch to extractor mode. _fixedPageDomTree = fixedPageTree; _filterState = FilterState.UseContentExtractor; // Have NextContentUnit look for the appropriate unit in the new mode. return null; } ////// Create an XmlTextReader on _xamlStream with the appropriate settings. /// private void CreateXmlReader() { if (_xamlReader != null) { _xamlReader.Close(); } _xamlReader = new XmlTextReader(_xamlStream); // Do not return pretty-pretting spacing between tags as data. ((XmlTextReader)_xamlReader).WhitespaceHandling = WhitespaceHandling.Significant; // Initialize reader state. _attributesToIgnore = AttributesToIgnore.None; // not in the middle of processing a start-tag } private void EnsureXmlReaderIsClosed() { if (_xamlReader != null) { _xamlReader.Close(); } } ////// Return the LCID in scope for the current node or, if there is none, /// the system's default LCID. /// Note: XmlGlyphRunInfo.LanguageID is an internal property that also has /// similar logic and will default to CultureInfo.InvariantCulture.LCID /// CultureInfo.InvariantCulture will never be null /// private uint GetCurrentLcid() { string languageString = GetLanguageString(); if (languageString.Length == 0) return (uint)CultureInfo.InvariantCulture.LCID; else if (_lcidDictionary.ContainsKey(languageString)) return _lcidDictionary[languageString]; else { CultureInfo cultureInfo = new CultureInfo(languageString); _lcidDictionary.Add(languageString, (uint)cultureInfo.LCID); return (uint)cultureInfo.LCID; } } private string GetLanguageString() { string languageString = _xamlReader.XmlLang; if (languageString.Length == 0) { // Check whether there is a parent XAML reader. if (_topLevelReader != null) { languageString = _topLevelReader.XmlLang; } } return languageString; } private void SkipCurrentElement() { _xamlReader.Skip(); } private bool IsPrefixedPropertyName(string name, out string propertyName) { int suffixStart = name.IndexOf('.'); if (suffixStart == -1) { propertyName = null; return false; } propertyName = name.Substring(suffixStart + 1); return true; } ////// 0 is an illegal value, so this function never returns 0. /// After the counter reaches UInt32.MaxValue we assert, since such a /// high number for chunks is most likely an indicator of some other /// problem in the system/code. /// private uint AllocateChunkID() { Invariant.Assert(_currentChunkID <= UInt32.MaxValue); ++_currentChunkID; return _currentChunkID; } ////// Find an attribute named propertyName or X.propertyName. /// private string GetPropertyAsAttribute(string propertyName) { string value = _xamlReader.GetAttribute(propertyName); if (value != null) { return value; } bool attributeFound = _xamlReader.MoveToFirstAttribute(); while (attributeFound) { string attributePropertyName; if ( IsPrefixedPropertyName(_xamlReader.LocalName, out attributePropertyName) && attributePropertyName.Equals(propertyName, StringComparison.Ordinal)) { value = _xamlReader.Value; break; } // Advance reader. attributeFound = _xamlReader.MoveToNextAttribute(); } // Reposition reader on owner element. _xamlReader.MoveToElement(); return value; } #region Context Stack Accessors private ContentDescriptor TopOfStack() { return (ContentDescriptor) _contextStack.Peek(); } private void Push(ContentDescriptor contentDescriptor) { if (!contentDescriptor.IsInline) { _expectingBlockStart = true; } _contextStack.Push(contentDescriptor); } private ContentDescriptor Pop() { ContentDescriptor topOfStack = (ContentDescriptor) _contextStack.Pop(); // If we reach an end of block, we expect the next item to // start with a block separator. if (!topOfStack.IsInline) { _expectingBlockStart = true; } return topOfStack; } private void ClearStack() { _contextStack.Clear(); } #endregion Context Stack Accessors #endregion Private Methods #region Private Constants ///XML namespace URI for in-document code. private const string _inDocumentCodeURI = "http://schemas.microsoft.com/winfx/2006/xaml"; // Tag and attribute names. private const string _pageContentName = "PageContent"; private const string _glyphRunName = "Glyphs"; private const string _pageContentSourceAttribute = "Source"; private const string _fixedPageName = "FixedPage"; private const string _xmlLangAttribute = "xml:lang"; private const string _paragraphSeparator = "\u2029"; private const string _unicodeStringAttribute = "UnicodeString"; ////// The default content descriptor has content in child nodes, no title, and block-type content. /// private readonly ContentDescriptor _defaultContentDescriptor = new ContentDescriptor(true /*hasIndexableContent*/, false /*isInline*/, null, null); private readonly ContentDescriptor _nonIndexableElementDescriptor = new ContentDescriptor(false); // Static fields. private static readonly ManagedFullPropSpec _propSpec = new ManagedFullPropSpec(IndexingFilterMarshaler.PSGUID_STORAGE, (uint)MS.Internal.Interop.PID_STG.CONTENTS); #endregion Private Constants #region Private Fields // Variables initialized in constructor and InitializeDeclaredFields. private Stack _contextStack; private FilterState _filterState; private string _currentContent; private uint _currentChunkID; private int _countOfCharactersReturned; private IndexingContentUnit _indexingContentUnit; private bool _expectingBlockStart; private XmlReader _topLevelReader; private FixedPageContentExtractor _fixedPageContentExtractor; private XmlDocument _fixedPageDomTree; // Variables initialized in constructor and (potentially, if implemented some day) in IPersistFile.Load. private Stream _xamlStream; // Variables initialized in Init. private bool _filterContents; //defaults to false private bool _returnCanonicalParagraphBreaks; //defaults to false // Reader state variables (initialized in CreateXmlReader). private XmlReader _xamlReader; private AttributesToIgnore _attributesToIgnore; ///Map from fully qualified element name to content location information. private Hashtable _xamlElementContentDescriptorDictionary; //Dictionary of Language strings and the corresponding LCID. private Dictionary_lcidDictionary; #endregion Private Fields } // class XamlFilter #endregion XamlFilter } // namespace MS.Internal.IO.Packaging // File provided for Reference Use Only by Microsoft Corporation (c) 2007. // Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- OptionUsage.cs
- CalendarDataBindingHandler.cs
- BypassElementCollection.cs
- HttpCapabilitiesSectionHandler.cs
- ElapsedEventArgs.cs
- EditorZone.cs
- ClientTargetCollection.cs
- DataContract.cs
- BinHexEncoder.cs
- DesignTable.cs
- CodeGroup.cs
- _FtpDataStream.cs
- DPTypeDescriptorContext.cs
- SortableBindingList.cs
- GlobalizationSection.cs
- Int64AnimationUsingKeyFrames.cs
- ReservationCollection.cs
- AutoGeneratedFieldProperties.cs
- ExceptionUtil.cs
- ListCollectionView.cs
- IdleTimeoutMonitor.cs
- IntSecurity.cs
- CompareInfo.cs
- SrgsOneOf.cs
- DLinqDataModelProvider.cs
- DataDocumentXPathNavigator.cs
- WmpBitmapEncoder.cs
- TableSectionStyle.cs
- DrawingImage.cs
- ColorKeyFrameCollection.cs
- PromptStyle.cs
- VersionedStreamOwner.cs
- RawStylusInput.cs
- SortableBindingList.cs
- SByte.cs
- COSERVERINFO.cs
- BamlLocalizableResourceKey.cs
- SmiEventSink_Default.cs
- ToolStripDropDown.cs
- HiddenFieldPageStatePersister.cs
- NamespaceInfo.cs
- TableSectionStyle.cs
- TypeElementCollection.cs
- BooleanAnimationBase.cs
- CompatibleComparer.cs
- wmiutil.cs
- AutoResetEvent.cs
- Accessible.cs
- RunClient.cs
- PrinterSettings.cs
- QueryCacheEntry.cs
- WhitespaceRuleLookup.cs
- SharedStatics.cs
- SpecialNameAttribute.cs
- TemplatedMailWebEventProvider.cs
- ItemCheckedEvent.cs
- WorkflowRuntimeService.cs
- ServiceDiscoveryElement.cs
- ToolBarPanel.cs
- DecimalConstantAttribute.cs
- Operand.cs
- FileInfo.cs
- QilDataSource.cs
- XPathNodeInfoAtom.cs
- Drawing.cs
- ActivityExecutor.cs
- SHA1.cs
- JoinSymbol.cs
- ListDictionary.cs
- FeatureSupport.cs
- XmlSchemaAll.cs
- ConfigurationManagerHelper.cs
- DataSpaceManager.cs
- documentation.cs
- BufferedStream.cs
- Subtree.cs
- OleDbCommandBuilder.cs
- ExtenderProvidedPropertyAttribute.cs
- ChangePassword.cs
- DateTimeOffsetAdapter.cs
- Int32Rect.cs
- ProcessThreadCollection.cs
- Compiler.cs
- ProcessActivityTreeOptions.cs
- DataGridTablesFactory.cs
- ImageClickEventArgs.cs
- GPRECTF.cs
- Rect.cs
- X509Chain.cs
- ButtonBase.cs
- ConfigurationLockCollection.cs
- bidPrivateBase.cs
- TransformCollection.cs
- PrefixHandle.cs
- AbandonedMutexException.cs
- PhonemeEventArgs.cs
- PersonalizationState.cs
- EventMappingSettingsCollection.cs
- UIPermission.cs
- DataColumnMapping.cs