pr2/PageRender2.php5

<?php
class PageRender2 extends SObject {
    protected $page;
    protected $options;
    protected $defaults;
    protected $inputs;
    protected $classes;
    protected $counters;
    private $auth;

    const XML_PARSE_ERROR = 35;

    public function __construct ($format = "") {
        $this->page = new SPage($format);
        $this->options = array();
        $this->inputs = array();
        $this->classes = array();
        $this->defaults = array();
        $this->counters = array();
        $this->errors = array();
        $this->auth = array();
        include(dirname(__FILE__) . "/config/PageRender2Config.php5");
    }

    /*--------------------------------------------------------------*/
    /* Get/Set Methods
    /*--------------------------------------------------------------*/

    //defaults
    public function getDefault ($key) {
        if (!isset($this->defaults[$key])) return "";
        return $this->defaults[$key];
    }

    public function setDefault ($key, $value) {
        $this->defaults[$key] = $value;
    }

    //classes
        // standard set/get
    public function getClass ($key) {
        return $this->getHelper('classes', $key);
    }

    public function setClass ($key, $value) {
        $this->classes[$key] = $value;
    }

        // ensure we get a new class instance-- create one if it does not exist,
        // and pass it a link to parent (this)
    public function getClassInstance ($key) {
        if(!isset($this->classes[$key])) {
            if (!class_exists($key)){
                $this->setPrettyError("getClassInstance", "can't find class '$key' to create an instance. "
                                    . "The class must be default, saved in the 'translate' directory, or included "
                                    . "directly.");
                return false;
            }
            $this->classes[$key] = new $key($this);
        }
        return $this->classes[$key];
    }

    //options
    public function getOption ($key) {
        if (!isset($this->options[$key])){ return $this->getDefault($key); }
        return $this->options[$key];
    }

    public function setOption ($key, $value) {
        $this->options[$key] = $value;
    }

    public function setToolkitTheme($theme) {
        Toolkit::setDefaultTheme($theme, true);
    }

    public function rebaseCserdUrls($enable = true, $projectUrl = false) {
        if($enable) {
            if($projectUrl === false)
                $projectUrl = ltrim($GLOBALS['SITE_URL'], '/');
            global $PATH;
            SConfig::setOption('pr2.cserdUrlMap',
                array("!http://www.shodor.org/$projectUrl/!" => "$PATH[home]/"));
        }
        else
            SConfig::setOption('pr2.cserdUrlMap', null);
    }

    //page
    public function getPage() {
        return $this->page;
    }


    private function getHelper($array, $key)
    {   if (!isset($this->$array[$key])) return false;
        return $this->$array[$key]; }

    //input
    public function getInput($key) {
        return $this->inputs[$key];
    }

    public function getPageTemplate() {
        return $this->getClassInstance($this->getOption('template'));
    }

    public function getLayout() {
        return $this->getClassInstance($this->getOption('layout'));
    }

    /*
    DEPRECATED
    public function getPath($name) {
        switch($name){
            case 'fullServerBaseURL':
                return $this->getOption('fullServerBaseURL') . $this->getOption('relServerBaseURL');
            case 'fullUIDirURL':
                return $this->getPath('fullServerBaseURL') . $this->getOption('relUIDirURL');
            case 'fullDefaultUIDirURL':
                return $this->getPath('fullUIDirURL') .$this->getOption('relDefaultUIDirURL');
            case 'fullLocalUIDirURL':
                return $this->getPath('fullUIDirURL') . $this->getOption('relLocalUIDirURL');
            case 'fullHomeURL':
                return $this->getPath('fullServerBaseURL') . $this->getOption('relHomeURL');
            case 'fullLocalImgDirURL':
                return $this->getPath('fullHomeURL') . $this->getOption('relLocalImgDirURL');
            case 'fullProjectCSSDirURL':
                return $this->getPath('fullHomeURL') . $this->getOption('relProjectCSSDirURL');
            case 'fullProjectJSDirURL':
                return $this->getPath('fullHomeURL') . $this->getOption('relProjectJSDirURL');

            case 'relServerBaseURL':
                return $this->getOption('relServerBaseURL');
            case 'relUIDirURL':
                return $this->getOption('relServerBaseURL') . $this->getOption('relUIDirURL');
            case 'relDefaultUIDirURL':
                return $this->getPath('relUIDirURL') . $this->getOption('relDefaultUIDirURL');
            case 'relLocalUIDirURL':
                return $this->getPath('relUIDirURL') . $this->getOption('relLocalUIDirURL');
            case 'relHomeURL':
                return $this->getOption('relServerBaseURL') . $this->getOption('relHomeURL');
            case 'relLocalMediaDirURL':
                return $this->getPath('fullHomeURL') . $this->getOption('relLocalMediaDirURL');
            case 'relLocalImgDirURL':
                return $this->getPath('fullHomeURL') . $this->getOption('relLocalImgDirURL');
            case 'relLocalCSSDirURL':
                return $this->getPath('fullHomeURL') . $this->getOption('relLocalCSSDirURL');
            case 'relProjectCSSDirURL':
                return $this->getPath('relHomeURL') . $this->getOption('relProjectCSSDirURL');
            case 'relProjectJSDirURL':
                return $this->getPath('relHomeURL') . $this->getOption('relProjectJSDirURL');
            default:
                return '';
        }
    }*/

