pr2/translate/STransStdXML3Helper.php5

<?php
class STransStdXML3Helper extends SObject {

    protected $parent;
    protected $translator;

    protected $listNum;         // static class var -- which list are we currently on (of all on this page)?
    protected $listItemCount;   // running count of items in current list
    protected $firstInSection;  // running bool - true false (first list item in section?)
    protected $catCount;        // running count of categories

    protected $albumNum;        //static class car -- the album we are currently on (of all on this page)

    protected $catBuf;      //store the category listing
    protected $catIdBuf;    //store the category ids
    protected $catCountBuf; //store the category counts
    protected $jsBuf;       //store javascript
    protected $curPrefix;   //store the current table id prefix
    protected $countByCat;

    protected $callbacks;

    protected $sectionDepth = 0;

    public function doc() {
        return "STransStdXML3Helper is a class that helps STransStdXML3 and STransListXML3"
                . " perform their translation.";
    }

    public function __construct($parent)
    {
        $this->listNum = 0;
        $this->albumNum = 0;
        if (parent::__construct($parent) === true) return false;
        $this->sectionDepth = 0;
    }

    // set which translator is the parent
    public function setTranslator($t) {
        $this->translator = $t;
    }

    public function getTranslator() {
        return $this->translator;
    }

    /* ------------------------------------------------- */
    /* RESOURCE TRANSLATION WORKER FUNCTIONS */
    /* ------------------------------------------------- */

    /* ------------------------------------------------- */
    // Following are the two ways an XML tag can be treated
    // in this schema-- as a "block level element container" or
    // as a mixed content container. Block level can only hold
    // section, p, ul/ol, table, div. Mixed can hold those
    // plus text, b, i, span, hr, br.

    // See the documentaion for more info
    /* -------------------------------------------------- */

    // These two functions, though currently redundant, are place-holders in case
    // there is a change in how the different tags are processed.
    public function translateResource($xmlResource) {
        return $this->processBlockLevelElementContainerXML($xmlResource);
    }

    public function processBlockLevelElementContainerXML($xml) {
        return $this->processBlockOrMixedContentXMLHelper($xml, true);
    }

    public function processMixedContentContainerXML($xml) {
        return $this->processBlockOrMixedContentXMLHelper($xml, false);
    }

    // This helper powers the two functions above.
    protected function processBlockOrMixedContentXMLHelper($xml, $block = true) {
        $content = "";
        $children = $xml->childNodes;
        foreach ($children as $child) {
            if ($child instanceof domElement) {
                // process the container-type elements based on what
                // type of conatiner this (parent tag) is
                if ($block) {
                    $content .= $this->processBlockLevelElementXML($child);
                } else {
                    $content .= $this->processMixedElementXML($child);
                }
            } else  {
                // the node is not block-level. Trim it to make sure it's not
                // just spaces. If there is content other than spaces, and if
                // this is a block container only, set a warning.
                $nodeValue = str_replace(array('&amp;lt;', '&amp;gt;'), array('&lt;', '&gt;'), $child->nodeValue);
                if ($block && (trim($nodeValue) != "")) {
                    $this->setPrettyWarning('processBlockOrMixedContentXMLHelper',
                        'Encountered mixed content, which is not allowed inside a '
                        . $xml->tagName . ' tag.');
                } else {
                // Otherwise, append the content to the output
                    $content .= $nodeValue;
                }
            }
        }
        return $content;
    }

    /* -------------------------------------------------- */
    // These functions process the two types of tags.
    // Optimally, we should add another function that is called in
    // the "default" case that we can override in child classes
    // to add custom tag support.
    /* -------------------------------------------------- */

    protected function processMixedElementXML($xml) {
        switch($xml->tagName) {
            case 'link':
                return $this->processLinkXML($xml);
                break;
            case 'media':
                return $this->processMediaXML($xml);
                break;
            case 'latex':
                return $this->processLatexXML($xml);
                break;
            case 'br':
                return $this->processBrXML($xml);
                break;
            case 'hr':
                return $this->processHrXML($xml);
                break;
            case 'b':
                return $this->processBoldXML($xml);
                break;
            case 'i':
                return $this->processItalicXML($xml);
                break;
            case 'u':
                return $this->processUnderlineXML($xml);
                break;
            case 'span':
                return $this->processSpanXML($xml);
                break;
            case 'sub':
                return $this->processSubXML($xml);
                break;
            case 'sup':
                return $this->processSupXML($xml);
                break;
            case 'pre':
                return $this->processPreXML($xml);
                break;
            case 'entity':
                return $this->processEntityXML($xml);
                break;
            default:
                return $this->processBlockLevelElementXML($xml);
        }
    }

