Ego_Output.php

gehe zur Dokumentation dieser Datei

<?php
require_once('base/Ego_System.php');
require_once('base/functions.php');

class Ego_Output {
    private $page = null;

    private $site = null;

    private $file = '';

    private $info = array();

    private $pool = '';

    private $mime_type = '';

    private $cache = '';

    private $generator = 'Server-File';

    private $etag = '';

    private $name = '';

    private $is_image = false;

    private $is_valid = false;

    private $web_format = false;

    private $temporary = false;

    private $quality = 100;

    private $multipart_support = false;

    private $error = false;

    public function __construct($source = null, $pool = '') {
        if (is_a($source, 'Page')) {
            // Datei einer Seite
            $this->page = $source;
            $this->site = $this->page->getSite();

            // Mediapool Unterverzeichnis erkennen
            $dir = '';
            if ($_REQUEST['dir'] || $_REQUEST['c_date']) {
                $dir = $_REQUEST['dir'] ? $_REQUEST['dir'] : $_REQUEST['c_date'];
                if ($_REQUEST['c_date'] && !is_numeric($dir) && strpos($dir, DIRECTORY_SEPARATOR) === false) {
                    // Mediapool Archive erwarten immer Zeitstempel
                    $dir = strtotime($dir);
                }
            }

            if ($_REQUEST['thumbnail']) {
                // Ein Thumbnail über die URL generieren
                list($width, $height, $index) = explode('x', $_REQUEST['thumbnail'], 3);
                $this->file = $this->getThumbnail((int) $width, (int) ($height ?? $width), $pool, $dir, [
                    'index' => (int) $index
                ]);
                $this->detectMimeType();
                $this->is_image = true;
                if ($pool) {
                    $this->pool = $pool;
                }
            } elseif ($pool) {
                $this->pool = $pool;
                $file = $this->page->getMediapool()->get($this->pool, $dir);
                $this->info = $file;
                $this->file = $file['file'];

                $this->detectMimeType();
                $type = $file['suffix'];
            } else {
                // Bei der Ausgabe eines Multimedia Ausschnitts wird die Originalseite referenziert
                if ($this->page->field['type'] == 'multimedia/image' && $this->page->extra['crop_image']) {
                    $extra = array(
                        'edit' => $this->page->extra['edit'],
                        'crop_image' => true
                    );
                    $this->page = $this->page->getParents()->nextPage();
                    $this->page->extra = array_merge($this->page->extra, $extra);
                }

                $this->file = $GLOBALS['egotec_conf']['var_dir'].'media/'.$this->site->name.'/';
                if ($_REQUEST['c_date']) {
                    // Als "c_date" das vom Page Konstruktor ermittelte Datum verwenden
                    $archive_file = $this->file . $this->page->getMediaFilename(
                        false,
                        '_'.Ego_System::dateEncode($this->page->field['c_date'])
                    );
                    if (Ego_System::file_exists($archive_file)) {
                        $this->file = $archive_file;
                    } else {
                        // Gibt es keine passende Version, wird das Original verwendet
                        $this->file .= $this->page->getMediaFilename();
                    }
                } else {
                    $this->file .= $this->page->getMediaFilename();
                }
                $this->mime_type = $this->page->extra['mime_type'];
                $type = $this->page->extra['image_type'];

                // Automatisch zur passenden Datei für das Endgerät wechseln
                if ($this->site->admin['video']['compress'] && !$GLOBALS['is_index']) {
                    require_once 'base/Ego_Mobile.php';
                    $mobile = new Ego_Mobile();
                    $files = [
                        '360p' => $this->page->getMediapool()->get('360p.mp4'),
                        '720p' => $this->page->getMediapool()->get('720p.mp4'),
                        '1080p' => $this->page->getMediapool()->get('1080p.mp4')
                    ];
                    $is_mobile = $mobile->isMobile();
                    $is_tablet = $mobile->isTablet();
                    if (
                        ($is_mobile && !$is_tablet && ($data = $files['360p'])) // 360p nur für Mobile
                        || ($is_tablet && ($data = $files['720p'])) // 720p nur für Tablets
                        || ($data = $files['1080p']) // 1080p nur für Desktops
                    ) {
                        $this->file = $data['file'];
                        $this->mime_type = $data['mime'];
                    } else {
                        // Wenn nichts zutrifft, dann die höhste verfügbare Auflösung verwenden (ansonsten die Originaldatei)
                        $existing_files = array_filter($files);
                        if ($data = array_pop($existing_files)) {
                            $this->file = $data['file'];
                            $this->mime_type = $data['mime'];
                        }
                    }
                }
            }

            // Bestimmte MimeTypes setzen
            if (!empty($type)) {
                $formats = array(
                    'docx' => 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
                    'pptx' => 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
                    'pptm' => 'application/vnd.ms-powerpoint.presentation.macroEnabled.12',
                    'xlsx' => 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
                    'xlsm' => 'application/vnd.ms-excel.sheet.macroEnabled.12',
                    'xps' => 'application/vnd.ms-xpsdocument',
                    'svg' => 'image/svg+xml'
                );
                if (array_key_exists($type, $formats)) {
                    $this->mime_type = $formats[$type];
                }
            }
        } elseif (is_string($source)) {
            if (strpos($source, 'string:') === 0) {
                // Übergebenen String in eine temporäre Datei speichern
                $file = tempnam($GLOBALS['egotec_conf']['tmp_dir'], 'output');
                Ego_System::file_put_contents($file, substr($source, 7));
                $this->setFile($file);
                $this->setTemporary(true);
            } else {
                // Existierende Datei verwenden
                $this->setFile($source);
            }
            if (!empty($GLOBALS['site']) && is_a($GLOBALS['site'], 'Site')) {
                $this->site = $GLOBALS['site'];
            } elseif (class_exists('Site')) {
                $this->site = new Site();
            }
        }

        // Erkennen, ob die auszugebende Datei ein Bild (außer SVG und ICO: diese werden immer direkt und ohne ImageMagick Transformation ausgegeben)
        $ignore_image_mimes = array('image/svg+xml', 'image/x-icon', 'image/vnd.microsoft.icon');
        $ignore_image_types = array('svg', 'ico');

        if (!$this->is_image) {
            if ($this->page && $this->page->field['type'] == 'multimedia/image') {
                $this->is_image = !in_array($this->page->extra['mime_type'], $ignore_image_mimes);
            } elseif ($pool) {
                $this->is_image = preg_match(
                    '/\.(' . implode(
                        '|',
                        array_filter(
                            Ego_System::getFormats('image'),
                            function ($type) use ($ignore_image_types) {
                                return !in_array($type, $ignore_image_types);
                            }
                        )
                    ) . ')$/ims',
                    $pool
                );
            } elseif ($this->file) {
                $this->is_image = !(strpos($this->mime_type, 'image') === false || in_array($this->mime_type, $ignore_image_mimes));
                if ($this->page && $this->page->extra['mime_type'] && $this->page->extra['image_type']) {
                    $this->is_valid = true; // Kopierte Multimedia Seitentypen unterstützen
                }
            }
        }

        if ($this->is_image) {
            $this->web_format = in_array(
                $this->mime_type,
                Ego_System::getFormats('web')
            );
            if (is_numeric($_REQUEST['quality'])) {
                // In der URL gesetzt
                $this->quality = $_REQUEST['quality'];
            } else if (is_numeric($GLOBALS['quality'])) {
                // Vom Template gesetzt
                $this->quality = $GLOBALS['quality'];
            } elseif (is_numeric($GLOBALS['egotec_conf']['image']['quality'])) {
                // Aus den Einstellungen des Mandanten auslesen
                $this->quality = $GLOBALS['egotec_conf']['image']['quality'];
            }
        }
    }

