simple_form.inc

<?php
require_once SQ_INCLUDE_PATH.'/asset.inc';
require_once SQ_FUDGE_PATH.'/general/general.inc';
require_once SQ_CORE_PACKAGE_PATH.'/interfaces/bridge/bridge.inc';


class Simple_Form extends Asset implements Bridge
{


    var $_errors = Array();


    var $_answers = Array();


    function Simple_Form($assetid=0)
    {
        $this->_ser_attrs = TRUE;
        $this->Asset($assetid);

    }//end constructor


//--        BRIDGE FUNCTIONS        --//


    function getAsset($assetid, $type_code='', $mute_errors=FALSE)
    {
        $asset = NULL;
        $id_parts = explode(':', $assetid);

        if (isset($id_parts[1])) {
            $shadowid = $id_parts[1];
        } else {
            return $asset;
        }

        // Questions follow the format '<assetid>:q<shadowid>'
        if ($shadowid{0} == 'q') {

            // pick up the question in question (!)
            $questions = $this->attr('questions');
            $questionid = substr($shadowid, 1, strlen($shadowid));
            if (empty($questions[$questionid])) return $asset;

            $q_type_code = $questions[$questionid]['type_code'];

            // not fussed about type code?
            if (empty($type_code)) $type_code = $q_type_code;

            // only give the asset back if of the right type code
            if (in_array($q_type_code, $GLOBALS['SQ_SYSTEM']->am->getTypeDescendants($type_code, TRUE))) {
                $questions[$questionid]['questionid'] = $questionid;
                $GLOBALS['SQ_SYSTEM']->am->includeAsset($q_type_code);

                // this eval returns the necessary object for the question type
                $asset = new $q_type_code($this->id, $questions[$questionid]);
            }
        }

        return $asset;

    }//end getAsset()


    function getLinks($assetid, $link_types, $type_code='', $strict_type_code=TRUE, $side_of_link='major', $sort_by=NULL, $dependant=NULL, $exclusive=NULL)
    {
        // there are no links away from the shadow asset (ie:questions)
        if (!is_numeric($assetid)) {
            $links = Array();
            if ($side_of_link == 'minor') {
                $return_link = FALSE;

                if ($type_code == '') {
                    // not fussed what we're getting, so return me
                    $return_link = TRUE;
                } else if ($strict_type_code) {
                    // strict type code check
                    $return_link = ($type_code == $this->type());
                } else {
                    $return_link = (in_array($this->type(), $GLOBALS['SQ_SYSTEM']->am->getTypeDescendants($type_code, TRUE)));
                }

                if ($return_link) {
                    $links[] = Array(
                                'linkid'            => 0,
                                'majorid'           => $this->id,
                                'minorid'           => $this->id.':'.$assetid,
                                'major_type_code'   => $this->type(),
                                'value'             => '',
                                'link_type'         => SQ_LINK_TYPE_2,
                                'is_dependant'      => TRUE,
                                'is_exclusive'      => FALSE,
                                'sort_order'        => 0,
                                'locked'            => 0,
                               );
                }
            }

            return $links;
        }//end if assetid is not numeric

        $links = Array();
        $new_sort_order = 0;

        // are we getting our bodycopy and/or nested forms (if they all exist)?
        $real_type_codes = Array(
                            'bodycopy'      => SQ_LINK_TYPE_2 | SQ_LINK_TYPE_3,
                            'simple_form'   => SQ_LINK_TYPE_2,
                           );

        foreach ($real_type_codes as $real_type_code => $allowed_link_types) {
            if ($type_code == '') {
                // not fussed what we're getting, so return me
                $get_type = TRUE;
            } else if ($strict_type_code) {
                $get_type = ($type_code == $real_type_code);
            } else {
                // specific type code set, non-strict check
                $get_type = (in_array($real_type_code, $GLOBALS['SQ_SYSTEM']->am->getTypeDescendants($type_code, TRUE)));
            }

            // we are getting this type?
            if ($get_type) {
                $links_query = $GLOBALS['SQ_SYSTEM']->am->generateGetLinksQuery($assetid, $link_types & $allowed_link_types, $real_type_code, FALSE);
                $type_links = NULL;
                try {
                    $query = MatrixDAL::preparePdoQuery(implode(' ', $links_query['sql_array']));

                    foreach($links_query['bind_vars'] as $bind_var => $bind_value) {
                        MatrixDAL::bindValueToPdo($query, $bind_var, $bind_value);
                    }
                    $type_links = MatrixDal::executePdoAssoc($query);
                } catch (Exception $e) {
                    throw new Exception($e->getMessage());
                }

                foreach (array_keys($type_links) as $key) {
                    $type_links[$key]['sort_order'] = $new_sort_order;
                    $links[] = $type_links[$key];
                    $new_sort_order++;
                }
            }
        }

        // but we also need question shadow asset links
        if ($link_types & SQ_LINK_TYPE_2) {
            $questions = $this->attr('questions');

            // keep a cache of asset type codes if we are checking on a non-strict
            // type code, to stop us calling getTypeDescendants() all the time
            // (not needed if strict type check or if not fussed)
            $get_question_types = Array();

            foreach ($questions as $questionid => $data) {
                if ($type_code == '') {
                    // not fussed what we're getting, so return me
                    $get_question = TRUE;
                } else if ($strict_type_code) {
                    // strict type code check
                    $get_question = ($type_code == $data['type_code']);
                } else {
                    // if we've already cached whether this question type is to be
                    // returned, then we don't need to look it up again
                    if (isset($get_question_types[$data['type_code']])) {
                        $get_question = $get_question_types[$data['type_code']];
                        $get_question_types[$data['type_code']] = $get_question;
                    } else {
                        $get_question = (in_array($data['type_code'], $GLOBALS['SQ_SYSTEM']->am->getTypeDescendants($type_code, TRUE)));
                    }
                }

                if ($get_question) {
                    $links[] = Array(
                                'linkid'            => 0,
                                'majorid'           => $this->id,
                                'minorid'           => $this->id.':q'.$questionid,
                                'minor_type_code'   => $data['type_code'],
                                'value'             => '',
                                'link_type'         => SQ_LINK_TYPE_2,
                                'is_dependant'      => TRUE,
                                'is_exclusive'      => FALSE,
                                'sort_order'        => $new_sort_order,
                                'locked'            => 0,
                               );
                }
                $new_sort_order++;
            }//end foreach
        }//end if

        if (is_null($sort_by)) $sort_by = 'sort_order';

        uasort($links, create_function('$a,$b','return $a["'.$sort_by.'"] > $b["'.$sort_by.'"];'));

        return $links;

    }//end getLinks()