    protected function processBlockLevelElementXML($xml) {
        switch($xml->tagName) {
            case 'section':
                return $this->processSectionXML($xml);
                break;
            case 'p':
                return $this->processParagraphXML($xml);
                break;
            case 'ul':
            case 'ol':
                return $this->processListXML($xml);
                break;
            case 'table':
                return $this->processTableXML($xml);
                break;
            case 'div':
                return $this->processDivXML($xml);
                break;
            case 'map':
                return $this->processMapXML($xml);
                break;
            case 'name':
            case 'shortName':
            case 'listItemData':
            case 'sectionData':
            case 'resourceData':
                break;
            default:
                $result = $this->processCustomElementXML($xml);
                if ($result == null) {
                    $this->setPrettyWarning('processXML', "Unknown tag '" . $xml->tagName . "'");
                }
                break;
        }
        return "";
    }

    // Another redundant function that leaves space for future expansion.
    protected function processCustomElementXML($xml) {
        switch($xml->tagName) {
            default;
                break;
        }
        return null;
    }

    /* -------------------------------------------------- */
    /* Functions that process individual tag types */
    /* -------------------------------------------------- */

    //# Section processing functions
    //# --------------------------------------------------

    protected function processSectionXML($xml) {
        $this->sectionDepth++;
        $ret = $this->processStandardTag($xml, "div",
                $this->processSectionTitle($xml) .
                $this->processBlockLevelElementContainerXML($xml),
                array('class' => 'section'));
        $this->sectionDepth--;
        return $ret;
    }

    protected function processSectionTitle($xml) {
        $elt = simplexml_import_dom($xml);
        if (isset($elt->name)) {
            $class = isset($elt->name->attributes()->class) ? ' class="' . $elt->name->attributes()->class . '"' : '';
            return "<h" . ($this->sectionDepth+1) . "$class>" . $this->processBlockOrMixedContentXMLHelper($xml->getElementsByTagName('name')->item(0), false) .
                    "</h" . ($this->sectionDepth+1) . ">";
        }
        return "";
    }


    //# Paragraph processing functions
    //# --------------------------------------------------

    protected function processParagraphXML($xml) {
        return $this->processStandardTag($xml, "p",
                $this->processMixedContentContainerXML($xml));
    }


    //# Table processing functions
    //# --------------------------------------------------

    protected function processTableXML($xml) {
        return $this->processStandardTag($xml, $xml->tagName,
                $this->processTableBodyContainerXML($xml));
    }

    protected function processTableBodyContainerXML($xml, $blockTbody = false) {
        $children = $xml->childNodes;
        $content = "";
        foreach ($children as $child) {
            if ($child instanceof DOMElement) {
                switch($child->tagName) {
                    case 'tbody':
                        if ($blockTbody == true) {
                            $this->warnUnexpectedTag('processTableBodyContainerXML', $child,
                                    'tbody', 'tr');
                        } else {
                            $content .= $this->processTableBodyXML($child);
                        }
                        break;
                    case 'tr':
                        $content .= $this->processTableRowXML($child);
                        break;
                    default:
                        $this->warnUnexpectedTag('processTableBodyContainerXML', $child,
                                    'table', 'tbody or tr');
                        break;
                }
            } else {
                $this->warnInvalidMixedContent('processTableBodyContainerXML', $child, 'tbody or tr');
            }
        }
        return $content;
    }

    protected function processTableDataContainerXML($xml) {
        $children = $xml->childNodes;
        $content = "";
        foreach ($children as $child) {
            if ($child instanceof DOMElement) {
                switch($child->tagName) {
                    case 'td':
                        $content .= $this->processTableDataXML($child);
                        break;
                    case 'th':
                        $content .= $this->processTableHeaderXML($child);
                        break;
                    default:
                        $this->warnUnexpectedTag('processTableDataContainerXML', $child,
                                    'tr', 'td or th');
                        break;
                }
            } else {
                $this->warnInvalidMixedContent('processTableDataContainerXML', $child, 'td or th');
            }
        }
        return $content;
    }

    protected function processTableDataXML($xml) {
        return $this->processStandardTag($xml, "td",
                $this->processMixedContentContainerXML($xml));
    }

    protected function processTableHeaderXML($xml) {
        return $this->processStandardTag($xml, "th",
                $this->processMixedContentContainerXML($xml));
    }

    protected function processTableBodyXML($xml) {
        return $this->processStandardTag($xml, $xml->tagName,
                $this->processTableBodyContainerXML($xml, true));
    }

    protected function processTableRowXML($xml) {
        return $this->processStandardTag($xml, $xml->tagName,
                $this->processTableDataContainerXML($xml, true));
    }


    //# List processing functions
    //# --------------------------------------------------

    protected function processListXML($xml) {
        return $this->processStandardTag($xml, $xml->tagName,
                $this->processListItemContainerXML($xml));
    }

    protected function processListItemContainerXML($xml) {
        $children = $xml->childNodes;
        $content = "";
        foreach ($children as $child) {
            if ($child instanceof DOMElement) {
                switch($child->tagName) {
                    case 'li':
                        $content .= $this->processListItemXML($child);
                        break;
                    default:
                        $this->warnUnexpectedTag('processListItemContainerXML', $child,
                            $xml->tagName, 'li');
                        break;
                }
            } else {
                $this->warnInvalidMixedContent('processListItemContainerXML', $child, 'li');
            }
        }
        return $content;
    }