    private function isValid($download = false) {
        return (
            $this->is_valid
            || (
                (
                    in_array($this->page->field['type'], array('multimedia/file', 'multimedia/image', 'multimedia/category'))
                    || $this->pool
                )
                && (
                    (
                        $download
                        && $this->page->field['type'] == 'multimedia/category'
                    )
                    || Ego_System::file_exists($this->file)
                )
                && $this->page->hasRights('view')
            )
        );
    }

    private function detectMimeType() {
        require_once('base/Ego_MimeType.php');
        $mime = new Ego_MimeType();
        $this->mime_type = $mime->autoDetect($this->file);
    }

    public function error($image = false) {
        Ego_System::header(404);
        if (($this->is_image || $image) && !$this->error) {
            $error_image = true;
            if (class_exists('Imagick')) {
                $width = $this->page ? $this->page->extra['origImgWidth'] : 0;
                if (!is_numeric($width) || $_REQUEST['width']) {
                    $width = (int) $_REQUEST['width'];
                }
                $height = $this->page ? $this->page->extra['origImgHeight'] : 0;
                if (!is_numeric($height) || $_REQUEST['height']) {
                    $height = (int) $_REQUEST['height'];
                }

                if ($width && $height) {
                    $this->file = tempnam($GLOBALS['egotec_conf']['tmp_dir'], 'transform');

                    $image = new Imagick();
                    $draw = new ImagickDraw();
                    $image->newImage($width, $height, new ImagickPixel('grey'));

                    $font_size = ceil(min(array($width, $height)) / 6);
                    $draw->setFillColor('lightgrey');
                    $draw->setFontSize($font_size);
                    $draw->setTextAlignment(Imagick::ALIGN_CENTER);
                    $image->annotateImage(
                        $draw,
                        ceil($width / 2),
                        ceil($height / 2) + ceil($font_size / 2),
                        0,
                        Ego_System::isDevMode() ? "{$width} x {$height}" : 404
                    );
                    $image->setFormat('png');

                    Ego_System::file_put_contents($this->file, $image);
                    $this->setTemporary(true);

                    $error_image = false;
                }
            }
            if ($error_image) {
                $this->file = $GLOBALS['egotec_conf']['egotec_dir'] . 'pub' .
                    DIRECTORY_SEPARATOR . 'missing_file.gif';
            }
            $this->detectMimeType();
            $this->is_valid = true;
            $this->error = true;
            $error = $this->read();
        } elseif ($this->site) {
            $error = $this->site->getErrorPage();
        } else {
            $site = new Site();
            $error = $site->getErrorPage();
        }
        return $error;
    }

