tooltip = _ToolTip()

class _FilesBreadCrumbs(object):

    def __call__(self, repo_name, rev, paths):

        if isinstance(paths, str):

            paths = paths.decode('utf-8')

        url_l = [link_to(repo_name, url('files_home',

                                        repo_name=repo_name,

                                        revision=rev, f_path=''))]

        paths_l = paths.split('/')

        for cnt, p in enumerate(paths_l):

            if p != '':

                url_l.append(link_to(p, url('files_home',

                                            repo_name=repo_name,

                                            revision=rev,

                                            f_path='/'.join(paths_l[:cnt + 1]))))

        return literal('/'.join(url_l))

files_breadcrumbs = _FilesBreadCrumbs()

class CodeHtmlFormatter(HtmlFormatter):

    """My code Html Formatter for source codes

    """

    def wrap(self, source, outfile):

        return self._wrap_div(self._wrap_pre(self._wrap_code(source)))

    def _wrap_code(self, source):

        for cnt, it in enumerate(source):

            i, t = it

            t = '<div id="L%s">%s</div>' % (cnt + 1, t)

            yield i, t

    def _wrap_tablelinenos(self, inner):

        dummyoutfile = StringIO.StringIO()

        lncount = 0

        for t, line in inner:

            if t:

                lncount += 1

            dummyoutfile.write(line)

        fl = self.linenostart

        mw = len(str(lncount + fl - 1))

        sp = self.linenospecial

        st = self.linenostep

        la = self.lineanchors

        aln = self.anchorlinenos

        nocls = self.noclasses

        if sp:

            lines = []

            for i in range(fl, fl + lncount):

                if i % st == 0:

                    if i % sp == 0:

                        if aln:

                            lines.append('<a href="#%s%d" class="special">%*d</a>' %

                                         (la, i, mw, i))

                        else:

                            lines.append('<span class="special">%*d</span>' % (mw, i))

                    else:

                        if aln:

                            lines.append('<a href="#%s%d">%*d</a>' % (la, i, mw, i))

                        else:

                            lines.append('%*d' % (mw, i))

                else:

                    lines.append('')

            ls = '\n'.join(lines)

        else:

            lines = []

            for i in range(fl, fl + lncount):

                if i % st == 0:

                    if aln:

                        lines.append('<a href="#%s%d">%*d</a>' % (la, i, mw, i))

                    else:

                        lines.append('%*d' % (mw, i))

                else:

                    lines.append('')

            ls = '\n'.join(lines)

        # in case you wonder about the seemingly redundant <div> here: since the

        # content in the other cell also is wrapped in a div, some browsers in

        # some configurations seem to mess up the formatting...

        if nocls:

            yield 0, ('<table class="%stable">' % self.cssclass +

                      '<tr><td><div class="linenodiv" '

                      'style="background-color: #f0f0f0; padding-right: 10px">'

                      '<pre style="line-height: 125%">' +

                      ls + '</pre></div></td><td class="code">')

        else:

            yield 0, ('<table class="%stable">' % self.cssclass +

                      '<tr><td class="linenos"><div class="linenodiv"><pre>' +

                      ls + '</pre></div></td><td class="code">')

        yield 0, dummyoutfile.getvalue()

        yield 0, '</td></tr></table>'

def pygmentize(filenode, **kwargs):

    """pygmentize function using pygments

    :param filenode:

    """

    return literal(code_highlight(filenode.content,

                                  filenode.lexer, CodeHtmlFormatter(**kwargs)))

