form_section.inc

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

class Form_Section extends Asset implements Bridge
{

    var $question_index = 0;

    var $question_col_width = 0;

    var $answer_col_width = 0;

    var $current_answers = Array();


    var $extra_data = Array();


    var $submission_errors = Array();


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

    }//end constructor


//--        GENERIC ASSET FUNCTIONS        --//


    function _updated($update_parents=TRUE)
    {
        if (!parent::_updated($update_parents)) return FALSE;
        if (SQ_IN_BACKEND) return $this->fileRegeneration();
        return TRUE;

    }//end _updated()


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

    }//end _getAllowedLinks()



    public function prepareLink(Asset $asset, $side_of_link, &$link_type, &$value, &$sort_order, &$dependant, &$exclusive)
    {   
        // if this is a bodycopy container then we need to make it a dependant link
        if ($side_of_link == 'major' && ($asset instanceof Form_Section) && $dependant != '1') {
            $dependant = '1';
            $link_type = SQ_LINK_TYPE_2;
            return TRUE;
        }

        return FALSE;

    }//end prepareLink()



    /* Clones certain specified components of the asset
    *
    * @param object     &$clone     the clone shell
    * @param array      $components the wanted components to clone eg.
    * <pre>
    *                               Array(
    *                                   'attributes',
    *                                   'metadata_schemas',
    *                                   'metadata',
    *                                   'workflow',
    *                                   'permissions',
    *                                   'data',
    *                                   'content_tags',
    *                                   'roles',
    *                               );
    *                               or alternately
    *                               Array('all');
    * </pre>
    * @param boolean    $override   whether or not to override the existing permission, metadata schemas, workflow schemas with the new ones.
    *
    * @return boolean
    * @access public
    * @see asset::cloneComponents()
    */
    function cloneComponents(&$clone, $components, $override=FALSE)
    {
        $GLOBALS['SQ_SYSTEM']->changeDatabaseConnection('db2');
        $GLOBALS['SQ_SYSTEM']->doTransaction('BEGIN');

        if (!parent::cloneComponents($clone, $components, $override)) {
            $GLOBALS['SQ_SYSTEM']->doTransaction('ROLLBACK');
            $GLOBALS['SQ_SYSTEM']->restoreDatabaseConnection();
            return FALSE;
        }

        if (in_array('attributes', $components) || in_array('all', $components)) {
            $sort_order = $this->attr('sort_order');
            $sort_order = str_replace($this->id.':q', $clone->id.':q', $sort_order);

            // save the information
            $clone->setAttrValue('sort_order', $sort_order);
            $clone->saveAttributes();

            // Now remap any parent forms, but only if we are being cloned along with a form clone:
            // remap to the cloned form. If we are being clone within a form, we will not remap.
            $form_parents = $GLOBALS['SQ_SYSTEM']->am->getDependantParents($this->id, 'form_email', FALSE);
            $clone_form_parents = $GLOBALS['SQ_SYSTEM']->am->getDependantParents($clone->id, 'form_email', FALSE);

            $clone_form_parents = array_diff($clone_form_parents, $form_parents);

            foreach ($clone_form_parents as $parent_assetid) {
                $form = $GLOBALS['SQ_SYSTEM']->am->getAsset($parent_assetid);

                $recip = unserialize($form->attr('recipient_emails_format'));
                $recip = str_replace('%response_'.$this->id.'_', '%response_'.$clone->id.'_', $recip);
                $rec = unserialize($form->attr('receipt_emails_format'));
                $rec = str_replace('%response_'.$this->id.'_', '%response_'.$clone->id.'_', $rec);
                $staf = unserialize($form->attr('staf_format'));
                $staf = str_replace('%response_'.$this->id.'_', '%response_'.$clone->id.'_', $staf);
                $sel = $form->attr('selective_emails');
                foreach ($sel as $key => $null) {
                    $sel[$key]['address'] = str_replace('%response_'.$this->id.'_', '%response_'.$clone->id.'_', $sel[$key]['address']);
                    $sel[$key]['assetid'] = str_replace($this->id.':q', $clone->id.':q', $sel[$key]['assetid']);
                }

                // field selections for STAF and receipt
                $staf_field = str_replace($this->id.':q', $clone->id.':q', $form->attr('staf_field'));
                $receipt_field = str_replace($this->id.':q', $clone->id.':q', $form->attr('receipt_field'));

                // save the information
                $form->setAttrValue('recipient_emails_format', serialize($recip));
                $form->setAttrValue('receipt_emails_format', serialize($rec));
                $form->setAttrValue('staf_format', serialize($staf));
                $form->setAttrValue('selective_emails', $sel);

                $form->setAttrValue('staf_field', $staf_field);
                $form->setAttrValue('receipt_field', $receipt_field);

                $form->saveAttributes();
            }
        }//end if

        $GLOBALS['SQ_SYSTEM']->doTransaction('COMMIT');
        $GLOBALS['SQ_SYSTEM']->restoreDatabaseConnection();
        return TRUE;

    }//end cloneComponents()


    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()