    private function prepend(&$page, &$site, &$auth, &$smarty) {
        if (
            !$this->pool
            && $page
            && $site
            && ($file = $site->getSiteFile($page->field['type'].DIRECTORY_SEPARATOR.'index.php'))
        ) {
            require_once($file);
        }
    }

    public function setName($name) {
        $this->name = $name;
    }

    private function getName() {
        if ($this->name != '') {
            return $this->name;
        } elseif ($this->pool) {
            return $this->pool;
        } elseif ($this->page) {
            $suffix = '.'.$this->page->extra['image_type'];
            return preg_replace(
                '/'.preg_quote($suffix, '/').'$/i',
                '',
                strtr($this->page->field['name'], '/\:*?"<>|', '_________')
            ).$suffix;
        } else {
            return basename($this->file);
        }
    }

    private function setDefaultHeaders($length = 0) {
        if (!empty($this->etag)) {
            Ego_System::header('ETag: "'.$this->etag.'"');
        }
        Ego_System::header('Content-Type: '.$this->mime_type.'; charset=UTF-8');
        $t = $this->page ? $this->site->getCacheExpire() : 0;
        if (!$t) { // Keiner darf cachen
            Ego_System::noCache();
        } else {
            /* Bei Bildern ist das Feld cache immer 0. Es wird trotzdem immer ein Header gesendet,
             * so dass Browser und Proxy cachen dürfen. */
            Ego_System::header("Expires: ". gmdate("D, d M Y H:i:s", time() + $t) . " GMT");

            /* Bei HTTPS und PDF muss für IE8 (unter kleiner) immer "Pragma: public" stehen
             * ansonsten gibt es komische Probleme bei "Ziel speichern unter"
             * und Seitenaufruf von PDFs bei HTTPS */
            if (
                $_SERVER['HTTPS'] == 'on'
                && in_array(
                    mb_strtolower($this->page->extra['image_type']),
                    array('pdf', 'doc', 'docx', 'dot')
                )
            ) {
                Ego_System::header("Pragma: public");
            }
            if (
                $this->page->field['cache']&2
                && $GLOBALS['auth']->isNobody()
            ) {
                // Proxy und/oder Browser darf cachen
                Ego_System::header('Cache-Control: public');
            } else {
                // Nur Browser darf cachen
                Ego_System::header('Cache-Control: private');
            }
        }
        if (!$GLOBALS['egotec_conf']['no_content_length_header']) {
            if (!$length) {
                $length = $this->getFilesize($this->file);
            }
            Ego_System::header('Content-Length: '.$length);
        }
        if ($this->page) {
            Ego_System::header("Last-Modified: ".gmdate("D, d M Y H:i:s", Ego_System::dateEncode($this->page->field['c_date']))." GMT");
            if ($this->page->extra['meta_robots'] && $this->page->extra['meta_robots'] != 'index') {
                Ego_System::header('X-Robots-Tag: '.$this->page->extra['meta_robots']);
            }
        }
    }

