WebHACC/Language/DOM.pm

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

use Scalar::Util qw[refaddr];

sub generate_structure_dump_section ($) {
  my $self = shift;
  
  my $out = $self->output;

  $out->start_section (role => 'tree');

  $out->start_tag ('ol', class => 'xoxo');

  my @node = ($self->{structure});
  while (@node) {
    my $child = shift @node;
    unless (ref $child) {
      $out->html ($child);
      next;
    }

    my $node_id = 'node-'.refaddr $child;
    my $nt = $child->node_type;
    if ($nt == $child->ELEMENT_NODE) {
      my $child_nsuri = $child->namespace_uri;
      $out->start_tag ('li', id => $node_id, class => 'tree-element');
      $out->start_tag ('code',
                       title => defined $child_nsuri ? $child_nsuri : '');
      $out->text ($child->tag_name); ## TODO: case
      $out->end_tag ('code');

      if ($child->has_attributes) {
        $out->start_tag ('ul', class => 'attributes');
        for my $attr (sort {$a->[0] cmp $b->[0]} map { [$_->name, $_->value, $_->namespace_uri, 'node-'.refaddr $_] }
                      @{$child->attributes}) {
          $out->start_tag ('li', id => $attr->[3], class => 'tree-attribute');
          $out->start_tag ('code',
                           title => defined $attr->[2] ? $attr->[2] : '');
          $out->html ($attr->[0]); ## ISSUE: case
          $out->end_tag ('code');
          $out->text (' = ');
          $out->start_tag ('q');
          $out->text ($attr->[1]); ## TODO: children
          $out->end_tag ('q');
        }
        $out->end_tag ('ul');
      }

      if ($child->has_child_nodes) {
        $out->start_tag ('ol', class => 'children');
        unshift @node, @{$child->child_nodes}, '</ol></li>';
      }
    } elsif ($nt == $child->TEXT_NODE) {
      $out->start_tag ('li', id => $node_id, class => 'tree-text');
      $out->start_tag ('q', lang => '');
      $out->text ($child->data);
      $out->end_tag ('q');
    } elsif ($nt == $child->CDATA_SECTION_NODE) {
      $out->start_tag ('li', id => $node_id, class => 'tree-cdata');
      $out->start_tag ('code');
      $out->text ('<![CDATA[');
      $out->end_tag ('code');
      $out->start_tag ('q', lang => '');
      $out->text ($child->data);
      $out->end_tag ('q');
      $out->start_tag ('code');
      $out->text (']]>');
      $out->end_tag ('code');
    } elsif ($nt == $child->COMMENT_NODE) {
      $out->start_tag ('li', id => $node_id, class => 'tree-cdata');
      $out->start_tag ('code');
      $out->text ('<!--');
      $out->end_tag ('code');
      $out->start_tag ('q', lang => '');
      $out->text ($child->data);
      $out->end_tag ('q');
      $out->start_tag ('code');
      $out->text ('-->');
      $out->end_tag ('code');
    } elsif ($nt == $child->DOCUMENT_NODE) {
      $out->start_tag ('li', id => $node_id, class => 'tree-document');
      $out->nl_text ('Document');

      $out->start_tag ('ul', class => 'attributes');
      
      my $cp = $child->manakai_charset;
      if (defined $cp) {
        $out->start_tag ('li');
        $out->nl_text ('manakaiCharset');
        $out->text (' = ');
        $out->code ($cp);
      }
      
      $out->start_tag ('li');
      $out->nl_text ('inputEncoding');
      $out->text (' = ');
      my $ie = $child->input_encoding;
      if (defined $ie) {
        $out->code ($ie);
        if ($child->manakai_has_bom) {
          $out->nl_text ('... with BOM');
        }
      } else {
        $out->html (qq[(<code>null</code>)]);
      }

      $out->start_tag ('li');
      $out->nl_text ('manakaiIsHTML:'.($child->manakai_is_html?1:0));

      $out->start_tag ('li');
      $out->nl_text ('manakaiCompatMode:'.$child->manakai_compat_mode);

      unless ($child->manakai_is_html) {
        $out->start_tag ('li');
        $out->nl_text ('xmlVersion');
        $out->text (' = ');
        $out->code ($child->xml_version);
        
        $out->start_tag ('li');
        $out->nl_text ('xmlEncoding');
        $out->text (' = ');
        if (defined $child->xml_encoding) {
          $out->code ($child->xml_encoding);
        } else {
          $out->html ('(<code>null</code>)');
        }

        $out->start_tag ('li');
        $out->nl_text ('xmlStandalone');
        $out->text (' = ');
        $out->code ($child->xml_standalone ? 'true' : 'false');
      }

      $out->end_tag ('ul');
      
      if ($child->has_child_nodes) {
        $out->start_tag ('ol', class => 'children');
        unshift @node, @{$child->child_nodes}, '</ol></li>';
      }
    } elsif ($nt == $child->DOCUMENT_TYPE_NODE) {
      $out->start_tag ('li', id => $node_id, class => 'tree-doctype');
      $out->code ('<!DOCTYPE>');
      $out->start_tag ('ul', class => 'attributes');

      $out->start_tag ('li', class => 'tree-doctype-name');
      $out->text ('Name = ');
      $out->code ($child->name);

      $out->start_tag ('li', class => 'tree-doctype-publicid');
      $out->text ('Public identifier = ');
      $out->code ($child->public_id);

      $out->start_tag ('li', class => 'tree-doctype-systemid');
      $out->text ('System identifier = ');
      $out->code ($child->system_id);

      $out->end_tag ('ul');
    } elsif ($nt == $child->PROCESSING_INSTRUCTION_NODE) {
      $out->start_tag ('li', id => $node_id, class => 'tree-id');
      $out->code ('<?');
      $out->code ($child->target);
      $out->text (' ');
      $out->code ($child->data);
      $out->code ('?>');
    } else { # error
      $out->start_tag ('li', id => $node_id, class => 'tree-unknown');
      $out->text ($child->node_type . ' ' . $child->node_name);
    }
  }
  $out->end_tag ('ol');

  $out->end_section;
} # generate_structure_dump_section

