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); } }