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