WebHACC/Language/HTML.pm

package WebHACC::Language::HTML;
use strict;
require WebHACC::Language::DOM;
push our @ISA, 'WebHACC::Language::DOM';

require Message::DOM::DOMImplementation;

sub new ($) {
  return bless {}, shift;
} # new

sub generate_syntax_error_section ($) {
  my $self = shift;
  
  require Encode;
  require Whatpm::HTML;
  
  my $out = $self->output;
  $out->start_section (id => 'parse-errors', title => 'Parse Errors');
  $out->start_tag (id => 'parse-errors-list');

  my $input = $self->input;
  my $result = $self->result;

  my $onerror = sub {
    my (%opt) = @_;
    my ($type, $cls, $msg) = main::get_text ($opt{type}, $opt{level});
    $out->html (qq[<dt class="$cls">] . $result->get_error_label ($input, \%opt));
    $type =~ tr/ /-/;
    $type =~ s/\|/%7C/g;
    $out->html (qq[<dd class="$cls">] . $result->get_error_level_label (\%opt) , $msg);
    $out->text (' [');
    $out->link ('Description',
                url => '../error-description#' . $type);
    $out->text (']');

    main::add_error ('syntax', \%opt => $result);
  };

  my $dom = Message::DOM::DOMImplementation->new;
  my $doc = $dom->create_document;
  my $el;
  my $inner_html_element = $input->{inner_html_element};
  if (defined $inner_html_element and length $inner_html_element) {
    $input->{charset} ||= 'windows-1252'; ## TODO: for now.
    my $t = \($input->{s});
    unless ($input->{is_char_string}) {
      $t = \(Encode::decode ($input->{charset}, $$t));
    }
    
    $el = $doc->create_element_ns
        ('http://www.w3.org/1999/xhtml', [undef, $inner_html_element]);
    Whatpm::HTML->set_inner_html ($el, $$t, $onerror);

    $self->{structure} = $el;
  } else {
    if ($input->{is_char_string}) {
      Whatpm::HTML->parse_char_string ($input->{s} => $doc, $onerror);
    } else {
      Whatpm::HTML->parse_byte_string
          ($input->{charset}, $input->{s} => $doc, $onerror);
    }

    $self->{structure} = $doc;
  }
  $doc->manakai_charset ($input->{official_charset})
      if defined $input->{official_charset};

  $doc->document_uri ($input->{uri});
  $doc->manakai_entity_base_uri ($input->{base_uri});

  $out->end_tag ('dl');
  $out->end_section;
} # generate_syntax_error_section

sub source_charset ($) {
  my $self = shift;
  return $self->input->{charset} || ($self->{structure}->owner_document || $self->{structure})->input_encoding;
  ## TODO: Can we always use input_encoding?
} # source_charset

1;
1	wakaba	1.1	package WebHACC::Language::HTML;
2			use strict;
3			require WebHACC::Language::DOM;
4			push our @ISA, 'WebHACC::Language::DOM';
5
6			require Message::DOM::DOMImplementation;
7
8			sub new ($) {
9			return bless {}, shift;
10			} # new
11
12			sub generate_syntax_error_section ($) {
13			my $self = shift;
14
15			require Encode;
16			require Whatpm::HTML;
17
18			my $out = $self->output;
19			$out->start_section (id => 'parse-errors', title => 'Parse Errors');
20			$out->start_tag (id => 'parse-errors-list');
21
22			my $input = $self->input;
23			my $result = $self->result;
24
25			my $onerror = sub {
26			my (%opt) = @_;
27			my ($type, $cls, $msg) = main::get_text ($opt{type}, $opt{level});
28			$out->html (qq[<dt class="$cls">] . $result->get_error_label ($input, \%opt));
29			$type =~ tr/ /-/;
30			$type =~ s/\\|/%7C/g;
31			$out->html (qq[<dd class="$cls">] . $result->get_error_level_label (\%opt) , $msg);
32			$out->text (' [');
33			$out->link ('Description',
34			url => '../error-description#' . $type);
35			$out->text (']');
36
37			main::add_error ('syntax', \%opt => $result);
38			};
39
40			my $dom = Message::DOM::DOMImplementation->new;
41			my $doc = $dom->create_document;
42			my $el;
43			my $inner_html_element = $input->{inner_html_element};
44			if (defined $inner_html_element and length $inner_html_element) {
45			$input->{charset} \|\|= 'windows-1252'; ## TODO: for now.
46			my $t = \($input->{s});
47			unless ($input->{is_char_string}) {
48			$t = \(Encode::decode ($input->{charset}, $$t));
49			}
50
51			$el = $doc->create_element_ns
52			('http://www.w3.org/1999/xhtml', [undef, $inner_html_element]);
53			Whatpm::HTML->set_inner_html ($el, $$t, $onerror);
54
55			$self->{structure} = $el;
56			} else {
57			if ($input->{is_char_string}) {
58			Whatpm::HTML->parse_char_string ($input->{s} => $doc, $onerror);
59			} else {
60			Whatpm::HTML->parse_byte_string
61			($input->{charset}, $input->{s} => $doc, $onerror);
62			}
63
64			$self->{structure} = $doc;
65			}
66			$doc->manakai_charset ($input->{official_charset})
67			if defined $input->{official_charset};
68
69			$doc->document_uri ($input->{uri});
70			$doc->manakai_entity_base_uri ($input->{base_uri});
71
72			$out->end_tag ('dl');
73			$out->end_section;
74			} # generate_syntax_error_section
75
76			sub source_charset ($) {
77			my $self = shift;
78			return $self->input->{charset} \|\| ($self->{structure}->owner_document \|\| $self->{structure})->input_encoding;
79			## TODO: Can we always use input_encoding?
80			} # source_charset
81
82			1;