Subversion Repositories DevTools

###############################################################################
# Codestriker: Copyright (c) 2001, 2002 David Sitsky.  All rights reserved.
# sits@users.sourceforge.net
#
# This program is free software; you can redistribute it and modify it under
# the terms of the GPL.

# Collection of routines for rendering HTML output.

package Codestriker::Http::Render;

use strict;
use DBI;
use CGI::Carp 'fatalsToBrowser';
use HTML::Entities ();

# Colour to use when displaying the line number that a comment is being made
# against.
my $CONTEXT_COLOUR = "red";

sub _normal_mode_start( $ );
sub _normal_mode_finish( $ );
sub _coloured_mode_start( $ );
sub _coloured_mode_finish( $ );

# New lines within a diff block.
my @diff_new_lines = ();

# The corresponding lines they refer to.
my @diff_new_lines_numbers = ();

# The corresponding offsets they refer to.
my @diff_new_lines_offsets = ();

# Old lines within a diff block.
my @diff_old_lines = ();

# The corresponding lines they refer to.
my @diff_old_lines_numbers = ();

# A record of added and removed lines for a given diff block when displaying a
# file in a popup window, along with their offsets.
my @view_file_minus = ();
my @view_file_plus = ();
my @view_file_minus_offset = ();
my @view_file_plus_offset = ();

# What colour a line should appear if it has a comment against it.
my $COMMENT_LINE_COLOUR = "red";

# Constructor for rendering complex data.
sub new ($$$$$$$\%\@$$\@\@\@\@$$) {
    my ($type, $query, $url_builder, $parallel, $max_digit_width, $topic,
        $mode, $comments, $tabwidth, $repository, $filenames_ref,
        $revisions_ref, $binaries_ref, $numchanges_ref, $max_line_length,
        $brmode, $fview) = @_;

    # Record all of the above parameters as instance variables, which remain
    # constant while we render code lines.
    my $self = {};
    $self->{query} = $query;
    $self->{url_builder} = $url_builder;
    $self->{parallel} = $parallel;
    $self->{max_digit_width} = $max_digit_width;
    $self->{topic} = $topic;
    $self->{mode} = $mode;
    if (! defined $brmode) {
        $brmode = $Codestriker::default_topic_br_mode;
    }
    if (! defined $fview) {
        $fview = $Codestriker::default_file_to_view;
    }   
    $self->{brmode} = $brmode;
    $self->{fview}  = $fview;
    $self->{comments} = $comments;
    $self->{tabwidth} = $tabwidth;
    $self->{repository} = $repository;
    $self->{filenames_ref} = $filenames_ref;
    $self->{revisions_ref} = $revisions_ref;
    $self->{binaries_ref} = $binaries_ref;
    $self->{numchanges_ref} = $numchanges_ref;
    $self->{max_line_length} = $max_line_length;
    $self->{old_linenumber} = 1;
    $self->{new_linenumber} = 1;

    # Get the main entry to the database
    my $topic_obj = Codestriker::Model::Topic->new($self->{topic});
    # Check for readonly
    $self->{topic_state} = $topic_obj->{topic_state};

    # Build a hash from filenumber|fileline|new -> comment array, so that
    # when rendering, lines can be coloured appropriately.  Also build a list
    # of what points in the review have a comment.  Also record a mapping
    # from filenumber|fileline|new -> the comment number.
    my %comment_hash = ();
    my @comment_locations = ();
    my %comment_location_map = ();
    for (my $i = 0; $i <= $#$comments; $i++) {
        my $comment = $$comments[$i];
        my $key = $comment->{filenumber} . "|" . $comment->{fileline} . "|" .
            $comment->{filenew};
        if (! exists $comment_hash{$key}) {
            push @comment_locations, $key;
            $comment_location_map{$key} = $#comment_locations;
        }
        push @{ $comment_hash{$key} }, $comment;
    }
    $self->{comment_hash} = \%comment_hash;
    $self->{comment_locations} = \@comment_locations;
    $self->{comment_location_map} = \%comment_location_map;

    # Also have a number of additional private variables which need to
    # be initialised.
    $self->{diff_current_filename} = "";
    $self->{diff_current_revision} = "";
    $self->{diff_current_repmatch} = 0;

    # Check if the repository has an associated LXR mapping, and if so, 
    # setup a db connection and prepare a select statement.
    if (defined $repository) {
        my $value = $Codestriker::lxr_map->{$repository->toString()};
        if (defined $value) {
            my %lxr = %{ $value };

            my $passwd = $lxr{password};
            if (! defined $passwd) {
                # For backwards compatibility.
                $passwd = $lxr{passwd};
            }
            my $dbh = DBI->connect($lxr{db}, $lxr{user}, $passwd,
                                   {AutoCommit=>0, RaiseError=>1})
                || die "Couldn't connect to database: " . DBI->errstr;
            my $select_ids =
                $dbh->prepare_cached('SELECT count(symname) FROM symbols where symname = ?');
            $self->{idhashref} = {};
            $self->{idhashsth} = $select_ids;
            $self->{idhashdbh} = $dbh;
            $self->{lxr_base_url} = $lxr{url};
        }
        else {
            # No LXR mapping defined for this repository.
            $self->{idhashref} = undef;
        }
    }
    else {
        # Topic has no repository, so no LXR mapping.
        $self->{idhashref} = undef;
    }

    bless $self, $type;
}

# cleanup, disconnect from the lxr database if connected
sub DESTROY {
    my $self = shift;
    $self->{idhashdbh}->disconnect() if exists $self->{idhashdbh};
} 


