#!@PERL@

# Get command line options
use Getopt::Long;
Getopt::Long::Configure("no_ignore_case", "pass_through");
GetOptions("m=s" => \$opt_m,         # Map file
           "t=s" => \$opt_t,         # Template directory
	   "f=s" => \$opt_f,         # Foomatic version
           "d=s" => \@opt_d);        # which Drivers?

# Wherever we put it...
my $mapfile;
# $mapfile = "../main/printers.xml";
$mapfile = $opt_m;

my $templatedir;
$templatedir = $opt_t;

my @drivertypes = ();
for my $d (@opt_d) {
    if (lc($d) eq "gs") {
	push (@drivertypes, "gs");
    }
    if (lc($d) eq "ijs") {
	push (@drivertypes, "ijs");
    }
    if (lc($d) eq "nogs") {
	@drivertypes = ("ijs");
    }
    if (lc($d) eq "noijs") {
	@drivertypes = ("gs");
    }
    if (lc($d) eq "all") {
	@drivertypes = ("gs", "ijs");
    }
    if (lc($d) eq "both") {
	@drivertypes = ("gs", "ijs");
    }
}

exit 0 if ($#drivertypes < 0); # Nothing to be done, exit silently

# Do we have Foomatic 2.9 or newer
my $foomatic3 = ((defined($opt_f)) && ($opt_f >= 2.9));

# The following substitutions happen to the template XML files:
# @@STPVER@@         - the version number (ie '4.1.5')
# @@DRVNAME@@        - driver name (ie gimp-print)
# @@STPRINTERS@@     - <printers>...</printers> clause for the driver
# @@OPTCONSTRAINTS@@ - <constraints>...</constraints> object for the option
# @@ENUMVALS@@       - <enum_vals>...</enum_vals> section for the enum option
# @@MINVAL@@         - minimum value for numeric setting
# @@MAXVAL@@         - maximum value for numeric setting
# @@DEFVAL@@         - default value for numeric setting

# For some things, there are option-specific root-around-n-writer
# functions.  So we have a dispatch table:
#
# function arguments are: ('StpDriverOptionName')

my $funcs = { 'InputSlot' => { 'OPTCONSTRAINTS' => \&build_cons,
			       'ENUMVALS' => \&build_ev, },
	      'InkType' => { 'OPTCONSTRAINTS' => \&build_cons,
			     'ENUMVALS' => \&build_ev },
	      'MediaType' => { 'OPTCONSTRAINTS' => \&build_cons,
			       'ENUMVALS' => \&build_ev },
	      'Model' => { 'OPTCONSTRAINTS' => \&build_model_cons,
			   'ENUMVALS' => \&build_model_ev },
	      'PageSize' => { 'OPTCONSTRAINTS' => \&build_cons,
			      'ENUMVALS' => \&build_ev },
	      'Quality' => { 'OPTCONSTRAINTS' => \&build_cons,
			     'ENUMVALS' => \&build_ev },
	      'Dither' => { 'OPTCONSTRAINTS' => \&build_cons,
			     'ENUMVALS' => \&build_ev },
	      'Color' => { 'OPTCONSTRAINTS' => \&build_cons,
			     'ENUMVALS' => \&build_ev },
	      'Resolution' => { 'OPTCONSTRAINTS' => \&build_resolution_cons,
				'ENUMVALS' => \&build_resolution_ev },
	      'PrintoutMode' => { 'OPTCONSTRAINTS' => 
				      \&build_printoutmode_cons,
				  'ENUMVALS' => 
				      \&build_printoutmode_ev },
	  };

my $drivervals = { 'PageSize' => \&optmap_pagesize,
		   'Color' => \&optmap_color
	       };

my $debug = 0;

# Foomatic name => Gimp-print name
%argnamemap = ('Quality' => 'Resolution');

$colormap = { 'gs' => { 'Grayscale' => '0',
			'Color' => '1',
			'BlackAndWhite' => '2' },
	      'ijs' => { 'Grayscale' => 'DeviceGray',
			 'Color' => 'DeviceRGB',
			 'BlackAndWhite' =>
			     'DeviceGray -dBitsPerSample=1',
			 'RawCMYK' => 'DeviceCMYK' }
	    };

use Data::Dumper;

open PIPE, "./printer_options|" or die "Cannot run printer_options: $!\n";
print STDERR "Loading options from ./printer_options...";
while(<PIPE>) {
    next if m!^#!;
    eval $_;
}
close PIPE or die "Cannot run printer_options: $!\n";
print STDERR "done.\n";

if ($foomatic3) {
    open PIPE, "./printer_margins|" or die "Cannot run printer_margins: $!\n";
    print STDERR "Loading margins from ./printer_margins...";
    $code = join('', <PIPE>);
    close PIPE or die "Cannot run printer_margins: $!\n";
    eval $code or die "Cannot run printer_margins: $!\n";
    print STDERR "done.\n";
}

open PIPE, "./stp_limits|" or die "Cannot run stp_limits: $!\n";
print STDERR "Loading options from ./stp_limits...";
while(<PIPE>) {
    next if m!^#!;
    eval $_;
}
close PIPE or die "Cannot run stp_limits: $!\n";
print STDERR "done.\n";

open PIPE, "./printers|" or die "Cannot run printers: $!\n";
print STDERR "Loading options from ./printers...";
while(<PIPE>) {
    next if m!^#!;
    eval $_;
}
close PIPE or die "Cannot run printers: $!\n";
print STDERR "done.\n";

# OK, now %stpdata is a big honking thing, and %defaults is in there, too.

# Invert, to build %bar{$optionname} = [ choice1, choice2 ];
my ($a, $otmp, $vtmp);
for $a (keys(%stpdata)) {
    for $otmp (keys %{$stpdata{$a}}) {
	for $vtmp (keys (%{$stpdata{$a}{$otmp}})) {
	    if (!$seen_evchoice{$otmp}{$vtmp}++) {
		push (@{$ev_choices{$otmp}}, [ $vtmp,
					       $stpdata{$a}{$otmp}{$vtmp}]);
	    }
	}
    }
}

if ($foomatic3) {
    # Generate data for "PrintoutMode" option, only needed for 
    # Foomatic 2.9.x or newer
    print STDERR "Generating data for \"PrintoutMode\" option...";
    ($printoutmode, $printoutmodechoices) = getprintoutmode();
    print STDERR "done.\n";
    # Foomatic >= 2.9: Make a list of all choice entries needed in the
    # "PrintoutMode" option XML file. Note: every choice ("Draft",
    # "Normal", ...) will appear several times, but with different
    # strings in "<ev_driverval>". Constraints will make only the
    # right choices getting into the PPD file. Assign a unique ID to
    # each entry.
    for $a (keys(%{$printoutmode})) {
	for $vtmp (keys %{$printoutmode->{$a}}) {
	    my $mode = $printoutmode->{$a}{$vtmp};
	    if (!$seen_modes{$vtmp}{$mode}++) {
		if (!defined($nums{$vtmp})) {
		    $nums{$vtmp} = 0;
		}
		$nums{$vtmp} ++;
		$modes{$vtmp}{$mode} = "$vtmp-$nums{$vtmp}";
	    }
	}
    }
}

# Step 1: construct a map from Model= values to Foomatic model id's
# this map is %mapstp.  The inverse from model to Model is %mapdb
#
# Foomatic is supposed to be a superset, so

open PRINTERS, $mapfile or die "Cannot open mapfile $mapfile: $!\n";
for (<PRINTERS>) {
    if (m!^#\s*gptofoo\s+([^\s]+)\s+([^\s]+)!) {
	push (@{$mapstp{$1}}, $2);
	$mapfoo{$2} = $1;	# do we need?
    }
}

$missing_drivers = 0;

# Are we missing any stp printers?
for (keys(%stpdata)) {
    if (!defined($mapstp{$_})) {
	$missing_drivers = 1;
	warn "No foomatic printer IDs for gimp-print printer $_.\n";
    }
}

for (keys(%mapstp)) {
    if (!defined($stpdata{$_})) {
	$missing_drivers = 1;
	warn "No gimp-print printer for foomatic ID $_.\n";
    }
}

if ($missing_drivers) {
   die "Cannot continue\n";
}

# Figure out version etc
open PIPE, "./gimp-print-version|" or die "Cannot run gimp-print-version: $!\n";
my $stpvers = <PIPE>;
close PIPE or die "Cannot run gimp-print-version: $!\n";
chomp $stpvers;

# Build <printers> clause...
my @printerlist = ();
push (@printerlist, " <printers>\n");
my $p1;
for $p1 (keys(%mapstp)) {
    push (@printerlist, "  <!-- gimp-print driver: $p1 -->\n");
    for my $id (@{$mapstp{$p1}}) {
	if ($foomatic3) {
	    # Add unprintable margins (only Foonmatic 2.9.x)
	    push(@printerlist, "  <printer>\n");
	    push(@printerlist, "    <id>$id</id>\n");
	    push(@printerlist, "    <margins>\n");
	    my ($cleft, $cright, $ctop, $cbottom) = 
		(undef, undef, undef, undef);
	    if (defined($imageableareas{$p1}{'Custom'})) {
		$cleft = $imageableareas{$p1}{'Custom'}{'left'};
		$cright = $imageableareas{$p1}{'Custom'}{'right'};
		$ctop = $imageableareas{$p1}{'Custom'}{'top'};
		$cbottom = $imageableareas{$p1}{'Custom'}{'bottom'};
		push(@printerlist, "      <general>\n");
		push(@printerlist, "        <relative />\n");
		push(@printerlist, "        <left>$cleft</left>\n");
		push(@printerlist, "        <right>$cright</right>\n");
		push(@printerlist, "        <top>$ctop</top>\n");
		push(@printerlist, "        <bottom>$cbottom</bottom>\n");
		push(@printerlist, "      </general>\n");
	    }
	    for my $ps (keys %{$imageableareas{$p1}}) {
		next if $ps eq 'Custom'; # We have done "Custom" already
		my ($left, $right, $top, $bottom, $width, $height);
		$left = $imageableareas{$p1}{$ps}{'left'};
		$right = $imageableareas{$p1}{$ps}{'right'};
		$top = $imageableareas{$p1}{$ps}{'top'};
		$bottom = $imageableareas{$p1}{$ps}{'bottom'};
		$width = $imageableareas{$p1}{$ps}{'width'};
		$height = $imageableareas{$p1}{$ps}{'height'};
		# If the <general> section serves for this paper size,
		# do not define an <exception>
		next if ((defined($cleft)) &&
			 ($left == $cleft) &&
			 ($right == $width - $cright) &&
			 ($top == $height - $ctop) &&
			 ($bottom == $cbottom));
		push(@printerlist, "      <exception PageSize=\"$ps\">\n");
		push(@printerlist, "        <absolute />\n");
		if ($left != $cleft) {
		    push(@printerlist, "        <left>$left</left>\n");
		}
		if ($right != $width - $cright) {
		    push(@printerlist, "        <right>$right</right>\n");
		}
		if ($top != $height - $ctop) {
		    push(@printerlist, "        <top>$top</top>\n");
		}
		if ($bottom != $cbottom) {
		    push(@printerlist, "        <bottom>$bottom" .
			 "</bottom>\n");
		}
		push(@printerlist, "      </exception>\n");
	    }
	    push(@printerlist, "    </margins>\n");
	    push(@printerlist, "  </printer>\n");
	} else {
	    # Printer IDs only
	    push(@printerlist, "  <printer><id>$id</id></printer>\n");
	}
    }
}
push (@printerlist, " </printers>\n");

$drivernameprefix = "gimp-print";
print STDERR "Using driver name prefix \"$drivernameprefix\"\n";

my $generalsubs = { 'STPVER' => $stpvers,
		    'DRVNAME' => $drivernameprefix,
		    'STPRINTERS' => join('', @printerlist) };

my $optiongroups = { 'PageSize' => 'General',
		     'InputSlot' => 'General',
		     'MediaType' => 'General',
		     'InkType' => 'General',
		     'PrintoutMode' => 'General',
		     'Resolution' => 'PrintoutMode',
		     'Quality' => 'PrintoutMode',
		     'Color' => 'PrintoutMode',
		     'ImageType' => 'PrintoutMode',
		     'Dither' => 'PrintoutMode',
		     'Gamma' => 'Adjustment',
		     'Density' => 'Adjustment',
		     'Brightness' => 'Adjustment',
		     'Contrast' => 'Adjustment',
		     'Saturation' => 'Adjustment',
		     'Cyan' => 'Adjustment',
		     'Magenta' => 'Adjustment',
		     'Yellow' => 'Adjustment' };

my @numericsubs = ('MINVAL', 'MAXVAL', 'DEFVAL');

# OK, make the db directory...
mkdir "foomatic-db", 0755 or
    die "Cannot create directory foomatic-db: $!\n"
     	unless -d "foomatic-db";

# Now do stuff, already.  Do the substitution into each file...
my $tmpl;
for $drivertype (@drivertypes) {
    $drivertypesuffix = "-$drivertype";
    $drivertypesuffix =~ s/-gs//;
    my $drvname = "$drivernameprefix$drivertypesuffix";
    $generalsubs->{'DRVNAME'} = $drvname;
    print "Generating Foomatic data for driver \"$drvname\"...\n";

    # OK, make the db heirarchy alongside the templates one...
    mkdir "foomatic-db/$drvname", 0755 or
	die "Cannot create directory foomatic-db/$drvname: $!\n"
     	    unless -d "foomatic-db/$drvname";
    mkdir "foomatic-db/$drvname/opt", 0755 or 
	die "Cannot create directory foomatic-db/$drvname/opt: $!\n"
	    unless -d "foomatic-db/$drvname/opt";
    mkdir "foomatic-db/$drvname/driver", 0755 or
	die "Cannot create directory foomatic-db/$drvname/driver: $!\n"
	    unless -d 'foomatic-db/$drvname/driver';

    opendir TDIR, "$templatedir-$drivertype" or
	die "Cannot open templates directory: $!\n";

    while ($tmpl=readdir(TDIR)) {

	# Only XML files
	next if ($tmpl !~ m!.+\.xml$!);
	# The "PrintoutMode" option is only supported by Foomatic 2.9.x or
	# newer
	next if ((!$foomatic3) && ($tmpl eq "PrintoutMode.xml"));

	my $fooopt = $tmpl;
	$fooopt =~ s!\.xml$!!;
	my $stpopt = $argnamemap{$fooopt};
	$stpopt = $fooopt if ! defined ($stpopt);

#	print STDERR "Argnamemap '$fooopt' => '$stpopt'\n";

	open TMPL, "$templatedir-$drivertype/$tmpl";
	my @datafile = <TMPL>;
	close TMPL;

	print STDERR "Processing $tmpl...";

	my $template = join('',@datafile);

	# First, do the generic substitutions.

	my ($substr);
	for $substr (keys(%$generalsubs)) {
	    my $substitution = $generalsubs->{$substr};
	    $template =~ s!\@\@$substr\@\@!$substitution!g;
	}

	# Put the options into PPD groups (Foomatic >= 2.9)

	if ($foomatic3) {
	    my $substitution = "\n   <arg_group>" . 
		$optiongroups->{$fooopt} . "</arg_group>";
	    $template =~ s!\@\@GROUP\@\@!$substitution!g;
	} else {
	    $template =~ s!\@\@GROUP\@\@!!g;
	}

	# Now do the numeric substitutions

	for $substr (@numericsubs) {
	    my $substitution = $stp_values{$substr}{$stpopt};
	    $template =~ s!\@\@$substr\@\@!$substitution!g;
	}

	# Now do special-purpose substitutions

	for $substr (keys(%{$funcs->{$fooopt}})) {
	    my $substitution = &{$funcs->{$fooopt}{$substr}}($stpopt);
	    if (defined($substitution)) {
		$template =~ s!\@\@$substr\@\@!$substitution!g;
	    }
	}

	# Any more?
	grep (m!\@\@([^\@]+)\@\@!g
	      && do { warn "  Unknown substitution $1 in $tmpl!\n"; },
	      split("\n",$template));

	# Finally, write out the new file

	# Options are under opt/
	my $dbfilename = lc("foomatic-db/$drvname/opt/$drvname-$tmpl");

	# Special case the actual driver file under driver/
	$dbfilename = "foomatic-db/$drvname/driver/$drvname.xml"
	    if ($tmpl eq 'gimp-print.xml');

	open NEWF, "> $dbfilename" or die "Cannot create $dbfilename: $!";
	print STDERR "writing $dbfilename...";
	print NEWF $template;
	print STDERR "done.\n";
	close NEWF;

    }

    closedir TDIR;

    # The paper size and resolution maps must be regenerated for the next
    # driver, because the "driverval"s are different for the different 
    # drivers. So delete the caches.
    undef $pagemap;
    undef %rescache;

}

sub get_ev_shortname {
    my ($val) = @_;
    $val =~ s/ //g;
    $val =~ s/\///g;
    $val =~ s/\://g;
    return $val;
}

sub get_ev_key {
    my ($val, $drv) = @_;
    return ("ev/$drv-" . get_ev_shortname($val));
}

sub build_ev {
    my ($stpopt) = @_;
    my $drvname = "$drivernameprefix$drivertypesuffix";

    my @vals = ();

    # OK, now for each enum_val
    my $ev;
    for $ev (@{$ev_choices{$stpopt}}) {
	#  Put in the basic choice info: ev names, etc
	my $ev_longname = @$ev[1];
	my $ev_shortname = @$ev[0];

	# The GhostScript driver has no "RawCMYK" output type setting
	next if (($drivertype eq "gs") && ($stpopt eq "Color") &&
		 ($ev_shortname eq "RawCMYK"));

	my $ev_id = get_ev_key($ev_shortname, $drvname);
	my $ev_driverval;

	# Either call a per-option function to get the driverval, or
	# just use the string choice name.
	if (defined($drivervals->{$stpopt})) {
	    $ev_driverval = &{$drivervals->{$stpopt}}($ev_shortname);
	    die "Undefined driverval for option $stpopt value $ev_shortname!\n"
		if (! defined($ev));
	} else {
	    $ev_driverval = $ev_shortname;
	}
	# Remove "Roll" paper sizes, user has to use "Custom" instead.
	next if (($stpopt eq "PageSize") && ($ev_driverval eq ""));
	push (@vals,
	      "    <enum_val id='$ev_id'>\n",
	      "      <ev_longname><en>$ev_longname</en></ev_longname>\n",
	      "      <ev_shortname><en>$ev_shortname</en></ev_shortname>\n",
	      "      <ev_driverval>$ev_driverval</ev_driverval>\n",
	      "      <constraints>\n",
	      "        <!-- Assume the option doesn't apply... -->\n",
	      "        <constraint sense='false'>\n",
	      "          <driver>$drvname</driver>\n",
	      "        </constraint>\n");

	#   Build constraints for this particular choice
	my $stpprn;
	for $stpprn (keys(%stpdata)) {
	    my $fooprn;
	    for $fooprn (@{$mapstp{$stpprn}}) {
		if ($stpdata{$stpprn}{$stpopt}{$ev_shortname}) {
		    # OK, this choice applies to this printer
		    push (@vals,
			  "        <constraint sense='true'>\n",
			  "          <!-- $fooprn == $stpprn -->\n",
			  "          <driver>$drvname</driver>\n",
			  "          <printer>$fooprn</printer>\n",
			  "        </constraint>\n");
		}
	    }
	}

	push (@vals,
	      "      </constraints>\n",
	      "    </enum_val>\n");
    }

    return join('',
		"<enum_vals>\n",
		@vals,
		"  </enum_vals>\n");
}

sub build_cons {

    my ($stpopt) = @_;

    my $drvname = "$drivernameprefix$drivertypesuffix";

    my @PNCONS = ();

    # For each stp printer...
    my $stpname;
    for $stpname (keys(%stpdata)) {

	if (0) {
	    print STDERR "    Processing gimp-print printer $stpname...\n";
	    print STDERR
		"      There are no foomatic printers mapped to $stpname!?\n"
		    if !$mapstp{$stpname};
	    print STDERR "      \%stpdata key is {$stpname}{$stpopt}\n";
	}

	# Add to this printer to argument constraints?
	if ($stpdata{$stpname}{$stpopt}) {

	    # What's the default value?
	    my $stpdef = $defaults{$stpname}{$stpopt};

	    # If there's no default, then this option doesn't apply to
	    # this printer.
	    if (defined($stpdef)) {

		my $foodefval = get_ev_key($stpdef, $drvname);

		if (0) {
		    print STDERR
			"      Default for $stpname/$stpopt is $stpdef aka $foodefval\n";
		}

		my $fooname;
		for $fooname (@{$mapstp{$stpname}}) {

		    if (0) {
			print STDERR
			    "      Printer $fooname takes option $stpopt.\n";
		    }

		    push (@PNCONS,
			  "    <constraint sense='true'>\n",
			  "      <driver>$drvname</driver>\n",
			  "      <printer>$fooname</printer><!-- gimp-print name: $stpname -->\n",
			  "      <arg_defval>$foodefval</arg_defval>\n",
			  "    </constraint>\n");
		}
	    }
	}

    }

    return join('',
		"<constraints>\n",
		@PNCONS,
		"  </constraints>\n");
}

sub optmap_pagesize {
    my ($value) = @_;

    if (!defined $pagemap) {
	open PUTIL, "./paper_sizes |" or die "Cannot run paper_sizes: $!\n";
	while (<PUTIL>) {
	    chomp;
	    $_ =~ m!^\s*(.+\S)\s+([0-9]+)\s+([0-9]+)\s*$!;
	    my ($name, $width, $height) = ($1, $2, $3);
	    if (($width > 0 and $height > 0) or
		($name eq "Custom")) {
		if ($drivertype eq "gs") {
		    $pagemap->{$name} = "$width $height";
		} else {
		    $pagemap->{$name} = "-dDEVICEWIDTHPOINTS=$width -dDEVICEHEIGHTPOINTS=$height";
		}
#		print STDERR "PageSize '$name' driverval '$width $height'\n";
	    }	
	}
	close PUTIL;
    }

    return $pagemap->{$value}
}

sub optmap_color {
    my ($value) = @_;
    if (defined $colormap->{$drivertype}{$value}) {
	return $colormap->{$drivertype}{$value};
    } else {
	die "Cannot map output type '$value'\n";
    }
}

sub build_model_cons {
    my ($stpopt) = @_;
    my $drvname = "$drivernameprefix$drivertypesuffix";


    # OK, this is funky.  For each stp model, we have a choice.  That
    # choice is valid for only the foo printers that correspond.  For
    # any given foo printer, there is *exactly one* available choice.
    # The defval is the one available choice.  Backends and
    # applications do not show options with only one choice; they just
    # select that choice.  So we don't bother to make pretty option
    # names or anything.
    #
    # See also build_model_ev()

    my @PNCONS = ();

    # For each stp printer...
    my $stpname;
    for $stpname (keys(%mapstp)) {

	# For each possible foo name
	my $fooname;
	for $fooname (@{$mapstp{$stpname}}) {

	    # What's the default value?
	    my $foodefval = get_ev_key($stpname, $drvname);

	    push (@PNCONS,
		  "    <constraint sense='true'>\n",
		  "      <driver>$drvname</driver>\n",
		  "      <printer>$fooname</printer>\n",
		  "      <arg_defval>$foodefval</arg_defval>\n",
		  "    </constraint>\n");
	}
    }

    return join('',
		"<constraints>\n",
		@PNCONS,
		"  </constraints>\n");


}

# See build_model_cons, above.
sub build_model_ev {
    my ($stpopt) = @_;
    my $drvname = "$drivernameprefix$drivertypesuffix";

    my @vals = ();

    # OK, now for each enum_val
    my $ev;
    for $ev (keys(%mapstp)) {
	#  Put in the basic choice info: ev names, etc
	my $ev_shortname = $ev;
	my $ev_longname = $printer_name{$ev};
	my $ev_shortname = get_ev_shortname($ev);
	my $ev_id = get_ev_key($ev, $drvname);
	my $ev_driverval;
	if ($drivertype eq "gs") {
	    $ev_driverval = $ev;
	} else {
	    my $make;
	    if ($ev =~ /^escp2/) {
		$make = "EPSON";
	    } elsif ($ev =~ /^bjc/) {
		$make = "CANON";
	    } elsif ($ev =~ /^pcl/) {
		$make = "HEWLETT-PACKARD";
	    } elsif ($ev =~ /^lexmark/) {
		$make = "LEXMARK";
	    } else {
		die "Could not determine printer manufacturer from \"$ev\"!\n";
	    }
	    $ev_driverval = "-sDeviceManufacturer=$make -sDeviceModel=$ev";
	}
	push (@vals,
	      "    <enum_val id='$ev_id'>\n",
	      "      <ev_longname><en>$ev_longname</en></ev_longname>\n",
	      "      <ev_shortname><en>$ev_shortname</en></ev_shortname>\n",
	      "      <ev_driverval>$ev_driverval</ev_driverval>\n",
	      "      <constraints>\n",
	      "        <!-- Assume the option doesn't apply... -->\n",
	      "        <constraint sense='false'>\n",
	      "          <driver>$drvname</driver>\n",
	      "        </constraint>\n",
	      "        <!-- ...except to these: -->\n",
	      );

	# This stp Model value applies only to mapped foo printers
	my $fooprn;
	for $fooprn (@{$mapstp{$ev}}) {

	    # OK, this choice applies to this enum
	    push (@vals,
		  "        <constraint sense='true'>\n",
		  "          <!-- Model $ev for $fooprn -->\n",
		  "          <driver>$drvname</driver>\n",
		  "          <printer>$fooprn</printer>\n",
		  "        </constraint>\n");
	}

	push (@vals,
	      "      </constraints>\n",
	      "    </enum_val>\n");
    }

    return join('',
		"<enum_vals>\n",
		@vals,
		"  </enum_vals>\n");
}


# Stuff for Resolution.
#
# printer_options gives us Quality information.  We examine this to
# determine what to do for the gs resolution argument:
#
#  - Is this a 180/360/720 printer or a 150/300/600 printer?
#
#  - What are the legal resolutions?  Sort of parse and compute these
#    from the Resolution values.
#
# In the case of the GhostScript driver The driverval is "X Y", and gets
# passed in a /HWResolution ps clause, for the IJS driver it is "XxY" and
# gets passed via the "-r" command line option of GhostScript.

sub compute_resolutions {
    my ($stpname) = @_;

    my $drvname = "$drivernameprefix$drivertypesuffix";

    if (!defined($rescache{$stpname})) {

	my @reslist = ();
	my %hash;
	my $defval;

	my $qual;
	for $qual (keys(%{$stpdata{$stpname}{'Resolution'}})) {
	    $qual =~ m!(\d+)\s*(x\s*(\d+))?!;
	    my ($x, $y) = ($1, $3);
	    $y = $x if !defined($y);

	    my $r;
	    if ($drivertype eq "gs") {
		$r = {'x' => $x,
		      'y' => $y,
		      'driverval' => "$x $y",
		      'ev_key' => get_ev_key("res-$x-$y", $drvname)
		      };
	    } else {
		$r = {'x' => $x,
		      'y' => $y,
		      'driverval' => "${x}x${y}",
		      'ev_key' => get_ev_key("res-$x-$y", $drvname)
		      };
	    }
	    push (@reslist, $r);

	    # Default?
	    $defval = get_ev_key("res-$x-$y", $drvname)
		if ($qual eq $defaults{$stpname}{'Resolution'});

	    # Note that this resolution value exists
	    $resolutions{"$x $y"} = { 'x' => $x,
				      'y' => $y };

	    # Note that this printer takes this resolution
	    $hash{$x}{$y} = 1;

	}

	$rescache{$stpname}{'list'} = \@reslist;
	$rescache{$stpname}{'defval'} = $defval;
	$rescache{$stpname}{'takesit'} = \%hash;
    }

    return $rescache{$stpname};
}

sub do_all_res {
    my $n;
    for $n (keys(%mapstp)) {
	compute_resolutions($n);
    }
}

sub build_resolution_ev {
    my ($stpopt) = @_;
    my $drvname = "$drivernameprefix$drivertypesuffix";

    my @vals = ();

    do_all_res();

    # OK, now for each possible resolution...
    my $ev;
    for $ev (keys(%resolutions)) {

	my ($x, $y) = ($resolutions{$ev}{'x'}, $resolutions{$ev}{'y'});

	#  Put in the basic choice info: ev names, etc
	my $ev_longname = "$x x $y DPI";
	my $ev_shortname = get_ev_shortname($ev_longname);
	my $ev_id = get_ev_key("res-$x-$y", $drvname);
	my $ev_driverval;
	if ($drivertype eq "gs") {
	    $ev_driverval = "$x $y";
	} else {
	    $ev_driverval = "${x}x${y}";
	}

	push (@vals,
	      "    <enum_val id='$ev_id'>\n",
	      "      <ev_longname><en>$ev_longname</en></ev_longname>\n",
	      "      <ev_shortname><en>$ev_shortname</en></ev_shortname>\n",
	      "      <ev_driverval>$ev_driverval</ev_driverval>\n",
	      "      <constraints>\n",
	      "        <!-- Assume the option doesn't apply... -->\n",
	      "        <constraint sense='false'>\n",
	      "          <driver>$drvname</driver>\n",
	      "        </constraint>\n",
	      "        <!-- ...except to these: -->\n",
	      );

	# Now, for each printer, put in a constraint if this
	# resolution makes sense or not...
	my $stpprn;
	for $stpprn (keys(%mapstp)) {

	    my $resobj = compute_resolutions($stpprn);
	    my $takesit = $resobj->{'takesit'}{$x}{$y};

	    if ($takesit) {
		my $fooprn;
		for $fooprn (@{$mapstp{$stpprn}}) {

#		    print STDERR "Printer $fooprn $stpprn uses ${x}x$y\n";

		    # OK, this choice applies to this enum
		    push (@vals,
			  "        <constraint sense='true'>\n",
			  "          <driver>$drvname</driver>\n",
			  "          <printer>$fooprn</printer><!-- stpname: $stpprn -->\n",
			  "        </constraint>\n");
		}
	    }

	}

	push (@vals,
	      "      </constraints>\n",
	      "    </enum_val>\n");
    }

    return join('',
		"<enum_vals>\n",
		@vals,
		"  </enum_vals>\n");
}

sub build_resolution_cons {
    my ($stpopt) = @_;
    my $drvname = "$drivernameprefix$drivertypesuffix";

    my @PNCONS = ();

    # For each stp printer...
    my $stpname;
    for $stpname (keys(%mapstp)) {

	# Get some resolution info
	my $r = compute_resolutions($stpname);

	# For each possible foo name
	my $fooname;
	for $fooname (@{$mapstp{$stpname}}) {

	    # What's the default value?
	    my $foodefval = $r->{'defval'};

	    push (@PNCONS,
		  "    <constraint sense='true'>\n",
		  "      <driver>$drvname</driver>\n",
		  "      <printer>$fooname</printer><!-- stpname: $stpname -->\n",
		  "      <arg_defval>$foodefval</arg_defval>\n",
		  "    </constraint>\n");
	}
    }

    return join('',
		"<constraints>\n",
		@PNCONS,
		"  </constraints>\n");
}

sub build_printoutmode_ev {
    my ($stpopt) = @_;
    my $drvname = "$drivernameprefix$drivertypesuffix";

    my @vals = ();

    # OK, now for each choice ("Draft", "Normal", ...) ...
    my $choice;
    for $choice (keys %modes) {
	# ... and each possible "<ev_driverval>" for it
	my $ev_driverval;
	for $ev_driverval (keys %{$modes{$choice}}) {
	    #  Put in the basic choice info: ev names, etc
	    my $ev_longname = $printoutmodechoices->{$choice};
	    my $ev_shortname = $choice;

	    my $ev_id = 
		get_ev_key($modes{$choice}{$ev_driverval}, $drvname);

	    push (@vals,
		  "    <enum_val id='$ev_id'>\n",
		  "      <ev_longname><en>$ev_longname</en></ev_longname>\n",
		  "      <ev_shortname><en>$ev_shortname</en></ev_shortname>\n",
		  "      <ev_driverval>$ev_driverval</ev_driverval>\n",
		  "      <constraints>\n",
		  "        <!-- Assume the option doesn't apply... -->\n",
		  "        <constraint sense='false'>\n",
		  "          <driver>$drvname</driver>\n",
		  "        </constraint>\n");

	    #   Build constraints for this particular ev_driverval
	    my $stpprn;
	    for $stpprn (keys(%stpdata)) {
		my $fooprn;
		for $fooprn (@{$mapstp{$stpprn}}) {
		    if ($printoutmode->{$stpprn}{$choice} eq 
			$ev_driverval) {
			# OK, this choice applies to this printer
			push (@vals,
			      "        <constraint sense='true'>\n",
			      "          <!-- $fooprn == $stpprn -->\n",
			      "          <driver>$drvname</driver>\n",
			      "          <printer>$fooprn</printer>\n",
			      "        </constraint>\n");
		    }
		}
	    }

	    push (@vals,
		  "      </constraints>\n",
		  "    </enum_val>\n");
	}
    }

    return join('',
		"<enum_vals>\n",
		@vals,
		"  </enum_vals>\n");
}

sub build_printoutmode_cons {
    my ($stpopt) = @_;
    my $drvname = "$drivernameprefix$drivertypesuffix";

    my @PNCONS = ();

    # For each stp printer...
    my $stpname;
    for $stpname (keys(%mapstp)) {

	# For each possible foo name
	my $fooname;
	for $fooname (@{$mapstp{$stpname}}) {

	    # What's the default value (always the "Normal" mode)?
	    my $normalmode = $printoutmode->{$stpname}{'Normal'};
	    my $foodefval = get_ev_key($modes{'Normal'}{$normalmode}, 
				       $drvname);

	    push (@PNCONS,
		  "    <constraint sense='true'>\n",
		  "      <driver>$drvname</driver>\n",
		  "      <printer>$fooname</printer>\n",
		  "      <arg_defval>$foodefval</arg_defval>\n",
		  "    </constraint>\n");
	}
    }

    return join('',
		"<constraints>\n",
		@PNCONS,
		"  </constraints>\n");
}

sub qualityorder {
    # List of suffixes of the Quality choices
    my @suffixes = (
		    # General
		    "",
		    "dpi",
		    # Epson/Lexmark
		    "mw",
		    "mw2",
		    "sw",
		    "fol",
		    "fol2",
		    "fourp",
		    "uni",
		    "mwuni",
		    "mw2uni",
		    "swuni",
		    "foluni",
		    "fol2uni",
		    "fourpuni",
		    "hq",
		    "hquni",
		    "hq2",
		    "hq2uni",
		    # Canon
		    "dmt",
		    # HP
		    "mono",
		    );
    my ($a, $b) = @_;
    # Bring the suffixes to lower case
    my $first = lc($a);
    my $second = lc($b);
    # Check whether they are in the @suffixes list
    my $i;
    for ($i = 0; $i <= $#suffixes; $i++) {
	my $firstinlist = ($first eq $suffixes[$i]);
	my $secondinlist = ($second eq $suffixes[$i]);
	if (($firstinlist) && (!$secondinlist)) {return -1};
	if (($secondinlist) && (!$firstinlist)) {return 1};
	if (($firstinlist) && ($secondinlist)) {return 0};
    }

    # Equal quality
    die "The quality choice suffixes $a and $b are unknown!\n";
    return 0;

}

sub getprintoutmode {
    my $choicelongnames = {
	'Draft' => 'Draft (Economy)',
	'Draft.Gray' => 'Draft Grayscale (Economy)',
	'Normal' => 'Normal',
	'Normal.Gray' => 'Normal Grayscale',
	'High' => 'High Quality',
	'High.Gray' => 'High Quality Grayscale',
	'VeryHigh' => 'Very High Quality',
	'VeryHigh.Gray' => 'Very High Quality Grayscale',
	'Photo' => 'Photo',
	'Photo.Gray' => 'Photo Grayscale',
    };

    ### BASIC RULES

    # See mode-specific rules below

    # There must be always a "Normal" mode, this will be the default.

    # On black-and-white printers there are no modes with ".Gray"
    # specifier, the standard modes are already grayscale.

    # No "Photo" mode on laser printers.

    # If on a PCL printer "600mono" is the chose quality, it will be
    # replaced by "300dpi" in color mode (This can lead to a mode being
    # removed by the following two rules).

    # If "VeryHigh" has exactly the same settings as "High", "VeryHigh"
    # is left out.

    # If "High" has exactly the same settings as "Normal", "High"
    # is left out.

    # If nothing is found for a certain mode, this mode is left out.

    my $modes = {};
    # Treat all printers
    my $stpprn;
    for $stpprn (keys(%stpdata)) {
	my $modeinfo = {};
	my ($draftminres, $draftbestsymmetry, $draftlowestqualstr) = 
	    (99999999, 99999999, "xxx");
	my $normaldefaultqual = $defaults{$stpprn}{'Resolution'};
	my ($highmaxres, $highbestsymmetry, $highbestqualstr) = 
	    (0, 99999999, "");
	my ($veryhighmaxres, $veryhighbestsymmetry, $veryhighbestqualstr) = 
	    (0, 99999999, "");
	my ($photomaxres, $photobestsymmetry, $photobestqualstr) = 
	    (0, 99999999, "");
	# Go through all choices of the "Quality" option and find the
	# best values for the "PrintoutMode" option
	my $quality;
	for $quality (keys(%{$stpdata{$stpprn}{'Resolution'}})) {
	    my ($xres, $yres, $qualstr);
	    if ($quality =~ /^(\d+)x(\d+)(\D.*)$/) {
		$xres = $1;
		$yres = $2;
		$qualstr = $3;
	    } elsif ($quality =~ /^(\d+)(\D.*)$/) {
		$xres = $1;
		$yres = $1;
		$qualstr = $2;
	    } else {
		die "Invalid quality: $quality\n";
	    }
	    # Resolution in dots per square inch
	    my $respersquareinch = $xres * $yres;
	    # Symmetry: Shows how far from symmetric a resolution is,
	    # the smaller, the more symmetric, symmetric resolutions (as
	    # 300x300 dpi) give zero.
	    my $symmetry = abs(log($yres/$xres));

	    ### Mode: DRAFT

	    # Use always the lowest available resolution/quality, 
	    # preferrably symmetric resolutions,

	    # Do not use resolutions with less than 150 dpi in both
	    # demensions.

	    # VeryFast dithering, ImageType LineArt

	    if (($respersquareinch < $draftminres) ||
		(($respersquareinch == $draftminres) && 
		 ($symmetry < $draftbestsymmetry)) ||
		(($respersquareinch == $draftminres) &&
		 ($symmetry == $draftbestsymmetry) &&
		 (qualityorder($qualstr, $draftlowestqualstr) < 0))) {
		$draftbestsymmetry = $symmetry;
		$draftminres = $respersquareinch;
		$draftlowestqualstr = $qualstr;
		next if (($xres < 150) && # Resolution not lower than
			 ($yres < 150));  # 150x150, 360x120 allowed
		$modeinfo->{'Draft'} = {
		    'quality' => $quality,
		    'xres' => $xres,
		    'yres' => $yres,
		    'dither' => 'VeryFast',
		    'image' => 'LineArt'
		}
	    }

	    ### Mode: NORMAL

	    # Default resolution/quality of GIMP-Print, upgrade to 
	    # unidirectional if possible, use 600x600 dpi for
	    # Lexmark Z..

	    # Adaptive Hybrid dithering, ImageType Photographs

	    if ((($stpprn =~ /^lexmark\-z/) &&
		 ($xres == 600) && ($yres == 600) && ($qualstr eq "uni")) ||
		(($stpprn !~ /^lexmark\-z/) &&
		 (($quality eq "${normaldefaultqual}uni") ||
		  (($quality eq $normaldefaultqual) &&
		   (!defined($normal->{'quality'})))))) {
		$modeinfo->{'Normal'} = {
		    'quality' => $quality,
		    'xres' => $xres,
		    'yres' => $yres,
		    'dither' => 'Adaptive',
		    'image' => 'Photographs'
		}
	    }

	    ### Mode: HIGH

	    # High: The highest resolution which is not higher than
	    # 720x720 dpi (Lexmark Z..: 1200x1200 dpi),
	    # unidirectional if possible, 
	    # not "fol", "fourp", "hq", "hq2"

	    # Adaptive Hybrid dithering, ImageType Photographs

	    if (($respersquareinch > $highmaxres) ||
		(($respersquareinch == $highmaxres) && 
		 ($symmetry < $highbestsymmetry)) ||
		(($respersquareinch == $highmaxres) &&
		 ($symmetry == $highbestsymmetry) &&
		 (qualityorder($qualstr, $highbestqualstr) > 0))) {
		unless ((($stpprn !~ /^lexmark\-z/) && 
			 (($xres > 720) || # Resolution not higher than
			  ($yres > 720))) || # 720x720 for non Lexmark
			($xres > 1200) || # not bigger than 1200x1200
			($yres > 1200) || # in general
			($qualstr =~ /^(hq.*|fo.*)$/)) { # Not "hq", "hq2",
		                                         # "fol", "fourp"
		    $highbestsymmetry = $symmetry;
		    $highmaxres = $respersquareinch;
		    $highbestqualstr = $qualstr;
		    $modeinfo->{'High'} = {
			'quality' => $quality,
			'xres' => $xres,
			'yres' => $yres,
			'dither' => 'Adaptive',
			'image' => 'Photographs'
		    }
		}
	    }

	    ### Mode: VERY HIGH

	    # Use always the highest available resolution/quality, 
	    # preferrably symmetric resolutions,

	    # On Epsons: Maximum 1440x720, not "hq2".

	    # Adaptive Hybrid dithering, ImageType Photographs

	    if (($respersquareinch > $veryhighmaxres) ||
		(($respersquareinch == $veryhighmaxres) && 
		 ($symmetry < $veryhighbestsymmetry)) ||
		(($respersquareinch == $veryhighmaxres) &&
		 ($symmetry == $veryhighbestsymmetry) &&
		 (qualityorder($qualstr, $veryhighbestqualstr) > 0))) {
		unless (($stpprn =~ /^escp2/) && # Epson
			(($xres > 1440) || # Resolution not higher than
			 ($yres > 720) ||  # 1440x720
			 ($qualstr eq "hq2"))) {  # Not "hq2"
		    $veryhighbestsymmetry = $symmetry;
		    $veryhighmaxres = $respersquareinch;
		    $veryhighbestqualstr = $qualstr;
		    $modeinfo->{'VeryHigh'} = {
			'quality' => $quality,
			'xres' => $xres,
			'yres' => $yres,
			'dither' => 'Adaptive',
			'image' => 'Photographs'
		    }
		}
	    }

	    ### Mode: PHOTO

	    # Use always the highest available resolution/quality, 
	    # preferrably symmetric resolutions,

	    # On Epsons: Maximum 2880x720

	    # EvenTone dithering, ImageType Photographs

	    if (($respersquareinch > $photomaxres) ||
		(($respersquareinch == $photomaxres) && 
		 ($symmetry < $photobestsymmetry)) ||
		(($respersquareinch == $photomaxres) &&
		 ($symmetry == $photobestsymmetry) &&
		 (qualityorder($qualstr, $photobestqualstr) > 0))) {
		unless (($stpprn =~ /^escp2/) && # Epson
			(($xres > 2880) || # Resolution not higher than
			 ($yres > 720))) {  # 2880x720
		    $photobestsymmetry = $symmetry;
		    $photomaxres = $respersquareinch;
		    $photobestqualstr = $qualstr;
		    $modeinfo->{'Photo'} = {
			'quality' => $quality,
			'xres' => $xres,
			'yres' => $yres,
			'dither' => 'EvenTone',
			'image' => 'Photographs'
		    }
		}
	    }
	}

	# We must have a "Normal" mode for every printer.
	if (!defined($modeinfo->{'Normal'}{'quality'})) {
	    die "No 'Normal' mode for $stpprn!\n";
	}

	# Build the strings with the settings for the "PrintoutMode"
	# option
	for my $m (keys(%{$modeinfo})) {
	    # If we didn't find anything for a certain mode, skip this
	    # mode
	    next if (!defined($modeinfo->{$m}{'quality'}));
	    my $modestr =
		"GSResolution=$modeinfo->{$m}{'xres'}x" .
		"$modeinfo->{$m}{'yres'}DPI " .
		"Quality=$modeinfo->{$m}{'quality'} " .
		"Dither=$modeinfo->{$m}{'dither'} " .
		"ImageType=$modeinfo->{$m}{'image'}";
	    if (defined($stpdata{$stpprn}{'Color'}{'Color'})) { 
		# Color printer
		$modes->{$stpprn}{$m} = $modestr . " OutputType=Color";
		$modes->{$stpprn}{"$m.Gray"} = 
		    $modestr . " OutputType=Grayscale";
		# Some HP inkjets have a "600mono" quality mode which
		# is only available in Grayscale, replace this mode by
		# "300dpi" in the settings for color printing
		if ($modes->{$stpprn}{$m} =~ /600mono/) {
		    if(!defined($stpdata{$stpprn}{'Resolution'}{'300dpi'})){
			die "No '300dpi' mode for $stpprn!";
		    }
		    $modes->{$stpprn}{$m} =~ s/600x600DPI/300x300DPI/;
		    $modes->{$stpprn}{$m} =~ s/600mono/300dpi/;
		}
	    } else {
		# bw printer
		if ($stpprn =~ /^pcl\-[2-6][vls]?i?$/) { # Laser printer
		    # No 'Photo' mode on laser printers
		    next if ($m eq 'Photo');
		    # Always "VeryFast" dithering on laser printers
		    $modestr =~ s/(Dither=)\S+/$1VeryFast/;
		}
		$modes->{$stpprn}{$m} = $modestr . " OutputType=Grayscale";
	    }
	}
	# Remove 'VeryHigh' and 'High' if they are identical to lower
	# quality modes
	if ($modes->{$stpprn}{'VeryHigh'} eq 
	    $modes->{$stpprn}{'High'}) {
	    delete($modes->{$stpprn}{'VeryHigh'});
	}
	if ($modes->{$stpprn}{'High'} eq 
	    $modes->{$stpprn}{'Normal'}) {
	    delete($modes->{$stpprn}{'High'});
	}
	if (defined($stpdata{$stpprn}{'Color'}{'Color'})) { 
	    # Color printer
	    if ($modes->{$stpprn}{'VeryHigh.Gray'} eq 
		$modes->{$stpprn}{'High.Gray'}) {
		delete($modes->{$stpprn}{'VeryHigh.Gray'});
	    }
	    if ($modes->{$stpprn}{'High.Gray'} eq 
		$modes->{$stpprn}{'Normal.Gray'}) {
		delete($modes->{$stpprn}{'High.Gray'});
	    }
	}
    }

    return ($modes, $choicelongnames)
}

exit(0);