use v6;

use PDF::Content::FontObj;

class PDF::Content::Font::CoreFont
    does PDF::Content::FontObj {
    use Font::AFM:ver(v1.23.5+);
    use PDF::Content::Font;
    use PDF::Content::Font::Enc::Type1;
    use PDF::COS::Dict;
    use PDF::COS::Name;

    has Font::AFM $.metrics handles <kern>;
    has PDF::Content::Font::Enc::Type1 $.encoder handles <encode decode enc>;
    has PDF::Content::Font $!dict;

    constant coreFonts = set <
        courier courier-oblique courier-bold courier-boldoblique
        helvetica helvetica-oblique helvetica-bold helvetica-boldoblique
        times-roman times-italic times-bold times-bolditalic
        symbol zapfdingbats
        >;

    # font aliases adapted from pdf.js/src/fonts.js
    constant stdFontMap = {

        :arialnarrow<helvetica>,
        :arialnarrow-bold<helvetica-bold>,
        :arialnarrow-bolditalic<helvetica-boldoblique>,
        :arialnarrow-italic<helvetica-oblique>,

        :arialblack<helvetica>,
        :arialblack-bold<helvetica-bold>,
        :arialblack-bolditalic<helvetica-boldoblique>,
        :arialblack-italic<helvetica-oblique>,

        :arial<helvetica>,
        :arial-bold<helvetica-bold>,
        :arial-bolditalic<helvetica-boldoblique>,
        :arial-italic<helvetica-oblique>,

        :arialmt<helvetica>,
        :arial-bolditalicmt<helvetica-boldoblique>,
        :arial-boldmt<helvetica-bold>,
        :arial-italicmt<helvetica-oblique>,

        :courier-bolditalic<courier-boldoblique>,
        :courier-italic<courier-oblique>,

        :couriernew<courier>,
        :couriernew-bold<courier-bold>,
        :couriernew-bolditalic<courier-boldoblique>,
        :couriernew-italic<courier-oblique>,

        :couriernewps-bolditalicmt<courier-boldoblique>,
        :couriernewps-boldmt<courier-bold>,
        :couriernewps-italicmt<courier-oblique>,
        :couriernewpsmt<courier>,

        :helvetica-bolditalic<helvetica-boldoblique>,
        :helvetica-italic<helvetica-oblique>,

        :times<times-roman>,
        :timesnewroman<times-roman>,
        :timesnewroman-bold<times-bold>,
        :timesnewroman-bolditalic<times-bolditalic>,
        :timesnewroman-italic<times-italic>,

        :timesnewromanps<times-roman>,
        :timesnewromanps-bold<times-bold>,
        :timesnewromanps-bolditalic<times-bolditalic>,

        :timesnewromanps-bolditalicmt<times-bolditalic>,
        :timesnewromanps-boldmt<times-bold>,
        :timesnewromanps-italic<times-italic>,
        :timesnewromanps-italicmt<times-italic>,

        :timesnewromanpsmt<times-roman>,
        :timesnewromanpsmt-bold<times-bold>,
        :timesnewromanpsmt-bolditalic<times-bolditalic>,
        :timesnewromanpsmt-italic<times-italic>,

        :sans-serif<helvetica>,
        :serif<times-roman>,

        :symbol-bold<symbol>,
        :symbol-italic<symbol>,
        :symbol-bolditalic<symbol>,

        :webdings<zapfdingbats>,
        :webdings-bold<zapfdingbats>,
        :webdings-italic<zapfdingbats>,
        :webdings-bolditalic<zapfdingbats>,

        :zapfdingbats-bold<zapfdingbats>,
        :zapfdingbats-italic<zapfdingbats>,
        :zapfdingbats-bolditalic<zapfdingbats>,
    };

    submethod TWEAK(PDF::Content::Font :$!dict) {
        PDF::Content::Font.make-font($_, self)
            with $!dict;
    }

    method core-font-name(Str:D $family!, Str :$weight?, Str :$style?, ) is export(:core-font-name) {
        my Str $face = $family.lc;
        my Str $bold = $weight && $weight ~~ m:i/bold|[6..9]\d\d/
            ?? 'bold' !! '';

        # italic & oblique can be treated as synonyms for core fonts
        my Str $italic = $style && $style ~~ m:i/italic|oblique/
            ?? 'italic' !! '';

        $bold ||= 'bold' if $face ~~ s/ ['-'|',']? bold //;
        $italic ||= $0.lc if $face ~~ s/ ['-'|',']? (italic|oblique) //;

        my Str $sfx = $bold || $italic
            ?? '-' ~ $bold ~ $italic
            !! '';

        $face ~~ s/[['-'|','].*]? $/$sfx/;
        $face = $_ with stdFontMap{$face};
        $face ∈ coreFonts ?? $face !! Nil;
    }

    our proto method load-font(|c) {*};

    multi method load-font( Str :$family!, |c) {
        $.load-font( $family, |c );
    }

    multi method height(Numeric $pointsize?, Bool :$ex where .so) {
        my Numeric $height = $!metrics.XHeight;
	$pointsize ?? $height * $pointsize / 1000 !! $height;
    }

    #| compute the overall font-height
    multi method height(Numeric $pointsize?, Bool :$from-baseline, Bool :$hanging) {
        my List $bbox = $!metrics.FontBBox;
	my Numeric $height = $hanging ?? $!metrics.Ascender !! $bbox[3];
	$height -= $hanging ?? $!metrics.Descender !! $bbox[1]
            unless $from-baseline;
	$pointsize ?? $height * $pointsize / 1000 !! $height;
    }

    method stringwidth(Str $str, $pointsize = 0, Bool :$kern

False


    method !encoding-name {
        my %enc-name = :win<WinAnsiEncoding>, :mac<MacRomanEncoding>, :mac-extra<MacExpertEncoding>;
        with %enc-name{self.enc} -> $name {
            :$name;
        }
    }

    method !make-dict {
        my $dict = {
            :Type( :name<Font> ), :Subtype( :name<Type1> ),
            :BaseFont( :name( $!metrics.FontName ) ),
        };
        $dict<Encoding> = $_ with self!encoding-name;
        $dict;
    }

    method to-dict {
        $!dict //= PDF::Content::Font.make-font(
            PDF::COS::Dict.COERCE(self!make-dict),
            self);
    }

    method font-name { $!metrics.FontName }
    method underline-position  { $!metrics.UnderlinePosition }
    method underline-thickness { $!metrics.UnderlineThickness }

    method !load-core-font(Str:D $font-name, :$enc!, |c) {
        state %core-font-cache;
        %core-font-cache{$font-name.lc~'-*-'~$enc} //= do {
            my $encoder = PDF::Content::Font::Enc::Type1.new: :$enc;
            my $metrics = Font::AFM.core-font( $font-name );
            self.new( :$encoder, :$metrics, |c);
        }
    }

    multi method load-font(Str:D $font-name! where /:i ^[ZapfDingbats|WebDings]/, :$enc='zapf', |c) {
        self!load-core-font('zapfdingbats', :$enc, |c );
    }

    multi method load-font(Str:D $font-name! where /:i ^Symbol/, :$enc='sym', |c) {
        self!load-core-font('symbol', :$enc, |c );
    }

    multi method load-font(Str:D $font-name!, :$enc = 'win', |c) is default {
        self!load-core-font($_, :$enc )
            with $.core-font-name($font-name, |c);
    }

    method is-embedded  { False }
    method is-subset    { False }
    method is-core-font { True }

    method cb-finish {
        my $dict := self.to-dict;

        if $!encoder.differences -> $Differences {
            my $Encoding = %(
                :Type( :name<Encoding> ),
                :$Differences,
               );
            $Encoding<BaseEncoding> = $_
                with self!encoding-name;

            $dict<Encoding> = $Encoding;
        }

        $dict;
    }
}


root

README

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<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<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=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>

=item1 B<Resources>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>

=end nested
=begin nested :!nested

=item1 B<Resoures>
    =item2 L<Download | file:../download/index.podlite>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=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/>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=end React


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


CoreFont

PDF::Content v0.5.17

Authors

License

Dependencies

Test Dependencies

Provides

Documentation