    function getAssetMapLinks()
    {
        $new_sort_order = 0;
        $old_links = $this->getLinks($this->id, SQ_SC_LINK_BACKEND_NAV);
        $links = Array();
        while (!empty($old_links)) {
            array_push($links, array_shift($old_links));
        }

        $questions = $this->attr('questions');

        foreach (array_keys($links) as $i) {

            $link = &$links[$i];
            if ($link['minor_type_code'] == 'bodycopy') {
                unset($links[$i]);
                continue;
            }

            if ($link['minor_type_code'] == 'simple_form') {
                unset($links[$i]);
                continue;
            }

            // mould it all to the asset map's liking
            $link['url'] = '';
            $link['path'] = '';
            $link['num_kids'] = 0;
            $link['accessible'] = 1;

            $link['assetid'] = $link['minorid'];
            $link['type_code'] = $link['minor_type_code'];
            $link['linkid'] = $link['majorid'].':'.$link['minorid'];

            $questionid = str_replace($this->id.':q', '', $link['assetid']);

            // make name and short name the same
            $link['name'] = $questions[$questionid]['attributes']['name'];
            $link['short_name'] = $link['name'];

            // make the status the same as the form's one
            $link['status'] = $this->status;

            unset($link['minor_type_code']);
            unset($link['majorid']);
            unset($link['minorid']);
            unset($link['value']);
            unset($link['is_exclusive']);

        }//end foreach

        return $links;

    }//end getAssetMapLinks()


    function getParents($shadowid, $type_code='', $strict_type_code=TRUE)
    {
        // basically get the parents of the section, and add itself in the
        $ret_val = $GLOBALS['SQ_SYSTEM']->am->generateGetParentsQuery($this->id, $type_code, $strict_type_code);
        if (empty($ret_val)) return Array();

        $queried_parents = NULL;
        try {
            $query = MatrixDAL::preparePdoQuery(implode(' ', $ret_val['sql_array']));
            foreach ($ret_val['bind_vars'] as $bind_var => $bind_value) {
                MatrixDAL::bindValueToPdo($query, $bind_var, $bind_value);
            }

            $queried_parents = MatrixDAL::executePdoAll($query);
        } catch (Exception $e) {
            throw new Exception($e->getMessage());
        }//end

        $parents = Array();

        foreach ($queried_parents as $queried_parent) {
            $parents[$queried_parent['majorid']] = $queried_parent['type_code'];
        }

        $parents[$this->id] = $this->type();

        return $parents;

    }//end getParents()


