No se encontró la página

 11747    function _imageError($file, $firsttime, $msg) 
 11748    { 
 11749        // Save re-trying image URL's which have already failed 
 11750        $this->failedimages[$file] = true; 
 11751        if ($firsttime && ($this->showImageErrors || $this->debug)) { 
 11752            throw new MpdfException("IMAGE Error (" . $file . "): " . $msg); 
 11753        } 
 11754        return false; 
 11755    } 
 11756 
 11757    function _getImage(&$file, $firsttime = true, $allowvector = true, $orig_srcpath = false, $interpolation = false) 

 11826                    $type = $this->_imageTypeFromString($data); 
 11827                } 
 11828            } 
 11829        } 
 11830        if (!$data) { 
 11831            return $this->_imageError($file, $firsttime, 'Could not find image file'); 
 11832        } 
 11833        if (empty($type)) { 
 11834            $type = $this->_imageTypeFromString($data); 
 11835        } 
 11836        if (($type == 'wmf' || $type == 'svg') && !$allowvector) { 

 3266                        } 
 3267                        $info['interpolation'] = $interpolation; 
 3268                    } 
 3269 
 3270                    // Image file 
 3271                    $info = $this->mpdf->_getImage($srcpath, true, true, $orig_srcpath, $interpolation); // mPDF 6 
 3272                    if (!$info) { 
 3273                        $info = $this->mpdf->_getImage($this->mpdf->noImageFile); 
 3274                        if ($info) { 
 3275                            $srcpath = $this->mpdf->noImageFile; 
 3276                            $w = ($info['w'] * (25.4 / $this->mpdf->dpi)); 

 16538                                    $attr[strtoupper($a3[1])] = trim($a3[2]); 
 16539                                } 
 16540                            } 
 16541                        } 
 16542                    } 
 16543                    $this->tag->OpenTag($tag, $attr, $a, $i); // mPDF 6 
 16544                    /* -- CSS-POSITION -- */ 
 16545                    if ($this->inFixedPosBlock) { 
 16546                        $this->fixedPosBlockBBox = array($tag, $attr, $this->x, $this->y); 
 16547                        $this->fixedPosBlock = ''; 
 16548                        $this->fixedPosBlockDepth = 1; 

 210 
 211        // Descripció 
 212        $content .= '<h3 style="">'.WebStrings::t('LABEL_DESCRIPTION','web').'</h3>' 
 213        .$model->translate('description'); 
 214 
 215        $this->WriteHTML($content); 
 216    } 
 217} 
 218 
 219 

 96             // Footer 
 97             $mpdf->setAutoBottomMargin = 'stretch'; 
 98             $mpdf->put_footer($title); 
 99  
 100            // Content 
 101            $mpdf->put_content($model,'route'); 
 102 
 103            $folder = LITHIUM_APP_PATH.'/resources/pdfs/'; 
 104 
 105            if (!is_dir($folder)) { 
 106                mkdir($folder,0777,true); 

 694            exit(); 
 695        } 
 696 
 697        // Generem pdf segons model, ens torna l'arxiu 
 698        if ($model === 'routes') { 
 699            $output_file = WebUtils::create_route_pdf($id); 
 700        } elseif ($model === 'empreses') { 
 701            $output_file = WebUtils::create_empresa_pdf($id); 
 702        } 
 703 
 704        // Si tenim arxiu el mostrem 

 172     * @return mixed  Returns the result of the method call 
 173     */ 
 174    public function invokeMethod($method, $params = array()) { 
 175        switch (count($params)) { 
 176            case 0: 
 177                return $this->{$method}(); 
 178            case 1: 
 179                return $this->{$method}($params[0]); 
 180            case 2: 
 181                return $this->{$method}($params[0], $params[1]); 
 182            case 3: 

 207            if (!method_exists($self, $action)) { 
 208                throw new DispatchException("Action `{$action}` not found."); 
 209            } 
 210            $render['template'] = $render['template'] ?: $action; 
 211 
 212            if ($result = $self->invokeMethod($action, $args)) { 
 213                if (is_string($result)) { 
 214                    $self->render(array('text' => $result)); 
 215                    return $self->response; 
 216                } 
 217                if (is_array($result)) { 

 258     */ 
 259    protected function _filter($method, $params, $callback, $filters = array()) { 
 260        list($class, $method) = explode('::', $method); 
 261 
 262        if (empty($this->_methodFilters[$method]) && empty($filters)) { 
 263            return $callback($this, $params, null); 
 264        } 
 265 
 266        $f = isset($this->_methodFilters[$method]) ? $this->_methodFilters[$method] : array(); 
 267        $data = array_merge($f, $filters, array($callback)); 
 268        return Filters::run($this, $params, compact('data', 'class', 'method')); 

 221 
 222            if (!$render['hasRendered'] && $render['auto']) { 
 223                $self->render(); 
 224            } 
 225            return $self->response; 
 226        }); 
 227    } 
 228 
 229    /** 
 230     * This method is used to pass along any data from the controller to the view and layout 
 231     * 

 269     */ 
 270    protected static function _call($callable, $request, $params) { 
 271        $params = compact('callable', 'request', 'params'); 
 272        return static::_filter(__FUNCTION__, $params, function($self, $params) { 
 273            if (is_callable($callable = $params['callable'])) { 
 274                return $callable($params['request'], $params['params']); 
 275            } 
 276            throw new DispatchException('Result not callable.'); 
 277        }); 
 278    } 
 279} 

 135    protected static function _filter($method, $params, $callback, $filters = array()) { 
 136        $class = get_called_class(); 
 137        $hasNoFilters = empty(static::$_methodFilters[$class][$method]); 
 138 
 139        if ($hasNoFilters && !$filters && !Filters::hasApplied($class, $method)) { 
 140            return $callback($class, $params, null); 
 141        } 
 142        if (!isset(static::$_methodFilters[$class][$method])) { 
 143            static::$_methodFilters += array($class => array()); 
 144            static::$_methodFilters[$class][$method] = array(); 
 145        } 

 272        return static::_filter(__FUNCTION__, $params, function($self, $params) { 
 273            if (is_callable($callable = $params['callable'])) { 
 274                return $callable($params['request'], $params['params']); 
 275            } 
 276            throw new DispatchException('Result not callable.'); 
 277        }); 
 278    } 
 279} 
 280 
 281 

 79             case 1: 
 80                 return static::$method($params[0]); 
 81             case 2: 
 82                 return static::$method($params[0], $params[1]); 
 83             case 3: 
 84                 return static::$method($params[0], $params[1], $params[2]); 
 85             case 4: 
 86                 return static::$method($params[0], $params[1], $params[2], $params[3]); 
 87             case 5: 
 88                 return static::$method($params[0], $params[1], $params[2], $params[3], $params[4]); 
 89             default: 

 161 
 162            if (!$params) { 
 163                throw new DispatchException('Could not route request.'); 
 164            } 
 165            $callable = $self::invokeMethod('_callable', array($result, $params, $options)); 
 166            return $self::invokeMethod('_call', array($callable, $result, $params)); 
 167        }); 
 168    } 
 169 
 170    /** 
 171     * Attempts to apply a set of formatting rules from `$_rules` to a `$params` array, where each 

 201    public function next($self, $params, $chain) { 
 202        if (empty($self) || empty($chain)) { 
 203            return parent::next(); 
 204        } 
 205        $next = parent::next(); 
 206        return $next($self, $params, $chain); 
 207    } 
 208 
 209    /** 
 210     * Gets the method name associated with this filter chain.  This is the method being filtered. 
 211     * 

 243        $wrap = static::$_exceptionHandler; 
 244        $_self = get_called_class(); 
 245 
 246        $filter = function($self, $params, $chain) use ($_self, $conditions, $handler, $wrap) { 
 247            try { 
 248                return $chain->next($self, $params, $chain); 
 249            } catch (Exception $e) { 
 250                if (!$_self::matches($e, $conditions)) { 
 251                    throw $e; 
 252                } 
 253                return $handler($wrap($e, true), $params); 

 201    public function next($self, $params, $chain) { 
 202        if (empty($self) || empty($chain)) { 
 203            return parent::next(); 
 204        } 
 205        $next = parent::next(); 
 206        return $next($self, $params, $chain); 
 207    } 
 208 
 209    /** 
 210     * Gets the method name associated with this filter chain.  This is the method being filtered. 
 211     * 

 140        $file = "{$config['path']}/config/routes.php"; 
 141        file_exists($file) ? call_user_func(function() use ($file) { include $file; }) : null; 
 142    } 
 143 
 144 
 145    return $chain->next($self, $params, $chain); 
 146}); 
 147 

 201    public function next($self, $params, $chain) { 
 202        if (empty($self) || empty($chain)) { 
 203            return parent::next(); 
 204        } 
 205        $next = parent::next(); 
 206        return $next($self, $params, $chain); 
 207    } 
 208 
 209    /** 
 210     * Gets the method name associated with this filter chain.  This is the method being filtered. 
 211     * 

 12     $indexPath = Libraries::get(true, 'path') . '/resources/docs.index.json'; 
 13  
 14     if (file_exists($indexPath) && is_readable($indexPath)) { 
 15         Code::index((array) json_decode(file_get_contents($indexPath), true)); 
 16     } 
 17     $result = $chain->next($self, $params, $chain); 
 18  
 19     if (($index = Code::index()) && is_array($index) && is_writable(dirname($indexPath))) { 
 20         file_put_contents($indexPath, json_encode($index)); 
 21     } 
 22     return $result; 

 182            } 
 183        } 
 184 
 185        $chain = new Filters($options); 
 186        $next = $chain->rewind(); 
 187        return $next($class, $params, $chain); 
 188    } 
 189 
 190    /** 
 191     * Provides short-hand convenience syntax for filter chaining. 
 192     * 

 142        if (!isset(static::$_methodFilters[$class][$method])) { 
 143            static::$_methodFilters += array($class => array()); 
 144            static::$_methodFilters[$class][$method] = array(); 
 145        } 
 146        $data = array_merge(static::$_methodFilters[$class][$method], $filters, array($callback)); 
 147        return Filters::run($class, $params, compact('data', 'class', 'method')); 
 148    } 
 149 
 150    /** 
 151     * Gets and caches an array of the parent methods of a class. 
 152     * 

 162            if (!$params) { 
 163                throw new DispatchException('Could not route request.'); 
 164            } 
 165            $callable = $self::invokeMethod('_callable', array($result, $params, $options)); 
 166            return $self::invokeMethod('_call', array($callable, $result, $params)); 
 167        }); 
 168    } 
 169 
 170    /** 
 171     * Attempts to apply a set of formatting rules from `$_rules` to a `$params` array, where each 
 172     * formatting rule is applied if the key of the rule in `$_rules` is present and not empty in 

 36  * @see lithium\action\Response 
 37  * @see lithium\action\Dispatcher 
 38  * @see lithium\net\http\Router 
 39  * @see lithium\action\Controller 
 40  */ 
 41 echo lithium\action\Dispatcher::run(new lithium\action\Request()); 
 42  
 43