    private function setSingleHeaders() {
        Ego_System::header('Content-Disposition: inline; filename="'.$this->getName().'";');
        Ego_System::header('Content-Transfer-Encoding: binary');
        Ego_System::header('Accept-Ranges: bytes');
        Ego_System::header('Content-Size: '.$this->getFilesize($this->file));
        Ego_System::header('Connection: Keep-Alive');
        $this->setDefaultHeaders();
        ob_clean();
        flush();
        readfile_chunked($this->file);
    }

    private function setRangeHeaders() {
        $fp = @fopen($this->file, 'rb');
        $size = $this->getFilesize($this->file);
        $length = $size;
        $start = 0;
        $end = $size - 1;
        if (isset($_SERVER['HTTP_RANGE'])) {
            $c_end = $end;
            list(, $range) = explode('=', $_SERVER['HTTP_RANGE'], 2);
            if (strpos($range, ',') !== false) {
                // Multiple Range
                if ($this->multipart_support) {
                    $boundary = md5('multipart_byteranges');
                    Ego_System::header(206);
                    Ego_System::header("Content-Length: $size");
                    Ego_System::header('Content-Type: multipart/byteranges; boundary=' . $boundary);
                    foreach (explode(',', $range) as $multi_range) {
                        $multi_range = explode('-', trim($multi_range));
                        if ($multi_range[0] == '-') {
                            $start = $size - substr($multi_range, 1);
                            $end = $c_end;
                        } else {
                            $start = $multi_range[0];
                            $end = (isset($multi_range[1]) && is_numeric($multi_range[1])) ? $multi_range[1] : $size;
                        }
                        fseek($fp, $start);
                        $buffer = 1024 * 8;
                        echo "--{$boundary}\r\n";
                        echo "Content-Type: {$this->mime_type}\r\n";
                        echo "Content-Range: bytes $start-$end/$size\r\n\r\n";
                        while (!feof($fp) && ($p = ftell($fp)) <= $end) {
                            if ($p + $buffer > $end) {
                                $buffer = $end - $p + 1;
                            }
                            set_time_limit(0);
                            echo fread($fp, $buffer);
                        }
                        echo "\r\n";
                        flush();
                    }
                    echo "--{$boundary}--\r\n\r\n";
                    fclose($fp);
                } else {
                    // Multiple Range nicht unterstützen und stattdessen als Download behandeln
                    $this->setDownloadHeaders();
                }
                return;
            } else {
                // Single Range
                if ($range[0] == '-') {
                    $c_start = $size - substr($range, 1);
                } else {
                    $range = explode('-', $range);
                    $c_start = $range[0];
                    $c_end = (isset($range[1]) && is_numeric($range[1])) ? $range[1] : $size;
                }
                $c_end = $c_end > $end ? $end : $c_end;
                if ($c_start > $c_end || $c_start > $size - 1 || $c_end >= $size) {
                    Ego_System::header(416);
                    Ego_System::header("Content-Range: bytes $start-$end/$size");
                    exit;
                }
                $start = $c_start;
                $end = $c_end;
                $length = $end - $start + 1;
                fseek($fp, $start);
                Ego_System::header(206);
            }
        }
        Ego_System::header("Content-Range: bytes $start-$end/$size");
        $this->setDefaultHeaders($length);
        $buffer = 1024 * 8;
        while (!feof($fp) && ($p = ftell($fp)) <= $end) {
            if ($p + $buffer > $end) {
                $buffer = $end - $p + 1;
            }
            set_time_limit(0);
            echo fread($fp, $buffer);
            flush();
        }
        fclose($fp);
    }