    function getChildren($assetid, $type_code='', $strict_type_code=TRUE, $dependant=NULL, $sort_by=NULL)
    {
        // no shadow assets have children in this asset
        if (!is_numeric($assetid)) return Array();

        if (!is_array($type_code)) {
            if (empty($type_code)) {
                $type_code = Array();
            } else {
                $type_code = Array($type_code);
            }
        }

        $children = Array();

        // this is so we get the sections as we go
        // have to do this all in here because calling asset manager will bring on a vicious loop
        $asset = $GLOBALS['SQ_SYSTEM']->am->getAsset($assetid);
        if (($asset instanceof Bridge) && ($assetid != $this->id)) {
            $children = $asset->getChildren($assetid, $type_code, $strict_type_code, $dependant, $sort_by);
            $this->forgetAsset($asset);
        } else {
            $ret_val = $GLOBALS['SQ_SYSTEM']->am->generateGetChildrenQuery($asset, $type_code, $strict_type_code, $dependant, $sort_by);
            unset($asset);


            if (!empty($ret_val)) {
                $sql_array = $ret_val['sql_array'];
                $bind_vars = $ret_val['bind_vars'];

                $result = NULL;
                try {
                    $query = MatrixDAL::preparePdoQuery(implode(' ', $sql_array));
                    foreach ($bind_vars as $bind_var => $bind_value) {
                        MatrixDAL::bindValueToPdo($query, $bind_var, $bind_value);
                    }
                    $result = MatrixDal::executePdoGroupedAssoc($query);
                } catch (Exception $e) {
                    throw new Exception($e->getMessage());
                }

                $children = $result;
            }
        }

        // now questions
        $entries = $this->attr('questions');
        if (empty($type_code)) {
            foreach ($entries as $questionid => $data) {
                $children[$this->id.':q'.$questionid] = Array(Array('type_code' => $data['type_code']));
            }
        } else {
            foreach ($type_code as $this_type_code) {
                foreach ($entries as $questionid => $data) {
                    if ($strict_type_code) {
                        if ($data['type_code'] == $this_type_code) {
                            $children[$this->id.':q'.$questionid] = Array(Array('type_code' => $data['type_code']));
                        }
                    } else {
                        $type_desc = $GLOBALS['SQ_SYSTEM']->am->getTypeDescendants($this_type_code) + Array($this_type_code);
                        if (in_array($data['type_code'], $type_desc)) {
                            $children[$this->id.':q'.$questionid] = Array(Array('type_code' => $data['type_code']));
                        }
                    }
                }
            }
        }

        if (!is_null($sort_by)) {
            uasort($children, create_function('$a,$b','return $a["'.$sort_by.'"] > $b["'.$sort_by.'"]'));
        }

        return $children;

    }//end getChildren()


    function getLineageFromURL($assetid, $protocol, $url)
    {
        return Array();

    }//end getLineageFromURL()


//--        ASSET COMMON FUNCTIONS        --//


    function _getName($short_name=FALSE, $contextid=NULL)
    {
        // No context specified, using the current context
        if ($contextid === NULL) {
            $contextid = $GLOBALS['SQ_SYSTEM']->getContextId();
        }//end if

        // Obtain the attribute value for Name from the specified Context
        $values = $GLOBALS['SQ_SYSTEM']->am->getAttributeValuesByName('name', $this->type(), Array($this->id), $contextid);
        if (empty($values) === TRUE) {
            return parent::_getName($short_name, $contextid);
        } else {
            return $values[$this->id];
        }

    }//end _getName()


    function _getAllowedLinks()
    {
        $links = Array(
                    SQ_LINK_TYPE_2  => Array(
                                        'bodycopy'      => Array(
                                                            'card'      => '1',
                                                            'exclusive' => FALSE,
                                                           ),
                                        'simple_form'   => Array(
                                                            'card'      => 'M',
                                                            'exclusive' => FALSE,
                                                           ),
                                       ),
                    SQ_LINK_TYPE_3  => Array(
                                        'bodycopy'  => Array(
                                                        'card'      => '1',
                                                        'exclusive' => FALSE,
                                                       ),
                                       ),
                 );
        return $links;

    }//end _getAllowedLinks()


//--        QUESTION HANDLING FUNCTIONS        --//


    function createQuestion($type_code, $name=NULL)
    {
        $next_question = $this->attr('next_question');
        $questions = $this->attr('questions');

        // if we weren't passed a name for some reason, set a default based on
        // the 'next question' counter
        if (is_null($name)) {
            $name = 'Question '.$next_question;
        }

        // set up the new question and bump the 'next question' counter
        $questions[$next_question] = Array(
                                        'type_code'     => $type_code,
                                        'name'          => $name,
                                        'sort_order'    => count($questions),
                                        'attributes'    => Array(
                                                            'name'  => $name,
                                                           ),
                                     );

        $this->setAttrValue('questions', $questions);
        $this->setAttrValue('next_question', $next_question + 1);

        // for system integrity purposes, acquire the lock on the new question
        $GLOBALS['SQ_SYSTEM']->am->acquireLock($this->id.':q'.$next_question, 'all', $this->id, TRUE);
        $GLOBALS['SQ_SYSTEM']->am->updateLock($this->id, 'all');

        return TRUE;

    }//end createQuestion()