sub generate_structure_error_section ($) {
  my $self = shift;
  
  my $out = $self->output;
  $out->start_section (role => 'structure-errors');
  $out->start_error_list (role => 'structure-errors');

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

  require Whatpm::ContentChecker;
  my $onerror = sub {
    $result->add_error (@_, layer => 'structure');
  };

  my $onsubdoc = $self->onsubdoc;
  if ($self->{structure}->node_type == $self->{structure}->ELEMENT_NODE) {
    $self->{add_info} = Whatpm::ContentChecker->check_element
        ($self->{structure}, $onerror, $onsubdoc);
  } else {
    $self->{add_info} = Whatpm::ContentChecker->check_document
        ($self->{structure}, $onerror, $onsubdoc);
  }

  $out->end_error_list (role => 'structure-errors');
  $out->end_section;
} # generate_structure_error_section

sub generate_additional_sections ($) {
  my $self = shift;
  $self->SUPER::generate_additional_sections;

  $self->generate_table_section;

  $self->generate_listing_section (
      key => 'id', id => 'identifiers',
      short_title => 'IDs', title => 'Identifiers',
  );
  $self->generate_listing_section (
      key => 'term', id => 'terms',
      short_title => 'Terms', title => 'Terms',
  );
  $self->generate_listing_section (
      key => 'class', id => 'classes',
      short_title => 'Classes', title => 'Classes',
  );

  $self->generate_rdf_section;
} # generate_additional_sections

sub generate_table_section ($) {
  my $self = shift;

  my $tables = $self->{add_info}->{table} || [];
  return unless @$tables;

  my $out = $self->output;
  $out->start_section (id => 'tables', short_title => 'Tables',
                       title => 'Tables Section');

  $out->html (q[<!--[if IE]><script type="text/javascript" src="../excanvas.js"></script><![endif]-->
<script src="../table-script.js" type="text/javascript"></script>
<noscript>
<p><em>Structure of tables are visualized here if scripting is enabled.</em></p>
</noscript>]);
  
  require JSON;
  
  my $i = 0;
  for my $table (@$tables) {
    $i++;
    my $index = $out->input->full_subdocument_index;
    $index = $index ? $index . '.' . $i : $i;
    $out->start_section (id => 'table-' . $i,
                         title => 'Table #',
                         text => $index);

    $out->start_tag ('dl');
    $out->dt ('Table Element');
    $out->start_tag ('dd');
    $out->node_link ($table->{element});
    $out->end_tag ('dl');
    delete $table->{element};

    for (@{$table->{column_group}}, @{$table->{column}}, $table->{caption},
         @{$table->{row}}) {
      next unless $_;
      delete $_->{element};
    }
    
    for (@{$table->{row_group}}) {
      next unless $_;
      next unless $_->{element};
      $_->{type} = $_->{element}->manakai_local_name;
      delete $_->{element};
    }
    
    for (@{$table->{cell}}) {
      next unless $_;
      for (@{$_}) {
        next unless $_;
        for (@$_) {
          $_->{id} = refaddr $_->{element} if defined $_->{element};
          delete $_->{element};
          $_->{is_header} = $_->{is_header} ? 1 : 0;
        }
      }
    }

    my $id_prefix = $self->input->id_prefix;
    $out->script (q[tableToCanvas (] .
        JSON::objToJson ($table) .
        q[, document.getElementById ('] . $id_prefix . 'table-' . $i . q[')] .
        q[, '] . $id_prefix . q[');]);

    $out->end_section;
  }

  $out->end_section;
} # generate_table_section