    protected function processListItemXML($xml) {
        return $this->processStandardTag($xml, "li",
                $this->processMixedContentContainerXML($xml));
    }

    //# Image maps
    //# --------------------------------------------------

    protected function processMapXML($xml) {
        return $this->processStandardTag($xml, $xml->tagName,
                $this->processMapContainerXML($xml), array('name' => $xml->getAttribute('name')));
    }

    protected function processMapContainerXML($xml) {
        $children = $xml->childNodes;
        $content = "";
        foreach ($children as $child) {
            if ($child instanceof DOMElement) {
                switch($child->tagName) {
                    case 'area':
                        $content .= $this->processAreaXML($child);
                        break;
                    default:
                        $this->warnUnexpectedTag('processMapContainerXML', $child,
                            $xml->tagName, 'area');
                        break;
                }
            } else {
                $this->warnInvalidMixedContent('processMapContainerXML', $child, 'area');
            }
        }
        return $content;
    }

    //# Mixed-content related tags
    //# --------------------------------------------------

    protected function processLinkXML($xml) {
        $aLinkAttributes = array();

        if ($xml->getAttribute('metaid') != "") {
            // if the metaid is set, use SDRMetadata to look up the URL for the id
            // and put that into the link tag
            $metaid = trim($xml->getAttribute('metaid'));
            // Default to open metadata links in a new window 
            $aLinkAttributes['target'] = '_blank'; 
            $url = SDR::getURLForResourceId($metaid);
            if($this->getTranslator()->getInputOption('enable_link_info')) {
                if(!isset($GLOBALS['ss_js_loaded'])) {
                    $GLOBALS['prm']->setOption('swatjs', true);
                    $GLOBALS['prm']->loadJS("SWAT.use('LinkInfo');\n");
                    $GLOBALS['ss_js_loaded'] = true;
                }
                $aLinkAttributes['onmouseover'] = 'LinkInfo.show(\'' . $url . '\', this, event)';
                $aLinkAttributes['onmousemove'] = 'LinkInfo.show(\'' . $url . '\', this, event)';
            }
            $rebasePatterns = $this->getTranslator()->getInputOption('cserdUrlMap');
            if(!is_array($rebasePatterns))
                $rebasePatterns = SConfig::getOption('pr2.cserdUrlMap');
            if(is_array($rebasePatterns) && count($rebasePatterns) > 0)
                $url = preg_replace(array_keys($rebasePatterns), array_values($rebasePatterns), $url);
        } else if($xml->getAttribute('snapid') != "") {
            $snapId = $xml->getAttribute('snapid');
            if(ctype_digit((string) $snapId))
                $res = SnapResource::retrieve($snapId);
            else
                $res = SnapResource::lookup($snapId);

            if($res == null || $res->getId() <= 0)
                $this->setWarning("Invalid snap ID/path given: '$snapId'");
            else {
                $v = $res->getActiveVersion();
                if($v == null)
                    $this->setWarning("No active version for Snap resource '$snapId'");
                else
                    $url = $v->getContentModule()->getLinkURL();
            }
        } else if ($xml->getAttribute('href') != "") {
            // otherwise, consult the HREF tag on the link if it is not empty
            $url = $xml->getAttribute('href');
            $base = $xml->getAttribute('base');
            $url = $this->rebaseUrl($base, $url);
        }
        else if($xml->getAttribute('name') != "") {
            $aLinkAttributes['name'] = $xml->getAttribute('name');
        }

        if($xml->getAttribute('where') != ""){
            $aLinkAttributes['target'] = $xml->getAttribute('where');
        }


        // if the URL has some content, then create a link tag.
        if (isset($url) && $url != "") {
            $aLinkAttributes['href'] = $url;
            $aLinkAttributes['class'] = 'realLink';
        } else if(!isset($aLinkAttributes['name'])) {
        // otherwise, just create a span that is styled to look like a broken link (unless this is an anchor tag, in which case, do nothing)
            return $this->processStandardTag($xml, "span",
                $this->processMixedContentContainerXML($xml),
                array('class' => 'brokenLink'));
        }

        return $this->processStandardTag($xml, "a",
            $this->processMixedContentContainerXML($xml),
            $aLinkAttributes);
    }

    protected function processLatexXML($xml) {

        $render = new LatexRenderModule();
        return($render->transform($xml->nodeValue));

    }

