else:

        params[fileid] += ['C:%s' % ln_ctx]

        ig_ws_key = fileid

        ig_ws_val = 'WS:%s' % 1

    if ig_ws:

        params[ig_ws_key] += [ig_ws_val]

    lbl = _('increase diff context to %(num)s lines') % {'num': ln_ctx}

    params['anchor'] = fileid

    img = h.image(h.url('/images/icons/table_add.png'), lbl, class_='icon')

    return h.link_to(img, h.url.current(**params), title=lbl, class_='tooltip')

class ChangesetController(BaseRepoController):

    def __before__(self):

        super(ChangesetController, self).__before__()

        c.affected_files_cut_off = 60

    def __load_data(self):

        repo_model = RepoModel()

        c.users_array = repo_model.get_users_js()

        c.user_groups_array = repo_model.get_user_groups_js()

    def _index(self, revision, method):

        c.anchor_url = anchor_url

        c.ignorews_url = _ignorews_url

        c.context_url = _context_url

        c.fulldiff = fulldiff = request.GET.get('fulldiff')

        #get ranges of revisions if preset

        rev_range = revision.split('...')[:2]

        enable_comments = True

        try:

            if len(rev_range) == 2:

                enable_comments = False

                rev_start = rev_range[0]

                rev_end = rev_range[1]

                rev_ranges = c.db_repo_scm_instance.get_changesets(start=rev_start,

                                                             end=rev_end)

            else:

                rev_ranges = [c.db_repo_scm_instance.get_changeset(revision)]

            c.cs_ranges = list(rev_ranges)

            if not c.cs_ranges:

                raise RepositoryError('Changeset range returned empty result')

        except(ChangesetDoesNotExistError,), e:

            log.error(traceback.format_exc())

            msg = _('Such revision does not exist for this repository')

            h.flash(msg, category='error')

            raise HTTPNotFound()

        except (Exception,), e:

            log.error(traceback.format_exc())

            raise HTTPNotFound()

        c.changes = OrderedDict()

        c.lines_added = 0  # count of lines added

        c.lines_deleted = 0  # count of lines removes

        c.changeset_statuses = ChangesetStatus.STATUSES

        comments = dict()

        c.statuses = []

        c.inline_comments = []

        c.inline_cnt = 0

        # Iterate over ranges (default changeset view is always one changeset)

        for changeset in c.cs_ranges:

            inlines = []

            if method == 'show':

                c.statuses.extend([ChangesetStatusModel().get_status(

                            c.db_repo.repo_id, changeset.raw_id)])

                # Changeset comments

                comments.update((com.comment_id, com)

                                for com in ChangesetCommentsModel()

                                .get_comments(c.db_repo.repo_id,

                                              revision=changeset.raw_id))

                # Status change comments - mostly from pull requests

                comments.update((st.changeset_comment_id, st.comment)

                                for st in ChangesetStatusModel()

                                .get_statuses(c.db_repo.repo_id,

                                              changeset.raw_id, with_revisions=True))

                inlines = ChangesetCommentsModel()\

                            .get_inline_comments(c.db_repo.repo_id,

                                                 revision=changeset.raw_id)

                c.inline_comments.extend(inlines)

            c.changes[changeset.raw_id] = []

            cs2 = changeset.raw_id

            cs1 = changeset.parents[0].raw_id if changeset.parents else EmptyChangeset().raw_id

            context_lcl = get_line_ctx('', request.GET)

            ign_whitespace_lcl = ign_whitespace_lcl = get_ignore_ws('', request.GET)

            _diff = c.db_repo_scm_instance.get_diff(cs1, cs2,

                ignore_whitespace=ign_whitespace_lcl, context=context_lcl)

            diff_limit = self.cut_off_limit if not fulldiff else None

            diff_processor = diffs.DiffProcessor(_diff,

                                                 vcs=c.db_repo_scm_instance.alias,

                                                 format='gitdiff',

                                                 diff_limit=diff_limit)

            cs_changes = OrderedDict()

            if method == 'show':

                _parsed = diff_processor.prepare()

                c.limited_diff = False

                if isinstance(_parsed, LimitedDiffContainer):

                    c.limited_diff = True

                for f in _parsed:

                    st = f['stats']

                    c.lines_added += st['added']

                    c.lines_deleted += st['deleted']

                    fid = h.FID(changeset.raw_id, f['filename'])

                    diff = diff_processor.as_html(enable_comments=enable_comments,

                                                  parsed_lines=[f])

                    cs_changes[fid] = [cs1, cs2, f['operation'], f['filename'],

                                       diff, st]

            else:

                # downloads/raw we only need RAW diff nothing else

                diff = diff_processor.as_raw()

                cs_changes[''] = [None, None, None, None, diff, None]

            c.changes[changeset.raw_id] = cs_changes

        #sort comments in creation order

        c.comments = [com for com_id, com in sorted(comments.items())]

        # count inline comments

        for __, lines in c.inline_comments:

            for comments in lines.values():

                c.inline_cnt += len(comments)

        if len(c.cs_ranges) == 1:

            c.changeset = c.cs_ranges[0]

            c.parent_tmpl = ''.join(['# Parent  %s\n' % x.raw_id

                                     for x in c.changeset.parents])

        if method == 'download':

            response.content_type = 'text/plain'

            response.content_disposition = 'attachment; filename=%s.diff' \

                                            % revision[:12]

            return diff

        elif method == 'patch':

            response.content_type = 'text/plain'

            c.diff = safe_unicode(diff)

            return render('changeset/patch_changeset.html')

        elif method == 'raw':

            response.content_type = 'text/plain'

            return diff

        elif method == 'show':

            self.__load_data()

            if len(c.cs_ranges) == 1:

                return render('changeset/changeset.html')

            else:

                c.cs_ranges_org = None

                revs = [ctx.revision for ctx in reversed(c.cs_ranges)]

                c.jsdata = json.dumps(graph_data(c.db_repo_scm_instance, revs))

                return render('changeset/changeset_range.html')

    @LoginRequired()

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

                                   'repository.admin')

    def index(self, revision, method='show'):

        return self._index(revision, method=method)

    @LoginRequired()

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

                                   'repository.admin')

    def changeset_raw(self, revision):

        return self._index(revision, method='raw')

    @LoginRequired()

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

                                   'repository.admin')

    def changeset_patch(self, revision):

        return self._index(revision, method='patch')

    @LoginRequired()

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

                                   'repository.admin')

    def changeset_download(self, revision):

        return self._index(revision, method='download')

    @LoginRequired()

    @NotAnonymous()

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

                                   'repository.admin')

    @jsonify

    def comment(self, repo_name, revision):

        status = request.POST.get('changeset_status')

        text = request.POST.get('text')

            text = text or (_('Status change -> %s')

                            % ChangesetStatus.get_status_lbl(status))

        c.co = comm = ChangesetCommentsModel().create(

            text=text,

            repo=c.db_repo.repo_id,

            user=c.authuser.user_id,

            revision=revision,

            f_path=request.POST.get('f_path'),

            line_no=request.POST.get('line'),

            status_change=(ChangesetStatus.get_status_lbl(status)

        )

        # get status if set !

            # if latest status was from pull request and it's closed

            # disallow changing status !

            # dont_allow_on_closed_pull_request = True !

            try:

                ChangesetStatusModel().set_status(

                    c.db_repo.repo_id,

                    status,

                    c.authuser.user_id,

                    comm,

                    revision=revision,

                    dont_allow_on_closed_pull_request=True

                )

            except StatusChangeOnClosedPullRequestError:

                log.error(traceback.format_exc())

                msg = _('Changing status on a changeset associated with '

                        'a closed pull request is not allowed')

                h.flash(msg, category='warning')

                return redirect(h.url('changeset_home', repo_name=repo_name,

                                      revision=revision))

        action_logger(self.authuser,

                      'user_commented_revision:%s' % revision,

                      c.db_repo, self.ip_addr, self.sa)

        Session().commit()

        if not request.environ.get('HTTP_X_PARTIAL_XHR'):

            return redirect(h.url('changeset_home', repo_name=repo_name,

                                  revision=revision))

        #only ajax below

        data = {

           'target_id': h.safeid(h.safe_unicode(request.POST.get('f_path'))),

        }

        if comm:

            data.update(comm.get_dict())

            data.update({'rendered_text':

                         render('changeset/changeset_comment_block.html')})

        return data

    @LoginRequired()

    @NotAnonymous()

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

                                   'repository.admin')

    def preview_comment(self):

        if not request.environ.get('HTTP_X_PARTIAL_XHR'):

            raise HTTPBadRequest()

        text = request.POST.get('text')

        if text:

            return h.rst_w_mentions(text)

        return ''

    @LoginRequired()

    @NotAnonymous()

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

                                   'repository.admin')

    @jsonify

    def delete_comment(self, repo_name, comment_id):

        co = ChangesetComment.get(comment_id)

        if not co:

            raise HTTPBadRequest()

        owner = co.author.user_id == c.authuser.user_id

        repo_admin = h.HasRepoPermissionAny('repository.admin')

        if h.HasPermissionAny('hg.admin')() or repo_admin or owner:

            ChangesetCommentsModel().delete(comment=co)

            Session().commit()

            return True

        else:

            raise HTTPForbidden()

    @LoginRequired()

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

                                   'repository.admin')

    @jsonify

    def changeset_info(self, repo_name, revision):

        if request.is_xhr:

            try:

                return c.db_repo_scm_instance.get_changeset(revision)

            except ChangesetDoesNotExistError, e:

                return EmptyChangeset(message=str(e))

        else:

            raise HTTPBadRequest()

    @LoginRequired()

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

                                   'repository.admin')

    @jsonify

    def changeset_children(self, repo_name, revision):

        if request.is_xhr:

            changeset = c.db_repo_scm_instance.get_changeset(revision)

            result = {"results": []}

            if changeset.children:

                result = {"results": changeset.children}

            return result

        else:

            raise HTTPBadRequest()

    @LoginRequired()

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

                                   'repository.admin')

    @jsonify

    def changeset_parents(self, repo_name, revision):

        if request.is_xhr:

            changeset = c.db_repo_scm_instance.get_changeset(revision)

            result = {"results": []}

            if changeset.parents:

                result = {"results": changeset.parents}

            return result

        else:

            raise HTTPBadRequest()

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

                                   'repository.admin')

    def create(self, repo_name):

        repo = RepoModel()._get_repo(repo_name)

        try:

            _form = PullRequestForm(repo.repo_id)().to_python(request.POST)

        except formencode.Invalid, errors:

            log.error(traceback.format_exc())

            msg = _('Error creating pull request: %s') % errors.msg

            h.flash(msg, 'error')

            return redirect(url('pullrequest_home', repo_name=repo_name)) ## would rather just go back to form ...

        # heads up: org and other might seem backward here ...

        org_repo_name = _form['org_repo']

        org_ref = _form['org_ref'] # will have merge_rev as rev but symbolic name

        org_repo = RepoModel()._get_repo(org_repo_name)

        (org_ref_type,

         org_ref_name,

         org_rev) = org_ref.split(':')

        other_repo_name = _form['other_repo']

        other_ref = _form['other_ref'] # will have symbolic name and head revision

        other_repo = RepoModel()._get_repo(other_repo_name)

        (other_ref_type,

         other_ref_name,

         other_rev) = other_ref.split(':')

        cs_ranges, _cs_ranges_not, ancestor_rev = \

            CompareController._get_changesets(org_repo.scm_instance.alias,

                                              other_repo.scm_instance, other_rev, # org and other "swapped"

                                              org_repo.scm_instance, org_rev,

                                              )

        revisions = [cs.raw_id for cs in cs_ranges]

        # hack: ancestor_rev is not an other_ref but we want to show the

        # requested destination and have the exact ancestor

        other_ref = '%s:%s:%s' % (other_ref_type, other_ref_name, ancestor_rev)

        reviewers = _form['review_members']

        title = _form['pullrequest_title']

        if not title:

            title = '%s#%s to %s#%s' % (org_repo_name, h.short_ref(org_ref_type, org_ref_name),

                                        other_repo_name, h.short_ref(other_ref_type, other_ref_name))

        description = _form['pullrequest_desc'].strip() or _('No description')

        try:

            pull_request = PullRequestModel().create(

                self.authuser.user_id, org_repo_name, org_ref, other_repo_name,

                other_ref, revisions, reviewers, title, description

            )

            Session().commit()

            h.flash(_('Successfully opened new pull request'),

                    category='success')

        except Exception:

            h.flash(_('Error occurred while creating pull request'),

                    category='error')

            log.error(traceback.format_exc())

            return redirect(url('pullrequest_home', repo_name=repo_name))

        return redirect(url('pullrequest_show', repo_name=other_repo_name,

                            pull_request_id=pull_request.pull_request_id))

    @LoginRequired()

    @NotAnonymous()

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

                                   'repository.admin')

    def post(self, repo_name, pull_request_id):

        repo = RepoModel()._get_repo(repo_name)

        pull_request = PullRequest.get_or_404(pull_request_id)

        _form = PullRequestPostForm()().to_python(request.POST)

        pull_request.title = _form['pullrequest_title']

        pull_request.description = _form['pullrequest_desc'].strip() or _('No description')

        Session().commit()

        h.flash(_('Pull request updated'), category='success')

        return redirect(url('pullrequest_show', repo_name=repo.repo_name,

                            pull_request_id=pull_request_id))

    @LoginRequired()

    @NotAnonymous()

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

                                   'repository.admin')

    @jsonify

    def update(self, repo_name, pull_request_id):

        pull_request = PullRequest.get_or_404(pull_request_id)

        if pull_request.is_closed():

            raise HTTPForbidden()

        #only owner or admin can update it

        owner = pull_request.author.user_id == c.authuser.user_id

        repo_admin = h.HasRepoPermissionAny('repository.admin')(c.repo_name)

        if h.HasPermissionAny('hg.admin') or repo_admin or owner:

            reviewers_ids = map(int, filter(lambda v: v not in [None, ''],

                request.POST.get('reviewers_ids', '').split(',')))

            PullRequestModel().update_reviewers(pull_request_id, reviewers_ids)

            Session().commit()

            return True

        raise HTTPForbidden()

    @LoginRequired()

    @NotAnonymous()

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

                                   'repository.admin')

    @jsonify

    def delete(self, repo_name, pull_request_id):

        pull_request = PullRequest.get_or_404(pull_request_id)

        #only owner can delete it !

        if pull_request.author.user_id == c.authuser.user_id:

            PullRequestModel().delete(pull_request)

            Session().commit()

            h.flash(_('Successfully deleted pull request'),

                    category='success')

            return redirect(url('my_account_pullrequests'))

        raise HTTPForbidden()

    @LoginRequired()

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

                                   'repository.admin')

    def show(self, repo_name, pull_request_id):

        repo_model = RepoModel()

        c.users_array = repo_model.get_users_js()

        c.user_groups_array = repo_model.get_user_groups_js()

        c.pull_request = PullRequest.get_or_404(pull_request_id)

        c.allowed_to_change_status = self._get_is_allowed_change_status(c.pull_request)

        cc_model = ChangesetCommentsModel()

        cs_model = ChangesetStatusModel()

        _cs_statuses = cs_model.get_statuses(c.pull_request.org_repo,

                                            pull_request=c.pull_request,

                                            with_revisions=True)

        cs_statuses = defaultdict(list)

        for st in _cs_statuses:

            cs_statuses[st.author.username] += [st]

        c.pull_request_reviewers = []

        c.pull_request_pending_reviewers = []

        for o in c.pull_request.reviewers:

            st = cs_statuses.get(o.user.username, None)

            if st:

                sorter = lambda k: k.version

                st = [(x, list(y)[0])

                      for x, y in (groupby(sorted(st, key=sorter), sorter))]

            else:

                c.pull_request_pending_reviewers.append(o.user)

            c.pull_request_reviewers.append([o.user, st])

        # pull_requests repo_name we opened it against

        # ie. other_repo must match

        if repo_name != c.pull_request.other_repo.repo_name:

            raise HTTPNotFound

        # load compare data into template context

        enable_comments = not c.pull_request.is_closed()

        self._load_compare_data(c.pull_request, enable_comments=enable_comments)

        # inline comments

        c.inline_cnt = 0

        c.inline_comments = cc_model.get_inline_comments(

                                c.db_repo.repo_id,

                                pull_request=pull_request_id)

        # count inline comments

        for __, lines in c.inline_comments:

            for comments in lines.values():

                c.inline_cnt += len(comments)

        # comments

        c.comments = cc_model.get_comments(c.db_repo.repo_id,

                                           pull_request=pull_request_id)

        # (badly named) pull-request status calculation based on reviewer votes

        c.current_changeset_status = cs_model.calculate_status(

                                        c.pull_request_reviewers,

                                         )

        c.changeset_statuses = ChangesetStatus.STATUSES

        c.as_form = False

        c.ancestor = None # there is one - but right here we don't know which

        return render('/pullrequests/pullrequest_show.html')

    @LoginRequired()

    @NotAnonymous()

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

                                   'repository.admin')

    @jsonify

    def comment(self, repo_name, pull_request_id):

        pull_request = PullRequest.get_or_404(pull_request_id)

        if pull_request.is_closed():

            raise HTTPForbidden()

        status = request.POST.get('changeset_status')

        text = request.POST.get('text')

        close_pr = request.POST.get('save_close')

        allowed_to_change_status = self._get_is_allowed_change_status(pull_request)

            _def = (_('Status change -> %s')

                            % ChangesetStatus.get_status_lbl(status))

            if close_pr:

                _def = _('Closing with') + ' ' + _def

            text = text or _def

        comm = ChangesetCommentsModel().create(

            text=text,

            repo=c.db_repo.repo_id,

            user=c.authuser.user_id,

            pull_request=pull_request_id,

            f_path=request.POST.get('f_path'),

            line_no=request.POST.get('line'),

            status_change=(ChangesetStatus.get_status_lbl(status)

            closing_pr=close_pr

        )

        action_logger(self.authuser,

                      'user_commented_pull_request:%s' % pull_request_id,

                      c.db_repo, self.ip_addr, self.sa)

        if allowed_to_change_status:

            # get status if set !

                ChangesetStatusModel().set_status(

                    c.db_repo.repo_id,

                    status,

                    c.authuser.user_id,

                    comm,

                    pull_request=pull_request_id

                )

            if close_pr:

                if status in ['rejected', 'approved']:

                    PullRequestModel().close_pull_request(pull_request_id)

                    action_logger(self.authuser,

                              'user_closed_pull_request:%s' % pull_request_id,

                              c.db_repo, self.ip_addr, self.sa)

                else:

                    h.flash(_('Closing pull request on other statuses than '

                              'rejected or approved forbidden'),

                            category='warning')

        Session().commit()

        if not request.environ.get('HTTP_X_PARTIAL_XHR'):

            return redirect(h.url('pullrequest_show', repo_name=repo_name,

                                  pull_request_id=pull_request_id))

        data = {

           'target_id': h.safeid(h.safe_unicode(request.POST.get('f_path'))),

        }

        if comm:

            c.co = comm

            data.update(comm.get_dict())

            data.update({'rendered_text':

                         render('changeset/changeset_comment_block.html')})

        return data

    @LoginRequired()

    @NotAnonymous()

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

                                   'repository.admin')

    @jsonify

    def delete_comment(self, repo_name, comment_id):

        co = ChangesetComment.get(comment_id)

        if co.pull_request.is_closed():

            #don't allow deleting comments on closed pull request

            raise HTTPForbidden()

        owner = co.author.user_id == c.authuser.user_id

        repo_admin = h.HasRepoPermissionAny('repository.admin')(c.repo_name)

        if h.HasPermissionAny('hg.admin') or repo_admin or owner:

            ChangesetCommentsModel().delete(comment=co)

            Session().commit()

            return True

        else:

            raise HTTPForbidden()

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

