XForms/XFormsInterfaceBuilder.php5

<?php
/* ------------------------------------------------------------------ */
/* XFormsInterfaceBuilder 1.0 */
/* jwsm updated interface look 3/21/08
/* jwsm@shodor.org | 9-23-06
/*
/* The XForms interface builder is the "view" for the Shodorx Forms
/* Engine. It renders the entire HTML page from the XML source.
/* This builder will check to see if there are errors set in the
/* parent and will include them while rendering. It will also check
/* for values set in the $_POST variables for already-submitted
/* values, and put them back into the fields onscreen so that the
/* user will not lose any submitted information in the case that
/* the form is returned.
/*
/* The main body of the code, formatXFormsInterface(), loops through
/* all the tags in the control section and switches on their type.
/* It then calls other formatting methods to deal with different
/* type input tags (i.e., input, textarea, select, select1).
/*
/* ------------------------------------------------------------------ */

class XFormsInterfaceBuilder extends SObject {

/* ------------------------------------------------------------------ */
/* INITIALIZATION */
/* ------------------------------------------------------------------ */

    /* ------------------------------------------------------------------ */
    /* Variables */
    /* ------------------------------------------------------------------ */
    protected $parent;
    protected $namePrefix = "shodor_xforms_";
    protected $validator;
    protected $selectCount;

    protected $inputWidth = 50;
    protected $textAreaWidth = 49;
    protected $tableBorder = 0;
    protected $tableWidth = 700;
    protected $tablePadding = 1;
    protected $tableSpacing = 5;

    protected $xformCache = null;
    /* ------------------------------------------------------------------ */
    /* Constructor */
    /* ------------------------------------------------------------------ */
    public function __construct ( $parent )
    {
        $this->parent = $parent;
        $this->validator = new StandardValidator();
        $this->selectCount = array();
    }


/* ------------------------------------------------------------------ */
/* HELPER METHODS */
/* ------------------------------------------------------------------ */

    public function getIdPrefix() {
        return $this->namePrefix;
    }

    /* ------------------------------------------------------------------ */
    /* Get values for nodes first from $_POST and then from XML */
    /* ------------------------------------------------------------------ */
    public function getPresetValues ( $node, $xml )
    {
        /* get the values that are actually in the XML file */
        $nodes = $this->findXMLNode($node, $xml);
        $result = array();
        if (!is_array($nodes)){
            $this->setError('Could not look up preset values for non-existent node "' . $node . '"');
            return array();
        }
        foreach($nodes as $n) {
            // takes actual *values* from input XML and pushes
            // them (not entire surrounding tag) onto list of values
            // DEBUGGING 7-31-08 -- TODO
            //print('node is ');
            //print_r($n);
            $val = SXMLHelper::contentFromXML((string)$n);
//          $val = XFormsFunctions::XMLToContent((string)$n);
            if ($val != '') {
                array_push($result, $val);
            }
        }

        /* check to see if there is a preset tag for this item */
        // if there is a preset set in the code (post XML), then
        // substitute any presets from the XML with the presets from
        // the code.
        $preset = $this->parent->getPreset($node);
        if($preset && count($nodes) > 0){
            //print("setting a preset");

            // if preset is a single value, throw an error
            if (!is_array($preset)) {
                $this->setPrettyError('getPresetValues', 'Preset for node ' . $node . ' was a '
                                        . 'string. Expecting array.');
                return false;
            }

            // preset should be an array -- loop through the items and process
            // each one with the XMLToContent function. Then return the array.
            $result = array();
            foreach ($preset as $pkey => $pval) {
                $result[$pkey] = SXMLHelper::contentFromXML($pval);
//              $result[$pkey] = XFormsFunctions::XMLToContent($pval);
            }
            $result = $preset;
    //      $result = XFormsFunctions::XMLToContent($preset);
        }
        return $result;
    }

