protected function getFieldDefault(NodeInterface $node, $entityType, $bundle, $fieldName, Context $context)
{
/* @var $node ViewNode */
$entityType = $node->getEntityType();
$bundle = $node->getBundle();
$default = array('type' => 'hidden', 'label' => 'hidden', 'settings' => array());
if (!($field = field_info_field($fieldName))) {
// @todo Should we warn? This is surely an extra field.
return $default;
}
if (!($field = field_info_field_types($field['type']))) {
$context->logError("%s: %s field type does not exist", $node->getPath(), $field['types']);
return $default;
}
$formatter = null;
if (!empty($field['default_formatter'])) {
$formatter = $field['default_formatter'];
if (!field_info_formatter_types($formatter)) {
$context->logWarning(sprintf("%s: field %s defines non existing default formatter: %s", $node->getPath(), $fieldName, $formatter));
$formatter = null;
}
}
if ($formatter) {
$default = array('type' => $formatter, 'label' => 'hidden', 'settings' => field_info_formatter_settings($formatter));
}
return $default;
}
/**
* Set formatter type and update defaults accordingly.
*
* @see _field_write_instance().
*/
public function setFormatter($view_mode, $formatter_name, $settings = array())
{
$this->display[$view_mode] = $settings;
$display =& $this->display[$view_mode];
$display += array('label' => 'above', 'type' => $formatter_name, 'settings' => array());
if ($formatter_name != 'hidden') {
$formatter_type = \field_info_formatter_types($display['type']);
$display['module'] = $formatter_type['module'];
$display['settings'] += \field_info_formatter_settings($display['type']);
}
}
/**
* Implements EditMetadataGeneratorInterface::generate().
*/
public function generate($entity_type, $entity, array $instance, $langcode, $view_mode)
{
$field_name = $instance['field_name'];
// Early-return if user does not have access.
$access = $this->accessChecker->accessEditEntityField($entity_type, $entity, $field_name);
if (!$access) {
return array('access' => FALSE);
}
// Early-return if no editor is available.
if (!_edit_is_extra_field($entity_type, $field_name)) {
$display = field_get_display($instance, $view_mode, $entity);
$formatter_type = field_info_formatter_types($display['type']);
$items = field_get_items($entity_type, $entity, $field_name, $langcode);
$items = $items === FALSE ? array() : $items;
$editor_id = $this->editorSelector->getEditor($formatter_type, $instance, $items);
} else {
// @see hook_edit_extra_fields_info()
$extra = edit_extra_field_info($entity_type, $field_name);
if (isset($extra['view mode dependent editor'][$view_mode])) {
$editor_id = $extra['view mode dependent editor'][$view_mode];
} else {
$editor_id = $extra['default editor'];
}
}
if (!isset($editor_id)) {
return array('access' => FALSE);
}
// Gather metadata, allow the editor to add additional metadata of its own.
if (!_edit_is_extra_field($entity_type, $field_name)) {
$label = $instance['label'];
} else {
$label = edit_extra_field_info($entity_type, $field_name, 'label');
}
list($id, $vid, $bundle) = entity_extract_ids($entity_type, $entity);
$metadata = array('label' => check_plain($label), 'access' => TRUE, 'editor' => $editor_id, 'aria' => t('Entity @type @id, field @field', array('@type' => $entity_type, '@id' => $id, '@field' => $label)));
if (!_edit_is_extra_field($entity_type, $field_name)) {
$editor = edit_editor_get($editor_id);
if (!empty($editor['metadata callback'])) {
if ($editor['file']) {
require_once $editor['file path'] . '/' . $editor['file'];
}
if (function_exists($editor['metadata callback'])) {
$custom_metadata = $editor['metadata callback']($instance, $items);
if (count($custom_metadata)) {
$metadata['custom'] = $custom_metadata;
}
}
}
// Allow the metadata to be altered.
$context = array('entity_type' => $entity_type, 'entity' => $entity, 'field' => $instance, 'items' => $items);
drupal_alter('edit_editor_metadata', $metadata, $editor_id, $context);
}
return $metadata;
}
function options_form(&$form, &$form_state)
{
parent::options_form($form, $form_state);
module_load_include('inc', 'views', 'modules/field/views_handler_field_field');
$subfield = $this->field_info;
$formatters = _field_view_formatter_options($subfield['type']);
$column_names = array_keys($subfield['columns']);
// If this is a multiple value field, add its options.
if ($this->multiple) {
$this->multiple_options_form($form, $form_state);
}
// No need to ask the user anything if the field has only one column.
if (count($subfield['columns']) == 1) {
$form['click_sort_column'] = array('#type' => 'value', '#value' => isset($column_names[0]) ? $column_names[0] : '');
} else {
$form['click_sort_column'] = array('#type' => 'select', '#title' => t('Column used for click sorting'), '#options' => drupal_map_assoc($column_names), '#default_value' => $this->options['click_sort_column'], '#description' => t('Used by Style: Table to determine the actual column to click sort the field on. The default is usually fine.'), '#fieldset' => 'more');
}
$form['type'] = array('#type' => 'select', '#title' => t('Formatter'), '#options' => $formatters, '#default_value' => $this->options['type'], '#ajax' => array('path' => views_ui_build_form_url($form_state)), '#submit' => array('views_ui_config_item_form_submit_temporary'), '#executes_submit_callback' => TRUE);
$form['field_api_classes'] = array('#title' => t('Use field template'), '#type' => 'checkbox', '#default_value' => $this->options['field_api_classes'], '#description' => t('If checked, field api classes will be added using field.tpl.php (or equivalent). This is not recommended unless your CSS depends upon these classes. If not checked, template will not be used.'), '#fieldset' => 'style_settings', '#weight' => 20);
if ($this->multiple) {
$form['field_api_classes']['#description'] .= ' ' . t('Checking this option will cause the group Display Type and Separator values to be ignored.');
}
// Get the currently selected formatter.
$format = $this->options['type'];
$formatter = field_info_formatter_types($format);
$settings = $this->options['settings'] + field_info_formatter_settings($format);
// Provide an instance array for hook_field_formatter_settings_form().
ctools_include('fields');
$this->instance = ctools_fields_fake_field_instance($this->definition['subfield_name'], '_custom', $formatter, $settings);
// Store the settings in a '_custom' view mode.
$this->instance['display']['_custom'] = array('type' => $format, 'settings' => $settings);
// Get the settings form.
$settings_form = array('#value' => array());
$function = $formatter['module'] . '_field_formatter_settings_form';
if (function_exists($function)) {
$settings_form = $function($subfield, $this->instance, '_custom', $form, $form_state);
}
$form['settings'] = $settings_form;
}
public static function changeInstances(array $field, array $field_instance_overrides = array())
{
$type_info = field_info_field_types($field['type']);
$instances = field_read_instances(array('field_name' => $field['field_name']));
foreach ($instances as $instance) {
$prior_instance = $instance;
// Serialize properties back into the data property so it can be saved
// to the database.
$instance['data'] = array();
foreach ($instance as $key => $value) {
switch ($key) {
case 'id':
case 'field_id':
case 'field_name':
case 'entity_type':
case 'bundle':
case 'deleted':
case 'data':
break;
default:
$instance['data'][$key] =& $instance[$key];
}
}
$instance['settings'] = array_intersect_key($instance['settings'], $type_info['instance_settings']);
$instance['settings'] += $type_info['instance_settings'];
// Validate the existing widget can be used with the new field type.
$widget_info = field_info_widget_types($instance['widget']['type']);
if (!in_array($field['type'], $widget_info['field types'])) {
// Fallback to using the field type's default widget.
$instance['widget']['type'] = $type_info['default_widget'];
$widget_info = field_info_widget_types($type_info['default_widget']);
$instance['widget']['module'] = $widget_info['module'];
$instance['widget']['settings'] = array_intersect_key($instance['widget']['settings'], $widget_info['settings']);
$instance['widget']['settings'] += $widget_info['settings'];
}
// Validate the existing formatters can be used with the new field type.
foreach ($instance['display'] as $view_mode => $display) {
if ($display['type'] !== 'hidden') {
$formatter_info = field_info_formatter_types($display['type']);
if (!in_array($field['type'], $formatter_info['field types'])) {
// Fallback to using the field type's default formatter.
$instance['display'][$view_mode]['type'] = $type_info['default_formatter'];
$formatter_info = field_info_formatter_types($type_info['default_formatter']);
$instance['display'][$view_mode]['module'] = $formatter_info['module'];
$instance['display'][$view_mode]['settings'] = array_intersect_key($instance['display'][$view_mode], $formatter_info['settings']);
$instance['display'][$view_mode]['settings'] += $formatter_info['settings'];
}
}
}
// Allow anything to be overridden before it gets saved.
$instance = drupal_array_merge_deep($instance, $field_instance_overrides);
drupal_write_record('field_config_instance', $instance, array('id'));
// Clear caches.
field_cache_clear();
module_invoke_all('field_update_instance', $instance, $prior_instance);
}
}