    /*--------------------------------------------------------------*/
    /* Loading Methods
    /*--------------------------------------------------------------*/

    public function add ($component, $options = array()) {
        $this->load($component, array_merge($options,
            array('inFormat' => 'tk', 'translator_tk' => 'STransTK')));
    }

    public function includeJS ($filename, $root = '') {
        if(strpos($root, '/') === false) {
            switch($root) {
                default:
                case '':
                case 'ProjectJS':
                    $root = SPath::getRelPath('ProjectJS');
                    break;
                case 'DefaultSkin':
                case 'CustomSkin':
                    $root = SPath::getRelPath($root) . '/js';
                    break;
            }
        }
        $this->load('<script type="text/javascript" src="' . $root . '/' . $filename . '"></script>' . "\n",
                        array('inFormat' => 'html', 'trans_target' => 'LibHeadTags'));
    }

    public function includeCSS ($filename, $root = '') {
        if($root !== null) {
            if(strpos($root, '/') === false) {
                switch($root) {
                    default:
                    case '':
                    case 'ProjectCSS':
                        $root = SPath::getRelPath('ProjectCSS');
                        break;
                    case 'DefaultSkin':
                    case 'CustomSkin':
                        $root = SPath::getRelPath($root) . '/css';
                        break;
                }
            }
            $root = "$root/";
        }
        else
            $root = '';
        $this->load('<link rel="stylesheet" type="text/css" href="' . $root . $filename . '" />' . "\n",
                        array('inFormat' => 'html', 'trans_target' => 'ExtraHeadTags'));
    }

    public function loadJS ($js, $slot = 'ExtraJS') {
        $this->load($js, array('inFormat' => 'html', 'trans_target' => $slot));
    }

    public function loadCSS ($css) {
        $this->load($css, array('inFormat' => 'html', 'trans_target' => 'ExtraCSS'));
    }