    function deleteQuestion($assetid)
    {
        list($sectionid, $shadowid) = explode(':q', $assetid);

        // make sure we can actually do something this
        if ($sectionid != $this->id) {
            // TRANSLATE: Get an error number for this
            trigger_error('Cannot delete question '.$assetid.' from '.translate('asset_format', $this->_getName(), $this->id).' as it does not belong to this section', E_USER_WARNING);
            return FALSE;
        }

        $questions = $this->attr('questions');

        if (!isset($questions[$shadowid])) {
            // TRANSLATE: Get an error number for this
            trigger_error('Cannot delete question '.$assetid.' from '.translate('asset_format', $this->_getName(), $this->id).' as it does not exist', E_USER_WARNING);
            return FALSE;
        } else {
            unset($questions[$shadowid]);
        }

        $this->setAttrValue('questions', $questions);
        return TRUE;

    }//end deleteQuestion()


    function paintQuestion($assetid)
    {
        $q = $GLOBALS['SQ_SYSTEM']->am->getAsset($assetid);
        echo $q->getHTMLField();

    }//end paintQuestion()


//--        FRONT-END PROCESSING FUNCTIONS        --//


    function process()
    {
        if (!isset($this->_is_processed)) {
            $this->_errors = Array();
            $this->_answers = Array();

            foreach ($this->attr('questions') as $shadowid => $data) {
                // get the question
                $assetid = $this->id.':q'.$shadowid;
                $name = 'q'.$assetid;
                $q = $GLOBALS['SQ_SYSTEM']->am->getAsset($assetid);
                $q->populate($this);

                // set the value and check whether it's valid
                if (isset($_POST[$name])) $q->setValue($_POST[$name]);
                $valid = $q->hasValidValue();

                if (!$valid) $this->_errors = array_merge($this->_errors, $q->getErrors());

                $this->_answers[$assetid] = Array(
                                                'name'          => $data['name'],
                                                'type_code'     => $data['type_code'],
                                                'value'         => $q->getValue(),
                                                'summary'       => $q->getSummary(),
                                                'extra_data'    => $q->getExtraData(),
                                                'is_error'      => !$valid,
                                            );

                $GLOBALS['SQ_SYSTEM']->am->forgetAsset($q);
                unset($q);

            }//end foreach question

            // Now, handle nested forms
            foreach ($GLOBALS['SQ_SYSTEM']->am->getLinks($this->id, SQ_LINK_TYPE_2, 'simple_form', FALSE) as $link) {
                $sectionid = $link['minorid'];
                $s = $GLOBALS['SQ_SYSTEM']->am->getAsset($sectionid);

                $valid = $s->process();
                if (!$valid) {
                    $this->_errors = array_merge($this->_errors, $s->getErrors());
                }

                $this->_answers += array_merge($this->_answers, $s->getAnswers());

                $GLOBALS['SQ_SYSTEM']->am->forgetAsset($s);
                unset($s);
            }

            $this->_is_processed = TRUE;
        }//end if

        return empty($this->_errors);

    }//end process()


    function getErrors()
    {
        return $this->_errors;

    }//end getErrors()


    function getQuestions($include_nested=FALSE)
    {
        $am = $GLOBALS['SQ_SYSTEM']->am;
        $questions = Array();

        $questions_raw = $this->attr('questions');
        foreach ($questions_raw as $q_id => $question) {
            $new_id = $this->id.':q'.$q_id;
            $questions[$new_id] = $question;

            // clear out unnecessary info from the question info
            unset($questions[$new_id]['attributes']);
        }

        if ($include_nested) {
            $nested_forms = $am->getLinks($this->id, SQ_SC_LINK_SIGNIFICANT, 'simple_form', FALSE);
            foreach ($nested_forms as $link) {
                $form = $am->getAsset($link['minorid']);
                if (!is_null($form)) {
                    $questions = array_merge($questions, $form->getQuestions($include_nested));
                    $am->forgetAsset($form);
                }
            }
        }

        return $questions;

    }//end getQuestions()


    function getAnswers()
    {
        return $this->_answers;

    }//end getAnswers()


    function getAnswerValues()
    {
        $answer_values = Array();
        foreach ($this->_answers as $assetid => $data) {
            $answer_values[$assetid] = $data['value'];
        }
        return $answer_values;

    }//end getAnswerValues()


    function getAnswerSummaries()
    {
        $answer_values = Array();
        foreach ($this->_answers as $assetid => $data) {
            $answer_values[$assetid] = $data['summary'];
        }
        return $answer_values;

    }//end getAnswerSummaries()


    function getAnswerExtraData()
    {
        $answer_values = Array();
        foreach ($this->_answers as $assetid => $data) {
            $answer_values[$assetid] = $data['extra_data'];
        }
        return $answer_values;

    }//end getAnswerExtraData()


//--        CLIENT-SIDE VALIDATION        --//


    function getClientSideJS()
    {
        ob_start();
            ?>submission_errors = new Array();

            <?php
            $init_code = ob_get_contents();
        ob_end_clean();

        $code = '';

        $questions = $this->attr('questions');
        foreach (array_keys($questions) as $key) {
            $q = $GLOBALS['SQ_SYSTEM']->am->getAsset($this->id.':q'.$key);

            $q_code = $q->generateJSCode();
            $code .= $q_code.(empty($q_code) ? '' : "\n");

            $GLOBALS['SQ_SYSTEM']->am->forgetAsset($q);
            unset($q);
        }

        foreach ($GLOBALS['SQ_SYSTEM']->am->getLinks($this->id, SQ_LINK_TYPE_2, 'simple_form', FALSE) as $link) {
            // get the section
            $sectionid = $link['minorid'];
            $s = $GLOBALS['SQ_SYSTEM']->am->getAsset($sectionid);
            $section_questions = $s->attr('questions');

            foreach (array_keys($section_questions) as $key) {
                $q = $GLOBALS['SQ_SYSTEM']->am->getAsset($s->id.':q'.$key);

                $q_code = $q->generateJSCode();
                $code .= $q_code.(empty($q_code) ? '' : "\n");

                $GLOBALS['SQ_SYSTEM']->am->forgetAsset($q);
                unset($q);
            }

            $GLOBALS['SQ_SYSTEM']->am->forgetAsset($s);
            unset($s);
        }

        if (empty($code)) {
            return '';
        } else {
            return $init_code.$code;
        }

    }//end getClientSideJS()


    function getClientSideFunction()
    {
        $code = $this->getClientSideJS();
        if (empty($code)) return '';

        ob_start();
            ?>
<script type="text/javascript">
function beforeSubmit_<?php echo $this->getPrefix() ?>(form) {
    <?php echo $code; ?>

    if (submission_errors.length > 0) {
        var errors_list = "<?php echo translate('core_form_submission_errors'); ?>\n";
        for(x in submission_errors) {
            errors_list += submission_errors[x] + "\n";
        }

        alert(errors_list);
        return false;
    } else {
        return true;
    }
}//end beforeSubmit_<?php echo $this->getPrefix() ?>()
</script>
            <?php
            $code = ob_get_contents();
        ob_end_clean();

        return $code;

    }//end getClientSideFunction()


//--        KEYWORD PROVISION        --//


    function onRequestKeywords(&$broadcaster, $vars=Array())
    {
        $vars['keywords'] = isset($vars['keywords']) ? $vars['keywords'] : Array();
        $keywords = Array();

        if ($this->isFormatBodycopyEnabled()) {
            $keywords = $this->getDisplayKeywords('form_');
        }

        $vars['keywords'] = array_merge($vars['keywords'], $keywords);

    }//end onRequestKeywords()


    function getDisplayKeywords($prefix)
    {
        $questions = $this->attr('questions');
        $keywords = Array();

        foreach ($questions as $shadowid => $question) {
            $keywords[$prefix.$this->id.'_q'.$shadowid] = 'Question Field: '.ellipsisize($question['attributes']['name'], 30).' ('.$this->id.':q'.$shadowid.')';
            $keywords[$prefix.$this->id.'_q'.$shadowid.'_note'] = 'Question Note: '.ellipsisize($question['attributes']['name'], 30).' ('.$this->id.':q'.$shadowid.')';
            $keywords[$prefix.$this->id.'_q'.$shadowid.'_id'] = 'Question ID: '.ellipsisize($question['attributes']['name'], 30).' ('.$this->id.':q'.$shadowid.')';
        }

        foreach ($GLOBALS['SQ_SYSTEM']->am->getLinks($this->id, SQ_LINK_TYPE_2, 'simple_form', FALSE) as $link) {
            // get the section
            $sectionid = $link['minorid'];
            $s = $GLOBALS['SQ_SYSTEM']->am->getAsset($sectionid);

            $keywords += $s->getDisplayKeywords($prefix);
            $keywords[$prefix.$s->id.'_name'] = 'Nested Form Name: '.$s->name.' ('.$s->id.')';

            $GLOBALS['SQ_SYSTEM']->am->forgetAsset($s);
            unset($s);
        }

        $keywords['submit_button'] = 'Submit Button';
        $keywords['reset_button'] = 'Reset Button';
        $keywords['form_errors'] = 'Form Errors';

        return $keywords;

    }//end getDisplayKeywords()


    function getResponseKeywords($prefix)
    {
        $questions = $this->attr('questions');
        $keywords = Array();

        foreach ($questions as $shadowid => $question) {
            $keywords[$prefix.$this->id.'_q'.$shadowid] = 'Summary: '.ellipsisize($question['attributes']['name'], 30).' ('.$this->id.':q'.$shadowid.')';
            $keywords[$prefix.$this->id.'_q'.$shadowid.'_raw'] = 'Raw Response: '.ellipsisize($question['attributes']['name'], 30).' ('.$this->id.':q'.$shadowid.')';
        }

        foreach ($GLOBALS['SQ_SYSTEM']->am->getLinks($this->id, SQ_LINK_TYPE_2, 'simple_form', FALSE) as $link) {
            // get the nested form
            $sectionid = $link['minorid'];
            $s = $GLOBALS['SQ_SYSTEM']->am->getAsset($sectionid);

            $keywords += $s->getResponseKeywords($prefix);
            $keywords[$prefix.$s->id.'_name'] = 'Nested Form Name: '.$s->name.' ('.$s->id.')';

            $GLOBALS['SQ_SYSTEM']->am->forgetAsset($s);
            unset($s);
        }

        return $keywords;

    }//end getResponseKeywords()


//--        KEYWORD REPLACEMENTS PROVISION        --//


    function getDisplayKeywordReplacement($prefix)
    {
        $questions = $this->attr('questions');
        $keywords = Array();

        foreach ($questions as $shadowid => $question) {
            // get the question
            $q = $GLOBALS['SQ_SYSTEM']->am->getAsset($this->id.':q'.$shadowid);
            $keywords[$prefix.$this->id.'_q'.$shadowid] = $q->getHtmlField();
            $keywords[$prefix.$this->id.'_q'.$shadowid.'_note'] = $q->attr('note');
            $keywords[$prefix.$this->id.'_q'.$shadowid.'_id'] = 'q'.$this->id.'_q'.$shadowid;
            $GLOBALS['SQ_SYSTEM']->am->forgetAsset($q);
            unset($q);
        }

        foreach ($GLOBALS['SQ_SYSTEM']->am->getLinks($this->id, SQ_LINK_TYPE_2, 'simple_form', FALSE) as $link) {
            // get the nested form
            $sectionid = $link['minorid'];
            $s = $GLOBALS['SQ_SYSTEM']->am->getAsset($sectionid);

            $keywords += $s->getDisplayKeywordReplacements($prefix);
            $keywords[$prefix.$s->id.'_name'] = $s->name;

            $GLOBALS['SQ_SYSTEM']->am->forgetAsset($s);
            unset($s);
        }

        // Submit Button, Reset Button, Form Errors
        ob_start();
            submit_button('submit_button', $this->attr('submit_button'));
            $submit_button = ob_get_contents();
        ob_end_clean();

        ob_start();
            reset_button('reset_button', $this->attr('reset_button'));
            $reset_button = ob_get_contents();
        ob_end_clean();

        $keywords['submit_button'] = $submit_button;
        $keywords['reset_button']  = $reset_button;
        $keywords['form_errors']   = implode('<br/>', $this->_errors);

        return $keywords;

    }//end getDisplayKeywordReplacement()


    function getResponseKeywordReplacement($prefix)
    {
        $questions = $this->attr('questions');
        $keywords = Array();

        foreach ($questions as $shadowid => $question) {
            $q = $GLOBALS['SQ_SYSTEM']->am->getAsset($this->id.':q'.$shadowid);
            $keywords[$prefix.$this->id.'_q'.$shadowid] = htmlentities($q->getSummary(), ENT_NOQUOTES, SQ_CONF_DEFAULT_CHARACTER_SET);
            $keywords[$prefix.$this->id.'_q'.$shadowid.'_raw'] = htmlentities($q->getValue(), ENT_NOQUOTES, SQ_CONF_DEFAULT_CHARACTER_SET);
            $GLOBALS['SQ_SYSTEM']->am->forgetAsset($q);
            unset($q);
        }

        foreach ($GLOBALS['SQ_SYSTEM']->am->getLinks($this->id, SQ_LINK_TYPE_2, 'simple_form', FALSE) as $link) {
            // get the nested form
            $sectionid = $link['minorid'];
            $s = $GLOBALS['SQ_SYSTEM']->am->getAsset($sectionid);

            $keywords += $s->getResponseKeywordReplacements($prefix);
            $keywords[$prefix.$s->id.'_name'] = $s->name;

            $GLOBALS['SQ_SYSTEM']->am->forgetAsset($s);
            unset($s);
        }

        return $keywords;

    }//end getResponseKeywordReplacement()


//--        CUSTOM FORMAT BODYCOPY FUNCTIONS        --//


    function createFormatBodycopy($enable_on_create=TRUE)
    {
        $_bodycopy_link = $GLOBALS['SQ_SYSTEM']->am->getLinks($this->id, SQ_LINK_TYPE_2 | SQ_LINK_TYPE_3, 'bodycopy', 'format');
        $bodycopy_link = reset($_bodycopy_link);

        // we already have a bodycopy link?!
        if ($bodycopy_link) {
            return FALSE;
        } else {
            $GLOBALS['SQ_SYSTEM']->am->includeAsset('bodycopy');

            $link_type = ($enable_on_create ? SQ_LINK_TYPE_2 : SQ_LINK_TYPE_3);

            $asset = new Bodycopy();
            $copy_link = Array(
                            'asset'         => &$this,
                            'value'         => 'format',
                            'link_type'     => $link_type,
                            'is_dependant'  => 1,
                            'is_exclusive'  => 1,
                         );

            $asset->setAttrValue('name', 'Format Bodycopy');
            if (!$asset->create($copy_link)) return FALSE;

            $GLOBALS['SQ_SYSTEM']->am->forgetAsset($asset);
            unset($asset);
        }

        return TRUE;

    }//end createFormatBodycopy()


    function &getFormatBodycopy($only_if_enabled=TRUE)
    {
        $asset = NULL;

        if ($only_if_enabled) {
            $link_types = SQ_LINK_TYPE_2;
        } else {
            $link_types = SQ_LINK_TYPE_2 | SQ_LINK_TYPE_3;
        }

        $tmp_bodycopy = $GLOBALS['SQ_SYSTEM']->am->getLinks($this->id, $link_types, 'bodycopy', 'format');
        $bodycopy_link = reset($tmp_bodycopy);

        if ($bodycopy_link) {
            $asset = $GLOBALS['SQ_SYSTEM']->am->getAsset($bodycopy_link['minorid'], 'bodycopy');
        }

        return $asset;

    }//end getFormatBodycopy()


    function isFormatBodycopyEnabled()
    {
        $link_types = SQ_LINK_TYPE_2 | SQ_LINK_TYPE_3;

        $_bodycopy_link = $GLOBALS['SQ_SYSTEM']->am->getLinks($this->id, $link_types, 'bodycopy', 'format');
        $bodycopy_link = reset($_bodycopy_link);

        if ($bodycopy_link) {
            return ($bodycopy_link['link_type'] == SQ_LINK_TYPE_2);
        } else {
            return FALSE;
        }


    }//end isFormatBodycopyEnabled()


    function setUseFormatBodycopy($enabled)
    {
        $tmp_bodycopy = $GLOBALS['SQ_SYSTEM']->am->getLinks($this->id, SQ_LINK_TYPE_2 | SQ_LINK_TYPE_3, 'bodycopy', 'format');
        $bodycopy_link = reset($tmp_bodycopy);

        if (!$bodycopy_link) {
            // no bodycopy yet? If we're trying to set to disabled, then we don't
            // need to do anything - if not then we need to create it
            if ($enabled) {
                if (!$this->createFormatBodycopy()) return FALSE;
            }
        } else {
            // set link type to either TYPE_2 if enabled or TYPE_3 if disabled
            $new_link_type = ($enabled) ? SQ_LINK_TYPE_2 : SQ_LINK_TYPE_3;
            if ($bodycopy_link['link_type'] != $new_link_type) {
                $GLOBALS['SQ_SYSTEM']->am->updateLink($bodycopy_link['linkid'], $new_link_type);
            }
        }

        return TRUE;

    }//end setUseFormatBodycopy()


//--        FORM SELF-PRINTING FUNCTIONS        --//


    function printBody($print_form_tags=TRUE, $submit_buttons=TRUE, $form_action='', $print_js=TRUE)
    {
        // return custom bodycopy but ONLY if enabled
        $format_bodycopy = $this->getFormatBodycopy(TRUE);

        // default form action
        if (empty($form_action)) {
            $form_action = $_SERVER['PHP_SELF'];
        }
        
        // We need to print js function even if we are not printing the form here, as another form in higher level (if any) might wanna use it
        if ($print_js && $this->attr('client_side')) {
            $client_side = $this->getClientSideFunction('beforeSubmit_'.$this->getPrefix());
            $onsubmit = ' onSubmit="return beforeSubmit_'.$this->getPrefix().'(this)"';
        } else {
            $client_side = '';
            $onsubmit = '';
        }
        echo $client_side;
        
        if ($print_form_tags) {
            ?><form id="<?php echo $this->getPrefix() ?>" enctype="multipart/form-data" action="<?php echo $form_action; ?>" method="post"<?php echo $onsubmit;  ?>><?php
        }

        // if format bodycopy enabled, print with that, otherwise print default
        if ($format_bodycopy) {
            $this->printCustomFormat($format_bodycopy);
        } else {
            $this->printDefaultFormat($submit_buttons);
        }

        if ($print_form_tags) {
            ?></form><?php
        }

    }//end printBody()


    function printDefaultFormat($submit_buttons=TRUE)
    {
        ?>
        <table>
        <?php foreach ($this->attr('questions') as $shadowid => $question) {
            $q = $GLOBALS['SQ_SYSTEM']->am->getAsset($this->id.':q'.$shadowid);
            $name = array_get_index($question['attributes'], 'name', '');
            $note = array_get_index($question['attributes'], 'note', '');

            $field = $q->getHTMLField();
            ?>
            <tr>
                <td><?php echo $name;
                echo ($note == '') ? '' : ('<br/><span style="font-size:0.8em">'.$note.'</span>'); ?></td>
                <td><?php echo $field; ?></td>
            </tr>
        <?php
            $GLOBALS['SQ_SYSTEM']->am->forgetAsset($q);
            unset($q);
        }

        if ($submit_buttons) {
            ?>
            <tr><td style="text-align:center" colspan="2"><?php
                submit_button('submit_button', $this->attr('submit_button'));
                reset_button('reset_button', $this->attr('reset_button'));
            ?></td></tr>
        <?php }
        ?>
        </table>
        <?php

    }//end printDefaultFormat()


    function printCustomFormat(&$bodycopy)
    {
        $replacements = $this->getDisplayKeywordReplacement('form_');
        $bodycopy->setKeywordReplacements($replacements);
        $bodycopy->printBody();

    }//end printCustomFormat()


//--        FORM STANDARD RECEIPT FUNCTIONS        --//


    function printReceipt($html=TRUE, $include_form_info=TRUE)
    {
        $answers = Array();

        // include form info if asked for
        if ($include_form_info) {
            $form_info = Array();
            $lineage = $GLOBALS['SQ_SYSTEM']->am->getLineageFromURL();
            $lineage_names = Array();
            foreach ($lineage as $asset) {
                $lineage_names[] = $asset['name'];
            }

            $form_info[] = Array(
                            'name'  => 'Form Submitted',
                            'value' => $this->name.' (Id: #'.$this->id.')',
                           );

            $form_info[] = Array(
                            'name'          => 'Form URL',
                            'value'         => current_url(TRUE, TRUE),
                            'html_value'    => '<a href="'.current_url(TRUE, TRUE).'">'.current_url(TRUE, TRUE).'</a>',
                           );

            $form_info[] = Array(
                            'name'  => 'Form Lineage',
                            'value' => implode(' => ', $lineage_names),
                           );

            $form_info[] = Array(
                            'name'  => 'Time of Submission',
                            'value' => date('l, j F Y H:i:s \G\M\TO'),
                           );

            if ($GLOBALS['SQ_SYSTEM']->userPublic()) {
                $form_info[] = Array(
                                'name'  => 'Submitted By',
                                'value' => 'No logged in user',
                               );
            } else {
                $user = $GLOBALS['SQ_SYSTEM']->user;
                $form_info[] = Array(
                                'name'  => 'Submitted By',
                                'value' => $user->name.' (Id: #'.$user->id.')',
                               );
            }

            // set max length equal to "time of submission" (we are getting the
            // max length of a question so the answers will align in the text
            // version)
            $max_name_length = 18;
        } else {
            $max_name_length = 0;
        }

        // gather questions
        foreach ($this->attr('questions') as $shadowid => $question) {
            $q = $GLOBALS['SQ_SYSTEM']->am->getAsset($this->id.':q'.$shadowid);
            $name = array_get_index($question['attributes'], 'name', '');
            $summary = $q->getSummary();

            $answers[] = Array(
                            'name'  => $name,
                            'value' => $summary,
                         );
            $max_name_length = max($max_name_length, strlen($name));

            $GLOBALS['SQ_SYSTEM']->am->forgetAsset($q);
            unset($q);
        }

        // now print the receipt
        if ($html) {
            ?>
            <table>
            <?php
            // only show form info if asked for
            if ($include_form_info) {
                ?>
                <tr><td colspan="2"><strong>Form Information</strong></td></tr>
                <?php foreach ($form_info as $form_info_item) {
                    ?>
                    <tr>
                        <td valign="top"><ul><li><?php echo htmlspecialchars($form_info_item['name']); ?>:</li></ul></td>
                        <td valign="top"><?php echo array_get_index($form_info_item, 'html_value', htmlspecialchars($form_info_item['value'])); ?></td>
                    </tr>
                <?php
                }
                ?><tr><td colspan="2"><strong>Form Responses</strong></td></tr><?php
            }
            ?>

            <?php foreach ($answers as $answer) {
                ?>
                <tr>
                    <td valign="top"><ul><li><?php echo htmlspecialchars($answer['name']); ?>:</li></ul></td>
                    <td valign="top"><?php echo htmlspecialchars($answer['value']); ?></td>
                </tr>
            <?php }
            ?>
            </table>
            <?php
        } else {

            // only show form info if asked for
            if ($include_form_info) {
                echo '=== Form Information ==='."\n";
                foreach ($form_info as $form_info_item) {
                    echo '* '.str_pad($form_info_item['name'], $max_name_length + 1).': '.$form_info_item['value']."\n";
                }
                echo "\n";
                echo '=== Form Responses ==='."\n";
            }

            foreach ($answers as $answer) {
                echo '* '.str_pad($answer['name'], $max_name_length + 1).': '.$answer['value']."\n";
            }
        }

    }//end printReceipt()


    function deleteAssetLink($linkid, $moving=FALSE)
    {
        return FALSE;

    }//end deleteAssetLink()


    function countLinks($assetid, $side_of_link='major', $link_types=0, $type_code='', $strict_type_code=TRUE, $ignore_linkid=0)
    {
        return 0;

    }//end countLinks()


    function getAssetMapAssetInfo($assetid)
    {
        return Array();

    }//end getAssetMapAssetInfo()


}//end class


?>