action="new", conditions=dict(method=["GET"]))

        m.connect("formatted_new_notification", "/notifications/new.{format}",

                  action="new", conditions=dict(method=["GET"]))

        m.connect("/notification/{notification_id}",

                  action="update", conditions=dict(method=["PUT"]))

        m.connect("/notification/{notification_id}",

                  action="delete", conditions=dict(method=["DELETE"]))

        m.connect("edit_notification", "/notification/{notification_id}/edit",

                  action="edit", conditions=dict(method=["GET"]))

        m.connect("formatted_edit_notification",

                  "/notification/{notification_id}.{format}/edit",

                  action="edit", conditions=dict(method=["GET"]))

        m.connect("notification", "/notification/{notification_id}",

                  action="show", conditions=dict(method=["GET"]))

        m.connect("formatted_notification", "/notifications/{notification_id}.{format}",

                  action="show", conditions=dict(method=["GET"]))

    #ADMIN MAIN PAGES

    with rmap.submapper(path_prefix=ADMIN_PREFIX,

                        controller='admin/admin') as m:

        m.connect('admin_home', '', action='index')

        m.connect('admin_add_repo', '/add_repo/{new_repo:[a-z0-9\. _-]*}',

                  action='add_repo')

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

    # API V2

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

    with rmap.submapper(path_prefix=ADMIN_PREFIX,

                        controller='api/api') as m:

        m.connect('api', '/api')

    #USER JOURNAL

    rmap.connect('journal', '%s/journal' % ADMIN_PREFIX,

                 controller='journal', action='index')

    rmap.connect('journal_rss', '%s/journal/rss' % ADMIN_PREFIX,

                 controller='journal', action='journal_rss')

    rmap.connect('journal_atom', '%s/journal/atom' % ADMIN_PREFIX,

                 controller='journal', action='journal_atom')

    rmap.connect('public_journal', '%s/public_journal' % ADMIN_PREFIX,

                 controller='journal', action="public_journal")

    rmap.connect('public_journal_rss', '%s/public_journal/rss' % ADMIN_PREFIX,

                 controller='journal', action="public_journal_rss")

    rmap.connect('public_journal_rss_old', '%s/public_journal_rss' % ADMIN_PREFIX,

                 controller='journal', action="public_journal_rss")

    rmap.connect('public_journal_atom',

                 '%s/public_journal/atom' % ADMIN_PREFIX, controller='journal',

                 action="public_journal_atom")

    rmap.connect('public_journal_atom_old',

                 '%s/public_journal_atom' % ADMIN_PREFIX, controller='journal',

                 action="public_journal_atom")

    rmap.connect('toggle_following', '%s/toggle_following' % ADMIN_PREFIX,

                 controller='journal', action='toggle_following',

                 conditions=dict(method=["POST"]))

    #SEARCH

    rmap.connect('search', '%s/search' % ADMIN_PREFIX, controller='search',)

    rmap.connect('search_repo', '%s/search/{search_repo:.*}' % ADMIN_PREFIX,

                  controller='search')

    #LOGIN/LOGOUT/REGISTER/SIGN IN

    rmap.connect('login_home', '%s/login' % ADMIN_PREFIX, controller='login')

    rmap.connect('logout_home', '%s/logout' % ADMIN_PREFIX, controller='login',

                 action='logout')

    rmap.connect('register', '%s/register' % ADMIN_PREFIX, controller='login',

                 action='register')

    rmap.connect('reset_password', '%s/password_reset' % ADMIN_PREFIX,

                 controller='login', action='password_reset')

    rmap.connect('reset_password_confirmation',

                 '%s/password_reset_confirmation' % ADMIN_PREFIX,

                 controller='login', action='password_reset_confirmation')

    #FEEDS

    rmap.connect('rss_feed_home', '/{repo_name:.*?}/feed/rss',

                controller='feed', action='rss',

                conditions=dict(function=check_repo))

    rmap.connect('atom_feed_home', '/{repo_name:.*?}/feed/atom',

                controller='feed', action='atom',

                conditions=dict(function=check_repo))

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

    # REPOSITORY ROUTES

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

    rmap.connect('summary_home', '/{repo_name:.*?}',

                controller='summary',

                conditions=dict(function=check_repo))

    rmap.connect('repos_group_home', '/{group_name:.*}',

                controller='admin/repos_groups', action="show_by_name",

                conditions=dict(function=check_group))

    rmap.connect('changeset_home', '/{repo_name:.*?}/changeset/{revision}',

                controller='changeset', revision='tip',

                conditions=dict(function=check_repo))

    #still working url for backward compat.

    rmap.connect('raw_changeset_home_depraced',

                 '/{repo_name:.*?}/raw-changeset/{revision}',

                 controller='changeset', action='changeset_raw',

                 revision='tip', conditions=dict(function=check_repo))

    ## new URLs

    rmap.connect('changeset_raw_home',

                 '/{repo_name:.*?}/changeset-diff/{revision}',

                 controller='changeset', action='changeset_raw',

                 revision='tip', conditions=dict(function=check_repo))

    rmap.connect('changeset_patch_home',

                 '/{repo_name:.*?}/changeset-patch/{revision}',

                 controller='changeset', action='changeset_patch',

                 revision='tip', conditions=dict(function=check_repo))

    rmap.connect('changeset_download_home',

                 '/{repo_name:.*?}/changeset-download/{revision}',

                 controller='changeset', action='changeset_download',

                 revision='tip', conditions=dict(function=check_repo))

    rmap.connect('changeset_comment',

                 '/{repo_name:.*?}/changeset/{revision}/comment',

                controller='changeset', revision='tip', action='comment',

                conditions=dict(function=check_repo))

    rmap.connect('changeset_comment_delete',

                 '/{repo_name:.*?}/changeset/comment/{comment_id}/delete',

                controller='changeset', action='delete_comment',

                conditions=dict(function=check_repo, method=["DELETE"]))

    rmap.connect('changeset_info', '/changeset_info/{repo_name:.*?}/{revision}',

                 controller='changeset', action='changeset_info')

    rmap.connect('compare_url',

                 '/{repo_name:.*?}/compare/{org_ref_type}@{org_ref:.*?}...{other_ref_type}@{other_ref:.*?}',

                 controller='compare', action='index',

                 conditions=dict(function=check_repo),

                 requirements=dict(

                            org_ref_type='(branch|book|tag|rev|org_ref_type)',

                            other_ref_type='(branch|book|tag|rev|other_ref_type)')

                 )

    rmap.connect('pullrequest_home',

                 '/{repo_name:.*?}/pull-request/new', controller='pullrequests',

                 action='index', conditions=dict(function=check_repo,

                                                 method=["GET"]))

    rmap.connect('pullrequest',

                 '/{repo_name:.*?}/pull-request/new', controller='pullrequests',

                 action='create', conditions=dict(function=check_repo,

                                                  method=["POST"]))

    rmap.connect('pullrequest_show',

                 '/{repo_name:.*?}/pull-request/{pull_request_id}',

                 controller='pullrequests',

                 action='show', conditions=dict(function=check_repo,

                                                method=["GET"]))

    rmap.connect('pullrequest_update',

                 '/{repo_name:.*?}/pull-request/{pull_request_id}',

                 controller='pullrequests',

                 action='update', conditions=dict(function=check_repo,

                                                method=["PUT"]))

    rmap.connect('pullrequest_delete',

                 '/{repo_name:.*?}/pull-request/{pull_request_id}',

                 controller='pullrequests',

                 action='delete', conditions=dict(function=check_repo,

                                                method=["DELETE"]))

    rmap.connect('pullrequest_show_all',

                 '/{repo_name:.*?}/pull-request',

                 controller='pullrequests',

                 action='show_all', conditions=dict(function=check_repo,

                                                method=["GET"]))

    rmap.connect('pullrequest_comment',

                 '/{repo_name:.*?}/pull-request-comment/{pull_request_id}',

                 controller='pullrequests',

                 action='comment', conditions=dict(function=check_repo,

                                                method=["POST"]))

    rmap.connect('pullrequest_comment_delete',

                 '/{repo_name:.*?}/pull-request-comment/{comment_id}/delete',

                controller='pullrequests', action='delete_comment',

                conditions=dict(function=check_repo, method=["DELETE"]))

    rmap.connect('summary_home', '/{repo_name:.*?}/summary',

# -*- coding: utf-8 -*-

"""

    rhodecode.controllers.summary

    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    Summary controller for Rhodecode

    :created_on: Apr 18, 2010

    :author: marcink

    :copyright: (C) 2010-2012 Marcin Kuzminski <marcin@python-works.com>

    :license: GPLv3, see COPYING for more details.

"""

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import traceback

import calendar

import logging

import urllib

from time import mktime

from datetime import timedelta, date

from urlparse import urlparse

from pylons import tmpl_context as c, request, url, config

from pylons.i18n.translation import _

from beaker.cache import cache_region, region_invalidate

from rhodecode.config.conf import ALL_READMES, ALL_EXTS, LANGUAGES_EXTENSIONS_MAP

from rhodecode.model.db import Statistics, CacheInvalidation

from rhodecode.lib.utils2 import safe_unicode

from rhodecode.lib.base import BaseRepoController, render

from rhodecode.lib.vcs.backends.base import EmptyChangeset

from rhodecode.lib.markup_renderer import MarkupRenderer

from rhodecode.lib.celerylib import run_task

from rhodecode.lib.celerylib.tasks import get_commits_stats

from rhodecode.lib.helpers import RepoPage

from rhodecode.lib.compat import json, OrderedDict

from rhodecode.lib.vcs.nodes import FileNode

log = logging.getLogger(__name__)

README_FILES = [''.join([x[0][0], x[1][0]]) for x in

                    sorted(list(product(ALL_READMES, ALL_EXTS)),

                           key=lambda y:y[0][1] + y[1][1])]

class SummaryController(BaseRepoController):

    @LoginRequired()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def __before__(self):

        super(SummaryController, self).__before__()

    def index(self, repo_name):

        c.dbrepo = dbrepo = c.rhodecode_db_repo

        c.following = self.scm_model.is_following_repo(repo_name,

                                                self.rhodecode_user.user_id)

        def url_generator(**kw):

            return url('shortlog_home', repo_name=repo_name, size=10, **kw)

        c.repo_changesets = RepoPage(c.rhodecode_repo, page=1,

                                     items_per_page=10, url=url_generator)

        page_revisions = [x.raw_id for x in list(c.repo_changesets)]

        c.statuses = c.rhodecode_db_repo.statuses(page_revisions)

        if self.rhodecode_user.username == 'default':

            # for default(anonymous) user we don't need to pass credentials

            username = ''

            password = ''

        else:

            username = str(self.rhodecode_user.username)

            password = '@'

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

        default_clone_uri = '{scheme}://{user}{pass}{netloc}{path}'

        uri_tmpl = config.get('clone_uri', default_clone_uri)

        uri_tmpl = uri_tmpl.replace('{', '%(').replace('}', ')s')

        decoded_path = safe_unicode(urllib.unquote(parsed_url.path))

        uri_dict = {

           'user': urllib.quote(username),

           'pass': password,

           'scheme': parsed_url.scheme,

           'netloc': parsed_url.netloc,

           'path': decoded_path

        }

        uri = uri_tmpl % uri_dict

        # generate another clone url by id

        uri_dict.update(

         {'path': decoded_path.replace(repo_name, '_%s' % c.dbrepo.repo_id)}

        )

        uri_id = uri_tmpl % uri_dict

        c.clone_repo_url = uri

        c.clone_repo_url_id = uri_id

        c.repo_tags = OrderedDict()

        for name, hash_ in c.rhodecode_repo.tags.items()[:10]:

            try:

                c.repo_tags[name] = c.rhodecode_repo.get_changeset(hash_)

            except ChangesetError:

                c.repo_tags[name] = EmptyChangeset(hash_)

        c.repo_branches = OrderedDict()

        for name, hash_ in c.rhodecode_repo.branches.items()[:10]:

            try:

                c.repo_branches[name] = c.rhodecode_repo.get_changeset(hash_)

            except ChangesetError:

                c.repo_branches[name] = EmptyChangeset(hash_)

        td = date.today() + timedelta(days=1)

        td_1m = td - timedelta(days=calendar.mdays[td.month])

        td_1y = td - timedelta(days=365)

        ts_min_m = mktime(td_1m.timetuple())

        ts_min_y = mktime(td_1y.timetuple())

        ts_max_y = mktime(td.timetuple())

        if dbrepo.enable_statistics:

            c.show_stats = True

            c.no_data_msg = _('No data loaded yet')

            run_task(get_commits_stats, c.dbrepo.repo_name, ts_min_y, ts_max_y)

        else:

            c.show_stats = False

            c.no_data_msg = _('Statistics are disabled for this repository')

        c.ts_min = ts_min_m

        c.ts_max = ts_max_y

        stats = self.sa.query(Statistics)\

            .filter(Statistics.repository == dbrepo)\

            .scalar()

        c.stats_percentage = 0

        if stats and stats.languages:

            c.no_data = False is dbrepo.enable_statistics

            lang_stats_d = json.loads(stats.languages)

            c.commit_data = stats.commit_activity

            c.overview_data = stats.commit_activity_combined

            lang_stats = ((x, {"count": y,

                               "desc": LANGUAGES_EXTENSIONS_MAP.get(x)})

                          for x, y in lang_stats_d.items())

            c.trending_languages = json.dumps(

                sorted(lang_stats, reverse=True, key=lambda k: k[1])[:10]

            )

            last_rev = stats.stat_on_revision + 1

            c.repo_last_rev = c.rhodecode_repo.count()\

                if c.rhodecode_repo.revisions else 0

            if last_rev == 0 or c.repo_last_rev == 0:

                pass

            else:

                c.stats_percentage = '%.2f' % ((float((last_rev)) /

                                                c.repo_last_rev) * 100)

        else:

            c.commit_data = json.dumps({})

            c.overview_data = json.dumps([[ts_min_y, 0], [ts_max_y, 10]])

            c.trending_languages = json.dumps({})

            c.no_data = True

        c.enable_downloads = dbrepo.enable_downloads

        if c.enable_downloads:

            c.download_options = self._get_download_links(c.rhodecode_repo)

        c.readme_data, c.readme_file = \

            self.__get_readme_data(c.rhodecode_db_repo)

        return render('summary/summary.html')

    def __get_readme_data(self, db_repo):

        repo_name = db_repo.repo_name

        @cache_region('long_term')

        def _get_readme_from_cache(key):

            readme_data = None

            readme_file = None

            log.debug('Looking for README file')

            try:

                # get's the landing revision! or tip if fails

                cs = db_repo.get_landing_changeset()

                if isinstance(cs, EmptyChangeset):

                    raise EmptyRepositoryError()

                renderer = MarkupRenderer()

                for f in README_FILES:

                    try:

                        readme = cs.get_node(f)

                        if not isinstance(readme, FileNode):

                            continue

                        readme_file = f

                        log.debug('Found README file `%s` rendering...' %

                                  readme_file)

                        readme_data = renderer.render(readme.content, f)

                        break

                    except NodeDoesNotExistError:

                        continue

            except ChangesetError:

                log.error(traceback.format_exc())

                pass

            except EmptyRepositoryError:

                pass

            except Exception:

                log.error(traceback.format_exc())

            return readme_data, readme_file

        key = repo_name + '_README'

        inv = CacheInvalidation.invalidate(key)

        if inv is not None:

            region_invalidate(_get_readme_from_cache, None, key)

            CacheInvalidation.set_valid(inv.cache_key)

        return _get_readme_from_cache(key)

    def _get_download_links(self, repo):

        download_l = []

        branches_group = ([], _("Branches"))

        tags_group = ([], _("Tags"))

        for name, chs in c.rhodecode_repo.branches.items():

            #chs = chs.split(':')[-1]

            branches_group[0].append((chs, name),)

        download_l.append(branches_group)

        for name, chs in c.rhodecode_repo.tags.items():

            #chs = chs.split(':')[-1]

            tags_group[0].append((chs, name),)

        download_l.append(tags_group)

        return download_l

        """

        cs = self.get_changeset(self.landing_rev) or self.get_changeset()

        return cs

    def update_changeset_cache(self, cs_cache=None):

        """

        Update cache of last changeset for repository, keys should be::

            short_id

            raw_id

            revision

            message

            date

            author

        :param cs_cache:

        """

        from rhodecode.lib.vcs.backends.base import BaseChangeset

        if cs_cache is None:

            cs_cache = self.get_changeset()

        if isinstance(cs_cache, BaseChangeset):

            cs_cache = cs_cache.__json__()

        if (cs_cache != self.changeset_cache

            or not self.last_change

            or not self.changeset_cache):

            _default = datetime.datetime.fromtimestamp(0)

            last_change = cs_cache.get('date') or self.last_change or _default

            log.debug('updated repo %s with new cs cache %s' % (self, cs_cache))

            self.updated_on = last_change

            self.changeset_cache = cs_cache

            Session().add(self)

            Session().commit()

        else:

            log.debug('Skipping repo:%s already with latest changes' % self)

    @property

    def tip(self):

        return self.get_changeset('tip')

    @property

    def author(self):

        return self.tip.author

    @property

    def last_change(self):

        return self.scm_instance.last_change

    def get_comments(self, revisions=None):

        """

        Returns comments for this repository grouped by revisions

        :param revisions: filter query by revisions only

        """

        cmts = ChangesetComment.query()\

            .filter(ChangesetComment.repo == self)

        if revisions:

            cmts = cmts.filter(ChangesetComment.revision.in_(revisions))

        grouped = defaultdict(list)

        for cmt in cmts.all():

            grouped[cmt.revision].append(cmt)

        return grouped

    def statuses(self, revisions=None):

        """

        Returns statuses for this repository

        :param revisions: list of revisions to get statuses for

        :type revisions: list

        """

        statuses = ChangesetStatus.query()\

            .filter(ChangesetStatus.repo == self)\

            .filter(ChangesetStatus.version == 0)

        if revisions:

            statuses = statuses.filter(ChangesetStatus.revision.in_(revisions))

        grouped = {}

        #maybe we have open new pullrequest without a status ?

        stat = ChangesetStatus.STATUS_UNDER_REVIEW

        status_lbl = ChangesetStatus.get_status_lbl(stat)

        for pr in PullRequest.query().filter(PullRequest.org_repo == self).all():

            for rev in pr.revisions:

                pr_id = pr.pull_request_id

                pr_repo = pr.other_repo.repo_name

                grouped[rev] = [stat, status_lbl, pr_id, pr_repo]

        for stat in statuses.all():

            pr_id = pr_repo = None

            if stat.pull_request:

                pr_id = stat.pull_request.pull_request_id

                pr_repo = stat.pull_request.other_repo.repo_name

            grouped[stat.revision] = [str(stat.status), stat.status_lbl,

                                      pr_id, pr_repo]

        return grouped

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

    # SCM CACHE INSTANCE

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

    @property

    def invalidate(self):

        return CacheInvalidation.invalidate(self.repo_name)

    def set_invalidate(self):

        """

        set a cache for invalidation for this instance

        """

        CacheInvalidation.set_invalidate(repo_name=self.repo_name)

    @LazyProperty

    def scm_instance(self):

        import rhodecode

        full_cache = str2bool(rhodecode.CONFIG.get('vcs_full_cache'))

        if full_cache:

            return self.scm_instance_cached()

        return self.__get_instance()

    def scm_instance_cached(self, cache_map=None):

        @cache_region('long_term')

        def _c(repo_name):

            return self.__get_instance()

        rn = self.repo_name

        log.debug('Getting cached instance of repo')

        if cache_map:

            # get using prefilled cache_map

            invalidate_repo = cache_map[self.repo_name]

            if invalidate_repo:

                invalidate_repo = (None if invalidate_repo.cache_active

                                   else invalidate_repo)

        else:

            # get from invalidate

            invalidate_repo = self.invalidate

        if invalidate_repo is not None:

            region_invalidate(_c, None, rn)

            # update our cache

            CacheInvalidation.set_valid(invalidate_repo.cache_key)

        return _c(rn)

    def __get_instance(self):

        repo_full_path = self.repo_full_path

        try:

            alias = get_scm(repo_full_path)[0]

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

            backend = get_backend(alias)

        except VCSError:

            log.error(traceback.format_exc())

            log.error('Perhaps this repository is in db and not in '

                      'filesystem run rescan repositories with '

                      '"destroy old data " option from admin panel')

            return

        if alias == 'hg':

            repo = backend(safe_str(repo_full_path), create=False,

                           baseui=self._ui)

            # skip hidden web repository

            if repo._get_hidden():

                return

        else:

            repo = backend(repo_full_path, create=False)

        return repo

class RepoGroup(Base, BaseModel):

    __tablename__ = 'groups'

    __table_args__ = (

        UniqueConstraint('group_name', 'group_parent_id'),

        CheckConstraint('group_id != group_parent_id'),

        {'extend_existing': True, 'mysql_engine': 'InnoDB',

         'mysql_charset': 'utf8'},

    )

    __mapper_args__ = {'order_by': 'group_name'}

    group_id = Column("group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

    group_name = Column("group_name", String(255, convert_unicode=False, assert_unicode=None), nullable=False, unique=True, default=None)

    group_parent_id = Column("group_parent_id", Integer(), ForeignKey('groups.group_id'), nullable=True, unique=None, default=None)

    group_description = Column("group_description", String(10000, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    enable_locking = Column("enable_locking", Boolean(), nullable=False, unique=None, default=False)

    repo_group_to_perm = relationship('UserRepoGroupToPerm', cascade='all', order_by='UserRepoGroupToPerm.group_to_perm_id')

    users_group_to_perm = relationship('UsersGroupRepoGroupToPerm', cascade='all')

    parent_group = relationship('RepoGroup', remote_side=group_id)

    def __init__(self, group_name='', parent_group=None):

        self.group_name = group_name

        self.parent_group = parent_group

}

.ac .yui-ac {

	position: inherit;

	font-size: 100%;

}

.ac .perm_ac {

	width: 20em;

}

.ac .yui-ac-input {

	width: 100%;

}

.ac .yui-ac-container {

	position: absolute;

	top: 1.6em;

	width: auto;

}

.ac .yui-ac-content {

	position: absolute;

	border: 1px solid gray;

	background: #fff;

	z-index: 9050;

}

.ac .yui-ac-shadow {

	position: absolute;

	width: 100%;

	background: #000;

	-moz-opacity: 0.1px;

	opacity: .10;

	filter: alpha(opacity = 10);

	z-index: 9049;

	margin: .3em;

}

.ac .yui-ac-content ul {

	width: 100%;

	margin: 0;

	padding: 0;

	z-index: 9050;

}

.ac .yui-ac-content li {

	cursor: default;

	white-space: nowrap;

	margin: 0;

	padding: 2px 5px;

	height: 18px;

	z-index: 9050;

	display: block;

	width: auto !important;

}

.ac .yui-ac-content li .ac-container-wrap{

    width: auto;

}

.ac .yui-ac-content li.yui-ac-prehighlight {

	background: #B3D4FF;

	z-index: 9050;

}

.ac .yui-ac-content li.yui-ac-highlight {

	background: #556CB5;

	color: #FFF;

	z-index: 9050;

}

.ac .yui-ac-bd{

	z-index: 9050;

}

.follow {

	background: url("../images/icons/heart_add.png") no-repeat scroll 3px;

	height: 16px;

	width: 20px;

	cursor: pointer;

	display: block;

	float: right;

	margin-top: 2px;

}

.following {

	background: url("../images/icons/heart_delete.png") no-repeat scroll 3px;

	height: 16px;

	width: 20px;

	cursor: pointer;

	display: block;

	float: right;

	margin-top: 2px;

}

.locking_locked{

    background: #FFF url("../images/icons/block_16.png") no-repeat scroll 3px;

    height: 16px;

    width: 20px;

    cursor: pointer;

    display: block;

    float: right;

    margin-top: 2px;    

}

.locking_unlocked{

    background: #FFF url("../images/icons/accept.png") no-repeat scroll 3px;

    height: 16px;

    width: 20px;

    cursor: pointer;

    display: block;

    float: right;

    margin-top: 2px;	

}

.currently_following {

	padding-left: 10px;

	padding-bottom: 5px;

}

.add_icon {

	background: url("../images/icons/add.png") no-repeat scroll 3px;

	padding-left: 20px;

	padding-top: 0px;

	text-align: left;

}

.accept_icon {

    background: url("../images/icons/accept.png") no-repeat scroll 3px;

    padding-left: 20px;

    padding-top: 0px;

    text-align: left;

}

.edit_icon {

	background: url("../images/icons/application_form_edit.png") no-repeat scroll 3px;

	padding-left: 20px;

	padding-top: 0px;

	text-align: left;

}

.delete_icon {

	background: url("../images/icons/delete.png") no-repeat scroll 3px;

	padding-left: 20px;

	padding-top: 0px;

	text-align: left;

}

.refresh_icon {

	background: url("../images/icons/arrow_refresh.png") no-repeat scroll

		3px;

	padding-left: 20px;

	padding-top: 0px;

	text-align: left;

}

.pull_icon {

	background: url("../images/icons/connect.png") no-repeat scroll 3px;

	padding-left: 20px;

	padding-top: 0px;

	text-align: left;

}

.rss_icon {

	background: url("../images/icons/rss_16.png") no-repeat scroll 3px;

	padding-left: 20px;

	padding-top: 4px;

	text-align: left;

	font-size: 8px

}

.atom_icon {

	background: url("../images/icons/atom.png") no-repeat scroll 3px;

	padding-left: 20px;

	padding-top: 4px;

	text-align: left;