    public function load ($input, $options = array(), $name = "") {
        // give it an untitled name if none is provided
        if ($name == ""){
            $name = "untitled" . $this->counters['untitledSlot'];
            $this->counters['untitledSlot']++;
        }

        // if the submitted object is a SNAP resource, then we should
        // treat it as special. We should get its active version and then
        // use its type to pick a translator (if the option is not specifically
        // set in the call to load).
        if (($input instanceof SnapResource) || ($input instanceof SnapVersion)) {
            if ($input instanceof SnapResource) {

                $r = $input;
                $v = $r->getActiveVersion();

                if ($v === null) {
                    $this->setPrettyError('load', 'No active version available.');
                    return false;
                }
            } else {
                $v = $input;
                $r = $v->getResource();
            }

            $cm = $v->getContentModule();

            if (!isset($options['inFormat'])){
                $transCL = $cm->getTranslator();
                $trans = $this->getClassInstance($transCL);
                $format = $trans->getInFormat();

                if ($format === false){
                    $this->setPrettyError('load', 'No format found for this resource.');
                    return false;
                }

                $options['inFormat'] = $format;
            }

            if (!isset($options["translator_$options[inFormat]"])) {
                $trans = $cm->getTranslator();

                $options["translator_$options[inFormat]"] = $trans;
            }

            $input = $cm;
            $options['_version'] = $v;
            $options['_resource'] = $r;

            if(!isset($options['no_snap_css']) || $options['no_snap_css'] == false) {
                $ss = $r->getStylesheets();
                if(count($ss) > 0) {
                    foreach($ss as $nm => $s) {
                        if($s->getActiveVersion())
                            $this->includeCSS($url = $s->getActiveVersion()->getContentModule()->getLinkURL(), null);
                    }
                }
            }
        }

        // make a new input object for the input, translate it, and store it
        $si = new SInput($input, $options, $this, $name);
        $this->inputs[$name] = $si;

        // if we have a flag set that we should wait to translate this input until
        // later, then go ahead and wait (return true)
        if(isset($options['waitToTranslate']) && ($options['waitToTranslate'] == true)) {
            return true;
        }

        // otherwise, translate!
        $si->translate();

        $this->getWarningFrom($si);

        if ($si->hasError()) {
            $this->getErrorFrom($si);
            return false;
        }
        return true;
    }

    /*--------------------------------------------------------------*/
    /* Rendering Methods
    /*--------------------------------------------------------------*/

    public function render() {
        $layoutClass = $this->getOption('layout');
        $templateClass = $this->getOption('template');
        $this->getClassInstance("$templateClass");
        $layoutInstance = $this->getClassInstance("$layoutClass");

        // check to make sure that the class instance was actually
        // found and instantiated.
        if ($layoutInstance === false) {
            $this->setPrettyError('render', 'Specified Layout class not found.');
            return false;
        }

        // do the layout
        $layoutInstance->layout();
        return true;
    }

    public function renderPrint ($format = "html") {
        global $SWAT;
        /*
        Load Toolkit global stuff like JavaScript and CSS, which needs to be loaded once, no matter how many times
        toolkit components are used and loaded

        Perhaps this should be done elsewhere?
        */

        /* If TK2 is a loaded module */
        if(in_array("tk2", SAutoLoad::getModules())) {
            $extraJS = Toolkit::prm_getExtraJS();
            $extraCSS = Toolkit::prm_getExtraCSS();
            $jsSource = Toolkit::prm_getJSSource();
            $cssSource = Toolkit::prm_getCSSSource();
            $hiddenForms = Toolkit::prm_getExtraForms();

            $this->load($extraJS, array('inFormat' => 'html', 'trans_target' => 'ExtraJS'));
            $this->load($extraCSS, array('inFormat' => 'html', 'trans_target' => 'ExtraCSS'));
            $this->load($jsSource, array('inFormat' => 'html',
                                    'trans_target' => 'DefaultJSLinks'));
            $this->load($cssSource, array('inFormat' => 'html',
                                    'trans_target' => 'DefaultCSSLinks'));
            $this->load($hiddenForms, array('inFormat' => 'html',
                                    'trans_target' => 'Main'));
        }

        if (in_array("xforms", SAutoLoad::getModules())) {
            $xformsUIBase = SPath::getRelPath('UI') . '/xforms/';
            // Import the XForms CSS file in the ExtraCSS slot
            $ecss = $this->getPage()->getSlot('ExtraCSS');
            $ecss = '@import "' . $xformsUIBase . 'xforms.css";' . $ecss;
            $this->getPage()->setSlot('ExtraCSS', $ecss);
            $this->getPage()->appendToSlot('ExtraHeadTags',
                        '<script src="' . SPath::getRelPath('UI')
                        . '/xforms/xforms.js" type="text/javascript"></script>');
            // Require prototype so that the select all/select none links work
            $this->setOption('prototype', true);
        }


        // propagate warnings and errors from other classes
        $this->getWarningFrom($this->getPage());
        $this->getErrorFrom($this->getPage());

        // if there is a SWAT class in the global scope, get errors from that

        if (isset($SWAT) && ($SWAT instanceof SWAT)) {

            $this->getWarningFrom($SWAT);
            $this->getErrorFrom($SWAT);
        }

        // get a pointer to the page object
        $page = $this->getPage();

        // if we are supposed to, display the warnings and errors
        // (currently supported for HTML only)
        if (SConfig::getOption('common.DISPLAY_ERRORS')) {
            $page->appendToSlot('Flash', $this->formatError($page->getFormat(), 'Error', $this->getError()));
        }
        if (SConfig::getOption('common.DISPLAY_WARNINGS')) {
            $page->appendToSlot('Flash', $this->formatError($page->getFormat(), 'Warning', $this->getWarning()));
        }

        // XXX: new error manager stuff
        $html = SErrorManager::prm_printMessages();

        $this->load($html, array('inFormat' => 'html', 'trans_target' => 'Flash'));
        // XXX: end error manager stuff

        // render the final page
        $result = $this->render();

        header('Content-type: text/' . $format . '; charset=utf-8');

        if ($result === false) {
            print("<h1>PageRender2 failed with the following errors:</h1>");
            print($this->formatError($page->getFormat(), 'Errors', $this->getError()));
            print($this->formatError($page->getFormat(), 'Warnings', $this->getWarning()));
            exit();
        }

        echo $page->getPage();

        // run the test suite if it's requested
        if (isset($_GET['runTestSuite'])) {
            STestReporter::register('pr2.analytics', (strpos($content, '_gat._getTracker') !== false));
            STestReporter::register('pr2.commonVersion', SConfig::getDefault('common.commonDir'));
        }

        // update cached version if we are in cache mode
        if ($this->getOption('cacheContentOnRender')){
            $this->updateCachedVersion();
            $caching = true;
        } else {
            $caching = false;
        }
        // register the cache status with the test reporter
        if (isset($_GET['runTestSuite'])) {
            STestReporter::register('pr2.caching', $caching);
        }

    }

