head

code

root

para

L<Examples| file:../examples/index.podlite>


L<Download |file:../download/index.podlite>


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


HEADER

FOOTER

Glyph

use v6;

class PDF::Font::Loader:ver<0.7.5> {

    use Font::FreeType;
    use Font::FreeType::Face;
    use PDF::Content::Font;
    use PDF::Content::Font::CoreFont;
    use PDF::Content::Font::Enc::Type1 :Type1EncodingScheme;
    use PDF::COS;
    use PDF::COS::Dict;
    use PDF::Font::Loader::FontObj;
    use PDF::Font::Loader::FontObj::CID;
    use PDF::Font::Loader::Dict :&load-font-opts;

    proto method load-font($?: |c) is export(:load-font) {*};

    multi method load-font($class = $?CLASS: IO() :$file!, |c) {
        my Blob $font-buf = $file.slurp: :bin;
        $class.load-font: :$font-buf, |c;
    }

    my subset Type1 where .font-format ~~ 'Type 1'|'CFF' && !.is-internally-keyed-cid;
    my subset CIDEncoding of Str where m/^[identity|utf]/;
    multi method load-font(
        $?: Font::FreeType::Face :$face!,
        Blob :$font-buf!,
        Bool :$embed = True,
        Str  :$enc = $face ~~ Type1 || !$embed || ($face.num-glyphs <= 255 && !$face.is-internally-keyed-cid)
            ?? 'win'
            !! 'identity-h',
        Bool :$cid = $face !~~ Type1 && $enc ~~ 'cmap'|CIDEncoding,
        |c,
    ) is hidden-from-backtrace {
        unless c<dict>.defined {
            fail "Type1 fonts cannot be used as a CID font"
                if $cid && $face ~~ Type1;
            fail "'$enc' encoding can only be used with CID fonts"
                if !$cid && $enc ~~ CIDEncoding;
        }
        my \fontobj-class = $cid
            ?? PDF::Font::Loader::FontObj::CID
            !! PDF::Font::Loader::FontObj;
        fontobj-class.new: :$face, :$font-buf, :$enc, :$embed, |c;
    }

    multi method load-font($class = $?CLASS: Blob :$font-buf!, Font::FreeType :$ft-lib, |c) is hidden-from-backtrace {
        my Font::FreeType::Face:D $face = $ft-lib.face($font-buf);
        $class.load-font: :$face, :$font-buf, |c;
    }

    # core font load
    multi method load-font(
        $class is copy = $?CLASS:
        :core-font($)! where .so,
        Str:D :$family!,
        Str:D :$enc = 'win',
        :dict($), :encoder($),
        |c
    ) {
        $class = PDF::Content::Font::CoreFont
            unless c<encoder> || $enc !~~ Type1EncodingScheme;
        $class.load-font: :$family, :$enc, |c;
    }

    # resolve font name via FontConfig
    multi method load-font($class is copy = $?CLASS: Str:D :$family!, PDF::COS::Dict :$dict, :$quiet, |c) is hidden-from-backtrace {
	my Str:D $file = $class.find-font(:$family, |c)
	    || do {
            note "unable to locate font. Falling back to mono-spaced font"
	        unless $quiet;
            %?RESOURCES<font/FreeMono.ttf>.absolute;
        }

        my PDF::Font::Loader::FontObj:D $font := $class.load-font: :$file, :$dict, |c;
	unless $quiet // !$dict {
	    my $name = c<font-name> // $family;
            note "loading font: $name -> $file";
	}
        $font;
    }

    # resolve via PDF font dictionary
    multi method load-font(
        $class is copy = $?CLASS:
        PDF::Content::Font:D :$dict!,
        Bool :$core-font,
        |c) is hidden-from-backtrace {
        my %opts = load-font-opts(:$dict, |c);
        $class = PDF::Content::Font::CoreFont
            if $core-font && PDF::Font::Loader::Dict.is-core-font(:$dict) && %opts<enc> ~~ Type1EncodingScheme && !%opts<encoder>;
        $class.load-font: |%opts, |c;
    }

    subset Weight is export(:Weight) where /^[thin|extralight|light|book|regular|medium|semibold|bold|extrabold|black|<[0..9]>**3]$/;
    subset Stretch of Str is export(:Stretch) where /^[[ultra|extra]?[condensed|expanded]]|normal$/;
    subset Slant   of Str is export(:Slant) where /^[normal|oblique|italic]$/;

    method find-font($?: Str :$family is copy,
                     Weight  :$weight is copy = 'medium',
                     Stretch :$stretch = 'normal',
                     Slant   :$slant = 'normal',
                     UInt    :$limit, # deprecated
                     UInt    :$best is copy = $limit,
                     Bool    :$seq, # deprecated
                     Bool    :$all is copy = $seq,
                     Bool    :$serif, # restrict to serif or sans-serif
                     :cid($), :differences($), :embed($), :enc($), :encoder($),
                     :font-name($), :font-descriptor($), :subset($),
                     *%props,
                    ) is raw is export(:find-font) is hidden-from-backtrace {

        warn ':seq option is deprecated. please use :all, or :$best'
            with $seq;

        warn ':limit option is deprecated. please use :all, or :$best'
           with $limit;

       # https://wiki.archlinux.org/title/Font_configuration/Examples#Default_fonts
        with $serif {
            $family = $_ ?? 'serif' !! 'sans-serif';
        }

        with $weight {
            # convert CSS/PDF numeric weights for fontconfig
            #      000  100        200   300  400     500    600      700  800       900
            $_ =  <thin extralight light book regular medium semibold bold extrabold black>[.substr(0,1).Int]
                if /^<[0..9]>/;
        }

        my $FontConfig := try PDF::COS.required("FontConfig::Pattern");
        if $FontConfig === Nil {
            $all = Nil;
            $best = Nil;
            # Try for an older FontConfig version
            $FontConfig := try PDF::COS.required("FontConfig");
            if $FontConfig === Nil {
                warn "FontConfig is required for the find-font method";
                return Str;
            }
        }
        my $patt = $FontConfig.new: |%props;
        $patt.family = $_ with $family;
        $patt.weight = $weight  unless $weight eq 'medium';
        $patt.width  = $stretch unless $stretch eq 'normal';
        $patt.slant  = $slant   unless $slant eq 'normal';

        if $all || $best {
            $patt.match-series(:$all, :$best).map: *.file;
        }
        else {
            with $patt.match -> $match {
                $match.file;
	    }
	    else {
	        Str;
            }
	}
    }

}



 =begin code :lang<raku>
 # load a font from a file
 use PDF::Font::Loader :&load-font;
 use PDF::Content::FontObj;

 my PDF::Content::FontObj $deja;
 $deja = PDF::Font::Loader.load-font: :file<t/fonts/DejaVuSans.ttf>;
 -- or --
 $deja = load-font( :file<t/fonts/DejaVuSans.ttf> );

 # find/load the best matching system font
 # *** requires FontConfig ***
 use PDF::Font::Loader :load-font, :find-font;
 $deja = load-font( :family<DejaVu>, :slant<italic> );
 my Str $file = find-font( :family<DejaVu>, :slant<italic> );
 my PDF::Content::FontObj $deja-vu = load-font: :$file;

 # use the font to add text to a PDF
 use PDF::Lite;
 my PDF::Lite $pdf .= new;
 $pdf.add-page.text: {
    .font = $deja, 12;
    .text-position = [10, 600];
    .say: 'Hello, world';
 }
 $pdf.save-as: "/tmp/example.pdf";
 =end code