    private function setDownloadHeaders() {
        Ego_System::header('Content-Description: File Transfer');
        Ego_System::header('Content-Disposition: attachment; filename="'.$this->getName().'";');
        Ego_System::header('Content-Transfer-Encoding: binary');
        Ego_System::header('Connection: close');
        $this->setDefaultHeaders();
        ob_clean();
        flush();
        readfile_chunked($this->file);
    }

    public function read($download = false) {
        // Datei aus dem Cache ermitteln
        if (
            !empty($this->etag)
            && $_SERVER['HTTP_IF_NONE_MATCH'] == '"' . $this->etag . '"'
            && $GLOBALS['auth']->isNobody()
        ) {
            Ego_System::header('Cache-Control: private');
            Ego_System::header(304);
            exit;
        }

        if ($this->isValid($download)) {
            $this->prepend($this->page, $this->site, $GLOBALS['auth'], $GLOBALS['smarty']);

            // In der Entwicklungsumgebung immer Platzhalter Bilder anzeigen
            if (
                $GLOBALS['egotec_conf']['dev']['images']
                && $this->is_image
                && !$download
            ) {
                $this->error(true);
            }

            // Parameter für die Modifizierung ermitteln
            $modify = array();
            $modify_keys = array('clip', 'rotation', 'mirror');
            if ($_REQUEST['original'] && !$GLOBALS['auth']->isNobody()) {
                // Angemeldete Benutzer dürfen das Original sehen
                unset($_REQUEST['width'], $_REQUEST['height']);

                // Im Original wird die Rotation beibehalten
                $modify_keys = array('rotation', 'mirror');
            }

            foreach ($modify_keys as $param) {
                if (isset($_REQUEST[$param])) {
                    $modify[$param] = $_REQUEST[$param];
                } else {
                    if ($this->pool) {
                        if (isset($this->info[$param])) {
                            $modify[$param] = $this->info[$param];
                        }
                    } elseif ($this->page->field['type'] == 'multimedia/image') {
                        if (isset($this->page->extra['edit'][$param])) {
                            $modify[$param] = $this->page->extra['edit'][$param];
                        }
                    }
                }
            }

            if (
                (!$download || !empty($modify))
                && $this->is_image
                && ($_REQUEST['width']
                    || $_REQUEST['height']
                    || $this->quality != 100
                    || !$this->web_format
                    || !empty($modify))
            ) {
                // Bild transformieren
                $this->transform((int) $_REQUEST['width'], (int) $_REQUEST['height'], $modify);
            }
            if ($download) {
                if (
                    !$this->page
                    && @is_dir($this->file)
                ) {
                    // Bei einem Verzeichnis wird automatisch ein Archiv erzeugt
                    $this->setTemporary(true);
                    $this->setFile($this->createArchive($this->file));
                } elseif (
                    $this->page
                    && $this->page->field['type'] == 'multimedia/category'
                    && !empty($this->site->admin['allow_download'])
                    && !empty($this->page->extra['allow_download'])
                ) {
                    // Archiv erstellen
                    $this->file = $this->page->export();
                    $this->detectMimeType();
                    $this->setTemporary(true);
                    $this->page->extra['image_type'] = 'tar.gz';
                }
                // Datei herunterladen
                $this->setDownloadHeaders();
            } else {
                // Datei ausgeben
                $partial = false;
                if (
                    (
                        isset($_SERVER['HTTP_RANGE']) // Range Header werden angefordert
                        || strpos($this->mime_type, 'video/') === 0 // Videos immer mit Range Header übertragen
                    )
                    && (
                        !preg_match('/MSIE (.*?);/', $_SERVER['HTTP_USER_AGENT'], $matches)
                        || $matches[1] > 8 // Range Header nicht für MSIE 8 und kleiner
                    )
                ) {
                    // teilweise
                    $this->setRangeHeaders();
                    $partial = true;
                } else {
                    // direkt
                    $this->setSingleHeaders();
                }
                if (
                    !$partial
                    && $this->site
                    && !empty($this->cache)
                    && ($this->page->field['cache']&3) != 0
                    && !$GLOBALS['no_cache']
                ) {
                    // Ausgabe cachen
                    $info = array(
                        'headers' => $GLOBALS['egotec']['response_headers'],
                        'stats' => $GLOBALS['stats'],
                        'type' => $this->page->field['type']
                    );
                    $this->site->setCacheEntry($this->cache . '.info', $info);
                    $this->site->setCacheEntry($this->cache, $this->file);
                }
            }
            if ($this->temporary) {
                @unlink($this->file);
            }
            exit;
        }
        return $this->error($this->page && strpos($this->page->extra['mime_type'], 'image/') === 0);
    }