    public function findXMLNode($node, $xml)
    {
        if (!isset($xml->model->instance)) {
            $this->setPrettyError('findXMLNode', 'model->instance node not found');
            return false;
        }

        $instance = $xml->model->instance;
        $result = array();

        /* search first with the explicit path */
        if (count($instance->xpath($node)) > 0 ){
            $result = $instance->xpath($node);

        /*  if that's not successful, search for a node inside the instance */
        } else if (count($instance->xpath("//instance/" . $node)) > 0) {
            $result = $instance->xpath("//instance/" . $node);

        /*  if that's not successful, search for a node inside the model directly */
        } else if (count($instance->xpath("//model/" . $node)) > 0) {
            $result = $instance->xpath("//model/" . $node);

        /*  if that's not successful, search with the "//" xpath, meaning
            any node in the instance with that name */
        } else if (count($instance->xpath("//" . $node)) > 0) {
            $result = $instance->xpath("//" . $node);

        /* ERROR: all fields should theoretically be in the instance */
        } else {
            $this->setError('Field "' . $node . '" appears in controls section but not in model section.');
            //print("Field $node Not Found In Instance");
            return false;
        }
        return $result;
    }

    public function getValuesFromPOST ( $node, $xml, $count = 0 )
    {
        # generate the field name
        $fieldName = $this->namePrefix . $node;

        # if the field name is set directly, return that
        if (isset($_POST[$fieldName])) {
            $postData = $_POST[$fieldName];
            return array($postData);
        }

        # return array for multiple-select lists that have numbered items
        $eltIndex = $fieldName . "_" . $count;

        # if the element is set, return it (decoded); otherwise return empty array
        return (isset($_POST[$eltIndex])) ?
            array($_POST[$eltIndex])
            //array(html_entity_decode($_POST[$eltIndex], ENT_QUOTES, "UTF-8"))
            : array();
    }

    public function getValueForInstanceNode ( $node, $xml, $count = 0) {
        return ($this->parent->isSubmitted()) ?
            $this->getValuesFromPOST($node, $xml, $count)
            : $this->getPresetValues($node, $xml);
    }

    public function getFirstValueForInstanceNode ($node, $xml, $count = 0) {
        $array = $this->getValueForInstanceNode($node, $xml, $count);
        $return = (count($array) > 0) ? $array[0] : $array;
        return $return;
    }

    public function incrementSelectCount ($node) {
        if (!isset($this->selectCount["$node"])) { $this->selectCount["$node"] = 0; }
        else { $this->selectCount["$node"]++; }
        return $this->selectCount["$node"];
    }


/* ---------------------------------------------------------------------- */
/* MAIN FORMATTING CONTROL */
/* ---------------------------------------------------------------------- */

    /* ------------------------------------------------------------------ */
    /* Format XForms Interface - translate XML to HTML */
    /* ------------------------------------------------------------------ */

