37:         */
38:        public function offsetGet($key)
39:        {
40:            if (is_int($key)) {
41:                $arr = array_slice((array) $this, $key, 1);
42:                if (!$arr) {
43:                    throw new Nette\MemberAccessException("Cannot read an undeclared column '$key'.");
44:                }
45:                return current($arr);
46:            }
47:            return $this->$key;
48:        }
49:    
50:    
51:        /**

303:    
304:            if (!$block) {
305:                $hint = ($t = Latte\Helpers::getSuggestion($this->getBlockNames($layer), $name))
306:                    ? ", did you mean '$t'?"
307:                    : '.';
308:                $name = $layer ? "$layer $name" : $name;
309:                throw new Latte\RuntimeException("Cannot include undefined block '$name'$hint");
310:            }
311:    
312:            $this->filter(
313:                function () use ($block, $params): void { reset($block->functions)($params); },
314:                $mod,
315:                $block->contentType,
316:                "block $name"
317:            );

358:            $block->functions = array_merge($block->functions, $functions);
359:        }
360:    
361:    
362:        /**
363:         * @param  string|\Closure|null  $mod  content-type name or modifier closure
364:         */
365:        private function filter(callable $function, $mod, string $contentType, string $name): void
366:        {
367:            if ($mod === null || $mod === $contentType) {
368:                $function();
369:    
370:            } elseif ($mod instanceof \Closure) {
371:                echo $mod($this->capture($function), $contentType);
372:    

306:                    ? ", did you mean '$t'?"
307:                    : '.';
308:                $name = $layer ? "$layer $name" : $name;
309:                throw new Latte\RuntimeException("Cannot include undefined block '$name'$hint");
310:            }
311:    
312:            $this->filter(
313:                function () use ($block, $params): void { reset($block->functions)($params); },
314:                $mod,
315:                $block->contentType,
316:                "block $name"
317:            );
318:        }
319:    
320:    

187:            echo '">KONTAKT</a><span>&nbsp;</span></li>
188:                </ul>
189:            </div>
190:        </nav>
191:        ';
192:            $this->renderBlock('extraHeader', get_defined_vars()) /* line 85 */;
193:            echo '
194:    </div>
195:    
196:    ';
197:            $this->renderBlock('content', [], 'html') /* line 88 */;
198:            echo "\n";
199:            if ($isFb) /* line 90 */ {
200:                echo '<section id="uzivatele">
201:        <h3>

165:        /**
166:         * Renders template.
167:         * @internal
168:         */
169:        public function render(string $block = null): void
170:        {
171:            $level = ob_get_level();
172:            try {
173:                $this->prepare();
174:                if (!$this->doRender($block)) {
175:                    $this->main();
176:                }
177:    
178:            } catch (\Throwable $e) {
179:                while (ob_get_level() > $level) {

198:    
199:            if ($this->referenceType === 'import') {
200:                if ($this->parentName) {
201:                    throw new Latte\RuntimeException('Imported template cannot use {extends} or {layout}, use {import}');
202:                }
203:    
204:            } elseif ($this->parentName) { // extends
205:                ob_start(function () {});
206:                $this->params = $this->main();
207:                ob_end_clean();
208:                $this->createTemplate($this->parentName, $this->params, 'extends')->render($block);
209:    
210:            } elseif ($block !== null) { // single block rendering
211:                $this->renderBlock($block, $this->params);
212:    

164:    
165:        /**
166:         * Renders template.
167:         * @internal
168:         */
169:        public function render(string $block = null): void
170:        {
171:            $level = ob_get_level();
172:            try {
173:                $this->prepare();
174:                if (!$this->doRender($block)) {
175:                    $this->main();
176:                }
177:    
178:            } catch (\Throwable $e) {

 91:    
 92:        /**
 93:         * Renders template to output.
 94:         * @param  object|mixed[]  $params
 95:         */
 96:        public function render(string $name, $params = [], string $block = null): void
 97:        {
 98:            $template = $this->createTemplate($name, $this->processParams($params));
 99:            $template->global->coreCaptured = false;
100:            ($this->probe)($template);
101:            $template->render($block);
102:        }
103:    
104:    
105:        /**

36:            return $this->latte;
37:        }
38:    
39:    
40:        /**
41:         * Renders template to output.
42:         */
43:        public function render(string $file = null, array $params = []): void
44:        {
45:            Nette\Utils\Arrays::toObject($params, $this);
46:            $this->latte->render($file ?: $this->file, $this);
47:        }
48:    
49:    
50:        /**

40:            return $this->source;
41:        }
42:    
43:    
44:        /**
45:         * Sends response to output.
46:         */
47:        public function send(Nette\Http\IRequest $httpRequest, Nette\Http\IResponse $httpResponse): void
48:        {
49:            if ($this->source instanceof Nette\Application\UI\Template) {
50:                $this->source->render();
51:    
52:            } else {
53:                echo $this->source;
54:            }

159:            }
160:            Arrays::invoke($this->onPresenter, $this, $this->presenter);
161:            $response = $this->presenter->run(clone $request);
162:    
163:            if ($response instanceof Responses\ForwardResponse) {
164:                $request = $response->getRequest();
165:                goto process;
166:            }
167:    
168:            Arrays::invoke($this->onResponse, $this, $response);
169:            $response->send($this->httpRequest, $this->httpResponse);
170:        }
171:    
172:    
173:        public function processException(\Throwable $e): void

80:        }
81:    
82:    
83:        /**
84:         * Dispatch a HTTP request to a front controller.
85:         */
86:        public function run(): void
87:        {
88:            try {
89:                Arrays::invoke($this->onStartup, $this);
90:                $this->processRequest($this->createInitialRequest());
91:                Arrays::invoke($this->onShutdown, $this);
92:    
93:            } catch (\Throwable $e) {
94:                Arrays::invoke($this->onError, $this, $e);

 1:    <?php
 2:    
 3:    declare(strict_types=1);
 4:    
 5:    require __DIR__ . '/../vendor/autoload.php';
 6:    
 7:    App\Bootstrap::boot()
 8:        ->createContainer()
 9:        ->getByType(Nette\Application\Application::class)
10:        ->run();
11: