Printerdrake changed to use Foomatic, driver options, spooler change

3 files changed, 964 insertions, 774 deletions

diff --git a/perl-install/printer.pm b/perl-install/printer.pm
index 0df3639ac..fa64ca1f8 100644
--- a/perl-install/printer.pm
+++ b/perl-install/printer.pm
@@ -1,11 +1,12 @@
-package printer; # $Id$
+package printer;
+# $Id$
 
 use diagnostics;
 use strict;
 
-use vars qw(%thedb %thedb_gsdriver %printer_type %printer_type_inv @papersize_type %fields @entries_db_short @entry_db_description %descr_to_help %descr_to_db %db_to_descr %descr_to_ppd);
+use vars qw(%thedb %spooler %spooler_inv %printer_type %printer_type_inv @entries_db_short @entry_db_description %descr_to_help %descr_to_db %db_to_descr %descr_to_ppd);
 
-use common;
+use common qw(:common :system :file);
 use commands;
 use run_program;
 
@@ -13,8 +14,18 @@ use run_program;
 my $prefix = "";
 
 #-location of the printer database in an installed system
-my $PRINTER_DB_FILE    = "/usr/lib/rhs/rhs-printfilters/printerdb";
-my $PRINTER_FILTER_DIR = "/usr/lib/rhs/rhs-printfilters";
+my $PRINTER_DB_FILE    = "/usr/share/foomatic/db/compiled/overview.xml";
+#-location of the file containing the default spooler's name
+my $FOOMATIC_DEFAULT_SPOOLER = "/etc/foomatic/defaultspooler";
+
+%spooler = (
+    __("CUPS - Common Unix Printing System") => "cups",
+    __("LPRng - LPR New Generation")         => "lprng",
+    __("LPD - Line Printer Daemon")          => "lpd",
+    __("PDQ - Print, Don't Queue")           => "pdq"
+#    __("PDQ - Marcia, click here!")           => "pdq"
+);
+%spooler_inv = reverse %spooler;
 
 %printer_type = (
     __("Local printer")            => "LOCAL",
@@ -25,293 +36,226 @@ my $PRINTER_FILTER_DIR = "/usr/lib/rhs/rhs-printfilters";
     __("SMB/Windows 95/98/NT")     => "SMB",
     __("NetWare")                  => "NCP",
     __("Printer Device URI")       => "URI",
+    __("Pipe into command")        => "POSTPIPE"
 );
 %printer_type_inv = reverse %printer_type;
 
-%fields = (
-    STANDARD => [qw(QUEUE SPOOLDIR IF)],
-    SPEC     => [qw(DBENTRY RESOLUTION PAPERSIZE BITSPERPIXEL CRLF)],
-    LOCAL    => [qw(DEVICE)],
-    REMOTE   => [qw(REMOTEHOST REMOTEQUEUE)],
-    SMB      => [qw(SMBHOST SMBHOSTIP SMBSHARE SMBUSER SMBPASSWD SMBWORKGROUP AF)],
-    NCP      => [qw(NCPHOST NCPQUEUE NCPUSER NCPPASSWD)],
-);
-@papersize_type = qw(letter legal ledger a3 a4);
-
 #------------------------------------------------------------------------------
 sub set_prefix($) { $prefix = $_[0]; }
 
-sub default_queue($) { (split '\|', $_[0]{QUEUE})[0] }
-sub default_spooldir($) { "/var/spool/lpd/" . default_queue($_[0]) }
+sub default_queue($) { $_[0]{QUEUE} }
 
 sub default_printer_type($) { "LOCAL" }