## usage:

## <%namespace name="comment" file="/changeset/changeset_file_comment.html"/>

## ${comment.comment_block(co)}

##

<%def name="comment_block(co)">

  <div class="comment" id="comment-${co.comment_id}" line="${co.line_no}">

    <div class="comment-wrapp">

      <div class="meta">

        <div style="float:left"> <img src="${h.gravatar_url(co.author.email, 20)}" /> </div>

          <div class="user">

              ${co.author.username}

          </div>

          <div class="date">

              ${h.age(co.modified_at)}

          </div>

       <div style="float:left;padding:4px 0px 0px 5px">

        <span class="">

         %if co.pull_request:

            %if co.status_change:

              ${_('Status change from pull request')}

              <a href="${h.url('pullrequest_show',repo_name=co.pull_request.other_repo.repo_name,pull_request_id=co.pull_request.pull_request_id)}">"${co.pull_request.title or _("No title")}"</a>:

            %else:

              ${_('Comment from pull request')}

              <a href="${h.url('pullrequest_show',repo_name=co.pull_request.other_repo.repo_name,pull_request_id=co.pull_request.pull_request_id)}">"${co.pull_request.title or _("No title")}"</a>

            %endif

         %else:

            %if co.status_change:

              ${_('Status change on changeset')}:

            %else:

              ${_('Comment on changeset')}

            %endif

         %endif

        </span>

       </div>

        %if co.status_change:

           <div  style="float:left" class="changeset-status-container">

             <div style="float:left;padding:10px 2px 0px 2px"></div>

             <div title="${_('Changeset status')}" class="changeset-status-lbl"> ${co.status_change[0].status_lbl}</div>

             <div class="changeset-status-ico"><img src="${h.url(str('/images/icons/flag_status_%s.png' % co.status_change[0].status))}" /></div>

           </div>

        %endif

      <a class="permalink" href="#comment-${co.comment_id}">&para;</a>

      %if h.HasPermissionAny('hg.admin')() or h.HasRepoPermissionAny('repository.admin')(c.repo_name) or co.author.user_id == c.authuser.user_id:

          <div onClick="confirm('${_("Delete comment?")}') && deleteComment(${co.comment_id})" class="buttons delete-comment btn btn-mini">${_('Delete')}</div>

      %endif

      </div>

      <div class="text">

          ${h.rst_w_mentions(co.text)|n}

      </div>

    </div>

  </div>

