Changeset 3492

Show
Ignore:
Timestamp:
09/09/07 16:31:04 (1 year ago)
Author:
faide
Message:

applied ticket #1410. Thanks beef.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • branches/1.0/turbogears/paginate.py

    r3366 r3492  
    7070    def entangle(func): 
    7171        def decorated(func, *args, **kw): 
    72             page = int(kw.pop('tg_paginate_no', 1)) 
    73             limit_ = int(kw.pop('tg_paginate_limit', limit)) 
    74             order = kw.pop('tg_paginate_order', None) 
    75             ordering = kw.pop('tg_paginate_ordering', {}) 
     72            def kwpop(default, *names): 
     73                for name in names: 
     74                    if kw.has_key(name): 
     75                        return kw.pop(name) 
     76                return default 
     77 
     78            page = int(kwpop(1, var_name + '_tgp_no', 'tg_paginate_no')) 
     79            limit_ = int( 
     80                kwpop(limit, var_name + '_tgp_limit', 'tg_paginate_limit')) 
     81            order = kwpop(None, var_name + '_tgp_order', 'tg_paginate_order') 
     82            ordering = kwpop( 
     83                {}, 
     84                var_name + '_tgp_ordering', 
     85                'tg_paginate_ordering') 
    7686 
    7787            # Convert ordering str to a dict. 
    …… 
    165175            input_values.pop('self', None) 
    166176            for input_key in input_values.keys(): 
    167                 if input_key.startswith('tg_paginate'): 
     177                if input_key.startswith(var_name + '_tgp') or \ 
     178                    input_key.startswith('tg_paginate'): 
    168179                    del input_values[input_key] 
    169180 
    170             cherrypy.request.paginate = Paginate(current_page=page, 
    171                                              limit=limit_, 
    172                                              pages=pages_to_show, 
    173                                              page_count=page_count, 
    174                                              input_values=input_values, 
    175                                              order=order, 
    176                                              ordering=ordering, 
    177                                              row_count=row_count) 
     181            paginate_instance = Paginate( 
     182                current_page=page, 
     183                limit=limit_,  
     184                pages=pages_to_show,  
     185                page_count=page_count,  
     186                input_values=input_values,  
     187                order=order, 
     188                ordering=ordering, 
     189                row_count=row_count, 
     190                var_name=var_name) 
     191 
     192            cherrypy.request.paginate = paginate_instance 
     193            if not hasattr(cherrypy.request, 'paginates'): 
     194                cherrypy.request.paginates = dict() 
     195            cherrypy.request.paginates[var_name] = paginate_instance 
    178196 
    179197            # we replace the var with the sliced one 
    …… 
    192210    if paginate: 
    193211        d.update(dict(paginate=paginate)) 
     212    paginates = getattr(cherrypy.request, 'paginates', None) 
     213    if paginates: 
     214        d.update(dict(paginates=paginates)) 
    194215variable_providers.append(_paginate_var_provider) 
    195216 
    196217class Paginate: 
    197218    """class for variable provider""" 
    198     def __init__(self, current_page, pages, page_count, input_values, 
    199                  limit, order, ordering, row_count): 
    200  
     219    def __init__(self, current_page, pages, page_count, input_values,  
     220                 limit, order, ordering, row_count, var_name): 
     221                  
     222        self.var_name = var_name 
    201223        self.pages = pages 
    202224        self.limit = limit 
    …… 
    217239 
    218240        # If ordering is empty, don't add it. 
    219         input_values = dict(tg_paginate_limit=limit) 
     241        input_values = {var_name + '_tgp_limit': limit} 
    220242        if ordering: 
    221             input_values['tg_paginate_ordering'] = ordering 
     243            input_values[var_name + '_tgp_ordering'] = ordering 
    222244        self.input_values.update(input_values) 
    223245 
    224246        if current_page < page_count: 
    225             self.input_values.update(dict( 
    226                                 tg_paginate_no=current_page+1, 
    227                                 tg_paginate_limit=limit)) 
    228             self.href_next = turbogears.url(cherrypy.request.path, 
    229                                             self.input_values) 
    230             self.input_values.update(dict( 
    231                                 tg_paginate_no=page_count, 
    232                                 tg_paginate_limit=limit)) 
    233             self.href_last = turbogears.url(cherrypy.request.path, 
    234                                             self.input_values) 
     247            self.input_values.update({ 
     248                var_name + '_tgp_no': current_page + 1, 
     249                var_name + '_tgp_limit': limit 
     250            }) 
     251            self.href_next = turbogears.url( 
     252                cherrypy.request.path, 
     253                self.input_values) 
     254            self.input_values.update({ 
     255                var_name + '_tgp_no': page_count, 
     256                var_name + '_tgp_limit': limit 
     257            }) 
     258            self.href_last = turbogears.url( 
     259                cherrypy.request.path, 
     260                self.input_values) 
    235261        else: 
    236262            self.href_next = None 
    …… 
    238264 
    239265        if current_page > 1: 
    240             self.input_values.update(dict( 
    241                                 tg_paginate_no=current_page-1, 
    242                                 tg_paginate_limit=limit)) 
    243             self.href_prev = turbogears.url(cherrypy.request.path, 
    244                                             self.input_values) 
    245             self.input_values.update(dict( 
    246                                 tg_paginate_no=1, 
    247                                 tg_paginate_limit=limit)) 
    248             self.href_first = turbogears.url(cherrypy.request.path, 
    249                                              self.input_values) 
     266            self.input_values.update({ 
     267                var_name + '_tgp_no': current_page - 1, 
     268                var_name + '_tgp_limit': limit 
     269            }) 
     270            self.href_prev = turbogears.url( 
     271                cherrypy.request.path, 
     272                self.input_values) 
     273            self.input_values.update({ 
     274                var_name + '_tgp_no': 1, 
     275                var_name + '_tgp_limit': limit 
     276            }) 
     277            self.href_first = turbogears.url( 
     278                cherrypy.request.path, 
     279                self.input_values) 
    250280        else: 
    251281            self.href_prev = None 
    …… 
    257287        # to break the API. 
    258288        order = order or None 
    259         self.input_values['tg_paginate_no'] = page 
     289        self.input_values[self.var_name + '_tgp_no'] = page 
    260290        if order: 
    261             self.input_values['tg_paginate_order'] = order 
     291            self.input_values[self.var_name + '_tgp_order'] = order 
    262292 
    263293        return turbogears.url('', self.input_values)