//--        BRIDGE FUNCTIONS        --//


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

        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]['question_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 getLinkById($linkid, $assetid=0, $side_of_link='major')
    {
        if (!is_numeric($assetid)) {
            if ($side_of_link == 'minor') {
                return 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 Array();
        }

        $id_parts = explode(':', $linkid);
        if (isset($id_parts[1]) && isset($id_parts[2])) {
            $looking_for = $id_parts[1].':'.$id_parts[2];
            $tmp_question_nb = str_replace('q', '', $id_parts[2]);
            $questions = $this->attr('questions');
            if (isset($questions[$tmp_question_nb])) {
                return Array(
                        'linkid'            => $linkid,
                        'majorid'           => $this->id,
                        'minorid'           => $this->id.':q'.$tmp_question_nb,
                        'minor_type_code'   => $questions[$tmp_question_nb]['question_type_code'],
                        'value'             => '',
                        'link_type'         => SQ_LINK_TYPE_2,
                        'is_dependant'      => TRUE,
                        'is_exclusive'      => FALSE,
                        'sort_order'        => 0,
                        'locked'            => 0,
                       );
            }
        }

        return Array();

    }//end getLinkById()


    function countLinks($assetid, $side_of_link='major', $link_types=0, $type_code='', $strict_type_code=TRUE, $ignore_linkid=0)
    {
        $tmp_questions = $this->attr('questions');
        if (isset($tmp_questions)) {
            return count($tmp_questions);
        }
        return 0;

    }//end countLinks()


    function deleteAssetLink($linkid, $moving=FALSE)
    {
        $id_parts = explode(':', $linkid);
        if (isset($id_parts[1]) && isset($id_parts[2])) {
            $question_to_delete = $id_parts[1].':'.$id_parts[2];
            $asset_to_delete = $this->getAsset($question_to_delete);
            if ($asset_to_delete != NULL) {
                return $this->deleteQuestion($asset_to_delete);
            }
        }

        return FALSE;

    }//end deleteAssetLink()


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

        if (!is_numeric($assetid)) {
            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;
        }

        $new_sort_order = 0;

        // There are no real links made at a section level
        // 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['question_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['question_type_code']])) {
                        $get_question = $get_question_types[$data['question_type_code']];
                        $get_question_types[$data['question_type_code']] = $get_question;
                    } else {
                        $get_question = (in_array($data['question_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['question_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];

            // we would remove real links at this point, but Form Section doesn't
            // have any real links underneath it

            // 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
        $ret_val = $GLOBALS['SQ_SYSTEM']->am->generateGetParentsQuery($this->id, $type_code, $strict_type_code);
        if (empty($ret_val)) return Array();

        $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::executePdoAssoc($query);
        $parents = Array();

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

        // TODO: add this asset only if it meets type code requirements
        $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();

        // we don't have to get any real links, sections only have question children

        // 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['question_type_code']));
            }
        } else {
            foreach ($type_code as $this_type_code) {
                foreach ($entries as $questionid => $data) {
                    if ($strict_type_code) {
                        if ($data['question_type_code'] == $this_type_code) {
                            $children[$this->id.':q'.$questionid] = $data['question_type_code'];
                        }
                    } else {
                        $type_desc = $GLOBALS['SQ_SYSTEM']->am->getTypeDescendants($this_type_code) + Array($this_type_code);
                        if (in_array($data['question_type_code'], $type_desc)) {
                            $children[$this->id.':q'.$questionid] = Array(Array('type_code' => $data['question_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()


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

    }//end getAssetMapAssetInfo()


//--        CONTENT FILE GENERATION        --//


    function fileRegeneration($form_regen=TRUE)
    {
        // we want to regen this section
        $edit = $this->getEditFns();
        $edit->generateContentFile($this);

        // sometimes, we might not want to regen the form (eg. if the form is calling this function!)
        if ($form_regen) {
            // then, get all the links of this guy's form parents
            $links = $GLOBALS['SQ_SYSTEM']->am->getLinks($this->id, SQ_LINK_TYPE_2, 'form', FALSE, 'minor');

            foreach ($links as $l) {
                $form = $GLOBALS['SQ_SYSTEM']->am->getAsset($l['majorid'], $l['major_type_code']);
                if (is_null($form)) continue;
                if (!$form->_updated()) {
                    unset($form);
                    return FALSE;
                }
                unset($form);
            }
        }//end if

        return TRUE;

    }//end fileRegeneration()




    function generateJSCode()
    {
        $questions = $this->getQuestions();
        $code = '';                     // blank sheet of code to start with

        foreach ($questions as $q_id => $question) {
            $q_asset = $GLOBALS['SQ_SYSTEM']->am->getAsset($this->id.':q'.$q_id);
            $q_code = $q_asset->generateJSCode();

            $code .= $q_code.(empty($q_code) ? '' : "\n");
        }

        return $code;

    }//end generateJSCode()


//--        QUESTION MANAGEMENT        --//


    function getQuestions($force=FALSE)
    {
        return $this->attr('questions');

    }//end getQuestions()


    function getQuestionAssets($type_code=NULL)
    {
        $am = $GLOBALS['SQ_SYSTEM']->am;
        $result = Array();

        $questions = $this->attr('questions');
        if (!empty($questions)) {
            foreach ($questions as $q_id => $question) {
                if (empty($type_code) || ($question['question_type_code'] === $type_code)) {
                    $id           =  $this->id.':q'.$q_id;
                    $result[$id]  = $am->getAsset($id);
                }
            }
        }

        return $result;

    }//end getQuestionAssets()


    function getAllQuestionAssets($type_code=NULL)
    {
        $questions = $this->getQuestionAssets($type_code);

        // Get questions within nested sections
        $nested_sections = $this->getSectionLinks();
        foreach ($nested_sections as $section_link) {
            $section = $GLOBALS['SQ_SYSTEM']->am->getAsset($section_link['minorid']);
            $questions += $section->getAllQuestionAssets($type_code);
        }

        return $questions;

    }//end getQuestionAssets()

    function getQuestionByID($questionid)
    {
        $questions = $this->getQuestions();
        return (isset($questions[$questionid])) ? $questions[$questionid] : Array();

    }//end getQuestionByID()


    function &getQuestionByOrder($orderid)
    {
        $sort_order = $this->attr('sort_order');
        $question = $GLOBALS['SQ_SYSTEM']->am->getAsset($sort_order[$orderid]);
        return $question;

    }//end getQuestionByOrder()


    function attachQuestion($type_code)
    {
        $GLOBALS['SQ_SYSTEM']->changeDatabaseConnection('db2');
        $db = MatrixDAL::getDb();

        $GLOBALS['SQ_SYSTEM']->doTransaction('BEGIN');

        $questions = $this->getQuestions();
        if ($this->attr('next_questionid') > 0) {
            $new_key = $this->attr('next_questionid');
        } else if (empty($questions)) {
            $new_key = 1;
        } else {
            $new_key = max(array_keys($questions)) + 1;
        }

        $questions[$new_key] = Array(
                                'question_type_code'    => $type_code,
                                'attributes'            => Array(
                                                            'name'  => 'Question '.(count($questions)+1),
                                                           ),
                               );

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

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

        if (empty($sort_order)) {
            $new_index = 0;
        } else {
            $new_index = max(array_keys($sort_order))+1;
        }
        $sort_order[$new_index] = $this->id.':q'.$new_key;
        $this->setAttrValue('sort_order', $sort_order);

        if (!$this->saveAttributes()) {
            $GLOBALS['SQ_SYSTEM']->doTransaction('ROLLBACK');
            $GLOBALS['SQ_SYSTEM']->restoreDatabaseConnection();
            return FALSE;
        }
        $GLOBALS['SQ_SYSTEM']->doTransaction('COMMIT');
        $GLOBALS['SQ_SYSTEM']->restoreDatabaseConnection();

        return TRUE;

    }//end attachQuestion()


    function deleteQuestion(&$question)
    {
        if ($question->_questionid == 0) return FALSE;

        $GLOBALS['SQ_SYSTEM']->changeDatabaseConnection('db2');
        $GLOBALS['SQ_SYSTEM']->doTransaction('BEGIN');
        $questions = $this->getQuestions();

        unset($questions[$question->_questionid]);

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

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

        // remove it from the sort order - it does not matter that there are gaps
        $old_index = array_search($question->id, $sort_order);
        unset($sort_order[$old_index]);

        // unset the question
        unset($question);

        $this->setAttrValue('sort_order', $sort_order);

        if (!$this->saveAttributes()) {
            $GLOBALS['SQ_SYSTEM']->doTransaction('ROLLBACK');
            $GLOBALS['SQ_SYSTEM']->restoreDatabaseConnection();
            return FALSE;
        }
        $GLOBALS['SQ_SYSTEM']->doTransaction('COMMIT');
        $GLOBALS['SQ_SYSTEM']->restoreDatabaseConnection();

        return TRUE;

    }//end deleteQuestion()


    function getQuestionCount()
    {
        $questions = $this->getQuestions();
        return count($questions);

    }//end getQuestionCount()


//--        SECTION MANAGEMENT        --//


    function getSectionLinks()
    {
        // This is what one would find in Asset_Manager::&getAsset() except we can't call that,
        // lest we spin off into an infinite loop involving OUR &getAsset().
        $value = Array(
                    'link_value'    => Array(''),
                    'equal'         => TRUE,
                 );
        $sql_query = $GLOBALS['SQ_SYSTEM']->am->generateGetLinksQuery($this->id, SQ_LINK_TYPE_2, 'form_section', TRUE, 'major', $value, '1', '0');
        if (empty($sql_query)) return Array();
        $sql_query['sql_array']['select'] .= ', l.majorid';     // we need the major id too
        $db = MatrixDAL::getDb();

        try {
            $sql = implode(' ', $sql_query['sql_array']);
            $query = MatrixDAL::preparePdoQuery($sql);
            foreach ($sql_query['bind_vars'] as $bind_var => $bind_value) {
                MatrixDAL::bindValueToPdo($query, $bind_var, $bind_value);
            }
            $result = MatrixDAL::executePdoAssoc($query);
        } catch (Exception $e) {
            throw new Exception('Unable to get section links attached to form_section: '.$this->id.' due to database error: '.$e->getMessage());
        }
        return $result;

    }//end getSectionLinks()


//--        PAINTING FUNCTIONS        --//


    function printBody(Form $form, $submit_buttons=FALSE)
    {
        // if format bodycopy enabled, print with that, otherwise print default
        if ($this->isFormatBodycopyEnabled()) {
            $this->printCustomFormat($form, $submit_buttons);
        } else {
            $this->printDefaultFormat($form, $submit_buttons);
        }

    }//end printBody()


    function printDefaultFormat(Form $form, $submit_buttons=FALSE)
    {
        // Default format definitions to keep the section looking in line with
        // its current parent form
        $form_width     = $form->attr('form_width');
        $question_width = $form->attr('question_col_width');
        $response_width = $form->attr('answer_col_width');

        include $this->data_path.'/content_file.php';

        if ($submit_buttons) {
            ob_start();
            ?>
            <table width="<?php echo $form_width; ?>">
                <tr>
                <td width="<?php echo $question_width; ?>">&nbsp;</td>
                <td width="<?php echo $response_width; ?>">
                    %submit_button%
                    %reset_button%
                </td>
                </tr>
                </table>
            <?php
            $content = ob_get_clean();

            require_once SQ_FUDGE_PATH.'/general/text.inc';

            $keyword_list = extract_keywords($content);
            if (!empty($keyword_list)) {
                foreach ($keyword_list as $keyword) {
                    if (isset($replacements[$keyword])) continue;
                    $replacements[$keyword] = $form->getKeywordReplacement($keyword);
                }
                replace_keywords($content, $replacements);
            }
            echo $content;
        }

    }//end printCustomFormat()


    function printCustomFormat(Form $form, $submit_buttons=FALSE)
    {
        // return custom bodycopy but ONLY if enabled
        $format_bodycopy = $this->getFormatBodycopy(TRUE);
        if (!$format_bodycopy) {
            // Halt the display if the custom format is being asked for, but does
            // not exist
            trigger_error('Form Section asked for a custom format when it has no format bodycopy enabled. This should not happen.', E_USER_ERROR);
        }

        $keywords = $format_bodycopy->getKeywords();
        $replacements = Array();

        foreach ($keywords as $keyword) {
            // Try to get a specific display keyword replacement, to handle
            // %question_*% and nested %section_*% keywords
            $replacement = $form->getDisplayKeywordReplacement($keyword);

            if (is_null($replacement)) {
                // If we couldn't get a keyword from there, use the generic
                // keyword replacement form - this will pick up CAPTCHA, errors,
                // submit/reset replacements
                $replacement = $form->getKeywordReplacement($keyword);
            }

            if (!is_null($replacement)) {
                $replacements[$keyword] = $replacement;
            }

        }//end foreach

        $format_bodycopy->setKeywordReplacements($replacements);
        $format_bodycopy->printBody();

    }//end printCustomFormat()


    function printSemanticSummary()
    {
        if ($this->getQuestionCount() > 0) {
            echo '<dl>'."\n";
            foreach ($this->attr('sort_order') as $sort_order => $question_assetid) {

                // Make sure that we own this question
                if ($this->id == strtok($question_assetid, ':')) {
                    $question = $GLOBALS['SQ_SYSTEM']->am->getAsset($question_assetid);
                    echo '<dt>'.$question->attr('name').'</dt>'."\n";
                    echo '<dd>'.htmlentities($question->getSummary(), ENT_NOQUOTES).'</dd>'."\n";
                }

            }
            echo '</dl>'."\n";
        }

        // now nested sections - get them to print itself out, recursively
        $section_links = $this->getSectionLinks();
        if (count($section_links) > 0) {
            echo '<ul>'."\n";
        }

        foreach ($section_links as $section_link) {
            echo '<li>'."\n";
                $section = $GLOBALS['SQ_SYSTEM']->am->getAsset($section_link['minorid']);
                echo '<strong>'.htmlentities($section->attr('name'), ENT_NOQUOTES).'</strong>'."\n";
                $section->printSemanticSummary();
            echo '</li>'."\n";
        }

        if (count($section_links) > 0) {
            echo '</ul>'."\n";
        }

    }//end printSemanticSummary()


//--        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);
                $this->fileRegeneration();
            }
        }

        return TRUE;

    }//end setUseFormatBodycopy()


//--        KEYWORD PROVISION        --//


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

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

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

    }//end onRequestKeywords()


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

        foreach ($questions as $shadowid => $question) {
            $keywords['question_field_'.$this->id.'_q'.$shadowid] = 'Question Field: '.ellipsisize($question['attributes']['name'], 30).' ('.$this->id.':q'.$shadowid.')';
            $keywords['question_name_'.$this->id.'_q'.$shadowid]    = 'Question Name: '.ellipsisize($question['attributes']['name'], 30).' ('.$this->id.':q'.$shadowid.')';
            $keywords['question_id_'.$this->id.'_q'.$shadowid]    = 'Question ID: '.ellipsisize($question['attributes']['name'], 30).' ('.$this->id.':q'.$shadowid.')';
            $keywords['question_note_'.$this->id.'_q'.$shadowid]  = 'Question Note: '.ellipsisize($question['attributes']['name'], 30).' ('.$this->id.':q'.$shadowid.')';
            $keywords['question_label_'.$this->id.'_q'.$shadowid] = 'Question Label: '.ellipsisize($question['attributes']['name'], 30).' ('.$this->id.':q'.$shadowid.')';
        }

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

            $keywords += $s->getDisplayKeywords();
            $keywords['section_title_'.$s->id] = 'Nested Section Name: '.$s->name.' ('.$s->id.')';
            $keywords['section_contents_'.$s->id] = 'Nested Section Contents: '.$s->name.' ('.$s->id.')';

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

        if ($include_submit_keywords) {
            $keywords['submit_button'] = 'Submit Button';
            $keywords['reset_button'] = 'Reset Button';
            $keywords['form_errors'] = 'Form Errors';
        }

        return $keywords;

    }//end getDisplayKeywords()


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

        foreach ($questions as $shadowid => $question) {
            $keywords['response_'.$this->id.'_q'.$shadowid]       = translate('cms_form_section_response', $this->name, ellipsisize($question['attributes']['name'], 30)).' ('.$this->id.':q'.$shadowid.')';
            $keywords['question_name_'.$this->id.'_q'.$shadowid]  = translate('cms_form_section_q_name', $this->name, ellipsisize($question['attributes']['name'], 30)).' ('.$this->id.':q'.$shadowid.')';
            $keywords['question_note_'.$this->id.'_q'.$shadowid]  = translate('cms_form_section_q_note', $this->name, ellipsisize($question['attributes']['name'], 30)).' ('.$this->id.':q'.$shadowid.')';
        }

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

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

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

        return $keywords;

    }//end getResponseKeywords()


//--        KEYWORD REPLACEMENTS        --//


    function getDisplayKeywordReplacements($generating=FALSE, $include_submit_keywords=TRUE, $form=NULL)
    {
        if (!is_null($form)) {
            assert_is_a($form, 'Form');
        }

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

        foreach ($questions as $shadowid => $question) {
            // get the question
            $assetid = $this->id.':q'.$shadowid;
            $q = $GLOBALS['SQ_SYSTEM']->am->getAsset($assetid);
            if ($generating) {
                $keywords['question_field_'.$this->id.'_q'.$shadowid] = '<'.'?php echo $GLOBALS[\'SQ_SYSTEM\']->am->getAsset(\''.$assetid.'\')->getHtmlField(); ?'.'>';
                $keywords['question_note_'.$this->id.'_q'.$shadowid]  = '<'.'?php echo $GLOBALS[\'SQ_SYSTEM\']->am->getAsset(\''.$assetid.'\')->attr(\'note\'); ?'.'>';
                $keywords['question_name_'.$this->id.'_q'.$shadowid]  = '<'.'?php echo $GLOBALS[\'SQ_SYSTEM\']->am->getAsset(\''.$assetid.'\')->attr(\'name\'); ?'.'>';
                $keywords['question_id_'.$this->id.'_q'.$shadowid]    = $assetid;
                $keywords['question_label_'.$this->id.'_q'.$shadowid] = '<'.'?php echo $GLOBALS[\'SQ_SYSTEM\']->am->getAsset(\''.$assetid.'\')->getHtmlLabel(); ?'.'>';
            } else {
                $keywords['question_field_'.$this->id.'_q'.$shadowid] = $q->getHtmlField();
                $keywords['question_note_'.$this->id.'_q'.$shadowid]  = $q->attr('note');
                $keywords['question_name_'.$this->id.'_q'.$shadowid]  = $q->attr('name');
                $keywords['question_id_'.$this->id.'_q'.$shadowid]    = $assetid;
                $keywords['question_label_'.$this->id.'_q'.$shadowid] = $q->getHtmlLabel();
            }
            $GLOBALS['SQ_SYSTEM']->am->forgetAsset($q);
            unset($q);
        }

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

            if ($generating) {
                $keywords['section_title_'.$s->id] = '<'.'?php echo $GLOBALS[\'SQ_SYSTEM\']->am->getAsset(\''.$sectionid.'\')->name; ?'.'>';;

                $keywords['section_contents_'.$s->id] = '<'.'?php include_once $GLOBALS[\'SQ_SYSTEM\']->am->getAsset(\''.$sectionid.'\')->data_path.\'/content_file.php\'; ?'.'>';;
            } else {
                $keywords['section_title_'.$s->id] = $s->name;
                ob_start();
                    $s->printBody($form);
                $keywords['section_contents_'.$s->id] = ob_get_clean();
            }

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

        if ($include_submit_keywords) {
            // Submit Button, Reset Button, Form Errors
            // TODO:
            ob_start();
                //submit_button('submit_button', );
                $submit_button = ob_get_contents();
            ob_end_clean();

            ob_start();
                //reset_button('reset_button', 'Reset');
                $reset_button = ob_get_contents();
            ob_end_clean();

            $keywords['submit_button'] = $submit_button;
            $keywords['reset_button']  = $reset_button;

            // TODO:
            $keywords['form_errors']   = implode('\n', $this->submission_errors);
        } else {
            // suppress them
            $keywords['submit_button'] = '';
            $keywords['reset_button']  = '';
            $keywords['form_errors']   = '';
        }

        return $keywords;

    }//end getDisplayKeywordReplacements()


}//end class
?>