def listkeywords(base, kwlist, bigletter=False):
    kwlist.sort()

    r = TemplateIO(html=True)
    
    if not kwlist:
        return r

    if len(kwlist) > 10:
        divide = 'p'
    else:
        divide = 'span'

    char = None

    kwlist.sort()

    for k in kwlist:
        if k[0] != char:
            if char:
                r += H('</%s>\n' % divide) 
            r += H('<%s class="emphasize %s">\n' % (divide, bigletter and 'bigletter' or ''))
            char = k[0]
        r += H('  <a class="kw" href="%s%s/">%s</a>\n') % (base, k, k)
    if char:
        r += H('</%s>\n' % divide) 

    return r.getvalue()

 def _render_start(self, request, action,
                   enctype=None, method='post', name=None):
     r = TemplateIO(html=1)
     r += htmltag('form', enctype=enctype, method=method,
                  action=action, name=name)
     r += self._render_hidden_widgets(request)
     return r.getvalue()

 def _render_hidden_widgets(self, request):
     r = TemplateIO(html=1)
     for widget in self.widget_order:
         if widget.widget_type == 'hidden':
             r += widget.render(request)
             r += self._render_error(self.error.get(widget.name))
     return r.getvalue()

 def _q_index(self):
     """
     If directory listings are allowed, generate a simple HTML
     listing of the directory's contents with each item hyperlinked;
     if the item is a subdirectory, place a '/' after it. If not allowed,
     return a page to that effect.
     """
     if self.index_filenames:
         for name in self.index_filenames:
             try:
                 obj = self._q_lookup(name)
             except errors.TraversalError:
                 continue
             if (not isinstance(obj, StaticDirectory)
                     and hasattr(obj, '__call__')):
                 return obj()
     if self.list_directory:
         title = 'Index of %s' % quixote.get_path()
         r = TemplateIO(html=True)
         template = htmltext('<a href="%s">%s</a>%s\n')
         r += htmltext('<pre>')
         r += template % ('..', '..', '')
         files = os.listdir(self.path)
         files.sort()
         for filename in files:
             filepath = os.path.join(self.path, filename)
             marker = os.path.isdir(filepath) and "/" or ""
             r += template % (urllib.quote(filename), filename, marker)
         r += htmltext('</pre>')
         body = r.getvalue()
     else:
         title = 'Directory listing denied'
         body = htmltext('<p>This directory does not allow its contents '
                         'to be listed.</p>')
     return errors.format_page(title, body)

 def _render_submit_buttons(self, request, ncols=3):
     r = TemplateIO(html=1)
     r += htmltext('<tr><td colspan="%d">\n') % ncols
     for button in self.submit_buttons:
         r += button.render(request)
     r += htmltext('</td></tr>')
     return r.getvalue()

 def _render_start(self):
     r = TemplateIO(html=True)
     r += htmltag('form', name=self.name, method=self.method,
                  enctype=self.enctype, action=self.action_url,
                  **self.attrs)
     r += self._render_hidden_widgets()
     return r.getvalue()

 def _render_finish(self):
     r = TemplateIO(html=True)
     r += htmltext('</form><br class="quixoteform" />')
     code = get_request().response.javascript_code
     if code:
         r += self._render_javascript(code)
     return r.getvalue()

 def _render_body(self):
     r = TemplateIO(html=True)
     if self.has_errors():
         r += self._render_error_notice()
     r += self._render_widgets()
     r += self._render_submit_widgets()
     return r.getvalue()

 def _render_submit_widgets(self):
     r = TemplateIO(html=True)
     if self.submit_widgets:
         r += htmltext('<div class="submit">')
         for widget in self.submit_widgets:
             r += widget.render()
         r += htmltext('</div><br class="submit" />')
     return r.getvalue()

    def editdetails(self, request, p):
        form = form2.Form(name='editdetails')

        form.add(form2.StringWidget, name='title', size=50,
                 value=p.title or '', title='Title')
        form.add(form2.StringWidget, name='keywords', size=40,
                 value=', '.join([ k.word for k in p.keywords]),
                 title='Keywords')
        form.add(form2.StringWidget, name='description', size=50,
                 value=p.description, title='Description')
