def errorlist(self, name=None, **attrs):
		"""
		Renders errors in a <ul> element if there are multiple, otherwise will
		use a div. Unless specified in attrs, class will be "Alert".

		If no errors present returns an empty string.

		`name` : errors for name. If **None** all errors will be rendered.
		"""

		if name is None:
			errors = self.all_errors()
		else:
			errors = self.errors_for(name)

		if not errors:
			return ''

		if 'class_' not in attrs:
			attrs['class_'] = "Alert"

		if len(errors) > 1:
			content = "\n".join(HTML.tag("li", error) for error in errors)

			return HTML.tag("ul", tags.literal(content), **attrs)

		return HTML.tag("div", errors[0], **attrs)

    def errorlist(self, name=None, **attrs):
        _ = self.form.request.translate
        """
        Renders errors in a <ul> element if there are multiple, otherwise will
        use a div. Unless specified in attrs, class will be "Alert".

        If no errors present returns an empty string.

        `name` : errors for name. If **None** all errors will be rendered.
        """

        if name is None:
            errors = self.all_errors()
        else:
            errors = self.errors_for(name)

        if not errors:
            return ''

        if 'class_' not in attrs:
            attrs['class_'] = "Alert"

        if len(errors) > 1:
            content = Markup("\n").join(HTML.tag("li", error) for error in errors)

            return HTML.tag("ul", tags.literal(content), **attrs)

        return Markup('''
            <div class="ui-widget clearfix" style="margin: 0.25em;">
                <div class="ui-state-error error-field-wrapper">
                <span class="ui-icon ui-icon-alert error-notice-icon">%s</span>%s
                </div>
            </div>
            ''') % (_('Error'),errors[0])

    def getAdrActions(self, principal):
        rc = []
        adr = principal.getAddress()

        address = {
            'name1': adr.name1,
            'name2': adr.name2,
            'name3': adr.name3,
            'street': adr.street,
            'number': adr.number,
            'zip_code': adr.zip_code,
            'city': adr.city,
            }

        oid = principal.oid
        if not adr or isinstance(adr, (models.AddressTraeger, models.AddressEinrichtung)):
            rc.append(
                    HTML.tag(
                        'a',
                        href="%s/addresses/add?form.field.oid=%s&form.field.mnr=%s" % (self.application_url(), oid, adr.mnr),
                        c="Neue Adresse anlegen",)
                    )
        elif isinstance(adr, models.Address):
            rc.append(
                    HTML.tag(
                        'a',
                        href="%s/addresses/%s/edit" % (self.application_url(), oid),
                        c="Adresse bearbeiten",)
                    )
        return address, rc

 def getErrorTag(self, name):
     if self.is_error(name):
         attrs = {}
         attrs['class'] = 'error_list'
         li = HTML.tag('li', self.errors_for(name)[0])
         return HTML.tag('ul', li, **attrs)
     return ''

 def pager(self, q=None):
     '''Returns pager html - for navigating between the pages.
        e.g. Something like this:
          <ul class='pagination pagination-alphabet'>
              <li class="active"><a href="/package/list?page=A">A</a></li>
              <li><a href="/package/list?page=B">B</a></li>
              <li><a href="/package/list?page=C">C</a></li>
                 ...
              <li class="disabled"><a href="/package/list?page=Z">Z</a></li>
              <li><a href="/package/list?page=Other">Other</a></li>
          </ul>
     '''
     if self.item_count < self.paging_threshold:
         return ''
     pages = []
     page = q or self.page
     for letter in self.letters:
         href = url_for(controller=self.controller_name, action='index', page=letter)
         link = HTML.a(href=href, c=letter)
         if letter != page:
             li_class = ''
         else:
             li_class = 'active'
         attributes = {'class_': li_class} if li_class else {}
         page_element = HTML.li(link, **attributes)
         pages.append(page_element)
     ul = HTML.tag('ul', *pages)
     div = HTML.div(ul, class_='pagination pagination-alphabet')
     return div

 def pager(self, q=None):
     '''Returns pager html - for navigating between the pages.
        e.g. Something like this:
          <div class='pager'>
              <span class="pager_curpage">A</span>
              <a class="pager_link" href="/package/list?page=B">B</a>
              <a class="pager_link" href="/package/list?page=C">C</a>
                 ...
              <a class="pager_link" href="/package/list?page=Z">Z</a
              <a class="pager_link" href="/package/list?page=Other">Other</a
          </div>
     '''
     if self.item_count < self.paging_threshold:
         return ''
     pages = []
     page = q or self.page
     letters = [char for char in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'] + [self.other_text]
     for letter in letters:
         if letter != page:
             if self.available.get(letter, 0):
                 page_element = HTML.a(class_='pager_link', href=url_for(controller=self.controller_name, action='index', page=letter),c=letter)
             else:
                 page_element = HTML.span(class_="pager_empty", c=letter)
         else:
             page_element = HTML.span(class_='pager_curpage', c=letter)
         pages.append(page_element)
     div = HTML.tag('div', class_='pager', *pages)
     return div

 def default_header_ordered_column_format(self, column_number, column_name,
                                          header_label):
     header_label = HTML(header_label, HTML.tag("span", class_="marker"))
     if column_name == "_numbered":
         column_name = "numbered"
     class_name = "c%s ordering %s %s" % (column_number, self.order_dir, column_name)
     return HTML.tag("td", header_label, class_=class_name)

 def render(self, **kwargs):
     html = ''
     checked = kwargs['options'][0][1]
     for label, value in kwargs['options']:
         r = tags.radio(self.name, value, checked=value == checked)
         t = HTML.tag('span', c=label)
         l = HTML.tag('label', c=r+' '+t)
         html += HTML.tag('li', c=l)
     return HTML.tag('ul', class_='inputs-list', c=html)

 def default_header_column_format(self, column_number, column_name,
     header_label):
     if column_name == "_numbered":
         column_name = "numbered"
     if column_name in self.exclude_ordering:
         class_name = "c%s %s" % (column_number, column_name)
         return HTML.tag("td", header_label, class_=class_name)
     else:
         header_label = HTML(header_label, HTML.tag("span", class_="marker"))
         class_name = "c%s ordering %s" % (column_number, column_name)
         return HTML.tag("td", header_label, class_=class_name)

 def _get_archived_btn(self, appstruct):
     """
         return the show archived button
     """
     archived = appstruct['archived']
     if not archived:
         url = self.request.current_route_path(_query=dict(archived="true"))
         link = HTML.a(u"Afficher les projets archivés",  href=url)
     else:
         url = self.request.current_route_path(_query=dict(archived="false"))
         link = HTML.a(u"Afficher les projets actifs", href=url)
     return StaticWidget(link)

 def _get_active_btn(self, appstruct):
     """
         return the show active button
     """
     active = appstruct['active']
     if active == 'N':
         url = self.request.current_route_path(_query=dict(active="Y"))
         link = HTML.a(u"Afficher les entreprises actives",  href=url)
     else:
         url = self.request.current_route_path(_query=dict(active="N"))
         link = HTML.a(u"Afficher les entreprises désactivées", href=url)
     return StaticWidget(link)

 def default_header_column_format(self, column_number, column_name,
     header_label):
     """Override of the ObjectGrid to use <th> for header columns
     """
     if column_name == "_numbered":
         column_name = "numbered"
     if column_name in self.exclude_ordering:
         class_name = "c%s %s" % (column_number, column_name)
         return HTML.tag("th", header_label, class_=class_name)
     else:
         header_label = HTML(
             header_label, HTML.tag("span", class_="marker"))
         class_name = "c%s ordering %s" % (column_number, column_name)
         return HTML.tag("th", header_label, class_=class_name)

 def default_header_ordered_column_format(self, column_number, column_name,
                                          header_label):
     """Override of the ObjectGrid to use <th> and to add an icon
     that represents the sort order for the column.
     """
     icon_direction = self.order_dir == 'asc' and 'up' or 'down'
     icon_class = 'icon-chevron-%s' % icon_direction
     icon_tag = HTML.tag("i", class_=icon_class)
     header_label = HTML(header_label, " ", icon_tag)
     if column_name == "_numbered":
         column_name = "numbered"
     class_name = "c%s ordering %s %s" % (
         column_number, self.order_dir, column_name)
     return HTML.tag("th", header_label, class_=class_name)

 def action_td(self, col_num, i, item):
     """Generate the column that has the actions in it.
     """
     return HTML.td(HTML.literal("""\
     <div class="btn-group">
       <a class="btn dropdown-toggle" data-toggle="dropdown" href="#">
       Action
       <span class="caret"></span>
       </a>
       <ul class="dropdown-menu" id="%s">
         <li><a class="todo-edit" href="#">Edit</a></li>
         <li><a class="todo-complete" href="#">Complete</a></li>
       </ul>
     </div>
     """ % item.id))

 def due_date_td(self, col_num, i, item):
     """Generate the column for the due date.
     """
     if item.due_date is None:
         return HTML.td('')
     span_class = 'due-date badge'
     if item.past_due:
         span_class += ' badge-important'
     due_date = localize_datetime(item.due_date, self.user_tz)
     span = HTML.tag(
         "span",
         c=HTML.literal(due_date.strftime('%Y-%m-%d %H:%M:%S')),
         class_=span_class,
     )
     return HTML.td(span)

    def tags_td(self, col_num, i, item):
        """Generate the column for the tags.
        """
        tag_links = []

        for tag in item.sorted_tags:
            tag_url = '%s/tags/%s' % (self.request.application_url, tag.name)
            tag_class = 'label'
            if self.selected_tag and tag.name == self.selected_tag:
                tag_class += ' label-warning'
            else:
                tag_class += ' label-info'
            anchor = HTML.tag("a", href=tag_url, c=tag.name,
                              class_=tag_class)
            tag_links.append(anchor)
        return HTML.td(*tag_links, _nl=True)

 def generate_header_link(self, column_number, column, label_text):
     """ This handles generation of link and then decides to call
     self.default_header_ordered_column_format 
     or 
     self.default_header_column_format 
     based on if current column is the one that is used for sorting or not
     """ 
     from pylons import url
     # this will handle possible URL generation
     request_copy = dict(self.request.copy().GET) 
     self.order_column = request_copy.pop("order_col", None)
     self.order_dir = request_copy.pop("order_dir", None)
     
     if column == self.order_column and self.order_dir == "asc":
         new_order_dir = "dsc"
     else:
         new_order_dir = "asc"
     
     url_href = url.current(order_col=column, order_dir=new_order_dir,
                            **request_copy)
     label_text = HTML.tag("a", href=url_href, c=label_text)
     # Is the current column the one we're ordering on?
     if column == self.order_column:
         return self.default_header_ordered_column_format(column_number,
                                                          column,
                                                          label_text)
     else:
         return self.default_header_column_format(column_number, column,
                                                  label_text)

    def label(self, name, label=None, **attrs):
        if 'for_' not in attrs:
            attrs['for_'] = self._id(None, name.lower())

        column = self.record().schema().column(name)
        label = label or column.displayName()
        return HTML.tag('label', label, **attrs)

 def due_date_td(self, col_num, i, item):
     """Generate the column for the due date.
     
     Time-Zone Localization is done in the model
     """
     if item.due_date is None:
         return HTML.td('')
     span_class = 'due-date badge'
     if item.past_due:
         span_class += ' badge-important'
     due_date = item.due_date 
     span = HTML.tag(
         "span",
         c=HTML.literal(due_date.strftime('%Y-%m-%d %H:%M:%S')),
         class_=span_class,
     )
     return HTML.td(span)

 def getAccountActions(self, account):
     rc = []
     oid = self.request.principal.oid
     rc.append(
             HTML.tag(
                 'a',
                 href="%s/accounts/add?form.field.oid=%s" % (self.application_url(), oid),
                 c="Neuen Benutzer anlegen",)
             )
     if not account:
         rc.append(
                 HTML.tag(
                     'a',
                     href="%s/accounts/add" % self.application_url(),
                     c="Neuen Benutzer anlegen",)
                 )
     return rc