-##
-## The following code comes from Plone project http://plone.org
-##
-""" Useful utilities function from the Plone project like Batch.
-
-
-
-"""
-
-
-from __future__ import nested_scopes
-
-from ZTUtils.Batch import Batch as ZTUBatch
-from ZTUtils import make_query
-from ExtensionClass import Base
-
-# These have to be duplicated from ZTUtils.Batch to use the correct Batch
-# class, otherwise orphans will come out wrong in the 'show x next messages'.
-class LazyPrevBatch(Base):
- def __of__(self, parent):
- return Batch(parent._sequence, parent._size,
- parent.first - parent._size + parent.overlap, 0,
- parent.orphan, parent.overlap)
-
-class LazyNextBatch(Base):
- def __of__(self, parent):
- try: parent._sequence[parent.end]
- except IndexError: return None
- return Batch(parent._sequence, parent._size,
- parent.end - parent.overlap, 0,
- parent.orphan, parent.overlap)
-
-class LazySequenceLength(Base):
- def __of__(self, parent):
- parent.sequence_length = l = len(parent._sequence)
- return l
-
-class Batch(ZTUBatch):
- """Create a sequence batch"""
- __allow_access_to_unprotected_subobjects__ = 1
-
- previous = LazyPrevBatch()
- next = LazyNextBatch()
- sequence_length = LazySequenceLength()
-
- size = first= start = end = orphan = overlap = navlist = None
- numpages = pagenumber = pagerange = pagerangeend = pagerangestart = pagenumber = quantumleap = None
-
- def __init__( self
- , sequence
- , size
- , start=0
- , end=0
- , orphan=0
- , overlap=0
- , pagerange=7
- , quantumleap=0
- , b_start_str='b_start'
- , before_getitem=lambda item: item
- , ):
- """ Encapsulate sequence in batches of size
- sequence - the data to batch.
- size - the number of items in each batch. This will be computed if left out.
- start - the first element of sequence to include in batch (0-index)
- end - the last element of sequence to include in batch (0-index, optional)
- orphan - the next page will be combined with the current page if it does not contain more than orphan elements
- overlap - the number of overlapping elements in each batch
- pagerange - the number of pages to display in the navigation
- quantumleap - 0 or 1 to indicate if bigger increments should be used in the navigation list for big results.
- b_start_str - the request variable used for start, default 'b_start'
- before_getitem - function that compute the item before getting it
- """
- start = start + 1
-
- start,end,sz = opt(start,end,size,orphan,sequence)
-
- self._sequence = sequence
- self.size = sz
- self._size = size
- self.start = start
- self.end = end
- self.orphan = orphan
- self.overlap = overlap
- self.first = max(start - 1, 0)
- self.length = self.end - self.first
-
- self.b_start_str = b_start_str
-
- self.last = self.sequence_length - size
-
- # Set up next and previous
- if self.first == 0:
- self.previous = None
-
- # Set up the total number of pages
- self.numpages = calculate_pagenumber(self.sequence_length - self.orphan, self.size, self.overlap)
-
- # Set up the current page number
- self.pagenumber = calculate_pagenumber(self.start, self.size, self.overlap)
-
- # Set up pagerange for the navigation quick links
- self.pagerange, self.pagerangestart, self.pagerangeend = calculate_pagerange(self.pagenumber,self.numpages,pagerange)
-
- # Set up the lists for the navigation: 4 5 [6] 7 8
- # navlist is the complete list, including pagenumber
- # prevlist is the 4 5 in the example above
- # nextlist is 7 8 in the example above
- self.navlist = self.prevlist = self.nextlist = []
- if self.pagerange and self.numpages >= 1:
- self.navlist = range(self.pagerangestart, self.pagerangeend)
- self.prevlist = range(self.pagerangestart, self.pagenumber)
- self.nextlist = range(self.pagenumber + 1, self.pagerangeend)
-
- # QuantumLeap - faster navigation for big result sets
- self.quantumleap = quantumleap
- self.leapback = self.leapforward = []
- if self.quantumleap:
- self.leapback = calculate_leapback(self.pagenumber, self.numpages, self.pagerange)
- self.leapforward = calculate_leapforward(self.pagenumber, self.numpages, self.pagerange)
-
- # comptute item before getting it
- self.before_getitem = before_getitem
-
- def __getitem__(self, index):
- if index < 0:
- if index + self.end < self.first: raise IndexError, index
- item = self._sequence[index + self.end]
- return self.before_getitem(item)
-
- if index >= self.length: raise IndexError, index
- item = self._sequence[index+self.first]
- return self.before_getitem(item)
-
- def pageurl(self, formvariables, pagenumber=-1):
- """ Makes the url for a given page """
- if pagenumber == -1:
- pagenumber = self.pagenumber
- b_start = pagenumber * (self.size - self.overlap) - self.size
- return make_query(formvariables, {self.b_start_str:b_start})
-
- def navurls(self, formvariables, navlist=[]):
- """ Returns the page number and url for the navigation quick links """
- if not navlist: navlist = self.navlist
- return map(lambda x, formvariables = formvariables: (x, self.pageurl(formvariables, x)), navlist)
-
- def prevurls(self, formvariables):
- """ Helper method to get prev navigation list from templates """
- return self.navurls(formvariables, self.prevlist)
-
- def nexturls(self, formvariables):
- """ Helper method to get next navigation list from templates """
- return self.navurls(formvariables, self.nextlist)
-
-# Calculate start, end, batchsize
-# This is copied from ZTUtils.Batch.py because orphans were not correct there.
-# 04/16/04 modified by Danny Bloemendaal (_ender_). Removed try/except structs because
-# in some situations they cause some unexpected problems. Also fixed some problems with the orphan stuff. Seems to work now.
-def opt(start,end,size,orphan,sequence):
- length = len(sequence)
- if size < 1:
- if start > 0 and end > 0 and end >= start:
- size = end + 1 - start
- else: size = 25
- if start > 0:
- if start>length:
- start = length
- if end > 0:
- if end < start: end = start
- else:
- end = start + size - 1
- if (end+orphan)>=length:
- end = length
- elif end > 0:
- if (end)>length:
- end = length
- start = end + 1 - size
- if start - 1 < orphan: start = 1
- else:
- start = 1
- end = start + size - 1
- if (end+orphan)>=length:
- end = length
- return start,end,size
-
-def calculate_pagenumber(elementnumber, batchsize, overlap=0):
- """ Calculate the pagenumber for the navigation """
- # To find first element in a page,
- # elementnumber = pagenumber * (size - overlap) - size (- orphan?)
- try:
- pagenumber,remainder = divmod(elementnumber, batchsize - overlap)
- except ZeroDivisionError:
- pagenumber, remainder = divmod(elementnumber, 1)
- if remainder > overlap:
- pagenumber = pagenumber + 1
- pagenumber = max(pagenumber, 1)
- return pagenumber
-
-def calculate_pagerange(pagenumber, numpages, pagerange):
- """ Calculate the pagerange for the navigation quicklinks """
- # Pagerange is the number of pages linked to in the navigation, odd number
- pagerange = max(0 , pagerange + pagerange % 2 - 1)
- # Making sure the list will not start with negative values
- pagerangestart = max ( 1, pagenumber - (pagerange - 1 ) / 2 )
- # Making sure the list does not expand beyond the last page
- pagerangeend = min ( pagenumber + (pagerange - 1 ) / 2, numpages) + 1
- return pagerange, pagerangestart, pagerangeend
-
-def calculate_quantum_leap_gap(numpages, pagerange):
- """ Find the QuantumLeap gap. Current width of list is 6 clicks (30/5) """
- return int(max(1,round(float(numpages - pagerange)/30))*5)
-
-def calculate_leapback(pagenumber, numpages, pagerange):
- """ Check the distance between start and 0 and add links as necessary """
- leapback = []
- quantum_leap_gap = calculate_quantum_leap_gap(numpages, pagerange)
- num_back_leaps = max(0,min(3, int(round(float(pagenumber - pagerange)/quantum_leap_gap) - 0.3)))
- if num_back_leaps:
- pagerange, pagerangestart, pagerangeend = calculate_pagerange( pagenumber, numpages, pagerange)
- leapback = range(pagerangestart - num_back_leaps * quantum_leap_gap, pagerangestart, quantum_leap_gap)
- return leapback
-
-def calculate_leapforward(pagenumber, numpages, pagerange):
- """ Check the distance between end and length and add links as necessary """
- leapforward = []
- quantum_leap_gap = calculate_quantum_leap_gap(numpages, pagerange)
- num_forward_leaps = max(0,min(3, int(round(float(numpages - pagenumber - pagerange)/quantum_leap_gap) - 0.3)))
- if num_forward_leaps:
- pagerange, pagerangestart, pagerangeend = calculate_pagerange( pagenumber, numpages, pagerange)
- leapforward = range(pagerangeend-1 + quantum_leap_gap, pagerangeend-1 + (num_forward_leaps+1) * quantum_leap_gap, quantum_leap_gap)
- return leapforward
-
-
-class IndexIterator:
- __allow_access_to_unprotected_subobjects__ = 1
-
- def __init__(self, upper=100000, pos=0):
- self.upper=upper
- self.pos=pos
-
- def next(self):
- if self.pos <= self.upper:
- self.pos += 1
- return self.pos
- raise KeyError, 'Reached upper bounds'
projects / Plinn.git / blobdiff