    // formatError()
    // -------------
    // formats error array into a printable string and returns the string
    public function formatError($format, $title, $error, $indent = 0) {
        switch($format){
            case 'html':

                if (!is_array($error)) {
                    return ("<b>$title</b>: " . $error . "<br />");
                } else {
                    $output = "";
                    foreach($error as $e) {
                        $output .= $this->formatError($format, $title, $e, $indent + 1);
                    }
                    return ($output == "") ? "" : "<div class='pr2error'>" . $output . "</div>";
                }

            default:
                return "";
        }

    }

    public function flash($string = "") {
        $this->getPage()->appendToSlot('Flash', '<div class="flashNotice">' . $string . '</div>');
    }

    public function flashAndExit($string = "") {
        $this->flash($string);
        $this->renderPrint();
        exit();
    }

    public function flashAndRedirect($string, $url) {
        global $SWAT;
        $guser = $SWAT->getGlobalUser();
        $guser->setFlash($string);
        SWATFunctions::redirect($url);
    }

    protected function runTestSuite($extras = null) {
        $content = $this->getPage()->getPage();
        $return = array();
        $return['pr2.analytics'] = (strpos($content, '_gat._getTracker') === false) ? 'off' : 'on';
        $return['pr2.commonVersion'] = SConfig::getDefault('common.commonDir');
        if ($extras != null)
            $return = array_merge($return, $extras);
        return $return;
    }

    /*--------------------------------------------------------------*/
    /* Caching Methods
    /*--------------------------------------------------------------*/

    public function useCachedVersion ($lifetime = "") {
        if(!SConfig::getDefault('pageCache.enable'))
            return false;

        if ($lifetime == "") $lifetime = $this->defaults['cacheLifetime'];

        $filename = SCacheManager::checkPageCache();
        if($filename !== false) {
            header('Content-type: text/' .
                $this->page->getTargetType() . '; charset=utf-8');
            readfile($filename);
            if (isset($_GET['runTestSuite']))
                STestReporter::register('pr2.caching', true);
            exit();
        }
        else {
            $this->setOption('cacheContentOnRender', true);
        }
        return false;
    }

    public function updateCachedVersion () {
        SCacheManager::addToPageCache($this->page);
    }

    public function dropCache($uri = null) {
        SCacheManager::clearPageCache($uri);
    }
}

?>

---