Example #1
0
        public void AddContent(PartInfo rel, Stream sourceStream, OpenXmlFormat openXmlFormat)
        {
            PartInfo parentPart = GetPart(rel.RelatedTo);
            PartInfo clonedPart = new PartInfo(this, rel);
            string sContentType;
            if (ContentIsInternalType(rel.Type, openXmlFormat))
            {
                sContentType = rel.GetContentType();
                clonedPart.Target = RemoveLeadingSlash(clonedPart.Target);
                parentPart.AddRelatedItem(clonedPart);
                if (m_partsMap.ContainsKey(clonedPart.AbsolutePath()) && sourceStream == null)
                { // we have already added this content via a relationship elsewhere, don't need to write it
                    return;
                }
                m_partsMap.Add(clonedPart.AbsolutePath(), clonedPart);

                if (sourceStream != null)
                {
                    string partName = clonedPart.AbsolutePath();
                    AddZipEntry(partName, sourceStream);
                    if (rel.ContentTypeOverriden())
                        m_contentTypes.Add("/" + partName, sContentType);
                }
            }
            else
            {//we should only get here for external rels - so there should never be an additional stream to add
                parentPart.AddRelatedItem(clonedPart);
                sContentType = rel.Type;
                if (m_partsMap.ContainsKey(clonedPart.Target))
                { // we have already added this content via a relationship elsewhere, don't need to write it
                    return;
                }
                m_partsMap.Add(clonedPart.Target, clonedPart);
                if (sourceStream != null)
                {
                    throw new System.InvalidOperationException("Sourcestream is not null for supposedly external hyperlink part");
                }
            }
        }
        protected override void PreprocessPart(PartInfo rel, DocumentProcessingActions actions)
        {
            if (rel.External)
                return;

            if (m_listPreprocessedParts.Contains(rel.AbsolutePath()))
                return;
            if (IsASlidePartButNotInRelationToPresentation(rel))
                return;

            m_listPreprocessedParts.Add(rel.AbsolutePath());

            IPartFilter pf = GetPartFilterForPreprocessing(rel, actions);
            if (pf == null)
                return;

            PreprocessSpecialParts(rel, pf);

            foreach (PartInfo subRel in pf.SortRelatedParts(rel.GetRelatedObjects()))
            {
                PreprocessPart(subRel, actions);
            }
        }
Example #3
0
        private void TryLoadRelationships(PartInfo forPart)
        {
            string sRelRoot = forPart.AbsolutePath();
            PartInfo rootPart;
            if (m_partsMap.TryGetValue(sRelRoot, out rootPart))
            {
                // already been here by some other path
                // However, need to add the related objects to forPart, which is a copy of the object in the map, because sorting in
                // the part filter may change the order in which we retrieve things from the relationship tree
                // Slides have circular relationships in the pptx files so watch that if we re-write this to use the mapped objets
                List<PartInfo> pliRels = rootPart.GetRelatedObjects();
                foreach (PartInfo rpi in pliRels)
                {
                    forPart.AddRelatedItem(rpi);
                }
                return;
            }

            m_partsMap[sRelRoot] = forPart;

            using (Stream str = GetPartContent(BuildRelationshipPartName(sRelRoot)))
            {
                if (str == null)
                    return;

                forPart.LoadRelationships(str);


                foreach (PartInfo part in forPart.GetRelatedObjects())
                {
                    if (!part.External)
                        TryLoadRelationships(part);
                }
            }
        }
Example #4
0
 public Stream GetPartContent(PartInfo part)
 {
     string sPhysicalName = part.AbsolutePath();
     return GetPartContent(sPhysicalName);
 }
Example #5
0
        private void ProcessPart(PartInfo rel, OPCPackage inputPackage, OPCPackage outputPackage, DocumentProcessingActions action)
        {
            if (rel.External)
            {
                ProcessExternalPart(rel, outputPackage, action);
                return;
            }

            if (m_ProcessedParts.ContainsKey(rel.AbsolutePath()))
            {
                if (outputPackage != null)
                    outputPackage.AddContent(rel, null, m_openXmlFormat);
                return;
            }

            m_ProcessedParts.Add(rel.AbsolutePath(), true);

            IPartFilter pf = GetPartFilter(rel, action);
            Stream inputData = rel.GetContent();
            RelatedPartProvider relPartProv = new RelatedPartProvider(inputPackage, rel);

            Stream modifiedStream = ProcessPartData(pf, inputData, relPartProv, action);

            if (modifiedStream != null)
                outputPackage.AddContent(rel, modifiedStream, m_openXmlFormat);

            if (action != DocumentProcessingActions.PassThrough && pf.IsBlockedFilter)
                return;

            foreach (PartInfo subRel in pf.SortRelatedParts(rel.GetRelatedObjects()))
            {
                ProcessPart(subRel, m_inputPackage, m_outputPackage, action);
            }
        }