user = User.get(id_)

        if user is not None:

            return person_getter(user)

    return id_

def boolicon(value):

    """Returns boolean value of a value, represented as small html image of true/false

    icons

    :param value: value

    """

    if value:

        return HTML.tag('i', class_="icon-ok")

    else:

        return HTML.tag('i', class_="icon-minus-circled")

def action_parser(user_log, feed=False, parse_cs=False):

    """

    This helper will action_map the specified string action into translated

    fancy names with icons and links

    :param user_log: user log instance

    :param feed: use output for feeds (no html and fancy icons)

    :param parse_cs: parse Changesets into VCS instances

    """

    action = user_log.action

    action_params = ' '

    x = action.split(':')

    if len(x) > 1:

        action, action_params = x

    def get_cs_links():

        revs_limit = 3  # display this amount always

        revs_top_limit = 50  # show upto this amount of changesets hidden

        revs_ids = action_params.split(',')

        deleted = user_log.repository is None

        if deleted:

            return ','.join(revs_ids)

        repo_name = user_log.repository.repo_name

        def lnk(rev, repo_name):

            lazy_cs = False

            title_ = None

            url_ = '#'

            if isinstance(rev, BaseChangeset) or isinstance(rev, AttributeDict):

                if rev.op and rev.ref_name:

                    if rev.op == 'delete_branch':

                        lbl = _('Deleted branch: %s') % rev.ref_name

                    elif rev.op == 'tag':

                        lbl = _('Created tag: %s') % rev.ref_name

                    else:

                        lbl = 'Unknown operation %s' % rev.op

                else:

                    lazy_cs = True

                    lbl = rev.short_id[:8]

                    url_ = url('changeset_home', repo_name=repo_name,

                               revision=rev.raw_id)

            else:

                # changeset cannot be found - it might have been stripped or removed

                lbl = rev[:12]

                title_ = _('Changeset %s not found') % lbl

            if parse_cs:

                return link_to(lbl, url_, title=title_, class_='tooltip')

            return link_to(lbl, url_, class_='lazy-cs' if lazy_cs else '',

                           **{'data-raw_id':rev.raw_id, 'data-repo_name':repo_name})

        def _get_op(rev_txt):

            _op = None

            _name = rev_txt

            if len(rev_txt.split('=>')) == 2:

                _op, _name = rev_txt.split('=>')

            return _op, _name

        revs = []

        if len(filter(lambda v: v != '', revs_ids)) > 0:

            repo = None

            for rev in revs_ids[:revs_top_limit]:

                _op, _name = _get_op(rev)

                # we want parsed changesets, or new log store format is bad

                if parse_cs:

                    try:

                        if repo is None:

                            repo = user_log.repository.scm_instance

                        _rev = repo.get_changeset(rev)

                        revs.append(_rev)

                    except ChangesetDoesNotExistError:

                        log.error('cannot find revision %s in this repo', rev)

                        revs.append(rev)

                else:

                    _rev = AttributeDict({

                        'short_id': rev[:12],

                        'raw_id': rev,

                        'message': '',

                        'op': _op,

                        'ref_name': _name

                    })

                    revs.append(_rev)

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

            [lnk(rev, repo_name) for rev in revs[:revs_limit]]

        )]

        _op1, _name1 = _get_op(revs_ids[0])

        _op2, _name2 = _get_op(revs_ids[-1])

        _rev = '%s...%s' % (_name1, _name2)

        compare_view = (

            ' <div class="compare_view" data-toggle="tooltip" title="%s">'

            '<a href="%s">%s</a> </div>' % (

                _('Show all combined changesets %s->%s') % (

                    revs_ids[0][:12], revs_ids[-1][:12]

                ),

                url('changeset_home', repo_name=repo_name,

                    revision=_rev

                ),

                _('Compare view')

            )

        )

        # if we have exactly one more than normally displayed

        # just display it, takes less space than displaying

        # "and 1 more revisions"

        if len(revs_ids) == revs_limit + 1:

            cs_links.append(", " + lnk(revs[revs_limit], repo_name))

        # hidden-by-default ones

        if len(revs_ids) > revs_limit + 1:

            uniq_id = revs_ids[0]

            html_tmpl = (

                '<span> %s <a class="show_more" id="_%s" '

                'href="#more">%s</a> %s</span>'

            )

            if not feed:

                cs_links.append(html_tmpl % (

                      _('and'),

                      uniq_id, _('%s more') % (len(revs_ids) - revs_limit),

                      _('revisions')

                    )

                )

            if not feed:

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

            else:

                html_tmpl = '<span id="%s"> %s </span>'

            morelinks = ', '.join(

              [lnk(rev, repo_name) for rev in revs[revs_limit:]]

            )

            if len(revs_ids) > revs_top_limit:

                morelinks += ', ...'

            cs_links.append(html_tmpl % (uniq_id, morelinks))

        if len(revs) > 1:

            cs_links.append(compare_view)

        return ''.join(cs_links)

    def get_fork_name():

        repo_name = action_params

        url_ = url('summary_home', repo_name=repo_name)

        return _('Fork name %s') % link_to(action_params, url_)

    def get_user_name():

        user_name = action_params

        return user_name

    def get_users_group():

        group_name = action_params

        return group_name

    def get_pull_request():

        from kallithea.model.db import PullRequest

        pull_request_id = action_params

        nice_id = PullRequest.make_nice_id(pull_request_id)

        deleted = user_log.repository is None

        if deleted:

            repo_name = user_log.repository_name

        else:

            repo_name = user_log.repository.repo_name

        return link_to(_('Pull request %s') % nice_id,

                    url('pullrequest_show', repo_name=repo_name,

                    pull_request_id=pull_request_id))

    def get_archive_name():

        archive_name = action_params

        return archive_name

    # action : translated str, callback(extractor), icon

    action_map = {

    'user_deleted_repo':           (_('[deleted] repository'),

                                    None, 'icon-trashcan'),

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

                                    None, 'icon-plus'),

    'user_created_fork':           (_('[created] repository as fork'),

                                    None, 'icon-fork'),

    'user_forked_repo':            (_('[forked] repository'),

                                    get_fork_name, 'icon-fork'),

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

                                    None, 'icon-pencil'),

    'user_downloaded_archive':      (_('[downloaded] archive from repository'),

                                    get_archive_name, 'icon-download-cloud'),

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

                                    None, 'icon-trashcan'),

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

                                    None, 'icon-plus'),

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

                                    None, 'icon-fork'),

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

                                    None, 'icon-pencil'),

    'admin_created_user':          (_('[created] user'),

                                    get_user_name, 'icon-user'),

    'admin_updated_user':          (_('[updated] user'),

                                    get_user_name, 'icon-user'),

    'admin_created_users_group':   (_('[created] user group'),

                                    get_users_group, 'icon-pencil'),

    'admin_updated_users_group':   (_('[updated] user group'),

                                    get_users_group, 'icon-pencil'),

    'user_commented_revision':     (_('[commented] on revision in repository'),

                                    get_cs_links, 'icon-comment'),

    'user_commented_pull_request': (_('[commented] on pull request for'),

                                    get_pull_request, 'icon-comment'),

    'user_closed_pull_request':    (_('[closed] pull request for'),

                                    get_pull_request, 'icon-ok'),

    'push':                        (_('[pushed] into'),

                                    get_cs_links, 'icon-move-up'),

    'push_local':                  (_('[committed via Kallithea] into repository'),

                                    get_cs_links, 'icon-pencil'),

    'push_remote':                 (_('[pulled from remote] into repository'),

                                    get_cs_links, 'icon-move-up'),

    'pull':                        (_('[pulled] from'),

                                    None, 'icon-move-down'),

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

                                    None, 'icon-heart'),

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

                                    None, 'icon-heart-empty'),

    }

    action_str = action_map.get(action, action)

    if feed:

        action = action_str[0].replace('[', '').replace(']', '')

    else:

        action = action_str[0] \

            .replace('[', '<b>') \

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

    action_params_func = lambda: ""

    if callable(action_str[1]):

        action_params_func = action_str[1]

    def action_parser_icon():

        action = user_log.action

        action_params = None

        x = action.split(':')

        if len(x) > 1:

            action, action_params = x

        ico = action_map.get(action, ['', '', ''])[2]

        html = """<i class="%s"></i>""" % ico

        return literal(html)

    # returned callbacks we need to call to get

    return [lambda: literal(action), action_params_func, action_parser_icon]

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

