[BACK]Return to lontable.pm CVS log [TXT] [DIR] Up to [LON-CAPA] / loncom / xml

Diff for /loncom/xml/lontable.pm between versions 1.5 and 1.6

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.
   
   
Removed from v.1.5  
changed lines
  Added in v.1.6

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>