File indexing completed on 2024-11-10 04:07:30

 #!/usr/bin/perl -w
 
 # This file is part of Krita
 #
 #  SPDX-FileCopyrightText: 2005 Sven Langkamp <sven.langkamp@gmail.com>
 #
 #  SPDX-License-Identifier: GPL-2.0-or-later
 
 
 use strict;
 use warnings;
 use Archive::Zip qw( :ERROR_CODES );
 use Archive::Zip::MemberRead;
 
 
 sub printi18n($$$$) {
   # function that prints the actual output
   my ($name, $filename, $filename2, $linenum) = @_;
   chomp($name); # chomp out the null bytes at the end if relevant
   $name =~ s/\0*//;
   if ($name ne "")
     {
       if ($filename =~ /myb$/)
       {
         print "// i18n: Display name of resource, see context: MyPaint brush [path-to-file]/[resource-filename]\n";
       }
       else
       {
         print "// i18n: Display name of resource, see context: [path-to-resources]/[resource-type]/[resource-filename]\n";
       }
 
       if ($name =~ /^\w\)/)
       {
         print "// i18n: 'a)', 'b)' etc. in resource names are used to keep resources in a specific order ";
         print "when Krita sorts them alphabetically. The order will be kept only using the original/untranslated names\n";
       }
       if ($name =~ /DITH\b/)
       {
         print "// i18n: DITH probably means 'dithering'\n";
       }
 
       if ($linenum > 0)
       {
         print "// i18n: file: ".$filename.":".$linenum."\n";
       }
 
       print "i18nc(\"".$filename."\",\"".$name."\");\n";
     }
 }
 
 sub parseFromFilenameAuto($) {
   # function that prettifies filenames without needing to define the extension
   # because it figures out the extension on its own
   my $name = $_[0];
   my @extensions = split(/\./, $name);
   my $extension = $extensions[$#extensions];
   return parseFromFilename($name, $extension);
 }
 
 sub parseFromFilename($$) {
   # function that prettifies filenames
   # it extracts the filename from the full path, cuts off the extension and replaces '_  with ' '
   my $name = $_[0];
   my $extension = $_[1];
   chomp($name);
   my @path = split(/\//, $name);
   $name = $path[$#path];
   $name =~ s/_/ /g;
   if( $extension ne "" ) {
     $name =~ s/\.${extension}$//g;
   }
   return $name;
 }
 
 sub readGeneric($$$$) {
   # function that reads all the lines from either the proper perl file handle
   # or from the special buffer made out of the contents of the file in the bundle
   my ($fh, $zipSpecialBuffer, $bufferref, $bytesnum) = @_;
 
   my $response = undef;
   my $buffer = ${$bufferref};
   if(defined $fh)
   {
     $response = read($fh, $buffer, $bytesnum);
   }
   elsif(defined $zipSpecialBuffer)
   {
     my $where = $zipSpecialBuffer->{"pos"};
     $buffer = unpack("x$where a${bytesnum}", $zipSpecialBuffer->{"buffer"});
     $response = length($buffer);
     $zipSpecialBuffer->{"pos"} = $zipSpecialBuffer->{"pos"} + $bytesnum;
   }
   ${$bufferref} = $buffer;
   return $response;
 }
 
 sub readAllLinesGeneric($$) {
   # function that reads all the lines from either the proper perl file handle
   # or from the MemberRead from the Archive::Zip module file handle
   my ($fh, $ziph) = @_;
   my @response = undef;
   if(defined $fh)
   {
     @response = <$fh>;
   }
   elsif(defined $ziph)
   {
     my $i = 0;
     @response = ();
     while (defined(my $line = $ziph->getline()))
     {
       push(@response, $line);
       $i += 1;
     }
   }
   return @response;
 }
 
 
 sub readGbrBytesWise($$) {
   # function that extracts a name from a gbr file
   # it's in the function to allow easier error checking
   # (early returning)
   my ($fh, $ziph) = @_;
 
   my $success = 1;
   my ($bytes, $size, $version);
   $success = readGeneric($fh, $ziph, \$bytes, 4) == 4;
 
   return "" if not $success;
 
   $size = unpack("N", $bytes);
   $success = readGeneric($fh, $ziph, \$bytes, 4) == 4;
 
   return "" if not $success;
 
   $version = unpack("N", $bytes);
   if( $version == 1 )
   {
     $success = readGeneric($fh, $ziph, \$bytes, 12) == 12;
     return "" if not $success;
 
     my $name;
     $success = readGeneric($fh, $ziph, \$name, $size - 21) == $size - 21;
     return "" if not $success;
 
     return $name;
   }
   else
   {
     $success = readGeneric($fh, $ziph, \$bytes, 20) == 20;
     return "" if not $success;
 
     my $name;
     $success = readGeneric($fh, $ziph, \$name, $size - 29) == $size - 29;
     return "" if not $success;
 
     return $name;
   }
 
   return "";
 
 }
 
 sub readZipSpecialBuffer($)
 {
   # this is a hack
   # $ziph->read($buffer, $bytes) didn't work but ->getline() did
   # this works for all binary files in the bundle that are supported at the moment
   my ($ziph) = @_;
   my $buffer = {};
   $buffer->{"pos"} = 0;
   my @array = readAllLinesGeneric(undef, $ziph);
   $buffer->{"buffer"} = join("\n", @array);
   return $buffer;
 }
 
 
 
 
 my @filenames = glob("./krita/data/gradients/*.ggr");
 push( @filenames, glob("./krita/data/palettes/*.gpl"));
 push( @filenames, glob("./krita/data/brushes/*.gih"));
 push( @filenames, glob("./krita/data/brushes/*.gbr"));
 push( @filenames, glob("./krita/data/brushes/*.svg"));
 push( @filenames, glob("./krita/data/patterns/*.pat"));
 push( @filenames, glob("./krita/data/patterns/*.png"));
 push( @filenames, glob("./krita/data/paintoppresets/*.kpp"));
 push( @filenames, glob("./krita/data/workspaces/*.kws"));
 push( @filenames, glob("./krita/data/windowlayouts/*.kwl"));
 push( @filenames, glob("./krita/data/gamutmasks/*.kgm"));
 push( @filenames, glob("./plugins/paintops/mypaint/brushes/*.myb"));
 push( @filenames, glob("./krita/data/symbols/*.svg"));
 
 
 my %bundleForResource;
 my %internalFilenameForResource;
 
 # get the filename from the bundle
 my @bundlenames = glob("./krita/data/bundles/*.bundle");
 foreach my $bundlename (@bundlenames)
 {
   my $bundle = Archive::Zip->new();
   unless ( $bundle->read( $bundlename ) == AZ_OK )
   {
     next;
   }
   my @memberNames = $bundle->memberNames();
   foreach my $member (@memberNames)
   {
     unless ($member =~ /xml$/ or $member eq "mimetype" or $member eq "preview.png") {
       my $newFilename = "$bundlename:$member";
       push(@filenames, $newFilename);
       $bundleForResource{$newFilename} = $bundle;
       $internalFilenameForResource{$newFilename} = $member;
     }
   }
 }
 
 
 
 my $isZip = 0;
 
 my $i = 0;
 
 foreach my $filename (@filenames)
 {
   $i = $i + 1;
 
   my $fh = undef;
   my $ziph = undef;
 
   unless ( open($fh, '<'.$filename) )
   {
     $fh = undef;
     unless ($filename =~ /\.bundle/) {
       next;
     }
     $ziph = Archive::Zip::MemberRead->new($bundleForResource{$filename}, $internalFilenameForResource{$filename});
 
     unless (defined $ziph) {
       next;
     }
     $isZip = 1;
   }
 
   if( $filename =~ /ggr/ || $filename =~ /gpl/ || $filename =~ /gih/ )
   {
     my @lines = readAllLinesGeneric($fh, $ziph);
 
     if( $filename =~ /ggr/ || $filename =~ /gpl/ )
     {
       my @splitted = split(/: /, $lines[1]);
       my $name = $splitted[1];
       chomp($name);
       $name =~ s/\t$//; # Trim trailing \t, fixes the name for "swatche.gpl"
       printi18n($name, $filename, $filename, 2);
     }
     else
     {
       my $name = $lines[0];
       chomp($name);
       printi18n($name, $filename, $filename, 1);
     }
   }
   elsif( $filename =~ /svg$/ )
   {
     my @lines = readAllLinesGeneric($fh, $ziph);
     my $svg = join('', @lines);
     my $name = "";
     if( $svg =~ m:(<title.*?</title>):s )
     {
       my $titlesvg = $1;
       if( $titlesvg =~ m:>(.*?)</title>:s ) #not perfect, but should usually do a good job, at least for existing libraries
       {
         $name = $1;
         chomp($name);
         $name =~ s/&amp;/&/; # 'Pepper & Carrot Speech Bubbles' needs it
       }
     }
     if ($name eq "")
     {
       $name = parseFromFilenameAuto($filename);
     }
     printi18n($name, $filename, $filename, -1);
   }
   elsif( $filename =~ /kpp$/ || $filename =~ /kws$/ || $filename =~ /kwl$/ || $filename =~ /kgm$/ || $filename =~ /jpg$/ || $filename =~ /myb$/ || $filename =~ /png$/ || $filename =~ /kse$/)
   {
     # all of Krita's default brush presets and other resources with abovementioned extensions
     # are named the same way the file is called
     # so there is no need to parse the file itself to find the name inside of it
     my $extension = split(/\./, $filename);
     my $name = parseFromFilenameAuto($filename);
     printi18n($name, $filename, $filename, -1); # sadly, I'm not sure what the last number means exactly
   }
   elsif($filename =~ /gbr|pat/)
   {
     my $zipSpecialBuffer = undef;
     if(defined($ziph)) {
       $zipSpecialBuffer = readZipSpecialBuffer($ziph);
     }
 
     if( $filename =~ /gbr/ )
     {
 
       my $name = readGbrBytesWise($fh, $zipSpecialBuffer);
       if($name eq "")
       {
         $name = parseFromFilenameAuto($filename);
       }
 
       printi18n($name, $filename, $filename, -1);
 
     }
     elsif( $filename =~ /pat$/ )
     {
       my $bytes;
       my $name;
       readGeneric($fh, $zipSpecialBuffer, \$bytes, 4);
       my $size = unpack("N", $bytes);
       readGeneric($fh, $zipSpecialBuffer, \$bytes, 20);
       readGeneric($fh, $zipSpecialBuffer, \$name, $size - 25);
       if( $name eq "" )
       {
         $name = parseFromFilenameAuto($filename);
       }
       printi18n($name, $filename, $filename, -1);
     }
   }
 
   close($fh) if defined $fh;
 
 }
 
 
 # add "memory" resources that are defined in Krita's code (KoResourceServerProvider)
 printi18n("0. Foreground to Background", "memory/gradients/Foreground to Background.svg", "memory/gradients/Foreground to Background.svg", -1);
 printi18n("1. Foreground to Transparent", "memory/gradients/Foreground to Transparent.svg", "memory/gradients/Foreground to Transparent.svg", -1);