para

#| Tagged and marked content
unit class PDF::Content::Tag;



head

This class assists in the detection or construction of tagged and
marked content in page or xobject form content streams:


code

=begin code :lang<raku>
use lib 't';
use PDFTiny;
use PDF::Content::XObject;
use PDF::Content::Tag :ParagraphTags, :IllustrationTags;

my PDFTiny $pdf .= new;

my $page = $pdf.add-page;
my $header-font = $pdf.core-font: :family<Helvetica>, :weight<bold>;
my $body-font = $pdf.core-font: :family<Helvetica>;

$page.graphics: -> $gfx {
    my PDF::Content::Tag $tag;

    $tag = $gfx.mark: Header1, {
        .say('Header text',
             :font($header-font),
             :font-size(15),
             :position[50, 120]);
    }

    say $tag.name.Str; # 'H1'
    say $tag.mcid;     # marked content id of 0

    $tag = $gfx.mark: Paragraph, {
        .say('Paragraph that contains a figure', :position[50, 100], :font($body-font), :font-size(12));

        # nested tag. Note: marks cannot be nested, but tags can
        .tag: Figure, {
            my PDF::Content::XObject $img .= open: "t/images/lightbulb.gif";
            .do: $img, :position[50,70];
        }

    }

    say $tag.name.Str;         # 'P'
    say $tag.mcid;             # marked content id of 1
    say $tag.kids[0].name.Str; # 'Figure'
}

say $page.gfx.tags.gist; # '<H1 MCID="0"/><P MCID="1"><Figure/></P>';
=end code



use PDF::COS;
use PDF::COS::Array;
use PDF::COS::Dict;
use PDF::COS::Stream;

our class NodeSet {...}

has Str $.name is rw;
has Str $.op;
has %.attributes;
has $.canvas is required;
method owner is DEPRECATED<canvas> { $!canvas }
has UInt $.start is rw;
has UInt $.end is rw;
has UInt $.mcid is rw;      # marked content identifer
has Str  $.dest-name is rw; # resolved named destination target
has PDF::COS::Stream $.content;
has PDF::Content::Tag $.parent is rw; # hierarchical parent
has NodeSet $.kids handles<AT-POS list grep map tags children elems> .= new;

#| See [PDF 32000 Tables 333 - Standard structure types for grouping elements]
my enum StructureTags is export(:StructureTags,:Tags) (
    :Document<Document>, :Part<Part>, :Article<Art>, :Section<Sect>,
    :Division<Div>, :BlockQuotation<BlockQuote>, :Caption<Caption>,
    :TableOfContents<TOC>, :TableOfContentsItem<TOCI>, :Index<Index>,
    :NonStructural<NonStruct>, :Private<Private>,
    # + [[PDF 32000-2 Table 364 Document level structure types]
    :DocumentFragment<DocumentFragment>,
    # + [PDF 32000-2 Table 365 — Grouping level structure types]
    :Aside<Aside>,
    # + [PDF 32000-2 Table 367 — Sub-block level structure type]
    :Subdivision<Sub>,
);

#| See [PDF 32000 Tables 334-337 - Block-level structure elements]
my enum ParagraphTags is export(:ParagraphTags,:Tags) (
    :Paragraph<P>, :Header<H>,
    :Header1<H1>,  :Header2<H2>,  :Header3<H3>,
    :Header4<H4>,  :Header5<H5>,  :Header6<H6>,
    # + [PDF 32000-2 Table 366 — Block level structure types]
    :Title<Title>, :FENote<FENote>,
);
my enum ListElemTags is export(:ListElemTags,:Tags) (
    :LIST<L>, :ListItem<LI>, :Label<Lbl>, :ListBody<LBody>,
);
my enum TableTags is export(:TableTags,:Tags) (
    :Table<Table>,     :TableHead<THead>, :TableBody<TBody>,
    :TableFoot<TFoot>, :TableHeader<TH>,  :TableRow<TR>,
    :TableData<TD>,
);

#| See [PDF 32000 Table 338 - Standard structure types for inline-level structure elements]
my enum InlineElemTags is export(:InlineElemTags,:Tags) (
    :Span<Span>, :Quotation<Quote>,   :Note<Note>, :Reference<Reference>,
    :BibliographyEntry<BibEntry>,     :CODE<Code>, :Link<Link>,
    :Annotation<Annot>, :Ruby<Ruby>,  :RubyPunctuation<RP>,
    :RubyBaseText<RB>,  :RubyText<RT>,
    :Warichu<Warichu>,  :WarichuPunctuation<RP>, :WarichuText<RT>,
    # + [PDF 32000-2 Table 368 — General inline level structure types]
    :Emphasis<Em>, :Strong<Strong>
);

my enum IllustrationTags is export(:IllustrationTags,:Tags) (
    :Figure<Figure>, :Formula<Formula>, :Form<Form>
);

