internal TextWrapper(
     ContentScanner scanner
     ) : base((Text)scanner.Current)
 {
     textStrings = new List <TextStringWrapper>();
     Extract(scanner.ChildLevel);
 }
            internal static GraphicsObjectWrapper Get(
                ContentScanner scanner
                )
            {
                ContentObject obj = scanner.Current;

                if (obj is ShowText)
                {
                    return(new TextStringWrapper(scanner));
                }
                else if (obj is Text)
                {
                    return(new TextWrapper(scanner));
                }
                else if (obj is XObject)
                {
                    return(new XObjectWrapper(scanner));
                }
                else if (obj is InlineImage)
                {
                    return(new InlineImageWrapper(scanner));
                }
                else
                {
                    return(null);
                }
            }
 internal GraphicsState(
     ContentScanner scanner
     )
 {
     this.scanner = scanner;
     Initialize();
 }
        /**
         * <summary>Instantiates a top-level content scanner.</summary>
         * <param name="contents">Content objects collection to scan.</param>
         */
        public ContentScanner(
            Contents contents
            )
        {
            this.parentLevel = null;
            this.objects     = this.contents = contents;

            MoveStart();
        }
            internal GraphicsState Clone(
                ContentScanner scanner
                )
            {
                GraphicsState state = (GraphicsState)Clone();

                state.scanner = scanner;
                return(state);
            }
        /**
         * <summary>Instantiates a child-level content scanner.</summary>
         * <param name="parentLevel">Parent scan level.</param>
         */
        private ContentScanner(
            ContentScanner parentLevel
            )
        {
            this.parentLevel = parentLevel;
            this.contents    = parentLevel.contents;
            this.objects     = ((CompositeObject)parentLevel.Current).Objects;

            MoveStart();
        }
Exemple #7
0
        /**
         * <summary>Instantiates a top-level content scanner.</summary>
         * <param name="contents">Content objects collection to scan.</param>
         */
        public ContentScanner(
            Contents contents
            )
        {
            this.parentLevel = null;
            this.objects     = this.contents = contents;

            canvasSize = contextSize = contents.ContentContext.Box.Size;

            MoveStart();
        }
    #pragma warning restore 0628
        #endregion

        #region private

        /**
         * <summary>Synchronizes the scanner state.</summary>
         */
        private void Refresh(
            )
        {
            if (Current is CompositeObject)
            {
                childLevel = new ContentScanner(this);
            }
            else
            {
                childLevel = null;
            }
        }
            internal InlineImageWrapper(
                ContentScanner scanner
                ) : base((InlineImage)scanner.Current)
            {
                Matrix ctm = scanner.State.Ctm;

                this.box = new RectangleF(
                    ctm.Elements[4],
                    scanner.ContentContext.Box.Height - ctm.Elements[5],
                    ctm.Elements[0],
                    Math.Abs(ctm.Elements[3])
                    );
            }
Exemple #10
0
            internal XObjectWrapper(
                ContentScanner scanner
                ) : base((XObject)scanner.Current)
            {
                Matrix ctm = scanner.State.Ctm;

                this.box = new RectangleF(
                    ctm.Elements[4],
                    scanner.ContextSize.Height - ctm.Elements[5],
                    ctm.Elements[0],
                    Math.Abs(ctm.Elements[3])
                    );
                this.name    = BaseDataObject.Name;
                this.xObject = BaseDataObject.GetResource(scanner.ContentContext);
            }
        /**
         * <summary>Instantiates a child-level content scanner for <see cref="org.pdfclown.documents.contents.xObjects.FormXObject">external form</see>.</summary>
         * <param name="formXObject">External form.</param>
         * <param name="parentLevel">Parent scan level.</param>
         */
        public ContentScanner(
            xObjects::FormXObject formXObject,
            ContentScanner parentLevel
            )
        {
            this.parentLevel = parentLevel;
            this.objects     = this.contents = formXObject.Contents;

            OnStart += delegate(
                ContentScanner scanner
                )
            {
                // Adjust the initial graphics state to the external form context!
                scanner.State.Ctm.Multiply(formXObject.Matrix);

                /*
                 * TODO: On rendering, clip according to the form dictionary's BBox entry!
                 */
            };
            MoveStart();
        }
 internal TextStringWrapper(
     ContentScanner scanner
     ) : base((ShowText)scanner.Current)
 {
     textChars = new List <TextChar>();
     {
         GraphicsState state = scanner.State;
         style = new TextStyle(
             state.Font,
             state.FontSize * state.Tm.Elements[3],
             state.RenderMode,
             state.StrokeColor,
             state.StrokeColorSpace,
             state.FillColor,
             state.FillColorSpace
             );
         BaseDataObject.Scan(
             state,
             new ShowTextScanner(this)
             );
     }
 }
            private void Extract(
                ContentScanner level
                )
            {
                if (level == null)
                {
                    return;
                }

                while (level.MoveNext())
                {
                    ContentObject content = level.Current;
                    if (content is ShowText)
                    {
                        textStrings.Add((TextStringWrapper)level.CurrentWrapper);
                    }
                    else if (content is ContainerObject)
                    {
                        Extract(level.ChildLevel);
                    }
                }
            }