diff --git a/modules/field/field.api.php b/modules/field/field.api.php
index 39618ea08e10f6c7915a9306758250d956d9b4aa..f8d2137d9c1ed32208ef2c1f5df70c1e1fe17be5 100644
--- a/modules/field/field.api.php
+++ b/modules/field/field.api.php
@@ -100,6 +100,63 @@ function hook_fieldable_info_alter(&$info) {
$info['node']['cacheable'] = FALSE;
}
+/**
+ * Expose "pseudo-field" components on fieldable objects.
+ *
+ * Field UI's 'Manage fields' page lets users re-order fields, but also
+ * non-field components. For nodes, that would be title, menu settings, or
+ * other elements exposed by contributed modules through hook_form() or
+ * hook_form_alter().
+ *
+ * Fieldable entities or contributed modules that want to have their components
+ * supported should expose them using this hook, and use
+ * field_attach_extra_weight() to retrieve the user-defined weight when
+ * inserting the component.
+ *
+ * @param $bundle
+ * The name of the bundle being considered.
+ * @return
+ * An array of 'pseudo-field' components. The keys are the name of the element
+ * as it appears in the form structure. The values are arrays with the
+ * following key/value pairs:
+ * - label: The human readable name of the component.
+ * - description: A short description of the component contents.
+ * - weight: The default weight of the element.
+ * - view: (optional) The name of the element as it appears in the rendered
+ * structure, if different from the name in the form.
+ */
+function hook_field_extra_fields($bundle) {
+ $extra = array();
+
+ if ($type = node_type_get_type($bundle)) {
+ if ($type->has_title) {
+ $extra['title'] = array(
+ 'label' => $type->title_label,
+ 'description' => t('Node module element.'),
+ 'weight' => -5,
+ );
+ }
+ if ($bundle == 'poll' && module_exists('poll')) {
+ $extra['title'] = array(
+ 'label' => t('Poll title'),
+ 'description' => t('Poll module title.'),
+ 'weight' => -5,
+ );
+ $extra['choice_wrapper'] = array(
+ 'label' => t('Poll choices'),
+ 'description' => t('Poll module choices.'),
+ 'weight' => -4,
+ );
+ $extra['settings'] = array(
+ 'label' => t('Poll settings'),
+ 'description' => t('Poll module settings.'),
+ 'weight' => -3,
+ );
+ }
+ }
+ return $extra;
+}
+
/**
* @} End of "ingroup field_fieldable_type"
*/
diff --git a/modules/field/field.attach.inc b/modules/field/field.attach.inc
index 55241f5affae60c82217347c961e2c87864478d1..838c6d93ced5c7534a1d7b5a50583e2f2d3852c2 100644
--- a/modules/field/field.attach.inc
+++ b/modules/field/field.attach.inc
@@ -457,6 +457,11 @@ function _field_invoke_multiple_default($op, $obj_type, $objects, &$a = NULL, &$
function field_attach_form($obj_type, $object, &$form, &$form_state) {
$form += (array) _field_invoke_default('form', $obj_type, $object, $form, $form_state);
+ // Add custom weight handling.
+ list($id, $vid, $bundle) = field_attach_extract_ids($obj_type, $object);
+ $form['#pre_render'][] = '_field_extra_weights_pre_render';
+ $form['#extra_fields'] = field_extra_fields($bundle);
+
// Let other modules make changes to the form.
foreach (module_implements('field_attach_form') as $module) {
$function = $module . '_field_attach_form';
@@ -1043,6 +1048,11 @@ function field_attach_view($obj_type, $object, $build_mode = 'full') {
$output = _field_invoke_default('view', $obj_type, $object, $build_mode);
+ // Add custom weight handling.
+ list($id, $vid, $bundle) = field_attach_extract_ids($obj_type, $object);
+ $output['#pre_render'][] = '_field_extra_weights_pre_render';
+ $output['#extra_fields'] = field_extra_fields($bundle);
+
// Let other modules make changes after rendering the view.
drupal_alter('field_attach_view', $output, $obj_type, $object, $build_mode);
@@ -1050,6 +1060,24 @@ function field_attach_view($obj_type, $object, $build_mode = 'full') {
}
+/**
+ * Retrieve the user-defined weight for a 'pseudo-field' component.
+ *
+ * @param $bundle
+ * The bundle name.
+ * @param $pseudo_field
+ * The name of the 'pseudo-field'.
+ * @return
+ * The weight for the 'pseudo-field', respecting the user settings stored by
+ * field.module.
+ */
+function field_attach_extra_weight($bundle, $pseudo_field) {
+ $extra = field_extra_fields($bundle);
+ if (isset($extra[$pseudo_field])) {
+ return $extra[$pseudo_field]['weight'];
+ }
+}
+
/**
* Implement hook_node_prepare_translation.
*
@@ -1084,7 +1112,7 @@ function field_attach_create_bundle($bundle) {
// Clear the cache.
field_cache_clear();
-
+ menu_rebuild();
foreach (module_implements('field_attach_create_bundle') as $module) {
$function = $module . '_field_attach_create_bundle';
$function($bundle);
diff --git a/modules/field/field.crud.inc b/modules/field/field.crud.inc
index 08afcb695dd7da65745b2c78e194fe472f9008bf..cea858d53b61902e824af55ae83ea20b095d83f0 100644
--- a/modules/field/field.crud.inc
+++ b/modules/field/field.crud.inc
@@ -637,8 +637,8 @@ function field_read_instances($params = array(), $include_additional = array())
foreach ($params as $key => $value) {
$query->condition('fci.' . $key, $value);
}
- $query->condition('fc.active', 1);
if (!isset($include_additional['include_inactive']) || !$include_additional['include_inactive']) {
+ $query->condition('fc.active', 1);
$query->condition('fci.widget_active', 1);
}
if (!isset($include_additional['include_deleted']) || !$include_additional['include_deleted']) {
diff --git a/modules/field/field.default.inc b/modules/field/field.default.inc
index 927571e84c2a95cf183959efe00b157e5415f27c..2c5e175b4871e0cdd8f01f1cf6b87ae94a004026 100644
--- a/modules/field/field.default.inc
+++ b/modules/field/field.default.inc
@@ -43,11 +43,8 @@ function field_default_submit($obj_type, $object, $field, $instance, &$items, $f
function field_default_insert($obj_type, $object, $field, $instance, &$items) {
// _field_invoke() populates $items with an empty array if the $object has no
// entry for the field, so we check on the $object itself.
- if (!property_exists($object, $field['field_name']) && !empty($instance['default_value_function'])) {
- $function = $instance['default_value_function'];
- if (drupal_function_exists($function)) {
- $items = $function($obj_type, $object, $field, $instance);
- }
+ if (empty($object) || !property_exists($object, $field['field_name'])) {
+ $items = field_get_default_value($obj_type, $object, $field, $instance);
}
}
/**
diff --git a/modules/field/field.form.inc b/modules/field/field.form.inc
index 10f687a56bb5ba7bead44b41e3ad909027e330f4..0bc155bc47b5b87e50a795f2658fbcbadb1e829d 100644
--- a/modules/field/field.form.inc
+++ b/modules/field/field.form.inc
@@ -37,13 +37,9 @@ function field_default_form($obj_type, $object, $field, $instance, $items, &$for
'instance' => $instance,
);
- // Populate widgets with default values if we're creating a new object.
- if (empty($items) && empty($id) && !empty($instance['default_value_function'])) {
- $items = array();
- $function = $instance['default_value_function'];
- if (drupal_function_exists($function)) {
- $items = $function($obj_type, $object, $field, $instance);
- }
+ // Populate widgets with default values when creating a new object.
+ if (empty($items) && empty($id)) {
+ $items = field_get_default_value($obj_type, $object, $field, $instance);
}
$form_element = array();
diff --git a/modules/field/field.info.inc b/modules/field/field.info.inc
index 5507f548d1eb7418c1fae9a318ff1c966cc5e8c2..685edd2d45670ccbd175158c3359593bff701dff 100644
--- a/modules/field/field.info.inc
+++ b/modules/field/field.info.inc
@@ -25,6 +25,7 @@
*/
function _field_info_cache_clear() {
_field_info_collate_types(TRUE);
+ drupal_static_reset('field_build_modes');
_field_info_collate_fields(TRUE);
}
@@ -263,6 +264,11 @@ function _field_info_prepare_instance($instance, $field) {
// Make sure all expected instance settings are present.
$instance['settings'] += field_info_instance_settings($field['type']);
+ // Set a default value for the instance.
+ if (field_behaviors_widget('default value', $instance) == FIELD_BEHAVIOR_DEFAULT && !isset($instance['default_value'])) {
+ $instance['default_value'] = NULL;
+ }
+
// Fallback to default widget if widget type is not available.
if (!field_info_widget_types($instance['widget']['type'])) {
$instance['widget']['type'] = $field_type['default_widget'];
diff --git a/modules/field/field.module b/modules/field/field.module
index 2be05058d884ccadb7dce22ee6047a7e42b213dd..e1e03b554e9c2264730f46cb76af6884142e5467 100644
--- a/modules/field/field.module
+++ b/modules/field/field.module
@@ -265,6 +265,32 @@ function field_associate_fields($module) {
}
}
+/**
+ * Helper function to get the default value for a field on an object.
+ *
+ * @param $obj_type
+ * The type of $object; e.g. 'node' or 'user'.
+ * @param $object
+ * The object for the operation.
+ * @param $field
+ * The field structure.
+ * @param $instance
+ * The instance structure.
+ */
+function field_get_default_value($obj_type, $object, $field, $instance) {
+ $items = array();
+ if (!empty($instance['default_value_function'])) {
+ $function = $instance['default_value_function'];
+ if (drupal_function_exists($function)) {
+ $items = $function($obj_type, $object, $field, $instance);
+ }
+ }
+ elseif (!empty($instance['default_value'])) {
+ $items = $instance['default_value'];
+ }
+ return $items;
+}
+
/**
* Helper function to filter out empty values.
*
@@ -279,15 +305,15 @@ function field_associate_fields($module) {
* TODO D7: poorly named...
*/
function field_set_empty($field, $items) {
- // Filter out empty values.
- $filtered = array();
$function = $field['module'] . '_field_is_empty';
+ // We ensure the function is loaded, but explicitly break if it is missing.
+ drupal_function_exists($function);
foreach ((array) $items as $delta => $item) {
- if (!$function($item, $field)) {
- $filtered[] = $item;
+ if ($function($item, $field)) {
+ unset($items[$delta]);
}
}
- return $filtered;
+ return array_values($items);
}
/**
@@ -335,7 +361,7 @@ function _field_sort_items_value_helper($a, $b) {
* Registry of available build modes.
*/
function field_build_modes($obj_type) {
- static $info;
+ $info = &drupal_static(__FUNCTION__, array());
if (!isset($info[$obj_type])) {
$info[$obj_type] = module_invoke_all('field_build_modes', $obj_type);
@@ -343,6 +369,63 @@ function field_build_modes($obj_type) {
return $info[$obj_type];
}
+/**
+ * Registry of pseudo-field components in a given bundle.
+ *
+ * @param $bundle_name
+ * The bundle name.
+ * @return
+ * The array of pseudo-field elements in the bundle.
+ */
+function field_extra_fields($bundle_name) {
+ $info = &drupal_static(__FUNCTION__, array());
+
+ if (empty($info)) {
+ $info = array();
+ $bundles = field_info_bundles();
+ foreach ($bundles as $bundle => $bundle_label) {
+ // Gather information about non-field object additions.
+ $extra = module_invoke_all('field_extra_fields', $bundle);
+ drupal_alter('field_extra_fields', $extra, $bundle);
+
+ // Add saved weights.
+ foreach (variable_get("field_extra_weights_$bundle", array()) as $key => $value) {
+ // Some stored entries might not exist anymore, for instance if uploads
+ // have been disabled or vocabularies were deleted.
+ if (isset($extra[$key])) {
+ $extra[$key]['weight'] = $value;
+ }
+ }
+ $info[$bundle] = $extra;
+ }
+ }
+ if (array_key_exists($bundle_name, $info)) {
+ return $info[$bundle_name];
+ }
+ else {
+ return array();
+ }
+}
+
+/**
+ * Pre-render callback to adjust weights of non-field elements on objects.
+ */
+function _field_extra_weights_pre_render($elements) {
+ if (isset($elements['#extra_fields'])) {
+ foreach ($elements['#extra_fields'] as $key => $value) {
+ // Some core 'fields' use a different key in node forms and in 'view'
+ // render arrays. Ensure that we are not on a form first.
+ if (!isset($elements['#build_id']) && isset($value['view']) && isset($elements[$value['view']])) {
+ $elements[$value['view']]['#weight'] = $value['weight'];
+ }
+ elseif (isset($elements[$key])) {
+ $elements[$key]['#weight'] = $value['weight'];
+ }
+ }
+ }
+ return $elements;
+}
+
/**
* Clear the cached information; called in several places when field
* information is changed.
diff --git a/modules/field/modules/list/list.module b/modules/field/modules/list/list.module
index 409cec7821c80eecd66dc6ed2257fd93686da196..f7401b83741b21bf082355a0a4d24ac85397bcf1 100644
--- a/modules/field/modules/list/list.module
+++ b/modules/field/modules/list/list.module
@@ -28,28 +28,28 @@ function list_field_info() {
'list' => array(
'label' => t('List'),
'description' => t('This field stores numeric keys from key/value lists of allowed values where the key is a simple alias for the position of the value, i.e. 0|First option, 1|Second option, 2|Third option.'),
- 'settings' => array('allowed_values_function' => ''),
+ 'settings' => array('allowed_values' => '', 'allowed_values_function' => ''),
'default_widget' => 'options_select',
'default_formatter' => 'list_default',
),
'list_boolean' => array(
'label' => t('Boolean'),
'description' => t('This field stores simple on/off or yes/no options.'),
- 'settings' => array('allowed_values_function' => ''),
+ 'settings' => array('allowed_values' => '', 'allowed_values_function' => ''),
'default_widget' => 'options_select',
'default_formatter' => 'list_default',
),
'list_number' => array(
'label' => t('List (numeric)'),
'description' => t('This field stores keys from key/value lists of allowed numbers where the stored numeric key has significance and must be preserved, i.e. \'Lifetime in days\': 1|1 day, 7|1 week, 31|1 month.'),
- 'settings' => array('allowed_values_function' => ''),
+ 'settings' => array('allowed_values' => '', 'allowed_values_function' => ''),
'default_widget' => 'options_select',
'default_formatter' => 'list_default',
),
'list_text' => array(
'label' => t('List (text)'),
'description' => t('This field stores keys from key/value lists of allowed values where the stored key has significance and must be a varchar, i.e. \'US States\': IL|Illinois, IA|Iowa, IN|Indiana'),
- 'settings' => array('allowed_values_function' => ''),
+ 'settings' => array('allowed_values' => '', 'allowed_values_function' => ''),
'default_widget' => 'options_select',
'default_formatter' => 'list_default',
),
@@ -97,6 +97,131 @@ function list_field_schema($field) {
);
}
+/**
+ * Implement hook_field_settings_form().
+ */
+function list_field_settings_form($field, $instance) {
+ $settings = $field['settings'];
+
+ $form['allowed_values'] = array(
+ '#type' => 'textarea',
+ '#title' => t('Allowed values list'),
+ '#default_value' => $settings['allowed_values'],
+ '#required' => FALSE,
+ '#rows' => 10,
+ '#description' => '<p>' . t('The possible values this field can contain. Enter one value per line, in the format key|label. The key is the value that will be stored in the database, and must be a %type value. The label is optional, and the key will be used as the label if no label is specified.', array('%type' => $field['type'] == 'list_text' ? t('text') : t('numeric'))) . '</p>',
+ '#element_validate' => array('list_allowed_values_validate'),
+ '#list_field_type' => $field['type'],
+ '#access' => empty($settings['allowed_values_function']),
+ );
+
+ // Alter the description for allowed values depending on the widget type.
+ if ($instance['widget']['type'] == 'options_onoff') {
+ $form['allowed_values']['#description'] .= '<p>' . t("For a 'single on/off checkbox' widget, define the 'off' value first, then the 'on' value in the <strong>Allowed values</strong> section. Note that the checkbox will be labeled with the label of the 'on' value.") . '</p>';
+ }
+ elseif ($instance['widget']['type'] == 'options_buttons') {
+ $form['allowed_values']['#description'] .= '<p>' . t("The 'checkboxes/radio buttons' widget will display checkboxes if the <em>Number of values</em> option is greater than 1 for this field, otherwise radios will be displayed.") . '</p>';
+ }
+ $form['allowed_values']['#description'] .= t('Allowed HTML tags in labels: @tags', array('@tags' => _field_filter_xss_display_allowed_tags()));
+
+ $form['allowed_values_function'] = array(
+ '#type' => 'value',
+ '#value' => $settings['allowed_values_function'],
+ );
+ $form['allowed_values_function_display'] = array(
+ '#type' => 'item',
+ '#title' => t('Allowed values list'),
+ '#markup' => t('The value of this field is being determined by the %function function and may not be changed.', array('%function' => $settings['allowed_values_function'])),
+ '#access' => !empty($settings['allowed_values_function']),
+ );
+
+ return $form;
+}
+
+/**
+ * Create an array of allowed values for this field.
+ */
+function list_allowed_values($field) {
+ $allowed_values = drupal_static(__FUNCTION__, array());
+
+ if (isset($allowed_values[$field['field_name']])) {
+ return $allowed_values[$field['field_name']];
+ }
+
+ $allowed_values[$field['field_name']] = array();
+
+ $function = $field['settings']['allowed_values_function'];
+ if (!empty($function) && drupal_function_exists($function)) {
+ $allowed_values[$field['field_name']] = $function($field);
+ }
+ elseif (!empty($field['settings']['allowed_values'])) {
+ $allowed_values[$field['field_name']] = list_allowed_values_list($field['settings']['allowed_values'], $field['type'] == 'list');
+ }
+
+ return $allowed_values[$field['field_name']];
+}
+
+/**
+ * Create an array of the allowed values for this field.
+ *
+ * Explode a string with keys and labels separated with '|' and with each new
+ * value on its own line.
+ *
+ * @param $string_values
+ * The list of choices as a string.
+ * @param $position_keys
+ * Boolean value indicating whether to generate keys based on the position of
+ * the value if a key is not manually specified, effectively generating
+ * integer-based keys. This should only be TRUE for fields that have a type of
+ * "list". Otherwise the value will be used as the key if not specified.
+ */
+function list_allowed_values_list($string_values, $position_keys = FALSE) {
+ $allowed_values = array();
+
+ $list = explode("\n", $string_values);
+ $list = array_map('trim', $list);
+ $list = array_filter($list, 'strlen');
+ foreach ($list as $key => $value) {
+ // Sanitize the user input with a permissive filter.
+ $value = field_filter_xss($value);
+
+ // Check for a manually specified key.
+ if (strpos($value, '|') !== FALSE) {
+ list($key, $value) = explode('|', $value);
+ }
+ // Otherwise see if we need to use the value as the key. The "list" type
+ // will automatically convert non-keyed lines to integers.
+ elseif (!$position_keys) {
+ $key = $value;
+ }
+ $allowed_values[$key] = (isset($value) && $value !== '') ? $value : $key;
+ }
+
+ return $allowed_values;
+}
+
+/**
+ * Element validate callback; check that the entered values are valid.
+ */
+function list_allowed_values_validate($element, &$form_state) {
+ $values = list_allowed_values_list($element['#value'], $element['#list_field_type'] == 'list');
+ $field_type = $element['#list_field_type'];
+ foreach ($values as $key => $value) {
+ if ($field_type == 'list_number' && !is_numeric($key)) {
+ form_error($element, t('The entered available values are not valid. Each key must be a valid integer or decimal.'));
+ break;
+ }
+ elseif ($field_type == 'list_text' && strlen($key) > 255) {
+ form_error($element, t('The entered available values are not valid. Each key must be a string less than 255 characters.'));
+ break;
+ }
+ elseif ($field_type == 'list' && (!preg_match('/^-?\d+$/', $key))) {
+ form_error($element, t('The entered available values are not valid. All specified keys must be integers.'));
+ break;
+ }
+ }
+}
+
/**
* Implement hook_field_validate().
*
@@ -161,29 +286,3 @@ function theme_field_formatter_list_default($element) {
function theme_field_formatter_list_key($element) {
return $element['#item']['safe'];
}
-
-/**
- * Create an array of the allowed values for this field.
- *
- * Call the allowed_values_function to retrieve the allowed
- * values array.
- *
- * TODO Rework this to create a method of selecting plugable allowed values lists.
- */
-function list_allowed_values($field) {
- static $allowed_values;
-
- if (isset($allowed_values[$field['field_name']])) {
- return $allowed_values[$field['field_name']];
- }
-
- $allowed_values[$field['field_name']] = array();
-
- if (isset($field['settings']['allowed_values_function'])) {
- $function = $field['settings']['allowed_values_function'];
- if (drupal_function_exists($function)) {
- $allowed_values[$field['field_name']] = $function($field);
- }
- }
- return $allowed_values[$field['field_name']];
-}
diff --git a/modules/field/modules/number/number.module b/modules/field/modules/number/number.module
index eb98aed5b4b78b399b17e7459bb999c6041f7986..52b3685f38c8bece9b0cbca12caf0b3454e99c83 100644
--- a/modules/field/modules/number/number.module
+++ b/modules/field/modules/number/number.module
@@ -87,6 +87,82 @@ function number_field_schema($field) {
);
}
+/**
+ * Implement hook_field_settings_form().
+ */
+function number_field_settings_form($field, $instance) {
+ $settings = $field['settings'];
+ $form = array();
+
+ if ($field['type'] == 'number_decimal') {
+ $form['precision'] = array(
+ '#type' => 'select',
+ '#title' => t('Precision'),
+ '#options' => drupal_map_assoc(range(10, 32)),
+ '#default_value' => $settings['precision'],
+ '#description' => t('The total number of digits to store in the database, including those to the right of the decimal.'),
+ );
+ $form['scale'] = array(
+ '#type' => 'select',
+ '#title' => t('Scale'),
+ '#options' => drupal_map_assoc(range(0, 10)),
+ '#default_value' => $settings['scale'],
+ '#description' => t('The number of digits to the right of the decimal.'),
+ );
+ $form['decimal'] = array(
+ '#type' => 'select',
+ '#title' => t('Decimal marker'),
+ '#options' => array(
+ '.' => 'decimal point',
+ ',' => 'comma',
+ ' ' => 'space',
+ ),
+ '#default_value' => $settings['decimal'],
+ '#description' => t('The character users will input to mark the decimal point in forms.'),
+ );
+ }
+
+ return $form;
+}
+
+/**
+ * Implement hook_field_instance_settings_form().
+ */
+function number_field_instance_settings_form($field, $instance) {
+ $settings = $instance['settings'];
+
+ $form['min'] = array(
+ '#type' => 'textfield',
+ '#title' => t('Minimum'),
+ '#default_value' => $settings['min'],
+ '#description' => t('The minimum value that should be allowed in this field. Leave blank for no minimum.'),
+ '#element_validate' => array('_element_validate_number'),
+ );
+ $form['max'] = array(
+ '#type' => 'textfield',
+ '#title' => t('Maximum'),
+ '#default_value' => $settings['max'],
+ '#description' => t('The maximum value that should be allowed in this field. Leave blank for no maximum.'),
+ '#element_validate' => array('_element_validate_number'),
+ );
+ $form['prefix'] = array(
+ '#type' => 'textfield',
+ '#title' => t('Prefix'),
+ '#default_value' => $settings['prefix'],
+ '#size' => 60,
+ '#description' => t("Define a string that should be prefixed to the value, like '$ ' or '€ '. Leave blank for none. Separate singular and plural values with a pipe ('pound|pounds')."),
+ );
+ $form['suffix'] = array(
+ '#type' => 'textfield',
+ '#title' => t('Suffix'),
+ '#default_value' => $settings['suffix'],
+ '#size' => 60,
+ '#description' => t("Define a string that should suffixed to the value, like ' m', ' kb/s'. Leave blank for none. Separate singular and plural values with a pipe ('pound|pounds')."),
+ );
+
+ return $form;
+}
+
/**
* Implement hook_field_validate().
*
diff --git a/modules/field/modules/text/text.module b/modules/field/modules/text/text.module
index b123602fd21c494d89e09b4c35b33cfb3b27830f..ba69c310bdd97086e4c509ecb9510e2839942004 100644
--- a/modules/field/modules/text/text.module
+++ b/modules/field/modules/text/text.module
@@ -128,6 +128,51 @@ function text_field_schema($field) {
);
}
+/**
+ * Implement hook_field_settings_form().
+ */
+function text_field_settings_form($field, $instance) {
+ $settings = $field['settings'];
+
+ $form['max_length'] = array(
+ '#type' => 'textfield',
+ '#title' => t('Maximum length'),
+ '#default_value' => $settings['max_length'],
+ '#required' => FALSE,
+ '#description' => t('The maximum length of the field in characters. Leave blank for an unlimited size.'),
+ '#element_validate' => array('_element_validate_integer_positive'),
+ );
+
+ return $form;
+}
+
+/**
+ * Implement hook_field_instance_settings_form().
+ */
+function text_field_instance_settings_form($field, $instance) {
+ $settings = $instance['settings'];
+
+ $form['text_processing'] = array(
+ '#type' => 'radios',
+ '#title' => t('Text processing'),
+ '#default_value' => $settings['text_processing'],
+ '#options' => array(
+ t('Plain text'),
+ t('Filtered text (user selects input format)'),
+ ),
+ );
+ if ($field['type'] == 'text_with_summary') {
+ $form['display_summary'] = array(
+ '#type' => 'checkbox',
+ '#title' => t('Summary input'),
+ '#default_value' => $settings['display_summary'],
+ '#description' => t('This allows authors to input an explicit summary, to be displayed instead of the automatically trimmed text when using the "Summary or trimmed" display format.'),
+ );
+ }
+
+ return $form;
+}
+
/**
* Implement hook_field_validate().
*
@@ -466,6 +511,35 @@ function text_field_widget_info() {
);
}
+/**
+ * Implement hook_field_widget_settings_form().
+ */
+function text_field_widget_settings_form($field, $instance) {
+ $widget = $instance['widget'];
+ $settings = $widget['settings'];
+
+ if ($widget['type'] == 'text_textfield') {
+ $form['size'] = array(
+ '#type' => 'textfield',
+ '#title' => t('Size of textfield'),
+ '#default_value' => $settings['size'],
+ '#required' => TRUE,
+ '#element_validate' => array('_element_validate_integer_positive'),
+ );
+ }
+ else {
+ $form['rows'] = array(
+ '#type' => 'textfield',
+ '#title' => t('Rows'),
+ '#default_value' => $settings['rows'],
+ '#required' => TRUE,
+ '#element_validate' => array('_element_validate_integer_positive'),
+ );
+ }
+
+ return $form;
+}
+
/**
* Implement FAPI hook_elements().
*
diff --git a/modules/field_ui/field_ui-display-overview-form.tpl.php b/modules/field_ui/field_ui-display-overview-form.tpl.php
new file mode 100644
index 0000000000000000000000000000000000000000..d4c2d903f14c44c2eeb6b7740970d9d47c938454
--- /dev/null
+++ b/modules/field_ui/field_ui-display-overview-form.tpl.php
@@ -0,0 +1,55 @@
+<?php
+// $Id$
+
+/**
+ * @file
+ * Default theme implementation to configure field display settings.
+ *
+ * Available variables:
+ *
+ * - $form: The complete form for the field display settings.
+ * - $contexts: An associative array of the available contexts for these fields.
+ * On the node field display settings this defaults to including "teaser" and
+ * "full" as the available contexts.
+ * - $rows: The field display settings form broken down into rendered rows for
+ * printing as a table.
+ * - $submit: The rendered submit button for this form.
+ *
+ * @see field_ui_display_overview_form()
+ * @see template_preprocess_field_ui_display_overview_form()
+ */
+?>
+<?php if ($rows): ?>
+ <table id="field-display-overview" class="sticky-enabled">
+ <thead>
+ <tr>
+ <th> </th>
+ <?php foreach ($contexts as $key => $value): ?>
+ <th colspan="2"><?php print $value; ?>
+ <?php endforeach; ?>
+ </tr>
+ <tr>
+ <th><?php print t('Field'); ?></th>
+ <?php foreach ($contexts as $key => $value): ?>
+ <th><?php print t('Label'); ?></th>
+ <th><?php print t('Format'); ?></th>
+ <?php endforeach; ?>
+ </tr>
+ </thead>
+ <tbody>
+ <?php
+ $count = 0;
+ foreach ($rows as $row): ?>
+ <tr class="<?php print $count % 2 == 0 ? 'odd' : 'even'; ?>">
+ <td><span class="<?php print $row->label_class; ?>"><?php print $row->human_name; ?></span></td>
+ <?php foreach ($contexts as $context => $title): ?>
+ <td><?php print $row->{$context}->label; ?></td>
+ <td><?php print $row->{$context}->type; ?></td>
+ <?php endforeach; ?>
+ </tr>
+ <?php $count++;
+ endforeach; ?>
+ </tbody>
+ </table>
+ <?php print $submit; ?>
+<?php endif; ?>
diff --git a/modules/field_ui/field_ui-field-overview-form.tpl.php b/modules/field_ui/field_ui-field-overview-form.tpl.php
new file mode 100644
index 0000000000000000000000000000000000000000..178e5151331af2ed248aba7f4470ba08c7fab5fa
--- /dev/null
+++ b/modules/field_ui/field_ui-field-overview-form.tpl.php
@@ -0,0 +1,94 @@
+<?php
+// $Id$
+
+/**
+ * @file
+ * Default theme implementation to configure field settings.
+ *
+ * Available variables:
+ *
+ * - $form: The complete overview form for the field settings.
+ * - $contexts: An associative array of the available contexts for these fields.
+ * On the node field display settings this defaults to including "teaser" and
+ * "full" as the available contexts.
+ * - $rows: The field overview form broken down into rendered rows for printing
+ * as a table.
+ * - $submit: The rendered submit button for this form.
+ *
+ * @see field_ui_field_overview_form()
+ * @see template_preprocess_field_ui_field_overview_form()
+ */
+?>
+<table id="field-overview" class="sticky-enabled">
+ <thead>
+ <tr>
+ <th><?php print t('Label'); ?></th>
+ <th><?php print t('Weight'); ?></th>
+ <th><?php print t('Name'); ?></th>
+ <th><?php print t('Field'); ?></th>
+ <th><?php print t('Widget'); ?></th>
+ <th colspan="2"><?php print t('Operations'); ?></th>
+ </tr>
+ </thead>
+ <tbody>
+ <?php
+ $count = 0;
+ foreach ($rows as $row): ?>
+ <tr class="<?php print $count % 2 == 0 ? 'odd' : 'even'; ?> <?php print $row->class ?>">
+ <?php
+ switch ($row->row_type):
+ case 'field': ?>
+ <td>
+ <span class="<?php print $row->label_class; ?>"><?php print $row->label; ?></span>
+ </td>
+ <td><?php print $row->weight . $row->hidden_name; ?></td>
+ <td><?php print $row->field_name; ?></td>
+ <td><?php print $row->type; ?></td>
+ <td><?php print $row->widget_type; ?></td>
+ <td><?php print $row->edit; ?></td>
+ <td><?php print $row->delete; ?></td>
+ <?php break;
+
+ case 'extra': ?>
+ <td>
+ <span class="<?php print $row->label_class; ?>"><?php print $row->label; ?></span>
+ </td>
+ <td><?php print $row->weight . $row->hidden_name; ?></td>
+ <td><?php print $row->name; ?></td>
+ <td colspan="2"><?php print $row->description; ?></td>
+ <td><?php print $row->edit; ?></td>
+ <td><?php print $row->delete; ?></td>
+ <?php break;
+
+ case 'add_new_field': ?>
+ <td>
+ <div class="<?php print $row->label_class; ?>">
+ <div class="new"><?php print t('Add new field'); ?></div>
+ <?php print $row->label; ?>
+ </div>
+ </td>
+ <td><div class="new"> </div><?php print $row->weight . $row->hidden_name; ?></td>
+ <td colspan="2"><div class="new"> </div><?php print $row->field_name; ?></td>
+ <td><div class="new"> </div><?php print $row->type; ?></td>
+ <td colspan="2"><div class="new"> </div><?php print $row->widget_type; ?></td>
+ <?php break;
+
+ case 'add_existing_field': ?>
+ <td>
+ <div class="<?php print $row->label_class; ?>">
+ <div class="new"><?php print t('Add existing field'); ?></div>
+ <?php print $row->label; ?>
+ </div>
+ </td>
+ <td><div class="new"> </div><?php print $row->weight . $row->hidden_name; ?></td>
+ <td colspan="3"><div class="new"> </div><?php print $row->field_name; ?></td>
+ <td colspan="2"><div class="new"> </div><?php print $row->widget_type; ?></td>
+ <?php break;
+ endswitch; ?>
+ </tr>
+ <?php $count++;
+ endforeach; ?>
+ </tbody>
+</table>
+
+<?php print $submit; ?>
diff --git a/modules/field_ui/field_ui-rtl.css b/modules/field_ui/field_ui-rtl.css
new file mode 100644
index 0000000000000000000000000000000000000000..6823e1e0b172f3ff7546b179d58c9804b1f969fd
--- /dev/null
+++ b/modules/field_ui/field_ui-rtl.css
@@ -0,0 +1,8 @@
+/* $Id$ */
+
+/* 'Manage fields' overview */
+#field-overview .label-add-new-field,
+#field-overview .label-add-existing-field {
+ float: right;
+}
+
diff --git a/modules/field_ui/field_ui.admin.inc b/modules/field_ui/field_ui.admin.inc
new file mode 100644
index 0000000000000000000000000000000000000000..caaa2d062b9c66206dad55c8a173393cf5192544
--- /dev/null
+++ b/modules/field_ui/field_ui.admin.inc
@@ -0,0 +1,1398 @@
+<?php
+// $Id$
+
+/**
+ * @file
+ * Administrative interface for custom field type creation.
+ */
+
+/**
+ * Menu callback; lists all defined fields for quick reference.
+ */
+function field_ui_fields_list() {
+ $instances = field_info_instances();
+ $field_types = field_info_field_types();
+ $bundles = field_info_bundles();
+ $header = array(t('Field name'), t('Field type'), t('Used in'));
+ $rows = array();
+ foreach ($instances as $bundle => $info) {
+ foreach ($info as $field_name => $instance) {
+ $field = field_info_field($field_name);
+ $admin_path = _field_ui_bundle_admin_path($bundle);
+ $rows[$field_name]['data'][0] = $field['locked'] ? t('@field_name (Locked)', array('@field_name' => $field_name)) : $field_name;
+ $rows[$field_name]['data'][1] = t($field_types[$field['type']]['label']);
+ $rows[$field_name]['data'][2][] = l($bundles[$bundle]['label'], $admin_path . '/fields');
+ $rows[$field_name]['class'] = $field['locked'] ? 'menu-disabled' : '';
+ }
+ }
+ foreach ($rows as $field_name => $cell) {
+ $rows[$field_name]['data'][2] = implode(', ', $cell['data'][2]);
+ }
+ if (empty($rows)) {
+ $output = t('No fields have been defined for any content type yet.');
+ }
+ else {
+ // Sort rows by field name.
+ ksort($rows);
+ $output = theme('table', $header, $rows);
+ }
+ return $output;
+}
+
+/**
+ * Helper function to display a message about inactive fields.
+ */
+function field_ui_inactive_message($bundle) {
+ $inactive_instances = field_ui_inactive_instances($bundle);
+ if (!empty($inactive_instances)) {
+ $field_types = field_info_field_types();
+ $widget_types = field_info_widget_types();
+
+ foreach ($inactive_instances as $field_name => $instance) {
+ $list[] = t('%field (@field_name) field requires the %widget_type widget provided by %widget_module module', array(
+ '%field' => $instance['label'],
+ '@field_name' => $instance['field_name'],
+ '%widget_type' => array_key_exists($instance['widget']['type'], $widget_types) ? $widget_types[$instance['widget']['type']]['label'] : $instance['widget']['type'],
+ '%widget_module' => $instance['widget']['module'],
+ ));
+ }
+ drupal_set_message(t('Inactive fields are not shown unless their providing modules are enabled. The following fields are not enabled: !list', array('!list' => theme('item_list', $list))), 'error');
+ }
+}
+
+/**
+ * Menu callback; listing of fields for a content type.
+ *
+ * Allows fields and pseudo-fields to be re-ordered.
+ */
+function field_ui_field_overview_form(&$form_state, $obj_type, $bundle) {
+ $bundle = field_attach_extract_bundle($obj_type, $bundle);
+
+ field_ui_inactive_message($bundle);
+ $admin_path = _field_ui_bundle_admin_path($bundle);
+
+ // When displaying the form, make sure the list of fields is up-to-date.
+ if (empty($form_state['post'])) {
+ field_cache_clear();
+ }
+
+ // Gather bundle information.
+ $instances = field_info_instances($bundle);
+ $field_types = field_info_field_types();
+ $widget_types = field_info_widget_types();
+
+ $extra = field_extra_fields($bundle);
+
+ // Store each default weight so that we can add the 'add new' rows after them.
+ $weights = array();
+
+ $form = array(
+ '#tree' => TRUE,
+ '#bundle' => $bundle,
+ '#fields' => array_keys($instances),
+ '#extra' => array_keys($extra),
+ '#field_rows' => array(),
+ );
+
+ // Fields.
+ foreach ($instances as $name => $instance) {
+ $field = field_info_field($instance['field_name']);
+ $admin_field_path = $admin_path . '/fields/' . $instance['field_name'];
+ $weight = $instance['widget']['weight'];
+ $form[$name] = array(
+ 'label' => array(
+ '#markup' => check_plain($instance['label']),
+ ),
+ 'field_name' => array(
+ '#markup' => $instance['field_name'],
+ ),
+ 'type' => array(
+ '#markup' => l(t($field_types[$field['type']]['label']), $admin_field_path . '/field-settings', array('attributes' => array('title' => t('Edit field settings.')))),
+ ),
+ 'widget_type' => array(
+ '#markup' => l(t($widget_types[$instance['widget']['type']]['label']), $admin_field_path . '/widget-type', array('attributes' => array('title' => t('Change widget type.')))),
+ ),
+ 'edit' => array(
+ '#markup' => l(t('edit'), $admin_field_path, array('attributes' => array('title' => t('Edit instance settings.')))),
+ ),
+ 'delete' => array(
+ '#markup' => l(t('delete'), $admin_field_path . '/delete', array('attributes' => array('title' => t('Delete instance.')))),
+ ),
+ 'weight' => array(
+ '#type' => 'textfield',
+ '#default_value' => $weight,
+ '#size' => 3,
+ ),
+ 'hidden_name' => array(
+ '#type' => 'hidden',
+ '#default_value' => $instance['field_name'],
+ ),
+ '#row_type' => 'field',
+ );
+
+ if (!empty($instance['locked'])) {
+ $form[$name]['edit'] = array('#value' => t('Locked'));
+ $form[$name]['delete'] = array();
+ $form[$name]['#disabled_row'] = TRUE;
+ }
+ $form['#field_rows'][] = $name;
+ $weights[] = $weight;
+ }
+
+ // Non-field elements.
+ foreach ($extra as $name => $label) {
+ $weight = $extra[$name]['weight'];
+ $form[$name] = array(
+ 'label' => array(
+ '#markup' => t($extra[$name]['label']),
+ ),
+ 'name' => array(
+ '#markup' => $name,
+ ),
+ 'description' => array(
+ '#markup' => isset($extra[$name]['description']) ? $extra[$name]['description'] : '',
+ ),
+ 'weight' => array(
+ '#type' => 'textfield',
+ '#default_value' => $weight,
+ '#size' => 3,
+ ),
+ 'edit' => array(
+ '#markup' => isset($extra[$name]['edit']) ? $extra[$name]['edit'] : '',
+ ),
+ 'delete' => array(
+ '#markup' => isset($extra[$name]['delete']) ? $extra[$name]['delete'] : '',
+ ),
+ 'hidden_name' => array(
+ '#type' => 'hidden',
+ '#default_value' => $name,
+ ),
+ '#disabled_row' => TRUE,
+ '#row_type' => 'extra',
+ );
+ $form['#field_rows'][] = $name;
+ $weights[] = $weight;
+ }
+
+ // Additional row: add new field.
+ $weight = !empty($weights) ? max($weights) + 1 : 0;
+ $field_type_options = field_ui_field_type_options();
+ $widget_type_options = field_ui_widget_type_options(NULL, TRUE);
+ if ($field_type_options && $widget_type_options) {
+ array_unshift($field_type_options, t('- Select a field type -'));
+ array_unshift($widget_type_options, t('- Select a widget -'));
+ $name = '_add_new_field';
+ $form[$name] = array(
+ 'label' => array(
+ '#type' => 'textfield',
+ '#size' => 15,
+ '#description' => t('Label'),
+ ),
+ 'field_name' => array(
+ '#type' => 'textfield',
+ // This field should stay LTR even for RTL languages.
+ '#field_prefix' => '<span dir="ltr">field_',
+ '#field_suffix' => '</span>‎',
+ '#attributes' => array('dir'=>'ltr'),
+ '#size' => 15,
+ '#description' => t('Field name (a-z, 0-9, _)'),
+ ),
+ 'type' => array(
+ '#type' => 'select',
+ '#options' => $field_type_options,
+ '#description' => t('Type of data to store.'),
+ ),
+ 'widget_type' => array(
+ '#type' => 'select',
+ '#options' => $widget_type_options,
+ '#description' => t('Form element to edit the data.'),
+ ),
+ 'weight' => array(
+ '#type' => 'textfield',
+ '#default_value' => $weight,
+ '#size' => 3,
+ ),
+ 'hidden_name' => array(
+ '#type' => 'hidden',
+ '#default_value' => $name,
+ ),
+ '#add_new' => TRUE,
+ '#row_type' => 'add_new_field',
+ );
+ $form['#field_rows'][] = $name;
+ }
+
+ // Additional row: add existing field.
+ $existing_field_options = field_ui_existing_field_options($bundle);
+ if ($existing_field_options && $widget_type_options) {
+ $weight++;
+ array_unshift($existing_field_options, t('- Select an existing field -'));
+ $name = '_add_existing_field';
+ $form[$name] = array(
+ 'label' => array(
+ '#type' => 'textfield',
+ '#size' => 15,
+ '#description' => t('Label'),
+ ),
+ 'field_name' => array(
+ '#type' => 'select',
+ '#options' => $existing_field_options,
+ '#description' => t('Field to share'),
+ ),
+ 'widget_type' => array(
+ '#type' => 'select',
+ '#options' => $widget_type_options,
+ '#description' => t('Form element to edit the data.'),
+ ),
+ 'weight' => array(
+ '#type' => 'textfield',
+ '#default_value' => $weight,
+ '#size' => 3,
+ ),
+ 'hidden_name' => array(
+ '#type' => 'hidden',
+ '#default_value' => $name,
+ ),
+ '#add_new' => TRUE,
+ '#row_type' => 'add_existing_field',
+ );
+ $form['#field_rows'][] = $name;
+ }
+
+ $form['submit'] = array('#type' => 'submit', '#value' => t('Save'));
+ return $form;
+}
+
+/**
+ * Theme preprocess function for field_ui-field-overview-form.tpl.php.
+ */
+function template_preprocess_field_ui_field_overview_form(&$vars) {
+ $form = &$vars['form'];
+
+ drupal_add_css(drupal_get_path('module', 'field_ui') . '/field_ui.css');
+ drupal_add_tabledrag('field-overview', 'order', 'sibling', 'field-weight');
+ drupal_add_js(drupal_get_path('module', 'field_ui') . '/field_ui.js');
+ // Add settings for the update selects behavior.
+ $js_fields = array();
+ foreach (field_ui_existing_field_options($form['#bundle']) as $field_name => $fields) {
+ $field = field_info_field($field_name);
+ $instance = field_info_instance($field_name, $form['#bundle']);
+ $js_fields[$field_name] = array('label' => $instance['label'], 'type' => $field['type'], 'widget' => $instance['widget']['type']);
+ }
+ drupal_add_js(array('fieldWidgetTypes' => field_ui_widget_type_options(), 'fields' => $js_fields), 'setting');
+
+ $order = _field_ui_overview_order($form, $form['#field_rows']);
+ $rows = array();
+
+ // Identify the 'new item' keys in the form.
+ $keys = array_keys($form);
+ $add_rows = array();
+ foreach ($keys as $key) {
+ if (substr($key, 0, 4) == '_add') {
+ $add_rows[] = $key;
+ }
+ }
+ while ($order) {
+ $key = reset($order);
+ $element = &$form[$key];
+ $row = new stdClass();
+
+ // Add target classes for the tabledrag behavior.
+ $element['weight']['#attributes']['class'] = 'field-weight';
+ $element['hidden_name']['#attributes']['class'] = 'field-name';
+ // Add target classes for the update selects behavior.
+ switch ($element['#row_type']) {
+ case 'add_new_field':
+ $element['type']['#attributes']['class'] = 'field-type-select';
+ $element['widget_type']['#attributes']['class'] = 'widget-type-select';
+ break;
+
+ case 'add_existing_field':
+ $element['field_name']['#attributes']['class'] = 'field-select';
+ $element['widget_type']['#attributes']['class'] = 'widget-type-select';
+ $element['label']['#attributes']['class'] = 'label-textfield';
+ break;
+ }
+ foreach (element_children($element) as $child) {
+ $row->{$child} = drupal_render($element[$child]);
+ }
+ $row->label_class = 'label-' . strtr($element['#row_type'], '_', '-');
+ $row->row_type = $element['#row_type'];
+ $row->class = 'draggable';
+ $row->class .= isset($element['#add_new']) ? ' add-new' : '';
+ $row->class .= isset($element['#disabled_row']) ? ' menu-disabled' : '';
+
+ $rows[] = $row;
+ array_shift($order);
+ }
+ $vars['rows'] = $rows;
+ $vars['submit'] = drupal_render_children($form);
+}
+
+/**
+ * Validate handler for the field overview form.
+ */
+function field_ui_field_overview_form_validate($form, &$form_state) {
+ _field_ui_field_overview_form_validate_add_new($form, $form_state);
+ _field_ui_field_overview_form_validate_add_existing($form, $form_state);
+}
+
+/**
+ * Helper function for field_ui_field_overview_form_validate.
+ *
+ * Validate the 'add new field' row.
+ */
+function _field_ui_field_overview_form_validate_add_new($form, &$form_state) {
+ $field = $form_state['values']['_add_new_field'];
+
+ // Validate if any information was provided in the 'add new field' row.
+ if (array_filter(array($field['label'], $field['field_name'], $field['type'], $field['widget_type']))) {
+ // Missing label.
+ if (!$field['label']) {
+ form_set_error('_add_new_field][label', t('Add new field: you need to provide a label.'));
+ }
+
+ // Missing field name.
+ if (!$field['field_name']) {
+ form_set_error('_add_new_field][field_name', t('Add new field: you need to provide a field name.'));
+ }
+ // Field name validation.
+ else {
+ $field_name = $field['field_name'];
+
+ // Add the 'field_' prefix.
+ if (substr($field_name, 0, 6) != 'field_') {
+ $field_name = 'field_' . $field_name;
+ form_set_value($form['_add_new_field']['field_name'], $field_name, $form_state);
+ }
+
+ // Invalid field name.
+ if (!preg_match('!^field_[a-z0-9_]+$!', $field_name)) {
+ form_set_error('_add_new_field][field_name', t('Add new field: the field name %field_name is invalid. The name must include only lowercase unaccentuated letters, numbers, and underscores.', array('%field_name' => $field_name)));
+ }
+ if (strlen($field_name) > 32) {
+ form_set_error('_add_new_field][field_name', t("Add new field: the field name %field_name is too long. The name is limited to 32 characters, including the 'field_' prefix.", array('%field_name' => $field_name)));
+ }
+
+ // Field name already exists. We need to check inactive fields as well, so
+ // we can't use field_info_fields().
+ $fields = field_read_fields(array('field_name' => $field_name), array('include_inactive' => TRUE));
+ if ($fields) {
+ form_set_error('_add_new_field][field_name', t('Add new field: the field name %field_name already exists.', array('%field_name' => $field_name)));
+ }
+ }
+
+ // Missing field type.
+ if (!$field['type']) {
+ form_set_error('_add_new_field][type', t('Add new field: you need to select a field type.'));
+ }
+
+ // Missing widget type.
+ if (!$field['widget_type']) {
+ form_set_error('_add_new_field][widget_type', t('Add new field: you need to select a widget.'));
+ }
+ // Wrong widget type.
+ elseif ($field['type']) {
+ $widget_types = field_ui_widget_type_options($field['type']);
+ if (!isset($widget_types[$field['widget_type']])) {
+ form_set_error('_add_new_field][widget_type', t('Add new field: invalid widget.'));
+ }
+ }
+ }
+}
+
+/**
+ * Helper function for field_ui_field_overview_form_validate.
+ *
+ * Validate the 'add existing field' row.
+ */
+function _field_ui_field_overview_form_validate_add_existing($form, &$form_state) {
+ // The form element might be absent if no existing fields can be added to
+ // this content type
+ if (isset($form_state['values']['_add_existing_field'])) {
+ $field = $form_state['values']['_add_existing_field'];
+
+ // Validate if any information was provided in the 'add existing field' row.
+ if (array_filter(array($field['label'], $field['field_name'], $field['widget_type']))) {
+ // Missing label.
+ if (!$field['label']) {
+ form_set_error('_add_existing_field][label', t('Add existing field: you need to provide a label.'));
+ }
+
+ // Missing existing field name.
+ if (!$field['field_name']) {
+ form_set_error('_add_existing_field][field_name', t('Add existing field: you need to select a field.'));
+ }
+
+ // Missing widget type.
+ if (!$field['widget_type']) {
+ form_set_error('_add_existing_field][widget_type', t('Add existing field: you need to select a widget.'));
+ }
+ // Wrong widget type.
+ elseif ($field['field_name'] && ($existing_field = field_info_field($field['field_name']))) {
+ $widget_types = field_ui_widget_type_options($existing_field['type']);
+ if (!isset($widget_types[$field['widget_type']])) {
+ form_set_error('_add_existing_field][widget_type', t('Add existing field: invalid widget.'));
+ }
+ }
+ }
+ }
+}
+
+/**
+ * Submit handler for the field overview form.
+ */
+function field_ui_field_overview_form_submit($form, &$form_state) {
+ $form_values = $form_state['values'];
+ $bundle = $form['#bundle'];
+ $admin_path = _field_ui_bundle_admin_path($bundle);
+
+ // Update field weights.
+ $extra = array();
+ foreach ($form_values as $key => $values) {
+ if (in_array($key, $form['#fields'])) {
+ $instance = field_read_instance($key, $bundle);
+ $instance['widget']['weight'] = $values['weight'];
+ foreach($instance['display'] as $build_mode => $display) {
+ $instance['display'][$build_mode]['weight'] = $values['weight'];
+ }
+ field_update_instance($instance);
+ }
+ elseif (in_array($key, $form['#extra'])) {
+ $extra[$key] = $values['weight'];
+ }
+ }
+
+ if ($extra) {
+ variable_set("field_extra_weights_$bundle", $extra);
+ }
+ else {
+ variable_del("field_extra_weights_$bundle");
+ }
+
+ $destinations = array();
+
+ // Create new field.
+ $field = array();
+ if (!empty($form_values['_add_new_field']['field_name'])) {
+ $values = $form_values['_add_new_field'];
+
+ $field = array(
+ 'field_name' => $values['field_name'],
+ 'type' => $values['type'],
+ );
+ $instance = array(
+ 'field_name' => $field['field_name'],
+ 'bundle' => $bundle,
+ 'label' => $values['label'],
+ 'widget' => array(
+ 'type' => $values['widget_type'],
+ 'weight' => $values['weight'],
+ ),
+ );
+
+ // Create the field and instance.
+ try {
+ field_create_field($field);
+ field_create_instance($instance);
+
+ $destinations[] = $admin_path . '/fields/refresh';
+ $destinations[] = $admin_path . '/fields/' . $field['field_name'] . '/field-settings';
+ $destinations[] = $admin_path . '/fields/' . $field['field_name'] . '/edit';
+
+ // Store new field information for any additional submit handlers.
+ $form_state['fields_added']['_add_new_field'] = $field['field_name'];
+ }
+ catch (Exception $e) {
+ drupal_set_message(t('There was a problem creating field %label: @message.', array('%label' => $instance['label'], '@message' => $e->getMessage())));
+ }
+ }
+
+ // Add existing field.
+ if (!empty($form_values['_add_existing_field']['field_name'])) {
+ $values = $form_values['_add_existing_field'];
+ $field = field_info_field($values['field_name']);
+ if (!empty($field['locked'])) {
+ drupal_set_message(t('The field %label cannot be added because it is locked.', array('%label' => $values['label'])));
+ }
+ else {
+ $instance = array(
+ 'field_name' => $field['field_name'],
+ 'bundle' => $bundle,
+ 'label' => $values['label'],
+ 'widget' => array(
+ 'type' => $values['widget_type'],
+ 'weight' => $values['weight'],
+ ),
+ );
+
+ try {
+ field_create_instance($instance);
+ $destinations[] = $admin_path . '/fields/refresh';
+ $destinations[] = $admin_path . '/fields/' . $instance['field_name'] . '/edit';
+ // Store new field information for any additional submit handlers.
+ $form_state['fields_added']['_add_existing_field'] = $instance['field_name'];
+ }
+ catch (Exception $e) {
+ drupal_set_message(t('There was a problem creating field instance %label: @message.', array('%label' => $instance['label'], '@message' => $e->getMessage())));
+ }
+ }
+ }
+
+ if ($destinations) {
+ $destinations[] = urldecode(substr(drupal_get_destination(), 12));
+ unset($_REQUEST['destination']);
+ $form_state['redirect'] = field_ui_get_destinations($destinations);
+ }
+
+ field_cache_clear();
+}
+
+/**
+ * Menu callback; presents a listing of fields display settings for a content type.
+ *
+ * This form includes form widgets to select which fields appear in teaser and
+ * full build modes, and how the field labels should be rendered.
+ */
+function field_ui_display_overview_form(&$form_state, $obj_type, $bundle, $build_modes_selector = 'basic') {
+ $bundle = field_attach_extract_bundle($obj_type, $bundle);
+
+ field_ui_inactive_message($bundle);
+ $admin_path = _field_ui_bundle_admin_path($bundle);
+
+ // Gather type information.
+ $entity = field_info_bundle_entity($bundle);
+ $instances = field_info_instances($bundle);
+ $field_types = field_info_field_types();
+ $build_modes = field_ui_build_modes_tabs($entity, $build_modes_selector);
+
+ $form = array(
+ '#tree' => TRUE,
+ '#bundle' => $bundle,
+ '#fields' => array_keys($instances),
+ '#contexts' => $build_modes_selector,
+ );
+
+ if (empty($instances)) {
+ drupal_set_message(t('There are no fields yet added. You can add new fields on the <a href="@link">Manage fields</a> page.', array('@link' => url($admin_path . '/fields'))), 'warning');
+ return $form;
+ }
+
+ // Fields.
+ $label_options = array(
+ 'above' => t('Above'),
+ 'inline' => t('Inline'),
+ 'hidden' => t('<Hidden>'),
+ );
+ foreach ($instances as $name => $instance) {
+ $field = field_info_field($instance['field_name']);
+ $weight = $instance['widget']['weight'];
+
+ $form[$name] = array(
+ 'human_name' => array('#markup' => check_plain($instance['label'])),
+ 'weight' => array('#type' => 'value', '#value' => $weight),
+ );
+ $defaults = $instance['display'];
+
+ $formatter_options = field_ui_formatter_options($field['type']);
+ $formatter_options['hidden'] = t('<Hidden>');
+ foreach ($build_modes as $build_mode => $label) {
+ $display = isset($instance['display'][$build_mode]) ? $instance['display'][$build_mode] : $instance['display']['full'];
+ $form[$name][$build_mode]['label'] = array(
+ '#type' => 'select',
+ '#options' => $label_options,
+ '#default_value' => $display['label'],
+ );
+ $form[$name][$build_mode]['type'] = array(
+ '#type' => 'select',
+ '#options' => $formatter_options,
+ '#default_value' => $display['type'],
+ );
+ }
+ }
+
+ $form['submit'] = array('#type' => 'submit', '#value' => t('Save'));
+ return $form;
+}
+
+
+/**
+ * Theme preprocess function for field_ui-display-overview-form.tpl.php.
+ */
+function template_preprocess_field_ui_display_overview_form(&$vars) {
+ $form = &$vars['form'];
+
+ $contexts_selector = $form['#contexts'];
+ $vars['contexts'] = field_ui_build_modes_tabs(field_info_bundle_entity($form['#bundle']), $contexts_selector);
+
+ $order = _field_ui_overview_order($form, $form['#fields']);
+ if (empty($order)) {
+ $vars['rows'] = array();
+ $vars['submit'] = '';
+ return;
+ }
+ $rows = array();
+ foreach ($order as $key) {
+ $element = &$form[$key];
+ $row = new stdClass();
+ foreach (element_children($element) as $child) {
+ if (array_key_exists('label', $element[$child])) {
+ $row->{$child}->label = drupal_render($element[$child]['label']);
+ $row->{$child}->type = drupal_render($element[$child]['type']);
+ }
+ else {
+ $row->{$child} = drupal_render($element[$child]);
+ }
+ }
+ $row->label_class = 'label-field';
+ $rows[] = $row;
+ }
+
+ $vars['rows'] = $rows;
+ $vars['submit'] = drupal_render_children($form);
+}
+
+/**
+ * Submit handler for the display overview form.
+ */
+function field_ui_display_overview_form_submit($form, &$form_state) {
+ module_load_include('inc', 'field', 'includes/field.crud');
+ $form_values = $form_state['values'];
+ foreach ($form_values as $key => $values) {
+ if (in_array($key, $form['#fields'])) {
+ $instance = field_info_instance($key, $form['#bundle']);
+ unset($values['weight']);
+ $instance['display'] = array_merge($instance['display'], $values);
+ field_update_instance($instance);
+ }
+ }
+ drupal_set_message(t('Your settings have been saved.'));
+}
+
+/**
+ * Return an array of field_type options.
+ */
+function field_ui_field_type_options() {
+ $options = &drupal_static(__FUNCTION__);
+
+ if (!isset($options)) {
+ $options = array();
+ $field_types = field_info_field_types();
+ $field_type_options = array();
+ foreach ($field_types as $name => $field_type) {
+ // Skip field types which have no widget types.
+ if (field_ui_widget_type_options($name)) {
+ $options[$name] = $field_type['label'];
+ }
+ }
+ asort($options);
+ }
+ return $options;
+}
+
+/**
+ * Return an array of widget type options for a field type.
+ *
+ * If no field type is provided, returns a nested array of all widget types,
+ * keyed by field type human name.
+ */
+function field_ui_widget_type_options($field_type = NULL, $by_label = FALSE) {
+ $options = &drupal_static(__FUNCTION__);
+
+ if (!isset($options)) {
+ $options = array();
+ $field_types = field_info_field_types();
+ foreach (field_info_widget_types() as $name => $widget_type) {
+ foreach ($widget_type['field types'] as $widget_field_type) {
+ // Check that the field type exists.
+ if (isset($field_types[$widget_field_type])) {
+ $options[$widget_field_type][$name] = $widget_type['label'];
+ }
+ }
+ }
+ }
+
+ if (isset($field_type)) {
+ return !empty($options[$field_type]) ? $options[$field_type] : array();
+ }
+ if ($by_label) {
+ $field_types = field_info_field_types();
+ $options_by_label = array();
+ foreach ($options as $field_type => $widgets) {
+ $options_by_label[$field_types[$field_type]['label']] = $widgets;
+ }
+ return $options_by_label;
+ }
+ return $options;
+}
+
+/**
+ * Return an array of formatter options for a field type.
+ *
+ * If no field type is provided, returns a nested array of all formatters, keyed
+ * by field type.
+ */
+function field_ui_formatter_options($field_type = NULL) {
+ $options = &drupal_static(__FUNCTION__);
+
+ if (!isset($options)) {
+ $field_types = field_info_field_types();
+ $options = array();
+ foreach (field_info_formatter_types() as $name => $formatter) {
+ foreach ($formatter['field types'] as $formatter_field_type) {
+ // Check that the field type exists.
+ if (isset($field_types[$formatter_field_type])) {
+ $options[$formatter_field_type][$name] = $formatter['label'];
+ }
+ }
+ }
+ }
+
+ if ($field_type) {
+ return !empty($options[$field_type]) ? $options[$field_type] : array();
+ }
+ return $options;
+}
+
+/**
+ * Return an array of existing field to be added to a bundle.
+ */
+function field_ui_existing_field_options($bundle) {
+ $options = array();
+ $field_types = field_info_field_types();
+ foreach (field_info_instances() as $bundle_name => $instances) {
+ // No need to look in the current bundle.
+ if ($bundle_name != $bundle) {
+ foreach ($instances as $instance) {
+ $field = field_info_field($instance['field_name']);
+ // Don't show locked fields or fields already in the current bundle.
+ if (empty($field['locked']) && !field_info_instance($field['field_name'], $bundle)) {
+ $text = t('@type: @field (@label)', array(
+ '@type' => $field_types[$field['type']]['label'],
+ '@label' => t($instance['label']), '@field' => $instance['field_name'],
+ ));
+ $options[$instance['field_name']] = (drupal_strlen($text) > 80 ? truncate_utf8($text, 77) . '...' : $text);
+ }
+ }
+ }
+ }
+ // Sort the list by field name.
+ asort($options);
+ return $options;
+}
+
+/**
+ * Helper function to determine if a field has data in the database.
+ */
+function field_ui_field_has_data($field) {
+ $results = field_attach_query($field['id'], array(), 1);
+ return !empty($results);
+}
+
+/**
+ * Menu callback; presents the field settings edit page.
+ */
+function field_ui_field_settings_form(&$form_state, $obj_type, $bundle, $instance) {
+ $bundle = field_attach_extract_bundle($obj_type, $bundle);
+ $field = field_info_field($instance['field_name']);
+
+ // When a field is first created, we have to get data from the db.
+ if (!isset($instance['label'])) {
+ $instance = field_read_instance($field['field_name'], $bundle);
+ $field = field_read_field($field['field_name']);
+ }
+
+ $field_type = field_info_field_types($field['type']);
+
+ $info_function = $field['module'] . '_field_info';
+ $info = $info_function();
+ $description = '<p><strong>' . $info[$field['type']]['label'] . ':</strong> ';
+ $description .= $info[$field['type']]['description'] . '</p>';
+ $form['#prefix'] = '<div class="description">' . $description . '</div>';
+
+ $description = '<p>' . t('These settings apply to the %field field everywhere it is used. These settings impact the way that data is stored in the database and cannot be changed once data has been created.', array('%field' => $instance['label'])) . '</p>';
+
+ // Create a form structure for the field values.
+ $form['field'] = array(
+ '#type' => 'fieldset',
+ '#title' => t('%field field settings', array('%field' => $instance['label'])),
+ '#description' => $description,
+ '#tree' => TRUE,
+ );
+
+ // See if data already exists for this field.
+ // If so, prevent changes to the field settings.
+ $has_data = field_ui_field_has_data($field);
+ if ($has_data) {
+ $form['field']['#description'] = '<div class=error>' . t('There is data for this field in the database. The field settings can no longer be changed.' . '</div>') . $form['field']['#description'];
+ }
+
+ // Build the non-configurable field values.
+ $form['field']['field_name'] = array('#type' => 'value', '#value' => $field['field_name']);
+ $form['field']['type'] = array('#type' => 'value', '#value' => $field['type']);
+ $form['field']['module'] = array('#type' => 'value', '#value' => $field['module']);
+ $form['field']['active'] = array('#type' => 'value', '#value' => $field['active']);
+
+ // Add settings provided by the field module.
+ $form['field']['settings'] = array();
+ $additions = module_invoke($field_type['module'], 'field_settings_form', $field, $instance);
+ if (is_array($additions)) {
+ $form['field']['settings'] = $additions;
+ // @todo Filter this so only the settings that cannot be changed are shown
+ // in this form. For now, treating all settings as changeable, which means
+ // they show up here and in edit form.
+ }
+ if (empty($form['field']['settings'])) {
+ $form['field']['settings'] = array(
+ '#markup' => t('%field has no field settings.', array('%field' => $instance['label'])),
+ );
+ }
+ else {
+ foreach ($form['field']['settings'] as $key => $setting) {
+ if (substr($key, 0, 1) != '#') {
+ $form['field']['settings'][$key]['#disabled'] = $has_data;
+ }
+ }
+ }
+ $form['#bundle'] = $bundle;
+
+ $form['submit'] = array('#type' => 'submit', '#value' => t('Save field settings'));
+ return $form;
+}
+
+/**
+ * Save a field's settings after editing.
+ */
+function field_ui_field_settings_form_submit($form, &$form_state) {
+ $form_values = $form_state['values'];
+ $field_values = $form_values['field'];
+
+ // Merge incoming form values into the existing field.
+ $field = field_info_field($field_values['field_name']);
+
+ // Do not allow changes to fields with data.
+ if (field_ui_field_has_data($field)) {
+ return;
+ }
+
+ // Remove the 'bundles' element added by field_info_field.
+ // @todo This is ugly, there must be a better way.
+ unset($field['bundles']);
+ $bundle = $form['#bundle'];
+ $instance = field_info_instance($field['field_name'], $bundle);
+
+ // Update the field.
+ $field = array_merge($field, $field_values);
+ field_ui_update_field($field);
+
+ drupal_set_message(t('Updated field %label field settings.', array('%label' => $instance['label'])));
+ $form_state['redirect'] = field_ui_next_destination($bundle);
+}
+
+/**
+ * Menu callback; select a widget for the field.
+ */
+function field_ui_widget_type_form(&$form_state, $obj_type, $bundle, $instance) {
+ $bundle = field_attach_extract_bundle($obj_type, $bundle);
+ $field = field_read_field($instance['field_name']);
+
+ $field_type = field_info_field_types($field['type']);
+ $widget_type = field_info_widget_types($instance['widget']['type']);
+ $bundles = field_info_bundles();
+ $bundle_label = $bundles[$bundle]['label'];
+
+ $form['basic'] = array(
+ '#type' => 'fieldset',
+ '#title' => t('Change widget'),
+ );
+ $form['basic']['widget_type'] = array(
+ '#type' => 'select',
+ '#title' => t('Widget type'),
+ '#required' => TRUE,
+ '#options' => field_ui_widget_type_options($field['type']),
+ '#default_value' => $instance['widget']['type'],
+ '#description' => t('The type of form element you would like to present to the user when creating this field in the %type type.', array('%type' => $bundle_label)),
+ );
+
+ $form['#instance'] = $instance;
+ $form['submit'] = array('#type' => 'submit', '#value' => t('Continue'));
+
+ $form['#validate'] = array();
+ $form['#submit'] = array('field_ui_widget_type_form_submit');
+
+ return $form;
+}
+
+/**
+ * Submit the change in widget type.
+ */
+function field_ui_widget_type_form_submit($form, &$form_state) {
+ $form_values = $form_state['values'];
+ $instance = $form['#instance'];
+ $bundle = $instance['bundle'];
+
+ // Set the right module information.
+ $widget_type = field_info_widget_types($form_values['widget_type']);
+ $widget_module = $widget_type['module'];
+
+ $instance['widget']['type'] = $form_values['widget_type'];
+ $instance['widget']['module'] = $widget_module;
+ try {
+ field_update_instance($instance);
+ drupal_set_message(t('Changed the widget for field %label.', array('%label' => $instance['label'])));
+ }
+ catch (FieldException $e) {
+ drupal_set_message(t('There was a problem changing the widget for field %label.', array('%label' => $instance['label'])));
+ }
+
+ $form_state['redirect'] = field_ui_next_destination($bundle);
+}
+
+/**
+ * Menu callback; present a form for removing a field from a content type.
+ */
+function field_ui_field_delete_form(&$form_state, $obj_type, $bundle, $instance) {
+ $bundle = field_attach_extract_bundle($obj_type, $bundle);
+ $field = field_info_field($instance['field_name']);
+ $admin_path = _field_ui_bundle_admin_path($bundle);
+
+ $form['bundle'] = array('#type' => 'value', '#value' => $bundle);
+ $form['field_name'] = array('#type' => 'value', '#value' => $field['field_name']);
+
+ $output = confirm_form($form,
+ t('Are you sure you want to delete the field %field?', array('%field' => $instance['label'])),
+ $admin_path . '/fields',
+ t('If you have any content left in this field, it will be lost. This action cannot be undone.'),
+ t('Delete'), t('Cancel'),
+ 'confirm'
+ );
+
+ if ($field['locked']) {
+ unset($output['actions']['submit']);
+ $output['description']['#markup'] = t('This field is <strong>locked</strong> and cannot be deleted.');
+ }
+
+ return $output;
+}
+
+/**
+ * Remove a field from a content type.
+ */
+function field_ui_field_delete_form_submit($form, &$form_state) {
+ $form_values = $form_state['values'];
+ $field = field_info_field($form_values['field_name']);
+ $instance = field_info_instance($form_values['field_name'], $form_values['bundle']);
+ $bundles = field_info_bundles();
+ $bundle = $form_values['bundle'];
+ $bundle_label = $bundles[$bundle]['label'];
+
+ if (!empty($bundle) && $field && !$field['locked'] && $form_values['confirm']) {
+ field_delete_instance($field['field_name'], $bundle);
+ // Delete the field if that was the last instance.
+ if (count($field['bundles'] == 1)) {
+ field_delete_field($field['field_name']);
+ }
+ drupal_set_message(t('The field %field has been deleted from the %type content type.', array('%field' => $instance['label'], '%type' => $bundle_label)));
+ }
+ else {
+ drupal_set_message(t('There was a problem removing the %field from the %type content type.', array('%field' => $instance['label'], '%type' => $bundle_label)));
+ }
+
+ $admin_path = _field_ui_bundle_admin_path($bundle);
+ $destinations = array(
+ $admin_path . '/fields/refresh',
+ $admin_path . '/fields',
+ );
+ $form_state['redirect'] = field_ui_get_destinations($destinations);
+}
+
+/**
+ * Menu callback; presents the field instance edit page.
+ */
+function field_ui_field_edit_form(&$form_state, $obj_type, $bundle, $instance) {
+ $bundle = field_attach_extract_bundle($obj_type, $bundle);
+
+ $field = field_info_field($instance['field_name']);
+ $form['#field'] = $field;
+
+ if (!empty($field['locked'])) {
+ $form['locked'] = array(
+ '#markup' => t('The field %field is locked and cannot be edited.', array('%field' => $instance['label'])),
+ );
+ return $form;
+ }
+
+ $field_type = field_info_field_types($field['type']);
+ $widget_type = field_info_widget_types($instance['widget']['type']);
+ $bundles = field_info_bundles();
+
+ $title = isset($instance['label']) ? $instance['label'] : $instance['field_name'];
+ drupal_set_title(check_plain($title));
+
+ // Create a form structure for the instance values.
+ $form['instance'] = array(
+ '#tree' => TRUE,
+ '#type' => 'fieldset',
+ '#title' => t('%type settings', array('%type' => $bundles[$bundle]['label'])),
+ '#description' => t('These settings apply only to the %field field when used in the %type type.', array('%field' => $instance['label'], '%type' => $bundles[$bundle]['label'])),
+ '#pre_render' => array('field_ui_field_edit_instance_pre_render'),
+ );
+
+ // Build the non-configurable instance values.
+ $form['instance']['field_name'] = array(
+ '#type' => 'value',
+ '#value' => $instance['field_name'],
+ );
+ $form['instance']['bundle'] = array(
+ '#type' => 'value',
+ '#value' => $bundle,
+ );
+ $form['instance']['widget']['weight'] = array(
+ '#type' => 'value',
+ '#value' => !empty($instance['widget']['weight']) ? $instance['widget']['weight'] : 0,
+ );
+
+ // Build the configurable instance values.
+ $form['instance']['label'] = array(
+ '#type' => 'textfield',
+ '#title' => t('Label'),
+ '#default_value' => !empty($instance['label']) ? $instance['label'] : $field['field_name'],
+ '#required' => TRUE,
+ '#description' => t('The human-readable label for this field.'),
+ '#weight' => -20,
+ );
+ $form['instance']['required'] = array(
+ '#type' => 'checkbox',
+ '#title' => t('Required'),
+ '#default_value' => !empty($instance['required']),
+ '#description' => t('Check if a value must be provided.'),
+ '#weight' => -10,
+ );
+
+ $form['instance']['description'] = array(
+ '#type' => 'textarea',
+ '#title' => t('Help text'),
+ '#default_value' => !empty($instance['description']) ? $instance['description'] : '',
+ '#rows' => 5,
+ '#description' => t('Instructions to present to the user below this field on the editing form.<br />Allowed HTML tags: @tags', array('@tags' => _field_filter_xss_display_allowed_tags())),
+ '#required' => FALSE,
+ '#weight' => 0,
+ );
+
+ // Build the widget component of the instance.
+ $form['instance']['widget']['type'] = array(
+ '#type' => 'value',
+ '#value' => $instance['widget']['type'],
+ );
+ $form['instance']['widget']['module'] = array(
+ '#type' => 'value',
+ '#value' => $widget_type['module'],
+ );
+ $form['instance']['widget']['active'] = array(
+ '#type' => 'value',
+ '#value' => !empty($field['instance']['widget']['active']) ? 1 : 0,
+ );
+
+ // Add additional field instance settings from the field module.
+ $additions = module_invoke($field['module'], 'field_instance_settings_form', $field, $instance);
+ if (is_array($additions)) {
+ $form['instance']['settings'] = $additions;
+ }
+
+ // Add additional widget settings from the widget module.
+ $additions = module_invoke($widget_type['module'], 'field_widget_settings_form', $field, $instance);
+ if (is_array($additions)) {
+ $form['instance']['widget']['settings'] = $additions;
+ $form['instance']['widget']['active']['#value'] = 1;
+ }
+
+ // Add handling for default value if not provided by any other module.
+ if (field_behaviors_widget('default value', $instance) == FIELD_BEHAVIOR_DEFAULT && empty($instance['default_value_function'])) {
+ // Store the original default value for use in programmed forms. The
+ // '#default_value' property is used instead of '#value' so programmed
+ // values can override whatever we set here.
+ $form['instance']['default_value'] = array(
+ '#type' => 'value',
+ '#default_value' => $instance['default_value'],
+ );
+
+ // We cannot tell at the time we build the form if this is a programmed form
+ // or not, so we always end up adding the default value widget even if we
+ // will not use it.
+ field_ui_default_value_widget($field, $instance, $form, $form_state);
+ }
+
+ $info = field_info_field_types($field['type']);
+ $description = '<p><strong>' . $info['label'] . ':</strong> ';
+ $description .= $info['description'] . '</p>';
+ $form['#prefix'] = '<div class="description">' . $description . '</div>';
+
+ $description = '<p>' . t('These settings apply to the %field field everywhere it is used.', array('%field' => $instance['label'])) . '</p>';
+
+ // Create a form structure for the field values.
+ $form['field'] = array(
+ '#type' => 'fieldset',
+ '#title' => t('%field field settings', array('%field' => $instance['label'])),
+ '#description' => $description,
+ '#tree' => TRUE,
+ );
+
+ // Build the configurable field values.
+ $description = t('Maximum number of values users can enter for this field.');
+ if (field_behaviors_widget('multiple values', $instance) == FIELD_BEHAVIOR_DEFAULT) {
+ $description .= '<br/>' . t("'Unlimited' will provide an 'Add more' button so the users can add as many values as they like.");
+ }
+ $form['field']['cardinality'] = array(
+ '#type' => 'select',
+ '#title' => t('Number of values'),
+ '#options' => array(FIELD_CARDINALITY_UNLIMITED => t('Unlimited')) + drupal_map_assoc(range(1, 10)),
+ '#default_value' => $field['cardinality'],
+ '#description' => $description,
+ );
+
+ // Add additional field settings from the field module.
+ $additions = module_invoke($field['module'], 'field_settings_form', $field, $instance);
+ if (is_array($additions)) {
+ // @todo Filter additional settings by whether they can be changed.
+ $form['field']['settings'] = $additions;
+ }
+
+ $form['submit'] = array('#type' => 'submit', '#value' => t('Save settings'));
+ return $form;
+}
+
+/**
+ * Pre-render function for field instance settings.
+ *
+ * Combines the instance, widget, and other settings into a single fieldset so
+ * that elements within each group can be shown at different weights as if they
+ * all had the same parent.
+ */
+function field_ui_field_edit_instance_pre_render($element) {
+ // Merge the widget settings into the main form.
+ if (isset($element['widget']['settings'])) {
+ foreach (element_children($element['widget']['settings']) as $key) {
+ $element['widget_' . $key] = $element['widget']['settings'][$key];
+ }
+ unset($element['widget']['settings']);
+ }
+
+ // Merge the instance settings into the main form.
+ if (isset($element['settings'])) {
+ foreach (element_children($element['settings']) as $key) {
+ $element['instance_' . $key] = $element['settings'][$key];
+ }
+ unset($element['settings']);
+ }
+
+ return $element;
+}
+
+/**
+ * Build default value fieldset.
+ */
+function field_ui_default_value_widget($field, $instance, &$form, &$form_state) {
+ $form['instance']['default_value_widget'] = array(
+ '#type' => 'fieldset',
+ '#title' => t('Default value'),
+ '#collapsible' => FALSE,
+ '#tree' => TRUE,
+ '#description' => t('The default value for this field, used when creating new content.'),
+ );
+
+ // Make sure the default value is not a required field.
+ $instance['required'] = FALSE;
+ $instance['description'] = '';
+ $items = $instance['default_value'];
+ // Set up form info that the default value widget will need.
+ $form['#fields'] = array(
+ $field['field_name'] => array(
+ 'field' => $field,
+ 'instance' => $instance,
+ ),
+ );
+ drupal_function_exists('field_default_form');
+ // @todo Allow multiple values (requires more work on 'add more' JS handler).
+ $widget_form = field_default_form(NULL, NULL, $field, $instance, $items, $form, $form_state, 0);
+ $form['instance']['default_value_widget'] += $widget_form;
+ $form['#fields'][$field['field_name']]['form_path'] = array(
+ 'instance',
+ 'default_value_widget',
+ $field['field_name'],
+ );
+}
+
+/**
+ * Validate a field's settings.
+ */
+function field_ui_field_edit_form_validate($form, &$form_state) {
+ $form_values = $form_state['values'];
+ $instance = $form_values['instance'];
+ $field = field_info_field($instance['field_name']);
+ $field_type = field_info_field_types($field['type']);
+ $widget_type = field_info_widget_types($instance['widget']['type']);
+
+ // Do no validation here. Assume field and widget modules are handling their
+ // own validation of form settings.
+
+ // If field.module is handling the default value, validate the result using
+ // the field validation.
+ if (field_behaviors_widget('default value', $instance) == FIELD_BEHAVIOR_DEFAULT) {
+ // If this is a programmed form, get rid of the default value widget, we
+ // have the default values already.
+ if (!empty($form_state['programmed'])) {
+ form_set_value(array('#parents' => array('instance', 'widget', 'default_value_widget')), NULL, $form_state);
+ return;
+ }
+
+ if (!empty($form_values['instance']['widget']['default_value_widget'])) {
+ // Fields that handle their own multiple values may use an expected value
+ // as the top-level key, so just pop off the top element.
+ $key = array_shift(array_keys($form_values['instance']['widget']['default_value_widget']));
+ $default_value = $form_values['instance']['widget']['default_value_widget'][$key];
+ $is_code = FALSE;
+ form_set_value(array('#parents' => array('instance', 'widget', 'default_value')), $default_value, $form_state);
+ }
+
+ if (isset($default_value)) {
+ $node = array();
+ $node[$field['field_name']] = $default_value;
+ $field['required'] = FALSE;
+ $field_function = $field_type['module'] . '_field';
+ $errors_before = form_get_errors();
+
+ // Widget now does its own validation, should be no need to add anything
+ // for widget validation here.
+ if (drupal_function_exists($field_function)) {
+ $field_function('validate', $node, $field, $default_value, $form, NULL);
+ }
+ // The field validation routine won't set an error on the right field, so
+ // set it here.
+ $errors_after = form_get_errors();
+ if (count($errors_after) > count($errors_before)) {
+ form_set_error('default_value', t('The default value is invalid.'));
+ }
+ }
+ }
+}
+
+/**
+ * Save instance settings after editing.
+ */
+function field_ui_field_edit_form_submit($form, &$form_state) {
+ $form_values = $form_state['values'];
+ $instance = $form_values['instance'];
+
+ // Update any field settings that have changed.
+ $field = field_info_field($instance['field_name']);
+ // Remove the 'bundles' element added by field_info_field.
+ // @todo This is ugly, there must be a better way.
+ unset($field['bundles']);
+ $field = array_merge($field, $form_state['values']['field']);
+ field_ui_update_field($field);
+
+ // Move the default value from the sample widget to the default value field.
+ if (isset($instance['default_value_widget'])) {
+ $instance['default_value'] = $instance['default_value_widget'][$instance['field_name']];
+ unset($instance['default_value_widget']);
+ }
+
+ // Update the instance settings.
+ module_load_include('inc', 'field', 'includes/field.crud');
+ field_update_instance($instance);
+
+ drupal_set_message(t('Saved %label configuration.', array('%label' => $instance['label'])));
+
+ $form_state['redirect'] = field_ui_next_destination($instance['bundle']);
+}
+
+/**
+ * Helper functions to handle multipage redirects.
+ */
+function field_ui_get_destinations($destinations) {
+ $query = array();
+ $path = array_shift($destinations);
+ if ($destinations) {
+ $query['destinations'] = $destinations;
+ }
+ return array($path, $query);
+}
+
+/**
+ * Return the next redirect path in a multipage sequence.
+ */
+function field_ui_next_destination($bundle) {
+ $destinations = !empty($_REQUEST['destinations']) ? $_REQUEST['destinations'] : array();
+ if (!empty($destinations)) {
+ unset($_REQUEST['destinations']);
+ return field_ui_get_destinations($destinations);
+ }
+ $admin_path = _field_ui_bundle_admin_path($bundle);
+ return $admin_path . '/fields';
+}
+
+/**
+ * Menu callback; rebuild the menu after adding new fields.
+ *
+ * Dummy function to force a page refresh so menu_rebuild() will work right
+ * when creating a new field that creates a new menu item.
+ */
+function field_ui_field_menu_refresh($obj_type, $bundle) {
+ $bundle = field_attach_extract_bundle($obj_type, $bundle);
+
+ menu_rebuild();
+ $destinations = field_ui_next_destination($bundle);
+ if (is_array($destinations)) {
+ $path = array_shift($destinations);
+ drupal_goto($path, $destinations);
+ }
+ drupal_goto($destinations);
+}
+
+/**
+ * Helper function to order fields when theming overview forms.
+ */
+function _field_ui_overview_order(&$form, $field_rows) {
+ // Put weight and parenting values into a $dummy render structure and let
+ // drupal_render() figure out the corresponding row order.
+ $dummy = array();
+ // Field rows: account for weight.
+ foreach ($field_rows as $name) {
+ $dummy[$name] = array(
+ '#markup' => $name . ' ',
+ '#type' => 'markup',
+ '#weight' => $form[$name]['weight']['#value'],
+ );
+ }
+ return $dummy ? explode(' ', trim(drupal_render($dummy))) : array();
+}
+
+/**
+ * Helper form element validator: integer.
+ */
+function _element_validate_integer($element, &$form_state) {
+ $value = $element['#value'];
+ if ($value !== '' && (!is_numeric($value) || intval($value) != $value)) {
+ form_error($element, t('%name must be an integer.', array('%name' => $element['#title'])));
+ }
+}
+
+/**
+ * Helper form element validator: integer > 0.
+ */
+function _element_validate_integer_positive($element, &$form_state) {
+ $value = $element['#value'];
+ if ($value !== '' && (!is_numeric($value) || intval($value) != $value || $value <= 0)) {
+ form_error($element, t('%name must be a positive integer.', array('%name' => $element['#title'])));
+ }
+}
+
+/**
+ * Helper form element validator: number.
+ */
+function _element_validate_number($element, &$form_state) {
+ $value = $element['#value'];
+ if ($value != '' && !is_numeric($value)) {
+ form_error($element, t('%name must be a number.', array('%name' => $element['#title'])));
+ }
+}
diff --git a/modules/field_ui/field_ui.api.php b/modules/field_ui/field_ui.api.php
new file mode 100644
index 0000000000000000000000000000000000000000..4c53faa396257019e0d1aa7ba46b89386b9818da
--- /dev/null
+++ b/modules/field_ui/field_ui.api.php
@@ -0,0 +1,135 @@
+<?php
+// $Id$
+
+/**
+ * @file
+ * Hooks provided by the Field UI module.
+ */
+
+/**
+ * @ingroup field_ui_field_type
+ * @{
+ */
+
+/**
+ * Field settings form.
+ *
+ * @param $field
+ * The field structure being configured.
+ * @param $instance
+ * The instance structure being configured.
+ * @return
+ * The form definition for the field settings.
+ */
+function hook_field_settings_form($field, $instance) {
+ $settings = $field['settings'];
+ $form['max_length'] = array(
+ '#type' => 'textfield',
+ '#title' => t('Maximum length'),
+ '#default_value' => $settings['max_length'],
+ '#required' => FALSE,
+ '#element_validate' => array('_element_validate_integer_positive'),
+ '#description' => t('The maximum length of the field in characters. Leave blank for an unlimited size.'),
+ );
+ return $form;
+}
+
+/**
+ * Instance settings form.
+ *
+ * @param $field
+ * The field structure being configured.
+ * @param $instance
+ * The instance structure being configured.
+ * @return
+ * The form definition for the field instance settings.
+ */
+function hook_field_instance_settings_form($field, $instance) {
+ $settings = $instance['settings'];
+
+ $form['text_processing'] = array(
+ '#type' => 'radios',
+ '#title' => t('Text processing'),
+ '#default_value' => $settings['text_processing'],
+ '#options' => array(
+ t('Plain text'),
+ t('Filtered text (user selects input format)'),
+ ),
+ );
+ if ($field['type'] == 'text_with_summary') {
+ $form['display_summary'] = array(
+ '#type' => 'select',
+ '#title' => t('Display summary'),
+ '#options' => array(
+ t('No'),
+ t('Yes'),
+ ),
+ '#description' => t('Display the summary to allow the user to input a summary value. Hide the summary to automatically fill it with a trimmed portion from the main post. '),
+ '#default_value' => !empty($settings['display_summary']) ? $settings['display_summary'] : 0,
+ );
+ }
+
+ return $form;
+}
+
+/**
+ * Widget settings form.
+ *
+ * @param $field
+ * The field structure being configured.
+ * @param $instance
+ * The instance structure being configured.
+ * @return
+ * The form definition for the widget settings.
+ */
+function hook_field_widget_settings_form($field, $instance) {
+ $widget = $instance['widget'];
+ $settings = $widget['settings'];
+ $form = array();
+
+ if ($widget['type'] == 'text_textfield') {
+ $form['size'] = array(
+ '#type' => 'textfield',
+ '#title' => t('Size of textfield'),
+ '#default_value' => $settings['size'],
+ '#element_validate' => array('_element_validate_integer_positive'),
+ '#required' => TRUE,
+ );
+ }
+ else {
+ $form['rows'] = array(
+ '#type' => 'textfield',
+ '#title' => t('Rows'),
+ '#default_value' => $settings['rows'],
+ '#element_validate' => array('_element_validate_integer_positive'),
+ '#required' => TRUE,
+ );
+ }
+
+ return $form;
+}
+
+/**
+ * Formatter settings form.
+ *
+ * @todo Not implemented yet. The signature below is only prospective, but
+ * providing $instance is not enough, since one $instance holds several display
+ * settings.
+ *
+ * @param $formatter
+ * The type of the formatter being configured.
+ * @param $settings
+ * The current values of the formatter settings.
+ * @param $field
+ * The field structure being configured.
+ * @param $instance
+ * The instance structure being configured.
+ * @return
+ * The form definition for the formatter settings.
+ */
+function hook_field_formatter_settings_form($formatter, $settings, $field, $instance) {
+}
+
+/**
+ * @} End of "ingroup field_ui_field_type"
+ */
diff --git a/modules/field_ui/field_ui.css b/modules/field_ui/field_ui.css
new file mode 100644
index 0000000000000000000000000000000000000000..2cc52736bd6a768dd4fb38ba2307a720ba3281d5
--- /dev/null
+++ b/modules/field_ui/field_ui.css
@@ -0,0 +1,18 @@
+/* $Id$ */
+
+/* 'Manage fields' overview */
+#field-overview .label-add-new-field,
+#field-overview .label-add-existing-field {
+ float: left; /* LTR */
+}
+#field-overview tr.add-new .tabledrag-changed {
+ display: none;
+}
+#field-overview tr.add-new .description {
+ margin-bottom: 0;
+}
+#field-overview .new {
+ font-weight: bold;
+ padding-bottom: .5em;
+}
+
diff --git a/modules/field_ui/field_ui.info b/modules/field_ui/field_ui.info
new file mode 100644
index 0000000000000000000000000000000000000000..e2ca87c16ed2a8a067a5041d336226e60009ecbc
--- /dev/null
+++ b/modules/field_ui/field_ui.info
@@ -0,0 +1,8 @@
+; $Id$
+name = Field UI
+description = User Interface for the Field API.
+package = Core
+version = VERSION
+core = 7.x
+files[] = field_ui.module
+files[] = field_ui.admin.inc
diff --git a/modules/field_ui/field_ui.js b/modules/field_ui/field_ui.js
new file mode 100644
index 0000000000000000000000000000000000000000..aea5cfb5f5f8dc18ac1a4468ac761b2faf955f0f
--- /dev/null
+++ b/modules/field_ui/field_ui.js
@@ -0,0 +1,84 @@
+// $Id$
+
+(function($) {
+
+Drupal.behaviors.fieldManageFields = {
+ attach: function (context) {
+ attachUpdateSelects(context);
+ }
+};
+
+function attachUpdateSelects(context) {
+ var widgetTypes = Drupal.settings.fieldWidgetTypes;
+ var fields = Drupal.settings.fields;
+
+ // Store the default text of widget selects.
+ $('#field-overview .widget-type-select', context).each(function () {
+ this.initialValue = this.options[0].text;
+ });
+
+ // 'Field type' select updates its 'Widget' select.
+ $('#field-overview .field-type-select', context).each(function () {
+ this.targetSelect = $('.widget-type-select', $(this).parents('tr').eq(0));
+
+ $(this).bind('mouseup keyup', function () {
+ var selectedFieldType = this.options[this.selectedIndex].value;
+ var options = (selectedFieldType in widgetTypes ? widgetTypes[selectedFieldType] : []);
+ this.targetSelect.fieldPopulateOptions(options);
+ });
+
+ // Trigger change on initial pageload to get the right widget options
+ // when field type comes pre-selected (on failed validation).
+ $(this).trigger('mouseup');
+ });
+
+ // 'Existing field' select updates its 'Widget' select and 'Label' textfield.
+ $('#field-overview .field-select', context).each(function () {
+ this.targetSelect = $('.widget-type-select', $(this).parents('tr').eq(0));
+ this.targetTextfield = $('.label-textfield', $(this).parents('tr').eq(0));
+
+ $(this).change(function (e, updateText) {
+ var updateText = (typeof updateText == 'undefined' ? true : updateText);
+ var selectedField = this.options[this.selectedIndex].value;
+ var selectedFieldType = (selectedField in fields ? fields[selectedField].type : null);
+ var selectedFieldWidget = (selectedField in fields ? fields[selectedField].widget : null);
+ var options = (selectedFieldType && (selectedFieldType in widgetTypes) ? widgetTypes[selectedFieldType] : []);
+ this.targetSelect.fieldPopulateOptions(options, selectedFieldWidget);
+
+ if (updateText) {
+ $(this.targetTextfield).attr('value', (selectedField in fields ? fields[selectedField].label : ''));
+ }
+ });
+
+ // Trigger change on initial pageload to get the right widget options
+ // and label when field type comes pre-selected (on failed validation).
+ $(this).trigger('change', false);
+ });
+}
+
+jQuery.fn.fieldPopulateOptions = function (options, selected) {
+ return this.each(function () {
+ var disabled = false;
+ if (options.length == 0) {
+ options = [this.initialValue];
+ disabled = true;
+ }
+
+ // If possible, keep the same widget selected when changing field type.
+ // This is based on textual value, since the internal value might be
+ // different (options_buttons vs. node_reference_buttons).
+ var previousSelectedText = this.options[this.selectedIndex].text;
+
+ var html = '';
+ jQuery.each(options, function (value, text) {
+ // Figure out which value should be selected. The 'selected' param
+ // takes precedence.
+ var is_selected = ((typeof selected != 'undefined' && value == selected) || (typeof selected == 'undefined' && text == previousSelectedText));
+ html += '<option value="' + value + '"' + (is_selected ? ' selected="selected"' : '') + '>' + text + '</option>';
+ });
+
+ $(this).html(html).attr('disabled', disabled ? 'disabled' : '');
+ });
+};
+
+})(jQuery);
diff --git a/modules/field_ui/field_ui.module b/modules/field_ui/field_ui.module
new file mode 100644
index 0000000000000000000000000000000000000000..ce856dd97a109258612553eee22955493896befd
--- /dev/null
+++ b/modules/field_ui/field_ui.module
@@ -0,0 +1,327 @@
+<?php
+// $Id$
+
+/**
+ * @file
+ * Allows administrators to associate custom fields to fieldable types.
+ */
+
+/**
+ * Implement hook_help().
+ */
+function field_ui_help($path, $arg) {
+ switch ($path) {
+ case 'admin/help#field_ui':
+ $output = '';
+ $output .= '<p>' . t('The Field UI module provides an administrative interface for adding custom fields to content types, users, comments, and other types of data. In the case of content types, a few fields are provided by default, such as the "Summary and Body" field. The Field UI module lets administrators edit or delete the default fields attached to content, as well as create new fields for storing any additional information. Field configuration is accessible through tabs on the <a href="@content-types">content types administration page</a>. (See the <a href="@node-help">node module help page</a> for more information about content types.)', array('@content-types' => url('admin/content/types'), '@node-help' => url('admin/help/node'))) . '</p>';
+ $output .= '<p>' . t('When adding a custom field to a content type, you determine its type (whether it will contain text, numbers, lists, etc.) and how it will be displayed (either as a text field or text area, a select box, checkboxes, radio buttons, or an auto-complete text field). A field may have multiple values (i.e., a "person" may have multiple e-mail addresses) or a single value (i.e., an "employee" has a single employee identification number).') . '</p>';
+ $output .= '<p>' . t('Custom field types may be provided by additional modules. Drupal core includes the following field types:') . '</p>';
+ $output .= '<ul>';
+ $output .= '<li>' . t('<em>Number</em>: Adds numeric field types, in integer, decimal or floating point form. You may define a set of allowed inputs, or specify an allowable range of values. A variety of common formats for displaying numeric data are available.') . '</li>';
+ $output .= '<li>' . t("<em>Text</em>: Adds text field types. A text field may contain plain text only, or optionally, may use Drupal's input format filters to securely manage HTML output. Text input fields may be either a single line (text field), multiple lines (text area), or for greater input control, a select box, checkbox, or radio buttons. If desired, CCK can validate the input to a set of allowed values.") . '</li>';
+ $output .= '<li>' . t('<em>List</em>: Provides storage mechanisms to store a list of items. Usually these items are input through a select list, checkboxes, or radio buttons.') . '</li>';
+ $output .= '</ul>';
+ return $output;
+
+ case 'admin/reports/fields':
+ return '<p>' . t('This list shows all fields currently in use for easy reference.') . '</p>';
+ }
+}
+
+/**
+ * Implement hook_menu().
+ */
+function field_ui_menu() {
+ $items['admin/reports/fields'] = array(
+ 'title' => 'Field list',
+ 'description' => 'Overview of fields on all object types.',
+ 'page callback' => 'field_ui_fields_list',
+ 'access arguments' => array('administer content types'),
+ 'type' => MENU_NORMAL_ITEM,
+ );
+
+ // Ensure the following is not executed until field_bundles is working and
+ // tables are updated. Needed to avoid errors on initial installation.
+ if (defined('MAINTENANCE_MODE')) {
+ return $items;
+ }
+ // Create tabs for all possible bundles.
+ foreach (field_info_fieldable_types() as $obj_type => $info) {
+ foreach ($info['bundles'] as $bundle_name => $bundle_info) {
+ if (isset($bundle_info['admin'])) {
+ // Extract informations from the bundle description.
+ $path = $bundle_info['admin']['path'];
+ $bundle_arg = isset($bundle_info['admin']['bundle argument']) ? $bundle_info['admin']['bundle argument'] : $bundle_name;
+ $access = array_intersect_key($bundle_info['admin'], drupal_map_assoc(array('access callback', 'access arguments')));
+
+ $items["$path/fields"] = array(
+ 'title' => 'Manage fields',
+ 'page callback' => 'drupal_get_form',
+ 'page arguments' => array('field_ui_field_overview_form', $obj_type, $bundle_arg),
+ 'type' => MENU_LOCAL_TASK,
+ 'weight' => 1,
+ ) + $access;
+ // A dummy function to trigger a page refresh so that field menus get
+ // rebuilt correctly when new fields are added.
+ $items["$path/fields/refresh"] = array(
+ 'title' => 'Refresh menu',
+ 'page callback' => 'field_ui_field_menu_refresh',
+ 'page arguments' => array($obj_type, $bundle_arg),
+ 'type' => MENU_CALLBACK,
+ 'weight' => 1,
+ ) + $access;
+ $items["$path/display"] = array(
+ 'title' => 'Display fields',
+ 'page callback' => 'drupal_get_form',
+ 'page arguments' => array('field_ui_display_overview_form', $obj_type, $bundle_arg),
+ 'type' => MENU_LOCAL_TASK,
+ 'weight' => 2,
+ ) + $access;
+
+ // 'Display fields' tab and context secondary tabs.
+ $tabs = field_ui_build_modes_tabs($obj_type);
+ foreach ($tabs as $key => $tab) {
+ $items["$path/display/$key"] = array(
+ 'title' => $tab['title'],
+ 'page arguments' => array('field_ui_display_overview_form', $obj_type, $bundle_arg, $key),
+ 'type' => $key == 'basic' ? MENU_DEFAULT_LOCAL_TASK : MENU_LOCAL_TASK,
+ 'weight' => $key == 'basic' ? 0 : 1,
+ ) + $access;
+ }
+
+ $instance_position = count(explode('/', $path)) + 1;
+ $items["$path/fields/%field_ui_menu"] = array(
+ 'title callback' => 'field_ui_menu_label',
+ 'title arguments' => array($instance_position),
+ 'load arguments' => array($bundle_name),
+ 'page callback' => 'drupal_get_form',
+ 'page arguments' => array('field_ui_field_edit_form', $obj_type, $bundle_arg, $instance_position),
+ 'type' => MENU_LOCAL_TASK,
+ ) + $access;
+ $items["$path/fields/%field_ui_menu/edit"] = array(
+ 'title' => 'Edit instance settings',
+ 'load arguments' => array($bundle_name),
+ 'page callback' => 'drupal_get_form',
+ 'page arguments' => array('field_ui_field_edit_form', $obj_type, $bundle_arg, $instance_position),
+ 'type' => MENU_DEFAULT_LOCAL_TASK,
+ ) + $access;
+ $items["$path/fields/%field_ui_menu/field-settings"] = array(
+ 'title' => 'Edit field settings',
+ 'load arguments' => array($bundle_name),
+ 'page callback' => 'drupal_get_form',
+ 'page arguments' => array('field_ui_field_settings_form', $obj_type, $bundle_arg, $instance_position),
+ 'type' => MENU_LOCAL_TASK,
+ ) + $access;
+ $items["$path/fields/%field_ui_menu/widget-type"] = array(
+ 'title' => 'Change widget type',
+ 'load arguments' => array($bundle_name),
+ 'page callback' => 'drupal_get_form',
+ 'page arguments' => array('field_ui_widget_type_form', $obj_type, $bundle_arg, $instance_position),
+ 'type' => MENU_LOCAL_TASK,
+ ) + $access;
+ $items["$path/fields/%field_ui_menu/delete"] = array(
+ 'title' => 'Delete instance',
+ 'load arguments' => array($bundle_name),
+ 'page callback' => 'drupal_get_form',
+ 'page arguments' => array('field_ui_field_delete_form', $obj_type, $bundle_arg, $instance_position),
+ 'type' => MENU_LOCAL_TASK,
+ ) + $access;
+ }
+ }
+ }
+ return $items;
+}
+
+/**
+ * Menu loader; Load a field instance based on its name.
+ */
+function field_ui_menu_load($field_name, $bundle_name) {
+ if ($instance = field_info_instance($field_name, $bundle_name)) {
+ return $instance;
+ }
+ return FALSE;
+}
+
+/**
+ * Menu title callback; Return a field label based on its instance.
+ */
+function field_ui_menu_label($instance) {
+ return t($instance['label']);
+}
+
+/**
+ * Implement hook_theme().
+ */
+function field_ui_theme() {
+ return array(
+ 'field_ui_field_overview_form' => array(
+ 'arguments' => array('form' => NULL),
+ 'file' => 'field_ui.admin.inc',
+ 'template' => 'field_ui-field-overview-form',
+ ),
+ 'field_ui_display_overview_form' => array(
+ 'arguments' => array('form' => NULL),
+ 'file' => 'field_ui.admin.inc',
+ 'template' => 'field_ui-display-overview-form',
+ ),
+ );
+}
+
+/**
+ * Group available build modes on tabs on the 'Display fields' page.
+ *
+ * @todo Remove this completely and use vertical tabs?
+ */
+function field_ui_build_modes_tabs($obj_type, $tab_selector = NULL) {
+ $info = &drupal_static(__FUNCTION__);
+
+ if (!isset($info[$obj_type])) {
+ $info[$obj_type] = module_invoke_all('field_ui_build_modes_tabs');
+ // Collect titles, and filter out non active modes.
+ $active_modes = field_build_modes($obj_type);
+ foreach ($info[$obj_type] as $tab => $values) {
+ $modes = array();
+ foreach ($info[$obj_type][$tab]['build modes'] as $mode) {
+ if (isset($active_modes[$mode])) {
+ $modes[$mode] = $active_modes[$mode];
+ }
+ }
+ if ($modes) {
+ $info[$obj_type][$tab]['build modes'] = $modes;
+ }
+ else {
+ unset($info[$obj_type][$tab]);
+ }
+ }
+ }
+ if ($tab_selector) {
+ return isset($info[$obj_type][$tab_selector]) ? $info[$obj_type][$tab_selector]['build modes'] : array();
+ }
+ return $info[$obj_type];
+}
+
+/**
+ * Implement hook_field_ui_build_modes_tabs() on behalf of other core modules.
+ *
+ * @return
+ * An array describing the build modes defined by the module, grouped by tabs.
+ *
+ * A module can add its render modes to a tab defined by another module.
+ * Expected format:
+ * @code
+ * array(
+ * 'tab1' => array(
+ * 'title' => t('The human-readable title of the tab'),
+ * 'build modes' => array('mymodule_mode1', 'mymodule_mode2'),
+ * ),
+ * 'tab2' => array(
+ * // ...
+ * ),
+ * );
+ * @endcode
+ */
+function field_ui_field_ui_build_modes_tabs() {
+ $modes = array(
+ 'basic' => array(
+ 'title' => t('Basic'),
+ 'build modes' => array('teaser', 'full'),
+ ),
+ 'rss' => array(
+ 'title' => t('RSS'),
+ 'build modes' => array('rss'),
+ ),
+ 'print' => array(
+ 'title' => t('Print'),
+ 'build modes' => array('print'),
+ ),
+ 'search' => array(
+ 'title' => t('Search'),
+ 'build modes' => array('search_index', 'search_result'),
+ ),
+ );
+ return $modes;
+}
+
+/**
+ * Updates a field.
+ *
+ * Field API does not allow field updates, so we create a method here to
+ * update a field if no data is created yet.
+ *
+ * @see field_create_field()
+ */
+function field_ui_update_field($field) {
+ $field_types = field_info_field_types();
+ $module = $field_types[$field['type']]['module'];
+
+ $defaults = field_info_field_settings($field['type']);
+ $field['settings'] = array_merge($defaults, (array) $field['settings']);
+ $data = $field;
+ unset($data['id'], $data['columns'], $data['field_name'], $data['type'], $data['locked'], $data['module'], $data['cardinality'], $data['active'], $data['deleted']);
+ $field['data'] = $data;
+
+ drupal_write_record('field_config', $field, array('field_name'));
+
+ // Clear caches.
+ field_cache_clear(TRUE);
+}
+
+/**
+ * Implement hook_field_attach_create_bundle().
+ */
+function field_ui_field_attach_create_bundle($bundle) {
+ // When a new bundle is created, the menu needs to be rebuilt to add our
+ // menu item tabs.
+ menu_rebuild();
+}
+
+/**
+ * Implement hook_field_attach_rename_bundle().
+ */
+function field_ui_field_attach_rename_bundle($bundle_old, $bundle_new) {
+ if ($bundle_old !== $bundle_new && $extra = variable_get("field_extra_weights_$bundle_old", array())) {
+ variable_set("field_extra_weights_$bundle_new", $extra);
+ variable_del("field_extra_weights_$bundle_old");
+ }
+}
+
+/**
+ * Implement hook_field_attach_delete_bundle().
+ */
+function field_ui_field_attach_delete_bundle($bundle) {
+ variable_del('field_extra_weights_' . $bundle);
+}
+
+/**
+ * Helper function to create the right administration path for a bundle.
+ */
+function _field_ui_bundle_admin_path($bundle_name) {
+ $bundles = field_info_bundles();
+ $bundle_info = $bundles[$bundle_name];
+ return isset($bundle_info['admin']['real path']) ? $bundle_info['admin']['real path'] : $bundle_info['admin']['path'];
+}
+
+/**
+ * Helper function to identify inactive fields within a bundle.
+ */
+function field_ui_inactive_instances($bundle_name = NULL) {
+ if (!empty($bundle_name)) {
+ $inactive = array($bundle_name => array());
+ $params = array('bundle' => $bundle_name);
+ }
+ else {
+ $inactive = array();
+ $params = array();
+ }
+ $active_instances = field_info_instances();
+ $all_instances = field_read_instances($params, array('include_inactive' => TRUE));
+ foreach ($all_instances as $instance) {
+ if (!isset($active_instances[$instance['bundle']][$instance['field_name']])) {
+ $inactive[$instance['bundle']][$instance['field_name']] = $instance;
+ }
+ }
+ if (!empty($bundle_name)) {
+ return $inactive[$bundle_name];
+ }
+ return $inactive;
+}
diff --git a/modules/node/node.module b/modules/node/node.module
index 7eda3b89bd4714d5c69fca5b825430a6c1c9fe6b..94373e834797cebb9d693c77bd182533fcece3ac 100644
--- a/modules/node/node.module
+++ b/modules/node/node.module
@@ -40,12 +40,25 @@ function node_help($path, $arg) {
$output .= '<p>' . t('The administrative <a href="@content">content page</a> allows you to review and manage your site content. The node module makes a number of permissions available for each content type, which may be set by role on the <a href="@permissions">permissions page</a>.', array('@content' => url('admin/content'), '@permissions' => url('admin/settings/permissions'))) . '</p>';
$output .= '<p>' . t('For more information, see the online handbook entry for <a href="@node">Node module</a>.', array('@node' => 'http://drupal.org/handbook/modules/node/')) . '</p>';
return $output;
+
case 'admin/content':
return ' '; // Return a non-null value so that the 'more help' link is shown.
+
case 'admin/structure/types/add':
return '<p>' . t('Each piece of content is of a specific content type. Each <em>content type</em> can have different fields, behaviors, and permissions assigned to it.') . '</p>';
+
+ case 'admin/structure/node-type/' . $arg[3] . '/fields':
+ return '<p>' . t('This form lets you add, edit, and arrange fields within the %type content type.', array('%type' => node_type_get_name($arg[3]))) . '</p>';
+
+ case 'admin/structure/node-type/' . $arg[3] . '/display':
+ return '<p>' . t('This form lets you configure how fields and labels are displayed when %type content is viewed in teaser and full-page mode.', array('%type' => node_type_get_name($arg[3]))) . '</p>';
+
+ case 'admin/structure/node-type/' . $arg[3] . '/display/' . $arg[5]:
+ return '<p>' . t('This form lets you configure how fields should be displayed when rendered %type content in the following contexts.', array('%type' => node_type_get_name($arg[3]))) . '</p>';
+
case 'node/%/revisions':
return '<p>' . t('The revisions let you track differences between multiple versions of a post.') . '</p>';
+
case 'node/%/edit':
$node = node_load($arg[1]);
$type = node_type_get_type($node);
@@ -173,6 +186,25 @@ function node_field_build_modes($obj_type) {
return $modes;
}
+/**
+ * Implement hook_field_extra_fields().
+ */
+function node_field_extra_fields($bundle) {
+ $extra = array();
+
+ if ($type = node_type_get_type($bundle)) {
+ if ($type->has_title) {
+ $extra['title'] = array(
+ 'label' => $type->title_label,
+ 'description' => t('Node module element.'),
+ 'weight' => -5,
+ );
+ }
+ }
+
+ return $extra;
+}
+
/**
* Gather a listing of links to nodes.
*
diff --git a/modules/node/node.pages.inc b/modules/node/node.pages.inc
index adcd326d4b629d3130571e789c9861315b81e4a4..2c1b942d64a208c76ab12a0a4c5b2918b81cb658 100644
--- a/modules/node/node.pages.inc
+++ b/modules/node/node.pages.inc
@@ -159,6 +159,7 @@ function node_form(&$form_state, $node) {
$form['additional_settings'] = array(
'#type' => 'vertical_tabs',
+ '#weight' => 99,
);
// Add a log field if the "Create new revision" option is checked, or if the
diff --git a/modules/poll/poll.module b/modules/poll/poll.module
index b8493a3978bb967723bc5fdc58b7ee24b67065b8..bcd5d62b37bb9d6b9ab496afee6a46b969ebab2f 100644
--- a/modules/poll/poll.module
+++ b/modules/poll/poll.module
@@ -198,6 +198,28 @@ function poll_node_info() {
);
}
+/**
+ * Implement hook_field_extra_fields().
+ */
+function poll_field_extra_fields($bundle) {
+ $extra = array();
+
+ if ($bundle == 'poll') {
+ $extra['choice_wrapper'] = array(
+ 'label' => t('Poll choices'),
+ 'description' => t('Poll module choices.'),
+ 'weight' => -4,
+ );
+ $extra['settings'] = array(
+ 'label' => t('Poll settings'),
+ 'description' => t('Poll module settings.'),
+ 'weight' => -3,
+ );
+ }
+
+ return $extra;
+}
+
/**
* Implement hook_form().
*/
diff --git a/modules/taxonomy/taxonomy.module b/modules/taxonomy/taxonomy.module
index c6805633720f055433ee49bcfb2f8d1ad93c6ce5..6294cf131cec0618dd3f4ec486bc63d082339cea 100644
--- a/modules/taxonomy/taxonomy.module
+++ b/modules/taxonomy/taxonomy.module
@@ -64,6 +64,25 @@ function taxonomy_field_build_modes($obj_type) {
return $modes;
}
+/**
+ * Implement hook_field_extra_fields().
+ */
+function taxonomy_field_extra_fields($bundle) {
+ $extra = array();
+
+ if ($type = node_type_get_type($bundle)) {
+ if (taxonomy_get_vocabularies($bundle)) {
+ $extra['taxonomy'] = array(
+ 'label' => t('Taxonomy'),
+ 'description' => t('Taxonomy module element.'),
+ 'weight' => -3,
+ );
+ }
+ }
+
+ return $extra;
+}
+
/**
* Implement hook_theme().
*/
@@ -2247,3 +2266,35 @@ function taxonomy_elements() {
),
);
}
+
+/**
+ * Implement hook_field_settings_form().
+ */
+function taxonomy_field_settings_form($field, $instance) {
+ // Get proper values for 'allowed_values_function', which is a core setting.
+ $vocabularies = taxonomy_get_vocabularies();
+ $options = array();
+ foreach ($vocabularies as $vocabulary) {
+ $options[$vocabulary->vid] = $vocabulary->name;
+ }
+ $form['allowed_values'] = array(
+ '#tree' => TRUE,
+ );
+
+ foreach ($field['settings']['allowed_values'] as $delta => $tree) {
+ $form['allowed_values'][$delta]['vid'] = array(
+ '#type' => 'select',
+ '#title' => t('Vocabulary'),
+ '#default_value' => $tree['vid'],
+ '#options' => $options,
+ '#required' => TRUE,
+ '#description' => t('The vocabulary which supplies the options for this field.'),
+ );
+ $form['allowed_values'][$delta]['parent'] = array(
+ '#type' => 'value',
+ '#value' => $tree['parent'],
+ );
+ }
+
+ return $form;
+}
diff --git a/modules/user/user.module b/modules/user/user.module
index 88a661ef7291a71e3c6f07d01313b21ab1abc9d3..2bc1dfb1d8b80d4c2fc4f83df94a837dbe47951a 100644
--- a/modules/user/user.module
+++ b/modules/user/user.module
@@ -120,6 +120,33 @@ function user_field_build_modes($obj_type) {
return $modes;
}
+/**
+ * Implement hook_field_extra_fields().
+ */
+function user_field_extra_fields($bundle) {
+ $extra = array();
+
+ if ($bundle == 'user') {
+ $extra['account'] = array(
+ 'label' => 'User name and password',
+ 'description' => t('User module account form elements'),
+ 'weight' => -10,
+ );
+ $extra['timezone'] = array(
+ 'label' => 'Timezone',
+ 'description' => t('User module timezone form element.'),
+ 'weight' => 6,
+ );
+ $extra['summary'] = array(
+ 'label' => 'History',
+ 'description' => t('User module history view element.'),
+ 'weight' => 5,
+ );
+ }
+
+ return $extra;
+}
+
function user_external_load($authname) {
$uid = db_query("SELECT uid FROM {authmap} WHERE authname = :authname", array(':authname' => $authname))->fetchField();
@@ -1344,6 +1371,11 @@ function user_menu() {
'page arguments' => array('user_admin_settings'),
'access arguments' => array('administer users'),
);
+ $items['admin/settings/user/settings'] = array(
+ 'title' => 'Settings',
+ 'type' => MENU_DEFAULT_LOCAL_TASK,
+ 'weight' => -10,
+ );
// Permission administration pages.
$items['admin/settings/permissions'] = array(
@@ -2430,6 +2462,10 @@ function user_help($path, $arg) {
<li>Anonymous user: this role is used for users that don\'t have a user account or that are not authenticated.</li>
<li>Authenticated user: this role is automatically granted to all logged in users.</li>
</ul>', array('@permissions' => url('admin/settings/permissions')));
+ case 'admin/settings/user/fields':
+ return '<p>' . t('This form lets administrators add, edit, and arrange fields for storing user data.') . '</p>';
+ case 'admin/settings/user/display':
+ return '<p>' . t('This form lets administrators configure how fields should be displayed when rendering a user profile page.') . '</p>';
case 'admin/people/search':
return '<p>' . t('Enter a simple pattern ("*" may be used as a wildcard match) to search for a username or e-mail address. For example, one may search for "br" and Drupal might return "brian", "brad", and "brenda@example.com".') . '</p>';
}
diff --git a/profiles/default/default.info b/profiles/default/default.info
index 4dfc866230c548ffd684756372d8a2c44e94238a..583829d8805fa2dd3e1d00e3b75d9067b84a7f9a 100644
--- a/profiles/default/default.info
+++ b/profiles/default/default.info
@@ -14,3 +14,4 @@ dependencies[] = taxonomy
dependencies[] = dblog
dependencies[] = search
dependencies[] = toolbar
+dependencies[] = field_ui