# PERMS

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

from kallithea.lib.auth import HasPermissionAny, \

    HasRepoPermissionAny, HasRepoGroupPermissionAny

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

# GRAVATAR URL

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

def gravatar_div(email_address, cls='', size=30, **div_attributes):

    """Return an html literal with a div around a gravatar if they are enabled.

    Extra keyword parameters starting with 'div_' will get the prefix removed

    and '_' changed to '-' and be used as attributes on the div. The default

    class is 'gravatar'.

    """

    from pylons import tmpl_context as c

    if not c.visual.use_gravatar:

        return ''

    if 'div_class' not in div_attributes:

        div_attributes['div_class'] = "gravatar"

    attributes = []

    for k, v in sorted(div_attributes.items()):

        assert k.startswith('div_'), k

        attributes.append(' %s="%s"' % (k[4:].replace('_', '-'), escape(v)))

    return literal("""<div%s>%s</div>""" %

                   (''.join(attributes),

                    gravatar(email_address, cls=cls, size=size)))

def gravatar(email_address, cls='', size=30):

    """return html element of the gravatar

    This method will return an <img> with the resolution double the size (for

    retina screens) of the image. If the url returned from gravatar_url is

    empty then we fallback to using an icon.

    """

    from pylons import tmpl_context as c

    if not c.visual.use_gravatar:

        return ''

    src = gravatar_url(email_address, size * 2)

    if src:

        # here it makes sense to use style="width: ..." (instead of, say, a

        # stylesheet) because we using this to generate a high-res (retina) size

        html = ('<img alt="" class="{cls}" style="width: {size}px; height: {size}px" src="{src}"/>'

            .format(cls=cls, size=size, src=src))

    else:

        # if src is empty then there was no gravatar, so we use a font icon

        html = ("""<i class="icon-user {cls}" style="font-size: {size}px;"></i>"""

            .format(cls=cls, size=size, src=src))

    return literal(html)