    protected function processMediaXML($xml) {
        STimer::startAvg('processMedia');
        $class = $xml->getAttribute('class');
        $id = $xml->getAttribute('id');
        $snapid = trim($xml->getAttribute('snapid'));
        $which = trim($xml->getAttribute('which'));
        $ismap = $xml->getAttribute('ismap');
        $usemap = $xml->getAttribute('usemap');
        $width = $xml->getAttribute('width');
        $height = $xml->getAttribute('height');
        $embed = $xml->getAttribute('embed');
        $style = $xml->getAttribute('style');
        $alt = $xml->getAttribute('alt');
        $title = $xml->getAttribute('title');
        $view = $xml->getAttribute('view');
        if($which == "") {
            $which = "original";
        }
        if($view == "") {
            $view = "embed";
        }
        else if($view == "download") {
            $downloadMessage = $xml->nodeValue;
            if($downloadMessage == '')
                $downloadMessage = 'Download';
        }
        if(strpos($snapid, "/") !== false)
            $res = SnapResource::lookup($snapid);
        else if(ctype_digit((string) $snapid))
            $res = SnapResource::retrieve((int)$snapid);
        else {
            $this->setWarning('snapid in media tag is not numeric: "' . htmlentities($snapid) . '"');
            $res = null;
        }

        if($res != null) {
            $version = $res->getActiveVersion();

            if($version == null) {
                $html = false;
                $msg = "No content (no active version for resource '$snapid')";
            }
            else {
                $cm = $version->getContentModule();

                $config = array('which' => $which);
                if($class != '') $config['class'] = $class;
                if($id != '') $config['id'] = $id;
                if($ismap != '') $config['ismap'] = $ismap;
                if($usemap != '') $config['usemap'] = $usemap;
                if($width != '') $config['width'] = $width;
                if($height != '') $config['height'] = $height;
                if($embed != '') $config['embed'] = $embed;
                if($style != '') $config['style'] = $style;
                if($alt != '') $config['alt'] = $alt;
                else $config['alt'] = SnapContentMediaImage::ALT_DESC;
                if($title != '') $config['title'] = $title;

                if($view == 'embed') {
                    $html = $cm->getHTML($config);
                    if(!$html)
                        $msg = $cm->getLastError();
                }
                else if($view == 'download')
                    $html = '<a href="/media/download' . $res->getCanonicalPath() . '">' . $downloadMessage . '</a>';
                else {
                    $html = false;
                    $msg = 'Invalid view type: ' . $view;
                }
            }
        }
        else {
            $html = false;
            $msg = "No content (no such resource '$snapid')";
        }

        if($html === false)
            $html = "<div style=\"padding: 4px; border: 1px solid black; "
                . "background-color: #E0E0E0; width: 8em; text-align: center;\">$msg</div>";

        STimer::endAvg('processMedia');
        return $html;
    }

    protected function processAreaXML($xml) {
        $url = $xml->getAttribute('href');
        $base = $xml->getAttribute('base');
        $url = $this->rebaseUrl($base, $url);
        $result = $this->processStandardTag($xml, 'area', '',
            array('class' => $xml->getAttribute('class'),
                    'id' => $xml->getAttribute('id'),
                    'alt' => $xml->getAttribute('alt'),
                    'title' => $xml->getAttribute('title'),
                    'shape' => $xml->getAttribute('shape'),
                    'coords' => $xml->getAttribute('coords'),
                    'href' => $url,
                    'nohref' => $xml->getAttribute('nohref'),
                    'target' => $xml->getAttribute('target'),
                    'onmouseover' => $xml->getAttribute('onmouseover'),
                    'onmouseout' => $xml->getAttribute('onmouseout')), true);
        return $result;
    }

    protected function processBrXML($xml) {
        return $this->processStandardTag($xml, "br", "", array(), true);
    }

    protected function processHrXML($xml) {
        return $this->processStandardTag($xml, "hr", "", array(), true);
    }

    protected function processBoldXML($xml) {
        return $this->processStandardTag($xml, "b",
            $this->processMixedContentContainerXML($xml));
    }

    protected function processItalicXML($xml) {
        return $this->processStandardTag($xml, "i",
            $this->processMixedContentContainerXML($xml));
    }

    protected function processUnderlineXML($xml) {
        return $this->processStandardTag($xml, "u",
            $this->processMixedContentContainerXML($xml));
    }

    protected function processSpanXML($xml) {
        return $this->processStandardTag($xml, "span",
            $this->processMixedContentContainerXML($xml));
    }

    protected function processDivXML($xml) {
        return $this->processStandardTag($xml, "div",
            $this->processMixedContentContainerXML($xml));
    }

    protected function processSubXML($xml) {
        return $this->processStandardTag($xml, "sub",
            $this->processMixedContentContainerXML($xml));
    }

    protected function processSupXML($xml) {
        return $this->processStandardTag($xml, "sup",
            $this->processMixedContentContainerXML($xml));
    }

    protected function processPreXML($xml) {
        return $this->processStandardTag($xml, "pre",
            $this->processMixedContentContainerXML($xml));
    }


    protected function processEntityXML($xml) {
        return '&' . $xml->nodeValue . ';';
    }


    /* -------------------------------------------------- */
    /* Functions that do all the common work of processing
    /* different tag types. */
    /* -------------------------------------------------- */

