1: <?php
  2: /**
  3:  * Magento
  4:  *
  5:  * NOTICE OF LICENSE
  6:  *
  7:  * This source file is subject to the Open Software License (OSL 3.0)
  8:  * that is bundled with this package in the file LICENSE.txt.
  9:  * It is also available through the world-wide-web at this URL:
 10:  * http://opensource.org/licenses/osl-3.0.php
 11:  * If you did not receive a copy of the license and are unable to
 12:  * obtain it through the world-wide-web, please send an email
 13:  * to license@magentocommerce.com so we can send you a copy immediately.
 14:  *
 15:  * DISCLAIMER
 16:  *
 17:  * Do not edit or add to this file if you wish to upgrade Magento to newer
 18:  * versions in the future. If you wish to customize Magento for your
 19:  * needs please refer to http://www.magentocommerce.com for more information.
 20:  *
 21:  * @category    Mage
 22:  * @package     Mage_Catalog
 23:  * @copyright   Copyright (c) 2012 Magento Inc. (http://www.magentocommerce.com)
 24:  * @license     http://opensource.org/licenses/osl-3.0.php  Open Software License (OSL 3.0)
 25:  */
 26: 
 27: 
 28: /**
 29:  * Product list toolbar
 30:  *
 31:  * @category    Mage
 32:  * @package     Mage_Catalog
 33:  * @author      Magento Core Team <core@magentocommerce.com>
 34:  */
 35: class Mage_Catalog_Block_Product_List_Toolbar extends Mage_Core_Block_Template
 36: {
 37:     /**
 38:      * Products collection
 39:      *
 40:      * @var Mage_Core_Model_Mysql4_Collection_Abstract
 41:      */
 42:     protected $_collection = null;
 43: 
 44:     /**
 45:      * GET parameter page variable
 46:      *
 47:      * @var string
 48:      */
 49:     protected $_pageVarName     = 'p';
 50: 
 51:     /**
 52:      * GET parameter order variable
 53:      *
 54:      * @var string
 55:      */
 56:     protected $_orderVarName        = 'order';
 57: 
 58:     /**
 59:      * GET parameter direction variable
 60:      *
 61:      * @var string
 62:      */
 63:     protected $_directionVarName    = 'dir';
 64: 
 65:     /**
 66:      * GET parameter mode variable
 67:      *
 68:      * @var string
 69:      */
 70:     protected $_modeVarName         = 'mode';
 71: 
 72:     /**
 73:      * GET parameter limit variable
 74:      *
 75:      * @var string
 76:      */
 77:     protected $_limitVarName        = 'limit';
 78: 
 79:     /**
 80:      * List of available order fields
 81:      *
 82:      * @var array
 83:      */
 84:     protected $_availableOrder      = array();
 85: 
 86:     /**
 87:      * List of available view types
 88:      *
 89:      * @var string
 90:      */
 91:     protected $_availableMode       = array();
 92: 
 93:     /**
 94:      * Is enable View switcher
 95:      *
 96:      * @var bool
 97:      */
 98:     protected $_enableViewSwitcher  = true;
 99: 
100:     /**
101:      * Is Expanded
102:      *
103:      * @var bool
104:      */
105:     protected $_isExpanded          = true;
106: 
107:     /**
108:      * Default Order field
109:      *
110:      * @var string
111:      */
112:     protected $_orderField          = null;
113: 
114:     /**
115:      * Default direction
116:      *
117:      * @var string
118:      */
119:     protected $_direction           = 'asc';
120: 
121:     /**
122:      * Default View mode
123:      *
124:      * @var string
125:      */
126:     protected $_viewMode            = null;
127: 
128:     /**
129:      * Available page limits for different list modes
130:      *
131:      * @var array
132:      */
133:     protected $_availableLimit  = array();
134: 
135:     /**
136:      * Default limits per page
137:      *
138:      * @var array
139:      */
140:     protected $_defaultAvailableLimit  = array(10=>10,20=>20,50=>50);
141: 
142:     /**
143:      * @var bool $_paramsMemorizeAllowed
144:      */
145:     protected $_paramsMemorizeAllowed = true;
146: 
147:     /**
148:      * Retrieve Catalog Config object
149:      *
150:      * @return Mage_Catalog_Model_Config
151:      */
152:     protected function _getConfig()
153:     {
154:         return Mage::getSingleton('catalog/config');
155:     }
156: 
157:     /**
158:      * Init Toolbar
159:      *
160:      */
161:     protected function _construct()
162:     {
163:         parent::_construct();
164:         $this->_orderField  = Mage::getStoreConfig(
165:             Mage_Catalog_Model_Config::XML_PATH_LIST_DEFAULT_SORT_BY
166:         );
167: 
168:         $this->_availableOrder = $this->_getConfig()->getAttributeUsedForSortByArray();
169: 
170:         switch (Mage::getStoreConfig('catalog/frontend/list_mode')) {
171:             case 'grid':
172:                 $this->_availableMode = array('grid' => $this->__('Grid'));
173:                 break;
174: 
175:             case 'list':
176:                 $this->_availableMode = array('list' => $this->__('List'));
177:                 break;
178: 
179:             case 'grid-list':
180:                 $this->_availableMode = array('grid' => $this->__('Grid'), 'list' =>  $this->__('List'));
181:                 break;
182: 
183:             case 'list-grid':
184:                 $this->_availableMode = array('list' => $this->__('List'), 'grid' => $this->__('Grid'));
185:                 break;
186:         }
187:         $this->setTemplate('catalog/product/list/toolbar.phtml');
188:     }
189: 
190:     /**
191:      * Disable list state params memorizing
192:      */
193:     public function disableParamsMemorizing()
194:     {
195:         $this->_paramsMemorizeAllowed = false;
196:         return $this;
197:     }
198: 
199:     /**
200:      * Memorize parameter value for session
201:      *
202:      * @param string $param parameter name
203:      * @param mixed $value parameter value
204:      * @return Mage_Catalog_Block_Product_List_Toolbar
205:      */
206:     protected function _memorizeParam($param, $value)
207:     {
208:         $session = Mage::getSingleton('catalog/session');
209:         if ($this->_paramsMemorizeAllowed && !$session->getParamsMemorizeDisabled()) {
210:             $session->setData($param, $value);
211:         }
212:         return $this;
213:     }
214: 
215:     /**
216:      * Set collection to pager
217:      *
218:      * @param Varien_Data_Collection $collection
219:      * @return Mage_Catalog_Block_Product_List_Toolbar
220:      */
221:     public function setCollection($collection)
222:     {
223:         $this->_collection = $collection;
224: 
225:         $this->_collection->setCurPage($this->getCurrentPage());
226: 
227:         // we need to set pagination only if passed value integer and more that 0
228:         $limit = (int)$this->getLimit();
229:         if ($limit) {
230:             $this->_collection->setPageSize($limit);
231:         }
232:         if ($this->getCurrentOrder()) {
233:             $this->_collection->setOrder($this->getCurrentOrder(), $this->getCurrentDirection());
234:         }
235:         return $this;
236:     }
237: 
238:     /**
239:      * Return products collection instance
240:      *
241:      * @return Mage_Core_Model_Mysql4_Collection_Abstract
242:      */
243:     public function getCollection()
244:     {
245:         return $this->_collection;
246:     }
247: 
248:     /**
249:      * Getter for $_pageVarName
250:      *
251:      * @return string
252:      */
253:     public function getPageVarName()
254:     {
255:         return $this->_pageVarName;
256:     }
257: 
258:     /**
259:      * Retrieve order field GET var name
260:      *
261:      * @return string
262:      */
263:     public function getOrderVarName()
264:     {
265:         return $this->_orderVarName;
266:     }
267: 
268:     /**
269:      * Retrieve sort direction GET var name
270:      *
271:      * @return string
272:      */
273:     public function getDirectionVarName()
274:     {
275:         return $this->_directionVarName;
276:     }
277: 
278:     /**
279:      * Retrieve view mode GET var name
280:      *
281:      * @return string
282:      */
283:     public function getModeVarName()
284:     {
285:         return $this->_modeVarName;
286:     }
287: 
288:     /**
289:      * Getter for $_limitVarName
290:      *
291:      * @return string
292:      */
293:     public function getLimitVarName()
294:     {
295:         return $this->_limitVarName;
296:     }
297: 
298:     /**
299:      * Return current page from request
300:      *
301:      * @return int
302:      */
303:     public function getCurrentPage()
304:     {
305:         if ($page = (int) $this->getRequest()->getParam($this->getPageVarName())) {
306:             return $page;
307:         }
308:         return 1;
309:     }
310: 
311:     /**
312:      * Get grit products sort order field
313:      *
314:      * @return string
315:      */
316:     public function getCurrentOrder()
317:     {
318:         $order = $this->_getData('_current_grid_order');
319:         if ($order) {
320:             return $order;
321:         }
322: 
323:         $orders = $this->getAvailableOrders();
324:         $defaultOrder = $this->_orderField;
325: 
326:         if (!isset($orders[$defaultOrder])) {
327:             $keys = array_keys($orders);
328:             $defaultOrder = $keys[0];
329:         }
330: 
331:         $order = $this->getRequest()->getParam($this->getOrderVarName());
332:         if ($order && isset($orders[$order])) {
333:             if ($order == $defaultOrder) {
334:                 Mage::getSingleton('catalog/session')->unsSortOrder();
335:             } else {
336:                 $this->_memorizeParam('sort_order', $order);
337:             }
338:         } else {
339:             $order = Mage::getSingleton('catalog/session')->getSortOrder();
340:         }
341:         // validate session value
342:         if (!$order || !isset($orders[$order])) {
343:             $order = $defaultOrder;
344:         }
345:         $this->setData('_current_grid_order', $order);
346:         return $order;
347:     }
348: 
349:     /**
350:      * Retrieve current direction
351:      *
352:      * @return string
353:      */
354:     public function getCurrentDirection()
355:     {
356:         $dir = $this->_getData('_current_grid_direction');
357:         if ($dir) {
358:             return $dir;
359:         }
360: 
361:         $directions = array('asc', 'desc');
362:         $dir = strtolower($this->getRequest()->getParam($this->getDirectionVarName()));
363:         if ($dir && in_array($dir, $directions)) {
364:             if ($dir == $this->_direction) {
365:                 Mage::getSingleton('catalog/session')->unsSortDirection();
366:             } else {
367:                 $this->_memorizeParam('sort_direction', $dir);
368:             }
369:         } else {
370:             $dir = Mage::getSingleton('catalog/session')->getSortDirection();
371:         }
372:         // validate direction
373:         if (!$dir || !in_array($dir, $directions)) {
374:             $dir = $this->_direction;
375:         }
376:         $this->setData('_current_grid_direction', $dir);
377:         return $dir;
378:     }
379: 
380:     /**
381:      * Set default Order field
382:      *
383:      * @param string $field
384:      * @return Mage_Catalog_Block_Product_List_Toolbar
385:      */
386:     public function setDefaultOrder($field)
387:     {
388:         if (isset($this->_availableOrder[$field])) {
389:             $this->_orderField = $field;
390:         }
391:         return $this;
392:     }
393: 
394:     /**
395:      * Set default sort direction
396:      *
397:      * @param string $dir
398:      * @return Mage_Catalog_Block_Product_List_Toolbar
399:      */
400:     public function setDefaultDirection($dir)
401:     {
402:         if (in_array(strtolower($dir), array('asc', 'desc'))) {
403:             $this->_direction = strtolower($dir);
404:         }
405:         return $this;
406:     }
407: 
408:     /**
409:      * Retrieve available Order fields list
410:      *
411:      * @return array
412:      */
413:     public function getAvailableOrders()
414:     {
415:         return $this->_availableOrder;
416:     }
417: 
418:     /**
419:      * Set Available order fields list
420:      *
421:      * @param array $orders
422:      * @return Mage_Catalog_Block_Product_List_Toolbar
423:      */
424:     public function setAvailableOrders($orders)
425:     {
426:         $this->_availableOrder = $orders;
427:         return $this;
428:     }
429: 
430:     /**
431:      * Add order to available orders
432:      *
433:      * @param string $order
434:      * @param string $value
435:      * @return Mage_Catalog_Block_Product_List_Toolbar
436:      */
437:     public function addOrderToAvailableOrders($order, $value)
438:     {
439:         $this->_availableOrder[$order] = $value;
440:         return $this;
441:     }
442:     /**
443:      * Remove order from available orders if exists
444:      *
445:      * @param string $order
446:      * @param Mage_Catalog_Block_Product_List_Toolbar
447:      */
448:     public function removeOrderFromAvailableOrders($order)
449:     {
450:         if (isset($this->_availableOrder[$order])) {
451:             unset($this->_availableOrder[$order]);
452:         }
453:         return $this;
454:     }
455: 
456:     /**
457:      * Compare defined order field vith current order field
458:      *
459:      * @param string $order
460:      * @return bool
461:      */
462:     public function isOrderCurrent($order)
463:     {
464:         return ($order == $this->getCurrentOrder());
465:     }
466: 
467:     /**
468:      * Retrieve Pager URL
469:      *
470:      * @param string $order
471:      * @param string $direction
472:      * @return string
473:      */
474:     public function getOrderUrl($order, $direction)
475:     {
476:         if (is_null($order)) {
477:             $order = $this->getCurrentOrder() ? $this->getCurrentOrder() : $this->_availableOrder[0];
478:         }
479:         return $this->getPagerUrl(array(
480:             $this->getOrderVarName()=>$order,
481:             $this->getDirectionVarName()=>$direction,
482:             $this->getPageVarName() => null
483:         ));
484:     }
485: 
486:     /**
487:      * Return current URL with rewrites and additional parameters
488:      *
489:      * @param array $params Query parameters
490:      * @return string
491:      */
492:     public function getPagerUrl($params=array())
493:     {
494:         $urlParams = array();
495:         $urlParams['_current']  = true;
496:         $urlParams['_escape']   = true;
497:         $urlParams['_use_rewrite']   = true;
498:         $urlParams['_query']    = $params;
499:         return $this->getUrl('*/*/*', $urlParams);
500:     }
501: 
502:     /**
503:      * Retrieve current View mode
504:      *
505:      * @return string
506:      */
507:     public function getCurrentMode()
508:     {
509:         $mode = $this->_getData('_current_grid_mode');
510:         if ($mode) {
511:             return $mode;
512:         }
513:         $modes = array_keys($this->_availableMode);
514:         $defaultMode = current($modes);
515:         $mode = $this->getRequest()->getParam($this->getModeVarName());
516:         if ($mode) {
517:             if ($mode == $defaultMode) {
518:                 Mage::getSingleton('catalog/session')->unsDisplayMode();
519:             } else {
520:                 $this->_memorizeParam('display_mode', $mode);
521:             }
522:         } else {
523:             $mode = Mage::getSingleton('catalog/session')->getDisplayMode();
524:         }
525: 
526:         if (!$mode || !isset($this->_availableMode[$mode])) {
527:             $mode = $defaultMode;
528:         }
529:         $this->setData('_current_grid_mode', $mode);
530:         return $mode;
531:     }
532: 
533:     /**
534:      * Compare defined view mode with current active mode
535:      *
536:      * @param string $mode
537:      * @return bool
538:      */
539:     public function isModeActive($mode)
540:     {
541:         return $this->getCurrentMode() == $mode;
542:     }
543: 
544:     /**
545:      * Retrieve availables view modes
546:      *
547:      * @return array
548:      */
549:     public function getModes()
550:     {
551:         return $this->_availableMode;
552:     }
553: 
554:     /**
555:      * Set available view modes list
556:      *
557:      * @param array $modes
558:      * @return Mage_Catalog_Block_Product_List_Toolbar
559:      */
560:     public function setModes($modes)
561:     {
562:         if(!isset($this->_availableMode)){
563:             $this->_availableMode = $modes;
564:         }
565:         return $this;
566:     }
567: 
568:     /**
569:      * Retrive URL for view mode
570:      *
571:      * @param string $mode
572:      * @return string
573:      */
574:     public function getModeUrl($mode)
575:     {
576:         return $this->getPagerUrl( array($this->getModeVarName()=>$mode, $this->getPageVarName() => null) );
577:     }
578: 
579:     /**
580:      * Disable view switcher
581:      *
582:      * @return Mage_Catalog_Block_Product_List_Toolbar
583:      */
584:     public function disableViewSwitcher()
585:     {
586:         $this->_enableViewSwitcher = false;
587:         return $this;
588:     }
589: 
590:     /**
591:      * Enable view switcher
592:      *
593:      * @return Mage_Catalog_Block_Product_List_Toolbar
594:      */
595:     public function enableViewSwitcher()
596:     {
597:         $this->_enableViewSwitcher = true;
598:         return $this;
599:     }
600: 
601:     /**
602:      * Is a enabled view switcher
603:      *
604:      * @return bool
605:      */
606:     public function isEnabledViewSwitcher()
607:     {
608:         return $this->_enableViewSwitcher;
609:     }
610: 
611:     /**
612:      * Disable Expanded
613:      *
614:      * @return Mage_Catalog_Block_Product_List_Toolbar
615:      */
616:     public function disableExpanded()
617:     {
618:         $this->_isExpanded = false;
619:         return $this;
620:     }
621: 
622:     /**
623:      * Enable Expanded
624:      *
625:      * @return Mage_Catalog_Block_Product_List_Toolbar
626:      */
627:     public function enableExpanded()
628:     {
629:         $this->_isExpanded = true;
630:         return $this;
631:     }
632: 
633:     /**
634:      * Check is Expanded
635:      *
636:      * @return bool
637:      */
638:     public function isExpanded()
639:     {
640:         return $this->_isExpanded;
641:     }
642: 
643:     /**
644:      * Retrieve default per page values
645:      *
646:      * @return string (comma separated)
647:      */
648:     public function getDefaultPerPageValue()
649:     {
650:         if ($this->getCurrentMode() == 'list') {
651:             if ($default = $this->getDefaultListPerPage()) {
652:                 return $default;
653:             }
654:             return Mage::getStoreConfig('catalog/frontend/list_per_page');
655:         }
656:         elseif ($this->getCurrentMode() == 'grid') {
657:             if ($default = $this->getDefaultGridPerPage()) {
658:                 return $default;
659:             }
660:             return Mage::getStoreConfig('catalog/frontend/grid_per_page');
661:         }
662:         return 0;
663:     }
664: 
665:     /**
666:      * Add new limit to pager for mode
667:      *
668:      * @param string $mode
669:      * @param string $value
670:      * @param string $label
671:      * @return Mage_Catalog_Block_Product_List_Toolbar
672:      */
673:     public function addPagerLimit($mode, $value, $label='')
674:     {
675:         if (!isset($this->_availableLimit[$mode])) {
676:             $this->_availableLimit[$mode] = array();
677:         }
678:         $this->_availableLimit[$mode][$value] = empty($label) ? $value : $label;
679:         return $this;
680:     }
681: 
682:     /**
683:      * Retrieve available limits for current view mode
684:      *
685:      * @return array
686:      */
687:     public function getAvailableLimit()
688:     {
689:         $currentMode = $this->getCurrentMode();
690:         if (in_array($currentMode, array('list', 'grid'))) {
691:             return $this->_getAvailableLimit($currentMode);
692:         } else {
693:             return $this->_defaultAvailableLimit;
694:         }
695:     }
696: 
697:     /**
698:      * Retrieve available limits for specified view mode
699:      *
700:      * @return array
701:      */
702:     protected function _getAvailableLimit($mode)
703:     {
704:         if (isset($this->_availableLimit[$mode])) {
705:             return $this->_availableLimit[$mode];
706:         }
707:         $perPageConfigKey = 'catalog/frontend/' . $mode . '_per_page_values';
708:         $perPageValues = (string)Mage::getStoreConfig($perPageConfigKey);
709:         $perPageValues = explode(',', $perPageValues);
710:         $perPageValues = array_combine($perPageValues, $perPageValues);
711:         if (Mage::getStoreConfigFlag('catalog/frontend/list_allow_all')) {
712:             return ($perPageValues + array('all'=>$this->__('All')));
713:         } else {
714:             return $perPageValues;
715:         }
716:     }
717: 
718:     /**
719:      * Get specified products limit display per page
720:      *
721:      * @return string
722:      */
723:     public function getLimit()
724:     {
725:         $limit = $this->_getData('_current_limit');
726:         if ($limit) {
727:             return $limit;
728:         }
729: 
730:         $limits = $this->getAvailableLimit();
731:         $defaultLimit = $this->getDefaultPerPageValue();
732:         if (!$defaultLimit || !isset($limits[$defaultLimit])) {
733:             $keys = array_keys($limits);
734:             $defaultLimit = $keys[0];
735:         }
736: 
737:         $limit = $this->getRequest()->getParam($this->getLimitVarName());
738:         if ($limit && isset($limits[$limit])) {
739:             if ($limit == $defaultLimit) {
740:                 Mage::getSingleton('catalog/session')->unsLimitPage();
741:             } else {
742:                 $this->_memorizeParam('limit_page', $limit);
743:             }
744:         } else {
745:             $limit = Mage::getSingleton('catalog/session')->getLimitPage();
746:         }
747:         if (!$limit || !isset($limits[$limit])) {
748:             $limit = $defaultLimit;
749:         }
750: 
751:         $this->setData('_current_limit', $limit);
752:         return $limit;
753:     }
754: 
755:     /**
756:      * Retrieve Limit Pager URL
757:      *
758:      * @param int $limit
759:      * @return string
760:      */
761:     public function getLimitUrl($limit)
762:     {
763:         return $this->getPagerUrl(array(
764:             $this->getLimitVarName() => $limit,
765:             $this->getPageVarName() => null
766:         ));
767:     }
768: 
769:     public function isLimitCurrent($limit)
770:     {
771:         return $limit == $this->getLimit();
772:     }
773: 
774:     public function getFirstNum()
775:     {
776:         $collection = $this->getCollection();
777:         return $collection->getPageSize()*($collection->getCurPage()-1)+1;
778:     }
779: 
780:     public function getLastNum()
781:     {
782:         $collection = $this->getCollection();
783:         return $collection->getPageSize()*($collection->getCurPage()-1)+$collection->count();
784:     }
785: 
786:     public function getTotalNum()
787:     {
788:         return $this->getCollection()->getSize();
789:     }
790: 
791:     public function isFirstPage()
792:     {
793:         return $this->getCollection()->getCurPage() == 1;
794:     }
795: 
796:     public function getLastPageNum()
797:     {
798:         return $this->getCollection()->getLastPageNumber();
799:     }
800: 
801:     /**
802:      * Render pagination HTML
803:      *
804:      * @return string
805:      */
806:     public function getPagerHtml()
807:     {
808:         $pagerBlock = $this->getChild('product_list_toolbar_pager');
809: 
810:         if ($pagerBlock instanceof Varien_Object) {
811: 
812:             /* @var $pagerBlock Mage_Page_Block_Html_Pager */
813:             $pagerBlock->setAvailableLimit($this->getAvailableLimit());
814: 
815:             $pagerBlock->setUseContainer(false)
816:                 ->setShowPerPage(false)
817:                 ->setShowAmounts(false)
818:                 ->setLimitVarName($this->getLimitVarName())
819:                 ->setPageVarName($this->getPageVarName())
820:                 ->setLimit($this->getLimit())
821:                 ->setFrameLength(Mage::getStoreConfig('design/pagination/pagination_frame'))
822:                 ->setJump(Mage::getStoreConfig('design/pagination/pagination_frame_skip'))
823:                 ->setCollection($this->getCollection());
824: 
825:             return $pagerBlock->toHtml();
826:         }
827: 
828:         return '';
829:     }
830: }
831: