diff options
Diffstat (limited to 'library/vendor/Zend/Paginator.php')
| -rw-r--r-- | library/vendor/Zend/Paginator.php | 1164 |
1 files changed, 1164 insertions, 0 deletions
diff --git a/library/vendor/Zend/Paginator.php b/library/vendor/Zend/Paginator.php new file mode 100644 index 0000000..e96f882 --- /dev/null +++ b/library/vendor/Zend/Paginator.php @@ -0,0 +1,1164 @@ +<?php +/** + * Zend Framework + * + * LICENSE + * + * This source file is subject to the new BSD license that is bundled + * with this package in the file LICENSE.txt. + * It is also available through the world-wide-web at this URL: + * http://framework.zend.com/license/new-bsd + * If you did not receive a copy of the license and are unable to + * obtain it through the world-wide-web, please send an email + * to license@zend.com so we can send you a copy immediately. + * + * @category Zend + * @package Zend_Paginator + * @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com) + * @license http://framework.zend.com/license/new-bsd New BSD License + * @version $Id$ + */ + +/** + * @see Zend_Loader_PluginLoader + */ + +/** + * @see Zend_Json + */ + +/** + * @category Zend + * @package Zend_Paginator + * @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com) + * @license http://framework.zend.com/license/new-bsd New BSD License + */ +class Zend_Paginator implements Countable, IteratorAggregate +{ + /** + * Specifies that the factory should try to detect the proper adapter type first + * + * @var string + */ + const INTERNAL_ADAPTER = 'Zend_Paginator_Adapter_Internal'; + + /** + * The cache tag prefix used to namespace Paginator results in the cache + * + */ + const CACHE_TAG_PREFIX = 'Zend_Paginator_'; + + /** + * Adapter plugin loader + * + * @var Zend_Loader_PluginLoader + */ + protected static $_adapterLoader = null; + + /** + * Configuration file + * + * @var Zend_Config + */ + protected static $_config = null; + + /** + * Default scrolling style + * + * @var string + */ + protected static $_defaultScrollingStyle = 'Sliding'; + + /** + * Default item count per page + * + * @var int + */ + protected static $_defaultItemCountPerPage = 10; + + /** + * Default number of local pages (i.e., the number of discretes + * page numbers that will be displayed, including the current + * page number) + * + * @var int + */ + protected static $_defaultPageRange = 10; + + /** + * Scrolling style plugin loader + * + * @var Zend_Loader_PluginLoader + */ + protected static $_scrollingStyleLoader = null; + + /** + * Cache object + * + * @var Zend_Cache_Core + */ + protected static $_cache; + + /** + * Enable or disable the cache by Zend_Paginator instance + * + * @var bool + */ + protected $_cacheEnabled = true; + + /** + * Adapter + * + * @var Zend_Paginator_Adapter_Interface + */ + protected $_adapter = null; + + /** + * Number of items in the current page + * + * @var integer + */ + protected $_currentItemCount = null; + + /** + * Current page items + * + * @var Traversable + */ + protected $_currentItems = null; + + /** + * Current page number (starting from 1) + * + * @var integer + */ + protected $_currentPageNumber = 1; + + /** + * Result filter + * + * @var Zend_Filter_Interface + */ + protected $_filter = null; + + /** + * Number of items per page + * + * @var integer + */ + protected $_itemCountPerPage = null; + + /** + * Number of pages + * + * @var integer + */ + protected $_pageCount = null; + + /** + * Number of local pages (i.e., the number of discrete page numbers + * that will be displayed, including the current page number) + * + * @var integer + */ + protected $_pageRange = null; + + /** + * Pages + * + * @var array + */ + protected $_pages = null; + + /** + * View instance used for self rendering + * + * @var Zend_View_Interface + */ + protected $_view = null; + + /** + * Adds an adapter prefix path to the plugin loader. + * + * @param string $prefix + * @param string $path + */ + public static function addAdapterPrefixPath($prefix, $path) + { + self::getAdapterLoader()->addPrefixPath($prefix, $path); + } + + /** + * Adds an array of adapter prefix paths to the plugin + * loader. + * + * <code> + * $prefixPaths = array( + * 'My_Paginator_Adapter' => 'My/Paginator/Adapter/', + * 'Your_Paginator_Adapter' => 'Your/Paginator/Adapter/' + * ); + * </code> + * + * @param array $prefixPaths + */ + public static function addAdapterPrefixPaths(array $prefixPaths) + { + if (isset($prefixPaths['prefix']) && isset($prefixPaths['path'])) { + self::addAdapterPrefixPath($prefixPaths['prefix'], $prefixPaths['path']); + } else { + foreach ($prefixPaths as $prefix => $path) { + if (is_array($path) && isset($path['prefix']) && isset($path['path'])) { + $prefix = $path['prefix']; + $path = $path['path']; + } + + self::addAdapterPrefixPath($prefix, $path); + } + } + } + + /** + * Adds a scrolling style prefix path to the plugin loader. + * + * @param string $prefix + * @param string $path + */ + public static function addScrollingStylePrefixPath($prefix, $path) + { + self::getScrollingStyleLoader()->addPrefixPath($prefix, $path); + } + + /** + * Adds an array of scrolling style prefix paths to the plugin + * loader. + * + * <code> + * $prefixPaths = array( + * 'My_Paginator_ScrollingStyle' => 'My/Paginator/ScrollingStyle/', + * 'Your_Paginator_ScrollingStyle' => 'Your/Paginator/ScrollingStyle/' + * ); + * </code> + * + * @param array $prefixPaths + */ + public static function addScrollingStylePrefixPaths(array $prefixPaths) + { + if (isset($prefixPaths['prefix']) && isset($prefixPaths['path'])) { + self::addScrollingStylePrefixPath($prefixPaths['prefix'], $prefixPaths['path']); + } else { + foreach ($prefixPaths as $prefix => $path) { + if (is_array($path) && isset($path['prefix']) && isset($path['path'])) { + $prefix = $path['prefix']; + $path = $path['path']; + } + + self::addScrollingStylePrefixPath($prefix, $path); + } + } + } + + /** + * Factory. + * + * @param mixed $data + * @param string $adapter + * @param array $prefixPaths + * @return Zend_Paginator + */ + public static function factory($data, $adapter = self::INTERNAL_ADAPTER, + array $prefixPaths = null) + { + if ($data instanceof Zend_Paginator_AdapterAggregate) { + return new self($data->getPaginatorAdapter()); + } else { + if ($adapter == self::INTERNAL_ADAPTER) { + if (is_array($data)) { + $adapter = 'Array'; + } else if ($data instanceof Zend_Db_Table_Select) { + $adapter = 'DbTableSelect'; + } else if ($data instanceof Zend_Db_Select) { + $adapter = 'DbSelect'; + } else if ($data instanceof Iterator) { + $adapter = 'Iterator'; + } else if (is_integer($data)) { + $adapter = 'Null'; + } else { + $type = (is_object($data)) ? get_class($data) : gettype($data); + + /** + * @see Zend_Paginator_Exception + */ + + throw new Zend_Paginator_Exception('No adapter for type ' . $type); + } + } + + $pluginLoader = self::getAdapterLoader(); + + if (null !== $prefixPaths) { + foreach ($prefixPaths as $prefix => $path) { + $pluginLoader->addPrefixPath($prefix, $path); + } + } + + $adapterClassName = $pluginLoader->load($adapter); + + return new self(new $adapterClassName($data)); + } + } + + /** + * Returns the adapter loader. If it doesn't exist it's created. + * + * @return Zend_Loader_PluginLoader + */ + public static function getAdapterLoader() + { + if (self::$_adapterLoader === null) { + self::$_adapterLoader = new Zend_Loader_PluginLoader( + array('Zend_Paginator_Adapter' => 'Zend/Paginator/Adapter') + ); + } + + return self::$_adapterLoader; + } + + /** + * Set a global config + * + * @param Zend_Config $config + */ + public static function setConfig(Zend_Config $config) + { + self::$_config = $config; + + $adapterPaths = $config->get('adapterpaths'); + + if ($adapterPaths != null) { + self::addAdapterPrefixPaths($adapterPaths->adapterpath->toArray()); + } + + $prefixPaths = $config->get('prefixpaths'); + + if ($prefixPaths != null) { + self::addScrollingStylePrefixPaths($prefixPaths->prefixpath->toArray()); + } + + $scrollingStyle = $config->get('scrollingstyle'); + + if ($scrollingStyle != null) { + self::setDefaultScrollingStyle($scrollingStyle); + } + } + + /** + * Returns the default scrolling style. + * + * @return string + */ + public static function getDefaultScrollingStyle() + { + return self::$_defaultScrollingStyle; + } + + /** + * Get the default item count per page + * + * @return int + */ + public static function getDefaultItemCountPerPage() + { + return self::$_defaultItemCountPerPage; + } + + /** + * Set the default item count per page + * + * @param int $count + */ + public static function setDefaultItemCountPerPage($count) + { + self::$_defaultItemCountPerPage = (int) $count; + } + + /** + * Get the default page range + * + * @return int + */ + public static function getDefaultPageRange() + { + return self::$_defaultPageRange; + } + + /** + * Set the default page range + * + * @param int $count + */ + public static function setDefaultPageRange($count) + { + self::$_defaultPageRange = (int) $count; + } + + /** + * Sets a cache object + * + * @param Zend_Cache_Core $cache + */ + public static function setCache(Zend_Cache_Core $cache) + { + self::$_cache = $cache; + } + + /** + * Sets the default scrolling style. + * + * @param string $scrollingStyle + */ + public static function setDefaultScrollingStyle($scrollingStyle = 'Sliding') + { + self::$_defaultScrollingStyle = $scrollingStyle; + } + + /** + * Returns the scrolling style loader. If it doesn't exist it's + * created. + * + * @return Zend_Loader_PluginLoader + */ + public static function getScrollingStyleLoader() + { + if (self::$_scrollingStyleLoader === null) { + self::$_scrollingStyleLoader = new Zend_Loader_PluginLoader( + array('Zend_Paginator_ScrollingStyle' => 'Zend/Paginator/ScrollingStyle') + ); + } + + return self::$_scrollingStyleLoader; + } + + /** + * Constructor. + * + * @param Zend_Paginator_Adapter_Interface|Zend_Paginator_AdapterAggregate $adapter + */ + public function __construct($adapter) + { + if ($adapter instanceof Zend_Paginator_Adapter_Interface) { + $this->_adapter = $adapter; + } else if ($adapter instanceof Zend_Paginator_AdapterAggregate) { + $this->_adapter = $adapter->getPaginatorAdapter(); + } else { + /** + * @see Zend_Paginator_Exception + */ + + throw new Zend_Paginator_Exception( + 'Zend_Paginator only accepts instances of the type ' . + 'Zend_Paginator_Adapter_Interface or Zend_Paginator_AdapterAggregate.' + ); + } + + $config = self::$_config; + + if ($config != null) { + $setupMethods = array('ItemCountPerPage', 'PageRange'); + + foreach ($setupMethods as $setupMethod) { + $value = $config->get(strtolower($setupMethod)); + + if ($value != null) { + $setupMethod = 'set' . $setupMethod; + $this->$setupMethod($value); + } + } + } + } + + /** + * Serializes the object as a string. Proxies to {@link render()}. + * + * @return string + */ + public function __toString() + { + try { + $return = $this->render(); + return $return; + } catch (Exception $e) { + trigger_error($e->getMessage(), E_USER_WARNING); + } + + return ''; + } + + /** + * Enables/Disables the cache for this instance + * + * @param bool $enable + * @return Zend_Paginator + */ + public function setCacheEnabled($enable) + { + $this->_cacheEnabled = (bool)$enable; + return $this; + } + + /** + * Returns the number of pages. + * + * @return integer + */ + public function count(): int + { + if (!$this->_pageCount) { + $this->_pageCount = $this->_calculatePageCount(); + } + + return $this->_pageCount; + } + + /** + * Returns the total number of items available. Uses cache if caching is enabled. + * + * @return integer + */ + public function getTotalItemCount() + { + if (!$this->_cacheEnabled()) { + return count($this->getAdapter()); + } else { + $cacheId = md5($this->_getCacheInternalId(). '_itemCount'); + $itemCount = self::$_cache->load($cacheId); + + if ($itemCount === false) { + $itemCount = count($this->getAdapter()); + + self::$_cache->save($itemCount, $cacheId, array($this->_getCacheInternalId())); + } + + return $itemCount; + } + } + + /** + * Clear the page item cache. + * + * @param int $pageNumber + * @return Zend_Paginator + */ + public function clearPageItemCache($pageNumber = null) + { + if (!$this->_cacheEnabled()) { + return $this; + } + + if (null === $pageNumber) { + foreach (self::$_cache->getIdsMatchingTags(array($this->_getCacheInternalId())) as $id) { + if (preg_match('|'.self::CACHE_TAG_PREFIX."(\d+)_.*|", $id, $page)) { + self::$_cache->remove($this->_getCacheId($page[1])); + } + } + } else { + $cleanId = $this->_getCacheId($pageNumber); + self::$_cache->remove($cleanId); + } + return $this; + } + + /** + * Returns the absolute item number for the specified item. + * + * @param integer $relativeItemNumber Relative item number + * @param integer $pageNumber Page number + * @return integer + */ + public function getAbsoluteItemNumber($relativeItemNumber, $pageNumber = null) + { + $relativeItemNumber = $this->normalizeItemNumber($relativeItemNumber); + + if ($pageNumber == null) { + $pageNumber = $this->getCurrentPageNumber(); + } + + $pageNumber = $this->normalizePageNumber($pageNumber); + + return (($pageNumber - 1) * $this->getItemCountPerPage()) + $relativeItemNumber; + } + + /** + * Returns the adapter. + * + * @return Zend_Paginator_Adapter_Interface + */ + public function getAdapter() + { + return $this->_adapter; + } + + /** + * Returns the number of items for the current page. + * + * @return integer + */ + public function getCurrentItemCount() + { + if ($this->_currentItemCount === null) { + $this->_currentItemCount = $this->getItemCount($this->getCurrentItems()); + } + + return $this->_currentItemCount; + } + + /** + * Returns the items for the current page. + * + * @return Traversable + */ + public function getCurrentItems() + { + if ($this->_currentItems === null) { + $this->_currentItems = $this->getItemsByPage($this->getCurrentPageNumber()); + } + + return $this->_currentItems; + } + + /** + * Returns the current page number. + * + * @return integer + */ + public function getCurrentPageNumber() + { + return $this->normalizePageNumber($this->_currentPageNumber); + } + + /** + * Sets the current page number. + * + * @param integer $pageNumber Page number + * @return Zend_Paginator $this + */ + public function setCurrentPageNumber($pageNumber) + { + $this->_currentPageNumber = (integer) $pageNumber; + $this->_currentItems = null; + $this->_currentItemCount = null; + + return $this; + } + + /** + * Get the filter + * + * @return Zend_Filter_Interface + */ + public function getFilter() + { + return $this->_filter; + } + + /** + * Set a filter chain + * + * @param Zend_Filter_Interface $filter + * @return Zend_Paginator + */ + public function setFilter(Zend_Filter_Interface $filter) + { + $this->_filter = $filter; + + return $this; + } + + /** + * Returns an item from a page. The current page is used if there's no + * page sepcified. + * + * @param integer $itemNumber Item number (1 to itemCountPerPage) + * @param integer $pageNumber + * @return mixed + */ + public function getItem($itemNumber, $pageNumber = null) + { + if ($pageNumber == null) { + $pageNumber = $this->getCurrentPageNumber(); + } else if ($pageNumber < 0) { + $pageNumber = ($this->count() + 1) + $pageNumber; + } + + $page = $this->getItemsByPage($pageNumber); + $itemCount = $this->getItemCount($page); + + if ($itemCount == 0) { + /** + * @see Zend_Paginator_Exception + */ + + throw new Zend_Paginator_Exception('Page ' . $pageNumber . ' does not exist'); + } + + if ($itemNumber < 0) { + $itemNumber = ($itemCount + 1) + $itemNumber; + } + + $itemNumber = $this->normalizeItemNumber($itemNumber); + + if ($itemNumber > $itemCount) { + /** + * @see Zend_Paginator_Exception + */ + + throw new Zend_Paginator_Exception('Page ' . $pageNumber . ' does not' + . ' contain item number ' . $itemNumber); + } + + return $page[$itemNumber - 1]; + } + + /** + * Returns the number of items per page. + * + * @return integer + */ + public function getItemCountPerPage() + { + if (empty($this->_itemCountPerPage)) { + $this->_itemCountPerPage = self::getDefaultItemCountPerPage(); + } + + return $this->_itemCountPerPage; + } + + /** + * Sets the number of items per page. + * + * @param integer $itemCountPerPage + * @return Zend_Paginator $this + */ + public function setItemCountPerPage($itemCountPerPage = -1) + { + $this->_itemCountPerPage = (integer) $itemCountPerPage; + if ($this->_itemCountPerPage < 1) { + $this->_itemCountPerPage = $this->getTotalItemCount(); + } + $this->_pageCount = $this->_calculatePageCount(); + $this->_currentItems = null; + $this->_currentItemCount = null; + + return $this; + } + + /** + * Returns the number of items in a collection. + * + * @param mixed $items Items + * @return integer + */ + public function getItemCount($items) + { + $itemCount = 0; + + if (is_array($items) || $items instanceof Countable) { + $itemCount = count($items); + } else { // $items is something like LimitIterator + $itemCount = iterator_count($items); + } + + return $itemCount; + } + + /** + * Returns the items for a given page. + * + * @return Traversable + */ + public function getItemsByPage($pageNumber) + { + $pageNumber = $this->normalizePageNumber($pageNumber); + + if ($this->_cacheEnabled()) { + $data = self::$_cache->load($this->_getCacheId($pageNumber)); + if ($data !== false) { + return $data; + } + } + + $offset = ($pageNumber - 1) * $this->getItemCountPerPage(); + + $items = $this->_adapter->getItems($offset, $this->getItemCountPerPage()); + + $filter = $this->getFilter(); + + if ($filter !== null) { + $items = $filter->filter($items); + } + + if (!$items instanceof Traversable) { + $items = new ArrayIterator($items); + } + + if ($this->_cacheEnabled()) { + self::$_cache->save($items, $this->_getCacheId($pageNumber), array($this->_getCacheInternalId())); + } + + return $items; + } + + /** + * Returns a foreach-compatible iterator. + * + * @return Traversable + */ + public function getIterator(): Traversable + { + return $this->getCurrentItems(); + } + + /** + * Returns the page range (see property declaration above). + * + * @return integer + */ + public function getPageRange() + { + if (null === $this->_pageRange) { + $this->_pageRange = self::getDefaultPageRange(); + } + + return $this->_pageRange; + } + + /** + * Sets the page range (see property declaration above). + * + * @param integer $pageRange + * @return Zend_Paginator $this + */ + public function setPageRange($pageRange) + { + $this->_pageRange = (integer) $pageRange; + + return $this; + } + + /** + * Returns the page collection. + * + * @param string $scrollingStyle Scrolling style + * @return array + */ + public function getPages($scrollingStyle = null) + { + if ($this->_pages === null) { + $this->_pages = $this->_createPages($scrollingStyle); + } + + return $this->_pages; + } + + /** + * Returns a subset of pages within a given range. + * + * @param integer $lowerBound Lower bound of the range + * @param integer $upperBound Upper bound of the range + * @return array + */ + public function getPagesInRange($lowerBound, $upperBound) + { + $lowerBound = $this->normalizePageNumber($lowerBound); + $upperBound = $this->normalizePageNumber($upperBound); + + $pages = array(); + + for ($pageNumber = $lowerBound; $pageNumber <= $upperBound; $pageNumber++) { + $pages[$pageNumber] = $pageNumber; + } + + return $pages; + } + + /** + * Returns the page item cache. + * + * @return array + */ + public function getPageItemCache() + { + $data = array(); + if ($this->_cacheEnabled()) { + foreach (self::$_cache->getIdsMatchingTags(array($this->_getCacheInternalId())) as $id) { + if (preg_match('|'.self::CACHE_TAG_PREFIX."(\d+)_.*|", $id, $page)) { + $data[$page[1]] = self::$_cache->load($this->_getCacheId($page[1])); + } + } + } + return $data; + } + + /** + * Retrieves the view instance. If none registered, attempts to pull f + * rom ViewRenderer. + * + * @return Zend_View_Interface|null + */ + public function getView() + { + if ($this->_view === null) { + /** + * @see Zend_Controller_Action_HelperBroker + */ + + $viewRenderer = Zend_Controller_Action_HelperBroker::getStaticHelper('viewRenderer'); + if ($viewRenderer->view === null) { + $viewRenderer->initView(); + } + $this->_view = $viewRenderer->view; + } + + return $this->_view; + } + + /** + * Sets the view object. + * + * @param Zend_View_Interface $view + * @return Zend_Paginator + */ + public function setView(Zend_View_Interface $view = null) + { + $this->_view = $view; + + return $this; + } + + /** + * Brings the item number in range of the page. + * + * @param integer $itemNumber + * @return integer + */ + public function normalizeItemNumber($itemNumber) + { + $itemNumber = (integer) $itemNumber; + + if ($itemNumber < 1) { + $itemNumber = 1; + } + + if ($itemNumber > $this->getItemCountPerPage()) { + $itemNumber = $this->getItemCountPerPage(); + } + + return $itemNumber; + } + + /** + * Brings the page number in range of the paginator. + * + * @param integer $pageNumber + * @return integer + */ + public function normalizePageNumber($pageNumber) + { + $pageNumber = (integer) $pageNumber; + + if ($pageNumber < 1) { + $pageNumber = 1; + } + + $pageCount = $this->count(); + + if ($pageCount > 0 && $pageNumber > $pageCount) { + $pageNumber = $pageCount; + } + + return $pageNumber; + } + + /** + * Renders the paginator. + * + * @param Zend_View_Interface $view + * @return string + */ + public function render(Zend_View_Interface $view = null) + { + if (null !== $view) { + $this->setView($view); + } + + $view = $this->getView(); + + return $view->paginationControl($this); + } + + /** + * Returns the items of the current page as JSON. + * + * @return string + */ + public function toJson() + { + $currentItems = $this->getCurrentItems(); + + if ($currentItems instanceof Zend_Db_Table_Rowset_Abstract) { + return Zend_Json::encode($currentItems->toArray()); + } else { + return Zend_Json::encode($currentItems); + } + } + + /** + * Tells if there is an active cache object + * and if the cache has not been desabled + * + * @return bool + */ + protected function _cacheEnabled() + { + return ((self::$_cache !== null) && $this->_cacheEnabled); + } + + /** + * Makes an Id for the cache + * Depends on the adapter object and the page number + * + * Used to store item in cache from that Paginator instance + * and that current page + * + * @param int $page + * @return string + */ + protected function _getCacheId($page = null) + { + if ($page === null) { + $page = $this->getCurrentPageNumber(); + } + return self::CACHE_TAG_PREFIX . $page . '_' . $this->_getCacheInternalId(); + } + + /** + * Get the internal cache id + * Depends on the adapter and the item count per page + * + * Used to tag that unique Paginator instance in cache + * + * @return string + */ + protected function _getCacheInternalId() + { + $adapter = $this->getAdapter(); + + if (method_exists($adapter, 'getCacheIdentifier')) { + return md5(serialize(array( + $adapter->getCacheIdentifier(), $this->getItemCountPerPage() + ))); + } else { + return md5(serialize(array( + $adapter, + $this->getItemCountPerPage() + ))); + } + } + + /** + * Calculates the page count. + * + * @return integer + */ + protected function _calculatePageCount() + { + return (integer) ceil($this->getTotalItemCount() / $this->getItemCountPerPage()); + } + + /** + * Creates the page collection. + * + * @param string $scrollingStyle Scrolling style + * @return stdClass + */ + protected function _createPages($scrollingStyle = null) + { + $pageCount = $this->count(); + $currentPageNumber = $this->getCurrentPageNumber(); + + $pages = new stdClass(); + $pages->pageCount = $pageCount; + $pages->itemCountPerPage = $this->getItemCountPerPage(); + $pages->first = 1; + $pages->current = $currentPageNumber; + $pages->last = $pageCount; + + // Previous and next + if ($currentPageNumber - 1 > 0) { + $pages->previous = $currentPageNumber - 1; + } + + if ($currentPageNumber + 1 <= $pageCount) { + $pages->next = $currentPageNumber + 1; + } + + // Pages in range + $scrollingStyle = $this->_loadScrollingStyle($scrollingStyle); + $pages->pagesInRange = $scrollingStyle->getPages($this); + $pages->firstPageInRange = min($pages->pagesInRange); + $pages->lastPageInRange = max($pages->pagesInRange); + + // Item numbers + if ($this->getCurrentItems() !== null) { + $pages->currentItemCount = $this->getCurrentItemCount(); + $pages->itemCountPerPage = $this->getItemCountPerPage(); + $pages->totalItemCount = $this->getTotalItemCount(); + $pages->firstItemNumber = (($currentPageNumber - 1) * $this->getItemCountPerPage()) + 1; + $pages->lastItemNumber = $pages->firstItemNumber + $pages->currentItemCount - 1; + } + + return $pages; + } + + /** + * Loads a scrolling style. + * + * @param string $scrollingStyle + * @return Zend_Paginator_ScrollingStyle_Interface + */ + protected function _loadScrollingStyle($scrollingStyle = null) + { + if ($scrollingStyle === null) { + $scrollingStyle = self::$_defaultScrollingStyle; + } + + switch (strtolower(gettype($scrollingStyle))) { + case 'object': + if (!$scrollingStyle instanceof Zend_Paginator_ScrollingStyle_Interface) { + /** + * @see Zend_View_Exception + */ + + throw new Zend_View_Exception('Scrolling style must implement ' . + 'Zend_Paginator_ScrollingStyle_Interface'); + } + + return $scrollingStyle; + + case 'string': + $className = self::getScrollingStyleLoader()->load($scrollingStyle); + + return new $className(); + + case 'null': + // Fall through to default case + + default: + /** + * @see Zend_View_Exception + */ + + throw new Zend_View_Exception('Scrolling style must be a class ' . + 'name or object implementing Zend_Paginator_ScrollingStyle_Interface'); + } + } +} |