        protected function processStandardTag($xml, $name, $content,
                        $attrs = array(), $singleton = false) {

        //build the HTML version of the attributes list
        $attrlist = "";

        // if an ID is set on the XML tag, change the ID
        // of the output tag
        if ($xml->getAttribute('id') != "") {
            $attrs['id'] = $xml->getAttribute('id');
        }

        if (isset($attrs['class'])){
            $attrs['class'] .= " ";
        } else {
            $attrs['class'] = "";
        }
        $attrs['class'] .= "StdXML3";

        // add custom classes to the output tag
        // if they are specified on the XML tag
        if ($xml->getAttribute('class') != "") {
            if (isset($attrs['class']) && ($attrs['class'] != "")) {
                $attrs['class'] .= " " . $xml->getAttribute('class');
            } else {
                $attrs['class'] = $xml->getAttribute('class');
            }
        }
        foreach ($attrs as $key => $value) {
            $value = trim($value);
            if($value != '')
                $attrlist .= " $key=\"$value\"";
        }

        // check to see if element is singleton
        if ($singleton) {
            return "<$name$attrlist />\n";
        } else {
            return "<$name$attrlist>" . $content . "</$name>";
        }
    }

    protected function warnInvalidMixedContent($function, $node, $expected) {
        $value = trim($node->nodeValue);
        if ($value != "") {
            if(property_exists($node, 'tagName'))
                $tagName = $node->tagName;
            else
                $tagName = "???";
            $this->setPrettyWarning($function, 'Encountered unexpected mixed content inside a '
                    . $tagName . ' tag. ' . $expected . ' expected.');
        }
    }

    protected function warnUnexpectedTag($function, $node, $parent, $expected) {
        $this->setPrettyWarning($function, 'Encountered unexpected tag ' . $node->tagName .
        ' inside a ' . $parent . '. ' . $expected . ' expected.');

    }

    protected function rebaseUrl($base, $url) {
        if($base == '')
            return $url;

        $info = explode(':', $base);
        // we can have, e.g.:
        //  rel="PATH:activities" (generates href="$PATH[activities]$href")
        //  rel="SPath:Project" (generates href="SPath::getFullPath('Project')/href")
        // so href should begin with a slash unless it intends to be glommed on directly to the base path
        if(count($info) != 2) {
            $this->setWarning('Invalid path source specification; ignoring');
        }
        else if($info[0] == 'PATH') {
            if(!isset($GLOBALS['PATH'][$info[1]])) {
                $this->setWarning('No such $PATH entry: ' . $info[1] . '; if you are in Snap2, ignore this warning');
            }
            else {
                $url = $GLOBALS['PATH'][$info[1]] . $url;
            }
        }
        else if($info[0] == 'SPath') {
            $base = SPath::getFullPath($info[1]);
            $url = "$base$url";
        }
        else {
            $this->setWarning('Invalid path source: "' . $info[0] . '"; ignoring');
        }
        return $url;
    }

    /* ------------------------------------------------- */
    /* LIST TRANSLATION WORKER FUNCTIONS */
    /* ------------------------------------------------- */



    /*-----------------------------------------------------*/
    /* Translate a given SInput album object
    /*-----------------------------------------------------*/