# Given an identifier, wrap it within the appropriate <A HREF> tag if it
# is a known identifier to LXR, otherwise just return the id.  To avoid
# excessive crap, only consider those identifiers which are at least 4
# characters long.
sub lxr_ident($$) {
    my ($self, $id) = @_;

    my $idhashref = $self->{idhashref};
    
    if (length($id) >= 4) {
        
        # Check if the id has not yet been found in lxr.
        if (not exists $idhashref->{$id}) {
            $idhashref->{$id} = 0;        # By default not found.
            my $sth = $self->{idhashsth}; # DB statement handle.

            # Fetch ids from lxr and store in hash.
            $sth->execute($id);
            ($idhashref->{$id}) = $sth->fetchrow_array();
        }
    }

    # Check if the id has been found in lxr.
    if ($$idhashref{$id}) {
        return "<A HREF=\"" . $self->{lxr_base_url} . "$id\" " .
            "CLASS=\"fid\">$id</A>";
    } else {
        return $id;
    }
}

# Parse the line and product the appropriate hyperlinks to LXR.
# Currently, this is very Java/C/C++ centric, but it will do for now.
sub lxr_data($$) {
    my ($self, $data) = @_;

    # Don't do anything if LXR is not enabled for this topic.
    return $data if ! defined $self->{idhashref};

    # If the line is just a comment, don't do any processing.  Note this code
    # isn't bullet-proof, but its good enough most of the time.
    $_ = $data;
    return $data if (/^(\s|&nbsp;)*\/\// || /^(\s|&nbsp;){0,10}\*/ ||
                     /^(\s|&nbsp;){0,10}\/\*/ ||
                     /^(\s|&nbsp;)*\*\/(\s|&nbsp;)*$/);
    
    # Handle package Java statements.
    if ($data =~ /^(package(\s|&nbsp;)+)([\w\.]+)(.*)$/) {
        return $1 . $self->lxr_ident($3) . $4;
    }
    
    # Handle Java import statements.
    if ($data =~ /^(import(\s|&nbsp;)+)([\w\.]+)\.(\w+)((\s|&nbsp;)*)(.*)$/) {
        return $1 . $self->lxr_ident($3) . "." . $self->lxr_ident($4) . "$5$7";
    }
    
    # Handle #include statements.  Note, these aren't identifier lookups, but
    # need to be mapped to http://localhost.localdomain/lxr/xxx/yyy/incfile.h
    # Should include the current filename in the object for matching purposes.
#    if (/^(\#\s*include\s+[\"<])(.*?)([\">].*)$/) {
#       return $1 . $self->lxr_ident($2) . $3;
#    }
    
    # Break the string into potential identifiers, and look them up to see
    # if they can be hyperlinked to an LXR lookup.
    my $idhashref = $self->{idhashref};
    my @data_tokens = split /([A-Za-z][\w]+)/, $data;
    my $newdata = "";
    my $in_comment = 0;
    my $eol_comment = 0;
    for (my $i = 0; $i <= $#data_tokens; $i++) {
        my $token = $data_tokens[$i];
        if ($token =~ /^[A-Za-z]/) {
            if ($eol_comment || $in_comment) {
                # Currently in a comment, don't LXRify.
                $newdata .= $token;
            } elsif ($token eq "nbsp" || $token eq "quot" || $token eq "amp" ||
                     $token eq "lt" || $token eq "gt") {
                # HACK - ignore potential HTML entities.  This needs to be
                # done in a smarter fashion later.
                $newdata .= $token;
            } else {
                $newdata .= $self->lxr_ident($token);
            }
        } else {
            $newdata .= $token;
            $token =~ s/(\s|&nbsp;)//g;
            
            # Check if we are entering or exiting a comment.
            if ($token =~ /\/\//) {
                $eol_comment = 1;
            } elsif ($token =~ /\*+\//) {
                $in_comment = 0;
            } elsif ($token =~ /\/\*/) {
                $in_comment = 1;
            }
        }
    }

    return $newdata;
}

# Render a delta.  If the filename has changed since the last delta, output the
# appropriate file headers. Pass in the delta object you want to render.
sub delta ($$$$$$$$$$) {
    my ($self, $delta) = @_;

    my $filename = $delta->{filename};
    my $filenumber = $delta->{filenumber},
    my $revision = $delta->{revision};
    my $old_linenumber = $delta->{old_linenumber};
    my $new_linenumber = $delta->{new_linenumber};
    my $text = $delta->{text};
    my $description = $delta->{description};
    my $binary = $delta->{binary};
    my $repmatch = $delta->{repmatch};

    # Don't do anything for binary files.
    return if $binary;

    my $query = $self->{query};

    if ($delta->is_delta_new_file() == 0)
    {
        # Check if the file heading needs to be output.
        if ($self->{diff_current_filename} ne $filename) {
            $self->delta_file_header($filename, $revision, $repmatch);
        }

        # Display the delta heading.
        $self->delta_heading($filenumber, $revision, $old_linenumber,
                             $new_linenumber, $description, $repmatch);

        # Now render the actual diff text itself.
        $self->delta_text($filename, $filenumber, $revision, $old_linenumber,
                          $new_linenumber, $text, $repmatch, 1, 1);
    }
    else
    {
        # Special formatting for full file upload that is not a diff.
        # If it not a diff, show the entire delta (actually the file
        # contents) in a single column.
        $self->delta_file_header($filename, $revision, $repmatch);

        print $query->Tr($query->td("&nbsp;"), $query->td("&nbsp;"),"\n");
        
        my @lines = split /\n/, $text;
        for (my $i = 0; $i <= $#lines; $i++) {
            my $line = $lines[$i];
            
            my $rendered_left_linenumber =
                $self->render_linenumber($i+1, $filenumber,1,1);
            
            # Removed the delta text, where + is added to the start of each
            # line.  Also make sure the line is suitably escaped.
            $line =~ s/^\+//;
            $line = HTML::Entities::encode($line);

            my $cell = $self->render_coloured_cell($line);
            my $cell_class =
                $self->{mode} == $Codestriker::COLOURED_MODE ? "n" : "msn";
            
            print $query->Tr($query->td($rendered_left_linenumber),
                             $query->td({-class=>$cell_class}, $cell),
                             "\n");
        }
    }
}