    public function formatXFormsInterface ( $xform )
    {
        global $TRANSACTION;
        /* Initialize vars */
        $infoArray = array();
        $htmlOutput = "";

        $this->xformCache = $xform;

        /* If there is a submission element in the form, build the FORM tag */
        $hasSubmission = isset($xform->model->submission);
        if ($hasSubmission){
            $id = $xform->model->submission['id'];
            $action = $xform->model->submission['action'];
            if($this->parent->getOption('formAction') != "") {
                $action = $this->parent->getOption('formAction');
            }
            if ($action == "SELF") {
                $action = $_SERVER['PHP_SELF'];
                $action = $_SERVER['REQUEST_URI'];
            }
            if (SConfig::getOption('xforms.action') != '') {
                $action = SConfig::getOption('xforms.action');
            }
            $method = $xform->model->submission['method'];

            /* introduce transaction support for use with CSERD */
            $transId = ($TRANSACTION == null) ? "" :
                    $TRANSACTION->getTransaction();
            $transInput = "";
            $tokenInput = "";
            if ($transId != "") {

            $transInput =<<<ENDTRANS
<input type="hidden" name="transaction" value="$transId" />
ENDTRANS;
            }
            if ($this->parent->getOption('token')) {
            $token = sha1(session_id() . 'hasdfhv894h3gpvub');
            $tokenInput =<<<ENDTOKEN
<input type="hidden" name="xformtoken" value="$token" />
ENDTOKEN;
            }

            $method = strtolower($method);

            $htmlOutput .=<<<END_OUTPUT
<div class="shodorxformWrapper">
<form class="shodorxform" action="$action" id="$id" method="$method" enctype="multipart/form-data" accept-charset="utf-8">
$transInput
$tokenInput
END_OUTPUT;
        }

        /* If there are errors remaining, make a note to the user */
        if ($this->parent->getErrorCount() > 0)
        {
            $errorCount = $this->parent->getErrorCount();
            $htmlOutput .= <<<END_OUTPUT
<div class="errorHeader" align="center">&darr;&nbsp;Your submission was not complete. Please see the $errorCount errors marked below:&nbsp;&darr;</div>
END_OUTPUT;
        }


        $formErr = $this->getParent()->getErrorCode('FORM');
        if ($formErr != '') {
            $formErrText = $this->getValidator()->getErrorCode($formErr);
            $htmlOutput .= <<<END_OUTPUT
<div class="errorHeader" align="center">$formErrText</div>
END_OUTPUT;
        }




        $lastChild = null;  # will hold the child
        $curGroup = null;   # will hold the current group; stored at start of next iteration
        $curGroupItemList = array();    #holds the list of items of the first control of the cur group
        $groups = array();  # the list to which groups are added after each iteration


        /* Loop through and append the form elements */
        foreach($xform->children() as $tag => $child)
        {

            /* CREATE THE CONTROL ELEMENT
                switch to decide what type of element to create
            */

            $control = null;
            switch($tag) {
                case 'select1':
                    $control = new XFormsSelect1Control();
                    $control->addItemsFromXMLTree($child);
                    break;
                case 'select':
                    $control = new XFormsSelectControl();
                    $control->addItemsFromXMLTree($child);
                    break;
                case 'input':
                    $control = new XFormsInputControl();
                    break;
                case 'password':
                    $control = new XFormsSecretControl();
                    break;
                case 'upload':
                    $control = new XFormsUploadControl();
                    break;
                case 'textarea':
                    $control = new XFormsTextareaControl();
                    break;
                case 'textbox':
                case 'submit':
                    $control = new XFormsSubmitControl();
                    break;
                case 'text':
                    $control = new XFormsTitleControl();
                    break;
                case 'model':
                    break;
                default:
                    $this->setPrettyError('formatXFormsInterface', 'Unknown tag found: ' . $tag);
                    return false;
                    break;
            }

            # if this control is null, skip it
            if ($control == null) continue;

            /* SET PROPERTIES
                use the XML to set the different properties on the control element
            */


            # set the parent attribute (the link to THIS InterfaceBuilder object)
            $control->setParent($this);

            # Get the description from the element
            if (isset($child->description)) {
                $xml = $child->description->asXML();
                $xml = str_replace("<description>", "", $xml);
                $xml = str_replace("</description>", "", $xml);
                $xml = SXMLHelper::contentFromXML($xml);
                $control->setDescription($xml);
            }

            # Set the appearance
            if ( isset($child['appearance'])) {
                $control->setAppearance($child['appearance']);
            }

            # set the ref-- binding to the instance XML
            if (isset($child['ref'])) {
                $control->setRef($child['ref']);
                $control->setRequired($this->isRequired($control->getRef(), $xform));
            }

            # set the location
            if (isset($child['location'])) {
                $control->setLocation($child['location']);
            }

            $control->searchForInputValues();


            /* NEW QUESTION GROUP?
                Decide if we need to make a new group or not */
            $curItemValues = $control->getItemValues();

            if ($curGroup != null
                && (count($curItemValues) > 0)
                && (SConfig::getOption('xforms.collapseIdentical') == true)
                && (count(array_diff($curItemValues, $curGroupItemList)) == 0 &&
                    count(array_diff($curGroupItemList, $curItemValues)) == 0)) {

                # USE THE EXISTING QUESTION GROUP
                # (if they are the same, just use the old group - don't make a new one)

                # set the question group's display mode to grid
                $curGroup->setDisplayMode('grid');

                # Transfer the label from the XML to be the group label
                $labelHTML = $this->getHTMLFromLabelXML($child);
                if ($labelHTML != '') {
                    $control->setLabel($labelHTML);
                }

            } else {

                # MAKE A NEW QUESTION GROUP
                # If they are not the same, or if we're not collapsing questions,
                # we need to make a new question group

                # store the old group
                if ($curGroup != null){
                    array_push($groups, $curGroup);
                }

                # Decide which type of group we are making based on the first element
                # to go into that group
                switch($tag) {
                    case 'text':
                        $curGroup = new XFormsTextGroup();
                        break;
                    case 'submit':
                        $curGroup = new XFormsSubmitGroup();
                        break;
                    default:
                        $curGroup = new XFormsControlGroup();
                        break;
                }

                //$curGroupItemList = array();
                $curGroupItemList = ($control->getItemValues());

                # Transfer the label from the XML to be the group label
                $labelHTML = $this->getHTMLFromLabelXML($child);
                if ($labelHTML != '') {
                    $curGroup->setLabel($labelHTML);
                    $control->setLabel($labelHTML);
                }

            }

            # LINK THE GROUP INTO THE CONTROL
            # set the group attribute (what group is the control in on the page)
            $control->setGroup($curGroup);

            # ADD THE CONTROL TO THE GROUP
            $curGroup->addControl($control);
        }

        # push the last group onto the array
        if ($curGroup != null) {
            array_push($groups, $curGroup);
        }


        /* Render out and append each group to the buffer */
        foreach($groups as $g) {
            $htmlOutput .= $g->render();
        }

        /* Print out token error if necessary*/
        $xfe = $this->parent->getValidator()->getErrorCode(
                    $this->parent->getErrorCode('token'));
        if ($xfe != '') {
            $errLabel = new TKLabel('&uarr; ' . $xfe);
            $errLabel->class = array('errorMsg');
            $box = new TKVBox();
            $box->add($errLabel);
            $htmlOutput .= $box->render();
        }

        if ($hasSubmission){
            $htmlOutput .= "</form></div>";
        }

        return $htmlOutput;
    }

/* ---------------------------------------------------------------------- */
/* HELPER METHODS */
/* ---------------------------------------------------------------------- */
/*  */

    protected function getHTMLFromLabelXML($child) {
        if (isset($child->label))
        {
            # get the label, preserving the formatting inside the XML
            $xml = $child->label->asXML();
            $xml = str_replace("<label>", "", $xml);
            $xml = str_replace("</label>", "", $xml);
            $xml = SXMLHelper::contentFromXML($xml);
            return $xml;
        }
        return '';
    }

    public function isRequired ($ref, $xform)
    {
        $node = $this->findXMLNode($ref, $xform);
        return ((count($node) > 0) && (isset($node[0]['required'])) && ($node[0]['required'] == "true()"));
    }

    public function getItemCount ($tag)
    {
        return (isset($this->itemCount["$tag"])) ? $this->itemCount["$tag"] : 0;
    }

    public function getNamePrefix ()
    {
        return $this->namePrefix;
    }

    public function getValidator ()
    {
        return $this->validator;
    }

    public function getParent() {
        return $this->parent;
    }

    public function getXFormCache() {
        return $this->xformCache;
    }

}

?>

---