    /* Most of this code is copied from translateList, below.
    /* This function takes every section tag with the "item" mapping
    /* and sends it through the translateAlbumUnit function, below.
    /* It currently does NOT through an error on incorrect tags, or
    /* section tags mapped as something besides "item". */
    public function translateAlbum ($xmlAlbum, $parentTrans, $si) {
        // check to see if the right root tag has been passed in.
        if ($xmlAlbum->tagName != 'XMLAlbum'){
            $this->setPrettyError('translate', 'Root XML tag is not XMLAlbum.');
            return false;
        }

        $xml = simplexml_import_dom($xmlAlbum);

        $htmlCollector = "";

        //These arrays store the same information they store in the on-page javascript. All of this information is pulled from SNAP Media.
        $photoPaths = array();
        $thumbPaths = array();
        $photoWidths = array();
        $photoHeights = array();
        $photoCaptions = array();
        $downloadPaths = array();

        foreach($xml->section as $albumUnit)
        {
            if ($albumUnit['mapping'] = 'item') {
                $photoAttributes = $this->translateAlbumUnit($albumUnit);
                //if(!$photoAttributes) {
                    //print "FALSE";
                //} else {
                if ($photoAttributes != null) {
                    $photoPaths[] = $photoAttributes[0];
                    $thumbPaths[] = $photoAttributes[1];
                    $downloadPaths[] = $photoAttributes[2];
                    $photoWidths[] = $photoAttributes[3];
                    $photoHeights[] = $photoAttributes[4];
                    $photoCaptions[] = $photoAttributes[5];
                }
            }
        }

        // I have included this variable because it is in the old code, but because I am using SNAP media fo the paths it won't change.
        $basePath = "";
        //The number of photos.
        $numberOfPhotos = count($photoPaths);

        // this uses SPath to get the path of the active common directory
        // and then looks inside for the photothumb script
        $thumbsScript = SPath::getRelPath('Common')
                        . '/pr2/components/photothumbs.php5';


        if ($numberOfPhotos > 0) {

        $uiPath = SPath::getRelPath('DefaultSkin');

        $htmlIfAnyPhotos = <<<END
<div class="scrollFrame">
<iframe name="photoview{$this->albumNum}_thumbnails" src='$thumbsScript?pvid={$this->albumNum}&pcount=$numberOfPhotos&basepath=$basePath' frameborder="0"   width="100%" height="80">Picture Thumbnails</iframe>
</div>
<div class="viewFrame" id="photoview{$this->albumNum}_viewframe">
<center><img id="photoview{$this->albumNum}_image" src="$uiPath/images/black_spinner_lg.gif" alt="photo" style="width:12px;height:12px;" /></center>
</div>
<div class=controlFrame>
<img id="photoview{$this->albumNum}_bigleft" src="$uiPath/images/leftarr.gif" class="bigArrow clickable" alt="Previous" style="float:left;margin-right:10px;" onclick="javascript:photolistPrev({$this->albumNum});" />
<img id="photoview{$this->albumNum}_bigright" src="$uiPath/images/rightarr.gif" class="bigArrow clickable" alt="Next" style="float:right;margin-left:10px;" onclick="javascript:photolistNext({$this->albumNum});" />
<span id="photoview{$this->albumNum}_caption" class="caption">
</span><br style="clear:both;" />
<span class="download"><small><a id="photoview{$this->albumNum}_download" href="#" target="_blank">[View Full Quality Image]</a></small></span><br style="clear:both;" />
</div>
END;
        } else {
            $htmlIfAnyPhotos = <<<END
<div class="photoviewMessage">This collection of photos is not currently available.</div>
END;
        }


        //This is all the html used for the photoviewer.
        $htmlCollector= <<<END_OF_TEXT
<div class="photoviewContainer">
<div class="photoviewBox">

$htmlIfAnyPhotos

</div>
</div>
END_OF_TEXT;

        $parentTrans->sendToTarget($si, $htmlCollector);

        //The extra javascript is just the four arrays.
        $parentTrans->getPage()->appendToSlot("ExtraJS", "var downloadPaths = [];" .//TODO: downloadPaths was undefined on the succeed_redesign page
                          "photoPaths[" . $this->albumNum . "] = new Array('"
                            . implode("','",$photoPaths) . "');\n"
                        . "thumbPaths[" . $this->albumNum . "] = new Array('"
                            . implode("','",$thumbPaths) . "');\n"
                        . "downloadPaths[" . $this->albumNum . "] = new Array('"
                            . implode("','" , $downloadPaths) . "');\n"
                        . "photoWidths[" . $this->albumNum . "] = new Array('"
                            . implode("','",$photoWidths) . "');\n"
                        . "photoHeights[" . $this->albumNum . "] = new Array('"
                            . implode("','",$photoHeights) . "');\n"
                        . "photoCaptions[" . $this->albumNum . "] = new Array('"
                            . implode("','",$photoCaptions) . "');\n");

        //I use the album number as a unique identifier.
        $this->albumNum++;

        return true;
    }

    /*-----------------------------------------------------*/
    /* Translate a single photo or media entry in an album.
    /*-----------------------------------------------------*/

    /* Currently, for better or worse, I assume the first media
    /* tag is the desired photo.  Any other tags are processed by
    /* processMixedContentContainerXML and added to the caption. */
    public function translateAlbumUnit ($albumUnit) {

        //these are the attributes we are looking for:
        $photoPath = "";
        $thumbPath = "";
        $photoWidth = "960"; //960 is the default for arbitrary reasons.
        $photoHeight = "960";
        $photoCaption = "";
        $downloadPath = '';

        // A simple binary to check if I have a photo yet.
        $photoFound = FALSE;

        foreach($albumUnit->children() as $child) {

            //If we have a sectionData tag, put it in our sub-function.
            if($child->getName() == 'sectionData') {
                if(!$photoFound) {
                    $photoInformation = $this->translateSectionData($child);
                    if($photoInformation) {
                        $photoFound = TRUE;
                        $photoPath = $photoInformation[0];
                        $thumbPath = $photoInformation[1];
                        $downloadPath = $photoInformation[2];
                        $photoWidth = $photoInformation[3];
                        $photoHeight = $photoInformation[4];
                    }
                }
            } else {
                // I need to convert back to give it to mixedContent.
                $domChild = dom_import_simplexml($child);
                $tmpCaption = $this->processMixedContentContainerXML($domChild);
                $tmpCaption = $this->escapeForJavascriptOutput($tmpCaption);
                $photoCaption .= $tmpCaption;
            }
        }

        if(!$photoFound) {
            $photoPath = '';
            $photoCaption = "<p><b>PHOTO NOT FOUND (IMAGES ONLY)</b></p>" . $photoCaption;
            return null;
        }

        //Add quotes before and after the caption...
        //$photoCaption = '"' . $photoCaption . '"';

        //we place all of the attributes in an array to return them.
        $photoInformation = array($photoPath, $thumbPath, $downloadPath, $photoWidth, $photoHeight, $photoCaption);

        return $photoInformation;
    }