    public function download() {

        return $this->read(true);
    }

    public function pdf($name = '', $temporary = true, $cookie = true, $return = 1) {
        if ($this->isValid()) {
            // Einstellungen
            $smarty = $GLOBALS['smarty'];
            $site = $this->site;
            $page = $this->page;
            $context = null;
            if ($cookie && !empty($_COOKIE[EGOTEC])) {
                $context = stream_context_create(array(
                    'http' => array(
                        'method' => 'GET',
                        'header' => "Cookie: ".EGOTEC."=".$_COOKIE[EGOTEC]."\r\n"
                    )
                ));
            }
            $s = Ego_System::file_get_contents($this->file, true, $context);
            if (!empty($name)) {
                $this->setName($name);
            }
            $_REQUEST['title'] = $this->getName();

            // Generierung durchführen
            $no_pdf_header = true;
            include('pdf/pdf_create.php');

            // Datei übernehmen
            $pdf_file = $GLOBALS['egotec_conf']['tmp_dir'].'output'.md5(microtime()).'.pdf';
            Ego_System::file_put_contents($pdf_file, $s);
            if ($temporary) {
                $this->removeFile();
            }
            $this->setTemporary($return !== 3);
            $this->setFile($pdf_file);

            // Datei ausgeben
            switch ($return) {
                case 1:
                    // Download
                    return $this->download();
                case 2:
                    // Ausgabe
                    return $this->read();
                case 3:
                    // Pfad zur generierten PDF Datei
                    return $this->file;
            }
        }
        return $this->error();
    }