# FIXME form layout
#        form.add(form2.TextWidget, name='description', cols=50, rows=10,
#                 value=p.description, title='Description')

        form.add(form2.SingleSelectWidget, name='owner', value=p.ownerID, title='Picture owner',
                 options=imagestore.form.userOptList())
        form.add(form2.SingleSelectWidget, name='visibility',
                 value=p.visibility, title='Visibility',
                 options=[ s for s in ['public', 'restricted', 'private']])

        (prev,next) = request.session.get_results_neighbours(p.id)

        if next is not None:
            form.add_submit('submit-next', H('Update picture and go to next >>'))
        else:
            form.add_submit('submit', 'Update picture details')
        form.add_reset('reset', 'Revert changes')

        if not form.is_submitted() or form.has_errors():
            from image_page import detail_table
            
            self.image.set_prevnext(request, p.id,
                                    urlfn=lambda pic, size, s=self.image: s.edit.path(pic))
            
            ret = TemplateIO(html=True)
            
            ret += page.pre(request, 'Edit details', 'editdetails', trail=False)
            ret += page.menupane(request)
            ret += self.image.view_rotate_link(request, p, wantedit=True)
            ret += detail_table(p)
            ret += form.render()
            ret += page.post()

            ret = ret.getvalue()
        else:
            keywords = form['keywords']
            keywords = imagestore.form.splitKeywords(keywords)

            p.setKeywords(keywords)

            p.visibility = form['visibility']

            if form.get_submit() == 'submit-next' and next:
                ret = quixote.redirect(self.image.edit.path(db.Picture.get(next)))
            else:
                ret = quixote.redirect(request.get_path())

        return ret

        def upload(self, request):
            form = self.upload_form(request)

            if form.get_submit() != 'upload':
                r = TemplateIO(html=True)

                r += page.pre(request, 'Upload pictures', 'upload')
                r += page.menupane(request)
                r += form.render()

                #r += H(request.dump_html())

                r += page.post()

                return r.getvalue()
            else:
                user = request.session.getuser()
                start = calendar.int_day.rounddown(gmt())
                end = calendar.int_day.roundup(gmt())
                upload = db.Upload.select(AND(db.Upload.q.import_time >= start,
                                              db.Upload.q.import_time < end,
                                              db.Upload.q.userID == user.id,
                                              db.Upload.q.collectionID == self.collection.db.id))

                assert upload.count() == 0 or upload.count() == 1, \
                       'Should be only one Upload per day per user'

                if upload.count() == 1:
                    u = upload[0]
                else:
                    u = db.Upload(user=user, collection=self.collection.db)

                c = int(form['camera'])

                if c == -2:
                    camera = None                    # new camera            
                elif c == -1:
                    camera = None                    # guess
                else:
                    camera = db.Camera.get(c)

                numfiles = int(form['numfiles'])

                keywords = form['keywords']
                if keywords is not None:
                    keywords = splitKeywords(keywords)

                print 'self.collection.db=%s' % self.collection.db

                request.response.buffered=False
                upload = self.do_upload(request,
                                        [ (f.fp, f.base_filename)
                                          for f in [ form['file.%d' % n]
                                                     for n in range(numfiles) ]
                                          if f is not None],
                                        user, camera, keywords, form['visibility'], u)
                return quixote.http_response.Stream(upload)

    def render(self, depth=0):
        r = TemplateIO(html=True)

        pfx = _p(depth)
        r += H("%s<div %s>") % (pfx, self.tags())
        self.renderitems(r, depth + 1, None)
        r += H("\n%s</div>\n") % pfx

        return r.getvalue()

 def render(self):
     """() -> HTML text
     Render a form as HTML.
     """
     r = TemplateIO(html=True)
     r += self._render_start()
     r += self._render_body()
     r += self._render_finish()
     return r.getvalue()

 def _render_body(self, request):
     r = TemplateIO(html=1)
     r += htmltext('<table>')
     r += self._render_error_notice(request)
     r += self._render_required_notice(request)
     r += self._render_visible_widgets(request)
     r += self._render_submit_buttons(request)
     r += htmltext('</table>')
     return r.getvalue()

 def render_content(self):
     r = TemplateIO(html=True)
     add_element_widget = self.get_widget('add_element')
     for widget in self.get_widgets():
         if widget is add_element_widget:
             continue
         r += widget.render()
     r += add_element_widget.render()
     return r.getvalue()

    def render():
        ret = TemplateIO(html=True)

        ret += page.pre(request, 'User administration', 'editusers')
        ret += page.menupane(request)
        ret += H('<h1>User administration</h1>\n')
        ret += userform.render()
        ret += page.post()

        return ret.getvalue()

 def _render_header(self, title):
     r = TemplateIO(html=True)
     r += htmltext('<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 '
                   'Transitional//EN" '
                   '"http://www.w3.org/TR/REC-html40/loose.dtd">')
     r += htmltext('<html>')
     r += htmltext('<head><title>%s</title></head>') % title
     r += htmltext('<body>')
     r += htmltext("<h1>%s</h1>") % title
     return r.getvalue()