sub generate_listing_section ($%) {
  my $self = shift;
  my %opt = @_;

  my $list = $self->{add_info}->{$opt{key}} || {};
  return unless keys %$list;

  my $out = $self->output;

  $out->start_section (id => $opt{id},
                       title => $opt{title},
                       short_title => $opt{short_title});
  $out->start_tag ('dl');

  for my $id (sort {$a cmp $b} keys %$list) {
    $out->start_tag ('dt');
    $out->code ($id);
    for (@{$list->{$id}}) {
      $out->start_tag ('dd');
      $out->node_link ($_);
    }
  }

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

my $generate_rdf_resource_html = sub ($$) {
  my ($resource, $out) = @_;

  if (defined $resource->{uri}) {
    $out->url ($resource->{uri});
  } elsif (defined $resource->{bnodeid}) {
    $out->text ('_:' . $resource->{bnodeid});
  } elsif ($resource->{nodes}) {
    $out->text ('(rdf:XMLLiteral)');
  } elsif (defined $resource->{value}) {
    $out->start_tag ('q',
                     lang => defined $resource->{language}
                         ? $resource->{language} : '');
    $out->text ($resource->{value});
    $out->end_tag ('q');

    if (defined $resource->{datatype}) {
      $out->text ('^^');
      $out->url ($resource->{datatype});
    } elsif (length $resource->{language}) {
      $out->text ('@' . $resource->{language});
    }
  } else {
    $out->text ('??'); ## NOTE: An error of the implementation.
  }
}; # $generate_rdf_resource_html

## TODO: Should we move this method to another module,
## such as Base or RDF?
sub generate_rdf_section ($) {
  my $self = shift;

  my $list = $self->{add_info}->{rdf} || [];
  return unless @$list;

  my $out = $self->output;
  $out->start_section (id => 'rdf', short_title => 'RDF',
                       title => 'RDF Triples');
  $out->start_tag ('dl');

  my $i = 0;
  for my $rdf (@$list) {
    $out->start_tag ('dt', id => 'rdf-' . $i++);
    $out->node_link ($rdf->[0]);
    $out->start_tag ('dd');
    $out->start_tag ('dl');
    for my $triple (@{$rdf->[1]}) {
      $out->start_tag ('dt');
      $out->node_link ($triple->[0]);
      $out->start_tag ('dd');
      $out->text ('Subject: ');
      $generate_rdf_resource_html->($triple->[1] => $out);
      $out->start_tag ('dd');
      $out->text ('Predicate: ');
      $generate_rdf_resource_html->($triple->[2] => $out);
      $out->start_tag ('dd');
      $out->text ('Object: ');
      $generate_rdf_resource_html->($triple->[3] => $out);
    }
    $out->end_tag ('dl');
  }
  $out->end_tag ('dl');
  $out->end_section;
} # generate_rdf_section

1;
1	package WebHACC::Language::DOM;
2	use strict;
3	require WebHACC::Language::Base;
4	push our @ISA, 'WebHACC::Language::Base';
5
6	use Scalar::Util qw[refaddr];
7
8	sub generate_structure_dump_section ($) {
9	my $self = shift;
10
11	my $out = $self->output;
12
13	$out->start_section (role => 'tree');
14
15	$out->start_tag ('ol', class => 'xoxo');
16
17	my @node = ($self->{structure});
18	while (@node) {
19	my $child = shift @node;
20	unless (ref $child) {
21	$out->html ($child);
22	next;
23	}
24
25	my $node_id = 'node-'.refaddr $child;
26	my $nt = $child->node_type;
27	if ($nt == $child->ELEMENT_NODE) {
28	my $child_nsuri = $child->namespace_uri;
29	$out->start_tag ('li', id => $node_id, class => 'tree-element');
30	$out->start_tag ('code',
31	title => defined $child_nsuri ? $child_nsuri : '');
32	$out->text ($child->tag_name); ## TODO: case
33	$out->end_tag ('code');
34
35	if ($child->has_attributes) {
36	$out->start_tag ('ul', class => 'attributes');
37	for my $attr (sort {$a->[0] cmp $b->[0]} map { [$_->name, $_->value, $_->namespace_uri, 'node-'.refaddr $_] }
38	@{$child->attributes}) {
39	$out->start_tag ('li', id => $attr->[3], class => 'tree-attribute');
40	$out->start_tag ('code',
41	title => defined $attr->[2] ? $attr->[2] : '');
42	$out->html ($attr->[0]); ## ISSUE: case
43	$out->end_tag ('code');
44	$out->text (' = ');
45	$out->start_tag ('q');
46	$out->text ($attr->[1]); ## TODO: children
47	$out->end_tag ('q');
48	}
49	$out->end_tag ('ul');
50	}
51
52	if ($child->has_child_nodes) {
53	$out->start_tag ('ol', class => 'children');
54	unshift @node, @{$child->child_nodes}, '</ol></li>';
55	}
56	} elsif ($nt == $child->TEXT_NODE) {
57	$out->start_tag ('li', id => $node_id, class => 'tree-text');
58	$out->start_tag ('q', lang => '');
59	$out->text ($child->data);
60	$out->end_tag ('q');
61	} elsif ($nt == $child->CDATA_SECTION_NODE) {
62	$out->start_tag ('li', id => $node_id, class => 'tree-cdata');
63	$out->start_tag ('code');
64	$out->text ('<![CDATA[');
65	$out->end_tag ('code');
66	$out->start_tag ('q', lang => '');
67	$out->text ($child->data);
68	$out->end_tag ('q');
69	$out->start_tag ('code');
70	$out->text (']]>');
71	$out->end_tag ('code');
72	} elsif ($nt == $child->COMMENT_NODE) {
73	$out->start_tag ('li', id => $node_id, class => 'tree-cdata');
74	$out->start_tag ('code');
75	$out->text ('<!--');
76	$out->end_tag ('code');
77	$out->start_tag ('q', lang => '');
78	$out->text ($child->data);
79	$out->end_tag ('q');
80	$out->start_tag ('code');
81	$out->text ('-->');
82	$out->end_tag ('code');
83	} elsif ($nt == $child->DOCUMENT_NODE) {
84	$out->start_tag ('li', id => $node_id, class => 'tree-document');
85	$out->nl_text ('Document');
86
87	$out->start_tag ('ul', class => 'attributes');
88
89	my $cp = $child->manakai_charset;
90	if (defined $cp) {
91	$out->start_tag ('li');
92	$out->nl_text ('manakaiCharset');
93	$out->text (' = ');
94	$out->code ($cp);
95	}
96
97	$out->start_tag ('li');
98	$out->nl_text ('inputEncoding');
99	$out->text (' = ');
100	my $ie = $child->input_encoding;
101	if (defined $ie) {
102	$out->code ($ie);
103	if ($child->manakai_has_bom) {
104	$out->nl_text ('... with BOM');
105	}
106	} else {
107	$out->html (qq[(<code>null</code>)]);
108	}
109
110	$out->start_tag ('li');
111	$out->nl_text ('manakaiIsHTML:'.($child->manakai_is_html?1:0));
112
113	$out->start_tag ('li');
114	$out->nl_text ('manakaiCompatMode:'.$child->manakai_compat_mode);
115
116	unless ($child->manakai_is_html) {
117	$out->start_tag ('li');
118	$out->nl_text ('xmlVersion');
119	$out->text (' = ');
120	$out->code ($child->xml_version);
121
122	$out->start_tag ('li');
123	$out->nl_text ('xmlEncoding');
124	$out->text (' = ');
125	if (defined $child->xml_encoding) {
126	$out->code ($child->xml_encoding);
127	} else {
128	$out->html ('(<code>null</code>)');
129	}
130
131	$out->start_tag ('li');
132	$out->nl_text ('xmlStandalone');
133	$out->text (' = ');
134	$out->code ($child->xml_standalone ? 'true' : 'false');
135	}
136
137	$out->end_tag ('ul');
138
139	if ($child->has_child_nodes) {
140	$out->start_tag ('ol', class => 'children');
141	unshift @node, @{$child->child_nodes}, '</ol></li>';
142	}
143	} elsif ($nt == $child->DOCUMENT_TYPE_NODE) {
144	$out->start_tag ('li', id => $node_id, class => 'tree-doctype');
145	$out->code ('<!DOCTYPE>');
146	$out->start_tag ('ul', class => 'attributes');
147
148	$out->start_tag ('li', class => 'tree-doctype-name');
149	$out->text ('Name = ');
150	$out->code ($child->name);
151
152	$out->start_tag ('li', class => 'tree-doctype-publicid');
153	$out->text ('Public identifier = ');
154	$out->code ($child->public_id);
155
156	$out->start_tag ('li', class => 'tree-doctype-systemid');
157	$out->text ('System identifier = ');
158	$out->code ($child->system_id);
159
160	$out->end_tag ('ul');
161	} elsif ($nt == $child->PROCESSING_INSTRUCTION_NODE) {
162	$out->start_tag ('li', id => $node_id, class => 'tree-id');
163	$out->code ('<?');
164	$out->code ($child->target);
165	$out->text (' ');
166	$out->code ($child->data);
167	$out->code ('?>');
168	} else { # error
169	$out->start_tag ('li', id => $node_id, class => 'tree-unknown');
170	$out->text ($child->node_type . ' ' . $child->node_name);
171	}
172	}
173	$out->end_tag ('ol');
174
175	$out->end_section;
176	} # generate_structure_dump_section
177
178	sub generate_structure_error_section ($) {
179	my $self = shift;
180
181	my $out = $self->output;
182	$out->start_section (role => 'structure-errors');
183	$out->start_error_list (role => 'structure-errors');
184
185	my $input = $self->input;
186	my $result = $self->result;
187
188	require Whatpm::ContentChecker;
189	my $onerror = sub {
190	$result->add_error (@_, layer => 'structure');
191	};
192
193	my $onsubdoc = $self->onsubdoc;
194	if ($self->{structure}->node_type == $self->{structure}->ELEMENT_NODE) {
195	$self->{add_info} = Whatpm::ContentChecker->check_element
196	($self->{structure}, $onerror, $onsubdoc);
197	} else {
198	$self->{add_info} = Whatpm::ContentChecker->check_document
199	($self->{structure}, $onerror, $onsubdoc);
200	}
201
202	$out->end_error_list (role => 'structure-errors');
203	$out->end_section;
204	} # generate_structure_error_section
205
206	sub generate_additional_sections ($) {
207	my $self = shift;
208	$self->SUPER::generate_additional_sections;
209
210	$self->generate_table_section;
211
212	$self->generate_listing_section (
213	key => 'id', id => 'identifiers',
214	short_title => 'IDs', title => 'Identifiers',
215	);
216	$self->generate_listing_section (
217	key => 'term', id => 'terms',
218	short_title => 'Terms', title => 'Terms',
219	);
220	$self->generate_listing_section (
221	key => 'class', id => 'classes',
222	short_title => 'Classes', title => 'Classes',
223	);
224
225	$self->generate_rdf_section;
226	} # generate_additional_sections
227
228	sub generate_table_section ($) {
229	my $self = shift;
230
231	my $tables = $self->{add_info}->{table} \|\| [];
232	return unless @$tables;
233
234	my $out = $self->output;
235	$out->start_section (id => 'tables', short_title => 'Tables',
236	title => 'Tables Section');
237
238	$out->html (q[<!--[if IE]><script type="text/javascript" src="../excanvas.js"></script><![endif]-->
239	<script src="../table-script.js" type="text/javascript"></script>
240	<noscript>
241	<p><em>Structure of tables are visualized here if scripting is enabled.</em></p>
242	</noscript>]);
243
244	require JSON;
245
246	my $i = 0;
247	for my $table (@$tables) {
248	$i++;
249	my $index = $out->input->full_subdocument_index;
250	$index = $index ? $index . '.' . $i : $i;
251	$out->start_section (id => 'table-' . $i,
252	title => 'Table #',
253	text => $index);
254
255	$out->start_tag ('dl');
256	$out->dt ('Table Element');
257	$out->start_tag ('dd');
258	$out->node_link ($table->{element});
259	$out->end_tag ('dl');
260	delete $table->{element};
261
262	for (@{$table->{column_group}}, @{$table->{column}}, $table->{caption},
263	@{$table->{row}}) {
264	next unless $_;
265	delete $_->{element};
266	}
267
268	for (@{$table->{row_group}}) {
269	next unless $_;
270	next unless $_->{element};
271	$_->{type} = $_->{element}->manakai_local_name;
272	delete $_->{element};
273	}
274
275	for (@{$table->{cell}}) {
276	next unless $_;
277	for (@{$_}) {
278	next unless $_;
279	for (@$_) {
280	$_->{id} = refaddr $_->{element} if defined $_->{element};
281	delete $_->{element};
282	$_->{is_header} = $_->{is_header} ? 1 : 0;
283	}
284	}
285	}
286
287	my $id_prefix = $self->input->id_prefix;
288	$out->script (q[tableToCanvas (] .
289	JSON::objToJson ($table) .
290	q[, document.getElementById ('] . $id_prefix . 'table-' . $i . q[')] .
291	q[, '] . $id_prefix . q[');]);
292
293	$out->end_section;
294	}
295
296	$out->end_section;
297	} # generate_table_section
298
299	sub generate_listing_section ($%) {
300	my $self = shift;
301	my %opt = @_;
302
303	my $list = $self->{add_info}->{$opt{key}} \|\| {};
304	return unless keys %$list;
305
306	my $out = $self->output;
307
308	$out->start_section (id => $opt{id},
309	title => $opt{title},
310	short_title => $opt{short_title});
311	$out->start_tag ('dl');
312
313	for my $id (sort {$a cmp $b} keys %$list) {
314	$out->start_tag ('dt');
315	$out->code ($id);
316	for (@{$list->{$id}}) {
317	$out->start_tag ('dd');
318	$out->node_link ($_);
319	}
320	}
321
322	$out->end_tag ('dl');
323	$out->end_section;
324	} # generate_listing_section
325
326	my $generate_rdf_resource_html = sub ($$) {
327	my ($resource, $out) = @_;
328
329	if (defined $resource->{uri}) {
330	$out->url ($resource->{uri});
331	} elsif (defined $resource->{bnodeid}) {
332	$out->text ('_:' . $resource->{bnodeid});
333	} elsif ($resource->{nodes}) {
334	$out->text ('(rdf:XMLLiteral)');
335	} elsif (defined $resource->{value}) {
336	$out->start_tag ('q',
337	lang => defined $resource->{language}
338	? $resource->{language} : '');
339	$out->text ($resource->{value});
340	$out->end_tag ('q');
341
342	if (defined $resource->{datatype}) {
343	$out->text ('^^');
344	$out->url ($resource->{datatype});
345	} elsif (length $resource->{language}) {
346	$out->text ('@' . $resource->{language});
347	}
348	} else {
349	$out->text ('??'); ## NOTE: An error of the implementation.
350	}
351	}; # $generate_rdf_resource_html
352
353	## TODO: Should we move this method to another module,
354	## such as Base or RDF?
355	sub generate_rdf_section ($) {
356	my $self = shift;
357
358	my $list = $self->{add_info}->{rdf} \|\| [];
359	return unless @$list;
360
361	my $out = $self->output;
362	$out->start_section (id => 'rdf', short_title => 'RDF',
363	title => 'RDF Triples');
364	$out->start_tag ('dl');
365
366	my $i = 0;
367	for my $rdf (@$list) {
368	$out->start_tag ('dt', id => 'rdf-' . $i++);
369	$out->node_link ($rdf->[0]);
370	$out->start_tag ('dd');
371	$out->start_tag ('dl');
372	for my $triple (@{$rdf->[1]}) {
373	$out->start_tag ('dt');
374	$out->node_link ($triple->[0]);
375	$out->start_tag ('dd');
376	$out->text ('Subject: ');
377	$generate_rdf_resource_html->($triple->[1] => $out);
378	$out->start_tag ('dd');
379	$out->text ('Predicate: ');
380	$generate_rdf_resource_html->($triple->[2] => $out);
381	$out->start_tag ('dd');
382	$out->text ('Object: ');
383	$generate_rdf_resource_html->($triple->[3] => $out);
384	}
385	$out->end_tag ('dl');
386	}
387	$out->end_tag ('dl');
388	$out->end_section;
389	} # generate_rdf_section
390
391	1;