    public function transform($width, $height, $modify = array()) {
        if ($this->is_image) {
            // Hook für eigene Transformationen erkennen
            $output_transform = $this->page && method_exists($this->page, 'outputTransform');

            // Wasserzeichen erkennen
            $output_watermark = '';
            if ($this->pool) {
                // Mediapool (ohne Vererbung)
                $list = md5($_REQUEST['dir']);
                $key = md5($this->pool);
                if ($this->page->extra['mediapool'][$list][$key]['watermark']) {
                    $output_watermark = $this->page->extra['mediapool'][$list][$key]['watermark'];
                }
            } elseif ($this->page) {
                // Multimedia (mit Vererbung)
                $inherit = $this->page->inheritExtra(array('watermark'));
                if ($inherit['watermark']) {
                    $output_watermark = $inherit['watermark'];
                }
            }

            // Kompressionen sind nur mit JPG Dateien möglich
            $quality = in_array($this->mime_type, array('image/jpeg', 'image/jpg')) ? $this->quality : 0;

            if ($width > 0 || $height > 0 || !empty($modify) || $output_transform || $output_watermark || $quality) {
                $size = getimagesize($this->file);

                // Breite und Höhe dürfen nicht größer sein als das Original
                if ($width > $size[0] || $height > $size[1]) {
                    $width = $size[0];
                    $height = $size[1];
                }

                if (!$_REQUEST['max'] || $size[0] > $width || $size[1] > $height || !empty($modify)) {
                    $dir = $GLOBALS['egotec_conf']['cachemedia_dir'];
                    if ($this->page) {
                        $dir .= $this->site->name . DIRECTORY_SEPARATOR . $this->site->language . DIRECTORY_SEPARATOR . $this->page->field['id'] . DIRECTORY_SEPARATOR;
                        $dir .= Ego_System::dateEncode($_REQUEST['c_date'] ? $_REQUEST['c_date'] : $this->page->field['c_date']) .
                                DIRECTORY_SEPARATOR;
                    } else {
                        $dir .= '_output' . DIRECTORY_SEPARATOR;
                    }
                    if (!file_exists($dir)) {
                        Ego_System::mkdir($dir);
                    }
                    $file = $dir . $width . 'x' . $height . 'x' . $this->quality . ($this->web_format ? '' : '_jpg');
                    if ($this->pool) {
                        $file .= '_' . str_replace('.', '_', base64_encode($this->pool));
                    } elseif (!$this->page) {
                        $file .= '_' . md5($this->file);
                    }
                    if ($output_watermark) {
                        $file .= '_' . md5($output_watermark);
                    }
                    if (!empty($modify)) {
                        $file .= '_' . md5(serialize($modify));
                    }

                    // Hook um abzufragen ob die Cache verwendet werden soll
                    $output_cache = $this->page && method_exists($this->page, 'outputCache');

                    if (
                        Ego_System::file_exists($file)
                        && !$_REQUEST['c_date']
                        && !$this->error
                        && (!$output_cache || $this->page->outputCache($width, $height))
                    ) {
                        // Datei aus dem Cache verwenden
                        $this->file = $file;
                        Ego_System::header("X-Cache: CMS");
                    } else {
                        // Keine unnötige Skalierung bei Originalgröße und voller Qualität
                        if (
                            !$_REQUEST['c_date']
                            && $size[0] == $width
                            && $size[1] == $height
                            && empty($modify)
                            && (!in_array($this->mime_type, array('image/jpeg', 'image/jpg'))
                                || $this->quality == 100)
                            && !$output_transform
                            && !$output_watermark
                        ) {
                            return false;
                        }

                        // Datei neu generieren
                        require_once('base/Ego_Image.php');
                        $imageTransform = new Ego_Image();
                        $tmp = tempnam($GLOBALS['egotec_conf']['tmp_dir'], 'transform');

                        if (Ego_System::copy($this->file, $tmp)) {
                            $imageTransform->load($tmp);

                            // Ausgabe modifizieren
                            if (!empty($modify)) {
                                // Bild spiegeln
                                if ($modify['mirror']) {
                                    if (strpos($modify['mirror'], 'v') !== false) {
                                        $imageTransform->mirror(true, false);
                                    }
                                    if (strpos($modify['mirror'], 'h') !== false) {
                                        $imageTransform->mirror(false, true);
                                    }
                                }

                                // Bild rotieren
                                if ($modify['rotation']) {
                                    $imageTransform->rotate((int) $modify['rotation']);
                                }

                                // Bildausschnitt verwenden
                                if ($modify['clip']) {
                                    list($x1, $y1, $x2, $y2) = explode(',', $modify['clip'], 4);
                                    $cwidth = $x2 - $x1;
                                    $cheight = $y2 - $y1;

                                    $imageTransform->crop($x1, $y1, $x2, $y2);

                                    $size[0] = $cwidth;
                                    $size[1] = $cheight;

                                    // Breite und Höhe dürfen nicht größer sein als der Ausschnitt
                                    if ($width > $cwidth) {
                                        $width = $cwidth;
                                    } elseif (!$width) {
                                        $width = (int)round($cwidth * ($height / $cheight));
                                    }
                                    if ($height > $cheight) {
                                        $height = $cheight;
                                    } elseif (!$height) {
                                        $height = (int)round($cheight * ($width / $cwidth));
                                    }
                                }
                            }

                            if ($_REQUEST['max']) {
                                if ($width) {
                                    // Breite ändern, Seitenverhältnis beibehalten
                                    $w = $width;
                                    $h = (int)round($size[1] * ($width / $size[0]));
                                }
                                if ($height && $h > $height) {
                                    // Höhe ändern, Seitenverhältnis beibehalten
                                    $w = (int)round($w * ($height / $h));
                                    $h = $height;
                                }
                                $imageTransform->resize($w, $h);
                            } else {
                                if ($width && $height) {
                                    // Höhe und Breite ändern
                                    $imageTransform->resize($width, $height);
                                } else if ($width) {
                                    // Breite ändern, Seitenverhältnis beibehalten
                                    $imageTransform->scaleByX($width);
                                } else if ($height) {
                                    // Höhe ändern, Seitenverhältnis beibehalten
                                    $imageTransform->scaleByY($height);
                                }
                            }

                            // Hook für eigene Transformationen anwenden
                            if ($output_transform) {
                                $this->page->outputTransform($imageTransform, $tmp, $width, $height, $modify);
                            }

                            // Wasserzeichen einfügen
                            if ($output_watermark) {
                                $imageTransform->watermark($output_watermark);
                            }

                            if (
                                !$this->error
                                && $imageTransform->save($file, ($this->web_format ? '' : 'jpeg'), $quality)
                            ) {
                                $imageTransform->free();
                                $this->file = $file;
                            }
                        }
                        @unlink($tmp);
                    }
                } else {
                    return false;
                }
            }
        }
        return true;
    }

