[LON-CAPA-cvs] cvs: loncom /xml londefdef.pm lontable.pm
foxr
foxr@source.lon-capa.org
Mon, 01 Nov 2010 10:52:09 -0000
This is a MIME encoded message
--foxr1288608729
Content-Type: text/plain
foxr Mon Nov 1 10:52:09 2010 EDT
Modified files:
/loncom/xml londefdef.pm lontable.pm
Log:
BZ6378 - Add back support for TeXwidth in <td> tag.
--foxr1288608729
Content-Type: text/plain
Content-Disposition: attachment; filename="foxr-20101101105209.txt"
Index: loncom/xml/londefdef.pm
diff -u loncom/xml/londefdef.pm:1.424 loncom/xml/londefdef.pm:1.425
--- loncom/xml/londefdef.pm:1.424 Tue Oct 19 19:33:21 2010
+++ loncom/xml/londefdef.pm Mon Nov 1 10:52:09 2010
@@ -1,7 +1,7 @@
# The LearningOnline Network with CAPA
# Tags Default Definition Module
#
-# $Id: londefdef.pm,v 1.424 2010/10/19 19:33:21 raeburn Exp $
+# $Id: londefdef.pm,v 1.425 2010/11/01 10:52:09 foxr Exp $
#
#
# Copyright Michigan State University Board of Trustees
@@ -2186,437 +2186,17 @@
if ($target eq 'web' || $target eq 'webgrade') {
$currentstring = $token->[2];
} elsif ($target eq 'tex') {
-
-
+
+
# New table code:
-
+
my $table = pop(@Apache::londefdef::table);
my $t = $table->generate();
# &Apache::lonnet::logthis("Generating string");
$currentstring = $t->generate_string();
# &Apache::lonnet::logthis("Generated: $currentstring");
&enable_para();
- #--------------------------------------------------------------
- # Old table code:
- #--------------------------------------------------------------
-
- if (0) {
-
- my $border = &Apache::lonxml::get_param('border',$parstack,$safeeval);
- my $inmemory = '';
- my $output = '';
- my $WARNING='';
- #width of columns from TeXwidth attributes
-
- # Protect against unbalanced </table> tag.
-
- if (scalar(@Apache::londefdef::table) > 0) {
-
- for (my $in=0;$in<=$Apache::londefdef::table[-1]{'row_number'};$in++) {
- for (my $jn=0;$jn<=$Apache::londefdef::table[-1]{'counter_columns'};$jn++) {
- if ($Apache::londefdef::table[-1]{'TeXlen'}[0][$jn]<$Apache::londefdef::table[-1]{'TeXlen'}[$in][$jn]) {
- $Apache::londefdef::table[-1]{'TeXlen'}[0][$jn]=$Apache::londefdef::table[-1]{'TeXlen'}[$in][$jn];
- }
- }
- }
- #free space and number of empty columns
- my ($available_space,$empty_columns)=($Apache::londefdef::table[-1]{'width'},0);
- if ($#Apache::londefdef::table ne 0) {$available_space=0.9*$available_space;}
- for (my $jn=0;$jn<=$Apache::londefdef::table[-1]{'counter_columns'};$jn++) {
- if ($Apache::londefdef::table[-1]{'TeXlen'}[0][$jn]==0) {
- $empty_columns++;
- } else {
- $available_space=$available_space-$Apache::londefdef::table[-1]{'TeXlen'}[0][$jn];
- }
- }
-
- #boundaries for contents columns
- my @min_len=();#columns can not be narrower
- my @max_len=();#maximum length of column
- my $avg_max;
- my $avg_min;
- my $counter_cols = $Apache::londefdef::table[-1]{'counter_columns'};
- for (my $jn=0;$jn<=$counter_cols; $jn++) {
- my ($localmin,$localmax)=(0,0);
- for (my $in=0;$in<=$Apache::londefdef::table[-1]{'row_number'};$in++) {
- if ($localmin<$Apache::londefdef::table[-1]{'minlen'}[$in][$jn]) {
- $localmin=$Apache::londefdef::table[-1]{'minlen'}[$in][$jn];
- }
- if ($localmax<$Apache::londefdef::table[-1]{'maxlen'}[$in][$jn]) {
- $localmax=$Apache::londefdef::table[-1]{'maxlen'}[$in][$jn];
- }
- }
- push @min_len, $localmin;
- push @max_len, $localmax;
- $avg_max = $localmax + $avg_max;
- $avg_min = $localmin + $avg_min;
- }
- # Does not really matter what the average max/min are if there are no cols.
- # and this prevents div 0 in that case.
-
- if ($counter_cols != 0) {
- $avg_max = $avg_max/$counter_cols;
- $avg_min = $avg_min/$counter_cols;
- }
-
-
- # I don't think the below is needed.. but just in case:
-
- if ($avg_min > $avg_max) {
- my $temp = $avg_min;
- $avg_min = $avg_max;
- $avg_max = $temp;
- }
-
-
- for (my $jn=0;$jn<=$counter_cols;$jn++) {
- my $localmin=0,;
- for (my $in=0;$in<=$Apache::londefdef::table[-1]{'row_number'};$in++) {
- if ($localmin<$Apache::londefdef::table[-1]{'objectlen'}[$in][$jn]) {
- $localmin=$Apache::londefdef::table[-1]{'objectlen'}[$in][$jn];
- }
- }
- if ($max_len[$jn]<$localmin) {
- $max_len[$jn]=$localmin;
- $Apache::londefdef::table[-1]{'objectsignal'}[$jn]=1;
- }#object size is bigger
- if ($min_len[$jn]<$localmin) {
- $min_len[$jn]=$localmin;
- $Apache::londefdef::table[-1]{'objectsignal'}[$jn]=1;
- }#object size is bigger
- if ($Apache::londefdef::table[-1]{'TeXlen'}[0][$jn]!=0) {
- $min_len[$jn]=0;
- $max_len[$jn]=0;
- }
- # Spans seem to be really bothered by max/min = 0. So if we have one
- # make it an average joe max/min.
-
- if ($max_len[$jn] == 0) {
- $max_len[$jn] = $avg_max;
- }
- if ($min_len[$jn] == 0) {
- $min_len[$jn] = $avg_min;
- }
-
- }
- #final adjustment of column width
- my @fwidth=@{$Apache::londefdef::table[-1]{'TeXlen'}[0]};#final width array
- my @adjust=();
- #step 1. adjustment by maximum value
- my $space_needed=0;
- for (my $jn=0;$jn<=$#max_len;$jn++) {
- $space_needed=$space_needed+$max_len[$jn];
- }
- if ($space_needed<=$available_space) {
-
- for (my $jn=0;$jn<=$#max_len;$jn++) {
- if ($fwidth[$jn]==0) {
- $fwidth[$jn]=$max_len[$jn];
- }
- }
- } else {
- #step 2. adjustment by minimum value (estimation)
- $space_needed=0;
- for (my $jn=0;$jn<=$#min_len;$jn++) {
- $space_needed+=$min_len[$jn];
- }
- if ($space_needed>$available_space) {
- $WARNING=' \textbf{NOT ENOUGH SPACE FOR TABLE} ';
- for (my $jn=0;$jn<=$#max_len;$jn++) {
- if ($fwidth[$jn]==0) {
- $fwidth[$jn]=$min_len[$jn];
- }
- }
- #check if we have objects which can be scaled
- my $how_many_to_scale=0;
- my @to_scale=();
- for (my $jn=0;$jn<=$#max_len;$jn++) {
- if ($Apache::londefdef::table[-1]{'objectsignal'}[$jn] eq '1') {
- $how_many_to_scale++;
- push @to_scale, $jn;
- }
- }
- if ($how_many_to_scale>0) {
- my $space_to_adjust=($space_needed-$available_space)/$how_many_to_scale;
- foreach my $jn (@to_scale) {
- for (my $in=0;$in<=$Apache::londefdef::table[-1]{'row_number'};$in++) {
- $Apache::londefdef::table[-1]{'content'}[$in][$jn]=~m/width\s*=\s*(\d+\.?\d*\s*(mm|cm|in|pc|pt)*)/;
- if ($1 ne '') {
- my $current_length=&recalc($1);
- $current_length=~/(\d+\.?\d*)/;
- $current_length=$current_length-$space_to_adjust;
- $Apache::londefdef::table[-1]{'content'}[$in][$jn]=~s/width\s*=\s*(\d+\.?\d*\s*(mm|cm|in|pc|pt)*)/width=$current_length mm/;
- }
- $Apache::londefdef::table[-1]{'content'}[$in][$jn]=~m/\[(\d+\.?\d*)\s*mm\]/;
- if ($1 ne '') {
- my $current_length=$1;
- $current_length=$current_length-$space_to_adjust;
- $Apache::londefdef::table[-1]{'content'}[$in][$jn]=~s/\[(\d+\.?\d*)\s*mm\]/\[$current_length mm\]/;
- }
- }
- $fwidth[$jn]=$fwidth[$jn]-$space_to_adjust;
- }
- }
- } else {
- #step 3. adjustment over minimal + corrections
- my $enlarge_coef=$available_space/$space_needed;
- my $acsessive=0;
- for (my $jn=0;$jn<=$#min_len;$jn++) {
- $adjust[$jn]=$min_len[$jn]*$enlarge_coef;
- if ($adjust[$jn]>$max_len[$jn]) {
- $fwidth[$jn]=$max_len[$jn];
- $acsessive=$acsessive+$adjust[$jn]-$max_len[$jn];
- $adjust[$jn]=0;
-
- }
- }
- if ($acsessive>0) {
- #we have an excess of space and can redistribute it
- my $notempty_columns=0;
- for (my $jn=0;$jn<=$#min_len;$jn++) {
- if ($adjust[$jn]!=0) {
- $notempty_columns++;
- }
- }
- my $per_column=$acsessive/$notempty_columns;
- for (my $jn=0;$jn<=$#min_len;$jn++) {
- if ($adjust[$jn]!=0) {
- $adjust[$jn]+=$per_column;
- $fwidth[$jn]=$adjust[$jn];
- }
- }
- } else {
- for (my $jn=0;$jn<=$#min_len;$jn++) {
- $fwidth[$jn]=$adjust[$jn];
- }
- }
- }
- }
- # use all available width or specified width as if not specified,
- # the specified width gets defaulted to the available width.
-
- my $current=0;
- for (my $i=0;$i<=$#fwidth;$i++) {
- $current+=$fwidth[$i];
- }
- if ($current == 0) {
- $current = $Apache::londefdef::table[-1]{'width'};
- }
- my $coef=$Apache::londefdef::table[-1]{'width'}/$current;
- for (my $i=0;$i<=$#fwidth;$i++) {
- $fwidth[$i]*=$coef;
- }
- #removing of empty columns if allowed
- my $permission=&Apache::lonxml::get_param('TeXDropEmptyColumns',$parstack,$safeeval,undef,0);
- if ($permission eq 'yes') {
- my @cleaned_table=();
- my @cleaned_header=();
- my $colind=0;
- for (my $jn=0;$jn<=$Apache::londefdef::table[-1]{'counter_columns'};$jn++) {
- if ($fwidth[$jn]!=0) {
- #we need to copy column
- for (my $in=0;$in<=$Apache::londefdef::table[-1]{'row_number'};$in++) {
- $cleaned_table[$in][$colind]=$Apache::londefdef::table[-1]{'content'}[$in][$jn];
- $cleaned_header[$colind]=$fwidth[$jn];
- }
- $colind++;
- }
- }
- $Apache::londefdef::table[-1]{'content'}=\@cleaned_table;
- @fwidth=@cleaned_header;
- }
-
-
- #construct header of the table
- my $header_of_table = '{'.$Apache::londefdef::table[-1]{'vvinc'};
- for (my $in=0;$in<=$#fwidth;$in++) {
- $header_of_table.='p{'.$fwidth[$in].' mm}'.$Apache::londefdef::table[-1]{'vvinc'};
- }
- $header_of_table .= '}';
-
- #fill the table
- for (my $in=0;$in<=$Apache::londefdef::table[-1]{'row_number'};$in++) {
- my $have_rowspan = 0;
- for (my $jn=0;$jn<=$#fwidth;$jn++) {
-
- #-----------------------------------------------------------
- # I think this order of doing things will ensure that
- # single rowspan, columspan and combined row/colspans will
- # work correctly. LaTeX is delicate here.
- # RF.
-
- # Start a rowspan if necessary:
-
- my $primary_col_width = $fwidth[$jn]; # Width of primary column.
- my $rowspan = $Apache::londefdef::table[-1]{'rowspan'}[$in][$jn];
- my $colspan = $Apache::londefdef::table[-1]{'colspan'}[$in][$jn];
- #
- # Do the appropriate magic if this has a colspan
- #
-
- my $border_char = "";
- if ($border) {
- $border_char = "|";
- }
- my $spanwidth = 0;
- if ($colspan > 1) {
- for (my $spancol = $jn; $spancol < $jn + $colspan; $spancol++) {
- $spanwidth += $fwidth[$spancol];
- }
- $output .= '\multicolumn{'.
- $colspan
- ."}";
- if ($Apache::londefdef::table[-1]{'align'}[$in][$jn] eq 'c') {
- $output .= '{'.$border_char.'c'.$border_char.'}{';
- } elsif ($Apache::londefdef::table[-1]{'align'}[$in][$jn] eq 'r') {
- $output .= '{'.$border_char.'r'.$border_char.'}{';
- }
- else {
- $output .= '{'.$border_char."p{$spanwidth mm}".$border_char.'}{';
- }
-
- } else {
- $spanwidth = $primary_col_width; # If no span width will be just colwidth
- }
-
- # Rowspan... if colspan is 1, and there's an alignment we'll need
- # to kick in a multicolumn in order to get the alignment spec.
- # this must precede the multirow or LaTex gets quite upset.
- # Naturally if colspan > 1 we've already done that above ^
- #
- my $multirow_aligned = 0;
- if ($rowspan > 1) {
- if ($colspan == 1) {
- if ($Apache::londefdef::table[-1]{'align'}[$in][$jn] eq 'c') {
- $output .= '\multicolumn{1}{'.$border_char.'c'.$border_char.'}{';
- $multirow_aligned = 1;
- } elsif ($Apache::londefdef::table[-1]{'align'}[$in][$jn] eq 'r') {
- $output .= '\multicolumn{1}{'.$border_char.'r'.$border_char.'}{';
- $multirow_aligned = 1;
- }
- }
- $have_rowspan++;
- if ($multirow_aligned) {
- $output .= '\multirow{'.$rowspan.'}[0]{*}{';
- } else {
- $output .= '\multirow{'.$rowspan."}[0]{$spanwidth mm}{";
- }
-
- $Apache::londefdef::table[-1]{'content'}[$in][$jn] =~
- s{^\s*\\par\s*}{};
- $Apache::londefdef::table[-1]{'content'}[$in][$jn] =~
- s{\s*\\vskip\s*0pt\s*$}{};
-
- #
- # If we did not throw in a multicolumn to align, then add
- # an extra {
- # so we close correctly without having to keep additional state
- # around
- #
- if (!$multirow_aligned) {
- $output .= '{';
- }
- }
- if (($rowspan eq '^') || ($rowspan eq '_')) {
- $have_rowspan++;
- }
- #--------------------------------------------------------------
-
-
- # For right and center alignment of single cells.
- # we are going to use a multicolumn with a span of 1 to specify alignment.
- #
- if ($colspan == 1 && $rowspan == 1) {
- if ($Apache::londefdef::table[-1]{'align'}[$in][$jn] eq 'c') {
- $output .= '\multicolumn{1}{'.$border_char.'c'.$border_char.'}{';
- } elsif ($Apache::londefdef::table[-1]{'align'}[$in][$jn] eq 'r') {
- $output .= '\multicolumn{1}{'.$border_char.'r'.$border_char.'}{';
- }
- }
-
- $output.=$Apache::londefdef::table[-1]{'content'}[$in][$jn];
-
- if (($colspan == 1 && $rowspan == 1) &&
- (($Apache::londefdef::table[-1]{'align'}[$in][$jn] eq 'c') ||
- ($Apache::londefdef::table[-1]{'align'}[$in][$jn] eq 'r'))) {
- $output .= '}';
- }
-
- # Close off any open multirow:
-
- if ($rowspan > 1) {
- $output .= '}}';
- }
- # Close off the colspan...
- #
- if ($colspan > 1) {
- $output .= '}';
- $jn += $colspan-1; # Adjust for number of rows really left.
- }
- if ($jn!=$#fwidth) {$output.=' '.$Apache::londefdef::table[-1]{'vinc'};}
- }
- # If have_rowspan > 0, and borders are on, then
- # we need to do more than put an \hline at the bottom of row.
- # we need to do the appropriate \cline to ensure that
- # the spanned rows don't have \hlines through them.
-
- if (($Apache::londefdef::table[-1]{'hinc'} =~ /\\hline/) && $have_rowspan) {
- $output .= ' \\\\ ';
- for (my $jn=0; $jn<=$#fwidth;$jn++) {
- my $rowspan = $Apache::londefdef::table[-1]{'rowspan'}[$in][$jn];
- if ($rowspan ne "^") {
- if (($rowspan <= 1) || ($rowspan eq '_')) {
- my $column = $jn+1;
- $output .= '\cline{'.$column.'-'.$column.'} ';
- }
- }
- }
-
- } else {
- $output.=' \\\\ '.$Apache::londefdef::table[-1]{'hinc'}.' ';
- }
- }
- # Note that \newline destroys alignment env's produced by e.g. <div>
- # $Apache::londefdef::table[-1]{'output'} .= $header_of_table.$Apache::londefdef::table[-1]{'hinc'}.$output.'\end{tabular}\strut\newline\strut ';
- $Apache::londefdef::table[-1]{'output'} .= $header_of_table.$Apache::londefdef::table[-1]{'hinc'}.$output.'\end{tabular}\strut'.'\\\\'."\n".'\strut ';
- if ($#Apache::londefdef::table > 0) {
- my $inmemory = $Apache::londefdef::table[-1]{'output'};
- # Figure out max/and min width by summing us and then
- # apply that to the current column of the table we nest in
- # if it's larger than the current width or the current width
- # is undefined.
- #
- my $min_nested_width = 0;
- my $max_nested_width = 0;
- for (my $col = 0; $col <= $Apache::londefdef::table[-1]{'counter_columns'}; $col++) {
- $min_nested_width += $min_len[$col];
- $max_nested_width += $max_len[$col];
-
- }
- # Fudge in an extra 5 mm for borders etc:
-
- $min_nested_width += 5;
- $max_nested_width += 5;
-
- my $outer_column = $Apache::londefdef::table[-2]{'counter_columns'};
- my $outer_row = $Apache::londefdef::table[-2]{'row_number'};
- if ($min_nested_width > $Apache::londefdef::table[-2]{'minlen'}[$outer_row][$outer_column]) {
- $Apache::londefdef::table[-2]{'minlen'}[$outer_row][$outer_column] = $min_nested_width;
- }
- if ($max_nested_width > $Apache::londefdef::table[-2]{'maxlen'}[$outer_row][$outer_column]) {
- $Apache::londefdef::table[-2]{'maxlen'}[$outer_row][$outer_column] = $max_nested_width;
- }
-
- pop @Apache::londefdef::table;
- push @{$Apache::londefdef::table[-1]{'include'}}, $inmemory;
- } else {
- $currentstring .= $Apache::londefdef::table[-1]{'output'};
- pop @Apache::londefdef::table;
- undef @Apache::londefdef::table;
- }
- }
- &enable_para();
- }
+
}
return $currentstring;
}
@@ -2733,7 +2313,7 @@
#
sub cell_config_hash {
- my ($align, $rowspan, $colspan) = @_;
+ my ($align, $rowspan, $colspan, $width) = @_;
my %config;
if ($align ne '') {
$config{'halign'} = $align;
@@ -2744,6 +2324,9 @@
if ($rowspan ne '') {
$config{'rowspan'} = $rowspan;
}
+ if ($width ne '') {
+ $config{'width'} = $width;
+ }
return \%config;
}
@@ -2755,11 +2338,11 @@
# attributes, but empty of text. end_td_tex will
# fetch the contents from the recursive parse and
# fill the cell with them:
- my $align = &Apache::lonxml::get_param('align', $parstack, $safeeval, undef, 1);
- my $rowspan = &Apache::lonxml::get_param('rowspan', $parstack, $safeeval, undef, 1);
- my $colspan = &Apache::lonxml::get_param('colspan', $parstack, $safeeval, undef, 1);
-
- my $config = &cell_config_hash($align, $rowspan, $colspan);
+ my $align = &Apache::lonxml::get_param('align', $parstack, $safeeval);
+ my $rowspan = &Apache::lonxml::get_param('rowspan', $parstack, $safeeval);
+ my $colspan = &Apache::lonxml::get_param('colspan', $parstack, $safeeval);
+ my $width = &Apache::lonxml::get_param('TeXwidth', $parstack, $safeeval);
+ my $config = &cell_config_hash($align, $rowspan, $colspan, $width);
my $table = $Apache::londefdef::table[-1];
$table->add_cell('', $config);
Index: loncom/xml/lontable.pm
diff -u loncom/xml/lontable.pm:1.13 loncom/xml/lontable.pm:1.14
--- loncom/xml/lontable.pm:1.13 Tue Sep 28 22:55:41 2010
+++ loncom/xml/lontable.pm Mon Nov 1 10:52:09 2010
@@ -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 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 @@
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 @@
column_count => 0,
row_open => 0,
rows => [],
+ col_widths => {}
};
foreach my $key (keys %$configuration) {
@@ -548,6 +548,7 @@
"top", "bottom" or "center"
+
=back
=cut
@@ -605,6 +606,13 @@
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 @@
$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 @@
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 @@
# 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 @@
# 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 @@
}
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 @@
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 @@
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__
+
--foxr1288608729--