static function create($name, $label = null, $allowMultiple = null, $maxAllowed = null, $formFields = null)
{
$tif = new SFTemplateInForm();
$tif->mTemplateName = str_replace('_', ' ', $name);
$tif->mFields = array();
if (is_null($formFields)) {
$fields = $tif->getAllFields();
$field_num = 0;
foreach ($fields as $field) {
$tif->mFields[] = SFFormField::create($field_num++, $field);
}
} else {
$tif->mFields = $formFields;
}
$tif->mLabel = $label;
$tif->mAllowMultiple = $allowMultiple;
$tif->mMaxAllowed = $maxAllowed;
return $tif;
}
public function formSerialize($form_def = '', $source_is_page = false, $existing_page_content = null, $page_title = null)
{
// public function formSerialize($form_def, $source_is_page, $existing_page_content = null, $page_title = null, $page_name_formula = null) {
global $wgRequest, $wgUser, $wgParser;
global $sfgTabIndex;
// used to represent the current tab index in the form
global $sfgFieldNum;
// used for setting various HTML IDs
global $sfgJSValidationCalls;
// array of Javascript calls to determine if page can be saved
# define a var for all fields
$__fields = array();
// initialize some variables
$sfgTabIndex = 1;
$sfgFieldNum = 1;
$source_page_matches_this_form = false;
$form_page_title = NULL;
// $form_is_partial is true if:
// (a) 'partial' == 1 in the arguments
// (b) 'partial form' is found in the form definition
// in the latter case, it may remain false until close to the end of
// the parsing, so we have to assume that it will become a possibility
$form_is_partial = false;
$new_text = "";
// if we have existing content and we're not in an active replacement
// situation, preserve the original content. We do this because we want
// to pass the original content on IF this is a partial form
// TODO: A better approach here would be to pass the revision id of the
// existing page content through the replace value, which would
// minimize the html traffic and would allow us to do a concurrent
// update check. For now, we pass it through the hidden text field...
if (!$wgRequest->getCheck('partial')) {
$original_page_content = $existing_page_content;
} else {
$original_page_content = null;
if ($wgRequest->getCheck('free_text')) {
$existing_page_content = $wgRequest->getVal('free_text');
$form_is_partial = true;
}
}
// disable all form elements if user doesn't have edit permission -
// two different checks are needed, because editing permissions can be
// set in different ways
// HACK - sometimes we don't know the page name in advance, but we still
// need to set a title here for testing permissions
if ($page_title == '') {
$this->mPageTitle = Title::newFromText("Semantic Forms permissions test");
} else {
$this->mPageTitle = Title::newFromText($page_title);
}
if ($wgUser->isAllowed('edit') && $this->mPageTitle->userCanEdit()) {
$form_is_disabled = false;
$form_text = "";
// show "Your IP address will be recorded" warning if user is
// anonymous - wikitext for bolding has to be replaced with HTML
if ($wgUser->isAnon()) {
$anon_edit_warning = preg_replace("/'''(.*)'''/", "<strong>\$1</strong>", wfMsg('anoneditwarning'));
$form_text .= "<p>{$anon_edit_warning}</p>\n";
}
} else {
$form_is_disabled = true;
// display a message to the user explaining why they can't edit the
// page - borrowed heavily from EditPage.php
if ($wgUser->isAnon()) {
$skin = $wgUser->getSkin();
$loginTitle = SpecialPage::getTitleFor('Userlogin');
$loginLink = $skin->makeKnownLinkObj($loginTitle, wfMsgHtml('loginreqlink'));
$form_text = wfMsgWikiHtml('whitelistedittext', $loginLink);
} else {
$form_text = wfMsg('protectedpagetext');
}
}
$javascript_text = "";
$sfgJSValidationCalls = array();
$fields_javascript_text = "";
// Remove <noinclude> sections and <includeonly> tags from form definition
$form_def = StringUtils::delimiterReplace('<noinclude>', '</noinclude>', '', $form_def);
$form_def = strtr($form_def, array('<includeonly>' => '', '</includeonly>' => ''));
// parse wiki-text
// add '<nowiki>' tags around every triple-bracketed form definition
// element, so that the wiki parser won't touch it - the parser will
// remove the '<nowiki>' tags, leaving us with what we need
global $sfgDisableWikiTextParsing;
if (!$sfgDisableWikiTextParsing) {
$form_def = "__NOEDITSECTION__" . strtr($form_def, array('{{{' => '<nowiki>{{{', '}}}' => '}}}</nowiki>'));
$wgParser->mOptions = new ParserOptions();
$wgParser->mOptions->initialiseFromUser($wgUser);
$form_def = $wgParser->parse($form_def, $this->mPageTitle, $wgParser->mOptions)->getText();
}
// turn form definition file into an array of sections, one for each
// template definition (plus the first section)
$form_def_sections = array();
$start_position = 0;
$section_start = 0;
$free_text_was_included = false;
$free_text_preload_page = null;
$all_values_for_template = array();
// unencode and HTML-encoded representations of curly brackets and
// pipes - this is a hack to allow for forms to include templates
// that themselves contain form elements - the escaping is needed
// to make sure that those elements don't get parsed too early
$form_def = str_replace(array('{', '|', '}'), array('{', '|', '}'), $form_def);
// and another hack - replace the 'free text' standard input with
// a field declaration to get it to be handled as a field
$form_def = str_replace('standard input|free text', 'field|<freetext>', $form_def);
while ($brackets_loc = strpos($form_def, "{{{", $start_position)) {
$brackets_end_loc = strpos($form_def, "}}}", $brackets_loc);
$bracketed_string = substr($form_def, $brackets_loc + 3, $brackets_end_loc - ($brackets_loc + 3));
$tag_components = explode('|', $bracketed_string);
$tag_title = trim($tag_components[0]);
if ($tag_title == 'for template' || $tag_title == 'end template') {
// create a section for everything up to here
$section = substr($form_def, $section_start, $brackets_loc - $section_start);
$form_def_sections[] = $section;
$section_start = $brackets_loc;
}
$start_position = $brackets_loc + 1;
}
// end while
$form_def_sections[] = trim(substr($form_def, $section_start));
// cycle through form definition file (and possibly an existing article
// as well), finding template and field declarations and replacing them
// with form elements, either blank or pre-populated, as appropriate
$all_fields = array();
$data_text = "";
$template_name = "";
$allow_multiple = false;
$instance_num = 0;
$all_instances_printed = false;
$strict_parsing = false;
// initialize list of choosers (dropdowns with available templates)
$choosers = array();
for ($section_num = 0; $section_num < count($form_def_sections); $section_num++) {
$tif = new SFTemplateInForm();
$start_position = 0;
$template_text = "";
// the append is there to ensure that the original array doesn't get
// modified; is it necessary?
$section = " " . $form_def_sections[$section_num];
while ($brackets_loc = strpos($section, '{{{', $start_position)) {
$brackets_end_loc = strpos($section, "}}}", $brackets_loc);
$bracketed_string = substr($section, $brackets_loc + 3, $brackets_end_loc - ($brackets_loc + 3));
$tag_components = explode('|', $bracketed_string);
$tag_title = trim($tag_components[0]);
// =====================================================
// for template processing
// =====================================================
if ($tag_title == 'for template') {
$old_template_name = $template_name;
$template_name = trim($tag_components[1]);
$tif->template_name = $template_name;
$query_template_name = str_replace(' ', '_', $template_name);
// also replace periods with underlines, since that's what
// POST does to strings anyway
$query_template_name = str_replace('.', '_', $query_template_name);
$chooser_name = false;
$chooser_caption = false;
// cycle through the other components
for ($i = 2; $i < count($tag_components); $i++) {
$component = $tag_components[$i];
if ($component == 'multiple') {
$allow_multiple = true;
}
if ($component == 'strict') {
$strict_parsing = true;
}
$sub_components = explode('=', $component);
if (count($sub_components) == 2) {
if ($sub_components[0] == 'label') {
$template_label = $sub_components[1];
} elseif ($sub_components[0] == 'chooser') {
$allow_multiple = true;
$chooser_name = $sub_components[1];
} elseif ($sub_components[0] == 'chooser caption') {
$chooser_caption = $sub_components[1];
}
}
}
// if this is the first instance, add the label in the form
if ($old_template_name != $template_name && isset($template_label)) {
// add a placeholder to the form text so the fieldset can be
// hidden if chooser support demands it
if ($chooser_name !== false) {
$form_text .= "<fieldset [[placeholder]] haschooser=true>\n";
} else {
$form_text .= "<fieldset>\n";
}
$form_text .= "<legend>{$template_label}</legend>\n";
}
$template_text .= "{{" . $tif->template_name;
# reads all the fields of the template definition page
$all_fields = $tif->getAllFields();
// remove template tag
$section = substr_replace($section, '', $brackets_loc, $brackets_end_loc + 3 - $brackets_loc);
$template_instance_query_values = $wgRequest->getArray($query_template_name);
// if we are editing a page, and this template can be found more than
// once in that page, and multiple values are allowed, repeat this
// section
$existing_template_text = null;
// replace underlines with spaces in template name, to allow for
// searching on either
$search_template_str = str_replace('_', ' ', $tif->template_name);
if ($source_is_page || $form_is_partial) {
if ($allow_multiple) {
// find instances of this template in the page -
// if there's at least one, re-parse this section of the
// definition form for the subsequent template instances in
// this page; if there's none, don't include fields at all.
// there has to be a more efficient way to handle multiple
// instances of templates, one that doesn't involve re-parsing
// the same tags, but I don't know what it is.
if (stripos(str_replace('_', ' ', $existing_page_content), '{{' . $search_template_str) !== false) {
$instance_num++;
} else {
$all_instances_printed = true;
}
}
// get the first instance of this template on the page being edited,
// even if there are more
if (($start_char = stripos(str_replace('_', ' ', $existing_page_content), '{{' . $search_template_str)) !== false) {
$fields_start_char = $start_char + 2 + strlen($search_template_str);
// skip ahead to the first real character
while (in_array($existing_page_content[$fields_start_char], array(' ', '\\n', '|'))) {
$fields_start_char++;
}
$template_contents = array('0' => '');
// cycle through template call, splitting it up by pipes ('|'),
// except when that pipe is part of a piped link
$field = "";
$uncompleted_square_brackets = 0;
$uncompleted_curly_brackets = 2;
$template_ended = false;
for ($i = $fields_start_char; !$template_ended && $i < strlen($existing_page_content); $i++) {
$c = $existing_page_content[$i];
if ($c == '[') {
$uncompleted_square_brackets++;
} elseif ($c == ']' && $uncompleted_square_brackets > 0) {
$uncompleted_square_brackets--;
} elseif ($c == '{') {
$uncompleted_curly_brackets++;
} elseif ($c == '}' && $uncompleted_curly_brackets > 0) {
$uncompleted_curly_brackets--;
}
// handle an end to a field and/or template declaration
$template_ended = $uncompleted_curly_brackets == 0 && $uncompleted_square_brackets == 0;
$field_ended = $c == '|' && $uncompleted_square_brackets == 0;
if ($template_ended || $field_ended) {
// if this was the last character in the template, remove
// the closing curly brackets
if ($template_ended) {
$field = substr($field, 0, -1);
}
// either there's an equals sign near the beginning or not -
// handling is similar in either way; if there's no equals
// sign, the index of this field becomes the key
$sub_fields = explode('=', $field, 2);
if (count($sub_fields) > 1) {
$template_contents[trim($sub_fields[0])] = trim($sub_fields[1]);
} else {
$template_contents[] = trim($sub_fields[0]);
}
$field = '';
} else {
$field .= $c;
}
}
$existing_template_text = substr($existing_page_content, $start_char, $i - $start_char);
// now remove this template from the text being edited
// if this is a partial form, establish a new insertion point
if ($existing_page_content && $form_is_partial && $wgRequest->getCheck('partial')) {
// if something already exists, set the new insertion point
// to its position; otherwise just let it lie
if (strpos($existing_page_content, $existing_template_text) !== false) {
$existing_page_content = str_replace('{{{insertionpoint}}}', '', $existing_page_content);
$existing_page_content = str_replace($existing_template_text, '{{{insertionpoint}}}', $existing_page_content);
}
} else {
$existing_page_content = str_replace($existing_template_text, '', $existing_page_content);
}
// if this is not a multiple-instance template, and we've found
// a match in the source page, there's a good chance that this
// page was created with this form - note that, so we don't
// send the user a warning
// (multiple-instance templates have a greater chance of
// getting repeated from one form to the next)
if (!$allow_multiple) {
$source_page_matches_this_form = true;
}
}
}
// if the input is from the form (meaning the user has hit one
// of the bottom row of buttons), and we're dealing with a
// multiple template, get the values for this instance of this
// template, then delete them from the array, so we can get the
// next group next time - the next() command for arrays doesn't
// seem to work here
if (!$source_is_page && $allow_multiple && $wgRequest) {
$all_instances_printed = true;
if ($old_template_name != $template_name) {
$all_values_for_template = $wgRequest->getArray($query_template_name);
}
if ($all_values_for_template) {
$cur_key = key($all_values_for_template);
// skip the input coming in from the "starter" div
if ($cur_key == 'num') {
unset($all_values_for_template[$cur_key]);
$cur_key = key($all_values_for_template);
}
if ($template_instance_query_values = current($all_values_for_template)) {
$all_instances_printed = false;
unset($all_values_for_template[$cur_key]);
}
}
}
// save the template name
$field = array();
$field['tmpl_name'] = $tif->template_name;
// =====================================================
// end template processing
// =====================================================
} elseif ($tag_title == 'end template') {
// remove this tag, reset some variables, and close off form HTML tag
$section = substr_replace($section, '', $brackets_loc, $brackets_end_loc + 3 - $brackets_loc);
$template_name = null;
if (isset($template_label)) {
$form_text .= "</fieldset>\n";
unset($template_label);
}
$allow_multiple = false;
$all_instances_printed = false;
$instance_num = 0;
// if the hiding placeholder is still around, this fieldset should
// be hidden because it is empty and choosers are being used. So,
// hide it.
$form_text = str_replace("[[placeholder]]", "style='display:none'", $form_text);
$__fields["template" . count($__fields)] = $field;
// =====================================================
// field processing
// =====================================================
} elseif ($tag_title == 'field') {
$field_name = trim($tag_components[1]);
// cycle through the other components
$is_mandatory = false;
$is_hidden = false;
$is_restricted = false;
$is_uploadable = false;
$is_list = false;
$input_type = null;
$field_args = array();
$default_value = "";
$possible_values = null;
$preload_page = null;
for ($i = 2; $i < count($tag_components); $i++) {
$component = trim($tag_components[$i]);
if ($component == 'mandatory') {
$is_mandatory = true;
} elseif ($component == 'hidden') {
$is_hidden = true;
} elseif ($component == 'restricted') {
$is_restricted = true;
} elseif ($component == 'uploadable') {
$field_args['is_uploadable'] = true;
} elseif ($component == 'list') {
$is_list = true;
} elseif ($component == 'autocomplete') {
$field_args['autocomplete'] = true;
} elseif ($component == 'no autocomplete') {
$field_args['no autocomplete'] = true;
} elseif ($component == 'remote autocompletion') {
$field_args['remote autocompletion'] = true;
} else {
$sub_components = explode('=', $component);
if (count($sub_components) == 2) {
if ($sub_components[0] == 'input type') {
$input_type = $sub_components[1];
} elseif ($sub_components[0] == 'default') {
$default_value = $sub_components[1];
} elseif ($sub_components[0] == 'preload') {
// free text field has special handling
if ($field_name == 'free text' || ($field_name = '<freetext>')) {
$free_text_preload_page = $sub_components[1];
} else {
// this variable is not used
$preload_page = $sub_components[1];
}
} elseif ($sub_components[0] == 'values') {
$possible_values = explode(',', $sub_components[1]);
} elseif ($sub_components[0] == 'values from category') {
$possible_values = SFUtils::getAllPagesForCategory($sub_components[1], 10);
} elseif ($sub_components[0] == 'values from concept') {
$possible_values = SFUtils::getAllPagesForConcept($sub_components[1]);
} else {
$field_args[$sub_components[0]] = $sub_components[1];
}
// for backwards compatibility
if ($sub_components[0] == 'autocomplete on' && $sub_components[1] == null) {
$field_args['no autocomplete'] = true;
}
}
}
}
$field_args['part_of_multiple'] = $allow_multiple;
// get the value from the request, if it's there, and if it's not
// an array
$escaped_field_name = str_replace("'", "\\'", $field_name);
if (isset($template_instance_query_values) && $template_instance_query_values != null && array_key_exists($escaped_field_name, $template_instance_query_values)) {
$field_query_val = $template_instance_query_values[$escaped_field_name];
if ($field_query_val && !is_array($field_query_val)) {
$cur_value = $field_query_val;
}
} else {
$cur_value = '';
}
if ($cur_value && !is_array($cur_value)) {
# no escaping needed
// $cur_value = str_replace('"', '"', $cur_value);
}
if ($cur_value == null) {
// set to default value specified in the form, if it's there
$cur_value = $default_value;
}
// if the user is starting to edit a page, and that page contains
// the current template being processed, get the current template
// field's value in the existing page
if ($source_is_page && !empty($existing_template_text)) {
if (isset($template_contents[$field_name])) {
$cur_value = $template_contents[$field_name];
} else {
$cur_value = '';
}
if ($cur_value) {
# no escaping needed
// $cur_value = str_replace('"', '"', $cur_value);
}
}
// handle the free text field - if it was declared as
// "field|free text" (a deprecated usage), it has to be outside
// of a template
if ($template_name == '' && $field_name == 'free text' || $field_name == '<freetext>') {
// add placeholders for the free text in both the form and
// the page, using <free_text> tags - once all the free text
// is known (at the end), it will get substituted in
if ($is_hidden) {
$new_text = SFFormUtils::hiddenFieldHTML('free_text', '<free_text>');
} else {
if (!array_key_exists('rows', $field_args)) {
$field_args['rows'] = 5;
}
if (!array_key_exists('cols', $field_args)) {
$field_args['cols'] = 80;
}
$sfgTabIndex++;
$sfgFieldNum++;
list($new_text, $new_javascript_text) = SFFormInputs::textAreaHTML('<free_text>', 'free_text', false, $form_is_disabled || $is_restricted, $field_args);
$fields_javascript_text .= $new_javascript_text;
}
$free_text_was_included = true;
// add a similar placeholder to the data text
$data_text .= "<free_text>\n";
}
if ($template_name == '') {
$section = substr_replace($section, $new_text, $brackets_loc, $brackets_end_loc + 3 - $brackets_loc);
} else {
if (is_array($cur_value)) {
// first, check if it's a list
if (array_key_exists('is_list', $cur_value) && $cur_value['is_list'] == true) {
$cur_value_in_template = "";
if (array_key_exists('delimiter', $field_args)) {
$delimiter = $field_args['delimiter'];
} else {
$delimiter = ",";
}
foreach ($cur_value as $key => $val) {
if ($key !== "is_list") {
if ($cur_value_in_template != "") {
$cur_value_in_template .= $delimiter . " ";
}
$cur_value_in_template .= $val;
}
}
} else {
// otherwise:
// if it has 1 or 2 elements, assume it's a checkbox; if it has
// 3 elements, assume it's a date
// - this handling will have to get more complex if other
// possibilities get added
if (count($cur_value) == 1) {
// manually load SMW's message values here, in case they
// didn't get loaded before
wfLoadExtensionMessages('SemanticMediaWiki');
$words_for_false = explode(',', wfMsgForContent('smw_false_words'));
// for each language, there's a series of words that are
// equal to false - get the word in the series that matches
// "no"; generally, that's the third word
$index_of_no = 2;
if (count($words_for_false) > $index_of_no) {
$no = ucwords($words_for_false[$index_of_no]);
} elseif (count($words_for_false) == 0) {
$no = "0";
// some safe value if no words are found
} else {
$no = ucwords($words_for_false[0]);
}
$cur_value_in_template = $no;
} elseif (count($cur_value) == 2) {
wfLoadExtensionMessages('SemanticMediaWiki');
$words_for_true = explode(',', wfMsgForContent('smw_true_words'));
// get the value in the 'true' series that tends to be "yes",
// and go with that one - generally, that's the third word
$index_of_yes = 2;
if (count($words_for_true) > $index_of_yes) {
$yes = ucwords($words_for_true[$index_of_yes]);
} elseif (count($words_for_true) == 0) {
$yes = "1";
// some safe value if no words are found
} else {
$yes = ucwords($words_for_true[0]);
}
$cur_value_in_template = $yes;
// if it's 3 or greater, assume it's a date or datetime
} elseif (count($cur_value) >= 3) {
$month = $cur_value['month'];
$day = $cur_value['day'];
if ($day != '') {
global $wgAmericanDates;
if ($wgAmericanDates == false) {
// pad out day to always be two digits
$day = str_pad($day, 2, "0", STR_PAD_LEFT);
}
}
$year = $cur_value['year'];
if (isset($cur_value['hour'])) {
$hour = $cur_value['hour'];
}
if (isset($cur_value['minute'])) {
$minute = $cur_value['minute'];
}
if (isset($cur_value['second'])) {
$second = $cur_value['second'];
}
if (isset($cur_value['ampm24h'])) {
$ampm24h = $cur_value['ampm24h'];
}
if (isset($cur_value['timezone'])) {
$timezone = $cur_value['timezone'];
}
if ($month != '' && $day != '' && $year != '') {
// special handling for American dates - otherwise, just
// the standard year/month/day (where month is a number)
global $wgAmericanDates;
if ($wgAmericanDates == true) {
$cur_value_in_template = "{$month} {$day}, {$year}";
} else {
$cur_value_in_template = "{$year}/{$month}/{$day}";
}
// include whatever time information we have
if (isset($hour)) {
$cur_value_in_template .= " " . str_pad(intval(substr($hour, 0, 2)), 2, '0', STR_PAD_LEFT) . ":" . str_pad(intval(substr($minute, 0, 2)), 2, '0', STR_PAD_LEFT);
}
if (isset($second)) {
$cur_value_in_template .= ":" . str_pad(intval(substr($second, 0, 2)), 2, '0', STR_PAD_LEFT);
}
if (isset($ampm24h)) {
$cur_value_in_template .= " {$ampm24h}";
}
if (isset($timezone)) {
$cur_value_in_template .= " {$timezone}";
}
} else {
$cur_value_in_template = "";
}
}
}
} else {
// value is not an array
$cur_value_in_template = $cur_value;
}
if ($query_template_name == null || $query_template_name == '') {
$input_name = $field_name;
} elseif ($allow_multiple) {
// 'num' will get replaced by an actual index, either in PHP
// or in Javascript, later on
$input_name = $query_template_name . '[num][' . $field_name . ']';
} else {
$input_name = $query_template_name . '[' . $field_name . ']';
}
// disable this field if either the whole form is disabled, or
// it's a restricted field and user doesn't have sysop privileges
$is_disabled = $form_is_disabled || $is_restricted && (!$wgUser || !$wgUser->isAllowed('editrestrictedfields'));
// create an SFFormTemplateField instance based on all the
// parameters in the form definition, and any information from
// the template definition (contained in the $all_fields parameter)
# creation of a form field from the definition page
$possible_values['_element'] = "value";
$form_field = $this->createFromDefinitionForSerialization($field_name, $input_name, $is_mandatory, $is_hidden, $is_uploadable, $possible_values, $is_disabled, $is_list, $input_type, $field_args, $all_fields, $strict_parsing);
// if this is not part of a 'multiple' template, incrememt the
// global tab index (used for correct tabbing)
if (!$field_args['part_of_multiple']) {
$sfgTabIndex++;
}
// increment the global field number regardless
$sfgFieldNum++;
// if the field is a date field, and its default value was set
// to 'now', and it has no current value, set $cur_value to be
// the current date
if ($default_value == 'now' && ($cur_value == '' || $cur_value == 'now')) {
if ($input_type == 'date' || $input_type == 'datetime' || $input_type == 'datetime with timezone' || $input_type == '' && $form_field->template_field->field_type == 'Date') {
$cur_time = time();
$year = date("Y", $cur_time);
$month = date("n", $cur_time);
$day = date("j", $cur_time);
global $wgAmericanDates, $sfg24HourTime;
if ($wgAmericanDates == true) {
$month_names = SFFormUtils::getMonthNames();
$month_name = $month_names[$month - 1];
$cur_value_in_template = "{$month_name} {$day}, {$year}";
} else {
$cur_value_in_template = "{$year}/{$month}/{$day}";
}
if ($input_type == 'datetime' || $input_type == 'datetime with timezone') {
if ($sfg24HourTime) {
$hour = str_pad(intval(substr(date("G", $cur_time), 0, 2)), 2, '0', STR_PAD_LEFT);
} else {
$hour = str_pad(intval(substr(date("g", $cur_time), 0, 2)), 2, '0', STR_PAD_LEFT);
}
$minute = str_pad(intval(substr(date("i", $cur_time), 0, 2)), 2, '0', STR_PAD_LEFT);
$second = str_pad(intval(substr(date("s", $cur_time), 0, 2)), 2, '0', STR_PAD_LEFT);
if ($sfg24HourTime) {
$cur_value_in_template .= " {$hour}:{$minute}:{$second}";
} else {
$ampm = date("A", $cur_time);
$cur_value_in_template .= " {$hour}:{$minute}:{$second} {$ampm}";
}
}
if ($input_type == 'datetime with timezone') {
$timezone = date("T", $cur_time);
$cur_value_in_template .= " {$timezone}";
}
}
}
// if the field is a text field, and its default value was set
// to 'current user', and it has no current value, set $cur_value
// to be the current user
if ($default_value == 'current user' && ($cur_value == '' || $cur_value == 'current user')) {
if ($input_type == 'text' || $input_type == '') {
$cur_value_in_template = $wgUser->getName();
$cur_value = $cur_value_in_template;
}
}
# field + field value
$form_field->cur_value = $cur_value;
# possible_values hack
$__tmpValues = $form_field->template_field->possible_values;
$form_field->template_field->possible_values = array();
if ($__tmpValues != NULL) {
foreach ($__tmpValues as $key => $value) {
$form_field->template_field->possible_values["value" . $key] = $value;
}
}
$field["field" . count($field)] = $this->toArrayForSerialize($form_field);
$new_text = "dummy";
// set only in order to break
if ($new_text) {
$section = substr_replace($section, $new_text, $brackets_loc, $brackets_end_loc + 3 - $brackets_loc);
} else {
$start_position = $brackets_end_loc;
}
}
} else {
// tag is not one of the three allowed values
// ignore tag
$start_position = $brackets_end_loc;
}
// end if
}
// end while
}
// end for
// get free text, and add to page data, as well as retroactively
// inserting it into the form
// If $form_is_partial is true then either:
// (a) we're processing a replacement (param 'partial' == 1)
// (b) we're sending out something to be replaced (param 'partial' is missing)
if ($form_is_partial) {
if (!$wgRequest->getCheck('partial')) {
$free_text = $original_page_content;
$form_text .= SFFormUtils::hiddenFieldHTML('partial', 1);
} else {
$free_text = null;
$existing_page_content = preg_replace('/²\\{(.*?)\\}²/s', '{{\\1}}', $existing_page_content);
$existing_page_content = preg_replace('/\\{\\{\\{insertionpoint\\}\\}\\}/', '', $existing_page_content);
$existing_page_content = Sanitizer::safeEncodeAttribute($existing_page_content);
}
} elseif ($source_is_page) {
// if the page is the source, free_text will just be whatever in the
// page hasn't already been inserted into the form
$free_text = trim($existing_page_content);
// or get it from a form submission
} elseif ($wgRequest->getCheck('free_text')) {
$free_text = $wgRequest->getVal('free_text');
if (!$free_text_was_included) {
$data_text .= "<free_text>";
}
// or get it from the form definition
} elseif ($free_text_preload_page != null) {
$free_text = SFFormUtils::getPreloadedText($free_text_preload_page);
} else {
$free_text = null;
}
# the free text is set here
// if the FCKeditor extension is installed, use that for the free text input
global $wgFCKEditorDir;
if ($wgFCKEditorDir) {
$showFCKEditor = SFFormUtils::getShowFCKEditor();
$free_text = htmlspecialchars($free_text);
if ($showFCKEditor & RTE_VISIBLE) {
$free_text = SFFormUtils::prepareTextForFCK($free_text);
}
} else {
$showFCKEditor = 0;
$free_text = Sanitizer::safeEncodeAttribute($free_text);
}
// now that we have it, substitute free text into the form and page
$form_text = str_replace('<free_text>', $free_text, $form_text);
$data_text = str_replace('<free_text>', $free_text, $data_text);
# return the fields
return $__fields;
}
