version 1.13, 2010/09/28 22:55:41
|
version 1.14, 2010/11/01 10:52:09
|
Line 58 use strict;
|
Line 58 use strict;
|
use Apache::lonlatextable; |
use Apache::lonlatextable; |
use Apache::lonnet; # for trace logging. |
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 |
=pod |
|
|
Line 255 The contents of the cell.
|
Line 255 The contents of the cell.
|
sub new { |
sub new { |
my ($class, $configuration) = @_; |
my ($class, $configuration) = @_; |
|
|
if($tracing) {&Apache::lonnet::logthis("new table object");} |
|
|
|
# Initialize the object member data with the default values |
# Initialize the object member data with the default values |
# then override with any stuff in $configuration. |
# then override with any stuff in $configuration. |
Line 269 sub new {
|
Line 268 sub new {
|
column_count => 0, |
column_count => 0, |
row_open => 0, |
row_open => 0, |
rows => [], |
rows => [], |
|
col_widths => {} |
}; |
}; |
|
|
foreach my $key (keys %$configuration) { |
foreach my $key (keys %$configuration) { |
Line 548 The default vertical alignment for text
|
Line 548 The default vertical alignment for text
|
|
|
"top", "bottom" or "center" |
"top", "bottom" or "center" |
|
|
|
|
=back |
=back |
|
|
=cut |
=cut |
Line 605 Number of rows the cell spans.
|
Line 606 Number of rows the cell spans.
|
|
|
Number of columns 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 |
=back |
|
|
=cut |
=cut |
Line 679 sub add_cell {
|
Line 687 sub add_cell {
|
$cell->{$key} = $config->{$key}; |
$cell->{$key} = $config->{$key}; |
} |
} |
} |
} |
|
|
$current_row->{'cell_width'} += $cell->{'colspan'}; |
$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); |
push(@$current_cells, $cell); |
|
|
if ($tracing) { &Apache::lonnet::logthis("add_cell done"); } |
if ($tracing) { &Apache::lonnet::logthis("add_cell done"); } |
Line 726 The caller can then ask the table object
|
Line 760 The caller can then ask the table object
|
sub generate { |
sub generate { |
my ($this) = @_; |
my ($this) = @_; |
my $useP = 0; |
my $useP = 0; |
my $colwidth; |
|
my $colunits; |
my $colunits = 'cm'; # All widths get normalized to cm. |
|
my $tablewidth; |
|
|
if($tracing) {&Apache::lonnet::logthis("generate"); } |
if($tracing) {&Apache::lonnet::logthis("generate"); } |
my $table = Apache::lonlatextable->new(); |
my $table = Apache::lonlatextable->new(); |
|
|
|
|
|
|
# Add the caption if supplied. |
# Add the caption if supplied. |
|
|
if ($this->{'caption'} ne "") { |
if ($this->{'caption'} ne "") { |
Line 742 sub generate {
|
Line 776 sub generate {
|
|
|
# Set the width if defined: |
# Set the width if defined: |
|
|
|
my $default_width; |
|
my $colwidths = $this->{'col_widths'}; |
if (defined ($this->{'width'})) { |
if (defined ($this->{'width'})) { |
# $table->set_width($this->{'width'}); |
$tablewidth = $this->{'width'}; |
# $table->set_width_environment('tabularx'); |
$tablewidth = $this->size_to_cm($tablewidth); |
|
|
$useP = 1; |
$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: |
# Build up the data: |
|
|
my @data; |
my @data; |
Line 811 sub generate {
|
Line 894 sub generate {
|
# para mode; and wrap the contents in the start/stop stuff: |
# para mode; and wrap the contents in the start/stop stuff: |
|
|
if ($useP) { |
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}"; |
$col_align = "p{$cw $colunits}"; |
$contents = $embeddedAlignStart . $contents . $embeddedAlignEnd; |
$contents = $embeddedAlignStart . $contents . $embeddedAlignEnd; |
} |
} |
Line 877 sub generate {
|
Line 966 sub generate {
|
} |
} |
for (my $i =0; $i < $column_count; $i++) { |
for (my $i =0; $i < $column_count; $i++) { |
if ($useP) { |
if ($useP) { |
$coldef .= "p{$colwidth $colunits}"; |
$coldef .= "p{$default_width $colunits}"; |
} else { |
} else { |
$coldef .= 'l'; |
$coldef .= 'l'; |
} |
} |
Line 896 sub generate {
|
Line 985 sub generate {
|
return $table; |
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. |
# The following methods allow for testability. |
|
|
Line 913 sub get_row {
|
Line 1025 sub get_row {
|
my $rows = $self->{'rows'}; # ref to an array.... |
my $rows = $self->{'rows'}; # ref to an array.... |
return $rows->[$row]; # ref to the row hash for the selected row. |
return $rows->[$row]; # ref to the row hash for the selected row. |
} |
} |
|
|
# Mandatory initialization. |
# Mandatory initialization. |
BEGIN{ |
BEGIN{ |
} |
} |
|
|
1; |
1; |
__END__ |
__END__ |
|
|