File Coverage

/root/.cpan/build/Imager-1.018-0/blib/lib/Imager/Font.pm

Criterion	Covered	Total	%
statement	58	170	34.1
branch	23	90	25.5
condition	10	38	26.3
subroutine	6	14	42.8
pod	9	9	100.0
total	106	321	33.0

package Imager::Font;
use 5.006;
use Imager::Color;
use strict;

our $VERSION = "1.039";

# the aim here is that we can:
#  - add file based types in one place: here
#  - make sure we only attempt to create types that exist
#  - give reasonable defaults
#  - give the user some control over which types get used
my %drivers =
  (
   tt=>{
        class=>'Imager::Font::Truetype',
        module=>'Imager/Font/Truetype.pm',
        files=>'.*\.ttf$',
	description => 'FreeType 1.x',
	checktype => 1,
       },
   t1=>{
        class=>'Imager::Font::T1',
        module=>'Imager/Font/T1.pm',
        files=>'.*\.pfb$',
	description => 'T1Lib',
       },
   ft2=>{
         class=>'Imager::Font::FT2',
         module=>'Imager/Font/FT2.pm',
         files=>'.*\.(pfa|pfb|otf|ttf|fon|fnt|dfont|pcf(\.gz)?)$',
	 description => 'FreeType 2.x',
        },
   ifs=>{
         class=>'Imager::Font::Image',
         module=>'Imager/Font/Image.pm',
         files=>'.*\.ifs$',
        },
   w32=>{
         class=>'Imager::Font::W32',
         module=>'Imager/Font/W32.pm',
	 description => 'Win32 GDI Fonts',
        },
  );

# this currently should only contain file based types, don't add w32
my @priority = qw(ft2 ifs);

sub new {
  my $class = shift;
  my $self = {};
  my ($file, $type, $id);
  my %hsh=(color => Imager::Color->new(255,0,0,255),
	   size => 15,
	   @_);

  bless $self,$class;

  if ($hsh{'file'}) {
    $file = $hsh{'file'};

    $type = $hsh{'type'};
    if (defined $type) {
      unless ($drivers{$type}) {
	Imager->_set_error("Unknown font type $type");
	return;
      }

      unless ($Imager::formats{$type}) {
	Imager->_set_error("The $type {$drivers{$type}) font driver is not installed");
	return;
      }
    }
    else {
      for my $drv (@priority) {
        undef $type;
        my $re = $drivers{$drv}{files} or next;
        if ($file =~ /$re/i) {
	  if (eval { require $drivers{$drv}{module}; 1 } and !( $drivers{$drv}{checktype} && !$Imager::formats{$drv} )) {
	    $type = $drv;
	    last;
	  }
        }
      }
    }
    if (!defined($type)) {
      # some types we can support, but the driver isn't available
      # work out which drivers support it, so we can provide the user
      # some useful information on how to get it working
      my @not_here;
      for my $driver_name (keys %drivers) {
	my $driver = $drivers{$driver_name};
	push @not_here, "$driver_name ($driver->{description})"
	  if $driver->{files} && $file =~ /$driver->{files}/i;
      }
      if (@not_here) {
	$Imager::ERRSTR = "No font drivers enabled that can support this file, rebuild Imager with any of ".join(", ", @not_here)." to use this font file";
      }
      else {
	$Imager::ERRSTR = "No font type found for $hsh{'file'}";
      }
      return;
    }
  } elsif ($hsh{face}) {
    $type = "w32";
  } else {
    $Imager::ERRSTR="No font file specified";
    return;
  }

  if ($drivers{$type}{checktype} && !$Imager::formats{$type}) {
    $Imager::ERRSTR = "`$type' not enabled";
    return;
  }

  # here we should have the font type or be dead already.

  require $drivers{$type}{module};
  return $drivers{$type}{class}->new(%hsh);
}

# returns first defined parameter
sub _first {
  for (@_) {
    return $_ if defined $_;
  }
  return undef;
}

sub draw {
  my $self = shift;
  my %input = ('x' => 0, 'y' => 0, @_);
  unless ($input{image}) {
    $Imager::ERRSTR = 'No image supplied to $font->draw()';
    return;
  }
  my $image = $input{image};
  $input{string} = _first($input{string}, $input{text});
  unless (defined $input{string}) {
    $image->_set_error("Missing required parameter 'string'");
    return;
  }
  $input{aa} = _first($input{aa}, $input{antialias}, $self->{aa}, 1);
  # the original draw code worked this out but didn't use it
  $input{align} = _first($input{align}, $self->{align});
  $input{color} = _first($input{color}, $self->{color});
  $input{color} = Imager::_color($input{'color'});

  $input{size} = _first($input{size}, $self->{size});
  unless (defined $input{size}) {
    $image->_set_error("No font size provided");
    return undef;
  }
  $input{align} = _first($input{align}, 1);
  $input{utf8} = _first($input{utf8}, $self->{utf8}, 0);
  $input{vlayout} = _first($input{vlayout}, $self->{vlayout}, 0);

  my $result = $self->_draw(%input);
  unless ($result) {
    $image->_set_error($image->_error_as_msg());
  }

  return $result;
}

