--- loncom/xml/lontable.pm	2010/09/28 22:55:41	1.13
+++ loncom/xml/lontable.pm	2010/11/01 10:52:09	1.14
@@ -1,7 +1,7 @@
 # The LearningOnline Network with CAPA
 #  Generating TeX tables.
 #
-# $Id: lontable.pm,v 1.13 2010/09/28 22:55:41 raeburn Exp $
+# $Id: lontable.pm,v 1.14 2010/11/01 10:52:09 foxr Exp $
 # 
 #
 # Copyright Michigan State University Board of Trustees
@@ -58,7 +58,7 @@ use strict;
 use Apache::lonlatextable;
 use Apache::lonnet;		# for trace logging.
 
-my $tracing = 1;		# Set to 1 to enable log tracing. 2 for local sub tracing.
+my $tracing = 0;		# Set to 1 to enable log tracing. 2 for local sub tracing.
 
 =pod
 
@@ -255,7 +255,6 @@ The contents of the cell.
 sub new {
     my ($class, $configuration) = @_;
 
-    if($tracing) {&Apache::lonnet::logthis("new table object");}
 
     #  Initialize the object member data with the default values
     #  then override with any stuff in $configuration.
@@ -269,6 +268,7 @@ sub new {
 	column_count   => 0,
 	row_open       => 0,
 	rows           => [],
+	col_widths      => {}
     };
 
     foreach my $key (keys %$configuration) {
@@ -548,6 +548,7 @@ The default vertical alignment for text
 
 "top", "bottom" or "center"
 
+
 =back 
 
 =cut
@@ -605,6 +606,13 @@ Number of rows the cell spans.
 
 Number of columns the cell spans.
 
+=item width
+
+LaTeX specification of the width of the cell.
+Note that if there is a colspan this width is going to be equally divided
+over the widths of the columnsn in the span.
+Note as well that if width specification conflict, the last one specified wins...silently.
+
 =back
 
 =cut
@@ -679,8 +687,34 @@ sub add_cell {
 	    $cell->{$key} = $config->{$key};
 	}
     }
+
     $current_row->{'cell_width'} += $cell->{'colspan'};
 
+
+    #
+    # Process the width if it exists.  If supplied it must be of the form:
+    #   float units
+    # Where units can be in, cm or mm.
+    # Regardless of the supplied units we will normalize to cm.
+    # This allows computation on units at final table generation time.
+    #
+
+    if (exists($cell->{'width'})) {
+	my $width;
+	my $widthcm;
+	$width   = $config->{'width'};
+	$widthcm = $self->size_to_cm($width);
+	
+	# If there's a column span, the actual width is divided by the span
+	# and applied to each of the columns in the span.
+
+	$widthcm = $widthcm / $cell->{'colspan'};
+	for (my $i = $last_coord; $i < $last_coord + $cell->{'colspan'}; $i++) {
+	    $self->{'col_widths'}->{$i} = $widthcm; 
+	}
+	
+    }
+
     push(@$current_cells, $cell);
 
     if ($tracing) { &Apache::lonnet::logthis("add_cell done"); }
@@ -726,14 +760,14 @@ The caller can then ask the table object
 sub generate {
     my ($this) = @_;
     my $useP   = 0;
-    my $colwidth;
-    my $colunits;
+
+    my $colunits = 'cm';	# All widths get normalized to cm.
+    my $tablewidth;
 
     if($tracing) {&Apache::lonnet::logthis("generate"); }
     my $table = Apache::lonlatextable->new();
 
 
-
     # Add the caption if supplied.
 
     if ($this->{'caption'} ne "") {
@@ -742,15 +776,64 @@ sub generate {
     
     # Set the width if defined:
 
+    my $default_width;
+    my $colwidths        = $this->{'col_widths'};
     if (defined ($this->{'width'})) {
-#	$table->set_width($this->{'width'});
-#	$table->set_width_environment('tabularx');
+	$tablewidth = $this->{'width'};
+	$tablewidth = $this->size_to_cm($tablewidth);
+
 	$useP = 1;
-	($colwidth, $colunits) = split(/ /, $this->{'width'});
-	$colwidth = $colwidth/$this->{'column_count'};
 
+	# Figure out the default width for a column with unspecified
+	# We take the initially specified widths and sum them up.
+	# This is subtracted from total width  above.
+	# If the result is negative we're going to allow a minimum of 2.54cm for
+	# each column and make the table spill appropriately.  
+	# This (like a riot) is an ugly thing but I'm open to suggestions about
+	# how to handle it better (e.g. scaling down requested widths?).
+
+	my $specified_width = 0.0;
+	my $specified_cols   = 0;
+	foreach my $col (keys %$colwidths) {
+	    $specified_width = $specified_width + $colwidths->{$col};
+	    $specified_cols++;
+	}
+	my $unspecified_cols = $this->{'column_count'} - $specified_cols;
+
+	#  If zero unspecified cols, we are pretty much done... just have to
+	#  adjust the total width to be specified  width. Otherwise we
+	#  must figure out the default width and total width:
+	#
+	my $total_width;
+	if($unspecified_cols == 0) {
+	    $total_width = $specified_width;
+	} else {
+	    $default_width = ($tablewidth - $specified_width)/$unspecified_cols; #  Could be negative....
+	    $total_width   = $default_width * $unspecified_cols + $specified_width;
+	}
+	
+	# if the default_width is < 0.0 the user has oversubscribed the width of the table with the individual
+	# column.  In this case, we're going to maintain the desired proportions of the user's columns, but 
+	# ensure that the unspecified columns get a fair share of the width..where a fair share is defined as
+	# the total width of the table / unspecified column count.
+	# We figure out what this means in terms of reducing the specified widths by dividing by a constant proportionality.
+	# Note that this cannot happen if the user hasn't specified anywidths as the computation above would then
+	# just make all columns equal fractions of the total table width.
+
+	if ($default_width < 0) {
+	    $default_width = ($tablewidth/$unspecified_cols);                     # 'fair' default width.
+	    my $width_remaining = $tablewidth - $default_width*$unspecified_cols; # What's left for the specified cols.
+	    my $reduction       = $tablewidth/$width_remaining;                    # Reduction fraction for specified cols
+	    foreach my $col (keys %$colwidths) {
+		$colwidths->{$col} = $colwidths->{$col}/$reduction;
+	    }
+	    
+        }
     }
 
+	
+
+
     # Build up the data:
 
     my @data;
@@ -811,7 +894,13 @@ sub generate {
 	    # para mode; and wrap the contents in the start/stop stuff:
 
 	    if ($useP) {
-		my $cw = $colwidth * $cells->[$cell]->{'colspan'};
+		my $cw;
+		if (defined($colwidths->{$cell})) {
+		    $cw = $colwidths->{$cell};
+		} else {
+		    $cw = $default_width;
+		}
+		my $cw = $cw * $cells->[$cell]->{'colspan'};
 		$col_align = "p{$cw $colunits}";
 		$contents = $embeddedAlignStart . $contents .  $embeddedAlignEnd;
 	    }
@@ -877,7 +966,7 @@ sub generate {
     }
     for (my $i =0; $i < $column_count; $i++) {
 	if ($useP) {
-	    $coldef .= "p{$colwidth $colunits}";
+	    $coldef .= "p{$default_width $colunits}";
 	} else {
 	    $coldef .= 'l';
 	}
@@ -896,6 +985,29 @@ sub generate {
     return $table;
 
 }
+#---------------------------------------------------------------------------
+#
+#  Private methods:
+#
+
+# 
+# Convert size with units -> size in cm.
+# The resulting size is floating point with no  units so that it can be used in
+# computation.  Note that an illegal or missing unit is treated silently as
+#  cm for now.
+#
+sub size_to_cm {
+    my ($this, $size_spec) = @_;
+    my ($size, $units) = split(/ /, $size_spec);
+    if (lc($units) eq 'mm') {
+	return $size / 10.0;
+    }
+    if (lc($units) eq 'in') {
+	return $size * 2.54;
+    }
+    
+    return $size;		# Default is cm.
+}
 #----------------------------------------------------------------------------
 # The following methods allow for testability.
 
@@ -913,9 +1025,11 @@ sub get_row {
     my $rows = $self->{'rows'};	  # ref to an array....
     return $rows->[$row];         # ref to the row hash for the selected row.
 }
+
 #   Mandatory initialization.
 BEGIN{
 }
 
 1;
 __END__
+