#!/usr/bin/perl -w
# -*-perl-*-
##################################################################
# "P4CGI" perl module.
#
# This package is documented using perlpod. 
#
package P4CGI ;

###
# You might need to uncomment and modify this to set the lib 
# to point to the perl libraries.
#
#use lib '/usr/local/lib/perl5/site_perl' ;

###
# Specify configuration file path
#
sub ConfigFileName()
{
    return "./P4DB.conf" ; # Change here to move or rename configuration file
}

use CGI ;
use CGI::Carp ;
use strict;


# A feeble attempt to fence off the most blatant DOS attacks.
$CGI::POST_MAX=1024 * 100;  # max 100K posts
$CGI::DISABLE_UPLOADS = 1;  # no uploads


#### Conficuration file name
my $CONFIG_FILE ;

#### Store error information

my @ERRLOG ; ## Error log
my $ERRORS ; ## Error counter

#### The following variables are set or updated by the init() routine.

my $CGI;			# Contains CGI object from CGI.pm 

   # Constants 
my $VERSION ;			# P4DB version
my $CHANGELEVEL ;		# P4 change level for relesed version
my $REQUIRED_SERVER_VERSION_YEAR ; # Required server version year
my $REQUIRED_SERVER_VERSION_NUMBER ; # Required server version number
my $STYLE_SHEET ;		# Style sheet file name
my $HELPFILE_PATH;		# Path to help file (html) ### OBSOLETE???


   # Information read from p4 depot:
my $LASTCHANGE ;  	        # Current change level
my $SERVER_VERSION_YEAR ;	# Server year
my $SERVER_VERSION_NO ;		# Server count
my $SERVER_VERSION_QUAL ;	# Server version qualifier
my $SERVER_VERSION_CHANGE ;	# Server change No.
my $NO_CONTACT_ERROR ;		# Defined if problem with 

   # Information from configuration file.a
my %CONF ;		        # Hash containing configuration
my $P4 ;			# Contains p4 command
my $PORT;			# Contains p4 port
my $P4_HOSTNAME;		# Contains p4 host name
my $UNUSEDCLIWL ;               # Unused client warning level (from configuration file)
my $UNUSEDUSRWL ;               # Unused user warning level (from configuration file)
my $REDIRECT_ERROR_TO_NULL_DEVICE; # Command that redirects errors to /dev/null
my $REDIRECT_ERROR_TO_STDOUT;   # Command that redirects errors to stdout
my @P4DBadmin ;	                # Admins for P4DB and Perforce server

   # Information store in cookies (user preferences etc).
my %SHORTCUTS ; 		# Shortcuts (from cookie)
my %PREF ;			# Current user preferences
my %PREF_LIST ;			# List of available preferences
my $IGNORE_CASE;		# "YES" if case should be ignored
my $MAX_CHANGES;		# Max changes for change list
my $TAB_SIZE;			# Tab size for file viewer
my $DEBUG ;			# Debug mode, When true, prints log (from preferences)

   # Misc info.
my $LEGEND ;			# Legend supplied to header (from CGi script)

#### Other package variables

my $pageStartPrinted ;		# Mark that html header is printed
                                # Used to avoid mutliple headers if an error occurres

my %EXTRAHEADER ;
my $ONLOADSCRIPT ;
my $helpTarget ;		# target for help text
my $printHeaderButtons ;


###
### Subroutine that prints the error log
###
sub prerrlog() {
    my $res = "" ;
    if(@ERRLOG> 0) {
	map { 
	    if(/^ERROR:/) { $_ = "<font color=red>" . &htmlEncode($_) . "</font>" ; } 
	    else { $_ = "<font color=blue>" . &htmlEncode($_) . "</font>" ; } 
	  }  @ERRLOG ;
	$res .= 
	    "<p><font color=blue>Log printout:<br><pre>" .
	    $CGI->self_url() .
	    join("\n",@ERRLOG) .
	    "</pre></font>\n" ;
    } ;    
    return $res ;
}

