NaszvadiG
9/6/2013 - 11:01 PM
Form.php
<?php if (!defined('BASEPATH')) exit('No direct script access allowed');
/**
* CodeIgniter Drupal-inspited Form API plus Bootstrap integration
*
* NOTE: This library does not provide utilities to protect forms
* against CSRF attacks. Make sure that you already turned CI's CSRF
* protection ON.
*
* @package CodeIgniter
* @author Sepehr Lajevardi <me@sepehr.ws>
* @copyright Copyright (c) 2012 Sepehr Lajevardi.
* @license http://codeigniter.com/user_guide/license.html
* @link https://github.com/sepehr/ci-form
* @version Version 1.0
* @filesource
*/
// ------------------------------------------------------------------------
/**
* Form API class for CodeIgniter.
*
* @package CodeIgniter
* @subpackage Libraries
* @category Forms
* @author Sepehr Lajevardi <me@sepehr.ws>
* @link https://github.com/sepehr/ci-form
* @todo - Form caching
* - Debug logs
* - Error handling
* - Redocument, add usage examples
* - Cleanup! It's very alpha, we need a better structure and more unified API
* - There are a bunch of templates that could be merged together, redundancy sucks!
* - Dependent dropdowns.
* - Ajax API, if possible.
* - Move templates into config files.
* - Make use of set_checkbox(), set_radio() when populating toggles.
* - Language class integration.
*/
class Form {
/**
* Stores the superobject.
* @var object
*/
private static $CI;
//--------------------------------------------------------------------
/**
* Stores the form default values.
* @var object
*/
private static $_values = array();
//--------------------------------------------------------------------
// Defaults
//--------------------------------------------------------------------
/**
* Stores field defaults.
* @var string
*/
private static $_form_defaults = array(
'action' => '',
'prefix' => '',
'suffix' => '',
'errors' => array(),
'attributes' => array(),
'multipart' => FALSE,
'multistep' => FALSE,
'multistep_nav' => FALSE,
'multistep_manual' => FALSE,
);
//--------------------------------------------------------------------
/**
* Stores fieldset defaults.
* @var string
*/
private static $_fieldset_defaults = array(
'legend' => '',
'prefix' => '',
'suffix' => '',
'active' => FALSE,
'attributes' => array(),
'accordion' => array(),
'type' => 'fieldset',
'before' => '',
'after' => '',
);
//--------------------------------------------------------------------
/**
* Stores field defaults.
* @var string
*/
private static $_field_defaults = array(
'type' => 'text',
'required' => FALSE,
'icon' => FALSE,
'disabled' => FALSE,
'readonly' => FALSE,
'form_actions' => FALSE,
'inline' => FALSE,
'error_type' => 'block',
'help_type' => 'block',
'class' => 'form-control span2',
'required_markup' => ' <strong>*</strong>',
'attributes' => array(),
'input_append' => '',
'render_class' => '',
'render_callback' => '',
'label' => '',
'value' => '',
'placeholder' => '',
'wrapper_class' => '',
'prefix' => '',
'suffix' => '',
'suffix_inline' => '',
'extra' => '',
'help' => '',
'error' => '',
'help_block' => '',
'help_inline' => '',
'checked' => '',
'selected' => '',
'options' => '',
'popover' => '',
'popover_title' => '',
'rules' => '',
'before' => '',
'after' => '',
'private' => '',
);
//--------------------------------------------------------------------
/**
* Stores input types.
* @var string
*/
private static $_input_fields = array(
'checkbox', 'datetime-local',
'color', 'date',
'datetime', 'week',
'email', 'file',
'hidden', 'image',
'month', 'number',
'password', 'radio',
'range', 'reset',
'search', 'submit',
'tel', 'text',
'time', 'url',
);
//--------------------------------------------------------------------
// Templates
//--------------------------------------------------------------------
/**
* Stores common fields template prototype.
* @var string
*/
private static $_default_template = '
{before}
<div id="{wrapper_id}" class="control-group {type}-control-wrapper{wrapper_class}{error}">
<label class="control-label" for="{id}">{label}{required}</label>
<div class="controls">
<div class="input-prepend{input_append}">
{icon}
{prefix}
<{element} id="{id}" class="{class}" placeholder="{placeholder}" name="{name}" type="{type}" value="{value}" {attributes} {disabled}{readonly}{checked}{selected} />
{suffix_inline}
{help_inline}
{help_block}
</div> <!-- /.input-prepend -->
{suffix}
</div> <!-- /.controls -->
</div> <!-- /.control-group -->
{after}
{private}
';
//--------------------------------------------------------------------
/**
* Stores common inline fields template prototype.
* @var string
*/
private static $_default_inline_template = '
{before}
<div id="{wrapper_id}" class="input-prepend inline-field">
{icon}
<{element} id="{id}" class="{class}" placeholder="{placeholder}" name="{name}" type="{type}" value="{value}" {attributes} {disabled}{readonly}{checked}{selected} />
</div> <!-- /.input-prepend -->
{after}
{private}
';
//--------------------------------------------------------------------
/**
* Stores hidden fields template prototype.
* @var string
*/
private static $_hidden_template = '
<input type="hidden" name="{name}" value="{value}" />
';
//--------------------------------------------------------------------
/**
* Stores a field help markup prototype.
* @var string
*/
private static $_accordion_template = '
<div {attributes}>
<div class="accordion-heading">
<a class="accordion-toggle" data-toggle="collapse" data-parent="#form-accordion" href="#{target_id}">{title}</a>
</div> <!-- /.accordion-heading -->
<div id="{target_id}" class="accordion-body collapse{active}">
<div class="accordion-inner">
{nav_prev} {body} {nav_next}
</div> <!-- /.accordion-inner -->
</div> <!-- /.accordion-body -->
</div> <!-- /.accordion-group -->
';
//--------------------------------------------------------------------
/**
* Stores a dropdown template prototype.
* @var string
*/
private static $_dropdown_template = '
{before}
<div id="{wrapper_id}" class="control-group {type}-control-wrapper{wrapper_class}{error}">
<label class="control-label" for="{id}">{label}{required}</label>
<div class="controls">
<div class="input-prepend{input_append}">
{icon}
{prefix}
{options}
{suffix_inline}
{help_inline}
{help_block}
</div> <!-- /.input-prepend -->
{suffix}
</div> <!-- /.controls -->
</div> <!-- /.control-group -->
{after}
{private}
';
//--------------------------------------------------------------------
/**
* Stores an inline dropdown template prototype.
* @var string
*/
private static $_dropdown_inline_template = '
{before}
<div class="input-prepend inline-field">
<label for="{id}">{label}{required}</label>
{icon}
{options}
</div>
{after}
{private}
';
//--------------------------------------------------------------------
/**
* Stores a button template prototype.
* @var string
*/
private static $_button_template = '
{before}
<div class="controls{form_actions}">
<{element} id="{id}" class="form-submit btn {class}" {attributes}>{value}</{element}>
</div> <!-- /.controls -->
{after}
{private}
';
//--------------------------------------------------------------------
/**
* Stores an inline button template prototype.
* @var string
*/
private static $_button_inline_template = '
{before}
<{element} id="{id}" class="form-submit btn {class}" style="float:none" {attributes}>{value}</{element}>
{after}
{private}
';
//--------------------------------------------------------------------
/**
* Stores a textarea template prototype.
* @var string
*/
private static $_textarea_template = '
{before}
<div id="{wrapper_id}" class="control-group {type}-control-wrapper{wrapper_class}{error}">
<label class="control-label" for="{id}">{label}{required}</label>
<div class="controls">
<div class="input-prepend{input_append}">
{icon}
{prefix}
<textarea id="{id}" class="{class}" placeholder="{placeholder}" name="{name}" type="{type}" {attributes} {disabled}{readonly}>{value}</textarea>
{suffix_inline}
{help_inline}
{help_block}
</div> <!-- /.input-prepend -->
{suffix}
</div> <!-- /.controls -->
</div> <!-- /.control-group -->
{after}
{private}
';
//--------------------------------------------------------------------
/**
* Stores checkboxes/radios template prototype.
* @var string
*/
private static $_toggles_template = '
{before}
<div id="{wrapper_id}" class="control-group {type}-control-wrapper{wrapper_class}{error}">
<label class="control-label" for="{id}">{label}{required}</label>
<div class="controls">
{prefix}
{options}
{suffix_inline}
</div> <!-- /.controls -->
{suffix}
</div> <!-- /.control-group -->
{after}
{private}
';
//--------------------------------------------------------------------
/**
* Stores an inline checkbox/radio template prototype.
* @var string
*/
private static $_toggle_template = '
{before}
<label class="{toggle} inline">
<input type="{toggle}" name="{name}" value="{value}" {attributes} {checked} /> {label}
</label>
{after}
{private}
';
//--------------------------------------------------------------------
/**
* Stores a field icon prototype.
* @var string
*/
private static $_icon_template = '<i class="icon icon-{icon}"></i>';
//--------------------------------------------------------------------
/**
* Stores a field help markup prototype.
* @var string
*/
private static $_help_template = '<span class="help-{type}">{help}</span>';
//--------------------------------------------------------------------
/**
* Form API Constructor
*
* @return void
*/
public function __construct()
{
// Get CI superobject
self::$CI =& get_instance();
// And load the form helper
self::$CI->load->helper('form_helper');
}
//--------------------------------------------------------------------
// API Functions
//--------------------------------------------------------------------
/**
* Loads a form definition and returns the rendered output.
*
* @return string
*/
public static function get($form_name, $values = FALSE, $render = TRUE, $flush = FALSE)
{
static $cache = array();
// Internally cache the form array, since it might be
// used for several times in one request.
(isset($cache[$form_name]) AND !$flush) OR $cache[$form_name] = self::load($form_name, $values);
// Return the form array or rendered HTML, if requested
return $render ? self::render($cache[$form_name]) : $cache[$form_name];
}
//--------------------------------------------------------------------
/**
* Loads a form definition array from a config file.
*
* @return array
*/
public static function load($form_name, $values = FALSE)
{
// Load form definition file,
// and set it to fail gracefully
if (self::$CI->load->config($form_name, FALSE, TRUE))
{
// Get the array
$form = self::$CI->config->item(basename($form_name));
// Set default field values to be overriden, if required
self::set_defaults($values);
// Allow other parties to manipulate the form array
class_exists('Events') AND Events::trigger("form_{$form_name}_alter", $form);
return $form;
}
// Failed to load form definition file
log_message('error', 'Form definition failed: ' . $form_name);
return FALSE;
}
//--------------------------------------------------------------------
/**
* Rendered a form definition array/sub-array into its HTML equivalent.
*
* @return string
*/
public static function render($form, $subform = FALSE)
{
// Terminate if not an array
if ( ! is_array($form))
{
return FALSE;
}
$output = '';
// Apply form defaults
$fields = $form = array_merge(self::$_form_defaults, $form);
// Render openning tag
$subform OR list($output, $fields) = self::_render_form_open($form, $form['multistep'], $form['multistep_manual']);
// Render fields and fieldsets
$output .= self::_render_fields($fields, $form['multistep']);
// Render closing tag
$subform OR $output .= self::_render_form_close($form['suffix'], $form['multistep']);
return $output;
}
//--------------------------------------------------------------------
/**
* Validates a form against its rules.
*
* This might be used instead of the $this->form_validation->[set_rules()|run()];
*
* @return boolean
*/
public static function validate($form_name, $CI = FALSE)
{
// Make sure that we have CI form validation class already in place.
class_exists('CI_Form_validation') OR self::$CI->load->library('form_validation');
// Workaround the HMVC issue
self::validate_init($CI);
// Load the form array
$form = self::load($form_name);
// Set custom callbacks validation errors
if (isset($form['errors']) AND is_array($form['errors']))
{
self::set_message($form['errors']);
}
$rules = self::_validate_rules($form);
// Pass it to the CI validation
return self::$CI
->form_validation
->set_rules($rules)
->run();
}
//--------------------------------------------------------------------
/**
* Works around form validation HMVC issue.
*
* @return void
*/
public static function validate_init($CI = FALSE)
{
is_object($CI) AND self::$CI->form_validation->CI = $CI;
}
//--------------------------------------------------------------------
/**
* Extracts validation rules from a form definition.
*
* @return array
*/
public static function validate_rules($form_name)
{
if ($form = self::load($form_name))
{
return self::_validate_rules($form);
}
return FALSE;
}
//--------------------------------------------------------------------
/**
* Sets custom callback error message.
*
* It's identical to CI form validation's set_message(),
* it's a wrapper in fact!
*/
public static function set_message($callback, $error = FALSE)
{
// Check if it's an array of callbacks
if (is_array($callback))
{
foreach ($callback as $name => $error)
{
self::set_message($name, $error);
}
}
// Make sure that we have CI form validation class already in place.
// @TODO: Cache check results.
class_exists('CI_Form_validation') OR self::$CI->load->library('form_validation');
self::$CI->form_validation->set_message($callback, $error);
}
//--------------------------------------------------------------------
/**
* Flushes form validation field data.
*
* @return void
*/
public static function flush($flush_post = TRUE)
{
// Flush $_POST data
$flush_post AND $_POST = array();
// Flush form validation data
if (class_exists('CI_Form_validation'))
{
// Reset form validation field data, here comes the hack!
self::$CI->form_validation = class_exists('MY_Form_validation')
? new MY_Form_validation()
: new CI_Form_validation();
}
}
//--------------------------------------------------------------------
/**
* Prepares the value for display in the form.
*
* @return string
*/
public static function value($name, $default = '')
{
// $_POST values?
if (isset($_POST[$name]))
{
return form_prep($_POST[$name]);
}
// Default values?
if (isset(self::$_values[$name]))
{
return form_prep(self::$_values[$name]);
}
return set_value($name, $default);
}
//--------------------------------------------------------------------
/**
* Checks checkbox/radio element values.
*
* @return boolean
* @todo REVIEW, FIX
*/
public static function value_toggled($name, $value, $checked = FALSE)
{
$clean = self::clean($name);
// Posted, check $_POST
if (isset($_POST[$clean]))
{
return is_array($_POST[$clean])
? in_array($value, $_POST[$clean])
: $_POST[$clean];
}
// Check if it's posted, but not checked
if ( ! empty($_POST) AND isset($_POST[$clean . '__toggle']))
{
// Set it! this will be a lil help for our controllers/models
$_POST[$clean] = FALSE;
return FALSE;
}
// Check self::$_values for single booleans
if (isset(self::$_values[$clean]))
{
return is_array(self::$_values[$clean])
? in_array($value, self::$_values[$clean])
: (bool) self::$_values[$name];
}
// Return the default passed
return $checked;
}
//--------------------------------------------------------------------
/**
* Returns form validation errors.
*
* @return boolean
*/
public static function errors($to_array = FALSE)
{
if ($to_array)
{
// Remove error delimiters
self::$CI->form_validation->set_error_delimiters(FALSE, FALSE);
// Return validation errors array
return array_filter(explode("\n", validation_errors()));
}
return validation_errors();
}
//--------------------------------------------------------------------
/**
* Sets form default valurs
*
* @return void
*/
public static function set_defaults($values)
{
is_object($values) AND $values = (array) $values;
is_array($values) AND self::$_values = $values;
}
//--------------------------------------------------------------------
/**
* Cleans string from []s.
*
* @return string
*/
public static function clean($name)
{
if (($pos = strpos($name, '[]')) !== FALSE)
{
$name = substr($name, 0, $pos);
}
return str_replace(array('[', ']'), array('-', ''), $name);
}
//--------------------------------------------------------------------
// Internal Renderrer methods
//--------------------------------------------------------------------
/**
* Renders an array of fields.
*
* @return string
*/
private static function _render_fields($fields, $multistep = FALSE)
{
$output = '';
if ( ! is_array($fields))
{
// Temporary:
return 'Form::_render_fields(): $fields is not properly formatted array, get some coffee!';
}
// Render each field to HTML by calling its corresponding renderrer callback
foreach ($fields as $name => &$data)
{
if ( ! isset($data['type']))
{
continue;
}
// Let submit typed inputs to be rendered as buttons
$data['type'] == 'submit' AND $data['type'] = 'button';
// Prepare checkbox/radiobutton elements, @TODO: Review.
if ($data['type'] == 'checkbox' OR $data['type'] == 'radio')
{
// Preserve element type and make sure that we'll
// call _render_toggles() to support renderring
// checkbox/radio groups
$data['toggle'] = $data['type'];
$data['type'] = 'toggles';
}
// 1. User custom renderrer: @TODO
// 2. Field specific renderrer:
if (method_exists(get_class(), '_render_' . $data['type']))
{
$renderer = '_render_' . $data['type'];
$output .= self::$renderer($data, $name, $multistep);
continue;
}
// 3. Default field renderrer:
$output .= self::_render_field($data, $name);
}
return $output;
}
//--------------------------------------------------------------------
/**
* Renders a single element array into HTML.
*
* @return string
*/
private static function _render_field($field, $name = FALSE, $template = FALSE)
{
// Set the correct template
$template OR $template = isset($field['inline']) ? self::$_default_inline_template : self::$_default_template;
// Setup field name
$name OR $name = isset($field['name']) ? $field['name']: 'no_name_' . rand(1, 10);
// Merge field defaults
$field = array_merge(self::$_field_defaults, $field);
// Remove brackets from name attribute, if any
$clean = self::clean($name);
// Add field extras
$field += array(
'name' => $name,
'id' => "edit-$clean",
'wrapper_id' => "$clean-wrapper",
);
// Field help
if ($field['help'])
{
$field["help_{$field['help_type']}"] = str_replace(array('{type}', '{help}'), array($field['help_type'], $field['help']), self::$_help_template);
}
// Field error
// @TODO: Errors overwrite help messages, fix this behavior
if (function_exists('form_error') AND form_error($field['name']))
{
$field['error'] = ' error'; // The wrapper flag class
$field["help_{$field['error_type']}"] = str_replace(array('{type}', '{help}'), array($field['error_type'], form_error($field['name'])), self::$_help_template);
}
// Field icon
$field['icon'] AND $field['icon'] = '<span class="add-on">' . self::_render_icon($field['icon']) . '</span>';
// Field element type
isset($field['element']) OR
$field['element'] = in_array($field['type'], self::$_input_fields) ? 'input' : $field['type'];
// @TODO: Improve this
// Prepare field value, exclude buttons, checkboxes and radios
if (isset($field['value']) AND $field['type'] != 'button' AND !isset($field['toggle']))
{
$field['value'] = self::value($field['name'], $field['value']);
}
// Boolean flags
$field['readonly'] = $field['readonly'] ? ' readonly' : '';
$field['disabled'] = $field['disabled'] ? ' disabled' : '';
// Mark field as required if it's so
$field['required'] = strpos($field['rules'], 'required') === FALSE ? '' : $field['required_markup'];
// Class strings
// @TODO: Fix form_actions. We should be able to group multiple buttons into one form_actions element
$field['form_actions'] AND $field['form_actions'] = ' form-actions';
$field['wrapper_class'] AND $field['wrapper_class'] = ' ' . $field['wrapper_class'];
// Popovers
$field['popover'] AND $field['attributes'] += array(
'rel' => 'popover',
'data-content' => $field['popover'],
'data-original-title' => $field['popover_title'],
);
// Parse extra attributes
isset($field['attributes']) AND $field['attributes'] = _parse_form_attributes($field['attributes'], array());
// Parse inline fields in suffix
if (isset($field['suffix']) AND is_array($field['suffix']))
{
$field['suffix'] = self::_render_fields($field['suffix']);
}
// As well as in suffix_inline
if (isset($field['suffix_inline']) AND is_array($field['suffix_inline']))
{
$field['suffix_inline'] = self::_render_fields($field['suffix_inline']);
$field['input_append'] = ' input-append';
}
// And as in after
isset($field['after']) AND is_array($field['after'])
AND $field['after'] = self::_render_fields($field['after']);
// Prep field placeholder map
foreach ($field as $key => $value)
{
$field['{' . $key . '}'] = $value;
unset($field[$key]);
}
return str_replace(array_keys($field), array_values($field), $template);
}
//--------------------------------------------------------------------
/**
* Renders a a subform array into HTML.
*
* @return string
*/
private static function _render_subform($field, $name = FALSE, $multistep = FALSE)
{
// Load subform array
$subform = self::load($field['subform']);
return self::_render_fields($subform, FALSE);
}
//--------------------------------------------------------------------
/**
* Renders a fieldset element and its embedded fields.
*
* @return string
*/
private static function _render_fieldset($fieldset, $name = FALSE, $multistep = FALSE)
{
$output = '';
// Merge fieldset defaults
$fieldset = array_merge(self::$_fieldset_defaults, $fieldset);
// Render fieldset prefix
$fieldset['prefix'] AND $output .= $fieldset['prefix'];
$output .= '<fieldset ' . _parse_form_attributes($fieldset['attributes'], array()) . '>';
// Render fieldset legend
$fieldset['legend'] AND $output .= '<legend>' . $fieldset['legend'] . '</legend>';
// Unset fieldset attributes
$_fieldset = $fieldset;
foreach (self::$_fieldset_defaults as $key => $value)
{
unset($fieldset[$key]);
}
// Render embedded fields
$output .= self::render($fieldset, TRUE) . '</fieldset>';
// Render fieldset suffix
$_fieldset['suffix'] AND $output .= $_fieldset['suffix'];
// Render fieldset as a multistep form step, if required
if ($multistep)
{
// Accordion dynamic defaults
// @TODO Integrate language class
$accordion_defaults = array(
'nav_buttons' => FALSE,
'body' => $output,
'title' => $_fieldset['legend'],
'active' => $_fieldset['active'],
'target_id' => $name . '-accordion',
'attributes' => array('class' => 'accordion-group', 'id' => $name . '-accordion-wrapper'),
'nav_next' => '',
'nav_prev' => '',
'nav_next_label' => 'Next',
'nav_prev_label' => 'Previous',
);
// Merge accordion defaults
$_fieldset['accordion'] = array_merge($accordion_defaults, $_fieldset['accordion']);
// Render fieldset as an accordion
$output = self::_render_accordion($_fieldset['accordion'], $name);
}
return $output;
}
//--------------------------------------------------------------------
/**
* Renders the passing array into an accordion element.
*
* @return string
*/
private static function _render_accordion($accordion, $name = FALSE)
{
// @TODO: Make sure that accordion group class is set
// Accordion navigation?
if ($accordion['nav_buttons'])
{
foreach (array('prev', 'next') as $nav)
{
if (isset($accordion["nav_$nav"]) AND $accordion["nav_$nav"])
{
// Render accordion navigation buttons
$accordion["nav_$nav"] = self::_render_button(array(
'type' => 'button',
'element' => 'a',
'class' => "btn btn-info pull-right accordion-$nav",
'value' => $accordion["nav_{$nav}_label"],
'attributes' => array(
'data-toggle' => 'collapse',
'data-parent' => '#form-accordion',
'data-target' => '#' . $accordion["nav_$nav"],
),
), "nav_button_$nav", FALSE);
}
}
}
// Active step? add the class
$accordion['active'] AND $accordion['active'] = ' in';
return self::_render_field($accordion, $name, self::$_accordion_template);
}
//--------------------------------------------------------------------
/**
* Renders a textarea element.
*
* @return string
*/
private static function _render_textarea($field, $name = FALSE, $multistep = FALSE)
{
return self::_render_field($field, $name, self::$_textarea_template);
}
//--------------------------------------------------------------------
/**
* Renders a toggle element (checkbox/radio).
*
* @return string
*/
private static function _render_toggle($field, $name = FALSE, $multistep = FALSE)
{
// Checkbox/radio value setup
if (self::value_toggled($name, $field['value'], $field['checked']))
{
$field['checked'] = 'checked';
}
return self::_render_field($field, $name, self::$_toggle_template);
}
//--------------------------------------------------------------------
/**
* Renders a group of toggle element (checkbox/radio).
*
* @return string
*/
public static function _render_toggles($field, $name = FALSE, $multistep = FALSE)
{
$toggles = '';
// Load checkbox/radio data model if set
if (isset($field['data']))
{
$field['options'] = self::_call_data_model($field['data']);
}
// Render each option as a single checkbox/radio element
foreach ($field['options'] as $value => $label)
{
$toggles .= self::_render_toggle(array(
'type' => 'toggles',
'value' => $value,
'label' => $label,
'toggle' => $field['toggle'],
'checked' => isset($field['value']) ? in_array($value, $field['value']) : FALSE,
), $name);
}
// Set rendered elements as options
$field['options'] = $toggles;
unset($field['value']);
// Append a hidden helper field, this will let
// us detect unchecked toggles on form submits
$field['private'] = self::_render_hidden('1', self::clean($name) . '__toggle');
return self::_render_field($field, $name, self::$_toggles_template);
}
//--------------------------------------------------------------------
/**
* Renders a button element.
*
* @return string
* @todo Ensure proper button classes
*/
private static function _render_button($button, $name = FALSE, $multistep = FALSE)
{
// Rendering A, DIV or SPAN elements as buttons?
isset($button['element']) OR $button['element'] = 'button';
// Add type if it's a button
$button['element'] == 'button' AND $button['element'] .= ' type="submit"';
// Default icon set?
if (isset($button['icon']))
{
$button['icon_prefix'] = $button['icon'];
unset($button['icon']);
}
// Inline icon: prefix
isset($button['icon_prefix']) AND
$button['value'] = self::_render_icon($button['icon_prefix']) . $button['value'];
// Inline icon: suffix
isset($button['icon_suffix']) AND
$button['value'] .= self::_render_icon($button['icon_suffix']);
// Inline element?
$template = isset($button['inline'])
? self::$_button_inline_template
: self::$_button_template;
return self::_render_field($button, $name, $template);
}
//--------------------------------------------------------------------
/**
* Renders a markup element.
*
* @return string
*/
private static function _render_markup($markup, $name = FALSE, $multistep = FALSE, $element = 'button')
{
// Load and return the view if it's set to
if (isset($markup['view']))
{
// View data may come in various formats, here they are:
if (isset($markup['data']) AND is_array($markup['data']))
{
// 1. Flat arrays: In this case we should fetch values from form defaults
foreach ($markup['data'] as $index => $key)
{
if (is_numeric($index) AND isset(self::$_values[$key]))
{
unset($markup['data'][$index]);
$markup['data'][$key] = self::$_values[$key];
}
}
}
// 2. No data set, fetch from defaults if available
else
{
$markup['data'] = isset(self::$_values[$name]) ? array($name => self::$_values[$name]) : '';
}
// 3. Otherwise there should be a key/valued array in data
return self::$CI->load->view($markup['view'], $markup['data'], TRUE);
}
// Otherwise check for raw HTML in 'value'
return isset($markup['value']) ? $markup['value'] : '';
}
//--------------------------------------------------------------------
/**
* Renders a select element.
*
* @return string
*/
private static function _render_dropdown($dropdown, $name, $multistep = FALSE)
{
// Load dropdown data model if set.
isset($dropdown['data']) AND $dropdown['options'] = self::_call_data_model($dropdown['data']);
// Prepare value
isset($dropdown['value']) OR $dropdown['value'] = '';
$dropdown['value'] = self::value($name, $dropdown['value']);
// Handle dropdown attributes
isset($dropdown['attributes']) OR $dropdown['attributes'] = array();
$dropdown['attributes'] += array('id' => 'edit-' . self::clean($name));
// Helps overcome dependent dropdowns issue on prepopulated options
(isset($dropdown['cached_value']) AND $dropdown['cached_value'])
AND $dropdown['attributes'] += array('cached_value' => $dropdown['value']);
// Parse attributes into string
$attributes = _parse_form_attributes($dropdown['attributes'], array());
// Handle multiselect dropdowns
$helper = (isset($dropdown['multiselect']) AND $dropdown['multiselect']) ? 'form_multiselect' : 'form_dropdown';
// Render dropdown select and option elements
isset($dropdown['options']) AND
$dropdown['options'] = $helper($name, $dropdown['options'], $dropdown['value'], $attributes);
// Inline element?
$template = isset($dropdown['inline'])
? self::$_dropdown_inline_template
: self::$_dropdown_template;
return self::_render_field($dropdown, $name, $template);
}
//--------------------------------------------------------------------
/**
* Renders an icon element.
*
* @return string
*/
public static function _render_icon($icon)
{
return str_replace('{icon}', $icon, self::$_icon_template);
}
//--------------------------------------------------------------------
/**
* Renders a hidden element.
*
* @return string
*/
public static function _render_hidden($field, $name, $multistep = FALSE)
{
// Get field value if it's an array
is_array($field) AND $field = $field['value'];
$hidden = str_replace('{name}', $name, self::$_hidden_template);
return str_replace('{value}', $field, $hidden);
}
//--------------------------------------------------------------------
/**
* Renders a form element openning tag.
*
* @return array
*/
private static function _render_form_open($form, $multistep = FALSE, $manual = FALSE)
{
// Open form, multipart if required
$output = $form['prefix'] . ($form['multipart']
? form_open_multipart($form['action'], $form['attributes'])
: form_open($form['action'], $form['attributes']));
// Prepare accordion collapse type
$manual = $manual ? 'manual' : 'auto';
// If the form is multistep, append accordion wrapper
$multistep AND $output .= '<div class="accordion" id="form-accordion" data-collapse-type="' . $manual . '">';
// Prep form array for field render
foreach (self::$_form_defaults as $key => $value)
{
unset($form[$key]);
}
return array($output, $form);
}
//--------------------------------------------------------------------
/**
* Renders a form element closing tag.
*
* @return string
*/
private static function _render_form_close($suffix, $multistep = FALSE)
{
// If the form is multistep, append accordion wrapper
$output = $multistep ? '</div>' : '';
return $output . form_close($suffix);
}
//--------------------------------------------------------------------
// Misc Helpers
//--------------------------------------------------------------------
/**
* Builds a validation array out of the form array.
*
* @return array
*/
private static function _validate_rules($form)
{
$rules = array();
foreach ($form as $name => $field)
{
// Extract rules from fieldsets
if (isset($field['type']) AND $field['type'] == 'fieldset')
{
$rules = array_merge($rules, self::_validate_rules($field));
continue;
}
// Extract rules from subforms
if (isset($field['type']) AND $field['type'] == 'subform')
{
$rules = array_merge($rules, self::_validate_rules(self::load($field['subform'])));
continue;
}
// Skip non-fields, or fields with no
if ( ! is_array($field) OR ! isset($field['type']) OR ! isset($field['rules']))
{
continue;
}
$rules[] = array(
'field' => $name,
'rules' => $field['rules'],
// Field label is optional, field name will be used instead
'label' => isset($field['label']) ? $field['label'] : '',
);
}
return $rules;
}
//--------------------------------------------------------------------
/**
* Calls form field data model method.
*/
private static function _call_data_model($data)
{
// Get model data
list($model, $method) = explode('.', $data);
$model_name = basename($model);
// Get method args, if any
preg_match('#\((.*?)\)#', $method, $match);
$arg = isset($match[1]) ? $match[1] : FALSE;
strpos($method, '(') !== FALSE AND $method = strstr($method, '(', TRUE);
// Typecast boolean args
if (strtolower($arg) == 'true' OR strtolower($arg) == 'false')
{
$arg = (bool) $arg;
}
// Load model, if not available
isset(self::$CI->$model_name) OR self::$CI->load->model($model, $model_name);
// Call the data method of provided model
// This will overwrite field "options" property
return method_exists(self::$CI->$model_name, $method)
? self::$CI->$model_name->$method($arg)
: array();
}
//--------------------------------------------------------------------
}
// End of Form class
/* End of file Form.php */
/* Location: ./application/libraries/Form.php */