def gravatar_url(email_address, size=30, default=''):

    # doh, we need to re-import those to mock it later

    from kallithea.config.routing import url

    from kallithea.model.db import User

    from pylons import tmpl_context as c

    if not c.visual.use_gravatar:

        return ""

    _def = 'anonymous@kallithea-scm.org'  # default gravatar

    email_address = email_address or _def

    if email_address == _def:

        return default

    parsed_url = urlparse.urlparse(url.current(qualified=True))

    url = (c.visual.gravatar_url or User.DEFAULT_GRAVATAR_URL ) \

               .replace('{email}', email_address) \

               .replace('{md5email}', hashlib.md5(safe_str(email_address).lower()).hexdigest()) \

               .replace('{netloc}', parsed_url.netloc) \

               .replace('{scheme}', parsed_url.scheme) \

               .replace('{size}', safe_str(size))

    return url

def changed_tooltip(nodes):

    """

    Generates a html string for changed nodes in changeset page.

    It limits the output to 30 entries

    :param nodes: LazyNodesGenerator

    """

    if nodes:

        pref = ': <br/> '

        suf = ''

        if len(nodes) > 30:

            suf = '<br/>' + _(' and %s more') % (len(nodes) - 30)

        return literal(pref + '<br/> '.join([safe_unicode(x.path)

                                             for x in nodes[:30]]) + suf)

    else:

        return ': ' + _('No files')

