cck/includes/cck.admin.inc

<?php
// $Id: cck.admin.inc,v 1.23 2009/07/10 11:31:38 yched Exp $

/**
 * @file
 * Administrative interface for custom field type creation.
 */

/**
 * Menu callback; replacement for node_overview_types().
 *
 * TODO Should this be a patch to node module instead,
 * to allow CCK to adapt the $rows array to add its operation?
 */
function cck_types_overview() {
  $types = node_type_get_types();
  $names = node_type_get_names();
  $header = array(t('Name'), t('Type'), t('Description'), array('data' => t('Operations'), 'colspan' => '4'),);
  $rows = array();
  foreach ($names as $key => $name) {
    $type = $types[$key];
    if (node_hook($type, 'form')) {
      $bundle_url_str = str_replace('_', '-', $type->type);
      $row = array(
        check_plain($name),
        check_plain($type->type),
      );
      // Make the description smaller
      $row[] = array('data' => filter_xss_admin($type->description), 'class' => 'description');
      // Set the edit column.
      $row[] = array('data' => l(t('edit'), 'admin/build/node-type/'. $bundle_url_str));
      // Set links for managing fields.
      // TODO: a hook to allow other cck modules to add more stuff?
      $row[] = array('data' => l(t('manage fields'), 'admin/build/node-type/'. $bundle_url_str .'/fields'));
      // Set the delete column.
      if ($type->custom) {
        $row[] = array('data' => l(t('delete'), 'admin/build/node-type/'. $bundle_url_str .'/delete'));
      }
      else {
        $row[] = array('data' => '');
      }

      $rows[] = $row;
    }
  }

  if (empty($rows)) {
    $rows[] = array(array('data' => t('No bundles available.'), 'colspan' => '7', 'class' => 'message'));
  }

  return theme('table', $header, $rows);
}

/**
 * Implementation of hook_content_types_overview().
 *
 * Display the default upload settings on the Node type overview page.
 *
 */
function cck_content_types_operations($type) {
  $bundle_url_str = str_replace('_', '-', $type->type);
  return array('data' => l(t('manage fields'), 'admin/build/node-type/'. $bundle_url_str .'/fields'));
}

/**
 * Menu callback; lists all defined fields for quick reference.
 */
function cck_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 = _cck_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 cck_inactive_message($bundle) {
  // TODO : adapt to new D7 APIs
  $inactive_fields = cck_inactive_fields($bundle);
  if (!empty($inactive_fields)) {
    $field_types = _field_field_types();
    $widget_types = _field_widget_types($bundle);
    drupal_set_message(t('This bundle has inactive fields. Inactive fields are not included in lists of available fields until their modules are enabled.'), 'error');
    foreach ($inactive_fields as $field_name => $field) {
      drupal_set_message(t('!field (!field_name) is an inactive !field_type field that uses a !widget_type widget.', array(
      '!field' => $field['label'],
      '!field_name' => $field['field_name'],
      '!field_type' => array_key_exists($field['type'], $field_types) ? $field_types[$field['type']]['label'] : $field['type'],
      '!widget_type' => array_key_exists($field['widget']['type'], $widget_types) ? $widget_types[$field['widget']['type']]['label'] : $field['widget']['type'],
      )));
    }
  }
}

/**
 * Menu callback; listing of fields for a content type.
 *
 * Allows fields to be reordered and nested in fieldgroups using
 * JS drag-n-drop. Non-field form elements can also be moved around.
 */
function cck_field_overview_form(&$form_state, $obj_type, $bundle) {
  $bundle = field_attach_extract_bundle($obj_type, $bundle);

  cck_inactive_message($bundle);
  $admin_path = _cck_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 = cck_extra_field_values($bundle);

  $groups = $group_options = array();
  if (module_exists('fieldgroup')) {
    $groups = fieldgroup_groups($bundle);
    $group_types = fieldgroup_types();
    $group_options = _fieldgroup_groups_label($bundle);
    // Add the ability to group under the newly created row.
    $group_options['_add_new_group'] = '_add_new_group';
  }

  // Store the default weights as we meet them, to be able to put the
  //'add new' rows after them.
  $weights = array();

  $form = array(
    '#tree' => TRUE,
    '#bundle' => $bundle,
    '#fields' => array_keys($instances),
    '#groups' => array_keys($groups),
    '#extra' => array_keys($extra),
    '#field_rows' => array(),
    '#group_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['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.'))))),
      'configure' => array(
        '#markup' => l(t('Configure'), $admin_field_path, array(
          'attributes' => array('title' => t('Edit instance settings.'))))),
      'remove' => array(
        '#markup' => l(t('Remove'), $admin_field_path .'/remove', array(
          'attributes' => array('title' => t('Remove instance.'))))),
      'weight' => array('#type' => 'textfield', '#default_value' => $weight, '#size' => 3),
      'parent' => array('#type' => 'select', '#options' => $group_options, '#default_value' => ''),
      'prev_parent' => array('#type' => 'hidden', '#value' => ''),
      'hidden_name' => array('#type' => 'hidden', '#default_value' => $instance['field_name']),
      '#leaf' => TRUE,
      '#row_type' => 'field',
      // TODO D7 : ??
      'field' =>  array('#type' => 'value', '#value' => $field),
    );

    if (!empty($instance['locked'])) {
      $form[$name]['configure'] = array('#value' => t('Locked'));
      $form[$name]['remove'] = array();
      $form[$name]['#disabled_row'] = TRUE;
    }
    $form['#field_rows'][] = $name;
    $weights[] = $weight;
  }

  // Groups.
  foreach ($groups as $name => $group) {
    $weight = $group['weight'];
    $form[$name] = array(
      'label' => array('#markup' => check_plain($group['label'])),
      'group_name' => array('#markup' => $group['group_name']),
      'group_type' => array('#markup' => t($group_types[$group['group_type']])),
      'configure' => array('#markup' => l(t('Configure'), $admin_path .'/groups/'. $group['group_name'])),
      'remove' => array('#markup' => l(t('Remove'), $admin_path .'/groups/'. $group['group_name'] .'/remove')),
      'weight' => array('#type' => 'textfield', '#default_value' => $weight, '#size' => 3),
      'parent' => array('#type' => 'hidden', '#default_value' => ''),
      'hidden_name' => array('#type' => 'hidden', '#default_value' => $group['group_name']),
      '#root' => TRUE,
      '#row_type' => 'group',
      'group' => array('#type' => 'value', '#value' => $group),
    );
    // Adjust child fields rows.
    foreach ($group['fields'] as $field_name => $field) {
      $form[$field_name]['parent']['#default_value'] = $name;
      $form[$field_name]['prev_parent']['#value'] = $name;
    }
    $form['#group_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'])),
      'description' => array('#markup' => isset($extra[$name]['description']) ? $extra[$name]['description'] : ''),
      'weight' => array('#type' => 'textfield', '#default_value' => $weight, '#size' => 3),
      'parent' => array('#type' => 'hidden', '#default_value' => ''),
      'configure' => array('#value' => isset($extra[$name]['configure']) ? $extra[$name]['configure'] : ''),
      'remove' => array('#value' => isset($extra[$name]['remove']) ? $extra[$name]['remove'] : ''),
      'hidden_name' => array('#type' => 'hidden', '#default_value' => $name),
      '#leaf' => TRUE,
      '#root' => TRUE,
      '#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 = cck_field_type_options();
  $widget_type_options = cck_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>&lrm;',
        '#attributes' => array('dir'=>'ltr'),
        '#size' => 15,
        '#description' => t('Field name (a-z, 0-9, _)'),
      ),
      'type' => array(
        '#type' => 'select',
        '#options' => $field_type_options,
        '#description' => theme('advanced_help_topic', 'cck', 'fields') . 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),
      'parent' => array('#type' => 'select', '#options' => $group_options, '#default_value' => ''),
      'hidden_name' => array('#type' => 'hidden', '#default_value' => $name),
      '#leaf' => TRUE,
      '#add_new' => TRUE,
      '#row_type' => 'add_new_field',
    );
    $form['#field_rows'][] = $name;
  }

  // Additional row : add existing field.
  $existing_field_options = cck_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),
      'parent' => array('#type' => 'select', '#options' => $group_options, '#default_value' => ''),
      'hidden_name' => array('#type' => 'hidden', '#default_value' => $name),
      '#leaf' => TRUE,
      '#add_new' => TRUE,
      '#row_type' => 'add_existing_field',
    );
    $form['#field_rows'][] = $name;
  }

  // Additional row : add new group.
  if (module_exists('fieldgroup')) {
    $weight++;
    $name = '_add_new_group';
    $form[$name] = array(
      'label' => array(
        '#type' => 'textfield',
        '#size' => 15,
        '#description' => t('Label'),
      ),
      'group_name' => array(
        '#type' => 'textfield',
        // This field should stay LTR even for RTL languages.
        '#field_prefix' => '<span dir="ltr">group_',
        '#field_suffix' => '</span>&lrm;',
        '#attributes' => array('dir'=>'ltr'),
        '#size' => 15,
        '#description' => t('Group name (a-z, 0-9, _)'),
      ),
      'group_option' => array(
        '#type' => 'hidden',
        '#value' => '',
      ),
      'group_type' => array(
        '#type' => 'hidden',
        '#value' => 'standard',
      ),
      'weight' => array('#type' => 'textfield', '#default_value' => $weight, '#size' => 3),
      'parent' => array('#type' => 'hidden', '#default_value' => ''),
      'hidden_name' => array('#type' => 'hidden', '#default_value' => $name),
      '#root' => TRUE,
      '#add_new' => TRUE,
      '#row_type' => 'add_new_group',
    );
    $form['#group_rows'][] = $name;
  }

  $form['submit'] = array('#type' => 'submit', '#value' => t('Save'));
  return $form;
}

function cck_field_overview_form_validate($form, &$form_state) {
  _cck_field_overview_form_validate_add_new($form, $form_state);
  _cck_field_overview_form_validate_add_existing($form, $form_state);
}

/**
 * Helper function for cck_field_overview_form_validate.
 *
 * Validate the 'add new field' row.
 */
function _cck_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']))) {
    // No label.
    if (!$field['label']) {
      form_set_error('_add_new_field][label', t('Add new field: you need to provide a label.'));
    }

    // No 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)));
      }
      // A field named 'field_instance' would cause a tablename clash with {field_field_instance}
      if ($field_name == 'field_instance') {
        form_set_error('_add_new_field][field_name', t("Add new field: the name 'field_instance' is a reserved name."));
      }

      // Field name already exists.
      // We need to check inactive fields as well, so we can't use field_fields().
      module_load_include('inc', 'content', 'includes/content.crud');
      $fields = field_read_fields(array(), TRUE);
      $used = FALSE;
      foreach ($fields as $existing_field) {
        $used |= ($existing_field['field_name'] == $field_name);
      }
      if ($used) {
        form_set_error('_add_new_field][field_name', t('Add new field: the field name %field_name already exists.', array('%field_name' => $field_name)));
      }
    }

    // No field type.
    if (!$field['type']) {
      form_set_error('_add_new_field][type', t('Add new field: you need to select a field type.'));
    }

    // No 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 = cck_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 cck_field_overview_form_validate.
 *
 * Validate the 'add existing field' row.
 */
function _cck_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']))) {
      // No label.
      if (!$field['label']) {
        form_set_error('_add_existing_field][label', t('Add existing field: you need to provide a label.'));
      }

      // No existing field.
      if (!$field['field_name']) {
        form_set_error('_add_existing_field][field_name', t('Add existing field: you need to select a field.'));
      }

      // No 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 = cck_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.'));
        }
      }
    }
  }
}

function cck_field_overview_form_submit($form, &$form_state) {
  $form_values = $form_state['values'];
  $bundle = $form['#bundle'];
  $admin_path = _cck_bundle_admin_path($bundle);

  // Update field weights.
  $extra = array();
  foreach ($form_values as $key => $values) {
    // Groups are handled in fieldgroup_cck_overview_form_submit().
    if (in_array($key, $form['#fields'])) {
      db_query("UPDATE {field_config_instance} SET weight = %d WHERE bundle = '%s' AND field_name = '%s'",
        $values['weight'], $bundle, $key);
    }
    elseif (in_array($key, $form['#extra'])) {
      $extra[$key] = $values['weight'];
    }
  }

  if ($extra) {
    variable_set('cck_extra_weights_'. $bundle, $extra);
  }
  else {
    variable_del('cck_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'],
      'weight' => $values['weight'],
      'widget' => array(
        'type' => $values['widget_type'],
      ),
    );

    // Create the field and instance.
    try {
      field_create_field($field);
      field_create_instance($instance);

      // Rebuild the menu so we can navigate to the field settings screen.
      //field_clear_type_cache(TRUE);
      //menu_rebuild();
      $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 fieldgroup submit handler.
      $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' => $values['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' => $field['field_name'])));
    }
    else {
      $instance = array(
        'field_name' => $field['field_name'],
        'bundle' => $bundle,
        'label' => $values['label'],
        'weight' => $values['weight'],
        'widget' => array(
          'type' => $values['widget_type'],
        ),
      );

      try {
        field_create_instance($instance);
        $destinations[] = $admin_path .'/fields/refresh';
        $destinations[] = $admin_path .'/fields/'. $instance['field_name'] .'/edit';
        // Store new field information for fieldgroup submit handler.
        $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' => $field['label'], '@message' => $e->getMessage())));
      }
    }
  }

  if ($destinations) {
    $destinations[] = urldecode(substr(drupal_get_destination(), 12));
    unset($_REQUEST['destination']);
    $form_state['redirect'] = cck_get_destinations($destinations);
  }

  field_cache_clear();
}

/**
 * Menu callback; presents a listing of fields display settings for a content type.
 *
 * Form includes form widgets to select which fields appear for teaser, full node
 * and how the field labels should be rendered.
 */
function cck_display_overview_form(&$form_state, $obj_type, $bundle, $contexts_selector = 'basic') {
  $bundle = field_attach_extract_bundle($obj_type, $bundle);

  cck_inactive_message($bundle);
  $admin_path = _cck_bundle_admin_path($bundle);

  // Gather type information.
  $entity = field_info_bundle_entity($bundle);
  $instances = field_info_instances($bundle);
  $field_types = field_info_field_types();

  $groups = $group_options = array();
  if (module_exists('fieldgroup')) {
    $groups = fieldgroup_groups($bundle);
    $group_options = _fieldgroup_groups_label($bundle);
  }

  $contexts = cck_build_modes($entity, $contexts_selector);
  $form = array(
    '#tree' => TRUE,
    '#bundle' => $bundle,
    '#fields' => array_keys($instances),
    '#groups' => array_keys($groups),
    '#contexts' => $contexts_selector,
  );

  if (empty($instances)) {
    drupal_set_message(t('There are no fields configured yet. 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']);
    $field_type = $field_types[$field['type']];
    $defaults = $instance['display'];
    $weight = $instance['weight'];

    $form[$name] = array(
      'human_name' => array('#markup' => check_plain($instance['label'])),
      'weight' => array('#type' => 'value', '#value' => $weight),
      'parent' => array('#type' => 'value', '#value' => ''),
    );

    // Formatters.
    $options = cck_formatter_options($field['type']);
    $options['hidden'] = t('<Hidden>');

    foreach ($contexts as $key => $value) {
      $form[$name][$key]['label'] = array(
        '#type' => 'select',
        '#options' => $label_options,
        '#default_value' => isset($defaults[$key]['label']) ? $defaults[$key]['label'] : 'hidden',
      );
      $form[$name][$key]['type'] = array(
        '#type' => 'select',
        '#options' => $options,
        '#default_value' => isset($defaults[$key]['type']) ? $defaults[$key]['type'] : 'default',
      );
    }
  }

  // Groups.
  $label_options = array(
    'above' => t('Above'),
    'hidden' => t('<Hidden>'),
  );
  $options = array(
    'no_style' => t('no styling'),
    'simple' => t('simple'),
    'fieldset' => t('fieldset'),
    'fieldset_collapsible' => t('fieldset - collapsible'),
    'fieldset_collapsed' => t('fieldset - collapsed'),
    'hidden' => t('<Hidden>'),
  );
  foreach ($groups as $name => $group) {
    $defaults = $group['settings']['display'];
    $weight = $group['weight'];

    $form[$name] = array(
      'human_name' => array('#markup' => check_plain($group['label'])),
      'weight' => array('#type' => 'value', '#value' => $weight),
    );
    foreach ($contexts as $key => $title) {
      $form[$name][$key]['label'] = array(
        '#type' => 'select',
        '#options' => $label_options,
        '#default_value' => isset($defaults[$key]['label']) ? $defaults[$key]['label'] : 'above',
      );
      $form[$name][$key]['format'] = array(
        '#type' => 'select',
        '#options' => $options,
        '#default_value' => isset($defaults[$key]['format']) ? $defaults[$key]['format'] : 'fieldset',
      );
    }
    foreach ($group['fields'] as $field_name => $field) {
      $form[$field_name]['parent']['#value'] = $name;
    }
  }

  $form['submit'] = array('#type' => 'submit', '#value' => t('Save'));
  return $form;
}

/**
 * Submit handler for the display overview form.
 */
function cck_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) {
    // Groups are handled in fieldgroup_display_overview_form_submit().
    if (in_array($key, $form['#fields'])) {
      $instance = field_info_instance($key, $form['#bundle']);
      unset($values['weight'], $values['parent']);
      $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 cck_field_type_options() {
  static $options;

  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 (cck_widget_type_options($name)) {
        $options[$name] = t($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 cck_widget_type_options($field_type = NULL, $by_label = FALSE) {
  static $options;

  if (!isset($options)) {
    $options = array();
    foreach (field_info_widget_types() as $name => $widget_type) {
      foreach ($widget_type['field types'] as $widget_field_type) {
        $options[$widget_field_type][$name] = t($widget_type['label']);
      }
    }
  }

  if ($field_type) {
    return !empty($options[$field_type]) ? $options[$field_type] : array();
  }
  elseif ($by_label) {
    $field_types = field_info_field_types();
    $options_by_label = array();
    foreach ($options as $field_type => $widgets) {
      $options_by_label[t($field_types[$field_type]['label'])] = $widgets;
    }
    return $options_by_label;
  }
  else {
    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 cck_formatter_options($field_type = NULL) {
  static $options;

  if (!isset($options)) {
    $options = array();
    foreach (field_info_formatter_types() as $name => $formatter) {
      foreach ($formatter['field types'] as $formatter_field_type) {
        $options[$formatter_field_type][$name] = t($formatter['label']);
      }
    }
  }

  if ($field_type) {
    return !empty($options[$field_type]) ? $options[$field_type] : array();
  }
  else {
    return $options;
  }
}

/**
 * Return an array of existing field to be added to a node type.
 */
function cck_existing_field_options($bundle) {
  $bundles = field_info_instances();
  $options = array();
  $field_types = field_info_field_types();
  foreach ($bundles as $bundle_name => $instances) {
    // No need to look in the currenht bundle.
    if ($bundle_name != $bundle) {
      foreach ($instances as $instance) {
        $field = field_info_field($instance['field_name']);
        // Don't show locked fields, or fields that are already in the current
        // bundle.
        if (empty($field['locked']) && !field_info_instance($field['field_name'], $bundle)) {
          $text = t('@type: @field (@label)', array('@type' => t($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 type, then by field name, then by label.
  asort($options);
  return $options;
}

/**
 * Helper function to determine if a field has data in the database.
 */
function cck_field_has_data($field_name) {
  $has_data = FALSE;
  if (drupal_function_exists('field_db_tablename')) {
    $table = field_db_tablename($field_name);
    if (db_table_exists($table)) {
      $query = db_select($table, 'f', array('fetch' => PDO::FETCH_ASSOC));
      $query->fields('f', array('entity_id'));
      $query->condition('f.deleted', 0);
      $results = $query->execute()->fetchAssoc();
      if (!empty($results)) {
        $has_data = TRUE;
      }
    }
  }
  return $has_data;
}

/**
 * Menu callback; presents the field settings edit page.
 */
function cck_field_settings_form(&$form_state, $obj_type, $bundle, $field_name) {
  $bundle = field_attach_extract_bundle($obj_type, $bundle);

  $instance = field_info_field($field_name, $bundle);
  $field = field_info_field($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_name, $bundle);
    $field = field_read_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 = cck_field_has_data($field_name);
  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_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 cck_field_settings_form_submit($form, &$form_state) {
  $form_values = $form_state['values'];
  $field_values = $form_values['field'];

  // Don't allow changes to fields with data.
  if (cck_field_has_data($field_values['field_name'])) {
    return;
  }

  // Merge incoming form values into the existing field.
  $field = field_info_field($field_values['field_name']);
  // Remove the 'bundles' element added by field_info_field
  // TODO: this is ugly, there should 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);
  cck_field_update_field($field);

  drupal_set_message(t('Updated field %label field settings.', array('%label' => $instance['label'])));
  $form_state['redirect'] = cck_next_destination($form_state, $bundle);
}

/**
 * The Field API doesn't allow field updates,
 * so we create a method here to update field if no data is created yet.
 *
 * @see
 *   field_create_field()
 */
function cck_field_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);
}

/**
 * Menu callback; select a widget for the field.
 */
function cck_widget_type_form(&$form_state, $obj_type, $bundle, $field_name) {
  $bundle = field_attach_extract_bundle($obj_type, $bundle);

  $instance = field_read_instance($field_name, $bundle);
  $field = field_read_field($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 = array();
  $form['basic'] = array(
    '#type' => 'fieldset',
    '#title' => t('Change widget'),
  );
  $form['basic']['widget_type'] = array(
    '#type' => 'select',
    '#title' => t('Widget type'),
    '#required' => TRUE,
    '#options' => cck_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('cck_widget_type_form_submit');

  return $form;
}

/**
 * Submit the change in widget type.
 */
function cck_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'];

  if (drupal_function_exists('field_update_instance')) {
    $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'])));
    }