    // The all-important function to process the most important tag in the album.
    // If the section data does not contain an image, this function will throw and error.
    public function translateSectionData ($sectionDataTag) {
        foreach($sectionDataTag->children() as $child) {
            if($child->getName() == "media") {
                $cm = NULL;
                // All of this code is copied from processMediaTag..
                $sectionAttributes = $child->attributes();
                $snapid = $sectionAttributes["snapid"];

                if(strpos($snapid, "/") === false) {
                    $res = SnapResource::retrieve((int)$snapid);
                } else {
                    $res = SnapResource::lookup($snapid);
                }

                // Get the ContentModule.
                if($res) {
                    $version = $res->getActiveVersion();
                    if($version)
                        $cm = $version->getContentModule();
                }
            }

            //If we have a media tag, make sure it is an image.
            if(isset($cm) && $cm->getName() == 'Media Image') {
                // And ask it for the width, height, etc...
                $photoAttributes = array($cm->getURL('display'), $cm->getURL('thumb'), $cm->getURL('original'), $cm->getWidth(), $cm->getHeight());
                return $photoAttributes;
            }
        }

        return FALSE;
    }

    // An all-important function Jonathan showed me.
    // This makes sure all the strings I use are javascript safe.
    function escapeForJavascriptOutput($text)
        {
                $text = str_replace("\"", "&#8220;", $text);
                $text = str_replace("\'", "&#8216;", $text);
                $text = preg_replace("/\n|\r|\t/", "", $text);
                $text = addSlashes($text);
                return $text;
        }

    /*-----------------------------------------------------*/
    /* Translate a given SInput list object
    /*-----------------------------------------------------*/
    public function translateList ($xmlList, $parentTrans, $si) {

        // check to see if the right root tag has been passed in.
        if ($xmlList->tagName != 'XMLList'){
            $this->setPrettyError('translate', 'Root XML tag is not XMLList.');
            return false;
        }

        $parentTrans->setOption('thumbnailWidth', 150);
        $parentTrans->setOption('thumbnailHeight', 80);
        $parentTrans->setOption('showCategoryLinks', true);
        $parentTrans->setOption('showSearchBox', true);

        $xml = simplexml_import_dom($xmlList);

        //initialize some variables
        $this->listItemCount = 0;
        $this->catCount = 0;
        $this->jsBuf = "";
        $this->catBuf = array();
        $this->catIdBuf = array();
        $this->catCountBuf = array();
        $this->curPrefix = "listing" . $this->listNum;

        // Translate the Page Content
        $collect =<<<END_TABLE

<div id="$this->curPrefix" class="Listing">
END_TABLE;


        // loop through the sections under the root tag (the categories)
        foreach($xml->section as $curUnit)
        {
            if ($curUnit['mapping'] = 'category')
                $collect .= $this->translateListUnit($curUnit);
        }
        $collect .= "<div id=\"$this->curPrefix" . "_noresults" . "\" class=\"listingNoResults\"><div>No Results Found</div></div>";
        $collect .= "</div>";

        //format the search box
        $queryName = $this->curPrefix . "query";
        $queryResultsName = $queryName . "_results";
        $searchBox = ($parentTrans->getOption('showSearchBox')) ? <<<END_SEARCHBOX
<table class="ListingQuery" border="0"><tr><td><span class="queryContainer"><input type="text" id="$queryName" value="Search this list"
onclick="javascript:if(this.value=='Search this list') this.value='';" onblur="javascript:if(this.value=='') this.value='Search this list';" /><span id="$queryResultsName" class="results" >Calculating...</span></span></td></tr></table>
END_SEARCHBOX
: "";

        //format the categories list in a box
        array_push($this->catBuf, <<<END_LIST_BOX
<a href="javascript:listAll('$this->curPrefix');" style="font-weight:bold">Show All</a>
END_LIST_BOX
);
        $categoriesList = ($parentTrans->getOption('showCategoryLinks')) ? '<div class="CategoryLinks"><span class="categoryLinksContainer">' . implode('&nbsp;&nbsp;&bull;&nbsp; ', $this->catBuf) . "</span></div>" : "";

        // send the content out
        $parentTrans->sendToTarget($si, $searchBox . $categoriesList . $collect);

        $collectJS = "listings[$this->listNum] = new listing('$this->curPrefix',new Array(";
        $collectJSArr = array();
        for($i=0;$i<count($this->catIdBuf);$i++)
        {array_push($collectJSArr, "new ctg('" . $this->catIdBuf[$i] . "'," . $this->catCountBuf[$i] . ")"); }
        $collectJS .= implode(",", $collectJSArr);
        $collectJS .= "));";
        $parentTrans->getPage()->appendToSlot('ExtraJS', <<<END_JS
queries[$this->listNum]='$queryName';queryValues[$this->listNum]='-1';
$collectJS
END_JS
);
        $parentTrans->getPage()->appendToSlot('OnLoad', "setTimeout('queryLists();', 300);");

        // increment variables
        $this->listNum++;

        return true;
    }

