version 1.5, 2008/12/09 11:50:08
|
version 1.6, 2008/12/23 11:49:32
|
Line 164 Table caption (configurable).
|
Line 164 Table caption (configurable).
|
|
|
Theme desired (configurable). |
Theme desired (configurable). |
|
|
|
=item width |
|
|
|
If defined, the width of the table (should be supplied |
|
in fraction of column width e.g. .75 for 75%. |
|
|
=item row_open |
=item row_open |
|
|
True if a row is open and not yet closed. |
True if a row is open and not yet closed. |
Line 189 Default horizontal alignment for cells i
|
Line 194 Default horizontal alignment for cells i
|
|
|
Default vertical alignment for cells in this row (may be ignored). |
Default vertical alignment for cells in this row (may be ignored). |
|
|
|
=item cell_width |
|
|
|
The width of the row in cells. This is the sum of the column spans |
|
of the cells in the row. |
|
|
=item cells |
=item cells |
|
|
Array of hashes where each element represents the data for a cell. |
Array of hashes where each element represents the data for a cell. |
Line 218 If present, indicates the number of rows
|
Line 228 If present, indicates the number of rows
|
If present indicates the number of columns this cell spans. |
If present indicates the number of columns this cell spans. |
Note that a cell can span both rows and columns. |
Note that a cell can span both rows and columns. |
|
|
|
=item start_col |
|
|
|
The starting column of the cell in the table grid. |
|
|
=item contents |
=item contents |
|
|
The contents of the cell. |
The contents of the cell. |
Line 420 sub start_row {
|
Line 434 sub start_row {
|
my $row_hash = { |
my $row_hash = { |
default_halign => "left", |
default_halign => "left", |
default_valign => "top", |
default_valign => "top", |
|
cell_width => 0, |
cells => [] |
cells => [] |
}; |
}; |
|
|
Line 459 sub end_row {
|
Line 474 sub end_row {
|
# Mostly we need to determine if this row has the maximum |
# Mostly we need to determine if this row has the maximum |
# cell count of any row in existence in the table: |
# cell count of any row in existence in the table: |
|
|
my $row = $self->{'rows'}[-1]; |
my $row = $self->{'rows'}->[-1]; |
my $cells = $row->{'cells'}; |
my $cells = $row->{'cells'}; |
my $raw_cell_count = scalar(@$cells); |
|
|
|
# Need to iterate through the columns as |
if ($row->{'cell_width'} > $self->{'column_count'}) { |
# colspans affect the count: |
$self->{'column_count'} = $row->{'cell_width'}; |
# |
|
my $cell_count = 0; |
|
for (my $i =0; $i < $raw_cell_count; $i++) { |
|
$cell_count = $cell_count + $cells->[$i]->{'colspan'}; |
|
} |
|
if ($cell_count > $self->{'column_count'}) { |
|
$self->{'column_count'} = $cell_count; |
|
} |
} |
|
|
$self->{'row_open'} = 0;; |
$self->{'row_open'} = 0;; |
Line 572 sub add_cell {
|
Line 579 sub add_cell {
|
if (!$self->{'row_open'}) { |
if (!$self->{'row_open'}) { |
$self->start_row(); |
$self->start_row(); |
} |
} |
|
my $rows = $self->{'rows'}; |
my $current_row = $self->{'rows'}->[-1]; |
my $current_row = $rows->[-1]; |
my $current_cells = $current_row->{'cells'}; |
my $current_cells = $current_row->{'cells'}; |
|
my $last_coord = $current_row->{'cell_width'}; |
|
|
# The way we handle row spans is to insert additional |
# We have to worry about row spans if there is a prior row: |
# blank cells as needed to reach this column. Each |
|
# cell that is inserted is empty, but has a row span decreased by one |
|
# from the row above. Column spans are propagated down from the row above |
|
# and handled when the table's LaTeX is generated. |
|
# There must be at least two rows in the row table to need to do this: |
|
|
|
my $rows = $self->{'rows'}; |
if (scalar(@$rows) > 1) { |
my $row_count = scalar(@$rows); |
|
if ($row_count > 1) { |
|
my $prior_row = $rows->[-2]; |
|
my $cells = $current_row->{'cells'}; |
|
my $prior_cells = $prior_row->{'cells'}; |
|
my $curr_colcount = scalar(@$cells); |
|
|
|
my $prior_colcount = scalar(@$prior_cells); |
|
|
|
while (($curr_colcount < $prior_colcount) && |
my $last_row = $rows->[-2]; |
$prior_cells->[$curr_colcount]->{'rowspan'} > 1) { |
if ($last_coord < $last_row->{'cell_width'}) { |
my %cell; |
my $prior_coord = 0; |
my $prior_cell = $prior_cells->[$curr_colcount]; |
my $prior_cell_index = 0; |
%cell = %$prior_cell; |
while ($prior_coord <= $last_coord) { |
$cell{'rowspan'}--; |
|
$cell{'contents'} = ""; |
# Pull a cell down if it's coord matches our start coord |
push(@$current_cells, \%cell); |
# And there's a row span > 1. |
$curr_colcount += $prior_cells->[$curr_colcount]->{'colspan'}; # could be a colspan too. |
# Having done so, we adjust our $last_coord to match the |
|
# end point of the pulled down cell. |
|
|
|
my $prior_cell = $last_row->{'cells'}->[$prior_cell_index]; |
|
if (($prior_cell->{'start_col'} == $last_coord) && |
|
($prior_cell->{'rowspan'} > 1)) { |
|
|
|
# Need to drop the cell down |
|
|
|
my %dropped_down_cell = %$prior_cell; |
|
$dropped_down_cell{'rowspan'}--; |
|
$dropped_down_cell{'contents'} = ''; |
|
|
|
push(@$current_cells, \%dropped_down_cell); |
|
$last_coord += $dropped_down_cell{'colspan'}; |
|
$current_row->{'cell_width'} = $last_coord; |
|
|
|
} |
|
$prior_coord += $prior_cell->{'colspan'}; |
|
$prior_cell_index++; |
|
} |
} |
} |
|
|
} |
} |
|
|
# |
# |
# Now we're ready to build up our cell: |
# Now we're ready to build up our cell: |
|
|
my $cell = { |
my $cell = { |
rowspan => 1, |
rowspan => 1, |
colspan => 1, |
colspan => 1, |
|
start_col => $last_coord, |
contents => $text |
contents => $text |
}; |
}; |
|
|
Line 618 sub add_cell {
|
Line 636 sub add_cell {
|
$cell->{$key} = $config->{$key}; |
$cell->{$key} = $config->{$key}; |
} |
} |
} |
} |
|
$current_row->{'cell_width'} += $cell->{'colspan'}; |
|
|
push(@$current_cells, $cell); |
push(@$current_cells, $cell); |
} |
} |
|
|
|
=pod |
|
|
|
=head2 generate |
|
|
|
Call this when the structures for the table have been built. |
|
This will generate and return the table object that can be used |
|
to generate the table. Returning the table object allows for |
|
a certain amount of testing to be done on the generated table. |
|
The caller can then ask the table object to generate LaTeX. |
|
|
|
=cut |
|
sub generate { |
|
my ($this) = @_; |
|
|
|
my $table = LaTeX::Table->new(); |
|
|
|
# Build up the data: |
|
|
|
my @data; |
|
my $rows = $this->{'rows'}; |
|
my $row_count = scalar(@$rows); |
|
my $inner_border = $this->{'inner_border'}; |
|
my $outer_border = $this->{'outer_border'}; |
|
my $column_count = $this->{'column_count'}; |
|
|
|
for (my $row = 0; $row < $row_count; $row++) { |
|
my @row; |
|
my $cells = $rows->[$row]->{'cells'}; |
|
my $cell_count = scalar(@$cells); |
|
my $startcol = 1; |
|
my @underlines; # Array of \cline cells if cellborder on. |
|
|
|
for (my $cell = 0; $cell < $cell_count; $cell++) { |
|
my $contents = $cells->[$cell]->{'contents'}; |
|
my $cspan = $cells->[$cell]->{'colspan'}; |
|
my $nextcol = $startcol + $cspan; |
|
if ($cspan > 1) { |
|
$contents = '\multicolumn{'.$cspan.'}{|l|}{'.$contents.'}'; |
|
} |
|
if ($inner_border && ($cells->[$cell]->{'rowspan'} == 1)) { |
|
my $lastcol = $nextcol -1; |
|
push(@underlines, "\\cline{$startcol-$lastcol}"); |
|
} |
|
$startcol = $nextcol; |
|
# Rowspans should take care of themselves. |
|
|
|
|
|
push(@row, $contents); |
|
|
|
} |
|
push(@data, \@row); |
|
if ($inner_border) { |
|
for (my $i =0; $i < scalar(@underlines); $i++) { |
|
push(@data, [$underlines[$i]]); |
|
} |
|
} |
|
|
|
} |
|
$table->set_data(\@data); |
|
|
|
my $coldef = ""; |
|
if ($outer_border || $inner_border) { |
|
$coldef .= '|'; |
|
} |
|
for (my $i =0; $i < $column_count; $i++) { |
|
$coldef .= 'l'; |
|
if ($inner_border || |
|
($outer_border && ($i == $column_count-1))) { |
|
$coldef .= '|'; |
|
} |
|
} |
|
$table->{'coldef'} = $coldef; |
|
|
|
# Return the table: |
|
|
|
return $table; |
|
|
|
} |
|
#---------------------------------------------------------------------------- |
# The following methods allow for testability. |
# The following methods allow for testability. |
|
|
|
|