def pygmentize_annotation(filenode, **kwargs):

    """pygmentize function for annotation

    :param filenode:

    """

    color_dict = {}

    def gen_color(n=10000):

        """generator for getting n of evenly distributed colors using 

        hsv color and golden ratio. It always return same order of colors

        :returns: RGB tuple

        """

        import colorsys

        golden_ratio = 0.618033988749895

        h = 0.22717784590367374

        for c in xrange(n):

            h += golden_ratio

            h %= 1

            HSV_tuple = [h, 0.95, 0.95]

            RGB_tuple = colorsys.hsv_to_rgb(*HSV_tuple)

            yield map(lambda x:str(int(x * 256)), RGB_tuple)

    cgenerator = gen_color()

    def get_color_string(cs):

        if color_dict.has_key(cs):

            col = color_dict[cs]

        else:

            col = color_dict[cs] = cgenerator.next()

        return "color: rgb(%s)! important;" % (', '.join(col))

    def url_func(changeset):

        tooltip_html = "<div style='font-size:0.8em'><b>Author:</b>" + \

        " %s<br/><b>Date:</b> %s</b><br/><b>Message:</b> %s<br/></div>"

        tooltip_html = tooltip_html % (changeset.author,

                                               changeset.date,

                                               tooltip(changeset.message))

        lnk_format = '%5s:%s' % ('r%s' % changeset.revision,

                                 short_id(changeset.raw_id))

        uri = link_to(

                lnk_format,

                url('changeset_home', repo_name=changeset.repository.name,

                    revision=changeset.raw_id),

                style=get_color_string(changeset.raw_id),

                class_='tooltip',

                title=tooltip_html

              )

        uri += '\n'

        return uri

    return literal(annotate_highlight(filenode, url_func, **kwargs))

def repo_name_slug(value):

    """Return slug of name of repository

    This function is called on each creation/modification

    of repository to prevent bad names in repo

    """

    slug = remove_formatting(value)

    slug = strip_tags(slug)

    for c in """=[]\;'"<>,/~!@#$%^&*()+{}|: """:

        slug = slug.replace(c, '-')

    slug = recursive_replace(slug, '-')

    slug = collapse(slug, '-')

    return slug

def get_changeset_safe(repo, rev):

    from vcs.backends.base import BaseRepository

    from vcs.exceptions import RepositoryError

    if not isinstance(repo, BaseRepository):

        raise Exception('You must pass an Repository '

                        'object as first argument got %s', type(repo))

    try:

        cs = repo.get_changeset(rev)

    except RepositoryError:

        from rhodecode.lib.utils import EmptyChangeset

        cs = EmptyChangeset()

    return cs

flash = _Flash()

#==============================================================================

# MERCURIAL FILTERS available via h.

#==============================================================================

from mercurial import util

from mercurial.templatefilters import person as _person

def _age(curdate):

    """turns a datetime into an age string."""

    if not curdate:

        return ''

    from datetime import timedelta, datetime

    agescales = [("year", 3600 * 24 * 365),

                 ("month", 3600 * 24 * 30),

                 ("day", 3600 * 24),

                 ("hour", 3600),

                 ("minute", 60),

                 ("second", 1), ]

    age = datetime.now() - curdate

    age_seconds = (age.days * agescales[2][1]) + age.seconds

    pos = 1

    for scale in agescales:

        if scale[1] <= age_seconds:

            if pos == 6:pos = 5

            return time_ago_in_words(curdate, agescales[pos][0]) + ' ' + _('ago')

        pos += 1

    return _('just now')

age = lambda  x:_age(x)

capitalize = lambda x: x.capitalize()

email = util.email

email_or_none = lambda x: util.email(x) if util.email(x) != x else None

person = lambda x: _person(x)

short_id = lambda x: x[:12]

def bool2icon(value):

    """Returns True/False values represented as small html image of true/false

    icons

    :param value: bool value

    """

    if value is True:

        return HTML.tag('img', src="/images/icons/accept.png", alt=_('True'))

    if value is False:

        return HTML.tag('img', src="/images/icons/cancel.png", alt=_('False'))

    return value