    /*-----------------------------------------------------*/
    /* Translate an entire unit, or category, of a list
    /*-----------------------------------------------------*/
    protected function translateListUnit ($curUnit)
    {
        if (!isset($curUnit->name)) {
            $this->setPrettyError('translate', '<section> XML tag missing a child <name> tag.');
            return false;
        }

        $id = $this->curPrefix . "_ctg" . $this->catCount;
        $countid = $id . "_count";
        $headid = $id . "_header";

        array_push($this->catIdBuf, $id);
        array_push($this->catBuf, <<<END_LINK
<a href="javascript:listCat('$this->curPrefix',$this->catCount);">$curUnit->name</a>
END_LINK
);

        // collect HTML
        $collect = "<div id=\"$id\">";
        $collect .= <<<END_HEADER

<div class="listingHeader" id="$headid"><span class="listingHeaderText">$curUnit->name&nbsp;&nbsp;<span id="$countid">(...)</span></span></div>
END_HEADER;
        $this->firstInSection = true;
        $localcount = 0;
        $this->countByCat = 0;
        foreach($curUnit->section as $page)
        {
            if ($page['mapping'] == 'item'){
                $collect .= $this->translateListPage($page);
                $this->listItemCount++;
                $this->firstInSection = false;
                $localcount++;
                $this->countByCat++;
            }
        }
        $collect .= "</div>";
        // end collect HTML

        array_push($this->catCountBuf, $localcount);
        $this->catCount++;
        return $collect;
    }

    /*-----------------------------------------------------*/
    /* Translate a page -- or row -- of the list
    /*-----------------------------------------------------*/
    protected function translateListPage ($page)
    {
        $pageStyleClass = $pageStyleId = "";

        $class = ($this->isEvenRow()) ? "evenRow" : "oddRow";
        $class .= ($this->isFirstInSection()) ? " firstInSection" : "";
        //$content = $this->transHelper->formatBlockHtml($page->section->block);

        $content = "";

        $doc = SXMLHelper::parse($page->asXML(), true);
        if(!$doc)
            return false;

        foreach($doc->childNodes as $child) {
            $content .= $this->processBlockLevelElementContainerXML($child);
        }

        if($page->listItemData->class) {
            $pageStyleClass .= " " . $page->listItemData->class . ' ';
        }

        // make sure that page name is set in input
        if (!isset($page->name)) {
            $this->setPrettyError('translate', 'XML <section> item tag missing a <name> tag.');
            return false;
        }

        // create the page name
        $pageName = $page->name;

        /* This tests for sectionData and listItemData tags.
        * listItemData is the old tag name and should be phased out.
        * This code prefers sectionData, if it exists, but still
        * supports ListItemData*/
        $dataTag = 'sectionData';
        if(!isset($page->sectionData) && isset($page->listItemData))
            $dataTag = 'listItemData';

        $link = "";
        // create the link
        if (isset($page->$dataTag->link))
        {
            $link = $page->$dataTag->link['href'];
            $linkStart = "<a href=\"$link\">";
            $linkEnd = "</a>";
        } else { $linkStart = $linkEnd = ""; }

        $thumbnail = "";
        if (isset($page->$dataTag)){

            // create the thumbnails
            if (isset($page->$dataTag->media))
            {
                $snapid = $page->$dataTag->media['snapid'];
                if($page->$dataTag->media['which'])
                    $which = $page->$dataTag->media['which'];
                else
                    $which = 'thumb';

                if(strpos($snapid, "/") !== false)
                    $res = SnapResource::lookup($snapid);
                else {
                    $res = SnapResource::retrieve((int)$snapid);
                }

                $imgURL = "";

                if($res != null) {
                    $version = $res->getActiveVersion();
                    if($version != null) {
                        $imgURL = $version->getContentModule()->getURL($which);
                        $imgURL = $version->getContentModule()->getURL($which);
                    }
                }

                $linkThumbClass = "";
                if ($link == ""){ $thumblink = "";}
                else { $thumblink = " onclick=\"location.href='$link';\" "; $linkThumbClass = "clickable"; }


                $thumbnail = <<<END_THUMB
    <div class="thumbnail $linkThumbClass" style="background-image:url('$imgURL');" $thumblink >&nbsp;</div>
END_THUMB;

            }

            // there is a style tag
            if (isset($page->$dataTag->style)) {
                $style = $page->$dataTag->style;

                // if there is a class tag, log it
                if (isset($style['class'])) {
                    $pageStyleClass = $style['class'];
                }
                // if there is an id tag, log it
                if (isset($style['id'])) {
                    $pageStyleId = ' id="' . $stype['id'] .'" ';
                }
            }

        }

        $collect = "";
        $id = $this->curPrefix . "_" . "ctg" . $this->catCount . "_" . $this->countByCat;
        $collect .= <<<END_ROW

<div class="$class" id="$id">
<div class="rowContainer $pageStyleClass" $pageStyleId>
<div class="rowTitle">$thumbnail$linkStart$pageName$linkEnd</div>
<div class="rowContent">$content</div><br style="clear:both;"/>
</div></div>
END_ROW;
        return $collect;
    }

    /*-----------------------------------------------------*/
    /* Helper functions
    /*-----------------------------------------------------*/

    protected function isEvenRow ()
    {   return ($this->listItemCount % 2 == 0); }

    protected function isFirstInSection ()
    {   return ($this->firstInSection); }
}



?>

---