def fancy_file_stats(stats):

    """

    Displays a fancy two colored bar for number of added/deleted

    lines of code on file

    :param stats: two element list of added/deleted lines of code

    """

    from kallithea.lib.diffs import NEW_FILENODE, DEL_FILENODE, \

        MOD_FILENODE, RENAMED_FILENODE, CHMOD_FILENODE, BIN_FILENODE

    a, d = stats['added'], stats['deleted']

    width = 100

    if stats['binary']:

        #binary mode

        lbl = ''

        bin_op = 1

        if BIN_FILENODE in stats['ops']:

            lbl = 'bin+'

        if NEW_FILENODE in stats['ops']:

            lbl += _('new file')

            bin_op = NEW_FILENODE

        elif MOD_FILENODE in stats['ops']:

            lbl += _('mod')

            bin_op = MOD_FILENODE

        elif DEL_FILENODE in stats['ops']:

            lbl += _('del')

            bin_op = DEL_FILENODE

        elif RENAMED_FILENODE in stats['ops']:

            lbl += _('rename')

            bin_op = RENAMED_FILENODE

        #chmod can go with other operations

        if CHMOD_FILENODE in stats['ops']:

            _org_lbl = _('chmod')

            lbl += _org_lbl if lbl.endswith('+') else '+%s' % _org_lbl

        #import ipdb;ipdb.set_trace()

        b_a = '<div class="bin bin1" style="width:0%"></div>'

    t = stats['added'] + stats['deleted']

    unit = float(width) / (t or 1)

    # needs > 9% of width to be visible or 0 to be hidden

    a_p = max(9, unit * a) if a > 0 else 0

    d_p = max(9, unit * d) if d > 0 else 0

    p_sum = a_p + d_p

    if p_sum > width:

        #adjust the percentage to be == 100% since we adjusted to 9

        if a_p > d_p:

            a_p = a_p - (p_sum - width)

        else:

            d_p = d_p - (p_sum - width)

    a_v = a if a > 0 else ''

    d_v = d if d > 0 else ''

    )

    )

_URLIFY_RE = re.compile(r'''

# URL markup

(?P<url>%s) |

# @mention markup

(?P<mention>%s) |

# Changeset hash markup

(?<!\w|[-_])

  (?P<hash>[0-9a-f]{12,40})

(?!\w|[-_]) |

# Markup of *bold text*

(?:

  (?:^|(?<=\s))

  (?P<bold> [*] (?!\s) [^*\n]* (?<!\s) [*] )

  (?![*\w])

) |

# "Stylize" markup

\[see\ \=&gt;\ *(?P<seen>[a-zA-Z0-9\/\=\?\&\ \:\/\.\-]*)\] |

\[license\ \=&gt;\ *(?P<license>[a-zA-Z0-9\/\=\?\&\ \:\/\.\-]*)\] |

\[(?P<tagtype>requires|recommends|conflicts|base)\ \=&gt;\ *(?P<tagvalue>[a-zA-Z0-9\-\/]*)\] |

\[(?:lang|language)\ \=&gt;\ *(?P<lang>[a-zA-Z\-\/\#\+]*)\] |

\[(?P<tag>[a-z]+)\]

''' % (url_re.pattern, MENTIONS_REGEX.pattern),

    re.VERBOSE | re.MULTILINE | re.IGNORECASE)