def action_parser(user_log):

    """This helper will map the specified string action into translated

    fancy names with icons and links

    :param user_log: user log instance

    """

    action = user_log.action

    action_params = ' '

    x = action.split(':')

    if len(x) > 1:

        action, action_params = x

    def get_cs_links():

        revs_limit = 5 #display this amount always

        revs_top_limit = 50 #show upto this amount of changesets hidden

        revs = action_params.split(',')

        repo_name = user_log.repository.repo_name

        from rhodecode.model.scm import ScmModel

        message = lambda rev: get_changeset_safe(ScmModel().get(repo_name),

                                                 rev).message

        cs_links = " " + ', '.join ([link_to(rev,

                url('changeset_home',

                repo_name=repo_name,

                revision=rev), title=tooltip(message(rev)),

                class_='tooltip') for rev in revs[:revs_limit] ])

        if len(revs) > revs_limit:

            uniq_id = revs[0]

            html_tmpl = ('<span> %s '

            '<a class="show_more" id="_%s" href="#more">%s</a> '

            '%s</span>')

            cs_links += html_tmpl % (_('and'), uniq_id, _('%s more') \

                                        % (len(revs) - revs_limit),

                                        _('revisions'))

            html_tmpl = '<span id="%s" style="display:none"> %s </span>'

            cs_links += html_tmpl % (uniq_id, ', '.join([link_to(rev,

                url('changeset_home',

                repo_name=repo_name, revision=rev),

                title=message(rev), class_='tooltip')

                for rev in revs[revs_limit:revs_top_limit]]))

        return cs_links

    def get_fork_name():

        from rhodecode.model.scm import ScmModel

        repo_name = action_params

        repo = ScmModel().get(repo_name)

        if repo is None:

            return repo_name

        return link_to(action_params, url('summary_home',

                                          repo_name=repo.name,),

                                          title=repo.dbrepo.description)

    map = {'user_deleted_repo':(_('User [deleted] repository'), None),

           'user_created_repo':(_('User [created] repository'), None),

           'user_forked_repo':(_('User [forked] repository as:'), get_fork_name),

           'user_updated_repo':(_('User [updated] repository'), None),

           'admin_deleted_repo':(_('Admin [delete] repository'), None),

           'admin_created_repo':(_('Admin [created] repository'), None),

           'admin_forked_repo':(_('Admin [forked] repository'), None),

           'admin_updated_repo':(_('Admin [updated] repository'), None),

           'push':(_('[Pushed]'), get_cs_links),

           'pull':(_('[Pulled]'), None),

           'started_following_repo':(_('User [started following] repository'), None),

           'stopped_following_repo':(_('User [stopped following] repository'), None),

            }

    action_str = map.get(action, action)

    action = action_str[0].replace('[', '<span class="journal_highlight">')\

                   .replace(']', '</span>')

    if action_str[1] is not None:

        action = action + " " + action_str[1]()

    return literal(action)

def action_parser_icon(user_log):

    action = user_log.action

    action_params = None

    x = action.split(':')

    if len(x) > 1:

        action, action_params = x

    tmpl = """<img src="/images/icons/%s" alt="%s"/>"""

    map = {'user_deleted_repo':'database_delete.png',

           'user_created_repo':'database_add.png',

           'user_forked_repo':'arrow_divide.png',

           'user_updated_repo':'database_edit.png',

           'admin_deleted_repo':'database_delete.png',

           'admin_created_repo':'database_add.png',

           'admin_forked_repo':'arrow_divide.png',

           'admin_updated_repo':'database_edit.png',

           'push':'script_add.png',

           'pull':'down_16.png',

           'started_following_repo':'heart_add.png',

           'stopped_following_repo':'heart_delete.png',

            }

    return literal(tmpl % (map.get(action, action), action))

#==============================================================================

# PERMS

#==============================================================================

from rhodecode.lib.auth import HasPermissionAny, HasPermissionAll, \

HasRepoPermissionAny, HasRepoPermissionAll

#==============================================================================

# GRAVATAR URL

#==============================================================================

import hashlib

import urllib

from pylons import request

def gravatar_url(email_address, size=30):

    ssl_enabled = 'https' == request.environ.get('wsgi.url_scheme')

    default = 'identicon'

    baseurl_nossl = "http://www.gravatar.com/avatar/"

    baseurl_ssl = "https://secure.gravatar.com/avatar/"

    baseurl = baseurl_ssl if ssl_enabled else baseurl_nossl

    # construct the url

    gravatar_url = baseurl + hashlib.md5(email_address.lower()).hexdigest() + "?"

    gravatar_url += urllib.urlencode({'d':default, 's':str(size)})

    return gravatar_url