</%def>

<%def name="comment_inline_form()">

<div id='comment-inline-form-template' style="display:none">

  <div class="comment-inline-form ac">

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

      ${h.form('#', class_='inline-form')}

      <div id="edit-container_{1}" class="clearfix">

          <div class="comment-help">${_('Commenting on line {1}.')}

          ${(_('Comments parsed using %s syntax with %s support.') % (

                 ('<a href="%s">RST</a>' % h.url('rst_help')),

                   ('<span style="color:#577632" class="tooltip" title="%s">@mention</span>' % _('Use @username inside this text to notify another user'))

               )

            )|n

           }

          <div id="preview-btn_{1}" class="preview-btn btn btn-mini">${_('Preview')}</div>

          </div>

            <div class="mentions-container" id="mentions_container_{1}"></div>

            <textarea id="text_{1}" name="text" class="comment-block-ta yui-ac-input"></textarea>

      </div>

      <div id="preview-container_{1}" class="clearfix" style="display:none">

         <div class="comment-help">

              ${_('Comment preview')}

            <div id="edit-btn_{1}" class="edit-btn btn btn-mini">${_('Edit')}</div>

          </div>

          <div id="preview-box_{1}" class="preview-box"></div>

      </div>

      <div class="comment-button">

      <div class="submitting-overlay">${_('Submitting ...')}</div>

      <input type="hidden" name="f_path" value="{0}">

      <input type="hidden" name="line" value="{1}">

      ${h.submit('save', _('Comment'), class_='btn btn-small save-inline-form')}

      ${h.reset('hide-inline-form', _('Cancel'), class_='btn btn-small hide-inline-form')}

      </div>

      ${h.end_form()}

  %else:

      ${h.form('')}

      <div class="clearfix">

          <div class="comment-help">

            ${_('You need to be logged in to comment.')} <a href="${h.url('login_home',came_from=h.url.current())}">${_('Login now')}</a>

          </div>

      </div>

      <div class="comment-button">

      ${h.reset('hide-inline-form', _('Hide'), class_='btn btn-small hide-inline-form')}

      </div>

      ${h.end_form()}

  %endif

  </div>

