interface/modules/zend_modules/library/Zend/View/Helper/Navigation.php

   1 <?php
   2 /**
   3  * Zend Framework (http://framework.zend.com/)
   4  *
   5  * @link      http://github.com/zendframework/zf2 for the canonical source repository
   6  * @copyright Copyright (c) 2005-2013 Zend Technologies USA Inc. (http://www.zend.com)
   7  * @license   http://framework.zend.com/license/new-bsd New BSD License
   8  */
   9
  10 namespace Zend\View\Helper;
  11
  12 use Zend\Navigation\AbstractContainer;
  13 use Zend\ServiceManager\ServiceLocatorAwareInterface;
  14 use Zend\View\Exception;
  15 use Zend\View\Helper\Navigation\AbstractHelper as AbstractNavigationHelper;
  16 use Zend\View\Helper\Navigation\HelperInterface as NavigationHelper;
  17
  18 /**
  19  * Proxy helper for retrieving navigational helpers and forwarding calls
  20  */
  21 class Navigation extends AbstractNavigationHelper
  22 {
  23     /**
  24      * View helper namespace
  25      *
  26      * @var string
  27      */
  28     const NS = 'Zend\View\Helper\Navigation';
  29
  30     /**
  31      * Default proxy to use in {@link render()}
  32      *
  33      * @var string
  34      */
  35     protected $defaultProxy = 'menu';
  36
  37     /**
  38      * Indicates whether or not a given helper has been injected
  39      *
  40      * @var array
  41      */
  42     protected $injected = array();
  43
  44     /**
  45      * Whether ACL should be injected when proxying
  46      *
  47      * @var bool
  48      */
  49     protected $injectAcl = true;
  50
  51     /**
  52      * Whether container should be injected when proxying
  53      *
  54      * @var bool
  55      */
  56     protected $injectContainer = true;
  57
  58     /**
  59      * Whether translator should be injected when proxying
  60      *
  61      * @var bool
  62      */
  63     protected $injectTranslator = true;
  64
  65     /**
  66      * @var Navigation\PluginManager
  67      */
  68     protected $plugins;
  69
  70     /**
  71      * Helper entry point
  72      *
  73      * @param  string|AbstractContainer $container container to operate on
  74      * @return Navigation
  75      */
  76     public function __invoke($container = null)
  77     {
  78         if (null !== $container) {
  79             $this->setContainer($container);
  80         }
  81
  82         return $this;
  83     }
  84
  85     /**
  86      * Magic overload: Proxy to other navigation helpers or the container
  87      *
  88      * Examples of usage from a view script or layout:
  89      * <code>
  90      * // proxy to Menu helper and render container:
  91      * echo $this->navigation()->menu();
  92      *
  93      * // proxy to Breadcrumbs helper and set indentation:
  94      * $this->navigation()->breadcrumbs()->setIndent(8);
  95      *
  96      * // proxy to container and find all pages with 'blog' route:
  97      * $blogPages = $this->navigation()->findAllByRoute('blog');
  98      * </code>
  99      *
 100      * @param  string $method             helper name or method name in container
 101      * @param  array  $arguments          [optional] arguments to pass
 102      * @throws \Zend\View\Exception\ExceptionInterface        if proxying to a helper, and the
 103      *                                    helper is not an instance of the
 104      *                                    interface specified in
 105      *                                    {@link findHelper()}
 106      * @throws \Zend\Navigation\Exception\ExceptionInterface  if method does not exist in container
 107      * @return mixed                      returns what the proxied call returns
 108      */
 109     public function __call($method, array $arguments = array())
 110     {
 111         // check if call should proxy to another helper
 112         $helper = $this->findHelper($method, false);
 113         if ($helper) {
 114             if ($helper instanceof ServiceLocatorAwareInterface && $this->getServiceLocator()) {
 115                 $helper->setServiceLocator($this->getServiceLocator());
 116             }
 117             return call_user_func_array($helper, $arguments);
 118         }
 119
 120         // default behaviour: proxy call to container
 121         return parent::__call($method, $arguments);
 122     }
 123
 124     /**
 125      * Renders helper
 126      *
 127      * @param  AbstractContainer $container
 128      * @return string
 129      * @throws Exception\RuntimeException
 130      */
 131     public function render($container = null)
 132     {
 133         return $this->findHelper($this->getDefaultProxy())->render($container);
 134     }
 135
 136     /**
 137      * Returns the helper matching $proxy
 138      *
 139      * The helper must implement the interface
 140      * {@link Zend\View\Helper\Navigation\Helper}.
 141      *
 142      * @param string $proxy  helper name
 143      * @param bool   $strict [optional] whether exceptions should be
 144      *                                  thrown if something goes
 145      *                                  wrong. Default is true.
 146      * @throws Exception\RuntimeException if $strict is true and helper cannot be found
 147      * @return \Zend\View\Helper\Navigation\HelperInterface  helper instance
 148      */
 149     public function findHelper($proxy, $strict = true)
 150     {
 151         $plugins = $this->getPluginManager();
 152         if (!$plugins->has($proxy)) {
 153             if ($strict) {
 154                 throw new Exception\RuntimeException(sprintf(
 155                     'Failed to find plugin for %s',
 156                     $proxy
 157                 ));
 158             }
 159             return false;
 160         }
 161
 162         $helper    = $plugins->get($proxy);
 163         $container = $this->getContainer();
 164         $hash      = spl_object_hash($container) . spl_object_hash($helper);
 165
 166         if (!isset($this->injected[$hash])) {
 167             $helper->setContainer();
 168             $this->inject($helper);
 169             $this->injected[$hash] = true;
 170         } else {
 171             if ($this->getInjectContainer()) {
 172                 $helper->setContainer($container);
 173             }
 174         }
 175
 176         return $helper;
 177     }
 178
 179     /**
 180      * Injects container, ACL, and translator to the given $helper if this
 181      * helper is configured to do so
 182      *
 183      * @param  NavigationHelper $helper helper instance
 184      * @return void
 185      */
 186     protected function inject(NavigationHelper $helper)
 187     {
 188         if ($this->getInjectContainer() && !$helper->hasContainer()) {
 189             $helper->setContainer($this->getContainer());
 190         }
 191
 192         if ($this->getInjectAcl()) {
 193             if (!$helper->hasAcl()) {
 194                 $helper->setAcl($this->getAcl());
 195             }
 196             if (!$helper->hasRole()) {
 197                 $helper->setRole($this->getRole());
 198             }
 199         }
 200
 201         if ($this->getInjectTranslator() && !$helper->hasTranslator()) {
 202             $helper->setTranslator(
 203                 $this->getTranslator(), $this->getTranslatorTextDomain()
 204             );
 205         }
 206     }
 207
 208     /**
 209      * Sets the default proxy to use in {@link render()}
 210      *
 211      * @param  string $proxy default proxy
 212      * @return Navigation
 213      */
 214     public function setDefaultProxy($proxy)
 215     {
 216         $this->defaultProxy = (string) $proxy;
 217         return $this;
 218     }
 219
 220     /**
 221      * Returns the default proxy to use in {@link render()}
 222      *
 223      * @return string
 224      */
 225     public function getDefaultProxy()
 226     {
 227         return $this->defaultProxy;
 228     }
 229
 230     /**
 231      * Sets whether container should be injected when proxying
 232      *
 233      * @param  bool $injectContainer
 234      * @return Navigation
 235      */
 236     public function setInjectContainer($injectContainer = true)
 237     {
 238         $this->injectContainer = (bool) $injectContainer;
 239         return $this;
 240     }
 241
 242     /**
 243      * Returns whether container should be injected when proxying
 244      *
 245      * @return bool
 246      */
 247     public function getInjectContainer()
 248     {
 249         return $this->injectContainer;
 250     }
 251
 252     /**
 253      * Sets whether ACL should be injected when proxying
 254      *
 255      * @param  bool $injectAcl
 256      * @return Navigation
 257      */
 258     public function setInjectAcl($injectAcl = true)
 259     {
 260         $this->injectAcl = (bool) $injectAcl;
 261         return $this;
 262     }
 263
 264     /**
 265      * Returns whether ACL should be injected when proxying
 266      *
 267      * @return bool
 268      */
 269     public function getInjectAcl()
 270     {
 271         return $this->injectAcl;
 272     }
 273
 274     /**
 275      * Sets whether translator should be injected when proxying
 276      *
 277      * @param  bool $injectTranslator
 278      * @return Navigation
 279      */
 280     public function setInjectTranslator($injectTranslator = true)
 281     {
 282         $this->injectTranslator = (bool) $injectTranslator;
 283         return $this;
 284     }
 285
 286     /**
 287      * Returns whether translator should be injected when proxying
 288      *
 289      * @return bool
 290      */
 291     public function getInjectTranslator()
 292     {
 293         return $this->injectTranslator;
 294     }
 295
 296     /**
 297      * Set manager for retrieving navigation helpers
 298      *
 299      * @param  Navigation\PluginManager $plugins
 300      * @return Navigation
 301      */
 302     public function setPluginManager(Navigation\PluginManager $plugins)
 303     {
 304         $renderer = $this->getView();
 305         if ($renderer) {
 306             $plugins->setRenderer($renderer);
 307         }
 308         $this->plugins = $plugins;
 309
 310         return $this;
 311     }
 312
 313     /**
 314      * Retrieve plugin loader for navigation helpers
 315      *
 316      * Lazy-loads an instance of Navigation\HelperLoader if none currently
 317      * registered.
 318      *
 319      * @return Navigation\PluginManager
 320      */
 321     public function getPluginManager()
 322     {
 323         if (null === $this->plugins) {
 324             $this->setPluginManager(new Navigation\PluginManager());
 325         }
 326
 327         return $this->plugins;
 328     }
 329 }