def urlify_text(s, repo_name=None, link_=None, truncate=None, stylize=False, truncatef=truncate):

    """

    Parses given text message and make literal html with markup.

    The text will be truncated to the specified length.

    Hashes are turned into changeset links to specified repository.

    URLs links to what they say.

    Issues are linked to given issue-server.

    If link_ is provided, all text not already linking somewhere will link there.

    """

    def _replace(match_obj):

        url = match_obj.group('url')

        if url is not None:

            return '<a href="%(url)s">%(url)s</a>' % {'url': url}

        mention = match_obj.group('mention')

        if mention is not None:

            return '<b>%s</b>' % mention

        hash_ = match_obj.group('hash')

        if hash_ is not None and repo_name is not None:

            from kallithea.config.routing import url  # doh, we need to re-import url to mock it later

            return '<a class="revision-link" href="%(url)s">%(hash)s</a>' % {

                 'url': url('changeset_home', repo_name=repo_name, revision=hash_),

                 'hash': hash_,

                }

        bold = match_obj.group('bold')

        if bold is not None:

            return '<b>*%s*</b>' % _urlify(bold[1:-1])

        if stylize:

            seen = match_obj.group('seen')

            if seen:

                return '<div class="metatag" data-tag="see">see =&gt; %s</div>' % seen

            license = match_obj.group('license')

            if license:

                return '<div class="metatag" data-tag="license"><a href="http:\/\/www.opensource.org/licenses/%s">%s</a></div>' % (license, license)

            tagtype = match_obj.group('tagtype')

            if tagtype:

                tagvalue = match_obj.group('tagvalue')

                return '<div class="metatag" data-tag="%s">%s =&gt; <a href="/%s">%s</a></div>' % (tagtype, tagtype, tagvalue, tagvalue)

            lang = match_obj.group('lang')

            if lang:

                return '<div class="metatag" data-tag="lang">%s</div>' % lang

            tag = match_obj.group('tag')

            if tag:

                return '<div class="metatag" data-tag="%s">%s</div>' % (tag, tag)

        return match_obj.group(0)

    def _urlify(s):

        """

        Extract urls from text and make html links out of them

        """

        return _URLIFY_RE.sub(_replace, s)

    if truncate is None:

        s = s.rstrip()

    else:

        s = truncatef(s, truncate, whole_word=True)

    s = html_escape(s)

    s = _urlify(s)

    if repo_name is not None:

        s = urlify_issues(s, repo_name)

    if link_ is not None:

        # make href around everything that isn't a href already

        s = linkify_others(s, link_)

    s = s.replace('\r\n', '<br/>').replace('\n', '<br/>')

    return literal(s)

def linkify_others(t, l):

    """Add a default link to html with links.

    HTML doesn't allow nesting of links, so the outer link must be broken up

    in pieces and give space for other links.

    """

    urls = re.compile(r'(\<a.*?\<\/a\>)',)

    links = []

    for e in urls.split(t):

        if e.strip() and not urls.match(e):

            links.append('<a class="message-link" href="%s">%s</a>' % (l, e))

        else:

            links.append(e)

    return ''.join(links)

# Global variable that will hold the actual urlify_issues function body.

# Will be set on first use when the global configuration has been read.

_urlify_issues_f = None

def urlify_issues(newtext, repo_name):

    """Urlify issue references according to .ini configuration"""

    global _urlify_issues_f

    if _urlify_issues_f is None:

        from kallithea import CONFIG

        from kallithea.model.db import URL_SEP

        assert CONFIG['sqlalchemy.url'] # make sure config has been loaded

        # Build chain of urlify functions, starting with not doing any transformation

        tmp_urlify_issues_f = lambda s: s

        issue_pat_re = re.compile(r'issue_pat(.*)')

        for k in CONFIG.keys():

            # Find all issue_pat* settings that also have corresponding server_link and prefix configuration

            m = issue_pat_re.match(k)

            if m is None:

                continue

            suffix = m.group(1)

            issue_pat = CONFIG.get(k)

            issue_server_link = CONFIG.get('issue_server_link%s' % suffix)

            issue_prefix = CONFIG.get('issue_prefix%s' % suffix)

            if issue_pat and issue_server_link and issue_prefix:

                log.debug('issue pattern %r: %r -> %r %r', suffix, issue_pat, issue_server_link, issue_prefix)

            else:

                log.error('skipping incomplete issue pattern %r: %r -> %r %r', suffix, issue_pat, issue_server_link, issue_prefix)

                continue

            # Wrap tmp_urlify_issues_f with substitution of this pattern, while making sure all loop variables (and compiled regexpes) are bound

            issue_re = re.compile(issue_pat)

            def issues_replace(match_obj,

                               issue_server_link=issue_server_link, issue_prefix=issue_prefix):

                leadingspace = ' ' if match_obj.group().startswith(' ') else ''

                issue_id = ''.join(match_obj.groups())

                issue_url = issue_server_link.replace('{id}', issue_id)

                issue_url = issue_url.replace('{repo}', repo_name)

                issue_url = issue_url.replace('{repo_name}', repo_name.split(URL_SEP)[-1])

                return (

                    '%(leadingspace)s<a class="issue-tracker-link" href="%(url)s">'

                    '%(issue-prefix)s%(id-repr)s'

                    '</a>'

                    ) % {

                     'leadingspace': leadingspace,

                     'url': issue_url,

                     'id-repr': issue_id,

                     'issue-prefix': issue_prefix,

                     'serv': issue_server_link,

                    }

            tmp_urlify_issues_f = (lambda s,

                                          issue_re=issue_re, issues_replace=issues_replace, chain_f=tmp_urlify_issues_f:

                                   issue_re.sub(issues_replace, chain_f(s)))

        # Set tmp function globally - atomically

        _urlify_issues_f = tmp_urlify_issues_f

    return _urlify_issues_f(newtext)

def render_w_mentions(source, repo_name=None):

    """

    Render plain text with revision hashes and issue references urlified

    and with @mention highlighting.

    """

    s = safe_unicode(source)

    s = urlify_text(s, repo_name=repo_name)

    return literal('<div class="formatted-fixed">%s</div>' % s)

def short_ref(ref_type, ref_name):

    if ref_type == 'rev':

        return short_id(ref_name)

    return ref_name

def link_to_ref(repo_name, ref_type, ref_name, rev=None):

    """

    Return full markup for a href to changeset_home for a changeset.

    If ref_type is branch it will link to changelog.

    ref_name is shortened if ref_type is 'rev'.

    if rev is specified show it too, explicitly linking to that revision.

    """

    txt = short_ref(ref_type, ref_name)

    if ref_type == 'branch':

        u = url('changelog_home', repo_name=repo_name, branch=ref_name)

    else:

        u = url('changeset_home', repo_name=repo_name, revision=ref_name)

    l = link_to(repo_name + '#' + txt, u)

    if rev and ref_type != 'rev':

        l = literal('%s (%s)' % (l, link_to(short_id(rev), url('changeset_home', repo_name=repo_name, revision=rev))))

    return l

def changeset_status(repo, revision):

    from kallithea.model.changeset_status import ChangesetStatusModel

    return ChangesetStatusModel().get_status(repo, revision)

def changeset_status_lbl(changeset_status):

    from kallithea.model.db import ChangesetStatus

    return ChangesetStatus.get_status_lbl(changeset_status)

def get_permission_name(key):

    from kallithea.model.db import Permission

    return dict(Permission.PERMS).get(key)

def journal_filter_help():

    return _(textwrap.dedent('''

        Example filter terms:

            repository:vcs

            username:developer

            action:*push*

            ip:127.0.0.1

            date:20120101

            date:[20120101100000 TO 20120102]

        Generate wildcards using '*' character:

            "repository:vcs*" - search everything starting with 'vcs'

            "repository:*vcs*" - search for repository containing 'vcs'

        Optional AND / OR operators in queries

            "repository:vcs OR repository:test"

            "username:test AND repository:test*"

    '''))