sub align {
  my $self = shift;
  my %input = ( halign => 'left', valign => 'baseline',
                'x' => 0, 'y' => 0, @_ );

  # image needs to be supplied, but can be supplied as undef
  unless (exists $input{image}) {
    Imager->_set_error("Missing required parameter 'image'");
    return;
  }

  my $errors_to = $input{image} || 'Imager';

  my $text = _first($input{string}, $input{text});
  unless (defined $text) {
    $errors_to->_set_error("Missing required parameter 'string'");
    return;
  }

  my $size = _first($input{size}, $self->{size});
  my $utf8 = _first($input{utf8}, 0);

  my $bbox = $self->bounding_box(string=>$text, size=>$size, utf8=>$utf8);
  my $valign = $input{valign};
  $valign = 'baseline'
    unless $valign && $valign =~ /^(?:top|center|bottom|baseline)$/;

  my $halign = $input{halign};
  $halign = 'start'
    unless $halign && $halign =~ /^(?:left|start|center|end|right)$/;

  my $x = $input{'x'};
  my $y = $input{'y'};

  if ($valign eq 'top') {
    $y += $bbox->ascent;
  }
  elsif ($valign eq 'center') {
    $y += $bbox->ascent - $bbox->text_height / 2;
  }
  elsif ($valign eq 'bottom') {
    $y += $bbox->descent;
  }
  # else baseline is the default

  if ($halign eq 'left') {
    $x -= $bbox->start_offset;
  }
  elsif ($halign eq 'start') {
    # nothing to do
  }
  elsif ($halign eq 'center') {
    $x -= $bbox->start_offset + $bbox->total_width / 2;
  }
  elsif ($halign eq 'end') {
    $x -= $bbox->advance_width;
  }
  elsif ($halign eq 'right') {
    $x -= $bbox->advance_width - $bbox->right_bearing;
  }
  $x = int($x);
  $y = int($y);

  if ($input{image}) {
    delete @input{qw/x y/};
    $self->draw(%input, 'x' => $x, 'y' => $y, align=>1)
      or return;
  }

  return ($x+$bbox->start_offset, $y-$bbox->ascent,
          $x+$bbox->end_offset, $y-$bbox->descent+1);
}

sub bounding_box {
  my $self=shift;
  my %input=@_;

  if (!exists $input{'string'}) {
    $Imager::ERRSTR='string parameter missing';
    return;
  }
  $input{size} ||= $self->{size};
  $input{sizew} = _first($input{sizew}, $self->{sizew}, 0);
  $input{utf8} = _first($input{utf8}, $self->{utf8}, 0);

  my @box = $self->_bounding_box(%input)
    or return;

  if (wantarray) {
    if(@box && exists $input{'x'} and exists $input{'y'}) {
      my($gdescent, $gascent)=@box[1,3];
      $box[1]=$input{'y'}-$gascent;      # top = base - ascent (Y is down)
      $box[3]=$input{'y'}-$gdescent;     # bottom = base - descent (Y is down, descent is negative)
      $box[0]+=$input{'x'};
      $box[2]+=$input{'x'};
    } elsif (@box && $input{'canon'}) {
      $box[3]-=$box[1];    # make it canonical (ie (0,0) - (width, height))
      $box[2]-=$box[0];
    }
    return @box;
  }
  else {
    require Imager::Font::BBox;

    return Imager::Font::BBox->new(@box);
  }
}

sub dpi {
  my $self = shift;

  # I'm assuming a default of 72 dpi
  my @old = (72, 72);
  if (@_) {
    $Imager::ERRSTR = "Setting dpi not implemented for this font type";
    return;
  }

  return @old;
}

sub transform {
  my $self = shift;

  my %hsh = @_;

  # this is split into transform() and _transform() so we can
  # implement other tags like: degrees=>12, which would build a
  # 12 degree rotation matrix
  # but I'll do that later
  unless ($hsh{matrix}) {
    $Imager::ERRSTR = "You need to supply a matrix";
    return;
  }

  return $self->_transform(%hsh);
}

sub _transform {
  $Imager::ERRSTR = "This type of font cannot be transformed";
  return;
}

sub utf8 {
  return 0;
}

sub priorities {
  my $self = shift;
  my @old = @priority;

  if (@_) {
    @priority = @_;
  }
  return @old;
}

sub register {
  my ($self, %opts) = @_;

  my $type = delete $opts{type};
  my $class = delete $opts{class};
  my $files = delete $opts{files};
  my $description = delete $opts{description} || $class;

  defined $type
    or return Imager->_set_error("No type parameter supplied to Imager::Font->regster");

  defined $class
    or return Imager->_set_error("No class parameter supplied to Imager::Font->register");

  if ($files) {
    eval { qr/$files/ }
      or return Imager->_set_error("files isn't a valid regexp");
  }

  if ($drivers{$type} && $drivers{$type}{class} ne $class) {
    Imager->_set_error("Font type $type already registered as $drivers{$type}{class}");
    return;
  }

  (my $module = $class . ".pm") =~ s(::)(/)g;

  my $driver =
    {
     class => $class,
     module => $module,
     description => $description,
    };
  $files and $driver->{files} = $files;

  $drivers{$type} = $driver;

  1;
}

1;

__END__