+sub spooler {
+    return @spooler_inv{qw(cups lpd lprng pdq)};
+}
 sub printer_type($) {
-    for ($_[0]{mode}) {
-	/CUPS/ && return @printer_type_inv{qw(LOCAL REMOTE SMB), $::expert ? qw(URI) : ()};
-	/lpr/  && return @printer_type_inv{qw(LOCAL LPD SMB NCP)};
+    for ($_[0]{SPOOLER}) {
+	/cups/ && return @printer_type_inv{qw(LOCAL CUPS LPD SOCKET SMB), $::expert ? qw(URI) : ()};
+	/lpd/  && return @printer_type_inv{qw(LOCAL LPD SOCKET SMB NCP), $::expert ? qw(POSTPIPE URI) : ()};
+	/lprng/  && return @printer_type_inv{qw(LOCAL LPD SOCKET SMB NCP), $::expert ? qw(POSTPIPE URI) : ()};
+	/pdq/  && return @printer_type_inv{qw(LOCAL LPD SOCKET), $::expert ? qw(URI) : ()};
     }
 }
 
+sub get_default_spooler () {
+    if (-f "$prefix$FOOMATIC_DEFAULT_SPOOLER") {
+	open DEFSPOOL, "< $prefix$FOOMATIC_DEFAULT_SPOOLER";
+	my $spool = <DEFSPOOL>;
+	chomp $spool;
+	close DEFSPOOL;
+	if ($spool =~ /cups|lpd|lprng|pdq/) {
+	    return $spool;
+	}
+    }
+}
+
+sub set_default_spooler ($) {
+    my ($printer) = @_;
+    open DEFSPOOL, "> $prefix$FOOMATIC_DEFAULT_SPOOLER";
+    print DEFSPOOL $printer->{SPOOLER};
+    close DEFSPOOL;
+}
+
 sub copy_printer_params($$) {
     my ($from, $to) = @_;
-    map { $to->{$_} = $from->{$_} } grep { $_ ne 'configured' } keys %$from; #- avoid cycles.
+    map { $to->{$_} = $from->{$_} } grep { $_ ne 'configured' } keys %$from; 
+    #- avoid cycles-----------------^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 }
 
 sub getinfo($) {
     my ($prefix) = @_;
     my $printer = {};
+    my @QUEUES;
 
     set_prefix($prefix);
 
-    #- try to detect which printing system has been previously installed.
-    #- the first detected is the default.
-    read_printers_conf($printer); #- try to read existing cups (local only) queues.
-    read_configured_queue($printer); #- try to read existing lpr queues.
-
-    add2hash($printer, {
-			#- global parameters.
-			want         => 0,
-			complete     => 0,
-			str_type     => undef,
-			QUEUE        => "lp",
-
-			#- lpr parameters.
-			SPOOLDIR     => "/var/spool/lpd/lp",
-			DBENTRY      => "PostScript",
-			PAPERSIZE    => "",
-			ASCII_TO_PS  => undef,
-			CRLF         => undef,
-			NUP          => 1,
-			RTLFTMAR     => 18,
-			TOPBOTMAR    => 18,
-			AUTOSENDEOF  => 1,
-
-			DEVICE       => "/dev/lp0",
-
-			REMOTEHOST   => "",
-			REMOTEQUEUE  => "",
-
-			NCPHOST      => "", #-"printerservername",
-			NCPQUEUE     => "", #-"queuename",
-			NCPUSER      => "", #-"user",
-			NCPPASSWD    => "", #-"pass",
-
-			SMBHOST      => "", #-"hostname",
-			SMBHOSTIP    => "", #-"1.2.3.4",
-			SMBSHARE     => "", #-"printername",
-			SMBUSER      => "", #-"user",
-			SMBPASSWD    => "", #-"passowrd",
-			SMBWORKGROUP => "", #-"AS3",
-
-			#- cups parameters.
-			DeviceURI    => "parallel:/dev/lp0",
-			Info         => "",
-			Location     => "",
-			State        => "Idle",
-			Accepting    => "Yes",
-		       });
-    $printer;
+    # Initialize $printer data structure
+    resetinfo($printer);
+
+    return $printer;
 }
 
 #------------------------------------------------------------------------------
-sub read_configured_queue($) {
+sub resetinfo($) {
     my ($printer) = @_;
-    my $current = undef;
-    my $flush_current = sub {
-	if ($current) {
-	    add2hash($printer->{configured}{$current->{QUEUE}} ||= {}, $current);
-	    $current = undef;
-	}
-    };
-
-    #- read /etc/printcap file.
-    local *PRINTCAP; open PRINTCAP, "$prefix/etc/printcap" or return;
-    local $_;
-    while (<PRINTCAP>) {
-	chomp;
-	my $p = '(?:\{(.*?)\}|(\S+))';
-	if (/^##PRINTTOOL3##\s+$p\s+$p\s+$p\s+$p\s+$p\s+$p\s+$p(?:\s+$p)?/) {
-	    &$flush_current;
-	    $current = {
-			mode => 'lpr',
-			TYPE => $1 || $2,
-			GSDRIVER => $3 || $4,
-			RESOLUTION => $5 || $6,
-			PAPERSIZE => $7 || $8,
-			#- ignored $9 || $10,
-			DBENTRY => $11 || $12,
-			BITSPERPIXEL => $13 || $14,
-			CRLF => $15 || $16,
-		       };
-	} elsif (/^\s*$/) { &$flush_current }
-	elsif (/^([^:]*):\\/) { $current->{QUEUE} = $1 }
-	if (/^\s+:(?:[^:]*:)*sd=([^:]*):/) { $current->{SPOOLDIR} = $1 }
-	if (/^\s+:(?:[^:]*:)*lp=([^:]*):\\/) { $current->{DEVICE} = $1 }
-	if (/^\s+:(?:[^:]*:)*rm=([^:]*):\\/) { $current->{REMOTEHOST} = $1 }
-	if (/^\s+:(?:[^:]*:)*rp=([^:]*):\\/) { $current->{REMOTEQUEUE} = $1 }
-	if (/^\s+:(?:[^:]*:)*af=([^:]*):\\/) { $current->{AF} = $1 }
-	if (/^\s+:(?:[^:]*:)*if=([^:]*):\\/) { $current->{IF} = $1 }
-    }
-    close PRINTCAP;
-    &$flush_current;
-
-    #- parse general.cfg for any configured queue.
-    foreach (values %{$printer->{configured}}) {
-	my $entry = $_;
-	local *F; open F, "$prefix$entry->{SPOOLDIR}/general.cfg" or next;
-	local $_;
-	while (<F>) {
-	    chomp;
-	    if (/^\s*(?:export\s+)?PRINTER_TYPE=(.*?)\s*$/) { $entry->{TYPE} = $1 unless defined $entry->{TYPE} }
-	    elsif (/^\s*(?:export\s+)?ASCII_TO_PS=(.*?)\s*$/) { $entry->{ASCII_TO_PS} = $1 eq 'YES' unless defined $entry->{ASCII_TO_PS} }
-	    elsif (/^\s*(?:export\s+)?PAPER_SIZE=(.*?)\s*$/) { $entry->{PAPERSIZE} = $1 unless defined $entry->{PAPERSIZE} }
-	}
-	close F;
-    }
-
-    #- parse postscript.cfg for any configured queue.
-    foreach (values %{$printer->{configured}}) {
-	my $entry = $_;
-	local *F; open F, "$prefix$entry->{SPOOLDIR}/postscript.cfg" or next;
-	local $_;
-	while (<F>) {
-	    chomp;
-	    if (/^\s*(?:export\s+)?GSDEVICE=(.*?)\s*$/) { $entry->{GSDRIVER} = $1 unless defined $entry->{GSDRIVER} }
-	    elsif (/^\s*(?:export\s+)?RESOLUTION=(.*?)\s*$/) { $entry->{RESOLUTION} = $1 unless defined $entry->{RESOLUTION} }
-	    elsif (/^\s*(?:export\s+)?COLOR=-dBitsPerPixel=(.*?)\s*$/) { $entry->{COLOR} = $1 unless defined $entry->{COLOR} }
-	    elsif (/^\s*(?:export\s+)?COLOR=(.*?)\s*$/) { $entry->{COLOR} = $1 ? $1 : 'Default' unless defined $entry->{COLOR} }
-	    elsif (/^\s*(?:export\s+)?PAPERSIZE=(.*?)\s*$/) { $entry->{PAPERSIZE} = $1 unless defined $entry->{PAPERSIZE} }
-	    elsif (/^\s*(?:export\s+)?EXTRA_GS_OPTIONS=(.*?)\s*$/) { $entry->{EXTRA_GS_OPTIONS} = $1 unless defined $entry->{EXTRA_GS_OPTIONS}; $entry->{EXTRA_GS_OPTIONS} =~ s/^\"(.*)\"/$1/ }
-	    elsif (/^\s*(?:export\s+)?REVERSE_ORDER=(.*?)\s*$/) { $entry->{REVERSE_ORDER} = $1 unless defined $entry->{REVERSE_ORDER} }
-	    elsif (/^\s*(?:export\s+)?PS_SEND_EOF=(.*?)\s*$/) { $entry->{AUTOSENDEOF} = $1 eq 'YES' && $entry->{DBENTRY} eq 'PostScript' unless defined $entry->{AUTOSENDEOF} }
-	    elsif (/^\s*(?:export\s+)?NUP=(.*?)\s*$/) { $entry->{NUP} = $1 unless defined $entry->{NUP} }
-	    elsif (/^\s*(?:export\s+)?RTLFTMAR=(.*?)\s*$/) { $entry->{RTLFTMAR} = $1 unless defined $entry->{RTLFTMAR} }
-	    elsif (/^\s*(?:export\s+)?TOPBOTMAR=(.*?)\s*$/) { $entry->{TOPBOTMAR} = $1 unless defined $entry->{TOPBOTMAR} }
-	}
-	close F;
-    }
-
-    #- parse textonly.cfg for any configured queue.
-    foreach (values %{$printer->{configured}}) {
-	my $entry = $_;
-	local *F; open F, "$prefix$entry->{SPOOLDIR}/textonly.cfg" or next;
-	local $_;
-	while (<F>) {
-	    chomp;
-	    if (/^\s*(?:export\s+)?TEXTONLYOPTIONS=(.*?)\s*$/) { $entry->{TEXTONLYOPTIONS} = $1 unless defined $entry->{TEXTONLYOPTIONS}; $entry->{TEXTONLYOPTIONS} =~ s/^\"(.*)\"/$1/ }
-	    elsif (/^\s*(?:export\s+)?CRLFTRANS=(.*?)\s*$/) { $entry->{CRLF} = $1 eq 'YES' unless defined $entry->{CRLF} }
-	    elsif (/^\s*(?:export\s+)?TEXT_SEND_EOF=(.*?)\s*$/) { $entry->{AUTOSENDEOF} = $1 eq 'YES' && $entry->{DBENTRY} ne 'PostScript' unless defined $entry->{AUTOSENDEOF} }
-	}
-	close F;
-    }
+    $printer->{QUEUE} = "";
+    $printer->{OLD_QUEUE} = "";
+    $printer->{ARGS} = "";
+    $printer->{DBENTRY} = "";
+    @{$printer->{OPTIONS}} = ();
+    $printer->{currentqueue} = {};
+    # -check which printing system was used previously and load the information
+    # -about its queues
+    read_configured_queues($printer);
+}
 
-    #- get extra parameters for SMB or NCP type queue.
-    foreach (values %{$printer->{configured}}) {
-	my $entry = $_;
-	if ($entry->{TYPE} eq 'SMB') {
-	    my $config_file = "$prefix$entry->{SPOOLDIR}/.config";
-	    local *F; open F, "$config_file" or next; #die "Can't open $config_file $!";
-	    local $_;
-	    while (<F>) {
-		chomp;
-		if (/^\s*share='\\\\(.*?)\\(.*?)'/) {
-		    $entry->{SMBHOST} = $1;
-		    $entry->{SMBSHARE} = $2;
-		} elsif (/^\s*hostip=(.*)/) {
-		    $entry->{SMBHOSTIP} = $1;
-		} elsif (/^\s*user='(.*)'/) {
-		    $entry->{SMBUSER} = $1;
-		} elsif (/^\s*password='(.*)'/) {
-		    $entry->{SMBPASSWD} = $1;
-		} elsif (/^\s*workgroup='(.*)'/) {
-		    $entry->{SMBWORKGROUP} = $1;
-		}
-	    }
+sub read_configured_queues($) {
+    my ($printer) = @_;
+    my @QUEUES;
+    # Get the default spooler choice from the config file
+    if (!($printer->{SPOOLER} ||= printer::get_default_spooler())) {
+	#- Find the first spooler where there are queues
+	my $spooler;
+	for $spooler (qw(cups pdq lprng lpd)) {
+	    #- poll queue info 
+	    local *F; 
+	    open F, ($::testing ? "$prefix" : "chroot $prefix/ ") . 
+		"foomatic-configure -P -s $spooler |" ||
+		    die "Could not run foomatic-configure";
+	    eval (join('',(<F>))); 
 	    close F;
-	} elsif ($entry->{TYPE} eq 'NCP') {
-	    my $config_file = "$prefix$entry->{SPOOLDIR}/.config";
-	    local *F; open F, "$config_file" or next; #die "Can't open $config_file $!";
-	    local $_;
-	    while (<F>) {
-		chomp;
-		if (/^\s*server=(.*)/) {
-		    $entry->{NCPHOST} = $1;
-		} elsif (/^\s*user='(.*)'/) {
-		    $entry->{NCPUSER} = $1;
-		} elsif (/^\s*password='(.*)'/) {
-		    $entry->{NCPPASSWD} = $1;
-		} elsif (/^\s*queue='(.*)'/) {
-		    $entry->{NCPQUEUE} = $1;
-		}
+	    #- Have we found queues?
+	    if ($#QUEUES != -1) {
+		$printer->{SPOOLER} = $spooler;
+		last;
 	    }
-	    close F;
 	}
+    } else {
+	#- Poll the queues of the current default spooler
+	local *F; 
+	open F, ($::testing ? "$prefix" : "chroot $prefix/ ") . 
+	    "foomatic-configure -P -s $printer->{SPOOLER} |" ||
+		die "Could not run foomatic-configure";
+	eval (join('',(<F>))); 
+	close F;
+    }
+    $printer->{configured} = {};
+    my $i;
+    my $N = $#QUEUES + 1;
+    for ($i = 0;  $i < $N; $i++) {
+	$printer->{configured}{$QUEUES[$i]->{'queuedata'}{'queue'}} = 
+	    $QUEUES[$i];
     }
-
-    #- assume this printing system, but only if some queue are defined.
-    scalar(keys %{$printer->{configured}}) > 0 and $printer->{mode} ||= 'lpr';
 }
 
 sub read_printer_db(;$) {
     my $dbpath = $prefix . ($_[0] || $PRINTER_DB_FILE);
 
-    scalar(keys %thedb) > 4 and return; #- try reparse if using only ppa, POSTSCRIPT, TEXT.
-
-    my %available_devices; #- keep only available devices in our database.
     local $_; #- use of while (<...
-    local *AVAIL; open AVAIL, ($::testing ? "$prefix" : "chroot $prefix/ ") . "/usr/bin/gs --help |";
-    while (<AVAIL>) {
-	if (/^Available devices:/ ... /^\S/) {
-	    @available_devices{split /\s+/, $_} = () if /^\s+/;
-	}
-    }
-    close AVAIL;
-    $available_devices{ppa} = undef; #- if -x "$prefix/usr/bin/pbm2ppa" && -x "$prefix/usr/bin/pnm2ppa";
-    delete $available_devices{''};
-    @available_devices{qw/POSTSCRIPT TEXT/} = (); #- these are always available.
 
     local *DBPATH; #- don't have to do close ... and don't modify globals at least
-    open DBPATH, $dbpath or die "An error has occurred on $dbpath : $!";
+    # Generate the Foomatic printer/driver overview, read it from the
+    # appropriate file when it is already generated
+    if (!(-f $dbpath)) {
+	open DBPATH, ($::testing ? "$prefix" : "chroot $prefix/ ") . 
+	    "foomatic-configure -O |" ||
+		die "Could not run foomatic-configure";
+    } else {
+	open DBPATH, $dbpath or die "An error has occurred on $dbpath : $!";
+    }
 
+    my $entry = {};
+    my $inentry = 0;
+    my $indrivers = 0;
+    my $inautodetect = 0;
     while (<DBPATH>) {
-	if (/^StartEntry:\s(\w*)/) {
-	    my $entry = { ENTRY => $1 };
-
-	  WHILE :
-	      while (<DBPATH>) {
-		SWITCH: {
-		      /GSDriver:\s*(\w*)/      and do { $entry->{GSDRIVER} = $1; last SWITCH };
-		      /Description:\s*{(.*)}/  and do { $entry->{DESCR}    = $1; last SWITCH };
-		      /About:\s*{\s*(.*?)\s*}/ and do { $entry->{ABOUT}    = $1; last SWITCH };
-		      /About:\s*{\s*(.*?)\s*\\\s*$/
-			and do {
-			    my $string = $1;
-			    while (<DBPATH>) {
-				$string =~ /\S$/ and $string .= ' ';
-				/^\s*(.*?)\s*\\\s*$/ and $string .= $1;
-				/^\s*(.*?)\s*}\s*$/  and do { $entry->{ABOUT} = $string . $1; last SWITCH };
-			    }
-			};
-		      /Resolution:\s*{(.*)}\s*{(.*)}\s*{(.*)}/
-			and do { push @{$entry->{RESOLUTION} ||= []}, { XDPI => $1, YDPI => $2, DESCR => $3 }; last SWITCH };
-		      /BitsPerPixel:\s*{(.*)}\s*{(.*)}/
-			and do { push @{$entry->{BITSPERPIXEL} ||= []}, {DEPTH => $1, DESCR => $2}; last SWITCH };
-
-		      /EndEntry/ and last WHILE;
-		  }
-	      }
-	    if (exists $available_devices{$entry->{GSDRIVER}}) {
-		$thedb{$entry->{ENTRY}} = $entry;
-		$thedb_gsdriver{$entry->{GSDRIVER}} = $entry;
+	chomp;
+	if ($inentry) {
+	    # We are inside a printer entry
+	    if ($indrivers) {
+		# We are inside the drivers block of a printers entry
+		if (m!^\s*</drivers>\s*$!) {
+		    # End of drivers block
+		    $indrivers = 0;
+		} elsif (m!^\s*<driver>(.+)</driver>\s*$!) {
+		    push (@{$entry->{drivers}}, $1);
+		}
+	    } elsif ($inautodetect) {
+		# We are inside the autodetect block of a printers entry
+		# All entries inside this block will be ignored
+		if (m!^.*</autodetect>\s*$!) {
+		    # End of autodetect block
+		    $inautodetect = 0;
+		}
+	    } else {
+		if (m!^\s*</printer>\s*$!) {
+		    # entry completed
+		    $inentry = 0;
+		    # Make one database entry per driver with the entry name
+		    # manufacturer|model|driver
+		    my $driver;
+		    for $driver (@{$entry->{drivers}}) {
+			my $driverstr;
+			if ($driver eq "Postscript") {
+			    $driverstr = "PostScript";
+			} else {
+			    $driverstr = "GhostScript + $driver";
+			}
+			$entry->{ENTRY} = "$entry->{make}|$entry->{model}|$driverstr";
+			$entry->{driver} = $driver;
+			# Duplicate contents of $entry because it is multiply entered to the database
+			map { $thedb{$entry->{ENTRY}}->{$_} = $entry->{$_} } keys %$entry;
+		    }
+		    $entry = {};
+		} elsif (m!^\s*<id>\s*([0-9]+)\s*</id>\s*$!) {
+		    # Foomatic printer ID
+		    $entry->{id} = $1;
+		} elsif (m!^\s*<make>(.+)</make>\s*$!) {
+		    # Printer manufacturer
+		    $entry->{make} = $1;
+		} elsif (m!^\s*<model>(.+)</model>\s*$!) {
+		    # Printer model
+		    $entry->{model} = $1;
+		} elsif (m!^\s*<drivers>\s*$!) {
+		    # Drivers block
+		    $indrivers = 1;
+		    @{$entry->{drivers}} = (); 
+		} elsif (m!^\s*<autodetect>\s*$!) {
+		    # Autodetect block
+		    $inautodetect = 1;
+		}
+	    }
+	} else {
+	    if (m!^\s*<printer>\s*$!) {
+		# new entry
+		$inentry = 1;
 	    }
 	}
     }
-
     @entries_db_short     = sort keys %printer::thedb;
-    %descr_to_db          = map { $printer::thedb{$_}{DESCR}, $_ } @entries_db_short;
-    %descr_to_help        = map { $printer::thedb{$_}{DESCR}, $printer::thedb{$_}{ABOUT} } @entries_db_short;
-    @entry_db_description = keys %descr_to_db;
-    %db_to_descr          = reverse %descr_to_db;
+    #%descr_to_db          = map { $printer::thedb{$_}{DESCR}, $_ } @entries_db_short;
+    #%descr_to_help        = map { $printer::thedb{$_}{DESCR}, $printer::thedb{$_}{ABOUT} } @entries_db_short;
+    #@entry_db_description = keys %descr_to_db;
+    #db_to_descr          = reverse %descr_to_db;
+}
+
+sub read_foomatic_options ($) {
+    my ($printer) = @_;
+    # Generate the option data for the chosen printer/driver combo
+    my $COMBODATA;
+    local *F;
+    open F, ($::testing ? "$prefix" : "chroot $prefix/ ") . 
+	"foomatic-configure -P -p $printer->{currentqueue}{'id'}" .
+	    " -d $printer->{currentqueue}{'driver'}" . 
+		($printer->{OLD_QUEUE} ?
+		  " -s $printer->{SPOOLER} -n $printer->{OLD_QUEUE}" : "") 
+		    . " |" ||
+	    die "Could not run foomatic-configure";
+    eval (join('',(<F>))); 
+    close F;
+    # Return the arguments field
+    return $COMBODATA->{'args'};
 }
 
 #------------------------------------------------------------------------------
@@ -361,7 +305,7 @@ sub read_printers_conf {
     close PRINTERS;
 
     #- assume this printing system.
-    $printer->{mode} ||= 'CUPS';
+    $printer->{SPOOLER} ||= 'CUPS';
 }
 
 sub get_direct_uri {
@@ -420,205 +364,46 @@ sub poll_ppd_base {
     $descr_to_ppd{"No driver (raw queue)"} = '';
 }
 
+
+
 #-******************************************************************************
 #- write functions
 #-******************************************************************************
 
-#------------------------------------------------------------------------------
-#- given the path queue_path, we create all the required spool directory
-#------------------------------------------------------------------------------
-sub create_spool_dir($) {
-    my ($queue_path) = @_;
-    my $complete_path = "$prefix/$queue_path";
-
-    commands::mkdir_("-p", $complete_path);
-
-    unless ($::testing) {
-	#-redhat want that "drwxr-xr-x root lp"
-	my $gid_lp = (getpwnam("lp"))[3];
-	chown 0, $gid_lp, $complete_path
-	  or die "An error has occurred - can't chgrp $complete_path to lp $!";
-    }
-}
-
-#------------------------------------------------------------------------------
-#-given the input spec file 'input', and the target output file 'output'
-#-we set the fields specified by fieldname to the values in fieldval
-#-nval  is the number of fields to set
-#-Doesnt currently catch error exec'ing sed yet
-#------------------------------------------------------------------------------
-sub create_config_file($$%) {
-    my ($inputfile, $outputfile, %toreplace) = @_;
-    template2file("$prefix/$inputfile", "$prefix/$outputfile", %toreplace);
-    eval { commands::chown_("root.lp", "$prefix/$outputfile") };
-}
-
-
-#------------------------------------------------------------------------------
-#-copy master filter to the spool dir
-#------------------------------------------------------------------------------
-sub copy_master_filter($) {
-    my ($queue_path) = @_;
-    my $complete_path = "$prefix/$queue_path/filter";
-    my $master_filter = "$prefix/$PRINTER_FILTER_DIR/master-filter";
-
-    eval { commands::cp('-f', $master_filter, $complete_path) };
-    $@ and die "Can't copy $master_filter to $complete_path $!";
-    eval { commands::chown_("root.lp", $complete_path); };
-}
-
-#------------------------------------------------------------------------------
-#- given a PrintCap Entry, create the spool dir and special
-#- rhs-printfilters related config files which are required
-#------------------------------------------------------------------------------
-my $intro_printcap_test = "
-#
-# Please don't edit this file directly unless you know what you are doing!
-# Look at the printcap(5) man page for more info.
-# Be warned that the control-panel printtool requires a very strict format!
-#
-# This file can be edited with printerdrake or printtool.
-#
-
-";
-
 sub configure_queue($) {
-    my ($entry) = @_;
-
-    for ($entry->{mode}) {
-	/CUPS/ && do {
-	    #- at this level, we are using lpadmin to create a local printer (only local
-	    #- printer are supported with printerdrake).
-	    run_program::rooted($prefix, "lpadmin",
-				"-p", $entry->{QUEUE},
-				$entry->{State} eq 'Idle' && $entry->{Accepting} eq 'Yes' ? ("-E") : (),
-				"-v", $entry->{DeviceURI},
-				$entry->{cupsPPD} ? ("-m", $entry->{cupsPPD}) : (),
-				$entry->{Info} ? ("-D", $entry->{Info}) : (),
-				$entry->{Location} ? ("-L", $entry->{Location}) : (),
-				if_($entry->{CUPSOPTIONS}, $entry->{CUPSOPTIONS}), #- use it if available, only for auto_install
-			       ) or die "lpadmin failed";
-	    last };
-	/lpr/  && do {
-	    #- old style configuration scheme for lpr.
-	    my $queue_path = "$entry->{SPOOLDIR}";
-	    create_spool_dir($queue_path);
-
-	    my $get_name_file = sub {
-		my ($name) = @_;
-		("$PRINTER_FILTER_DIR/$name.in", "$entry->{SPOOLDIR}/$name")
-	    };
-	    my ($filein, $file);
-	    my %fieldname = ();
-	    my $dbentry = $thedb{($entry->{DBENTRY})} or die "no dbentry";
-
-	    #- make general.cfg
-	    ($filein, $file) = &$get_name_file("general.cfg");
-	    $fieldname{ascps_trans} = $entry->{ASCII_TO_PS} || $dbentry->{GSDRIVER} eq 'ppa' ? "YES" : "NO";
-	    $fieldname{desiredto}   = $dbentry->{GSDRIVER} ne "TEXT" ? "ps" : "asc";
-	    $fieldname{papersize}   = $entry->{PAPERSIZE} ? $entry->{PAPERSIZE} : "letter";
-	    $fieldname{printertype} = $entry->{TYPE};
-	    create_config_file($filein, $file, %fieldname);
-
-	    #- now do postscript.cfg
-	    ($filein, $file) = &$get_name_file("postscript.cfg");
-	    %fieldname = ();
-	    $fieldname{gsdevice}       = $dbentry->{GSDRIVER};
-	    $fieldname{papersize}      = $entry->{PAPERSIZE} ? $entry->{PAPERSIZE} : "letter";
-	    $fieldname{resolution}     = $entry->{RESOLUTION};
-	    $fieldname{color}          = $entry->{BITSPERPIXEL} ne "Default" &&
-	      (($dbentry->{GSDRIVER} ne "uniprint" && "-dBitsPerPixel=") . $entry->{BITSPERPIXEL});
-	    $fieldname{reversepages}   = $entry->{REVERSE_ORDER} ? "YES" : "";
-	    $fieldname{extragsoptions} = "\"$entry->{EXTRA_GS_OPTIONS}\"";
-	    $fieldname{pssendeof}      = $entry->{AUTOSENDEOF} ? ($dbentry->{GSDRIVER} eq "POSTSCRIPT" ? "YES" : "NO") : "NO";
-	    $fieldname{nup}            = $entry->{NUP};
-	    $fieldname{rtlftmar}       = $entry->{RTLFTMAR};
-	    $fieldname{topbotmar}      = $entry->{TOPBOTMAR};
-	    create_config_file($filein, $file, %fieldname);
-
-	    #- finally, make textonly.cfg
-	    ($filein, $file) = &$get_name_file("textonly.cfg");
-	    %fieldname = ();
-	    $fieldname{textonlyoptions} = "\"$entry->{TEXTONLYOPTIONS}\"";
-	    $fieldname{crlftrans}       = $entry->{CRLF} ? "YES" : "";
-	    $fieldname{textsendeof}     = $entry->{AUTOSENDEOF} ? ($dbentry->{GSDRIVER} eq "POSTSCRIPT" ? "NO" : "YES") : "NO";
-	    create_config_file($filein, $file, %fieldname);
-
-	    if ($entry->{TYPE} eq "SMB") {
-		#- simple config file required if SMB printer
-		my $config_file = "$prefix$queue_path/.config";
-		local *F;
-		open F, ">$config_file" or die "Can't create $config_file $!";
-		print F "share='\\\\$entry->{SMBHOST}\\$entry->{SMBSHARE}'\n";
-		print F "hostip=$entry->{SMBHOSTIP}\n";
-		print F "user='$entry->{SMBUSER}'\n";
-		print F "password='$entry->{SMBPASSWD}'\n";
-		print F "workgroup='$entry->{SMBWORKGROUP}'\n";
-		close F;
-		eval { chmod 0640, $config_file; commands::chown_("root.lp", $config_file) };
-	    } elsif ($entry->{TYPE} eq "NCP") {
-		#- same for NCP printer
-		my $config_file = "$prefix$queue_path/.config";
-		local *F;
-		open F, ">$config_file" or die "Can't create $config_file $!";
-		print F "server=$entry->{NCPHOST}\n";
-		print F "queue=$entry->{NCPQUEUE}\n";
-		print F "user=$entry->{NCPUSER}\n";
-		print F "password=$entry->{NCPPASSWD}\n";
-		close F;
-		eval { chmod 0640, $config_file; commands::chown_("root.lp", $config_file) };
-	    }
-
-	    copy_master_filter($queue_path);
-
-	    #-now the printcap file, note this one contains all the printer (use configured for that).
-	    local *PRINTCAP;
-	    open PRINTCAP, ">$prefix/etc/printcap" or die "Can't open printcap file $!";
-	    print PRINTCAP $intro_printcap_test;
-	    foreach (values %{$entry->{configured}}) {
-		$_->{DBENTRY} = $thedb_gsdriver{$_->{GSDRIVER}}{ENTRY} unless defined $_->{DBENTRY};
-		my $db_ = $thedb{$_->{DBENTRY}} or next; #die "no dbentry";
-
-		$_->{SPOOLDIR} ||= default_spooldir($_);
-		$_->{IF}       ||= "$_->{SPOOLDIR}/filter";
-		$_->{AF}       ||= "$_->{SPOOLDIR}/acct";
-
-		printf PRINTCAP "##PRINTTOOL3##  %s %s %s %s %s %s %s%s\n",
-		  $_->{TYPE} || '{}',
-		    $db_->{GSDRIVER} || '{}',
-		      $_->{RESOLUTION} || '{}',
-			$_->{PAPERSIZE} || '{}',
-			  '{}',
-			    $db_->{ENTRY} || '{}',
-			      $_->{BITSPERPIXEL} || '{}',
-				$_->{CRLF} ? " 1" : "";
-
-		print PRINTCAP "$_->{QUEUE}:\\\n";
-		print PRINTCAP "\t:sd=$_->{SPOOLDIR}:\\\n";
-		print PRINTCAP "\t:mx#0:\\\n\t:sh:\\\n";
-
-		if ($_->{TYPE} eq "LOCAL") {
-		    print PRINTCAP "\t:lp=$_->{DEVICE}:\\\n";
-		} elsif ($_->{TYPE} eq "LPD") {
-		    print PRINTCAP "\t:rm=$_->{REMOTEHOST}:\\\n";
-		    print PRINTCAP "\t:rp=$_->{REMOTEQUEUE}:\\\n";
-		} else {
-		    #- (pcentry->Type == (PRINTER_SMB | PRINTER_NCP))
-		    print PRINTCAP "\t:lp=/dev/null:\\\n";
-		    print PRINTCAP "\t:af=$_->{AF}\\\n";
-		}
+    my ($printer) = @_;
 
-		#- cheating to get the input filter!
-		print PRINTCAP "\t:if=$_->{IF}:\n";
-		print PRINTCAP "\n";
-	    }
-	    eval { commands::chown_("root.lp", "$prefix/etc/printcap") };
-	    last };
+    if ($printer->{currentqueue}{foomatic}) {
+	#- Create the queue with "foomatic-configure"
+        run_program::rooted($prefix, "foomatic-configure",
+			    "-s", $printer->{SPOOLER},
+			    "-n", $printer->{currentqueue}{'queue'},
+			    "-c", $printer->{currentqueue}{'connect'},
+			    "-p", $printer->{currentqueue}{'id'},
+			    "-d", $printer->{currentqueue}{'driver'},
+			    "-N", $printer->{currentqueue}{'desc'},
+			    "-L", $printer->{currentqueue}{'loc'},
+			    @{$printer->{OPTIONS}}
+			    ) or die "foomatic-configure failed";
+    } elsif (0) {
+	#- #### For later CUPS+PPD support
+	#- at this level, we are using lpadmin to create a local printer (only local
+	#- printer are supported with printerdrake).
+        run_program::rooted($prefix, "lpadmin",
+			    "-p", $printer->{QUEUE},
+			    $printer->{State} eq 'Idle' && $printer->{Accepting} eq 'Yes' ? ("-E") : (),
+			    "-v", $printer->{DeviceURI},
+			    $printer->{cupsPPD} ? ("-m", $printer->{cupsPPD}) : (),
+			    $printer->{Info} ? ("-D", $printer->{Info}) : (),
+			    $printer->{Location} ? ("-L", $printer->{Location}) : (),
+			    if_($printer->{CUPSOPTIONS}, $printer->{CUPSOPTIONS}), #- use it if available, only for auto_install
+			    ) or die "lpadmin failed";
     }
 
     my $useUSB = 0;
-    foreach (values %{$entry->{configured}}) {
-	$useUSB ||= $_->{DEVICE} =~ /usb/ || $_->{DeviceURI} =~ /usb/;
+    foreach (values %{$printer->{configured}}) {
+	$useUSB ||= $_->{'queuedata'}{'connect'} =~ /usb/ || 
+	    $_->{DeviceURI} =~ /usb/;
     }
     if ($useUSB) {
 	my $f = "$prefix/etc/sysconfig/usb";
@@ -628,60 +413,64 @@ sub configure_queue($) {
     }
 }
 
-#- use the queue currently configured at the top of printer hash.
-sub remove_queue($) {
-    my ($printer) = @_;
-    $printer->{configured}{$printer->{QUEUE}} or return; #- something strange at this point.
-
-    if ($printer->{mode} eq 'CUPS') {
-	run_program::rooted($prefix, "lpadmin", "-x", $printer->{QUEUE});
-    }
-    delete $printer->{configured}{$printer->{QUEUE}};
+sub remove_queue($$) {
+    my ($printer) = $_[0];
+    my ($queue) = $_[1];
+    run_program::rooted($prefix, "foomatic-configure", "-D",
+			"-s", $printer->{SPOOLER},
+			"-n", $queue);
+    delete $printer->{configured}{$queue};
 }
 
 sub restart_queue($) {
     my ($printer) = @_;
     my $queue = default_queue($printer);
 
-    for ($printer->{mode}) {
+    # Restart the daemon(s)
+    for ($printer->{SPOOLER}) {
 	/CUPS/ && do {
-	    #- restart cups before cleaning the queue.
+	    #- restart cups.
 	    run_program::rooted($prefix, "/etc/rc.d/init.d/cups start"); sleep 1;
-	    run_program::rooted($prefix, "lprm-cups", "-P$queue", "-");
 	    last };
-	/lpr/  && do {
-	    #- restart lpd after cleaning the queue.
+	/lpr|lprng/ && do {
+	    #- restart lpd.
 	    foreach (("/var/spool/lpd/$queue/lock", "/var/spool/lpd/lpd.lock")) {
 		my $pidlpd = (cat_("$prefix$_"))[0];
 		kill 'TERM', $pidlpd if $pidlpd;
 		unlink "$prefix$_";
 	    }
-	    run_program::rooted($prefix, "lprm-lpd", "-P$queue", "-"); sleep 1;
 	    run_program::rooted($prefix, "lpd"); sleep 1;
 	    last };
     }
+    # Kill the jobs
+    run_program::rooted($prefix, "foomatic-printjob", "-R",
+			"-s", $printer->{SPOOLER},
+			"-P", $queue, "-");
+
 }
 
 sub print_pages($@) {
     my ($printer, @pages) = @_;
     my $queue = default_queue($printer);
-    my ($lpr, $lpq);
-
-    for ($printer->{mode}) {
-	/CUPS/ and ($lpr, $lpq) = ("/usr/bin/lpr-cups", "/usr/bin/lpq-cups");
-	/lpr/  and ($lpr, $lpq) = ("/usr/bin/lpq-lpd", "/usr/bin/lpq-lpd");
-    }
+    my $lpr = "/usr/bin/foomatic-printjob";
+    my $lpq = "$lpr -Q";
 
+    # Print the pages
     foreach (@pages) {
-	run_program::rooted($prefix, $lpr, "-P$queue", $_);
+	run_program::rooted($prefix, $lpr, "-s", $printer->{SPOOLER},
+			    "-P", $queue, $_);
     }
     sleep 5; #- allow lpr to send pages.
-    local *F; open F, ($::testing ? "$prefix" : "chroot $prefix/ ") . "$lpq -P$queue |";
-    my @lpq_output = grep { !/^no entries/ && !(/^Rank\s+Owner/ .. /^\s*$/) } <F>;
+    # Check whether the job is queued
+    local *F; 
+    open F, ($::testing ? "$prefix" : "chroot $prefix/ ") . "$lpq -s $printer->{SPOOLER} -P $queue |";
+    my @lpq_output =
+	grep { !/^no entries/ && !(/^Rank\s+Owner/ .. /^\s*$/) } <F>;
     close F;
     @lpq_output;
 }
 
+
 #-######################################################################################
 #- Wonderful perl :(
 #-######################################################################################
diff --git a/perl-install/printerdrake.pm b/perl-install/printerdrake.pm
index 21df546a2..2ba7b5c01 100644
--- a/perl-install/printerdrake.pm
+++ b/perl-install/printerdrake.pm
@@ -1,9 +1,10 @@
-package printerdrake; # $Id$
+package printerdrake;
+# $Id$
 
 use diagnostics;
 use strict;
 
-use common;
+use common qw(:common :file :functional :system);
 use detect_devices;
 use commands;
 use modules;
@@ -33,9 +34,12 @@ sub auto_detect {
 sub setup_local($$$) {
     my ($printer, $in, $install) = @_;
 
+    my $queue = $printer->{OLD_QUEUE};
     my @port = ();
     my @str = ();
+    my $device;
     my @parport = auto_detect($in);
+    # $printer->{currentqueue}{queuedata}
     foreach (@parport) {
 	$_->{val}{DESCRIPTION} and push @str, _("A printer, model \"%s\", has been detected on ",
 						$_->{val}{DESCRIPTION}) . $_->{port};
@@ -45,92 +49,240 @@ sub setup_local($$$) {
     } else {
 	@port = map { $_->{port} } grep { $_->{val}{DESCRIPTION} } @parport;
     }
-    $printer->{DEVICE} = $port[0] if $port[0];
-
+    if (($printer->{configured}{$queue}) &&
+	($printer->{currentqueue}{'connect'} =~ m/^file:/)) {
+	$device = $printer->{currentqueue}{'connect'};
+	$device =~ s/^file://;
+    } elsif ($port[0]) {
+	$device = $port[0];
+    }
     if ($in) {
 	$::expert or $in->set_help('configurePrinterDev') if $::isInstall;
 	return if !$in->ask_from_entries_refH(_("Local Printer Device"),
 _("What device is your printer connected to 
 (note that /dev/lp0 is equivalent to LPT1:)?\n") . (join "\n", @str), [
-{ label => _("Printer Device"), val => \$printer->{DEVICE}, list => \@port } ],
+{ label => _("Printer Device"), val => \$device, list => \@port, not_edit => !$::expert } ],
+complete => sub {
+    unless ($device ne "") {
+	$in->ask_warn('', __("Device/file name missing!"));
+	return (1,0);
+    }
+    return 0;
+}
 					     );
     }
 
-    #- make the DeviceURI from DEVICE.
-    $printer->{DeviceURI} = ($printer->{DEVICE} =~ /usb/ ? "usb:" : "parallel:") . $printer->{DEVICE};
+    #- make the DeviceURI from $device.
+    $printer->{currentqueue}{'connect'} = "file:" . $device;
+
+    #- Read the printer driver database if necessary
+    if ((keys %printer::thedb) == 0) {printer::read_printer_db();}
 
+    #- Search the database entry which matches the detected printer best
     foreach (@parport) {
-	$printer->{DEVICE} eq $_->{port} or next;
-	$printer->{DBENTRY} = $printer::descr_to_db{common::bestMatchSentence($_->{val}{DESCRIPTION},
-									      @printer::entry_db_description)};
-        $printer->{cupsDescr} = common::bestMatchSentence($_->{val}{DESCRIPTION}, keys %printer::descr_to_ppd);
+	$device eq $_->{port} or next;
+        $printer->{DBENTRY} =
+            common::bestMatchSentence2($_->{val}{DESCRIPTION}, 
+            keys %printer::thedb);
     }
     1;
 }
 
-sub setup_remote($$$) {
+sub setup_lpd($$$) {
     my ($printer, $in, $install) = @_;
 
+    my $uri;
+    my $remotehost;
+    my $remotequeue;
+    my $queue = $printer->{OLD_QUEUE};
+    if (($printer->{configured}{$queue}) &&
+	($printer->{currentqueue}{'connect'} =~ m/^lpd:/)) {
+	$uri = $printer->{currentqueue}{'connect'};
+	$uri =~ m!^\s*lpd://([^/]+)/([^/]+)/?\s*$!;
+	$remotehost = $1;
+	$remotequeue = $2;
+    } else {
+	$remotehost = "";
+	$remotequeue = "lp";
+    }
+
     return if !$in->ask_from_entries_refH(_("Remote lpd Printer Options"),
-_("To use a remote lpd print queue, you need to supply
+__("To use a remote lpd print queue, you need to supply
 the hostname of the printer server and the queue name
-on that server which jobs should be placed in."), [
-{ label => _("Remote hostname"), val => \$printer->{REMOTEHOST} },
-{ label => _("Remote queue"), val => \$printer->{REMOTEQUEUE} } ],
+on that server."), [
+{ label => _("Remote hostname"), val => \$remotehost },
+{ label => _("Remote queue"), val => \$remotequeue } ],
+complete => sub {
+    unless ($remotehost ne "") {
+	$in->ask_warn('', __("Remote host name missing!"));
+	return (1,0);
+    }
+    unless ($remotequeue ne "") {
+	$in->ask_warn('', __("Remote queue name missing!"));
+	return (1,1);
+    }
+    return 0;
+}
 			      );
-    #- make the DeviceURI from DEVICE.
-    $printer->{DeviceURI} = "lpd://$printer->{REMOTEHOST}/$printer->{REMOTEQUEUE}";
+    #- make the DeviceURI from user input.
+    $printer->{currentqueue}{'connect'} = 
+        "lpd://$remotehost/$remotequeue";
 }
 
 sub setup_smb($$$) {
     my ($printer, $in, $install) = @_;
 
+    my $uri;
+    my $smbuser = "";
+    my $smbpassword = "";
+    my $workgroup = "";
+    my $smbserver = "";
+    my $smbserverip = "";
+    my $smbshare = "";
+    my $queue = $printer->{OLD_QUEUE};
+    if (($printer->{configured}{$queue}) &&
+	($printer->{currentqueue}{'connect'} =~ m/^smb:/)) {
+	$uri = $printer->{currentqueue}{'connect'};
+	$uri =~ m!^\s*smb://(.*)$!;
+	my $parameters = $1;
+	# Get the user's login and password from the URI
+	if ($parameters =~ m!([^@]*)@([^@]+)!) {
+	    my $login = $1;
+	    $parameters = $2;
+	    if ($login =~ m!([^:]*):([^:]*)!) {
+		$smbuser = $1;
+		$smbpassword = $2;
+	    } else {
+		$smbuser = $login;
+		$smbpassword = "";
+	    }
+	} else {
+	    $smbuser = "";
+	    $smbpassword = "";
+	}
+	# Get the workgroup, server, and share name
+	if ($parameters =~ m!([^/]*)/([^/]+)/([^/]+)$!) {
+	    $workgroup = $1;
+	    $smbserver = $2;
+	    $smbshare = $3;
+	} elsif ($parameters =~ m!([^/]+)/([^/]+)$!) {
+	    $workgroup = "";
+	    $smbserver = $1;
+	    $smbshare = $2;
+	} else {
+	    die "The \"smb://\" URI must at least contain the server name and the share name!\n";
+	}
+	if (network::is_ip($smbserver)) {
+	    $smbserverip = $smbserver;
+	    $smbserver = "";
+	}
+    }
+
     return if !$in->ask_from_entries_refH(_("SMB (Windows 9x/NT) Printer Options"),
 _("To print to a SMB printer, you need to provide the
 SMB host name (Note! It may be different from its
 TCP/IP hostname!) and possibly the IP address of the print server, as
 well as the share name for the printer you wish to access and any
 applicable user name, password, and workgroup information."), [
-{ label => _("SMB server host"), val => \$printer->{SMBHOST} },
-{ label => _("SMB server IP"), val => \$printer->{SMBHOSTIP} },
-{ label => _("Share name"), val => \$printer->{SMBSHARE} },
-{ label => _("User name"), val => \$printer->{SMBUSER} },
-{ label => _("Password"), val => \$printer->{SMBPASSWD}, hidden => 1 },
-{ label => _("Workgroup"), val => \$printer->{SMBWORKGROUP} }, ],
-					 complete => sub {
-					     unless (network::is_ip($printer->{SMBHOSTIP})) {
-						 $in->ask_warn('', _("IP address should be in format 1.2.3.4"));
-						 return (1,1);
-					     }
-					     return 0;
-					 },
-					);
-    #- make the DeviceURI from DEVICE, try to probe for available variable to build a some suitable URI.
-    #- Yes, SMBWORKGROUP is not used here, seems to be not usefull for cups.
-    $printer->{DeviceURI} = join '', ("smb://",
-				      ($printer->{SMBUSER} && ($printer->{SMBUSER} .
-							       ($printer->{SMBPASSWD} && ":$printer->{SMBPASSWD}") . "@")),
-				      ($printer->{SMBHOST} || $printer->{SMBHOSTIP}),
-				      "/$printer->{SMBSHARE}");
-
-    &$install('samba');
-    $printer->{mode} eq 'CUPS' and printer::restart_queue($printer);
+{ label => _("SMB server host"), val => \$smbserver },
+{ label => _("SMB server IP"), val => \$smbserverip },
+{ label => _("Share name"), val => \$smbshare },
+{ label => _("User name"), val => \$smbuser },
+{ label => _("Password"), val => \$smbpassword, hidden => 1 },
+{ label => _("Workgroup"), val => \$workgroup }, ],
+complete => sub {
+    unless ((network::is_ip($smbserverip)) || ($smbserverip eq "")) {
+	$in->ask_warn('', _("IP address should be in format 1.2.3.4"));
+	return (1,1);
+    }
+    unless (($smbserver ne "") || ($smbserverip ne "")) {
+	$in->ask_warn('', __("Either the server name or the server's IP must be given!"));
+	return (1,0);
+    }
+    unless ($smbshare ne "") {
+	$in->ask_warn('', __("Samba share name missing!"));
+	return (1,2);
+    }
+    return 0;
+}
+    );
+    #- make the DeviceURI from, try to probe for available variable to
+    #- build a suitable URI.
+    $printer->{currentqueue}{'connect'} =
+    join '', ("smb://", ($smbuser && ($smbuser . 
+    ($smbpassword && ":$smbpassword") . "@")), ($workgroup && ("$workgroup/")),
+    ($smbserver || $smbserverip), "/$smbshare");
+
+    &$install('samba-client');
+    $printer->{SPOOLER} eq 'cups' and printer::restart_queue($printer);
     1;
 }
 
 sub setup_ncp($$$) {
     my ($printer, $in, $install) = @_;
 
+    my $uri;
+    my $ncpuser = "";
+    my $ncppassword = "";
+    my $ncpserver = "";
+    my $ncpqueue = "";
+    my $queue = $printer->{OLD_QUEUE};
+    if (($printer->{configured}{$queue}) &&
+	($printer->{currentqueue}{'connect'} =~ m/^ncp:/)) {
+	$uri = $printer->{currentqueue}{'connect'};
+	$uri =~ m!^\s*ncp://(.*)$!;
+	my $parameters = $1;
+	# Get the user's login and password from the URI
+	if ($parameters =~ m!([^@]*)@([^@]+)!) {
+	    my $login = $1;
+	    $parameters = $2;
+	    if ($login =~ m!([^:]*):([^:]*)!) {
+		$ncpuser = $1;
+		$ncppassword = $2;
+	    } else {
+		$ncpuser = $login;
+		$ncppassword = "";
+	    }
+	} else {
+	    $ncpuser = "";
+	    $ncppassword = "";
+	}
+	# Get the workgroup, server, and share name
+	if ($parameters =~ m!([^/]+)/([^/]+)$!) {
+	    $ncpserver = $1;
+	    $ncpqueue = $2;
+	} else {
+	    die "The \"ncp://\" URI must at least contain the server name and the share name!\n";
+	}
+    }
+
     return if !$in->ask_from_entries_refH(_("NetWare Printer Options"),
-_("To print to a NetWare printer, you need to provide the
+_("To print on a NetWare printer, you need to provide the
 NetWare print server name (Note! it may be different from its
 TCP/IP hostname!) as well as the print queue name for the printer you
 wish to access and any applicable user name and password."), [
-{ label => _("Printer Server"), val => \$printer->{NCPHOST} },
-{ label => _("Print Queue Name"), val => \$printer->{NCPQUEUE} },
-{ label => _("User name"), val => \$printer->{NCPUSER} },
-{ label => _("Password"), val => \$printer->{NCPPASSWD}, hidden => 1 } ],
+{ label => _("Printer Server"), val => \$ncpserver },
+{ label => _("Print Queue Name"), val => \$ncpqueue },
+{ label => _("User name"), val => \$ncpuser },
+{ label => _("Password"), val => \$ncppassword, hidden => 1 } ],
+complete => sub {
+    unless ($ncpserver ne "") {
+	$in->ask_warn('', __("NCP server name missing!"));
+	return (1,0);
+    }
+    unless ($ncpqueue ne "") {
+	$in->ask_warn('', __("NCP queue name missing!"));
+	return (1,1);
+    }
+    return 0;
+}
 					);
+    # Generate the Foomatic URI
+    $printer->{currentqueue}{'connect'} =
+    join '', ("ncp://", ($ncpuser && ($ncpuser . 
+    ($ncppassword && ":$ncppassword") . "@")),
+    "$ncpserver/$ncpqueue");
+
     &$install('ncpfs');
     1;
 }
@@ -139,16 +291,42 @@ sub setup_socket($$$) {
     my ($printer, $in, $install) = @_;
     my ($hostname, $port);
 
+    my $uri;
+    my $remotehost;
+    my $remoteport;
+    my $queue = $printer->{OLD_QUEUE};
+    if (($printer->{configured}{$queue}) &&
+	($printer->{currentqueue}{'connect'} =~ m/^socket:/)) {
+	$uri = $printer->{currentqueue}{'connect'};
+	$uri =~ m!^\s*socket://([^/:]+):([0-9]+)/?\s*$!;
+	$remotehost = $1;
+	$remoteport = $2;
+    } else {
+	$remotehost = "";
+	$remoteport = "9100";
+    }
+
     return if !$in->ask_from_entries_refH(_("Socket Printer Options"),
 _("To print to a socket printer, you need to provide the
 hostname of the printer and optionally the port number."), [
-{ label => _("Printer Hostname"), val => \$hostname },
-{ label => _("Port"), val => \$port } ],
+{ label => _("Printer Hostname"), val => \$remotehost },
+{ label => _("Port"), val => \$remoteport } ],
+complete => sub {
+    unless ($remotehost ne "") {
+	$in->ask_warn('', __("Printer host name missing!"));
+	return (1,0);
+    }
+    unless ($remoteport =~ /^[0-9]+$/) {
+	$in->ask_warn('', __("The port must be an integer number!"));
+	return (1,1);
+    }
+    return 0;
+}
 					 );
 
-    #- make the DeviceURI parameters given above, these parameters are not in printer
-    #- structure as only the URI is needed (cups only).
-    $printer->{DeviceURI} = join '', ("socket://$hostname", $port ? (":$port") : ());
+    #- make the Foomatic URI
+    $printer->{currentqueue}{'connect'} = 
+    join '', ("socket://$remotehost", $remoteport ? (":$remoteport") : ());
     1;
 }
 
@@ -156,52 +334,264 @@ sub setup_uri($$$) {
     my ($printer, $in, $install) = @_;
 
     return if !$in->ask_from_entries_refH(_("Printer Device URI"),
-_("You can specify directly the URI to access the printer with CUPS."), [
-{ label => _("Printer Device URI"), val => \$printer->{DeviceURI}, list => [ printer::get_direct_uri(),
-                                                                      "file:/",
-                                                                      "http://",
-                                                                      "ipp://",
-                                                                      "lpq://",
-                                                                      "smb://",
-                                                                      "socket://",
-                                                                    ], not_edit => 0 }, ],
-					 );
-    if ($printer->{DeviceURI} =~ /^smb:/) {
-        &$install('samba');
+__("You can specify directly the URI to access the printer. The URI must fulfill either the CUPS or the Foomatic specifications. Not that not all URI types are supported by all the spoolers."), [
+{ label => _("Printer Device URI"),
+val => \$printer->{currentqueue}{'connect'},
+list => [ $printer->{currentqueue}{'connect'},
+	  "file:/",
+	  "http://",
+	  "ipp://",
+	  "lpd://",
+	  "smb://",
+	  "ncp://",
+	  "socket://",
+	  "postpipe:",
+	  ], not_edit => 0 }, ],
+complete => sub {
+    unless ($printer->{currentqueue}{'connect'} =~ /[^:]+:.+/) {
+	$in->ask_warn('', __("A valid URI must be entered!"));
+	return (1,0);
+    }
+    return 0;
+}
+    );
+    if ($printer->{currentqueue}{'connect'} =~ /^smb:/) {
+        &$install('samba-client');
+        printer::restart_queue($printer);
+    }
+    if ($printer->{currentqueue}{'connect'} =~ /^ncp:/) {
+        &$install('ncpfs');
         printer::restart_queue($printer);
     }
     1;
 }
 
-sub setup_gsdriver($$$;$) {
-    my ($printer, $in, $install, $upNetwork) = @_;
-    for ($printer->{mode}) {
-	/CUPS/ && return setup_gsdriver_cups($printer, $in, $install, $upNetwork);
-	/lpr/  && return setup_gsdriver_lpr($printer, $in, $install, $upNetwork);
-	die "mode not chosen to configure a printer";
+sub setup_postpipe($$$) {
+    my ($printer, $in, $install) = @_;
+
+    my $uri;
+    my $commandline;
+    my $queue = $printer->{OLD_QUEUE};
+    if (($printer->{configured}{$queue}) &&
+	($printer->{currentqueue}{'connect'} =~ m/^postpipe:/)) {
+	$uri = $printer->{currentqueue}{'connect'};
+	$uri =~ m!^\s*postpipe:(.*)$!;
+	$commandline = $1;
+    } else {
+	$commandline = "";
+    }
+
+    return if !$in->ask_from_entries_refH(__("Pipe into command"),
+__("Here you can specify any arbitrary command line into which the job should be piped instead of being sent directly to a printer."), [
+{ label => _("Command line"),
+val => \$commandline }, ],
+complete => sub {
+    unless ($commandline ne "") {
+	$in->ask_warn('', __("A command line must be entered!"));
+	return (1,0);
     }
+    return 0;
 }
+);
 
-sub setup_gsdriver_cups($$$;$) {
+    #- make the Foomatic URI
+    $printer->{currentqueue}{'connect'} = "postpipe:$commandline";
+    
+    1;
+}
+
+sub setup_gsdriver($$$;$) {
     my ($printer, $in, $install, $upNetwork) = @_;
+    #- Read the printer driver database if necessary
+    if ((keys %printer::thedb) == 0) {printer::read_printer_db();}
     my $testpage = "/usr/share/cups/data/testprint.ps";
-
+    my $queue = $printer->{OLD_QUEUE};
     $in->set_help('configurePrinterType') if $::isInstall;
     while (1) {
-	$printer->{cupsDescr} ||= printer::get_descr_from_ppd($printer);
-	$printer->{cupsDescr} = $in->ask_from_treelist('', _("What type of printer do you have?"), '|',
-						       [ keys %printer::descr_to_ppd ], $printer->{cupsDescr}) or return;
-	$printer->{cupsPPD} = $printer::descr_to_ppd{$printer->{cupsDescr}};
-
-	#- install additional tools according to PPD files.
-        $printer->{cupsPPD} =~ /lexmark/i and &$install('ghostscript-utils');
-
+	if ($printer->{configured}{$queue}) {
+	    # The queue was already configured
+	    if ($printer->{configured}{$queue}{'queuedata'}{'foomatic'}) {
+		# The queue was configured with Foomatic
+		my $driverstr;
+		if ($printer->{configured}{$queue}{'driver'} eq "Postscript") {
+		    $driverstr = "PostScript";
+		} else {
+		    $driverstr =
+			"GhostScript + $printer->{configured}{$queue}{'driver'}";
+		}
+		my $make = $printer->{configured}{$queue}{'make'};
+		my $model =
+		    $printer->{configured}{$queue}{'model'};
+		$printer->{DBENTRY} = "$make|$model|$driverstr";
+	    } elsif ($printer->{SPOOLER} eq "cups") {
+		# Do we have a native CUPS driver or a PostScript PPD file?
+		$printer->{DBENTRY} = printer::get_descr_from_ppd($printer) ||
+		    $printer->{DBENTRY};
+	    }
+	}
+	# Choose the printer/driver from the list
+	my $oldchoice = $printer->{DBENTRY};
+	$printer->{DBENTRY} = $in->ask_from_treelist
+	    (__("Printer model selection"),
+	     __("Which printer model do you have?"), '|',
+	     [ keys %printer::thedb ], $printer->{DBENTRY}) or return;
+	$printer->{currentqueue}{'id'} =
+	    $printer::thedb{$printer->{DBENTRY}}{id};
+	$printer->{currentqueue}{'driver'} =
+	    $printer::thedb{$printer->{DBENTRY}}{driver};
+	$printer->{currentqueue}{'make'} =
+	    $printer::thedb{$printer->{DBENTRY}}{make};
+	$printer->{currentqueue}{'model'} =
+	    $printer::thedb{$printer->{DBENTRY}}{model};
+	if ($printer->{currentqueue}{'id'}) {
+	    # We have a Foomatic queue
+	    $printer->{currentqueue}{'foomatic'} = 1;
+	    # Now get the options for this printer/driver combo
+	    if (($printer->{configured}{$queue}) &&
+		($printer->{configured}{$queue}{'queuedata'}{'foomatic'})) {
+		# The queue was already configured with Foomatic ...
+		if ($printer->{DBENTRY} eq $oldchoice) {
+		    # ... and the user didn't change the printer/driver
+		    $printer->{ARGS} = $printer->{configured}{$queue}{'args'};
+		} else {
+		    # ... and the user has chosen another printer/driver
+		    $printer->{ARGS}=printer::read_foomatic_options($printer);
+		}
+	    } else {
+		$printer->{ARGS} = printer::read_foomatic_options($printer);
+	    }
+	    # Set up the widgets for the option dialog
+	    my @widgets;
+	    my @userinputs;
+	    my @choicelists;
+	    my @shortchoicelists;
+	    my $i;
+	    for ($i = 0; $i <= $#{$printer->{ARGS}}; $i++) {
+		my $optshortdefault = $printer->{ARGS}[$i]{'default'};
+		if ($printer->{ARGS}[$i]{'type'} eq 'enum') {
+		    # enumerated option
+		    push(@choicelists, []);
+		    push(@shortchoicelists, []);
+		    my $choice;
+		    for $choice (@{$printer->{ARGS}[$i]{'vals'}}) {
+			push(@{$choicelists[$i]}, $choice->{'comment'});
+			push(@{$shortchoicelists[$i]}, $choice->{'value'});
+			if ($choice->{'value'} eq $optshortdefault) {
+			    push(@userinputs, $choice->{'comment'});
+			}
+		    }
+		    push(@widgets,
+			 { label => $printer->{ARGS}[$i]{'comment'}, 
+			   val => \$userinputs[$i], 
+			   not_edit => 1,
+			   list => \@{$choicelists[$i]} });
+		} elsif ($printer->{ARGS}[$i]{'type'} eq 'bool') {
+		    # boolean option
+		    push(@choicelists, [$printer->{ARGS}[$i]{'name'}, 
+					$printer->{ARGS}[$i]{'name_false'}]);
+		    push(@shortchoicelists, []);
+		    push(@userinputs, $choicelists[$i][1-$optshortdefault]);
+		    push(@widgets,
+			 { label => $printer->{ARGS}[$i]{'comment'},
+			   val => \$userinputs[$i],
+			   not_edit => 1,
+			   list => \@{$choicelists[$i]} });
+		} else {
+		    # numerical option
+		    push(@choicelists, []);
+		    push(@shortchoicelists, []);
+		    push(@userinputs, $optshortdefault);
+		    push(@widgets,
+			 { label => $printer->{ARGS}[$i]{'comment'} . 
+			       " ($printer->{ARGS}[$i]{'min'} ... " .
+			       "$printer->{ARGS}[$i]{'max'})",
+			   #type => 'range',
+			   #min => $printer->{ARGS}[$i]{'min'},
+			   #max => $printer->{ARGS}[$i]{'max'},
+			   val => \$userinputs[$i] } );
+		}
+	    }
+	    # Show the options dialog. The call-back function does a
+	    # range check of the numerical options.
+	    my $windowtitle;
+#	    if ($::expert) {
+		$windowtitle = $printer->{DBENTRY};
+		$windowtitle =~ s/\|/ /;
+		$windowtitle =~ s/\|/, /;
+#	    } else {
+#		$windowtitle = "$printer->{currentqueue}{'make'} " .
+#		    "$printer->{currentqueue}{'model'}"
+#	    }
+	    return if !$in->ask_from_entries_refH
+		($windowtitle,
+		 _("Printer options"), \@widgets,
+		 complete => sub {
+		     my $i;
+		     for ($i = 0; $i <= $#{$printer->{ARGS}}; $i++) {
+			 if (($printer->{ARGS}[$i]{'type'} eq 'int') ||
+			     ($printer->{ARGS}[$i]{'type'} eq 'float')) {
+			     unless
+				 (($printer->{ARGS}[$i]{'type'} eq 'float') ||
+				  ($userinputs[$i] =~ /^[0-9]+$/)) {
+				 $in->ask_warn
+				     ('', __("Option $printer->{ARGS}[$i]{'comment'} must be an integer number!"));
+				 return (1, $i);
+			     }
+			     unless
+				 (($printer->{ARGS}[$i]{'type'} eq 'int') ||
+				  ($userinputs[$i] =~ /^[0-9\.]+$/)) {
+				 $in->ask_warn
+				     ('', __("Option $printer->{ARGS}[$i]{'comment'} must be a number!"));
+				 return (1, $i);
+			     }
+			     unless (($userinputs[$i] >= 
+				      $printer->{ARGS}[$i]{'min'}) &&
+				     ($userinputs[$i] <= 
+				      $printer->{ARGS}[$i]{'max'})) {
+				 $in->ask_warn
+				     ('', __("Option $printer->{ARGS}[$i]{'comment'} out of range!"));
+				 return (1, $i);
+			     }
+			 }
+		     }
+		     return (0);
+		 } );
+	    # Read out the user's choices
+	    @{$printer->{OPTIONS}} = ();
+	    for ($i = 0; $i <= $#{$printer->{ARGS}}; $i++) {
+		push(@{$printer->{OPTIONS}}, "-o");
+		if ($printer->{ARGS}[$i]{'type'} eq 'enum') {
+		    # enumerated option
+		    my $j;
+		    for ($j = 0; $j <= $#{$choicelists[$i]}; $j++) {
+			if ($choicelists[$i][$j] eq $userinputs[$i]) {
+			    push(@{$printer->{OPTIONS}},
+				$printer->{ARGS}[$i]{'name'} .
+				"=". $shortchoicelists[$i][$j]);
+			}
+		    }
+		} elsif ($printer->{ARGS}[$i]{'type'} eq 'bool') {
+		    # boolean option
+		    push(@{$printer->{OPTIONS}},
+				$printer->{ARGS}[$i]{'name'} .
+				"=". 
+				(($choicelists[$i][0] eq $userinputs[$i]) ?
+				 "1" : "0"));
+		} else {
+		    # numerical option
+		    push(@{$printer->{OPTIONS}},
+				$printer->{ARGS}[$i]{'name'} .
+				"=" . $userinputs[$i]);
+		}
+	    }
+	}
+	# print "$printer->{OPTIONS}\n";
+		
 	$printer->{complete} = 1;
-	printer::copy_printer_params($printer, $printer->{configured}{$printer->{QUEUE}} ||= {});
 	printer::configure_queue($printer);
 	$printer->{complete} = 0;
 	
-	if ($in->ask_yesorno('', _("Do you want to test printing?"), 1)) {
+	if ($in->ask_yesorno('', __("Do you want to print a test page?"), 1)) {
 	    my @lpq_output;
 	    {
 		my $w = $in->wait_message('', _("Printing test page(s)..."));
@@ -212,11 +602,11 @@ sub setup_gsdriver_cups($$$;$) {
 
 	    if (@lpq_output) {
 		$in->ask_yesorno('', _("Test page(s) have been sent to the printer daemon.
-This may take a little time before printer start.
+It may take some time before the printer starts.
 Printing status:\n%s\n\nDoes it work properly?", "@lpq_output"), 1) and last;
 	    } else {
 		$in->ask_yesorno('', _("Test page(s) have been sent to the printer daemon.
-This may take a little time before printer start.
+It may take some time before the printer starts.
 Does it work properly?"), 1) and last;
 	    }
 	} else {
@@ -226,294 +616,295 @@ Does it work properly?"), 1) and last;
     $printer->{complete} = 1;
 }
 
-sub setup_gsdriver_lpr($$$;$) {
+sub setup_gsdriver_cups($$$;$) {
     my ($printer, $in, $install, $upNetwork) = @_;
-    my $action;
-    my @action = qw(ascii ps both done);
-    my %action = (
-		  ascii  => _("Yes, print ASCII test page"),
-		  ps     => _("Yes, print PostScript test page"),
-		  both   => _("Yes, print both test pages"),
-		  done   => _("No"),
-		 );
-
-    do {
-	$printer->{DBENTRY} ||= $printer::thedb_gsdriver{$printer->{GSDRIVER}}{ENTRY};
-	$printer->{DBENTRY} = $printer::descr_to_db{
-	    $in->ask_from_list_(_("Configure Printer"),
-				_("What type of printer do you have?"),
-				[ @printer::entry_db_description ],
-				$printer::db_to_descr{$printer->{DBENTRY}},
-                                { %printer::descr_to_help }) || return
-	   };
-	my %db_entry = %{$printer::thedb{$printer->{DBENTRY}}};
-
-	#- specific printer drivers to install.
-	#-&$install('pnm2ppa') if $db_entry{GSDRIVER} eq 'ppa';
-
-	my @list_res = @{$db_entry{RESOLUTION} || []};
-	my @res = map { "$_->{XDPI}x$_->{YDPI}" } @list_res;
-	my @list_col      = @{$db_entry{BITSPERPIXEL} || []};
-	my @col           = map { "$_->{DEPTH} $_->{DESCR}" } @list_col;
-	my %col_to_depth  = map { ("$_->{DEPTH} $_->{DESCR}", $_->{DEPTH}) } @list_col;
-	my %depth_to_col  = reverse %col_to_depth;
-	my $is_uniprint = $db_entry{GSDRIVER} eq "uniprint";
-
-	$printer->{PAPERSIZE} ||= "letter";
-	$printer->{RESOLUTION} = @res ? $res[0] || "Default" : "Default" unless member($printer->{RESOLUTION}, @res);
-	$printer->{ASCII_TO_PS} = $db_entry{GSDRIVER} eq 'POSTSCRIPT' unless defined($printer->{ASCII_TO_PS});
-	$printer->{CRLF} = $db_entry{DESCR} =~ /HP/ unless defined($printer->{CRLF});
-	$printer->{BITSPERPIXEL} = @list_col ? $depth_to_col{$printer->{BITSPERPIXEL}} || $col[0] : "Default";
-	$printer->{NUP} = 1 unless member($printer->{NUP}, qw(1 2 4 8));
-	$printer->{RTLFTMAR} = 18 unless $printer->{RTLFTMAR} =~ /^\d+$/;
-	$printer->{TOPBOTMAR} = 18 unless $printer->{TOPBOTMAR} =~ /^\d+$/;
-	$printer->{EXTRA_GS_OPTIONS} =~ s/^"(.*)"/$1/;
-	$printer->{TEXTONLYOPTIONS} =~ s/^"(.*)"/$1/;
-
-	return if !$in->ask_from_entries_refH('', _("Printer options"), [
-{ label => _("Paper Size"), val => \$printer->{PAPERSIZE}, type => 'list', not_edit => !$::expert, list => \@printer::papersize_type },
-{ label => _("Eject page after job?"), val => \$printer->{AUTOSENDEOF}, type => 'bool' },
-  if_(@list_res > 1,
-{ label => _("Resolution"), val => \$printer->{RESOLUTION}, type => 'list', not_edit => !$::expert, list => \@res },
-  ), if_(@list_col > 1,
-     $is_uniprint ?
-{ label => _("Uniprint driver options"), val => \$printer->{BITSPERPIXEL}, type => 'list', list => \@col } :
-{ label => _("Color depth options"), val => \$printer->{BITSPERPIXEL}, type => 'list', list => \@col }
-  ), if_($db_entry{GSDRIVER} ne 'TEXT' && $db_entry{GSDRIVER} ne 'POSTSCRIPT' && $db_entry{GSDRIVER} ne 'ppa',
-{ label => _("Print text as PostScript?"), val => \$printer->{ASCII_TO_PS}, type => 'bool' },
-  ), if_($db_entry{GSDRIVER} ne 'POSTSCRIPT',
-{ label => _("Fix stair-stepping text?"), val => \$printer->{CRLF}, type => 'bool' },
-  ), if_($db_entry{GSDRIVER} ne 'TEXT',
-{ label => _("Number of pages per output pages"), val => \$printer->{NUP}, type => 'list', not_edit => !$::expert, list => [1,2,4,8] },
-{ label => _("Right/Left margins in points (1/72 of inch)"), val => \$printer->{RTLFTMAR} },
-{ label => _("Top/Bottom margins in points (1/72 of inch)"), val => \$printer->{TOPBOTMAR} },
-  ), if_($::expert && $db_entry{GSDRIVER} ne 'TEXT' && $db_entry{GSDRIVER} ne 'POSTSCRIPT',
-{ label => _("Extra GhostScript options"), val => \$printer->{EXTRA_GS_OPTIONS} },
-  ), if_($::expert && $db_entry{GSDRIVER} ne 'POSTSCRIPT',
-{ label => _("Extra Text options"), val => \$printer->{TEXTONLYOPTIONS} },
-  ),
-#+ { label => _("Reverse page order"), val => \$printer->{REVERSE_ORDER}, type => 'bool' },
-]);
-
-        $printer->{BITSPERPIXEL} = $col_to_depth{$printer->{BITSPERPIXEL}} || $printer->{BITSPERPIXEL}; #- translate back.
+    my $testpage = "/usr/share/cups/data/testprint.ps";
+    $in->set_help('configurePrinterType') if $::isInstall;
+    while (1) {
+	$printer->{cupsDescr} ||= printer::get_descr_from_ppd($printer);
+	$printer->{cupsDescr} = $in->ask_from_treelist('', _("What type of printer do you have?"), '|',
+						       [ keys %printer::descr_to_ppd ], $printer->{cupsDescr}) or return;
+	$printer->{cupsPPD} = $printer::descr_to_ppd{$printer->{cupsDescr}};
+
+	#- install additional tools according to PPD files.
+        $printer->{cupsPPD} =~ /lexmark/i and &$install('ghostscript-utils');
 
 	$printer->{complete} = 1;
 	printer::copy_printer_params($printer, $printer->{configured}{$printer->{QUEUE}} ||= {});
 	printer::configure_queue($printer);
 	$printer->{complete} = 0;
 	
-	$action = $in->ask_from_listf('', _("Do you want to test printing?"), sub { $action{$_[0]} }, \@action, 'done') or return;
-
-	my @testpages;
-	push @testpages, "/usr/lib/rhs/rhs-printfilters/testpage.asc"
-	  if $action eq "ascii" || $action eq "both";
-	push @testpages, "/usr/lib/rhs/rhs-printfilters/testpage". ($printer->{PAPERSIZE} eq 'a4' && '-a4') .".ps"
-	  if $action eq "ps" || $action eq "both";
-
-	if (@testpages) {
+	if ($in->ask_yesorno('', _("Do you want to test printing?"), 1)) {
 	    my @lpq_output;
 	    {
 		my $w = $in->wait_message('', _("Printing test page(s)..."));
 
 		$upNetwork and do { &$upNetwork(); undef $upNetwork; sleep(1) };
-		printer::restart_queue($printer);
-		@lpq_output = printer::print_pages($printer, @testpages);
+		@lpq_output = printer::print_pages($printer, $testpage);
 	    }
 
 	    if (@lpq_output) {
-		$action = $in->ask_yesorno('', _("Test page(s) have been sent to the printer daemon.
+		$in->ask_yesorno('', _("Test page(s) have been sent to the printer daemon.
 This may take a little time before printer start.
-Printing status:\n%s\n\nDoes it work properly?", "@lpq_output"), 1) ? 'done' : 'change';
+Printing status:\n%s\n\nDoes it work properly?", "@lpq_output"), 1) and last;
 	    } else {
-		$action = $in->ask_yesorno('', _("Test page(s) have been sent to the printer daemon.
+		$in->ask_yesorno('', _("Test page(s) have been sent to the printer daemon.
 This may take a little time before printer start.
-Does it work properly?"), 1) ? 'done' : 'change';
+Does it work properly?"), 1) and last;
 	    }
+	} else {
+	    last;
 	}
-    } while ($action ne 'done');
+    }
     $printer->{complete} = 1;
 }
 
+sub setup_default_spooler ($$) {
+    my ($printer, $in) = @_;
+    $printer->{SPOOLER} ||= 'cups';
+    my $str_spooler = 
+	$in->ask_from_list_(__("Select Printer Spooler"),
+			    __("Which printing system (spooler) do you want to use?"),
+			    [ printer::spooler() ],
+			    $printer::spooler_inv{$printer->{SPOOLER}},
+			    ) or return;
+    $printer->{SPOOLER} = $printer::spooler{$str_spooler};
+    # Get the queues of this spooler
+    printer::read_configured_queues($printer);
+    return $printer->{SPOOLER};
+}
+
 #- Program entry point for configuration with lpr or cups (stored in $mode).
 sub main($$$$;$) {
     my ($printer, $in, $ask_multiple_printer, $install, $upNetwork) = @_;
-    my ($queue, $continue) = ('', 1);
 
+    # printerdrake does not work without foomatic
+    &$install('foomatic') unless $::testing;
+
+    !$::expert && ($printer->{SPOOLER} ||= 'cups'); # only experts should be asked
+                                                 # for the spooler
+    my ($queue, $continue) = ('', 1);
     while ($continue) {
 	if (!$ask_multiple_printer && %{$printer->{configured} || {}} == ()) {
-	    $queue = $printer->{want} || $in->ask_yesorno(_("Printer"),
-							  _("Would you like to configure a printer?"), 0) ? 'lp' : 'Done';
+	    $queue = $printer->{want} || 
+		$in->ask_yesorno(_("Printer"),
+				 __("Would you like to configure printing?"),
+				 0) ? 'lp' : 'Done';
+	    $printer->{SPOOLER} ||= setup_default_spooler ($printer, $in) ||
+		return;
+	    
 	} else {
-	    unless (%{$printer->{configured} || {}} == ()) {
+	    # Ask for a spooler when noone is defined
+	    $printer->{SPOOLER} ||= setup_default_spooler ($printer, $in) ||
+		return;
+	    # Show a queue list window when there is at least one queue
+	    # or when we are in expert mode
+	    unless ((%{$printer->{configured} || {}} == ()) && (!$::expert)) {
 		$in->ask_from_entries_refH_powered(
-						   {
-						    messages =>
-_("Here are the following print queues.
-You can add some more or change the existing ones."),
-						    cancel => '',
-						   }, [ { val => \$queue, format => \&translate,
-							  list => [ (sort keys %{$printer->{configured} || {}}),
-								    __("Add"), __("Done") ] } ]
-						  );
-	    } else { $queue = 'Add' } #- as there are no printer already configured, Add one automatically.
-	    if ($queue eq 'Add') {
-		my %queues; @queues{map { split '\|', $_ } keys %{$printer->{configured}}} = ();
+		    {messages =>
+                      _("Here are the following print queues.
+                      You can add some more or change the existing ones."),
+		      cancel => '',
+		    },
+		    # List the queues
+                    [ { val => \$queue, format => \&translate,
+		        list => [ (sort keys %{$printer->{configured} || {}}),
+		    # Button to add a new queue
+		    __("Add queue"),
+		    # In expert mode we can change the spooler
+		    ($::expert ?
+		     ( __("Spooler: ") .
+		       $printer::spooler_inv{$printer->{SPOOLER}} ) : ()),
+		    # Bored by configuring your printers, get out of here!
+		    __("Done") ] } ]
+		);
+	    } else { $queue = 'Add queue' }  #- as there are no printers 
+	                                     #- already configured, Add one
+	                                     #- automatically.
+	    if ($queue eq 'Add queue') {
+		my %queues; 
+		@queues{map { split '\|', $_ } keys %{$printer->{configured}}} = ();
 		my $i = ''; while ($i < 100) { last unless exists $queues{"lp$i"}; ++$i; }
 		$queue = "lp$i";
 	    }
+	    if ($queue =~ /^Spooler: /) {
+		$printer->{SPOOLER} =
+		    setup_default_spooler ($printer, $in) || $printer->{SPOOLER};
+		next;
+	    }
 	}
+	# Save the default spooler
+	printer::set_default_spooler($printer);
+	#- Close printerdrake
 	$queue eq 'Done' and last;
 
-	#- switch according to what is being installed: cups, lpr or other.
-	for ($printer->{mode}) {
-	    /CUPS/ && do { &$install('cups-drivers') unless $::testing;
-			   my $w = $in->wait_message(_("CUPS starting"), _("Reading CUPS drivers database..."));
-			   printer::poll_ppd_base(); last };
-	    /lpr/  && do { &$install('rhs-printfilters') unless $::testing;
-			   printer::read_printer_db(); last };
-	}
-
-	printer::copy_printer_params($printer->{configured}{$queue}, $printer) if $printer->{configured}{$queue};
-	$printer->{OLD_QUEUE} = $printer->{QUEUE} = $queue; #- keep in mind old name of queue (in case of changing)
+	#- Install the printer driver database
+	#for ($printer->{SPOOLER}) {
+	#    /CUPS/ && do { &$install('cups-drivers') unless $::testing;
+	#		   my $w = $in->wait_message(_("CUPS starting"), _("Reading CUPS drivers database..."));
+	#		   printer::poll_ppd_base(); last };
+	#}
+
+	#- Copy the queue data and work on the copy
+	$printer->{currentqueue} = {};
+	printer::copy_printer_params
+	    ($printer->{configured}{$queue}{'queuedata'},
+	     $printer->{currentqueue})
+	    if $printer->{configured}{$queue};
+	#- keep in mind old name of queue (in case of changing)
+	$printer->{OLD_QUEUE} = $printer->{QUEUE} = $queue;
 
 	while ($continue) {
 	    $in->set_help('configurePrinterConnected') if $::isInstall;
-	    $printer::printer_type_inv{$printer->{TYPE}} or $printer->{TYPE} = printer::default_printer_type($printer);
-	    $printer->{str_type} = $printer::printer_type_inv{$printer->{TYPE}};
-	    if ($printer->{mode} eq 'CUPS') {
-		$printer->{str_type} = $in->ask_from_list_(_("Select Printer Connection"),
-							   _("How is the printer connected?"),
-							   [ printer::printer_type($printer) ],
-							   $printer->{str_type},
-							  ) or return;
-		$printer->{TYPE} = $printer::printer_type{$printer->{str_type}};
-		if ($printer->{TYPE} eq 'REMOTE') {
-		    $printer->{str_type} = $printer::printer_type_inv{CUPS};
-		    $printer->{str_type} = $in->ask_from_list_(_("Select Remote Printer Connection"),
-_("With a remote CUPS server, you do not have to configure
-any printer here; printers will be automatically detected.
-In case of doubt, select \"Remote CUPS server\"."),
-							       [ @printer::printer_type_inv{qw(CUPS LPD SOCKET)} ],
-							       $printer->{str_type},
-							      ) or return;
-		    $printer->{TYPE} = $printer::printer_type{$printer->{str_type}};
-		}
-		if ($printer->{TYPE} eq 'CUPS') {
-		    #- hack to handle cups remote server printing,
-		    #- first read /etc/cups/cupsd.conf for variable BrowsePoll address:port
-		    my @cupsd_conf = printer::read_cupsd_conf();
-		    my ($server, $port);
-
-		    foreach (@cupsd_conf) {
-			/^\s*BrowsePoll\s+(\S+)/ and $server = $1, last;
+	    if ($printer->{configured}{$queue}) {
+		#- Which printer type did we have before (check beginning of 
+		#- URI)
+		my $type;
+		for $type (qw(file lpd socket smb ncp postpipe)) {
+		    if ($printer->{currentqueue}{'connect'}
+			=~ /^$type:/) {
+			$printer->{TYPE} = 
+			    ($type eq 'file' ? 'LOCAL' : uc($type));
+			last;
 		    }
-		    $server =~ /([^:]*):(.*)/ and ($server, $port) = ($1, $2);
-
-		    #- then ask user for this combination
-		    #- and rewrite /etc/cups/cupsd.conf according to new settings.
-		    #- there are no other point where such information is written in this file.
-		    if ($in->ask_from_entries_refH(_("Remote CUPS server"),
+		}
+	    } else {
+		#- Set default values for a new queue
+		$printer::printer_type_inv{$printer->{TYPE}} or 
+		    $printer->{TYPE} = printer::default_printer_type($printer);
+		$printer->{currentqueue}{'queue'} = $queue;
+		$printer->{currentqueue}{'foomatic'} = 0;
+		$printer->{currentqueue}{'desc'} = "";
+		$printer->{currentqueue}{'loc'} = "";
+		$printer->{currentqueue}{'spooler'} =
+		    $printer->{SPOOLER};
+	    }
+	    $printer->{str_type}=$printer::printer_type_inv{$printer->{TYPE}};
+	    $printer->{str_type} = 
+		$in->ask_from_list_(_("Select Printer Connection"),
+				    _("How is the printer connected?"),
+				    [ printer::printer_type($printer) ],
+				    $printer->{str_type},
+				    ) or return;
+	    $printer->{TYPE} = $printer::printer_type{$printer->{str_type}};
+#	    if ($printer->{TYPE} eq 'REMOTE') {
+#		$printer->{str_type} = $printer::printer_type_inv{CUPS};
+#		$printer->{str_type} = 
+#		    $in->ask_from_list_(_("Select Remote Printer Connection"),
+#_("With a remote CUPS server, you do not have to configure
+#any printer here; printers will be automatically detected.
+#In case of doubt, select \"Remote CUPS server\"."),
+#					[ @printer::printer_type_inv{qw(CUPS LPD SOCKET)} ],
+#					$printer->{str_type},
+#					) or return;
+#		$printer->{TYPE} = $printer::printer_type{$printer->{str_type}};
+#	    }
+	    if ($printer->{TYPE} eq 'CUPS') {
+		#- hack to handle cups remote server printing,
+		#- first read /etc/cups/cupsd.conf for variable BrowsePoll address:port
+		my @cupsd_conf = printer::read_cupsd_conf();
+		my ($server, $port);
+		
+		foreach (@cupsd_conf) {
+		    /^\s*BrowsePoll\s+(\S+)/ and $server = $1, last;
+		}
+		$server =~ /([^:]*):(.*)/ and ($server, $port) = ($1, $2);
+		
+		#- then ask user for this combination
+		#- and rewrite /etc/cups/cupsd.conf according to new settings.
+		#- there are no other point where such information is written in this file.
+		if ($in->ask_from_entries_refH
+		    (_("Remote CUPS server"),
 _("With a remote CUPS server, you do not have to configure
 any printer here; printers will be automatically detected
 unless you have a server on a different network; in the
 latter case, you have to give the CUPS server IP address
-and optionally the port number."), [
-{ label => _("CUPS server IP"), val => \$server },
-{ label => _("Port"), val => \$port } ],
-						   complete => sub {
-						       unless (!$server || network::is_ip($server)) {
-							   $in->ask_warn('', _("IP address should be in format 1.2.3.4"));
-							   return (1,0);
-						       }
-						       if ($port !~ /^\d*$/) {
-							   $in->ask_warn('', _("Port number should be numeric"));
-							   return (1,1);
-						       }
-						       return 0;
-						   },
-						   )) {
-			$server && $port and $server = "$server:$port";
-			if ($server) {
-			    @cupsd_conf = map { $server and s/^\s*BrowsePoll\s+(\S+)/BrowsePoll $server/ and $server = '';
-						$_ } @cupsd_conf;
-			    $server and push @cupsd_conf, "\nBrowsePoll $server\n";
-			} else {
-			    @cupsd_conf = map { s/^\s*BrowsePoll\s+(\S+)/\#BrowsePoll $1/;
-						$_ } @cupsd_conf;
-			}
-		        printer::write_cupsd_conf(@cupsd_conf);
+and optionally the port number."),
+		     [
+		      { label => _("CUPS server IP"), val => \$server },
+		      { label => _("Port"), val => \$port } ],
+		     complete => sub {
+			 unless (!$server || network::is_ip($server)) {
+			     $in->ask_warn('', _("IP address should be in format 1.2.3.4"));
+			     return (1,0);
+			 }
+			 if ($port !~ /^\d*$/) {
+			     $in->ask_warn('', _("Port number should be numeric"));
+			     return (1,1);
+			 }
+			 return 0;
+		     },
+		     )) {
+		    $server && $port and $server = "$server:$port";
+		    if ($server) {
+			@cupsd_conf = map { $server and s/^\s*BrowsePoll\s+(\S+)/BrowsePoll $server/ and $server = '';
+					    $_ } @cupsd_conf;
+			$server and push @cupsd_conf, "\nBrowsePoll $server\n";
+		    } else {
+			@cupsd_conf = map { s/^\s*BrowsePoll\s+(\S+)/\#BrowsePoll $1/;
+					    $_ } @cupsd_conf;
 		    }
-		    return; #- exit printer configuration, here is another hack for simplification.
+		    printer::write_cupsd_conf(@cupsd_conf);
 		}
-		$in->set_help('configurePrinterLocal') if $::isInstall;
-		$in->ask_from_entries_refH_powered(
-                    { title => _("Select Printer Connection"),
-		      cancel => !$printer->{configured}{$printer->{QUEUE}} ? '' : _("Remove queue"),
-		      callbacks => { complete => sub {
-					 unless ($printer->{QUEUE} =~ /^\w+[\w\|]*\w+$/) {
-					     $in->ask_warn('', _("Name of printer should contains only letters, numbers and the underscore"));
-					     return (1,0);
-					 }
-					 return 0;
-				     },
-				   },
-		      messages =>
-_("Every printer need a name (for example lp).
-Other parameters such as the description of the printer or its location
-can be defined. What name should be used for this printer and
-how is the printer connected?") }, [
-{ label => _("Name of printer"), val => \$printer->{QUEUE} },
-{ label => _("Description"), val => \$printer->{Info} },
-{ label => _("Location"), val => \$printer->{Location} },
-                                   ]) or printer::remove_queue($printer), $continue = 1, last;
-	    } else {
-		if (!$::expert) {
-		    $printer->{str_type} = $in->ask_from_list_(_("Select Printer Connection"),
-							       _("How is the printer connected?"),
-							       [ printer::printer_type($printer) ],
-							       $printer->{str_type},
-							      ) or return;
-		} else {
-		    $in->set_help('configurePrinterLPR') if $::isInstall;
-		    $in->ask_from_entries_refH_powered(
-		        { title => _("Select Printer Connection"), 
-			  cancel => $::expert ? _("Remove queue") : '',
-			  messages =>
-_("Every print queue (which print jobs are directed to) needs a
-name (often lp) and a spool directory associated with it. What
-name and directory should be used for this queue and how is the printer connected?"),
-			  callbacks => { changed => sub {
-					     $printer->{SPOOLDIR} = printer::default_spooldir($printer) unless $_[0];
-					 } }
-		        }, [
-{ label => _("Name of queue"), val => \$printer->{QUEUE} },
-{ label => _("Spool directory"), val => \$printer->{SPOOLDIR} },
-{ label => _("Printer Connection"), val => \$printer->{str_type}, list => [ printer::printer_type($printer) ] },
-]) or printer::remove_queue($printer), $continue = 1, last;
-		}
-		$printer->{TYPE} = $printer::printer_type{$printer->{str_type}};
+		return; #- exit printer configuration, here is another hack for simplification.
 	    }
-
+	    # Name, description, location
+	    $in->set_help('configurePrinterLocal') if $::isInstall;
+	    $in->ask_from_entries_refH_powered
+		(
+		 { title => __("Enter Printer Name and Comments"),
+		   cancel => !$printer->{configured}{$queue} ? '' : _("Remove queue"),
+		   callbacks => { complete => sub {
+		       unless ($printer->{currentqueue}{'queue'} =~ /^\w+$/) {
+			   $in->ask_warn('', _("Name of printer should contain only letters, numbers and the underscore"));
+			   return (1,0);
+		       }
+		       return 0;
+		   },
+			      },
+		   messages =>
+__("Every printer needs a name (for example lp).
+The Description and Location fields do not need 
+to be filled in. They are comments for the users.") }, 
+		 [
+		  { label => _("Name of printer"),
+		    val => \$printer->{currentqueue}{'queue'} },
+		  { label => _("Description"),
+		    val => \$printer->{currentqueue}{'desc'} },
+		  { label => _("Location"),
+		    val => \$printer->{currentqueue}{'loc'} },
+		  ]) or 
+	    printer::remove_queue($printer, $printer->{currentqueue}{'queue'}),
+		      $continue = 1, last;
+
+	    $printer->{QUEUE} = $printer->{currentqueue}{'queue'};
 	    $continue = 0;
 	    for ($printer->{TYPE}) {
 		/LOCAL/     and setup_local    ($printer, $in, $install) and last;
-		/LPD/       and setup_remote   ($printer, $in, $install) and last;
+		/LPD/       and setup_lpd      ($printer, $in, $install) and last;
 		/SOCKET/    and setup_socket   ($printer, $in, $install) and last;
 		/SMB/       and setup_smb      ($printer, $in, $install) and last;
 		/NCP/       and setup_ncp      ($printer, $in, $install) and last;
 		/URI/       and setup_uri      ($printer, $in, $install) and last;
+		/POSTPIPE/  and setup_postpipe ($printer, $in, $install) and last;
 		$continue = 1; last;
 	    }
 	}
-
 	#- configure specific part according to lpr/cups.
 	if (!$continue && setup_gsdriver($printer, $in, $install, $printer->{TYPE} !~ /LOCAL/ && $upNetwork)) {
+	    if (lc($printer->{QUEUE}) ne lc($printer->{OLD_QUEUE})) {
+		printer::remove_queue($printer, $printer->{OLD_QUEUE});
+	    }
 	    delete $printer->{OLD_QUEUE}
-		if $printer->{QUEUE} ne $printer->{OLD_QUEUE} && $printer->{configured}{$printer->{QUEUE}};
+	    if $printer->{QUEUE} ne $printer->{OLD_QUEUE} && $printer->{configured}{$printer->{QUEUE}};
 	    $continue = $::expert;
 	} else {
 	    $continue = 1;
 	}
+	if ($continue) {
+	    # Reinitialize $printer data structure
+	    printer::resetinfo($printer);
+	}
     }
 }
 
diff --git a/perl-install/standalone/printerdrake b/perl-install/standalone/printerdrake
index c6f9d90a6..5f9277f12 100755
--- a/perl-install/standalone/printerdrake
+++ b/perl-install/standalone/printerdrake
@@ -38,12 +38,22 @@ $::noauto = /-noauto/;
 $::skiptest = /-skiptest/;
 $::testing = /-testing/;
 
-my $printer; eval { $printer = printer::getinfo('') };
-/-lpr/ and $printer->{mode} = 'lpr';
-/-cups/ and $printer->{mode} = 'CUPS';
-$printer->{mode} ||= 'CUPS'; #- assume this default if nothing found.
+my $printer;
+# Get what was installed before
+eval { $printer = printer::getinfo('') };
+# Choose the spooler by command line options
+/-cups/ and
+    $printer->{mode} = 'cups' and printer::read_configured_queues($printer);
+/-lpr/ and 
+    $printer->{mode} = 'lpd' and printer::read_configured_queues($printer);
+/-lpd/ and 
+    $printer->{mode} = 'lpd' and printer::read_configured_queues($printer);
+/-lprng/ and 
+    $printer->{mode} = 'lprng' and printer::read_configured_queues($printer);
+/-pdq/ and 
+    $printer->{mode} = 'pdq' and printer::read_configured_queues($printer);
 
-my $in = vnew interactive('su', 'printer');
+my $in = vnew interactive('printer', 'su');
 
 -r '/etc/modules.conf' and modules::mergein_conf('/etc/modules.conf');