###
### Initialization code, called from BEGIN().
###
sub init( )
{
    $printHeaderButtons="Y" ;

    # We require server from 2001 or newer
    #
    $REQUIRED_SERVER_VERSION_YEAR = 2002 ;
    $REQUIRED_SERVER_VERSION_NUMBER = 2 ;

    # Set config file name
    #
    $CONFIG_FILE = &ConfigFileName() ;

			## death handler
    $SIG{'__DIE__'} = sub {	# Thank you Ron Shalhoup for the tip
	my($error) = shift; 
	&P4CGI::bail("Signal caught: $error") ;	
	exit 0; 
    }; 

    # clear error counter
    #
    $ERRORS = 0 ;

    # Set P4DB version
    #
    $VERSION="3.1b1" ;
    $CHANGELEVEL=4018 ;

    # Set some configuration defaults
    #
    $HELPFILE_PATH     = "./" ;
    $UNUSEDCLIWL       = 10 ;
    $UNUSEDUSRWL       = 10 ;
    
    # Initiate CGI module 
    #
    $CGI = new CGI ;
    $CGI->autoEscape(undef) ;

    # Setup list of preferences
    #
    %PREF_LIST = 
	(
	 "DP"   => ["a:LIST","P4 Depot",                       0],
	 "IC"   => ["d:BOOL","Ignore case",                    0],
	 "MX"   => ["d:INT" ,"Max changes to show",          400],
	 "TB"   => ["d:INT" ,"Default tab stop",               8],
	 "HD"   => ["e:BOOL","Hide deleted files by default",  0],
	 "VC"   => ["f:BOOL","View files with colors",         1],
	 "ST"   => ["f:LIST","Style Sheet File",               0],
	 "PH"   => ["f:LIST","Header style",                   0,"Pulldown Menues","Text Links"],
# Comment out line below to disable log printouts completely.
	 "DBG"  => ["z:BOOL","Print log information (debug)",  0],
	 ) ;
    
    # Read user preferences
    #
    %PREF=$CGI->cookie(-name=>"P4DB_PREFERENCES") ; # First try cookie...
    my $p ;    
    foreach $p (keys %PREF_LIST) { # Fill in defaults for those missing in cookie
	if(! defined $PREF{$p}) { 
	    $PREF{$p} = $ {$PREF_LIST{$p}}[2];
	    ERRLOG("Set default for $p!") ;
	}
    }  ;
    foreach $p (keys %PREF) { 	# Check that all specified prefereces really exists...
	if(exists $PREF_LIST{$p}) {
	    ERRLOG("PREF: $p => $PREF{$p} (${$PREF_LIST{$p}}[1])") ;
	}
	else {
	    delete $PREF{$p} ;
	} ;
    } ;    
    # If new preferences are specified, parse and modify
    if(defined $CGI->param("SET_PREFERENCES")) {
	my $c ;
	foreach $c (keys %PREF) {
	    my $val =  $CGI->param($c) ;
	    if(defined $val) {
		$CGI->delete($c) ;
		my $type = $ {$PREF_LIST{$c}}[0] ;
		if($type eq "INT") {  $val =~ /^\d+$/ or next ;	} ;
		if($type eq "BOOL") { $val =~ /^[01]$/ or next ; } ;
		if($c eq "DP" and
		   $PREF{$c} != $val) {
		    # if we get here the user as modified depot, we should restart with index.cgi
		    &ONLOADSCRIPT("location='index.cgi';") ;
		    $CGI->delete("SET_PREFERENCES") ; # To stop SetPreferences.cgi from replacing the ONLOADSCRIPT
		}
		$PREF{$c} = $val ;
	    }
	}
    }

    # Set up data structure for configuration file
    #
    my %configReaderData = ( "P4PATH"                        => \$P4,
			     "HTML_HELPFILE_PATH"            => \$HELPFILE_PATH,
			     "P4DB_ADMIN"                    => \@P4DBadmin,
			     "SHELL"                         => \$ENV{"SHELL"},
			     "REDIRECT_ERROR_TO_NULL_DEVICE" => \$REDIRECT_ERROR_TO_NULL_DEVICE,
			     "REDIRECT_ERROR_TO_STDOUT"      => \$REDIRECT_ERROR_TO_STDOUT,
			     "DEPOT"                         => $PREF_LIST{"DP"},
			     "STYLES"                        => $PREF_LIST{"ST"},
			     "UNUSED_CLIENT_WARNING_LEVEL"   => \$UNUSEDCLIWL,
			     "UNUSED_USER_WARNING_LEVEL"     => \$UNUSEDUSRWL
			     ) ;
    
    # Read configuration file 
    #
    local *F ;
    my $line = 0 ;
    open(F,"<$CONFIG_FILE") or &P4CGI::bail("Could not open config file \"$CONFIG_FILE\" for read") ;   
    while(<F>) {
	$line++ ;
	chomp ;			# Remove newline
	s/^\s+// ;		# Remove leading spaces
	next if (/^\#/ or /^\s*$/) ; # Skip if comment or empty line
	s/\s+/ /g ;		# Normalize all spaces to a single space
	s/ $// ;		# Remove trailing spaces

				# Check syntax and get data
	/^(\S+):\s*(.*)/ or 
	    &P4CGI::bail("Parse error in config file \"$CONFIG_FILE\" line $line:\n\"$_\"") ;
				# Get values
	my ($res,$val) = ($1,$2);
				# Make sure configuration exist
	if(! exists $configReaderData{$res}) {
	    &P4CGI::bail("Parse error in config file \"$CONFIG_FILE\" line $line:\n\"$_\"") ;
	} ;
				# Get config value and check type
	my $ref = $configReaderData{$res} ;
	my $type = ref($ref) ;
	$type eq "SCALAR" and do { $$ref = $val ; ERRLOG("$res=$val") ; next ; } ;
	$type eq "ARRAY" and do {
	    if($res =~ /^\@/) {
		push @$ref,split /\s+/,$val ;
	    }
	    else {
		push @$ref,$val ;
	    } ;
# Security note: any user can se p4 user and password in log. Uncomment for debug only.
#	    ERRLOG("push $res,$val") ; 
	    next ;
	} ;
	&P4CGI::bail("Illegal config type $type line $line:\n\"$_\"") ;	
    }
    close F ;

    # Set port and p4 command
    #
    $PORT = $ {$PREF_LIST{"DP"}}[$PREF{"DP"}+3] ;
    if(!defined $PORT) {
	$PORT = $ {$PREF_LIST{"DP"}}[3] ;
	$PREF{"DP"} = 0 ;
    }
    bail("DEPOT NOT DEFINED") unless defined $PORT ;
    $P4_HOSTNAME=$PORT ;
    $P4_HOSTNAME =~ s/:.*$//;
    
    $PORT =~ /(\S+)\s(\S+)\s(\S+)\s(\S+)/ or do { bail("DEPOT line not correct ($PORT)") ; } ;
    $PORT = $1 ;
    $P4 .= " -p $1 -u $2 -c $3 " ;
    if($4 ne "*") {
	$P4 .= "-P $4 " ;
    } ;

# Security note: any user can see p4 user and password in log. Uncomment for debug only.
#    push @ERRLOG,"P4 command set to: \"$P4\"" ;
    
    # Set variables from config
    $IGNORE_CASE   = $PREF{"IC"} ? "Yes" : "No" ;
    $TAB_SIZE      = $PREF{"TB"} ;
    $TAB_SIZE = 16 if $TAB_SIZE > 16 ;
    $TAB_SIZE = 0 if $TAB_SIZE <= 0 ;
    $MAX_CHANGES   = $PREF{"MX"} ;
    my @t =split(/ /,$ {$PREF_LIST{"ST"}}[3+$PREF{"ST"}]) ;
    $STYLE_SHEET   = $t[0]  ;
    
    push @ERRLOG,"Style sheet file: $STYLE_SHEET" ;

    foreach (keys %ENV) {
	push @ERRLOG,"Environment variable $_: \"". $ENV{$_} . "\"" ;
    } ;

    # Check that we have contact with p4 server
    #
    $LASTCHANGE= undef ;
    my $d ;
    p4call(\$d,"changes -m 1") ;
    $d =~ /Change (\d+)/ and do { $LASTCHANGE=$1 ;} ;

    # Get server version
    #
    $SERVER_VERSION_YEAR   = 0 ;
    $SERVER_VERSION_NO     = 0 ;
    $SERVER_VERSION_CHANGE = 0 ; 

    my @tmp ;
    p4call(\@tmp,"info") ;
    foreach $d (@tmp) {
	$d =~ /^Server version: (.+?)\/(.+?)\/(\d+)\.(\d+)([^\/]*)\/(\d+)/ and 
	    do { $SERVER_VERSION_YEAR   = $3 ;
		 $SERVER_VERSION_NO     = $4 ;
		 $SERVER_VERSION_QUAL   = $5 ;
		 $SERVER_VERSION_CHANGE = $6 ; }
    } ;
    if($SERVER_VERSION_YEAR == 0) {
	$NO_CONTACT_ERROR = "NO CONTACT WITH SERVER \"$PORT\"" ;
    }
    else {
	if(($SERVER_VERSION_YEAR < $REQUIRED_SERVER_VERSION_YEAR) or
	   (($SERVER_VERSION_YEAR == $REQUIRED_SERVER_VERSION_YEAR) and 
	    ($SERVER_VERSION_NO < $REQUIRED_SERVER_VERSION_NUMBER))) {
	    $NO_CONTACT_ERROR = 
		"P4DB REQUIRES VERSION $REQUIRED_SERVER_VERSION_YEAR.$REQUIRED_SERVER_VERSION_NUMBER OR NEWER<br>" .
		"(Current server $SERVER_VERSION_YEAR.$SERVER_VERSION_NO)" ;
	} ;
    } ;

    # Handle shortcuts
    #
    %SHORTCUTS=$CGI->cookie(-name=>"P4DB_F_$P4_HOSTNAME") ; # read shortcuts cookie
    
    my $addShortCut=$CGI->param(-name=>"ADDSHORTCUT") ;	# Add shortcut if specified
    if(defined $addShortCut) {
	my ($target,$name) = split(":::",$addShortCut) ;
	my $urlpath=&P4CGI::cgi()->url() ;
	$urlpath =~ s|[^/]+$|| ;              
	$target =~ s/^$urlpath// ;
	$SHORTCUTS{$name} = $target  ;
	$CGI->delete("ADDSHORTCUT") ;
    } ;

    my $rmShortCut=$CGI->param(-name=>"RMSHORTCUT") ; # Delete shortcut if specified
    if(defined $rmShortCut) {	
	my ($target,$name) = split(":::",$rmShortCut) ;	
	if($SHORTCUTS{$name} eq $target) {
	    delete $SHORTCUTS{$name}  ;
	}
	$CGI->delete("RMSHORTCUT") ;
    };

    my $clearShortCuts=$CGI->param(-name=>"CLRSHORTCUTS") ; # Clear all shortcuts if specified
    if(defined $clearShortCuts) {	
	my %empt ;
	%SHORTCUTS = %empt ;
 	$CGI->delete("CLRSHORTCUTS") ;
    };       
    print STDERR "Exit init()\n"; ## DEBUG
} ;


#################################################################
### Documentation start

=head1 About

P4CGI - Support for CGIs that interface p4. Written specifically for P4DB

=cut
    ;

################################################################
## Short access functions used to get preferences and such    ##
## in CGIs.                                                   ##
################################################################

=head1 General functions

General functions.

=cut
    ;

sub CURRENT_CHANGE_LEVEL() { return $LASTCHANGE ? $LASTCHANGE : -1 ; } ;
sub USER_P4PORT()          { return $PORT ;                } ;
sub HELPFILE_PATH()        { return $HELPFILE_PATH ;       } ;
sub REDIRECT_ERROR_TO_NULL_DEVICE() { return $REDIRECT_ERROR_TO_NULL_DEVICE ; } ;
sub REDIRECT_ERROR_TO_STDOUT() { return $REDIRECT_ERROR_TO_STDOUT ; } ;
sub VIEW_WITH_COLORS()     { return $PREF{"VC"} ;          } ;
sub HEADER_STYLE()         { return $PREF{"PH"} ;          } ; # 1=pulldown, 2=text links
sub SHOW_FULL_DESC()       { return $PREF{"FD"} ;          } ;
sub HIDE_DELETED()         { return $PREF{"HD"} ;          } ;
sub CURR_DEPOT_NO()        { return $PREF{"DP"} ;          } ;
sub DEPOT_NAME($)          { my $s = ${$PREF_LIST{"DP"}}[$_[0]+3] ; 
			     $s =~ s/^.*;\s+// ;
			     return $s ;} ;
sub NO_OF_DEPOTS()         { return scalar(@{$PREF_LIST{"DP"}}) - 3 ; } ;
sub CHANGES_IN_SEPARATE_WIN() { return $PREF{"NW"} ;      } ;
sub MAX_CHANGES()          { return $MAX_CHANGES ;         } ;
sub ERRLOG                 { push @ERRLOG,@_ ; }; 
sub ERROR                  { &ERRLOG(map { "ERROR: $_" } @_) ; $ERRORS++ ; }; 
sub EXTRAHEADER(% )        { %EXTRAHEADER = @_ ; } ;
sub ONLOADSCRIPT($ )       { $ONLOADSCRIPT= shift @_ ; } ;
sub SKIPHEADERBUTTONS()    { $printHeaderButtons = undef ; } ;
sub SET_HELP_TARGET($ )    { $helpTarget = shift @_ ; } ;
sub IGNORE_CASE()          { return $IGNORE_CASE ; } ;
sub UNUSEDCLIWL()          { return $UNUSEDCLIWL ; } ; 
sub UNUSEDUSRWL()          { return $UNUSEDUSRWL ; } ;
sub VERSION()              { return $VERSION ; } ;
sub CHANGELEVEL()          { return $CHANGELEVEL ; } ;
sub SERVER_VERSION()       { return ($SERVER_VERSION_YEAR,
				     $SERVER_VERSION_NO,
				     $SERVER_VERSION_QUAL) ; } ;
sub REQUIRED_SERVER_VERSION() { return "$REQUIRED_SERVER_VERSION_YEAR.$REQUIRED_SERVER_VERSION_NUMBER" ; } ;
sub SHORTCUTS()            { return %SHORTCUTS ; } ;
sub PREF()                 { return %PREF ; } ;
sub PREF_LIST()            { return %PREF_LIST ; } ;

sub STARTPAGE_MARKER       { return "__ Default start page __" ; } ;


###################################################################
###  cgi
###

=head2 cgi

C<&P4CGI::cgi()>

Return CGI reference 

Example:

    my $file = P4CGI::cgi()->param("file") ;
    print "File parameter value: $file\n" ;

=cut
    ;
sub cgi() {
    confess "CGI not initialized" unless defined $CGI ;
    return $CGI ;
}

###################################################################
### Fix some special characters to html entities
###

=head2 htmlEncode

C<&P4CGI::htmlEncode(>B<str>C<)>

Convert all '>' to "C<&gt;>", '<' to "C<&lt;>" and '&' to "C<&amp;>".

=over 4

=item str

String to convert

=back

Example:

    my $cvstr = &P4CGI::htmlEncode("String containing <,> and &") ;

=cut 
    ;

sub htmlEncode($ )
{    
    my $d = &rmTabs(shift @_) ;
    $d =~ s/&/&amp;/g ; # & -> &amp;
    $d =~ s/\"/&quot;/g;# " -> &quot;
    $d =~ s/</&lt;/g  ; # < -> &lt;
    $d =~ s/>/&gt;/g  ; # > -> &gt;
    return $d ;
}

###################################################################
### Replace tabs with spaces
###

=head2 rmTabs

C<&P4CGI::rmTabs(>B<str>C<)>

Returns B<str> with all tabs converted to spaces

=over 4

=item I<str>

String to convert

=back

=cut 
    ;

sub rmTabs($ )
{    
    # This algorithm is kind of, well, the first thing I came up
    # with. Should be replaced with a smarter (== more efficient)
    # eventually.......
    my $l = shift @_ ;    
    if($l =~ /\t/) { # only do this if there really are tabs in the text
	my $tabsz=$TAB_SIZE ;
	$tabsz = 8 unless $tabsz ;
	my $pos = 0 ;
	$l = join('',map
		  { 
		      if($_ ne "\t") {
			  $pos++ ;	
			  $_  ;
		      } else
		      {
			  my $p = $pos % $tabsz ;
			  $pos += $tabsz-$p ;
			  substr("                ",0,$tabsz-$p) ;
		      } ;
		  } split('',$l)) ;
	# For those that wonder what is going on:
	# 1.  Split string to an array (of characters)
	# 2.  For each entry of array, map a function that returns value
	#     for entry or, if value is <TAB>, returns a number of spaces
	#     depending on position in string
	# 3.  Make string (scalar) of array returned from map using join().
	# (Note that the steps appear in the reverse order in the code)
    }
    return $l ;
}

###################################################################
### Set magic buttons
###

=head2 magic

C<&P4CGI::magic(>B<text>C<)>

Returns B<text> with some magic "patterns" substituted with links.

Currently the pattern "change I<number>" (and some variants) is replaced with a link to the
change browser.

Example:

    my $t = "Integrated change 4711 to this codeline" ;

    print &P4CGI::magic($t) ; # inserts a link to change 4711

=cut ;
sub magic($;\@)
{    
    my $t = shift @_ ;
    my %found ;
    my $res = "" ;
    my $hot = 0 ;
    my $max = &P4CGI::CURRENT_CHANGE_LEVEL() ;
    while($t =~ s/^([\s\n]*)(no\.|\.|ch\.|[a-zA-Z-0-9]+|[^a-zA-Z-0-9]+)//i) {
	$res .= $1 ;
	my $tok = $2 ;	
	if($hot == 0) {
	    $hot = 3 if $tok =~ /^(ch[\.]?|change|integrate|submit)/i ;
	}
	else {
	    $hot-- ;
	    if($tok =~ /^\d+$/ and !($t =~ /\.\d+/)) {
		if($tok > 0 and $tok < $max) {
		    $hot = 3 ;
		    $found{$tok} = 1 ;
		    $tok = ahref(-url => "changeView.cgi",
				 "CH=$tok",
				 "HELP=View change $tok",
				 "<b>$tok</b>") ;
		}		
	    }
	    elsif($tok eq ".") {
		$hot = 0 ;
	    }	    
	}
	$res .= $tok ;	
    } ;
    $res .= $t ;

    my $ar ;
    if($ar = shift @_) {
	@$ar = sort { $a <=> $b } keys %found ;
    } ;
    return $res ;
}

###################################################################
### UrlEncode
###

=head2 urlEncode

C<&P4CGI::urlEncode(>B<text>C<)>

Returns B<text> with characters like space substituted with "%<ASCII value>".

Example:

    my $t = "/File with spaces" ;

    print &P4CGI::urlEncode($t) ; # prints: /File%20with%20spaces

=cut
;
sub urlEncode($)
{    
    my $t = shift @_ ;
    $t =~ s/%(?![\da-fA-F][\da-fA-F])/%25/g ;
    $t =~ s/\?/%3f/g ;
    $t =~ s/&/%26/g ;
    $t =~ s/ /%20/g ;
    $t =~ s/;/%3b/g ;
    $t =~ s/\+/%2b/g ;
    $t =~ s/-/%2d/g ;
    $t =~ s/_/%5f/g ;
    $t =~ s/~/%7e/g ;
    return $t ;
}

###################################################################
### urlDecode
###

=head2 urlDecode

C<&P4CGI::urlDecode(>B<text>C<)>

Reverse the operation of C<urlEncode>. See above.

=cut
;
sub urlDecode($)
{    
    my $t = shift @_ ;  
    my $r = "" ;
    while($t =~ /(.*)\%(..)(.*)/) {
	my ($start,$code,$end) = ($1,$2,$3) ;
	$r .= $start ;
	$t = $end ;
	if($code eq "25") {
	    $r .= "%" ;
	}
	else {
	    if($code =~ /[\da-fA-F][\da-fA-F]/) {
		$r .= char("0x$code") ;
	    }
	    else {
		$r .= "%$code" ;
	    }
	}
    }
    return  $r . $t ;
}

################################################################
## 


=head1 Functions for p4 access

    These fuctions used the "p4" command to access the depot.

=cut

###################################################################
###  p4call
###

=head2 p4call

C<&P4CGI::p4call(>B<result>C<,>B<command>C<)>

Request data from p4. Calls p4 with command B<command> and returns data in B<result>.

This function is really three different functions depeding in the type of the
B<result> parameter.

=over 4

=item result

This parameter can be of three different types:

=over 4

=item Filehandle (typeglob)

Data from command can be read from filehandle. NOTE! File must be closed by
caller.

=item Reference to array

Returns result from command into array (newlines stripped)

=item Reference to scalar

Returns result from command into scalar. (lines separated by newline)

=back

Any other type of parameter will abort operation

=item command

Command to send to p4 command line client.

=back

Example:

    my $d ;
    &P4CGI::p4call(\$d,"changes -m 1") ;
    $d =~ /Change (\d+)/ or &bail("No contact with P4 server") ;
    $LASTCHANGE=$1 ;    

=cut
    ;

sub p4call {
    my ( $par, @command ) = @_; 
    my $partype = ref $par ;
    push @ERRLOG,"p4call(<$partype>,@command)" ;
    if(!$partype) {
	open( $par, "$P4 @command|" ) || &bail( "$P4 @command failed" );
	return ;
    }  ;
    "ARRAY" eq $partype and do {
	local *P4 ;
	@$par = () ;
	open( P4, "$P4 @command|" ) || &bail( "$P4 @command failed" );
	while(<P4>) {
	    chomp ;
	    push @$par,$_ ;
	} ;
	close P4 ;
	return ;
    } ;
    "SCALAR" eq $partype and do {
	$$par = "" ;
	local *P4 ;
	open( P4, "$P4 @command|" ) || &bail( "$P4 @command failed" );
	while(<P4>) {
	    $$par .= $_ ;
	} ;
	close P4 ;	
	return ;
    } ;
    die("Called with illegal parameter ref: $partype") ;
} ;

###################################################################
###  p4readform
###

=head2 p4readform

C<&P4CGI::p4readform(>B<command>,B<resulthash>C<)>

Reads output from a P4 command and assumes the data is a form (e.g. "client -o").

The form is stored in a hash and the function returns an array containing all
field names in the order they appeared. The hash will contain the field names as
key and field values as data.

=over 4

=item command

Command to send to p4 command line client.

=item resulthash

Reference to a hash to receive reults

=back

Example:

    my %fields ;
    my @fields = &P4CGI::p4readforml("client -o",\%fields) ;
    my $f ;
    foreach $f (@fields) {
        print "field $f: $fields{$f}\n" ;
    }

=cut
    ;

sub p4readform($\% )
{
    my $cmd = shift @_ ;
    my $href = shift @_ ;
    my @result ;
				# clear hash
    %$href = () ;

    local *F ;
    p4call(*F,$cmd) ;
    my $cline = <F>;
    while($cline) {
	chomp $cline ;
	$_ = $cline ;
	if(/^\#/ or /^\s*$/) {	# skip comments and empty line
	    $cline = <F>;
	    next ;
	}
	if(/^(\S+):\s*(.*)\s*$/) {
	    my $fld=$1 ;
	    my $val=$2 ;
	    push @result,$fld ;
	    my $ws ;
	    if($val eq "") {
		$val = undef ;
		while(defined ($cline = <F>)) {
		    $_ = $cline ;
		    chomp ;
		    last if /^\w/ ;
		    s/^\s+// ;
		    if(defined $val) {
			$val .= "\n$_" ;
		    }
		    else {
			$val = "$_" ;
		    }
		}
	    }
	    else {
		$cline = <F>;
	    }
	    $$href{$fld}=$val ;
	}
	else {
	    $cline = <F>;
	}
    }
    close *F ;
    return @result ;
} ;

################################################################
################################################################
################ Page header, footer and common ################
################ routines.                      ################
################################################################
################################################################

###################################################################
###  start_page
###

=head2 start_page

C<&P4CGI::start_page(>B<title>[C<,>B<legend>]C<)>

Start a page. Print http header and first part of the html code for a page.

=over 4

=item title

Title of page. If the text contains " -- " it is removed and all text 
is used for the page title but only the text before " -- " is printed 
in the page header.

=item legend (Optional)

Short help text to be displayed at top of page

=back

Example:

 my @buttons ;
 push @button,P4CGI::buttonCell("http://www.perforce.com",
				"Tooltip help text",
				"Go To Perforce") ;

 my $start = P4CGI::start_page("Title of page",
			       @buttons) ;
 print $start ;

=cut ;

sub start_page($;@)
{
#    print STDERR "Start_page()\n" ; ## DEBUG

    my @cookiepar ;
				# Set up cookies and print header
    my @cookieArray ;
    push @cookieArray,$CGI->cookie(-name=>"P4DB_PREFERENCES",
				   -value=>\%PREF,
				   -path=>"/",
				   -expires=>'+6M');
    push @cookieArray,$CGI->cookie(-name=>"P4DB_F_$P4_HOSTNAME",
				   -value=>\%SHORTCUTS,
				   -path=>"/",
				   -expires=>'+6M');
    push @cookiepar,"-cookie",\@cookieArray ;

    my $ret =  $CGI->header(@cookiepar,
			    %EXTRAHEADER). "\n"  ;

    my $title  = shift @_ ;
    my @buttons = @_ ;
    my $buttons ;

    my $helpURL="${HELPFILE_PATH}/P4DB_Help.html" ;
    if(defined $helpTarget) {
	$helpURL .= "#$helpTarget" ;
    } ;

    if(@buttons) {
	$buttons = buttonHMenuTable(@buttons) ;
    }
    my $n = 0 ;
    
    $ONLOADSCRIPT = "" unless defined $ONLOADSCRIPT ;

    my $t = "$title" ;		# Take title and removed all HTML tags 
    $t =~ s/<br>/ /ig ;
    $t =~ s/<[^>]*>//g ;
    $t =~ s/ -- / /;
    $title =~ s/ -- .*$/ / ;
    my %header ;
    $header{"-title"}  = "P4DB: $t" ;
    $header{"-author"} = "fredric\@mydata.se" ;
    $header{"-style"} = { -src=>$STYLE_SHEET } ;
    $header{"-class"} = "DataFrame" ;
    $header{"-head"} = CGI::meta({"-http-equiv" => 'Content-Script-Type',
				  "-content" => 'text/javascript' }) ;
    $header{"-onload"} = $ONLOADSCRIPT if $ONLOADSCRIPT ;
#    $header{"-script"} = { -src=>"P4DB.js" , -language=>"JavaScript" } ;
    $ret .=  $CGI->start_html(%header) ;
    
    
    # Main pages menu
    # 
    my $opt ;
    my $options = "" ;
    my $headerStyle = HEADER_STYLE() ;
    foreach $opt (
		  ["intro.cgi",           "Intro page",        "P4DB Intro page"],
		  ["depotTreeBrowser.cgi","Depot Browser",     "Browse Depot Tree"],
		  ["changeList.cgi",      "Submitted Changes", "View submitted changes for //...",
		   { FSPC => "//..."} ],
		  ["changeList.cgi",      "Pending Changes",   "View pending changes for //...",
		   { FSPC   => "//...", 
		     STATUS => "pending"}],
		  ["searchPattern.cgi",   "Find&nbsp;Changes",  "Search for changes"],
		  ["findFiles.cgi",       "Find Files",         "Search depot for files"],
		  ["fileOpen.cgi",        "Open files",         "List open files"],
		  ["branchList.cgi", 	  "Branches",           "List branches"],
		  ["labelList.cgi",       "Labels",             "List labels in depot"],
		  ["jobList.cgi",         "Jobs",               "View selected jobs"],
		  ["userList.cgi",        "Users and Groups",   "List Users and Groups"],
		  ["clientList.cgi",      "Clients",   	        "List Clients"  ],
		  ["depotStats.cgi",      "Depot Statistics",   "View Depot Statistics"],
		  ["SetPreferences.cgi",  "User Preferences",   "Set user preferences manage user shortcuts"],
		  ["p4race.cgi",          "Submit Race",         "The Great Submit Race"]) {
	my @arr = @$opt ;

	my $url   = shift @arr ;
	my $text  = shift @arr ;
	my $title = shift @arr ;
	my $xparams ;
	if(@arr) {
	    my $hr = shift @arr ;
	    $xparams = join("&",map { &htmlEncode("$_=${$hr}{$_}") ; } keys %$hr) ;
	} ;
	my $selected = "" ;
	my $q = "" ;
	$q = $xparams if defined $xparams ;	
	if (($url eq $CGI->url(-relative=>1) and
	     $q eq $ENV{"QUERY_STRING"})) {
	    $selected = "selected" ;
	}
	$url .= "?$xparams" if defined $xparams ;
	if($headerStyle == 0) {
	    $options .= "\n      <option value=\"$url\" title=\"$title\" $selected>$text</option>" ;
	}
	else { # $headerStyle == 1
	    $options .= " <span class=\"HeaderTableSeparator\">|</span>" if $options ne "" ;
	    $text =~ s/ /&nbsp;/g ;
	    if($selected eq "selected") {
		$options .= "\n      <span class=\"HeaderTableSelected\">$text</span>" ;
	    }
	    else {
		$options .= "\n      <a class=\"HeaderTable\" href=\"$url\" title=\"$title\" $selected>$text</a>" ;
	    }
	}
    } ;

    my	$selectPage ;
    if($headerStyle == 0) {
	my $script =
	    "var n = this.selectedIndex ; ".
	    "if(n > 0) { ; " .
	    "var o = this.options[n] ; ".
	    "location = o.value;" .
	    "}" ;
	$selectPage =
	    join("\n    ",
		 ("<select title=\"Select a predefined entry to P4DB\" class=\"HeaderTable\" size=\"1\" name=\"Page\" onChange=\"$script\">" ,
		  "<option> -- Select page -- </option>\n",
		  $options ,
		  "</select>\n")) ;
    }
    else { # $headerStyle == 1
	$selectPage = "<span class=\"HeaderTable\">$options\n</span>" ;
    }
       
    # User shortcuts
    # 
    my $scscript =
	"var n = this.selectedIndex ; ".
	"if(n > 0) { ; " .
	"var o = this.options[n] ; ".
	"location = o.value;" .
	"}" ;

    my $disabled="" ;
    my %shortcuts = %SHORTCUTS ;
#    delete $shortcuts{&STARTPAGE_MARKER()} ;
    $disabled = "disabled" unless (keys %shortcuts) ;
    my $shortcuts = "" ;
    if($headerStyle == 0 ) {
	$shortcuts = "<select title=\"Select a personal shortcut\" class=\"HeaderTable\" size=\"1\" onChange=\"$scscript\" $disabled>\n" ;
	$shortcuts .= "<option>-- Select Shortcurt --</option>\n",
    }
    my $name ;
    foreach $name (sort { uc($a) cmp uc($b) } keys %shortcuts) {
#	next if $name eq &STARTPAGE_MARKER() ;
	my $target = $SHORTCUTS{$name} ;
	my $selected = "" ;
#	$selected = "selected" if 
	my $title = "Shortcut: $name" ;
	if($headerStyle == 0) {
	    $shortcuts .= 
		"\n      <option value=\"$target\" title=\"$title\" $selected>$name</option>" ;
	}
	else { # $headerStyle == 1
	    $shortcuts .= " <span class=\"HeaderTableSeparator\">|</span>" if $shortcuts ne "" ;
	    $shortcuts .= "<span class=\"HeaderTable\">Shortcuts:<br>\n" if $shortcuts eq "" ;
	    $name =~ s/ /&nbsp;/g ;
	    if($selected eq "selected") {
		$shortcuts .= "\n      <span class=\"HeaderTableSelected\">$name</span>" ;
	    }
	    else {
		$shortcuts .= "\n      <a class=\"HeaderTable\" href=\"$target\" title=\"$title\" $selected>$name</a>" ;
	    }
	}
    }    
    if($headerStyle == 0) {
	$shortcuts .= "</select>\n" ;
    }
    else { # $headerStyle == 1
	$shortcuts .= "</span>\n" ;
    }

    my $urlSelf = urlEncode($CGI->self_url) ;

    my $disableButtons = "" ;
    $disableButtons="disabled" unless $printHeaderButtons ;

    my $buttonClass="HeaderTable" ;
    $buttonClass="HeaderTableDisabled" unless $printHeaderButtons ;
    
    my $addshortcutScript = 
	"location = 'addshortcut.cgi?SC=" . $urlSelf . "' ;" ;

    my $addshortcut = 
	"<button class=\"$buttonClass\" type=\"button\" name=\"addsc\" value=\"addsc\" ".
	"title=\"Add current page to list of shortcuts\" ".
	"onclick=\"$addshortcutScript\" $disableButtons> Add Shortcut </button>\n" ;

    my $addstartLocation=
	join("",("addshortcut.cgi?ADDSHORTCUT=${urlSelf}:::" ,
		 urlEncode(&STARTPAGE_MARKER()),
		 "&GOTO=$urlSelf")) ;
		 
    my $makeStartPage = 
	"<button class=\"$buttonClass\" type=\"button\" name=\"makestart\" value=\"makestart\" ".
	"title=\"Make current page your start page\" ".
	"onclick=\"location='$addstartLocation' ;\" $disableButtons> Make startpage </button>\n" ;
    
    if($headerStyle == 0) {
	$ret .= join("\n",("<table class=\"HeaderTable\">",
			   "  <tr>",
			   "    <td class=\"HeaderTable_AppName\">",
			   "      <a class=\"HeaderTable_AppName\" href=\"index.cgi\" title=\"Go to start page\">",
			   "        P4DB 3.1",
			   "      </a>",
			   "    </td>",
			   "    <td class=\"HeaderTable\">",
			   $selectPage,
			   "    </td>",
			   "    <td class=\"HeaderTable\">",
			   $shortcuts,		       
			   "    </td>",
			   "    <td class=\"HeaderTable\">",
			   $addshortcut,
			   "    </td>",
			   "    <td class=\"HeaderTable\">",
			   $makeStartPage,
			   "    </td>",
			   "  </tr>",
			   "</table>")) ;
    }
    else {  # $headerStyle == 1
	$ret .= join("\n",("<table class=\"HeaderTable\">",
			   "  <tr>",
			   "    <td class=\"HeaderTable_AppName\">",
			   "      <a class=\"HeaderTable_AppName\" href=\"index.cgi\" title=\"Go to start page\">",
			   "        P4DB 3.1",
			   "      </a>",
			   "    </td>",
			   "    <td class=\"HeaderTableTextSelect\">",
			   $selectPage,
			   "    </td>",
			   "    <td class=\"HeaderTableTextSelect\">",
			   $shortcuts,		       
			   "    </td>",
			   "    <td class=\"HeaderTable\">",
			   $addshortcut,
			   "<br>",
			   $makeStartPage,
			   "    </td>",
			   "  </tr>",
			   "</table>")) ;
    }
    
    if(defined $NO_CONTACT_ERROR) {
	$ret .= "<p class=\"Error\">ERROR: $NO_CONTACT_ERROR</p>" ;
    }
    
    my $headerTable = start_table("class=\"PageTitle\"") ;
    my $prHeaderTable = 0 ;
    if($title ne "") {
	$headerTable .= table_row({-class  => "PageTitle",
				   -text   => "$title"}) ;
	$prHeaderTable++ ;
    }
    if(defined $buttons) {
	$headerTable .= table_row($buttons) ;
	$prHeaderTable++ ;
    } ;
    $headerTable .= end_table() ;
    if($prHeaderTable) { $ret .= $headerTable ; } ;
    $pageStartPrinted = 1 ;
#    print STDERR "Exit Start_page()\n" ; ## DEBUG    

    return $ret . "\n" ;    
} ;

###################################################################
###  end_page
###

=head2 end_page

C<&P4CGI::end_page()>

End a page. Print HTML trailer.

Example:

 print P4CGI::end_page() ;

=cut ;

sub end_page()
{
    my $err = "" ;
    if($PREF{"DBG"}) {
	$err = &prerrlog() ;
    } ;
    return  $err .  $CGI->end_html() ;
} ;

sub end_page_header()
{
    return  $CGI->end_html() ;
} ;

###################################################################
### bail
###

=head2 bail

C<&P4CGI::bail(>B<message>C<)>

Report an error. This routine will emit HTML code for an error message, print the error log  and exit.

This rouine is intended to report internal errors in the code (much like assert(3) in c). 

=over 4

=item message
Message that will be displayed to user

=back

Example:

 unless(defined $must_be_defined) { 
     &P4CGI::bail("was not defined") ; 
 } ;

=cut ;

my $bailed ;

sub bail(@) {
    unless(defined $bailed) {
	$bailed = 1 ;
	my $message = shift @_ ;
	my $text = shift @_ ;    
	unless(defined $pageStartPrinted) {
	    print 
		"",
		$CGI->header(),
		$CGI->start_html(-title   => "Error in script",
				 -bgcolor => "white");
	    $pageStartPrinted = 1 ;
	} ;    
	$message = &htmlEncode($message) ;
	print 
	    "<br><hr color=red><p align=center><font color=red size=+2>An error has occurred<br>Sorry!</font><p><font color=red>Message:<BR><pre>$message</pre><br>" ;
	if(defined $text) { 
	    $text = &htmlEncode($text) ;
	    print "<pre>$text</pre><br>\n" ; 
	} ;
	print
	    "<p>Parameters to script:<br>",
	    $CGI->dump() ;
	print "</font>\n",prerrlog(), end_page() ;	
	die($message) ;
    }
} ;

###################################################################
### signalError
###

=head2 signalError

C<&P4CGI::signalError(>B<message>C<)>

Report an operator error in a reasonable fashion.
SignalError can be called before or after start_page() but if it is called 
before start_page() a "default" page header will appear. It is recommended 
to call signalError() after start_page() to make it more obvious to the
operator what the problem was.

=over 4

=item message
Message that will be displayed to user

=back

Example:

 unless(defined $must_be_defined) { 
     &P4CGI::signalError("was not defined") ; 
 } ;

=cut ;

sub signalError {
    my $message = shift @_ ;
    my $text = shift @_ ;    
    unless(defined $pageStartPrinted) {
	print "",start_page("Error","") ;
	$pageStartPrinted = 1 ;
    } ;    
    $message = &htmlEncode($message) ;
    print 
	"<p align=center><font color=red size=+2>$message</font><br><br>" ;
    if(defined $text) { 
	$text = &htmlEncode($text) ;
	print "<pre>$text</pre><br>\n" ; 
    } ;
    print "", end_page() ;	
    exit 0 ;
} ;

###################################################################
### help_link
###  
sub help_link($ ) {
    my $helpURL="$HELPFILE_PATH/P4DB_Help.html#" . shift @_ ; ;
    return ahref(-url=>$helpURL,
		 "<font size=+2 style=fixed><B>?</B></font>") ;
}


###################################################################
### start_table
###  

=head2 start_table

C<&P4CGI::start_table(>B<table_attribute_text>C<)>

Start a table with optional table attributes

=over 4

=item table_attribute_text

This text will be inserted as attributes to table tag

=back

Example:

    print P4CGI::start_table("align=center border") ;

=cut ;
sub start_table
{
    my $attribs = shift @_ ;
    my $ret = "<table " ;
    if($attribs) {
	$ret .=  " $attribs" ;
    }
    return $ret . ">\n";
}

###################################################################
### end_table
###  

=head2 end_table

C<&P4CGI::end_table()>

Return end of table string. (trivial function included mostly for symmetry)

=cut ;

sub end_table() 
{
    return "</table>\n" ;
}

###################################################################
### table_row
###

=head2 table_row

C<&P4CGI::table_row(>B<options>C<,>B<listOfValues>C<)>

Insert a row in table.

=over 4

=item options

A list of key/value pairs (a hash will do just fine) containing options for 
the row. 

The key must start with a "-".

Most key/value pairs are treated as attributes to the <TR>-tag.
The following keys are recognized as special:

=over 4

=item C<-type>

Type of cells. Default is <TD>-type. 

=item C<->I<anykey>

I<anykey> will be assumed to be a row option and will be inserted in the TR-tag. 
The value for the option is the key value, unless value is empty or undefined, in which
case the option anykey is assumed to have no value.

=back

=item listOfValues

Row data. Remaining values are assumed to be data for each cell. 
The data is typically the text in the cell but can also be:

=over 4

=item undef

An undefined value indicates that the next cell spans more than one column. 

=item Reference to a hash

The hash contains two keys: "-text" for cell text and "-type" for cell type.
All other key/value pairs are treated as attributes to the <TD> or <TH> tag.

=back

=back

Example:

 print P4CGI::start_table("align=center") ;
                                   ### print header row
 print P4CGI::table_row(-type   => "th",
			-valign => "top",
			-align  => "left",
                        "Heading 1","Heading 2",undef,"Heading 3") ;
                                   ### print data
 my %h = (-text    => "text in hash", 
	  -bgcolor => "blue") ;
 print P4CGI::table_row(-valign  => "top",
			-bgcolor => "white",
                        "Cell 1",
			{-text    => "Cell 2",
			 -bgcolor => "red"},
			\%h,
			"Cell 3-2") ;
 print P4CGI::end_table() ;

=cut ;

sub table_row 
{   
    confess ("P4CGI::table_row() Parameters required!") if @_ == 0 ;
    my @ret ;
    my $n = 0 ;
    my $ec = 0 ;
    my $option = shift @_ ;
    my %options ;
    while(defined $option and ($option =~ s/^-//)) {	
	confess ("P4CGI::table_row() Option value required!") if @_ == 0 ;
	$options{lc($option)} = shift @_ ;
	$option = shift @_ ;
    }
    unshift @_,$option ;
    
    my $type      = "td" ;
    $type = $options{"type"} if defined $options{"type"} ;
    delete $options{"type"} ;

    push @ret,"<tr" ;
    my $attr ;
    foreach $attr (keys %options) {
	push @ret," $attr" ;
	if($options{$attr}) {
	    push @ret,"=$options{$attr}" ;
	}
    }
    push @ret,">\n" ;

    my $colspan = 0 ;
    my $cell ;
    foreach $cell (@_) {
	$colspan++ ;
	if(defined $cell) {
	    my $COLSPAN="colspan=$colspan" ;
	    $colspan=0 ;
	    if(ref $cell) {
		my $reftyp = ref $cell ;
		"HASH" eq $reftyp and do { my $txt = $$cell{"-text"} ;
					   confess "P4CGI::table_row() Missing text argument" 
					       unless defined $txt ;
					   delete $$cell{"-text"} ;
					   my $tp = $type ;
					   $tp = $$cell{"-type"} if defined 
					       $$cell{"-type"} ;
					   delete $$cell{"-type"} ;
					   push @ret,"<$tp $COLSPAN" ;
					   my $attr ;
					   foreach $attr (keys %$cell) {
					       ($a = $attr) =~ s/^-// ;
					       push @ret," $a=$$cell{$attr}" ;
					   }
					   push @ret,">$txt</$tp>\n" ;
					   next ; } ;
		confess "Illegal cell data type \"$reftyp\"" ;
	    } 
	    else {
		push @ret,"<$type $COLSPAN>$cell</$type>\n" ;
	    }
	}
    }
    push @ret,"</tr>\n" ;
    return join("",@ret) ;
}

###################################################################
### table_header
###

=head2 table_header

C<&P4CGI::table_header(>B<list of label/hint>C<)>

Create a table header row with a a description and an optional hint for each column. 

=over 4

=item list of label/hint

A list of column labels optionally followed by a '/' and a hint.

=back

Example:

 print P4CGI::start_table("align=center") ;
                                   ### print header row
 print P4CGI::table_header("File/click for story","Revision/click to view") ;
                                   ### print data
 my %h = (-text    => "text in hash", 
	  -bgcolor => "blue") ;
 print P4CGI::table_row(-valign  => "top",
			-bgcolor => "white",
                        "Cell 1",
			{-text    => "Cell 2",
			 -bgcolor => "red"},
			\%h,
			"Cell 3-2") ;
 print P4CGI::end_table() ;

=cut ;

sub table_header
{   
    my @cols ;
    my @tmp = @_ ;
    my $tmp ;
    my $n ;
    while(@tmp > 0) {	
	$tmp = shift @tmp ;
	if(defined $tmp) {
	    my $label = $tmp ;
	    push @cols,{ -text => $label,
			 -class => "ListHeader" } ;
	}
	else {
	    push @cols,$tmp ;
	}
    }
    return table_row(-class => "ListHeader", @cols) ;
} ;


################################################################
### Make a framed table with a title
###

sub start_framedTable($ ) 
{
    my $title = shift @_ ;
    return   
	"<span class=\"FrameTitle\">$title</span>\n" .
	"<table class=\"Frame\"><tr><td>\n" ;
}

sub end_framedTable() 
{
    return "</td></tr></table>\n" ;
}

sub framedTable($$ ) 
{
    my $title = shift @_ ;
    my $contents = shift @_ ;
    return join("\n",(&start_framedTable($title),
		      $contents,
		      &end_framedTable())) ;
}

###################################################################
### Make a list
###

=head2 ul_list

C<&P4CGI::ul_list(>B<list>C<)>

Return a bulleted list.

=over 4

=item I<list>

Lits of data to print as bulleted list

=back

Example:

 print P4CGI::ul_list("This","is","a","bulleted","list") ;

=cut ;

sub ul_list(@ ) 
{
    my @ret ;
    if($_[0] eq "-title") {
	shift @_ ;
	push @ret, shift @_ ;
    }
    push @ret,"<ul>\n" ;
    my $a ;
    foreach $a (@_) {
	push @ret,"<li>$a\n" ;
    }
    push @ret,"</ul>\n" ;
    return join("",@ret) ;
}

###################################################################
### Make a dl list
###

=head2 dl_list

C<&P4CGI::dl_list(>B<list_of_pairs>C<)>

Returns a definition list.

=over 4

=item list_of_pairs

List of data pairs to print as a definition list. 
A hash will do just fine, only you have no control over the order in the list. 

=back

Example:

 print P4CGI::dl_list("This","Description of this",
                      "That","Description of that") ;

=cut ;

sub dl_list
{
    my @ret ;
    if($_[0] eq "-title") {
	shift @_ ;
	push @ret,shift @_ ;  
    }
    if($_[0] eq "-compact") {
	push @ret,"<dl compact>\n" ;
	shift @_ ;
    } 
    else {
	push @ret,"<dl>\n" ;
    }
    while(@_ > 1) {
	push @ret,"<dt>",shift @_,"<dd>",shift @_,"\n" ;
    }
    push @ret,"</dl>\n" ;
    return join("",@ret) ;
}

###################################################################
### Create a href tag
###

=head2 ahref

C<&P4CGI::ahref(>B<options>C<,>B<parameters>C<,>B<text>C<)>

Returns a <A HREF...>...</A> tag pair.

=over 4

=item I<options>

Optional list of option-value pairs. Valid options are:

=over 4

=item C<-url>

Url for link. Default is current.

=item C<-anchor>

Anchor in url. Default is none.

=back

Any non-valid option marks the end of the options

=item I<parameters>

Optional list of parameters for link.

=item I<text>

The last parameter is used as text for link. 

If the next to the last parameter has the format: C<"HELP=Help text"> the
help text is displayed as a tooltip.

=back

Example:

    print &P4CGI::ahref("Back to myself") ; # link to this. No parameters.

    print &P4CGI::ahref("-url","www.perforce.com",
			"To perforce") ; # link to perforce

    print &P4CGI::ahref("-anchor","THERE",
			"Go there") ; # link to anchor THERE

    print &P4CGI::ahref("-url","changeList.cgi",
			"FSPC=//.../doc/...",
			"HELP=Click here",               # a tooltop help text
			"Changes for all documentation") ; # url with parameter

=cut ;

sub ahref
{    
    my $args=@_ ;
    
    my @tmp = @_ ;
    my $url = $ENV{SCRIPT_NAME} ;
    my $anchor = "" ;
    my $pars   = "" ;
    my $params = "" ;
    while($tmp[0] =~ /^-/) {
	$tmp[0] =~ /^-url$/i and do {
	    shift @tmp ;
	    $url = shift(@tmp) ;
	    next ;
	} ;
	$tmp[0] =~ /^-anchor$/i and do {
	    shift @tmp ;
	    $anchor = "#" . shift @tmp ;
	    next ;
	} ;
	$tmp[0] =~ /^-(.*)/ and do {
	    my $p = $1 ;
	    shift @tmp ;
	    my $v = shift @tmp ;
	    $params .= " $p=$v" ;
	    next ;
	} ;
	last ;
    }
    my $tooltips="" ;
    while(@tmp > 1) {
	if($tmp[0] =~ /HELP=(.*)/) {
	    $tooltips=" title=\"$1\"" ;
	    shift @tmp ;
	    next ;
	}
	if(length($pars) > 0) {
	    $pars .= "&" ;
	}
	else {
	    $pars = "?" ;
	} ;
	$pars .= urlEncode(shift @tmp) ;
    } ;
    my $txt = shift @tmp ;
    $pars =~ s/ /\+/g ;
    return "<a href=\"${url}${pars}${anchor}\"$params$tooltips>$txt</a>" ;
}

###################################################################
### ButtonCell
### Create a button link in a table cell
###
sub buttonCell($$@)
{
    return "<td>" . &buttonLink(@_) . "</td>\n" ;
}

###################################################################
### ButtonLink
### Create a button link
###
sub buttonLink($$@)
{
    my $url  = shift @_ ;
    my $help = shift @_ ;
    my @text = @_ ;
    my $params ;
    while(@text > 1) {
	if($params) {
	    $params .= ";" ;
	}
	else {
	    $params = "?" ;
	}
	$params .= shift @text ;
    }    
    return "<button class=\"button\" onclick=\"location='$url$params' ; return false ;\" title=\"$help\">$text[0]</button>\n" ;
}

###################################################################
### buttonVMenuTable
### Create a vertical menu of "buttons".
###
sub buttonVMenuTable(@)
{
    my $r = "<table cellspacing=\"3\" cellpadding=\"0\" class=\"Button\">\n" ;
    while(@_) {
	my $m = shift @_ ;
	$r .= "<tr>\n    " . $m ."</tr>\n" ;
    }
    return $r . "</table>\n" ;
}

###################################################################
### buttonHMenuTable
### Create a horizontal menu of "buttons".
###
sub buttonHMenuTable(@)
{
    return
	"<table cellspacing=\"3\" cellpadding=\"0\" class=\"Button\">\n".
	"<tr>\n    " .
	join('    ',@_) .
	"</tr>\n" .
	"</table>\n" ;
}

###################################################################
### splitLine
### Split a line containing html tags with <br>-tags
###
sub splitLine($$)
{
    my $line = shift @_ ;
    my $maxlen  = shift @_ ;
    my @line = split(/(<[^>]+>)/,$line) ; 
    $line = "" ;
    my $pos = 0 ;
    while(@line) {
	my $l = shift @line ;
	my $txt ="" ;
	my $len = $maxlen-$pos ;
	while(length($l) > $len and
	      $l =~ s/(.{1,$len}\S*)\s*(.*)/$2/) {
	    $txt .= $1  ;
	    $txt .= "<br>\n" if length($l) ;
	    $pos = 0 ;
	}	
	$pos += length($l) ;
	$txt .= $l ;
	$txt =~ s/ /&nbsp;/g ;
	$line .= $txt ;
	last if @line == 0 ;
	$line .= shift @line ;
    }
    return $line ;
}

###################################################################
### formatDescription
### Format a description text and insert it into a cell
###
sub formatDescription($;\@)
{
    my $desc = shift @_ ;
    my @tmp ;
    my $refref ;
    $refref = shift @_ or $refref = \@tmp ;
    $desc = &htmlEncode($desc) ;
    $desc = &P4CGI::magic($desc,$refref) ;
    my @desc = map { my $d = splitLine($_,78) ;
		     $d ;
		 } split("\n",$desc) ;
    return join("<br>\n",@desc) ;
}

sub BEGIN ()
{
    init() ;
} ;

1;