def safe_unicode(str):

        #get the repositories that should be invalidated

        invalidation_list = [str(x.cache_key) for x in \

                             self.sa.query(CacheInvalidation.cache_key)\

                             .filter(CacheInvalidation.cache_active == False)\

                             .all()]

        for r in all_repos:

            repo = self.get(r.repo_name, invalidation_list)

            if repo is not None:

                last_change = repo.last_change

                tip = h.get_changeset_safe(repo, 'tip')

                tmp_d = {}

                tmp_d['name'] = r.repo_name

                tmp_d['name_sort'] = tmp_d['name'].lower()

                tmp_d['description'] = repo.dbrepo.description

                tmp_d['description_sort'] = tmp_d['description']

                tmp_d['last_change'] = last_change

                tmp_d['last_change_sort'] = time.mktime(last_change.timetuple())

                tmp_d['tip'] = tip.raw_id

                tmp_d['tip_sort'] = tip.revision

                tmp_d['rev'] = tip.revision

                tmp_d['contact'] = repo.dbrepo.user.full_contact

                tmp_d['contact_sort'] = tmp_d['contact']

                tmp_d['repo_archives'] = list(repo._get_archives())

                tmp_d['last_msg'] = tip.message

                tmp_d['repo'] = repo

                yield tmp_d

    def get_repo(self, repo_name):

        return self.get(repo_name)

    def get(self, repo_name, invalidation_list=None):

        """Get's repository from given name, creates BackendInstance and

        propagates it's data from database with all additional information

        :param repo_name:

        :param invalidation_list: if a invalidation list is given the get

            method should not manually check if this repository needs 

            invalidation and just invalidate the repositories in list

        """

        if not HasRepoPermissionAny('repository.read', 'repository.write',

                            'repository.admin')(repo_name, 'get repo check'):

            return

        #======================================================================

        # CACHE FUNCTION

        #======================================================================

        @cache_region('long_term')

        def _get_repo(repo_name):

            repo_path = os.path.join(self.repos_path, repo_name)

            try:

                alias = get_scm(repo_path)[0]

                log.debug('Creating instance of %s repository', alias)

                backend = get_backend(alias)

            except VCSError:

                log.error(traceback.format_exc())

                return

            if alias == 'hg':

                from pylons import app_globals as g

                repo = backend(repo_path, create=False, baseui=g.baseui)

                #skip hidden web repository

                if repo._get_hidden():

                    return

            else:

                repo = backend(repo_path, create=False)

            dbrepo = self.sa.query(Repository)\

                .options(joinedload(Repository.fork))\

                .options(joinedload(Repository.user))\

                .filter(Repository.repo_name == repo_name)\

                .scalar()

            make_transient(dbrepo)

            if dbrepo.user:

                make_transient(dbrepo.user)

            if dbrepo.fork:

                make_transient(dbrepo.fork)

            repo.dbrepo = dbrepo

            return repo

        pre_invalidate = True

        if invalidation_list is not None:

            pre_invalidate = repo_name in invalidation_list

        if pre_invalidate:

            invalidate = self._should_invalidate(repo_name)

            if invalidate:

                log.info('invalidating cache for repository %s', repo_name)

                region_invalidate(_get_repo, None, repo_name)

                self._mark_invalidated(invalidate)

        return _get_repo(repo_name)

    def mark_for_invalidation(self, repo_name):

        """Puts cache invalidation task into db for 

        further global cache invalidation

        :param repo_name: this repo that should invalidation take place

        """

        log.debug('marking %s for invalidation', repo_name)

        cache = self.sa.query(CacheInvalidation)\

            .filter(CacheInvalidation.cache_key == repo_name).scalar()

        if cache:

            #mark this cache as inactive

            cache.cache_active = False

        else:

            log.debug('cache key not found in invalidation db -> creating one')

            cache = CacheInvalidation(repo_name)

        try:

            self.sa.add(cache)

            self.sa.commit()

        except (DatabaseError,):

            log.error(traceback.format_exc())

            self.sa.rollback()

    def toggle_following_repo(self, follow_repo_id, user_id):

        f = self.sa.query(UserFollowing)\

            .filter(UserFollowing.follows_repo_id == follow_repo_id)\

            .filter(UserFollowing.user_id == user_id).scalar()

        if f is not None:

            try:

                self.sa.delete(f)

                self.sa.commit()

                action_logger(UserTemp(user_id),

                              'stopped_following_repo',

                              RepoTemp(follow_repo_id))

                return

            except:

                log.error(traceback.format_exc())

                self.sa.rollback()

                raise

        try:

            f = UserFollowing()

            f.user_id = user_id

            f.follows_repo_id = follow_repo_id

            self.sa.add(f)

            self.sa.commit()

            action_logger(UserTemp(user_id),

                          'started_following_repo',

                          RepoTemp(follow_repo_id))

        except:

            log.error(traceback.format_exc())

            self.sa.rollback()

            raise

    def toggle_following_user(self, follow_user_id , user_id):

        f = self.sa.query(UserFollowing)\

            .filter(UserFollowing.follows_user_id == follow_user_id)\

            .filter(UserFollowing.user_id == user_id).scalar()

        if f is not None:

            try:

                self.sa.delete(f)

                self.sa.commit()

                return

            except:

                log.error(traceback.format_exc())

                self.sa.rollback()

                raise

        try:

            f = UserFollowing()

            f.user_id = user_id

            f.follows_user_id = follow_user_id

            self.sa.add(f)

            self.sa.commit()

        except:

            log.error(traceback.format_exc())

            self.sa.rollback()

            raise

        r = self.sa.query(Repository)\

            .filter(Repository.repo_name == repo_name).scalar()

        f = self.sa.query(UserFollowing)\

            .filter(UserFollowing.follows_repository == r)\

            .filter(UserFollowing.user_id == user_id).scalar()

        return f is not None

        u = UserModel(self.sa).get_by_username(username)

        f = self.sa.query(UserFollowing)\

            .filter(UserFollowing.follows_user == u)\

            .filter(UserFollowing.user_id == user_id).scalar()

        return f is not None

    def get_followers(self, repo_id):

        return self.sa.query(UserFollowing)\

                .filter(UserFollowing.follows_repo_id == repo_id).count()

    def get_forks(self, repo_id):

        return self.sa.query(Repository)\

                .filter(Repository.fork_id == repo_id).count()

    def get_unread_journal(self):

        return self.sa.query(UserLog).count()

    def _should_invalidate(self, repo_name):

        """Looks up database for invalidation signals for this repo_name

        :param repo_name:

        """

        ret = self.sa.query(CacheInvalidation)\

            .options(FromCache('sql_cache_short',

                           'get_invalidation_%s' % repo_name))\

            .filter(CacheInvalidation.cache_key == repo_name)\

            .filter(CacheInvalidation.cache_active == False)\

            .scalar()

        return ret

    def _mark_invalidated(self, cache_key):

        """ Marks all occurences of cache to invaldation as already invalidated

        :param cache_key:

        """

        if cache_key:

            log.debug('marking %s as already invalidated', cache_key)

        try:

            cache_key.cache_active = True

            self.sa.add(cache_key)

            self.sa.commit()

        except (DatabaseError,):

            log.error(traceback.format_exc())

            self.sa.rollback()

	               <span>${_('Summary')}</span>                 

	               </a>	            

	            </li>

                ##<li ${is_current('shortlog')}>

                ##   <a title="${_('Shortlog')}" href="${h.url('shortlog_home',repo_name=c.repo_name)}">

                ##   <span class="icon">

                ##       <img src="/images/icons/application_view_list.png" alt="${_('Shortlog')}" />

                ##   </span>

                ##   <span>${_('Shortlog')}</span>                 

                ##   </a>             

                ##</li>	            

                <li ${is_current('changelog')}>

                   <a title="${_('Changelog')}" href="${h.url('changelog_home',repo_name=c.repo_name)}">

                   <span class="icon">

                       <img src="/images/icons/time.png" alt="${_('Changelog')}" />

                   </span>

                   <span>${_('Changelog')}</span>                 

                   </a>             

                </li>   	

                <li ${is_current('switch_to')}>

                   <a title="${_('Switch to')}" href="#">

                   <span class="icon">

                       <img src="/images/icons/arrow_switch.png" alt="${_('Switch to')}" />

                   </span>

                   <span>${_('Switch to')}</span>                 

                   </a>    

                    <ul>

                        <li>

                            ${h.link_to('%s (%s)' % (_('branches'),len(c.repository_branches.values()),),h.url('branches_home',repo_name=c.repo_name),class_='branches childs')}

                            <ul>

                            %if c.repository_branches.values():

						        %for cnt,branch in enumerate(c.repository_branches.items()):

						            <li>${h.link_to('%s - %s' % (branch[0],h.short_id(branch[1])),h.url('files_home',repo_name=c.repo_name,revision=branch[1]))}</li>

						        %endfor

						    %else:

						    	<li>${h.link_to(_('There are no branches yet'),'#')}</li>

						    %endif

                            </ul>                        

                        </li>

                        <li>

                            ${h.link_to('%s (%s)' % (_('tags'),len(c.repository_tags.values()),),h.url('tags_home',repo_name=c.repo_name),class_='tags childs')}

                            <ul>

                            %if c.repository_tags.values():

                                %for cnt,tag in enumerate(c.repository_tags.items()):

                                 <li>${h.link_to('%s - %s' % (tag[0],h.short_id(tag[1])),h.url('files_home',repo_name=c.repo_name,revision=tag[1]))}</li>

                                %endfor

                            %else:

                            	<li>${h.link_to(_('There are no tags yet'),'#')}</li>

                            %endif

                            </ul>                        

                        </li>                        

                    </ul>

                </li>

                <li ${is_current('files')}>

                   <a title="${_('Files')}" href="${h.url('files_home',repo_name=c.repo_name)}">

                   <span class="icon">

                       <img src="/images/icons/file.png" alt="${_('Files')}" />

                   </span>

                   <span>${_('Files')}</span>                 

                   </a>             

                </li>                            

                <li ${is_current('options')}>

                   <a title="${_('Options')}" href="#">

                   <span class="icon">

                       <img src="/images/icons/table_gear.png" alt="${_('Admin')}" />

                   </span>

                   <span>${_('Options')}</span>                 

                   </a>

                   <ul>

                   %if h.HasRepoPermissionAll('repository.admin')(c.repo_name):

                     %if h.HasPermissionAll('hg.admin')('access settings on repository'):

                         <li>${h.link_to(_('settings'),h.url('edit_repo',repo_name=c.repo_name),class_='settings')}</li>

                     %else:

                         <li>${h.link_to(_('settings'),h.url('repo_settings_home',repo_name=c.repo_name),class_='settings')}</li>

                     %endif

                   	<li>${h.link_to(_('fork'),h.url('repo_fork_home',repo_name=c.repo_name),class_='fork')}</li>

                   %endif  

                   	<li>${h.link_to(_('search'),h.url('search_repo',search_repo=c.repo_name),class_='search')}</li>

                    %if h.HasPermissionAll('hg.admin')('access admin main page'):

                    <li>

                       ${h.link_to(_('admin'),h.url('admin_home'),class_='admin')}  

                        <%def name="admin_menu()">

                        <ul>

                            <li>${h.link_to(_('journal'),h.url('admin_home'),class_='journal')}</li>

                            <li>${h.link_to(_('repositories'),h.url('repos'),class_='repos')}</li>

                            <li>${h.link_to(_('users'),h.url('users'),class_='users')}</li>

                            <li>${h.link_to(_('users groups'),h.url('users_groups'),class_='groups')}</li>

                            <li>${h.link_to(_('permissions'),h.url('edit_permission',id='default'),class_='permissions')}</li>

                            <li>${h.link_to(_('ldap'),h.url('ldap_home'),class_='ldap')}</li>

                            <li class="last">${h.link_to(_('settings'),h.url('admin_settings'),class_='settings')}</li>        

                        </ul>

                        </%def>

                        ${admin_menu()}

                    </li>

                    %endif

                   </ul>             

                </li>

                <li>

                    <a title="${_('Followers')}" href="#">

                    <span class="icon_short">

                        <img src="/images/icons/heart.png" alt="${_('Followers')}" />

                    </span>

                    <span class="short">${c.repository_followers}</span>

                    </a>

                </li>

                <li>

                    <a title="${_('Forks')}" href="#">

                    <span class="icon_short">

                        <img src="/images/icons/arrow_divide.png" alt="${_('Forks')}" />

                    </span>

                    <span class="short">${c.repository_forks}</span>

                    </a>

                </li>                

	        </ul>

		%else:

		    ##ROOT MENU

            <ul id="quick">

                <li>

                    <a title="${_('Home')}"  href="${h.url('home')}">

                    <span class="icon">

                        <img src="/images/icons/home_16.png" alt="${_('Home')}" />

                    </span>

                    <span>${_('Home')}</span>                 

                    </a>        

                </li>

                %if c.rhodecode_user.username != 'default':

                <li>

                    <a title="${_('Journal')}"  href="${h.url('journal')}">

                    <span class="icon">

                        <img src="/images/icons/book.png" alt="${_('Journal')}" />

                    </span>

                    <span>${_('Journal')}</span>                 

                    </a>        

                </li>

                %endif          

                <li>

                    <a title="${_('Search')}"  href="${h.url('search')}">

                    <span class="icon">

                        <img src="/images/icons/search_16.png" alt="${_('Search')}" />

                    </span>

                    <span>${_('Search')}</span>                 

                    </a>        

                </li>

				%if h.HasPermissionAll('hg.admin')('access admin main page'):

                <li ${is_current('admin')}>

                   <a title="${_('Admin')}" href="${h.url('admin_home')}">

                   <span class="icon">

                       <img src="/images/icons/cog_edit.png" alt="${_('Admin')}" />

                   </span>

                   <span>${_('Admin')}</span>                 

                   </a>

                    ${admin_menu()}

                </li>

				%endif

			</ul>

		%endif    