    public function setFile($file) {
        $this->file = $file;
        $this->detectMimeType();
        $this->is_valid = true;
    }

    public function removeFile() {
        @unlink($this->file);
        $this->file = '';
        $this->is_valid = false;
    }

    public function setCache($cache, $etag = '') {
        $this->cache = $cache;
        $this->etag = $etag;
    }

    public function setTemporary($temporary) {
        $this->temporary = $temporary;
    }

    public function createArchive($path) {
        if (@is_dir($path)) {
            $dir = $GLOBALS['egotec_conf']['tmp_dir'];
            $name = basename($path);
            $file = $name.'.tar.gz';

            // Archiv erstellen
            require_once('Archive/Tar.php');
            $cwd = getcwd();
            chdir($dir);
            $zip = new Archive_Tar($file, 'gz');
            $zip->_separator = ',';
            $zip->setIgnoreList(array($dir));
            $zip->createModify(rtrim($path, DIRECTORY_SEPARATOR), '', $name);
            chdir($cwd);
            return $dir.$file;
        }
        return null;
    }

    public static function export($key, $type) {
        $source = '';
        switch ($type) {
            case 'workflow':
                require_once('workflow/Ego_Workflow.php');
                $workflow = new Ego_Workflow($key);
                $source = $workflow->export();
                break;
            case 'template':
                require_once('base/template/Ego_Template.php');
                $template = new Ego_Template($key);
                $source = $template->export();
        }
        if (!empty($source)) {
            $output = new Ego_Output($source);
            $output->setTemporary(true);
            $output->download();
        }
    }

    private function getThumbnail($width, $height = 0, $pool = '', $dir = '', $params = []) {
        if ($this->page) {
            return $this->page->getThumbnail($width, $height, $pool, $dir, $params);
        } else {
            // TODO Thumbnail für Dateien, die keinem Page Objekt zugeordnet sind
        }
        return null;
    }

    private function getFilesize($file) {
        return (int) @filesize($file);
    }
}
?>