#| These tags are meaningful within content streams, as opposed to the structure-tree
my enum ContentTags is export(:ContentTags,:Tags) (
    :Artifact<Artifact>,   # Can also be Structural Element (PDF 32000-2)
    :OptionalContent<OC>,  # [PDF 32000 8.11.3.2 Optional Content in Content Streams]
    :TagSuspect<TagSuspect>, :ReversedChars<ReversedChars>, # [PDF 32000 14.8.2 Tagged PDF and Page Content]
    :Clipped<Clip>, # [PDF 32000 14.6.3 Marked Content and Clipping
);

constant %TagAliases is export(:TagAliases) = (
    StructureTags, ParagraphTags, ListElemTags, TableTags,
    InlineElemTags, IllustrationTags, ContentTags,
).map(*.enums).Hash;

constant TagSet is export(:TagSet) = %TagAliases.values.Set;

#| Add a child tag
multi method add-kid(PDF::Content::Tag $kid --> PDF::Content::Tag) {
    die 'tag already parented by {.gist}' with $kid.parent;
    die "can't add tag to itself"
        if $kid === self;
    $!kids.push: $kid;
    $kid.parent = self;
    $kid;
}

method !attributes-gist {
    given %!attributes {
        my %a = $_;
        %a<MCID> = $_ with self.?mcid;
        %a.pairs.sort.map({ " {.key}=\"{.value}\"" }).join: '';
    }
}

method gist {
    my $attributes = self!attributes-gist();
    $.kids
        ?? [~] ("<{$.name}$attributes>",
                $!kids».gist.Slip,
                "</{$.name}>")
        !! "<{$.name}$attributes/>";
}

#| take self and all descendants
method take-descendants {
    take self;
    $!kids.take-descendants;
}

#| gather all descendants
method descendants returns Seq { gather self.take-descendants }

our class NodeSet {
    my subset Node where PDF::Content::Tag | Str;
    has Node @.tags handles<grep map AT-POS Bool shift push elems>;

    method children { @!tags }
    method take-descendants { @!tags.grep(PDF::Content::Tag).map(*.take-descendants) }
    method descendants { gather self.take-descendants }
    method gist { @!tags».gist.join }
}


root

PageTree

React

=begin React :component<HeaderCol> :id<menu> 
=para L<Documentation|/doc/introduction>
=para L<Modules| /mods>
=para L<Examples| file:../examples/index.podlite>
=para L<AI|file:../mcp/index.podlite>
=para L<Download |file:../download/index.podlite>
=para L<About|file:../about/index.podlite>
=para 🔍 K<⌘K>/K<ctrl-K>
=end React


=begin React :component<HeaderCol> :id<footer>  
=begin nested :!nested
=item1 B<Language>
    =item2 L<Get started|file:../getting-started/getting-started.podlite>
    =item2 L<Why Raku?|/doc/language/faq#Why-should-I-learn-Raku-What's-so-great-about-it>
    =item2 L<Try Raku|https://glot.io/new/raku>
    =item2 L<Download | file:../download/index.podlite>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>

=end nested
=begin nested :!nested

=item1 B<L<Documentation|/doc>>
    =item2 L<Getting started, Migration guides from other languages, & Tutorials | file:../doc/introduction.podlite>
    =item2 L<Language References|file:../doc/reference.podlite>
    =item2 L<Type Reference| file:../doc/types.podlite>
    =item2 L<Miscellaneous| file:../doc/miscellaneous.podlite>
    =item2 L<FAQs (Frequently Asked Questions)|/doc/language/faq>
    =item2 L<Community|/doc/language/community>
    =item2 L<The list of all documents|file:../doc/index.podlite>
    =item2 L<Hand these documents to an AI assistant|file:../mcp/index.podlite>

=end nested
=begin nested :!nested
=item1 B<Learning>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Wikibook |https://en.wikibooks.org/wiki/Raku_Programming>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>
    =item2 L<Learn Raku in Y minutes|https://learnxinyminutes.com/docs/raku/>
    =item2 L<Golfing |https://github.com/AlexDaniel/raku-golf-cheatsheet>
=end nested
=begin nested :!nested

=item1 B<Explore>
    =item2 L<Raku Blog Aggregator|https://planet.raku.org/>
    =item2 L<Rakudo Weekly|https://rakudoweekly.blog/>
    =item2 L<The Weekly Challenge |https://perlweeklychallenge.org/>
    =item2 L<Raku Advent Calendar|https://raku-advent.blog/>

=end nested
=end React


Built with L<Podlite|https://podlite.org> — the markup and publishing tools behind this site.


=begin React :component<CookieConsent> :id<CookieConsent> :buttonCaption("Got it!")
=para
This website uses cookies for analytics.
=end React


Tag

Description

Example

Methods

PDF::Content v0.9.11

Authors

License

Dependencies

Test Dependencies

Provides

Documentation