This module provides font loading and handling for
L<PDF::Lite>,  L<PDF::API6> and other PDF modules.


A class level method to load a font from a font file, or pattern creating a new L<PDF::Font::Loader::FontObj> object.


Loads a font from a given font file as a L<PDF::Font::Loader::FontObj> object.


Finds the best matching font using the `find-font` method on a pattern and loads it. If `:core-font` is True and the pattern
matches a core-font, it is loaded as a L<PDF::Content::Font::CoreFont> object.


item

C<PDF::Font::Loader.load-font(Str :$family, Str :$weight, Str :$stretch, Str :$slant, Bool :$core-font, Bool :$subset, Str :$enc, Str :$lang);>


my $vera = PDF::Font::Loader.load-font: :family<vera>;
my $deja = PDF::Font::Loader.load-font: :family<Deja>, :weight<bold>, :stretch<condensed> :slant<italic>);


Finds and loads the best-matching system font via L<FontConfig>.


Note: This method requires the Raku L<FontConfig> module to be installed,
unless the `:core-font` option is used, to load only PDF core fonts.


This method requires the optional L<FontConfig> Raku module to be installed.


Locates, font-files after sorting system fonts using the pattern.
Normally the best matching font-file is returned, or multiple font
files can be returned using the `:best($n)` or `:all` options.


=begin code :lang<raku>
my $file = PDF::Font::Loader.find-font: :family<Deja>, :weight<bold>, :width<condensed>, :slant<italic>, :lang<en>;
say $file;  # /usr/share/fonts/truetype/dejavu/DejaVuSansCondensed-BoldOblique.ttf
my $font = PDF::Font::Loader.load-font: :$file;
=end code


The `:all` option returns a sequence of all fonts, ordered by best to worst matching. This method may be useful, if you wish to apply your own selection critera.


The `:best($n)` is similar to `:all`, but returns at most the `$n` best matching fonts.


Any additional options are treated as a L<FontConfig> pattern attributes. For example `:spacing<mono>` will select monospace fonts.


=begin code :lang<raku>
use PDF::Font::Loader;
use Font::FreeType;
use Font::FreeType::Face;
my Font::FreeType $ft .= new;
my $series = PDF::Font::Loader.find-font(:best(10), :!serif, :weight<bold>,);
my Str @best = $series.Array;
# prefer a font with kerning
my Str $best-font = @best.first: -> $file {
    my Font::FreeType::Face $face = $ft.face: $file;
    $face.has-kerning;
}
# fall-back to best matching font without kerning
$best-font //= @best.head;

note "best font: " ~ $best-font;
=end code


Loader

The Raku Knowledge Base


=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


Glyph

class PDF::Font::Loader::Glyph

Description

Example

Methods

code-point

name

cid

gid

ax

ay

sx

PDF::Font::Loader v0.7.5

Authors

License

Dependencies

Test Dependencies

Provides

Documentation