</%def>

<%def name="css()">

<link rel="stylesheet" type="text/css" href="/css/style.css" media="screen" />

<link rel="stylesheet" type="text/css" href="/css/pygments.css"  />

<link rel="stylesheet" type="text/css" href="/css/diff.css"  />

</%def>

<%def name="js()">

##<script type="text/javascript" src="/js/yui/utilities/utilities.js"></script>

##<script type="text/javascript" src="/js/yui/container/container.js"></script>

##<script type="text/javascript" src="/js/yui/datasource/datasource.js"></script>

##<script type="text/javascript" src="/js/yui/autocomplete/autocomplete.js"></script>

##<script type="text/javascript" src="/js/yui/selector/selector-min.js"></script>

<script type="text/javascript" src="/js/yui2a.js"></script>

<!--[if IE]><script language="javascript" type="text/javascript" src="/js/excanvas.min.js"></script><![endif]-->

<script type="text/javascript" src="/js/yui.flot.js"></script>

<script type="text/javascript">

var base_url  ='/_admin/toggle_following';

var YUC = YAHOO.util.Connect;

var YUD = YAHOO.util.Dom;

var YUE = YAHOO.util.Event;

    if(f.getAttribute('class')=='follow'){

        f.setAttribute('class','following');

        f.setAttribute('title',"${_('Stop following this repository')}");

    }

    else{

        f.setAttribute('class','follow');

        f.setAttribute('title',"${_('Start following this repository')}");

    }

}

function toggleFollowingUser(fallows_user_id,token){