Beispiel #1
0
        XpsSerializationManager(
            BasePackagingPolicy packagingPolicy,
            bool batchMode
            ) :
            base()
        {
            this._packagingPolicy = packagingPolicy;
            this._isBatchMode     = batchMode;
            this._isSimulating    = false;
            this._simulator       = null;

            _reachSerializationServices = new ReachSerializationServices();
            _visualSerializationService = new VisualSerializationService(this);

            _reachSerializationServices.RegisterNameSpacesForTypes();
            _reachSerializationServices.RegisterSerializableDependencyPropertiesForReachTypes();
            _reachSerializationServices.RegisterNoneSerializableClrPropertiesForReachTypes();

            XpsResourcePolicy resourcePolicy = new XpsResourcePolicy(XpsResourceSharing.NoResourceSharing);

            resourcePolicy.RegisterService(new XpsImageSerializationService(), typeof(XpsImageSerializationService));
            resourcePolicy.RegisterService(new XpsFontSerializationService(packagingPolicy), typeof(XpsFontSerializationService));

            this._resourcePolicy = resourcePolicy;
            _documentNumber      = 0;
            _pageNumber          = 0;
            _documentStartState  = false;
            _pageStartState      = false;

            XpsPackagingPolicy xpsPackagingPolicy = _packagingPolicy as XpsPackagingPolicy;

            if (xpsPackagingPolicy != null)
            {
                _xpsDocEventManager = new XpsDriverDocEventManager(this);

                xpsPackagingPolicy.PackagingProgressEvent += new PackagingProgressEventHandler(_xpsDocEventManager.ForwardPackagingProgressEvent);

                this.XpsSerializationPrintTicketRequiredOnXpsDriverDocEvent += new XpsSerializationPrintTicketRequiredEventHandler(_xpsDocEventManager.ForwardUserPrintTicket);
            }
        }
Beispiel #2
0
        ReleaseXmlWriter(
            Type writerType
            )
        {
            Toolbox.EmitEvent(EventTrace.Event.WClientDRXReleaseWriterStart);

            bool subsetComplete = false;
            int  refCnt         = DecrementRefCntByType(writerType);

            //
            // signal the font sub-setter that we completed a node
            if (_resourcePolicy != null)
            {
                XpsFontSerializationService fontService = (XpsFontSerializationService)_resourcePolicy.GetService(typeof(XpsFontSerializationService));
                //
                // The font subsetter will determine if based on this
                // signal we have completed a subset
                //
                if (fontService != null && refCnt == 0)
                {
                    subsetComplete = fontService.SignalCommit(writerType);
                }
            }


            //
            // Allow the packaging policy to release the stream
            //
            if (_packagingPolicy != null)
            {
                if (writerType == typeof(FixedDocumentSequence))
                {
                    _packagingPolicy.ReleaseXmlWriterForFixedDocumentSequence();
                }
                else if (writerType == typeof(FixedDocument))
                {
                    _packagingPolicy.ReleaseXmlWriterForFixedDocument();
                }
                else if (writerType == typeof(FixedPage))
                {
                    _packagingPolicy.ReleaseXmlWriterForFixedPage();
                }
                else if (writerType == typeof(Visual))
                {
                    _packagingPolicy.ReleaseXmlWriterForFixedPage();
                }
                else
                {
                    throw new XpsSerializationException(SR.Get(SRID.ReachSerialization_NotSupported));
                }
            }

            //
            // If the subsetting is complete we need to notify the interleaving policy
            // so it can flush.
            //
            if (subsetComplete && refCnt == 0)
            {
                XpsPackagingPolicy xpsPackagingPolicy = _packagingPolicy as  XpsPackagingPolicy;
                if (xpsPackagingPolicy != null)
                {
                    xpsPackagingPolicy.InterleavingPolicy.SignalSubsetComplete();
                }
            }

            Toolbox.EmitEvent(EventTrace.Event.WClientDRXReleaseWriterEnd);
        }
Beispiel #3
0
        private void SerializeHyperlink(PathGeometry geometry, String id, Uri navigateUri)
        {
            String    nameForType = "Path";
            XmlWriter writer      = LinkXmlWriter;

            bool useID = false;

            if (!String.IsNullOrEmpty(id))
            {
                useID = AddLinkTarget(id);
            }

            if (!useID && navigateUri == null)
            {
                // don't write out this path
                return;
            }

            writer.WriteStartElement(nameForType);

            if (navigateUri != null)
            {
                if (IsFragment(navigateUri))
                {
                    XpsPackagingPolicy   policy   = SerializationManager.PackagingPolicy as XpsPackagingPolicy;
                    XpsOMPackagingPolicy omPolicy = SerializationManager.PackagingPolicy as XpsOMPackagingPolicy;
                    if (policy == null && omPolicy == null)
                    {
                        throw new XpsSerializationException(SR.Get(SRID.ReachSerialization_WrongPackagingPolicy));
                    }

                    Uri documentUri = SerializationManager.PackagingPolicy.CurrentFixedDocumentUri;
                    Uri pageUri     = SerializationManager.PackagingPolicy.CurrentFixedPageUri;

                    Uri    relativeUri         = PackUriHelper.GetRelativeUri(pageUri, documentUri);
                    string documentFragmentUri = relativeUri.OriginalString + navigateUri.OriginalString;
                    WriteAttribute(writer, "FixedPage.NavigateUri", documentFragmentUri);
                }
                else
                {
                    WriteAttribute(writer, "FixedPage.NavigateUri", navigateUri);
                }
                WriteAttribute(writer, "Fill", "#00000000");
            }
            else
            {
                WriteAttribute(writer, "Opacity", "0");
            }

            if (useID)
            {
                WriteAttribute(writer, "Name", id);
            }

            geometry.FillRule = FillRule.Nonzero;

            Size pageSize = ((IXpsSerializationManager)_serializationManager).FixedPageSize;

            VisualTreeFlattener.WritePath(writer, geometry, pageSize);

            writer.WriteEndElement();
        }