def newuser(request):
    user = admin.login_user(quiet=True)

    if not ((user and user.mayAdmin) or
            config.get('users', 'unpriv_newuser')):
        raise AccessError('You may not create a new user')

    form = form2.Form()
    
    form.add(form2.StringWidget, 'username', title='User name')
    form.add(form2.StringWidget, 'fullname', title='Full name')
    form.add(form2.StringWidget, 'email', title='email address')
    form.add(form2.PasswordWidget, 'pass1', title='Password')
    form.add(form2.PasswordWidget, 'pass2', title='Password verify')
    form.add_submit('create', 'Create user')
    
    ret = None
    
    if form.is_submitted():
        username = form['username'].strip()
        if db.User.select(db.User.q.username == username).count() != 0:
            form.get_widget('username').set_error(H("Username '%s' already in use") % username)
        if form['pass1'] != form['pass2']:
            form.get_widget('pass1').set_error('Passwords do not match')
        fullname = form['fullname'].strip()
        if fullname == '':
            form.get_widget('fullname').set_error('Full name not set')
        email = form['email'].strip()
        if email == '':
            form.get_widget('email').set_error('Missing or bad email address')
            
        if not form.has_errors():
            u = db.User(username=username, fullname=fullname,
                        password=form['pass1'],
                        email=email,
                        mayAdmin=False,
                        mayViewall=False,
                        mayUpload=False,
                        mayComment=config.get('users', 'mayComment'),
                        mayRate=config.get('users', 'mayRate'))
            ret = quixote.redirect(path(u))

    if ret is None:
        r = TemplateIO(html=True)
        
        r += page.pre(request, 'New User', 'newuser')
        r += page.menupane(request)
        r += form.render()
        r += page.post()

        ret =  r.getvalue()

    return ret

 def __call__(self, request):
     r = TemplateIO(html=0)
     file_name = request.get_path()[1:]     # drop leading '/'
     r += header(get_title_from_path(file_name))
     body = StaticFile.__call__(self, request)
     if isinstance(body, Stream):
         for hunk in body:
             r += hunk
     else:
         r += body
     r += footer()
     return r.getvalue()

 def render_content(self):
     r = TemplateIO(html=True)
     for widget in self.get_widgets():
         if widget.get_title():
             classnames = '%s widget' % widget.__class__.__name__
             r += H('<td title="%s" class="%s">') % (widget.get_hint(), classnames)
             r += widget.render_content()
             r += widget.render_error(widget.get_error())
             r += H('</td>')
         else:
             r += widget.render_content()
     return r.getvalue()