# Output the header for a series of deltas for a specific file.
sub delta_file_header ($$$$) {
    my ($self, $filename, $revision, $repmatch) = @_;

    my $filename_short = get_filename($filename);

    my $query = $self->{query};
    
    # We need the file names for building the forward and backward
    # url Strings.
    my $filenames = $self->{filenames_ref};

    # Close the table, update the current filename, and open a new table.
    print $query->end_table();
    $self->{diff_current_filename} = $filename;
    $self->{diff_current_revision} = $revision;
    $self->{diff_current_repmatch} = $repmatch;
    $self->print_coloured_table();

    # Url to the table of contents on the same page.
    my $contents_url =
        $self->{url_builder}->view_url($self->{topic}, -1,
                                       $self->{mode}, $self->{brmode},
                                       $self->{fview})
                                       . "#contents";
                                       
    # Variables to store the navigation Urls.   
    my $fwd_index = "";
    my $bwd_index = "";
    my $fwd_url   = "";
    my $bwd_url   = "";
    
    # Get the current file index.
    my $cfi = $self->{fview};
    
    # Store the current view mode, single view = 0, all files = -1.
    my $vmode = $self->{fview} == -1 ? -1 : 0; 
    
    # No better idea how I can get the array index of the current file. In the
    # single display mode you got it through fview - but in multi mode?
    if ($cfi == -1) {
        for (my $i = 0; $i <= $#$filenames; $i++) {
            if ($$filenames[$i] eq $filename) {
                $cfi = $i;
                last;
            }
        }
    }
    
    # Check the bounds for the previous and next browser.  A value of -1
    # indicates there it is not a valid link.
    $fwd_index = ($cfi+1 > $#$filenames ? -1 : $cfi+1);
    $bwd_index = ($cfi-1 < 0 ? -1 : $cfi-1);
        
    # Build the urls for next and previous file. Differ through $vmode
    # between all and single file review.
    if ($fwd_index != -1) {
        $fwd_url = $self->{url_builder}->view_url($self->{topic}, -1,
                                                  $self->{mode},
                                                  $self->{brmode},
                                                  $vmode == -1 ? -1 : $fwd_index)
                                                  . "#$$filenames[$fwd_index]";
    }
    if ($bwd_index != -1) {
        $bwd_url = $self->{url_builder}->view_url($self->{topic}, -1,
                                                  $self->{mode},
                                                  $self->{brmode},
                                                  $vmode == -1 ? -1 : $bwd_index)
                                                  . "#$$filenames[$bwd_index]";
    }

    # Generate the text for the link to add a file-level comment.
    my $add_file_level_comment_text =
        $self->render_comment_link($cfi, -1, 1, "[Add File Comment]",
                                   "file_comment", undef);

    if ($repmatch && $revision ne $Codestriker::ADDED_REVISION &&
        $revision ne $Codestriker::PATCH_REVISION) {
        # File matches something in the repository.  Link it to
        # the repository viewer if it is defined.
        my $cell = "";
        my $revision_text = "revision $revision";
        my $file_url = "";
        if (defined $self->{repository}) {
            $file_url = $self->{repository}->getViewUrl($filename);
        }

        if ($file_url eq "") {
            # Output the header without hyperlinking the filename.
            $cell = $query->td({-class=>'file', -colspan=>'3'},
                               "Diff for ",
                               $query->a({name=>$filename},
                                         $filename_short),
                               $revision_text);
        }
        else {
            # Link the filename to the repository system with more information
            # about it.
            $cell = $query->td({-class=>'file', -colspan=>'3'},
                               "Diff for ",
                               $query->a({href=>$file_url,
                                          name=>$filename},
                                         $filename_short),
                               $revision_text);
        }

        # Output the "back to contents" link and some browsing links
        # for visiting the previous and next file (<<, >>), in
        # addition to the "add file-level comment" link.

        print $query->Tr($cell,     # = file header     
                         $query->td({-class=>'file', align=>'right'},
                                    "$add_file_level_comment_text ",
                                    ($bwd_url ne "" ? $query->a({href=>$bwd_url},"[<<]") : ""),
                                    $query->a({href=>$contents_url},"[Top]"),
                                    ($fwd_url ne "" ? $query->a({href=>$fwd_url},"[>>]") : "")));
    } else {
        # No match in repository, or a new file.
        print $query->Tr($query->td({-class=>'file', -colspan=>'3'},
                                    "File ",
                                    $query->a({name=>$filename},$filename)),
                         $query->td({-class=>'file', align=>'right'},
                                    "$add_file_level_comment_text ",
                                    ($bwd_url ne "" ? $query->a({href=>$bwd_url},"[<<]") : ""),
                                    $query->a({href=>$contents_url},"[Top]"),
                                    ($fwd_url ne "" ? $query->a({href=>$fwd_url},"[>>]") : "")));
    }

}

# Output the delta heading, which consists of links to view the old and new
# file in its entirety.
sub delta_heading ($$$$$$$) {
    my ($self, $filenumber, $revision, $old_linenumber, $new_linenumber,
        $description, $repmatch) = @_;

    my $query = $self->{query};

    # Create some blank space.
    print $query->Tr($query->td("&nbsp;"), $query->td("&nbsp;"),
                     $query->td("&nbsp;"), $query->td("&nbsp;"), "\n");

    # Output a diff block description if one is available, in a separate
    # row.
    if ($description ne "") {
        my $description_escaped = HTML::Entities::encode($description);
        print $query->Tr($query->td({-class=>'line', -colspan=>'2'},
                                    $description_escaped),
                         $query->td({-class=>'line', -colspan=>'2'},
                                    $description_escaped));
    }

    if ($repmatch && $revision ne $Codestriker::ADDED_REVISION &&
        $revision ne $Codestriker::PATCH_REVISION) {
        # Display the line numbers corresponding to the patch, with links
        # to the entire file.
        my $url_builder = $self->{url_builder};
        my $topic = $self->{topic};
        my $mode = $self->{mode};
        my $url_old_full =
            $url_builder->view_file_url($topic, $filenumber, 0,
                                        $old_linenumber, $mode, 0);
        my $url_old = "javascript: myOpen('$url_old_full','CVS')";

        my $url_old_both_full =
            $url_builder->view_file_url($topic, $filenumber, 0,
                                        $old_linenumber, $mode, 1);
        my $url_old_both =
            "javascript: myOpen('$url_old_both_full','CVS')";

        my $url_new_full =
            $url_builder->view_file_url($topic, $filenumber, 1,
                                        $new_linenumber, $mode, 0);
        my $url_new = "javascript: myOpen('$url_new_full','CVS')";

        my $url_new_both_full =
            $url_builder->view_file_url($topic, $filenumber, 1,
                                        $new_linenumber, $mode, 1);
        my $url_new_both = "javascript: myOpen('$url_new_both_full','CVS')";

        print $query->Tr($query->td({-class=>'line', -colspan=>'2'},
                                    $query->a({href=>$url_old}, "Line " .
                                              $old_linenumber) .
                                    " | " .
                                    $query->a({href=>$url_old_both},
                                              "Parallel")),
                         $query->td({-class=>'line', -colspan=>'2'},
                                    $query->a({href=>$url_new}, "Line " .
                                              $new_linenumber) .
                                    " | " .
                                    $query->a({href=>$url_new_both},
                                              "Parallel"))),
                                    "\n";
    } else {
        # No match in the repository - or a new file.  Just display
        # the headings.
        print $query->Tr($query->td({-class=>'line', -colspan=>'2'},
                                    "Line $old_linenumber"),
                         $query->td({-class=>'line', -colspan=>'2'},
                                    "Line $new_linenumber")),
        "\n";
    }
}

# Output the delta text chunk in the coloured format.
sub delta_text ($$$$$$$$$$$) {
    my ($self, $filename, $filenumber, $revision, $old_linenumber,
        $new_linenumber, $text, $repmatch, $new, $link) = @_;

    my $query = $self->{query};

    # Split up the lines, and display them, with the appropriate links.
    my @lines = split /\n/, $text;
    $self->{old_linenumber} = $old_linenumber;
    $self->{new_linenumber} = $new_linenumber;
    for (my $i = 0; $i <= $#lines; $i++) {
        my $line = $lines[$i];
        if ($self->{parallel}) {
            $self->display_coloured_data($filenumber, $line, $link);
        } else {
            $self->display_single_filedata($filenumber, $line, $new, $link);
        }
    }

    # Render the diff blocks.
    if ($self->{parallel}) {
        $self->render_changes($filenumber, $link);
    } else {
        $self->flush_monospaced_lines($filenumber, $self->{max_line_length},
                                      $new, $link);
    }
}

# Display a line for coloured data.  Note special handling is done for
# unidiff formatted text, to output it in the "coloured-diff" style.  This
# requires storing state when retrieving each line.
sub display_coloured_data ($$$$) {
    my ($self, $filenumber, $data, $link) = @_;

    my $query = $self->{query};

    # Escape the data.
    $data = HTML::Entities::encode($data);

    my $leftline = $self->{old_linenumber};
    my $rightline = $self->{new_linenumber};
    if ($data =~ /^\-(.*)$/) {
        # Line corresponds to something which has been removed.
        add_old_change($1, $leftline);
        $leftline++;
    } elsif ($data =~ /^\+(.*)$/) {
        # Line corresponds to something which has been removed.
        add_new_change($1, $rightline);
        $rightline++;
    } elsif ($data =~ /^\\/) {
        # A diff comment such as "No newline at end of file" - ignore it.
    } else {
        # Strip the first space off the diff for proper alignment.
        $data =~ s/^\s//;

        # Render the previous diff changes visually.
        $self->render_changes($filenumber, $link);

        # Render the current line for both cells.
        my $celldata = $self->render_coloured_cell($data);

        # Determine the appropriate classes to render.
        my $cell_class =
            $self->{mode} == $Codestriker::COLOURED_MODE ? "n" : "msn";

        my $rendered_left_linenumber =
            $self->render_linenumber($leftline, $filenumber, 0, $link);
        my $rendered_right_linenumber =
            ($leftline == $rightline && !$self->{parallel}) ?
            $rendered_left_linenumber :
            $self->render_linenumber($rightline, $filenumber, 1, $link);

        print $query->Tr($query->td($rendered_left_linenumber),
                         $query->td({-class=>$cell_class}, $celldata),
                         $query->td($rendered_right_linenumber),
                         $query->td({-class=>$cell_class}, $celldata),
                         "\n");

        $leftline++;
        $rightline++;
    }

    # Update the left and right line nymber state variables.
    $self->{old_linenumber} = $leftline;
    $self->{new_linenumber} = $rightline;
}

# Render a cell for the coloured diff.
sub render_coloured_cell($$)
{
    my ($self, $data) = @_;

    if (! defined $data || $data eq "") {
        return "&nbsp;";
    }

    # Replace spaces and tabs with the appropriate number of &nbsp;'s.
    $data = tabadjust($self->{tabwidth}, $data, 1);
    if ($self->{brmode} == $Codestriker::LINE_BREAK_ASSIST_MODE) {
        $data =~ s/^(\s+)/my $sp='';for(my $i=0;$i<length($1);$i++){$sp.='&nbsp;'}$sp;/ge;
    }
    else {
    $data =~ s/\s/&nbsp;/g;
    }

    # Add LXR links to the output.
    $data = $self->lxr_data($data);

    # Unconditionally add a &nbsp; at the start for better alignment.
    return "&nbsp;$data";
}

# Indicate a line of data which has been removed in the diff.
sub add_old_change($$) {
    my ($data, $linenumber) = @_;
    push @diff_old_lines, $data;
    push @diff_old_lines_numbers, $linenumber;
}

# Indicate that a line of data has been added in the diff.
sub add_new_change($$) {
    my ($data, $linenumber) = @_;
    push @diff_new_lines, $data;
    push @diff_new_lines_numbers, $linenumber;
}

# Render the current diff changes, if there is anything.
sub render_changes($$$) {
    my ($self, $filenumber, $link) = @_;

    return if ($#diff_new_lines == -1 && $#diff_old_lines == -1);

    my ($arg1, $arg2, $arg3, $arg4);
    my $mode = $self->{mode};
    if ($#diff_new_lines != -1 && $#diff_old_lines != -1) {
        # Lines have been added and removed.
        if ($mode == $Codestriker::COLOURED_MODE) {
            $arg1 = "c"; $arg2 = "cb"; $arg3 = "c"; $arg4 = "cb";
        } else {
            $arg1 = "msc"; $arg2 = "mscb"; $arg3 = "msc"; $arg4 = "mscb";
        }
    } elsif ($#diff_new_lines != -1 && $#diff_old_lines == -1) {
        # New lines have been added.
        if ($mode == $Codestriker::COLOURED_MODE) {
            $arg1 = "a"; $arg2 = "ab"; $arg3 = "a"; $arg4 = "ab";
        } else {
            $arg1 = "msa"; $arg2 = "msab"; $arg3 = "msa"; $arg4 = "msab";
        }
    } else {
        # Lines have been removed.
        if ($mode == $Codestriker::COLOURED_MODE) {
            $arg1 = "r"; $arg2 = "rb"; $arg3 = "r"; $arg4 = "rb";
        } else {
            $arg1 = "msr"; $arg2 = "msrb"; $arg3 = "msr"; $arg4 = "msrb";
        }
    }
    $self->render_inplace_changes($arg1, $arg2, $arg3, $arg4, $filenumber,
                                  $link);

    # Now that the diff changeset has been rendered, remove the state data.
    @diff_new_lines = ();
    @diff_new_lines_numbers = ();
    @diff_old_lines = ();
    @diff_old_lines_numbers = ();
}

# Render the inplace changes in the current diff change set.
sub render_inplace_changes($$$$$$$)
{
    my ($self, $old_col, $old_notpresent_col, $new_col,
        $new_notpresent_col, $filenumber, $link) = @_;

    my $old_data;
    my $new_data;
    my $old_data_line;
    my $new_data_line;
    while ($#diff_old_lines != -1 || $#diff_new_lines != -1) {

        # Retrieve the next lines which were removed (if any).
        if ($#diff_old_lines != -1) {
            $old_data = shift @diff_old_lines;
            $old_data_line = shift @diff_old_lines_numbers;
        } else {
            undef($old_data);
            undef($old_data_line);
        }

        # Retrieve the next lines which were added (if any).
        if ($#diff_new_lines != -1) {
            $new_data = shift @diff_new_lines;
            $new_data_line = shift @diff_new_lines_numbers;
        } else {
            undef($new_data);
            undef($new_data_line);
        }

        my $render_old_data = $self->render_coloured_cell($old_data);
        my $render_new_data = $self->render_coloured_cell($new_data);
        
        # Set the colours to use appropriately depending on what is defined.
        my $render_old_colour = $old_col;
        my $render_new_colour = $new_col;
        if (defined $old_data && ! defined $new_data) {
            $render_new_colour = $new_notpresent_col;
        } elsif (! defined $old_data && defined $new_data) {
            $render_old_colour = $old_notpresent_col;
        }

        my $parallel = $self->{parallel};

        my $query = $self->{query};
        print $query->Tr($query->td($self->render_linenumber($old_data_line,
                                                             $filenumber,
                                                             0, $link)),
                         $query->td({-class=>"$render_old_colour"},
                                    $render_old_data),
                         $query->td($self->render_linenumber($new_data_line,
                                                             $filenumber,
                                                             1, $link)),
                         $query->td({-class=>"$render_new_colour"},
                                    $render_new_data), "\n");
    }
}
        
# Render a linenumber as a hyperlink.  If the line already has a
# comment made against it, render it with $comment_line_colour.  The
# title of the link should be set to the comment digest, and the
# status line should be set if the mouse moves over the link.
# Clicking on the link will take the user to the add comment page.
sub render_linenumber($$$$$) {
    my ($self, $line, $filenumber, $new, $link) = @_;

    if (! defined $line) {
        return "&nbsp;";
    }

    # Determine what class to use when rendering the number.
    my ($comment_class, $no_comment_class);
    if ($self->{mode} == $Codestriker::COLOURED_MODE) {
        $comment_class = "com";
        $no_comment_class = "nocom";
    } else {
        $comment_class = "smscom";
        $no_comment_class = "smsnocom";
    }

    # Check if the linenumber is outside the review.
    if ($link == 0) {
        return $line;
    }

    # Now render the line.
    return $self->render_comment_link($filenumber, $line, $new, $line,
                                      $comment_class, $no_comment_class);
}

# Render the supplied text within a edit comment link.
sub render_comment_link {
    my ($self, $filenumber, $line, $new, $text,
        $comment_class, $no_comment_class) = @_;

    # Determine the anchor and edit URL for this line number.
    my $anchor = "$filenumber|$line|$new";
    my $edit_url = "javascript:eo('$filenumber','$line','$new')";

    # Set the anchor to this line number.
    my $params = {};
    $params->{name} = $anchor;

    # Only set the href attribute if the comment is in open state.
    if (!Codestriker::topic_readonly($self->{topic_state})) {
            $params->{href} = $edit_url;
    }

    # If a comment exists on this line, set span and the overlib hooks onto
    # it.
    my $query = $self->{query};
    my %comment_hash = %{ $self->{comment_hash} };
    my %comment_location_map = %{ $self->{comment_location_map} };
    my $comment_number = undef;
    if (exists $comment_hash{$anchor}) {
        # Determine what comment number this anchor refers to.
        $comment_number = $comment_location_map{$anchor};

        if (defined $comment_class) {
            $text = $query->span({-id=>"c$comment_number"}, "") .
                $query->span({-class=>$comment_class}, $text);
        }

        # Determine what the next comment in line is.
        my $index = -1;
        my @comment_locations = @{ $self->{comment_locations} };
        for ($index = 0; $index <= $#comment_locations; $index++) {
            last if $anchor eq $comment_locations[$index];
        }

        $params->{onmouseover} = "return overlib(comment_text[$index],STICKY,DRAGGABLE,ALTCUT);";
        $params->{onmouseout} = "return nd();";
    } else {
        if (defined $no_comment_class) {
            $text = $query->span({-class=>$no_comment_class}, $text);
        }
    }

    return $query->a($params, $text);
}

# Start hook called when about to start rendering to a page.
sub start($) {
    my ($self) = @_;

    # Now create the start of the rendering tables.
    if ($self->{mode} == $Codestriker::NORMAL_MODE) {
        $self->_normal_mode_start();
    } else {
        $self->_coloured_mode_start();
    }
}

# Finished hook called when finished rendering to a page.
sub finish($) {
    my ($self) = @_;
    if ($self->{mode} == $Codestriker::NORMAL_MODE) {
        $self->_normal_mode_finish();
    } else {
        $self->_coloured_mode_finish();
    }

    $self->_print_legend();
}

# Start topic view display hook for normal mode.
sub _normal_mode_start($) {
    my ($self) = @_;
    print "<PRE>\n";
}

# Finish topic view display hook for normal mode.
sub _normal_mode_finish($) {
    my ($self) = @_;
    print "</PRE>\n";
}

# Private functon to print the diff legend out at the bottom of the topic text page.
sub _print_legend($) {
    my ($self) = @_;

    my $query = $self->{query};
    my $topic = $self->{topic};
    my $mode = $self->{mode};

    print $query->start_table({-cellspacing=>'0', -cellpadding=>'0',
                               -border=>'0'}), "\n";
    print $query->Tr($query->td("&nbsp;"), $query->td("&nbsp;"));
    print $query->Tr($query->td({-colspan=>'2'}, "Legend:"));
    print $query->Tr($query->td({-class=>'rf'},
                                "Removed"),
                     $query->td({-class=>'rb'}, "&nbsp;"));
    print $query->Tr($query->td({-class=>'cf',
                                 -align=>"center", -colspan=>'2'},
                                "Changed"));
    print $query->Tr($query->td({-class=>'ab'}, "&nbsp;"),
                     $query->td({-class=>'af'},
                                "Added"));
    print $query->end_table(), "\n";
}


# Start topic view display hook for coloured mode.  This displays a simple
# legend, displays the files involved in the review, and opens up the initial
# table.
sub _coloured_mode_start($) {
    my ($self) = @_;

    my $query = $self->{query};
    my $topic = $self->{topic};
    my $mode = $self->{mode};
    my $brmode = $self->{brmode};
    my $fview = $self->{fview};
    my $display_all_url =
        $self->{url_builder}->view_url($topic, -1, $mode, $brmode, -1);
    my $display_single_url =
        $self->{url_builder}->view_url($topic, -1, $mode, $brmode, 0);

    
    # Print out the "table of contents".
    my $filenames = $self->{filenames_ref};
    my $revisions = $self->{revisions_ref};
    my $binaries = $self->{binaries_ref};
    my $numchanges = $self->{numchanges_ref};

    print $query->p;
    print $query->start_table({-cellspacing=>'0', -cellpadding=>'0',
                               -border=>'0'}), "\n";
    
               
    # Include a link to view all files in a topic, if we are in single
    # display mode.
    if ($fview != -1) {
        print $query->Tr($query->td($query->a({name=>"contents"},
                                              "Files in Topic: ("),
                                    $query->a({href=>$display_all_url},
                                              "view all files"), ")"),
                         $query->td("&nbsp;")), "\n";
    }
    else {
        print $query->Tr($query->td($query->a({name=>"contents"},
                                              "Files in Topic:")),
                         $query->td("&nbsp;")), "\n";
    }
    
    my $url_builder = $self->{url_builder};
    for (my $i = 0; $i <= $#$filenames; $i++) {
        my $filename = $$filenames[$i];
    my $filename_short = get_filename($filename);

        my $revision = $$revisions[$i];
        my $numchange = $$numchanges[$i];
        my $href_filename =
            $url_builder->view_url($topic, -1, $mode, $brmode, $i) .
            "#" . "$filename";
        my $anchor_filename =
            $url_builder->view_url($topic, -1, $mode, $brmode, -1) .
            "#" . "$filename";
        my $tddata = $$binaries[$i] ? $filename :
        $query->a({href=>$href_filename}, "$filename_short");

        if ($fview == -1) {
            # Add a jump to link for the all files view.
            $tddata = "[" . $query->a({href=>$anchor_filename}, "Jump to") . "] " . $tddata;
        }

        my $lineData = "";

        if ($numchange ne "") {
            $lineData = "&nbsp; <FONT size=-1>{$numchange}</FONT>";
        }

        my $class = "";
        $class = "af" if ($revision eq $Codestriker::ADDED_REVISION);
        $class = "rf" if ($revision eq $Codestriker::REMOVED_REVISION);
        $class = "cf" if ($revision eq $Codestriker::PATCH_REVISION);
        if ($revision eq $Codestriker::ADDED_REVISION ||
            $revision eq $Codestriker::REMOVED_REVISION ||
            $revision eq $Codestriker::PATCH_REVISION) {
            # Added, removed or patch file.
            print $query->Tr($query->td({-class=>"$class", -colspan=>'2'},
                                        $tddata),
                             $query->td({-class=>"$class"}, $lineData)) . "\n";
        } else {
            # Modified file.
            print $query->Tr($query->td({-class=>'cf'}, $tddata),
                             $query->td({-class=>'cf'}, "&nbsp; $revision"),
                             $query->td({-class=>'cf'}, $lineData)) .
                             "\n";
        }
    }
    print $query->end_table() . "\n";

    # Render the "Add comment to topic" link.
    print $query->p;
    print $self->render_comment_link(-1, -1, 1, "Add General Comment",
                                     "general_comment", undef);
    print " to topic.";
    print $query->p;

    print $query->start_table() ;
}

# Render the initial start of the coloured table, with an empty row setting
# the widths.
sub print_coloured_table($)
{
    my ($self) = @_;

    my $query = $self->{query};
    print $query->start_table({-width=>'100%',
                               -border=>'0',
                               -cellspacing=>'0',
                               -cellpadding=>'0'}), "\n";
    print $query->Tr($query->td({-width=>'2%'}, "&nbsp;"),
                     $query->td({-width=>'48%'}, "&nbsp;"),
                     $query->td({-width=>'2%'}, "&nbsp;"),
                     $query->td({-width=>'48%'}, "&nbsp;"), "\n");
}


# Finish topic view display hook for coloured mode.
sub _coloured_mode_finish ($) {
    my ($self) = @_;

    if ($self->{fview} != -1) {
        # Show the current file header again for navigation purposes when
        # viewing a single file at a time.
        $self->delta_file_header($self->{diff_current_filename},
                                 $self->{diff_current_revision},
                                 $self->{diff_current_repmatch});
    }

    print "</TABLE>\n";

    # Render the "Add comment to topic" link.
    my $query = $self->{query};
    print $query->p;
    print $self->render_comment_link(-1, -1, 1, "Add General Comment",
                                     "general_comment", undef);
    print " to topic.";
    print $query->p;
}

# Display a line for a single file view.
sub display_single_filedata ($$$$$) {
    my ($self, $filenumber, $data, $new, $link) = @_;

    my $leftline = $self->{old_linenumber};
    my $rightline = $self->{new_linenumber};
    my $max_line_length = $self->{max_line_length};

    # Handling of either an old or new view.
    if ($data =~ /^\-(.*)$/o) {
        # A removed line.
        $self->add_minus_monospace_line($1, $leftline++);
    } elsif ($data =~ /^\+(.*)$/o) {
        # An added line.
        $self->add_plus_monospace_line($1, $rightline++);
    } else {
        # An unchanged line, output it and anything pending, and remove
        # the leading space for alignment reasons.
        $data =~ s/^\s//;
        $self->flush_monospaced_lines($filenumber, $max_line_length, $new,
                                      $link);

        my $linenumber = $new ? $rightline : $leftline;
        print $self->render_monospaced_line($filenumber, $linenumber, $new,
                                            $data, $link,
                                            $max_line_length, "");
        $leftline++;
        $rightline++;
    }

    # Update the left and right line nymber state variables.
    $self->{old_linenumber} = $leftline;
    $self->{new_linenumber} = $rightline;
}

# Print out a line of data with the specified line number suitably aligned,
# and with tabs replaced by spaces for proper alignment.
sub render_monospaced_line ($$$$$$$$) {
    my ($self, $filenumber, $linenumber, $new, $data, $link,
        $max_line_length, $class) = @_;

    # Convert any identifier to their LXR links.
    $data = $self->lxr_data(HTML::Entities::encode($data));

    my $prefix = "";
    my $digit_width = length($linenumber);
    my $max_digit_width = $self->{max_digit_width};
    for (my $i = 0; $i < ($max_digit_width - $digit_width); $i++) {
        $prefix .= " ";
    }

    # Determine what class to use when rendering the number.
    my ($comment_class, $no_comment_class);
    if ($self->{parallel} == 0) {
        $comment_class = "mscom";
        $no_comment_class = "msnocom";
    } else {
        if ($self->{mode} == $Codestriker::COLOURED_MODE) {
            $comment_class = "com";
            $no_comment_class = "nocom";
        } else {
            $comment_class = "smscom";
            $no_comment_class = "smsnocom";
        }
    }

    my $line_cell = "";
    if ($link == 0) {
        # A line outside of the review.  Just render the line number, as
        # the "name" of the linenumber should not be used.
        $line_cell = "$prefix$linenumber";
    } else {
        $line_cell = $prefix .
            $self->render_comment_link($filenumber, $linenumber, $new,
                                       $linenumber, $comment_class,
                                       $no_comment_class);
    }

    # Render the line data.  If the user clicks on a topic line, the
    # edit window is focused to the appropriate line.
    my $query = $self->{query};

    # Replace the line data with spaces.
    my $newdata = tabadjust($self->{tabwidth}, $data, 0);

    if ($class ne "") {
        # Add the appropriate number of spaces to justify the data to a length
        # of $max_line_length, and render it within a SPAN to get the correct
        # background colour.
        my $padding = $max_line_length - length($data);
        for (my $i = 0; $i < ($padding); $i++) {
            $newdata .= " ";
        }
        return "$line_cell " .
            $query->span({-class=>"$class"}, $newdata) . "\n";
    }
    else {
        return "$line_cell $newdata\n";
    }
}

# Record a plus line.
sub add_plus_monospace_line ($$$) {
    my ($self, $linedata, $offset) = @_;
    push @view_file_plus, $linedata;
    push @view_file_plus_offset, $offset;
}

# Record a minus line.
sub add_minus_monospace_line ($$$) {
    my ($self, $linedata, $offset) = @_;
    push @view_file_minus, $linedata;
    push @view_file_minus_offset, $offset;
}

# Flush the current diff chunk.  Note if the original file is being rendered,
# the minus lines are used, otherwise the plus lines.
sub flush_monospaced_lines ($$$$$) {
    my ($self, $filenumber, $max_line_length, $new, $link) = @_;

    my $class = "";
    if ($#view_file_plus != -1 && $#view_file_minus != -1) {
        # This is a change chunk.
        $class = "msc";
    }
    elsif ($#view_file_plus != -1) {
        # This is an add chunk.
        $class = "msa";
    }
    elsif ($#view_file_minus != -1) {
        # This is a remove chunk.
        $class = "msr";
    }

    if ($new) {
        for (my $i = 0; $i <= $#view_file_plus; $i++) {
            print $self->render_monospaced_line($filenumber,
                                                $view_file_plus_offset[$i],
                                                $new,
                                                $view_file_plus[$i], $link,
                                                $max_line_length, $class);
        }
    }
    else {
        for (my $i = 0; $i <= $#view_file_minus; $i++) {
            print $self->render_monospaced_line($filenumber,
                                                $view_file_minus_offset[$i],
                                                $new,
                                                $view_file_minus[$i], $link,
                                                $max_line_length, $class);
        }
    }
    $#view_file_minus = -1;
    $#view_file_minus_offset = -1;
    $#view_file_plus = -1;
    $#view_file_plus_offset = -1;
}

# Replace the passed in string with the correct number of spaces, for
# alignment purposes.
sub tabadjust ($$$) {
    my ($tabwidth, $input, $htmlmode) = @_;

    $_ = $input;
    if ($htmlmode) {
        1 while s/\t+/'&nbsp;' x
            (length($&) * $tabwidth - length($`) % $tabwidth)/eo;
    }
    else {
        1 while s/\t+/' ' x
            (length($&) * $tabwidth - length($`) % $tabwidth)/eo;
    }
    return $_;
}

# Retrieve the data that forms the "context" when submitting a comment.
sub get_context ($$$$$$$$$) {
    my ($type, $targetline, $context, $html_view, $old_startline,
        $new_startline, $text, $new) = @_;

    # Break the text into lines.
    my @document = split /\n/, $text;

    # Calculate the location of the target line within the diff chunk.
    my $offset;
    my $old_linenumber = $old_startline;
    my $new_linenumber = $new_startline;
    for ($offset = 0; $offset <= $#document; $offset++) {

        my $data = $document[$offset];

        # Check if the target line as been found.
        if ($data =~ /^ /o) {
            last if ($new && $new_linenumber == $targetline);
            last if ($new == 0 && $old_linenumber == $targetline);
            $old_linenumber++;
            $new_linenumber++;
        } elsif ($data =~ /^\+/o) {
            last if ($new && $new_linenumber == $targetline);
            $new_linenumber++;
        } elsif ($data =~ /^\-/o) {
            last if ($new == 0 && $old_linenumber == $targetline);
            $old_linenumber++;
        }
    }

    # Get the minimum and maximum line numbers for this context, and return
    # the data.  The line of interest will be rendered appropriately.
    my $min_line = ($offset - $context < 0 ? 0 : $offset - $context);
    my $max_line = $offset + $context;
    my $context_string = "";
    for (my $i = $min_line; $i <= $max_line && $i <= $#document; $i++) {
        my $linedata = $document[$i];
        if ($html_view) {
            if ($i == $offset) {
                $context_string .=
                    "<font color=\"$CONTEXT_COLOUR\">" .
                      HTML::Entities::encode($linedata) . "</font>\n";
            } else {
                $context_string .= HTML::Entities::encode("$linedata") ."\n";
            }
        } else {
            # This is the context for emails.
            $context_string .= ($i == $offset) ? "* " : "  ";
            $context_string .= $linedata . "\n";
        }
    }
    return $context_string;
}

sub get_filename ($) {
    my ($extended_path) = @_;
    my $normal_path = $extended_path;
    my $path_separation = "/";

    if ($extended_path =~ /^(.*)@@(.*)/) {
        $normal_path = $1;      # before clearcase extended path
        my $other_path = $2;    # rest of the path that have clearcase Multi version paths

        # Before manipulating, see what kind of path separation is used
        # Assuming, only either \ or / is used.
        if ($extended_path =~ /\\/) {
            $path_separation = "\\";
        }

        my @nodes = split(/[\/\\]/, $other_path);
        my $temp;

        while (@nodes) {
            $temp = $nodes[0];
            if ($temp =~ /^[0-9]+$/ && $nodes[1]) {        # leaf nodes with version
                $normal_path = $normal_path . $path_separation . $nodes[1];
            }
            shift(@nodes);
        }
    }

    return $normal_path;
}

1;