version 1.8, 2009/01/20 12:01:01
|
version 1.14, 2010/11/01 10:52:09
|
Line 38
|
Line 38
|
# |
# |
|
|
# This module is a support packkage that helps londefdef generate |
# This module is a support packkage that helps londefdef generate |
# LaTeX tables using the LaTeX::Table package. A prerequisite is that |
# LaTeX tables using the Apache::lonlatextable package. A prerequisite is that |
# the print generator must have added the following to the LaTeX |
# the print generator must have added the following to the LaTeX |
# |
# |
# \usepackage{xtab} |
# \usepackage{xtab} |
Line 55
|
Line 55
|
|
|
package Apache::lontable; |
package Apache::lontable; |
use strict; |
use strict; |
use LaTeX::Table; |
use Apache::lonlatextable; |
use Apache::lonnet; # for trace logging. |
use Apache::lonnet; # for trace logging. |
|
|
my $tracing = 0; # 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. |
Line 65 my $tracing = 0; # Set to 1 to enable l
|
Line 65 my $tracing = 0; # Set to 1 to enable l
|
=head1 lontable Table generation assistant for the LaTeX target |
=head1 lontable Table generation assistant for the LaTeX target |
|
|
This module contains support software for generating tables in LaTeX output mode |
This module contains support software for generating tables in LaTeX output mode |
In this implementation, we use the LaTeX::Table package to do the actual final formatting. |
In this implementation, we use the Apache::lonlatextable package to do the actual final formatting. |
Each table creates a new object. Table objects can have global properties configured. |
Each table creates a new object. Table objects can have global properties configured. |
The main operations on a table object are: |
The main operations on a table object are: |
|
|
Line 131 The table caption text.
|
Line 131 The table caption text.
|
|
|
The theme of the table to use. Defaults to Zurich. Themes we know about are: |
The theme of the table to use. Defaults to Zurich. Themes we know about are: |
NYC, NYC2, Zurich, Berlin, Dresden, Houston, Miami, plain, Paris. Other themes can be added |
NYC, NYC2, Zurich, Berlin, Dresden, Houston, Miami, plain, Paris. Other themes can be added |
to the LaTeX::Table package, and they will become supported automatically, as theme names are |
to the Apache::lonlatextable package, and they will become supported automatically, as theme names are |
not error checked. Any use of a non-existent theme is reported by the LaTeX::Table package |
not error checked. Any use of a non-existent theme is reported by the Apache::lonlatextable package |
when the table text is generated. |
when the table text is generated. |
|
|
=item width |
=item width |
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 265 sub new {
|
Line 264 sub new {
|
outer_border => 0, |
outer_border => 0, |
inner_border => 0, |
inner_border => 0, |
caption => "", |
caption => "", |
theme => "Zurich", |
theme => "plain", |
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 = LaTeX::Table->new(); |
my $table = Apache::lonlatextable->new(); |
$table->set_center(0); # loncapa tables don't float. |
|
$table->set_environment(0); |
|
|
|
|
|
# Add the caption if supplied. |
# Add the caption if supplied. |
Line 743 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 761 sub generate {
|
Line 843 sub generate {
|
my $outer_border = $this->{'outer_border'}; |
my $outer_border = $this->{'outer_border'}; |
my $column_count = $this->{'column_count'}; |
my $column_count = $this->{'column_count'}; |
|
|
|
# Add a top line if the outer or inner border is enabled: |
|
|
|
if ($outer_border || $inner_border) { |
|
push(@data, ["\\cline{1-$column_count}"]); |
|
|
|
} |
|
|
for (my $row = 0; $row < $row_count; $row++) { |
for (my $row = 0; $row < $row_count; $row++) { |
my @row; |
my @row; |
my $cells = $rows->[$row]->{'cells'}; |
my $cells = $rows->[$row]->{'cells'}; |
Line 770 sub generate {
|
Line 859 sub generate {
|
my @underlines; # Array of \cline cells if cellborder on. |
my @underlines; # Array of \cline cells if cellborder on. |
|
|
|
|
|
|
for (my $cell = 0; $cell < $cell_count; $cell++) { |
for (my $cell = 0; $cell < $cell_count; $cell++) { |
my $contents = $cells->[$cell]->{'contents'}; |
my $contents = $cells->[$cell]->{'contents'}; |
|
|
Line 792 sub generate {
|
Line 882 sub generate {
|
|
|
if ($halign eq 'right') { |
if ($halign eq 'right') { |
$col_align = 'r'; |
$col_align = 'r'; |
$embeddedAlignStart = '\begin{flushright} '; |
$embeddedAlignStart = '\raggedleft'; |
$embeddedAlignEnd = ' \end{flushright}'; |
|
} |
} |
if ($halign eq 'center') { |
if ($halign eq 'center') { |
$col_align = 'c'; |
$col_align = 'c'; |
Line 805 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 855 sub generate {
|
Line 950 sub generate {
|
} |
} |
|
|
} |
} |
|
# |
|
# Add bottom border if necessary: if the inner border was on, the loops above |
|
# will have done a bottom line under the last cell. |
|
# |
|
if ($outer_border && !$inner_border) { |
|
push(@data, ["\\cline{1-$column_count}"]); |
|
|
|
} |
$table->set_data(\@data); |
$table->set_data(\@data); |
|
|
my $coldef = ""; |
my $coldef = ""; |
Line 863 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 878 sub generate {
|
Line 981 sub generate {
|
|
|
if ($tracing) { &Apache::lonnet::logthis("Leaving generate"); } |
if ($tracing) { &Apache::lonnet::logthis("Leaving 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 898 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__ |
|
|