<!--
	Copyright 2009 The Go Authors. All rights reserved.
	Use of this source code is governed by a BSD-style
	license that can be found in the LICENSE file.
-->
{{with .PDoc}}
	{{if $.IsPkg}}
		<div id="short-nav">
			<dl>
			<dd><code>import "{{html .ImportPath}}"</code></dd>
			</dl>
			<dl>
			<dd><a href="#overview">Overview</a></dd>
			<dd><a href="#index">Index</a></dd>
			{{if $.Examples}}
				<dd><a href="#examples">Examples</a></dd>
			{{end}}
			{{if $.Dirs}}
				<dd><a href="#subdirectories">Subdirectories</a></dd>
			{{end}}
			</dl>
		</div>
		<h2 id="overview">Overview</h2>
		<!-- The package's Name is printed as title by the top-level template -->
		{{comment_html .Doc}}
		{{example_html "" $.Examples $.FSet}}
	
		<h2 id="index">Index</h2>
		<!-- Table of contents for API; must be named manual-nav to turn off auto nav. -->
		<div id="manual-nav">
			<dl>
			{{if .Consts}}
				<dd><a href="#constants">Constants</a></dd>
			{{end}}
			{{if .Vars}}
				<dd><a href="#variables">Variables</a></dd>
			{{end}}
			{{range .Funcs}}
				{{$name_html := html .Name}}
				<dd><a href="#{{$name_html}}">{{node_html .Decl $.FSet}}</a></dd>
			{{end}}
			{{range .Types}}
				{{$tname_html := html .Name}}
				<dd><a href="#{{$tname_html}}">type {{$tname_html}}</a></dd>
				{{range .Funcs}}
					{{$name_html := html .Name}}
					<dd>&nbsp; &nbsp; <a href="#{{$name_html}}">{{node_html .Decl $.FSet}}</a></dd>
				{{end}}
				{{range .Methods}}
					{{$name_html := html .Name}}
					<dd>&nbsp; &nbsp; <a href="#{{$tname_html}}.{{$name_html}}">{{node_html .Decl $.FSet}}</a></dd>
				{{end}}
			{{end}}
			{{if .Bugs}}
				<dd><a href="#bugs">Bugs</a></dd>
			{{end}}
		</dl>

		{{if $.Examples}}
			<h4 id="examples">Examples</h4>
			<dl>
			{{range $.Examples}}
			<dd><a class="exampleLink" href="#example_{{.Name}}">{{example_name .Name}}</a></dd>
			{{end}}
			</dl>
		{{end}}

		{{with .Filenames}}
			<h4>Package files</h4>
			<p>
			<span style="font-size:90%">
			{{range .}}
				<a href="/{{.|srcLink}}">{{.|filename|html}}</a>
			{{end}}
			</span>
			</p>
		{{end}}
	
		{{with .Consts}}
			<h2 id="constants">Constants</h2>
			{{range .}}
				<pre>{{node_html .Decl $.FSet}}</pre>
				{{comment_html .Doc}}
			{{end}}
		{{end}}
		{{with .Vars}}
			<h2 id="variables">Variables</h2>
			{{range .}}
				<pre>{{node_html .Decl $.FSet}}</pre>
				{{comment_html .Doc}}
			{{end}}
		{{end}}
		{{range .Funcs}}
			{{/* Name is a string - no need for FSet */}}
			{{$name_html := html .Name}}
			<h2 id="{{$name_html}}">func <a href="/{{posLink_url .Decl $.FSet}}">{{$name_html}}</a></h2>
			<pre>{{node_html .Decl $.FSet}}</pre>
			{{comment_html .Doc}}
			{{example_html .Name $.Examples $.FSet}}
		{{end}}
		{{range .Types}}
			{{$tname := .Name}}
			{{$tname_html := html .Name}}
			<h2 id="{{$tname_html}}">type <a href="/{{posLink_url .Decl $.FSet}}">{{$tname_html}}</a></h2>
			<pre>{{node_html .Decl $.FSet}}</pre>
			{{comment_html .Doc}}

			{{range .Consts}}
				<pre>{{node_html .Decl $.FSet}}</pre>
				{{comment_html .Doc}}
			{{end}}

			{{range .Vars}}
				<pre>{{node_html .Decl $.FSet}}</pre>
				{{comment_html .Doc}}
			{{end}}

			{{example_html $tname $.Examples $.FSet}}

			{{range .Funcs}}
				{{$name_html := html .Name}}
				<h3 id="{{$name_html}}">func <a href="/{{posLink_url .Decl $.FSet}}">{{$name_html}}</a></h3>
				<pre>{{node_html .Decl $.FSet}}</pre>
				{{comment_html .Doc}}
				{{example_html .Name $.Examples $.FSet}}
			{{end}}

			{{range .Methods}}
				{{$name_html := html .Name}}
				<h3 id="{{$tname_html}}.{{$name_html}}">func ({{html .Recv}}) <a href="/{{posLink_url .Decl $.FSet}}">{{$name_html}}</a></h3>
				<pre>{{node_html .Decl $.FSet}}</pre>
				{{comment_html .Doc}}
				{{$name := printf "%s_%s" $tname .Name}}
				{{example_html $name $.Examples $.FSet}}
			{{end}}
		{{end}}
		</div>
	{{else}}  {{/* not a package; is a command */}}
		{{comment_html .Doc}}
	{{end}}

	{{with .Bugs}}
		<h2 id="bugs">Bugs</h2>
		{{range .}}
		{{comment_html .}}
		{{end}}
	{{end}}
{{end}}

{{with .PAst}}
	<pre>{{node_html . $.FSet}}</pre>
{{end}}

{{with .PList}}
	<h2>Other packages</h2>
	<p>
	{{/* PList entries are strings - no need for FSet */}}
	{{range .}}
	<a href="?p={{urlquery .}}">{{html .}}</a><br />
	{{end}}
	</p>
{{end}}

{{with .Dirs}}
	{{/* DirList entries are numbers and strings - no need for FSet */}}
	{{if $.PDoc}}<h2 id="subdirectories">Subdirectories</h2>{{end}}
	<table class="dir">
	<tr>
	<th>Name</th>
	<th>&nbsp;&nbsp;&nbsp;&nbsp;</th>
	<th style="text-align: left; width: auto">Synopsis</th>
	</tr>
	{{if not $.DirFlat}}
		<tr>
		<td><a href="..">..</a></td>
		</tr>
	{{end}}
	{{range .List}}
		{{if $.DirFlat}}
			{{if .HasPkg}}
				<tr>
				<td><a href="{{html .Path}}">{{html .Path}}</a></td>
				<td>&nbsp;&nbsp;&nbsp;&nbsp;</td>
				<td style="width: auto">{{html .Synopsis}}</td>
				</tr>
			{{end}}
		{{else}}
			<tr>
			<td>{{repeat `&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;` .Depth}}<a href="{{html .Path}}">{{html .Name}}</a></td>
			<td>&nbsp;&nbsp;&nbsp;&nbsp;</td>
			<td style="width: auto">{{html .Synopsis}}</td>
			</tr>
		{{end}}
	{{end}}
	</table>
{{end}}
