Packages

  • Nette
    • Application
      • Diagnostics
      • Responses
      • Routers
      • UI
    • Caching
      • Storages
    • ComponentModel
    • Config
      • Adapters
      • Extensions
    • Database
      • Diagnostics
      • Drivers
      • Reflection
      • Table
    • DI
      • Diagnostics
    • Diagnostics
    • Forms
      • Controls
      • Rendering
    • Http
    • Iterators
    • Latte
      • Macros
    • Loaders
    • Localization
    • Mail
    • Reflection
    • Security
      • Diagnostics
    • Templating
    • Utils
      • PhpGenerator
  • NetteModule
  • None
  • PHP

Classes

  • NAppForm
  • NControl
  • NMultiplier
  • NPresenter
  • NPresenterComponent

Interfaces

  • IRenderable
  • ISignalReceiver
  • IStatePersistent

Exceptions

  • NBadSignalException
  • NInvalidLinkException
  • Overview
  • Package
  • Class
  • Tree
  1: <?php
  2: 
  3: /**
  4:  * This file is part of the Nette Framework (http://nette.org)
  5:  *
  6:  * Copyright (c) 2004 David Grudl (http://davidgrudl.com)
  7:  *
  8:  * For the full copyright and license information, please view
  9:  * the file license.txt that was distributed with this source code.
 10:  * @package Nette\Application\UI
 11:  */
 12: 
 13: 
 14: 
 15: /**
 16:  * PresenterComponent is the base class for all Presenter components.
 17:  *
 18:  * Components are persistent objects located on a presenter. They have ability to own
 19:  * other child components, and interact with user. Components have properties
 20:  * for storing their status, and responds to user command.
 21:  *
 22:  * @author     David Grudl
 23:  *
 24:  * @property-read NPresenter $presenter
 25:  * @property-read string $uniqueId
 26:  * @package Nette\Application\UI
 27:  */
 28: abstract class NPresenterComponent extends NComponentContainer implements ISignalReceiver, IStatePersistent, ArrayAccess
 29: {
 30:     /** @var array */
 31:     protected $params = array();
 32: 
 33: 
 34: 
 35:     /**
 36:      */
 37:     public function __construct(IComponentContainer $parent = NULL, $name = NULL)
 38:     {
 39:         $this->monitor('NPresenter');
 40:         parent::__construct($parent, $name);
 41:     }
 42: 
 43: 
 44: 
 45:     /**
 46:      * Returns the presenter where this component belongs to.
 47:      * @param  bool   throw exception if presenter doesn't exist?
 48:      * @return NPresenter|NULL
 49:      */
 50:     public function getPresenter($need = TRUE)
 51:     {
 52:         return $this->lookup('NPresenter', $need);
 53:     }
 54: 
 55: 
 56: 
 57:     /**
 58:      * Returns a fully-qualified name that uniquely identifies the component
 59:      * within the presenter hierarchy.
 60:      * @return string
 61:      */
 62:     public function getUniqueId()
 63:     {
 64:         return $this->lookupPath('NPresenter', TRUE);
 65:     }
 66: 
 67: 
 68: 
 69:     /**
 70:      * This method will be called when the component (or component's parent)
 71:      * becomes attached to a monitored object. Do not call this method yourself.
 72:      * @param  IComponent
 73:      * @return void
 74:      */
 75:     protected function attached($presenter)
 76:     {
 77:         if ($presenter instanceof NPresenter) {
 78:             $this->loadState($presenter->popGlobalParameters($this->getUniqueId()));
 79:         }
 80:     }
 81: 
 82: 
 83: 
 84:     /**
 85:      * Calls public method if exists.
 86:      * @param  string
 87:      * @param  array
 88:      * @return bool  does method exist?
 89:      */
 90:     protected function tryCall($method, array $params)
 91:     {
 92:         $rc = $this->getReflection();
 93:         if ($rc->hasMethod($method)) {
 94:             $rm = $rc->getMethod($method);
 95:             if ($rm->isPublic() && !$rm->isAbstract() && !$rm->isStatic()) {
 96:                 $this->checkRequirements($rm);
 97:                 $rm->invokeArgs($this, $rc->combineArgs($rm, $params));
 98:                 return TRUE;
 99:             }
100:         }
101:         return FALSE;
102:     }
103: 
104: 
105: 
106:     /**
107:      * Checks for requirements such as authorization.
108:      * @return void
109:      */
110:     public function checkRequirements($element)
111:     {
112:     }
113: 
114: 
115: 
116:     /**
117:      * Access to reflection.
118:      * @return NPresenterComponentReflection
119:      */
120:     public function getReflection()
121:     {
122:         return new NPresenterComponentReflection($this);
123:     }
124: 
125: 
126: 
127:     /********************* interface IStatePersistent ****************d*g**/
128: 
129: 
130: 
131:     /**
132:      * Loads state informations.
133:      * @param  array
134:      * @return void
135:      */
136:     public function loadState(array $params)
137:     {
138:         foreach ($this->getReflection()->getPersistentParams() as $nm => $meta) {
139:             if (isset($params[$nm])) { // ignore NULL values
140:                 if (isset($meta['def'])) {
141:                     if (is_array($params[$nm]) && !is_array($meta['def'])) {
142:                         $params[$nm] = $meta['def']; // prevents array to scalar conversion
143:                     } else {
144:                         settype($params[$nm], gettype($meta['def']));
145:                     }
146:                 }
147:                 $this->$nm = & $params[$nm];
148:             } else {
149:                 $params[$nm] = & $this->$nm;
150:             }
151:         }
152:         $this->params = $params;
153:     }
154: 
155: 
156: 
157:     /**
158:      * Saves state informations for next request.
159:      * @param  array
160:      * @param  NPresenterComponentReflection (internal, used by Presenter)
161:      * @return void
162:      */
163:     public function saveState(array & $params, $reflection = NULL)
164:     {
165:         $reflection = $reflection === NULL ? $this->getReflection() : $reflection;
166:         foreach ($reflection->getPersistentParams() as $nm => $meta) {
167: 
168:             if (isset($params[$nm])) {
169:                 $val = $params[$nm]; // injected value
170: 
171:             } elseif (array_key_exists($nm, $params)) { // $params[$nm] === NULL
172:                 continue; // means skip
173: 
174:             } elseif (!isset($meta['since']) || $this instanceof $meta['since']) {
175:                 $val = $this->$nm; // object property value
176: 
177:             } else {
178:                 continue; // ignored parameter
179:             }
180: 
181:             if (is_object($val)) {
182:                 $class = get_class($this);
183:                 throw new InvalidStateException("Persistent parameter must be scalar or array, $class::\$$nm is " . gettype($val));
184: 
185:             } else {
186:                 if (isset($meta['def'])) {
187:                     settype($val, gettype($meta['def']));
188:                     if ($val === $meta['def']) {
189:                         $val = NULL;
190:                     }
191:                 } else {
192:                     if ((string) $val === '') {
193:                         $val = NULL;
194:                     }
195:                 }
196:                 $params[$nm] = $val;
197:             }
198:         }
199:     }
200: 
201: 
202: 
203:     /**
204:      * Returns component param.
205:      * If no key is passed, returns the entire array.
206:      * @param  string key
207:      * @param  mixed  default value
208:      * @return mixed
209:      */
210:     final public function getParameter($name = NULL, $default = NULL)
211:     {
212:         if (func_num_args() === 0) {
213:             return $this->params;
214: 
215:         } elseif (isset($this->params[$name])) {
216:             return $this->params[$name];
217: 
218:         } else {
219:             return $default;
220:         }
221:     }
222: 
223: 
224: 
225:     /**
226:      * Returns a fully-qualified name that uniquely identifies the parameter.
227:      * @return string
228:      */
229:     final public function getParameterId($name)
230:     {
231:         $uid = $this->getUniqueId();
232:         return $uid === '' ? $name : $uid . self::NAME_SEPARATOR . $name;
233:     }
234: 
235: 
236: 
237:     /** @deprecated */
238:     function getParam($name = NULL, $default = NULL)
239:     {
240:         //trigger_error(__METHOD__ . '() is deprecated; use getParameter() instead.', E_USER_WARNING);
241:         if (func_num_args() === 0) {
242:             return $this->params;
243:         } elseif (isset($this->params[$name])) {
244:             return $this->params[$name];
245:         } else {
246:             return $default;
247:         }
248:     }
249: 
250: 
251: 
252:     /** @deprecated */
253:     function getParamId($name)
254:     {
255:         trigger_error(__METHOD__ . '() is deprecated; use getParameterId() instead.', E_USER_WARNING);
256:         return $this->getParameterId($name);
257:     }
258: 
259: 
260: 
261:     /**
262:      * Returns array of classes persistent parameters. They have public visibility and are non-static.
263:      * This default implementation detects persistent parameters by annotation @persistent.
264:      * @return array
265:      */
266:     public static function getPersistentParams()
267:     {
268:         $arg = func_get_arg(0);
269:         $rc = new NClassReflection($arg);
270:         $params = array();
271:         foreach ($rc->getProperties(ReflectionProperty::IS_PUBLIC) as $rp) {
272:             if (!$rp->isStatic() && $rp->hasAnnotation('persistent')) {
273:                 $params[] = $rp->getName();
274:             }
275:         }
276:         return $params;
277:     }
278: 
279: 
280: 
281:     /********************* interface ISignalReceiver ****************d*g**/
282: 
283: 
284: 
285:     /**
286:      * Calls signal handler method.
287:      * @param  string
288:      * @return void
289:      * @throws NBadSignalException if there is not handler method
290:      */
291:     public function signalReceived($signal)
292:     {
293:         if (!$this->tryCall($this->formatSignalMethod($signal), $this->params)) {
294:             $class = get_class($this);
295:             throw new NBadSignalException("There is no handler for signal '$signal' in class $class.");
296:         }
297:     }
298: 
299: 
300: 
301:     /**
302:      * Formats signal handler method name -> case sensitivity doesn't matter.
303:      * @param  string
304:      * @return string
305:      */
306:     public function formatSignalMethod($signal)
307:     {
308:         return $signal == NULL ? NULL : 'handle' . $signal; // intentionally ==
309:     }
310: 
311: 
312: 
313:     /********************* navigation ****************d*g**/
314: 
315: 
316: 
317:     /**
318:      * Generates URL to presenter, action or signal.
319:      * @param  string   destination in format "[[module:]presenter:]action" or "signal!" or "this"
320:      * @param  array|mixed
321:      * @return string
322:      * @throws NInvalidLinkException
323:      */
324:     public function link($destination, $args = array())
325:     {
326:         if (!is_array($args)) {
327:             $args = func_get_args();
328:             array_shift($args);
329:         }
330: 
331:         try {
332:             return $this->getPresenter()->createRequest($this, $destination, $args, 'link');
333: 
334:         } catch (NInvalidLinkException $e) {
335:             return $this->getPresenter()->handleInvalidLink($e);
336:         }
337:     }
338: 
339: 
340: 
341:     /**
342:      * Returns destination as Link object.
343:      * @param  string   destination in format "[[module:]presenter:]view" or "signal!"
344:      * @param  array|mixed
345:      * @return NLink
346:      */
347:     public function lazyLink($destination, $args = array())
348:     {
349:         if (!is_array($args)) {
350:             $args = func_get_args();
351:             array_shift($args);
352:         }
353: 
354:         return new NLink($this, $destination, $args);
355:     }
356: 
357: 
358: 
359:     /**
360:      * Determines whether it links to the current page.
361:      * @param  string   destination in format "[[module:]presenter:]action" or "signal!" or "this"
362:      * @param  array|mixed
363:      * @return bool
364:      * @throws NInvalidLinkException
365:      */
366:     public function isLinkCurrent($destination = NULL, $args = array())
367:     {
368:         if ($destination !== NULL) {
369:             if (!is_array($args)) {
370:                 $args = func_get_args();
371:                 array_shift($args);
372:             }
373:             $this->link($destination, $args);
374:         }
375:         return $this->getPresenter()->getLastCreatedRequestFlag('current');
376:     }
377: 
378: 
379: 
380:     /**
381:      * Redirect to another presenter, action or signal.
382:      * @param  int      [optional] HTTP error code
383:      * @param  string   destination in format "[[module:]presenter:]view" or "signal!"
384:      * @param  array|mixed
385:      * @return void
386:      * @throws NAbortException
387:      */
388:     public function redirect($code, $destination = NULL, $args = array())
389:     {
390:         if (!is_numeric($code)) { // first parameter is optional
391:             $args = $destination;
392:             $destination = $code;
393:             $code = NULL;
394:         }
395: 
396:         if (!is_array($args)) {
397:             $args = func_get_args();
398:             if (is_numeric(array_shift($args))) {
399:                 array_shift($args);
400:             }
401:         }
402: 
403:         $presenter = $this->getPresenter();
404:         $presenter->redirectUrl($presenter->createRequest($this, $destination, $args, 'redirect'), $code);
405:     }
406: 
407: 
408: 
409:     /********************* interface ArrayAccess ****************d*g**/
410: 
411: 
412: 
413:     /**
414:      * Adds the component to the container.
415:      * @param  string  component name
416:      * @param  IComponent
417:      * @return void
418:      */
419:     final public function offsetSet($name, $component)
420:     {
421:         $this->addComponent($component, $name);
422:     }
423: 
424: 
425: 
426:     /**
427:      * Returns component specified by name. Throws exception if component doesn't exist.
428:      * @param  string  component name
429:      * @return IComponent
430:      * @throws InvalidArgumentException
431:      */
432:     final public function offsetGet($name)
433:     {
434:         return $this->getComponent($name, TRUE);
435:     }
436: 
437: 
438: 
439:     /**
440:      * Does component specified by name exists?
441:      * @param  string  component name
442:      * @return bool
443:      */
444:     final public function offsetExists($name)
445:     {
446:         return $this->getComponent($name, FALSE) !== NULL;
447:     }
448: 
449: 
450: 
451:     /**
452:      * Removes component from the container.
453:      * @param  string  component name
454:      * @return void
455:      */
456:     final public function offsetUnset($name)
457:     {
458:         $component = $this->getComponent($name, FALSE);
459:         if ($component !== NULL) {
460:             $this->removeComponent($component);
461:         }
462:     }
463: 
464: }
465: 
Nette Framework 2.0.0 (for PHP 5.2, prefixed) API API documentation generated by ApiGen 2.7.0