</div>

</%def>

## generates inlines taken from c.comments var

<%def name="inlines()">

    <div class="comments-number">${ungettext("%d comment", "%d comments", len(c.comments)) % len(c.comments)} ${ungettext("(%d inline)", "(%d inline)", c.inline_cnt) % c.inline_cnt}</div>

    %for path, lines in c.inline_comments:

        % for line,comments in lines.iteritems():

            <div style="display:none" class="inline-comment-placeholder" path="${path}" target_id="${h.safeid(h.safe_unicode(path))}">

            %for co in comments:

                ${comment_block(co)}

            %endfor

            </div>

        %endfor

    %endfor

</%def>

## generate inline comments and the main ones

<%def name="generate_comments()">

<div class="comments">

    <div id="inline-comments-container">

    ## generate inlines for this changeset

     ${inlines()}

    </div>

    %for co in c.comments:

        <div id="comment-tr-${co.comment_id}">

          ${comment_block(co)}

        </div>

    %endfor

</div>

</%def>

## MAIN COMMENT FORM

<%def name="comments(post_url, cur_status, is_pr=False, change_status=True)">

<div class="comments">

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

    <div class="comment-form ac">

        ${h.form(post_url)}

        <div id="edit-container" class="clearfix">

            <div class="comment-help">

                ${(_('Comments parsed using %s syntax with %s support.') % (('<a href="%s">RST</a>' % h.url('rst_help')),

                  '<span style="color:#577632" class="tooltip" title="%s">@mention</span>' %

                  _('Use @username inside this text to send notification to this Kallithea user')))|n}

                <div id="preview-btn" class="preview-btn btn btn-mini">${_('Preview')}</div>

            </div>

            <div class="mentions-container" id="mentions_container"></div>

            ${h.textarea('text', class_="comment-block-ta")}

            %if change_status:

              <div id="status_block_container" class="status-block">

                %if is_pr:

                  ${_('Vote for pull request status')}:

                %else:

                  ${_('Set changeset status')}:

                %endif

                <input type="radio" class="status_change_radio" name="changeset_status" id="changeset_status_unchanged" value="" checked="checked" />

                <label for="changeset_status_unchanged">

                  ${_('No change')}

                </label>

                %for status,lbl in c.changeset_statuses:

                    <span style="margin-left: 15px;">

                        <input type="radio" class="status_change_radio" name="changeset_status" id="${status}" value="${status}">

                        <label for="${status}"><img src="${h.url('/images/icons/flag_status_%s.png' % status)}" />${lbl}</label>

                    </span>

                %endfor

                %if is_pr and change_status:

                <input id="save_close" type="checkbox" name="save_close" disabled="${'1' if cur_status in ['not_reviewed','under_review'] else ''}">

                <label id="save_close_label" for="save_close" class="${'disabled' if cur_status in ['not_reviewed','under_review'] else ''}">${_("Close (when approved or rejected)")}</label>

                %endif

              </div>

            %endif

        </div>

        <div id="preview-container" class="clearfix" style="display:none">

           <div class="comment-help">

                ${_('Comment preview')}

              <div id="edit-btn" class="edit-btn btn btn-mini">${_('Edit')}</div>

            </div>

            <div id="preview-box" class="preview-box"></div>

        </div>

        <div class="comment-button">

        ${h.submit('save', _('Comment'), class_="btn")}

        </div>

        ${h.end_form()}

    </div>

    %endif

</div>

<script>

YUE.onDOMReady(function () {

   MentionsAutoComplete('text', 'mentions_container', _USERS_AC_DATA, _GROUPS_AC_DATA);

   var set_close_button_state = function(cur_val){

     %if is_pr and change_status:

       if (cur_val == 'approved' || cur_val == 'rejected') {

           YUD.removeClass('save_close_label', 'disabled');

           YUD.get('save_close').disabled = false;

       }else{

           YUD.addClass('save_close_label', 'disabled');

           YUD.get('save_close').disabled = true;

           YUD.get('save_close').checked = false;

       }

     %endif

   }

   YUE.on(YUQ('.status_change_radio'), 'change',function(e){

       var val = e.currentTarget.value;

       set_close_button_state(val);

   })

   // if currect checked status is approved or rejected we should unlock the close button

   var cur_val = YUQ('.status_change_radio[checked]')[0].value;

   set_close_button_state(cur_val)

   YUE.on('preview-btn', 'click', function(e){

       var _text = YUD.get('text').value;

       if(!_text){

           return

       }

       var post_data = {'text': _text};

       YUD.addClass('preview-box', 'unloaded');

       YUD.get('preview-box').innerHTML = _TM['Loading ...'];

       YUD.setStyle('edit-container', 'display', 'none');

       YUD.setStyle('preview-container', 'display', '');

       var url = pyroutes.url('changeset_comment_preview', {'repo_name': '${c.repo_name}'});

       ajaxPOST(url,post_data,function(o){

           YUD.get('preview-box').innerHTML = o.responseText;

           YUD.removeClass('preview-box', 'unloaded');

       })

   })

   YUE.on('edit-btn', 'click', function(e){

       YUD.setStyle('edit-container', 'display', '');

       YUD.setStyle('preview-container', 'display', 'none');

   })

});

</script>

</%def>