def not_mapped_error(repo_name):

    flash(_('%s repository is not mapped to db perhaps'

            ' it was created or renamed from the filesystem'

            ' please run the application again'

            ' in order to rescan repositories') % repo_name, category='error')

def ip_range(ip_addr):

    from kallithea.model.db import UserIpMap

    s, e = UserIpMap._get_ip_range(ip_addr)

    return '%s - %s' % (s, e)

def form(url, method="post", **attrs):

    """Like webhelpers.html.tags.form but automatically using secure_form with

    authentication_token for POST. authentication_token is thus never leaked

    in the URL."""

    if method.lower() == 'get':

        return insecure_form(url, method=method, **attrs)

    # webhelpers will turn everything but GET into POST

    return secure_form(url, method=method, **attrs)

    color: #FFF;

    font-weight: 700;

}

#footer .navbar-link {

    color: #FFF;

}

#login div.panel-heading {

    clear: both;

    overflow: hidden;

    position: relative;

    background-color: #577632;

    background-repeat: repeat-x;

    background-image: linear-gradient(to bottom, #577632, #577632);

    margin: 0 auto;

    padding: 0;

}

#login div.inner .icon-lock {

    font-size: 80pt;

    color: #DDD;

}

#login div.inner {

    background: #FFF;

    border-top: none;

    border-bottom: none;

    margin: 0 auto;

    padding: 20px;

}

#login div.form div.form-horizontal div.form-group > label {

    width: 173px;

    float: left;

    text-align: right;

    margin: 2px 10px 0 0;

    padding: 5px 0 0 5px;

}

#login div.form div.form-horizontal div.form-group div input {

    background: #FFF;

    border-top: 1px solid #b3b3b3;

    border-left: 1px solid #b3b3b3;

    border-right: 1px solid #eaeaea;

    border-bottom: 1px solid #eaeaea;

    color: #000;

    font-size: 11px;

    margin: 0;

    padding: 7px 7px 6px;

}

#login div.form .buttons {

    float: right;

}

#login div.form div.links {

    clear: both;

    overflow: hidden;

    margin: 10px 0 0;

    border-top: 1px solid #DDD;

    padding: 10px 0 0;

}

.user-menu {

    margin: 0px !important;

    float: left;

}

.user-menu .container {

    padding: 0px 4px 0px 4px;

    margin: 0px 0px 0px 0px;

}

.user-menu .gravatar {

    margin: 0px 0px 0px 0px;

    cursor: pointer;

}

.user-menu .gravatar.enabled {

    background-color: #FDF784 !important;

}

.user-menu .gravatar:hover {

    background-color: #FDF784 !important;

}

#quick_login {

    min-height: 110px;

    padding: 4px;

    position: absolute;

    right: 0;

    background-color: #577632;

    background-repeat: repeat-x;

    background-image: linear-gradient(to bottom, #577632, #577632);

    z-index: 999;

    border-radius: 0px 0px 4px 4px;

    box-shadow: 0 2px 2px rgba(0, 0, 0, 0.6);

    overflow: hidden;

}

#quick_login h4 {

    color: #fff;

    padding: 5px 0px 5px 14px;

}

#quick_login .password_forgoten {

    padding-right: 0px;

    padding-top: 0px;

    text-align: left;

}

#quick_login .password_forgoten a {

    font-size: 10px;

    color: #fff;

    padding: 0px !important;

    line-height: 20px !important;

}

#quick_login .register {

    padding-right: 10px;

    padding-top: 5px;

    text-align: left;

}

#quick_login .register a {

    font-size: 10px;

    color: #fff;

    padding: 0px !important;

    line-height: 20px !important;

}

#quick_login .submit {

    margin: -20px 0 0 0px;

    position: absolute;

    right: 15px;

}

#quick_login .links_left {

    float: left;

    margin-right: 130px;

    width: 170px;