class SmartDateWidgetBase in Smart Date 3.1.x

Base class for the 'smartdate_*' widgets.

Hierarchy

• class \Drupal\Component\Plugin\PluginBase implements DerivativeInspectionInterface, PluginInspectionInterface
  • class \Drupal\Core\Plugin\PluginBase uses DependencySerializationTrait, MessengerTrait, StringTranslationTrait
    • class \Drupal\Core\Field\PluginSettingsBase implements DependentPluginInterface, PluginSettingsInterface
      • class \Drupal\Core\Field\WidgetBase implements WidgetInterface, ContainerFactoryPluginInterface
        • class \Drupal\datetime\Plugin\Field\FieldWidget\DateTimeWidgetBase
          • class \Drupal\smart_date\Plugin\Field\FieldWidget\SmartDateWidgetBase

1 file declares its use of SmartDateWidgetBase

SmartDateOverrideForm.php in modules/smart_date_recur/src/Form/SmartDateOverrideForm.php

File

src/Plugin/Field/FieldWidget/SmartDateWidgetBase.php, line 23

Namespace

Drupal\smart_date\Plugin\Field\FieldWidget

class SmartDateWidgetBase extends DateTimeWidgetBase {

  /**
   * {@inheritdoc}
   */
  public static function defaultSettings() {
    return [
      'show_extra' => TRUE,
    ] + parent::defaultSettings();
  }

  /**
   * {@inheritdoc}
   */
  public function settingsForm(array $form, FormStateInterface $form_state) {
    $element = parent::settingsForm($form, $form_state);
    $cardinality = $this->fieldDefinition
      ->getFieldStorageDefinition()
      ->getCardinality();
    if ($cardinality != 1) {
      $element['show_extra'] = [
        '#type' => 'checkbox',
        '#title' => $this
          ->t('Always show an extra, empty widget (Drupal default). Otherwise the user must explicitly add a new widget if needed.'),
        '#default_value' => $this
          ->getSetting('show_extra'),
      ];
    }
    return $element;
  }

  /**
   * {@inheritdoc}
   */
  public function settingsSummary() {
    $summary = parent::settingsSummary();
    $cardinality = $this->fieldDefinition
      ->getFieldStorageDefinition()
      ->getCardinality();
    if ($cardinality != 1 && !$this
      ->getSetting('show_extra')) {
      $summary[] = $this
        ->t('Suppress extra, empty widget.');
    }
    return $summary;
  }

  /**
   * {@inheritdoc}
   */
  public function formElement(FieldItemListInterface $items, $delta, array $element, array &$form, FormStateInterface $form_state) {
    $element = parent::formElement($items, $delta, $element, $form, $form_state);
    $field_def = $this->fieldDefinition;
    $field_type = $field_def
      ->getType();
    $allow_recurring = FALSE;
    if ($field_type == 'smartdate') {
      if ($field_def instanceof FieldConfigInterface) {
        $allow_recurring = $field_def
          ->getThirdPartySetting('smart_date_recur', 'allow_recurring');
      }
      elseif ($field_def instanceof BaseFieldDefinition) {

        // TODO: Document that for custom entities, you must enable recurring
        // functionality by adding ->setSetting('allow_recurring', TRUE)
        // to your field definition.
        $allow_recurring = $field_def
          ->getSetting('allow_recurring');
      }

      // TODO: more elegant way to handle hiding recurring instances?
      if ($allow_recurring && $items[$delta]->rrule) {
        $rrule = SmartDateRule::load($items[$delta]->rrule);
        if ($rrule && isset($form['#rules_processed'][$items[$delta]->rrule])) {

          // Not the first instance, so skip this delta.
          $element['#access'] = FALSE;
          return $element;
        }
        else {

          // Keep track of this rule as having been processed.
          $form['#rules_processed'][$items[$delta]->rrule] = $items[$delta]->rrule;
          $items[$delta]->value = (int) $rrule->start
            ->getString();
          $items[$delta]->end_value = (int) $rrule->end
            ->getString();
          $items[$delta]->duration = ($items[$delta]->end_value - $items[$delta]->value) / 60;
        }
      }
      $defaults = $this->fieldDefinition
        ->getDefaultValueLiteral()[0];
      $timezone = isset($items[$delta]->timezone) ? $items[$delta]->timezone : date_default_timezone_get();
      $values['start'] = isset($items[$delta]->value) ? DrupalDateTime::createFromTimestamp($items[$delta]->value, $timezone) : '';
      $values['end'] = isset($items[$delta]->end_value) ? DrupalDateTime::createFromTimestamp($items[$delta]->end_value, $timezone) : '';
      $values['duration'] = isset($items[$delta]->duration) ? $items[$delta]->duration : $defaults['default_duration'];
      $values['timezone'] = isset($items[$delta]->timezone) ? $items[$delta]->timezone : '';
    }
    elseif ($field_type == 'daterange') {
      if ($items[$delta]->start_date) {

        /** @var \Drupal\Core\Datetime\DrupalDateTime $start_date */
        $start_date = $items[$delta]->start_date;
        $values['start'] = $this
          ->createDefaultValue($start_date, $element['value']['#date_timezone']);
      }
      if ($items[$delta]->end_date) {

        /** @var \Drupal\Core\Datetime\DrupalDateTime $end_date */
        $end_date = $items[$delta]->end_date;
        $values['end'] = $this
          ->createDefaultValue($end_date, $element['value']['#date_timezone']);
      }
      if (!empty($start_date) && !empty($end_date)) {
        $intervalFormatter = DrupalDateTime::createFromTimestamp(0);
        $timeInterval = $start_date
          ->diff($end_date);
        $intervalInSeconds = $intervalFormatter
          ->add($timeInterval)
          ->getTimeStamp();
        $values['duration'] = $intervalInSeconds / 60;
      }
      $defaults = [];
      $default_duration = $this
        ->getSetting('default_duration');
      if ($default_duration || $default_duration === 0 || $default_duration === '0') {
        $defaults['default_duration'] = $default_duration;
      }
      $default_duration_increments = $this
        ->getSetting('default_duration_increments');
      if ($default_duration_increments) {
        $defaults['default_duration_increments'] = $default_duration_increments;
      }
    }
    $values['storage'] = $field_type;
    $form['#attached']['library'][] = 'smart_date/smart_date';
    $element['#attributes']['class'][] = 'smartdate--widget';
    $this
      ->createWidget($element, $values, $defaults);
    if ($allow_recurring && function_exists('smart_date_recur_widget_extra_fields')) {
      smart_date_recur_widget_extra_fields($element, $items[$delta], $this);
    }
    return $element;
  }

  /**
   * Helper method to create SmartDate element.
   */
  public static function createWidget(&$element, $values, ?array $defaults) {

    // If an empty set of defaults provided, create our own.
    if (empty($defaults)) {
      $defaults = [
        'default_duration_increments' => "30\n60|1 hour\n90\n120|2 hours\ncustom",
        'default_duration' => '60',
      ];
    }

    // Wrap all of the select elements with a fieldset.
    $element['#theme_wrappers'][] = 'fieldset';
    $element['#element_validate'][] = [
      static::class,
      'validateStartEnd',
    ];
    $element['value']['#title'] = t('Start');
    $element['value']['#date_year_range'] = '1902:2037';
    if (isset($values['start'])) {

      // Ensure values always display relative to the site.
      $element['value']['#default_value'] = self::remapDatetime($values['start']);
    }
    $element['end_value'] = [
      '#title' => t('End'),
    ] + $element['value'];
    if (isset($values['end'])) {

      // Ensure values always display relative to the site.
      $element['end_value']['#default_value'] = self::remapDatetime($values['end']);
    }
    $element['value']['#attributes']['class'] = [
      'time-start',
    ];
    $element['end_value']['#attributes']['class'] = [
      'time-end',
    ];
    if (isset($values['storage'])) {
      $element['storage'] = [
        '#type' => 'value',
        '#value' => $values['storage'],
      ];
    }

    // Parse the allowed duration increments and create labels if not provided.
    $increments = SmartDateListItemBase::parseValues($defaults['default_duration_increments']);
    foreach ($increments as $key => $label) {
      if (strcmp($key, $label) !== 0) {

        // Label provided, so no extra logic required.
        continue;
      }
      if (is_numeric($key)) {

        // Anything but whole minutes will create errors with the time field.
        $num = (int) $key;
        $increments[$key] = t('@count minutes', [
          '@count' => $num,
        ]);
      }
      elseif ($key == 'custom') {
        $increments[$key] = t('Custom');
      }
      else {

        // Note sure what else we would encounter, so escape it.
        $increments[$key] = t('@key (unrecognized format)', [
          '@key' => $key,
        ]);
      }
    }
    $default_duration = $values['duration'] ?? $defaults['default_duration'];
    if (!array_key_exists($default_duration, $increments)) {
      if (array_key_exists('custom', $increments)) {
        $default_duration = 'custom';
      }
      else {

        // TODO: throw some kind of error/warning if invalid duration?
        $default_duration = '';
      }
    }
    $element['duration'] = [
      '#title' => t('Duration'),
      '#type' => 'select',
      '#options' => $increments,
      '#default_value' => $default_duration,
      '#attributes' => [
        'data-default' => $defaults['default_duration'],
        'class' => [
          'field-duration',
        ],
      ],
      '#wrapper_attributes' => [
        'class' => [
          'duration-wrapper',
        ],
      ],
    ];

    // No true input, so preserve an existing value otherwise use site default.
    $default_tz = isset($values['timezone']) ? $values['timezone'] : NULL;
    $element['timezone'] = [
      '#type' => 'hidden',
      '#title' => t('Time zone'),
      '#default_value' => $default_tz,
    ];
  }

  /**
   * {@inheritdoc}
   */
  public function massageFormValues(array $values, array $form, FormStateInterface $form_state) {

    // The widget form element type has transformed the value to a
    // DrupalDateTime object at this point. We need to convert it back to the
    // storage timestamp.
    foreach ($values as &$item) {
      if (!isset($item['storage']) || $item['storage'] != 'smartdate') {

        // Use the processing from core's Datetime Range.
        $core_range = new DateRangeWidgetBase($this
          ->getPluginId(), $this
          ->getPluginDefinition(), $this->fieldDefinition, $this
          ->getSettings(), $this->thirdPartySettings);
        $values = $core_range
          ->massageFormValues($values, $form, $form_state);
        return $values;
      }
      $timezone = NULL;
      if (!empty($item['timezone'])) {
        $timezone = new \DateTimezone($item['timezone']);
      }
      if (!empty($item['value']) && $item['value'] instanceof DrupalDateTime) {

        // Adjust the date for storage.
        $item['value'] = $this
          ->smartGetTimestamp($item['value'], $timezone);
      }
      if (!empty($item['end_value']) && $item['end_value'] instanceof DrupalDateTime) {

        // Adjust the date for storage.
        $item['end_value'] = $this
          ->smartGetTimestamp($item['end_value'], $timezone);
      }
      if ($item['duration'] == 'custom') {

        // If using a custom duration, calculate based on start and end times.
        if (!empty($item['end_value']) && !empty($item['value'])) {
          $item['duration'] = (int) ((int) $item['end_value'] - (int) $item['value']) / 60;
        }
      }
    }
    if (!$form_state
      ->isValidationComplete()) {

      // Make sure we only process once, after validation.
      return $values;
    }

    // Skip any additional processing if the field doesn't allow recurring.
    $field_def = $this->fieldDefinition;
    if ($field_def instanceof FieldConfigInterface) {
      $allow_recurring = $field_def
        ->getThirdPartySetting('smart_date_recur', 'allow_recurring');
    }
    elseif ($field_def instanceof BaseFieldDefinition) {

      // TODO: Document that for custom entities, you must enable recurring
      // functionality by adding ->setSetting('allow_recurring', TRUE)
      // to your field definition.
      $allow_recurring = $field_def
        ->getSetting('allow_recurring');
    }
    else {

      // Not sure what other method we can provide to define this.
      $allow_recurring = FALSE;
    }
    if ($allow_recurring && function_exists('smart_date_recur_widget_extra_fields')) {

      // Provide extra parameters to be stored with the recurrence rule.
      $month_limit = SmartDateRule::getMonthsLimit($field_def);
      if ($form_state
        ->getFormObject() instanceof EntityFormInterface) {
        $entity = $form_state
          ->getformObject()
          ->getEntity();
        $entity_type = $entity
          ->getEntityTypeId();
        $bundle = $entity
          ->bundle();
      }
      $field_name = $field_def
        ->getName();
      smart_date_recur_generate_rows($values, $entity_type, $bundle, $field_name, $month_limit);
    }
    return $values;
  }

  /**
   * Conditionally convert a DrupalDateTime object to a timestamp.
   *
   * @param \Drupal\Core\Datetime\DrupalDateTime $time
   *   The time to be converted.
   * @param DateTimezone|null $timezone
   *   An optional timezone to use for conversion.
   */
  private function smartGetTimestamp(DrupalDateTime $time, $timezone = NULL) {

    // Map the date to be relative to a provided timezone, if supplied.
    if ($timezone) {
      $time = $this
        ->remapDatetime($time, $timezone);
    }
    return $time
      ->getTimestamp();
  }

  /**
   * Conditionally convert a DrupalDateTime object to a timestamp.
   *
   * @param \Drupal\Core\Datetime\DrupalDateTime|null $time
   *   The time to be converted.
   * @param DateTimezone|null $timezone
   *   An optional timezone to use for conversion.
   */
  public static function remapDatetime($time, $timezone = NULL) {
    if (empty($time)) {
      return '';
    }
    $time = new DrupalDateTime($time
      ->format(DateTimeItemInterface::DATETIME_STORAGE_FORMAT), $timezone);
    return $time;
  }

  /**
   * Ensure that the start date <= the end date via #element_validate callback.
   *
   * @param array $element
   *   An associative array containing the properties and children of the
   *   generic form element.
   * @param \Drupal\Core\Form\FormStateInterface $form_state
   *   The current state of the form.
   * @param array $complete_form
   *   The complete form structure.
   */
  public static function validateStartEnd(array &$element, FormStateInterface $form_state, array &$complete_form) {
    $start_time = $element['value']['#value']['object'];
    $end_time = $element['end_value']['#value']['object'];
    if ($start_time instanceof DrupalDateTime && $end_time instanceof DrupalDateTime) {
      if ($start_time
        ->getTimestamp() !== $end_time
        ->getTimestamp()) {
        $interval = $start_time
          ->diff($end_time);
        if ($interval->invert === 1) {
          $form_state
            ->setError($element, t('The @title end date cannot be before the start date', [
            '@title' => $element['#title'],
          ]));
        }
      }
    }
  }

  /**
   * Special handling to create form elements for multiple values.
   *
   * Handles generic features for multiple fields:
   * - number of widgets
   * - AHAH-'add more' button
   * - table display and drag-n-drop value reordering.
   */
  protected function formMultipleElements(FieldItemListInterface $items, array &$form, FormStateInterface $form_state) {
    $field_name = $this->fieldDefinition
      ->getName();
    $cardinality = $this->fieldDefinition
      ->getFieldStorageDefinition()
      ->getCardinality();
    $parents = $form['#parents'];

    // Determine the number of widgets to display.
    switch ($cardinality) {
      case FieldStorageDefinitionInterface::CARDINALITY_UNLIMITED:
        $field_state = static::getWidgetState($parents, $field_name, $form_state);
        $max = $field_state['items_count'];
        $is_multiple = TRUE;
        break;
      default:
        $max = $cardinality - 1;
        $is_multiple = $cardinality > 1;
        break;
    }
    if ($max > 0 && !$this
      ->getSetting('show_extra')) {
      $max -= 1;
    }
    $title = $this->fieldDefinition
      ->getLabel();
    $description = FieldFilteredMarkup::create(\Drupal::token()
      ->replace($this->fieldDefinition
      ->getDescription()));
    $elements = [];
    for ($delta = 0; $delta <= $max; $delta++) {

      // Add a new empty item if it doesn't exist yet at this delta.
      if (!isset($items[$delta])) {
        $items
          ->appendItem();
      }

      // For multiple fields, title and description are handled by the wrapping
      // table.
      if ($is_multiple) {
        $element = [
          '#title' => $this
            ->t('@title (value @number)', [
            '@title' => $title,
            '@number' => $delta + 1,
          ]),
          '#title_display' => 'invisible',
          '#description' => '',
        ];
      }
      else {
        $element = [
          '#title' => $title,
          '#title_display' => 'before',
          '#description' => $description,
        ];
      }
      $element = $this
        ->formSingleElement($items, $delta, $element, $form, $form_state);
      if ($element && (!isset($element['#access']) || $element['#access'] !== FALSE)) {

        // Input field for the delta (drag-n-drop reordering).
        if ($is_multiple) {

          // We name the element '_weight' to avoid clashing with elements
          // defined by widget.
          $element['_weight'] = [
            '#type' => 'weight',
            '#title' => $this
              ->t('Weight for row @number', [
              '@number' => $delta + 1,
            ]),
            '#title_display' => 'invisible',
            // Note: this 'delta' is the FAPI #type 'weight' element's property.
            '#delta' => $max,
            '#default_value' => $items[$delta]->_weight ?: $delta,
            '#weight' => 100,
          ];
        }
        $elements[$delta] = $element;
      }
    }
    if ($elements) {
      $elements += [
        '#theme' => 'field_multiple_value_form',
        '#field_name' => $field_name,
        '#cardinality' => $cardinality,
        '#cardinality_multiple' => $this->fieldDefinition
          ->getFieldStorageDefinition()
          ->isMultiple(),
        '#required' => $this->fieldDefinition
          ->isRequired(),
        '#title' => $title,
        '#description' => $description,
        '#max_delta' => $max,
      ];

      // Add 'add more' button, if not working with a programmed form.
      if ($cardinality == FieldStorageDefinitionInterface::CARDINALITY_UNLIMITED && !$form_state
        ->isProgrammed()) {
        $id_prefix = implode('-', array_merge($parents, [
          $field_name,
        ]));
        $wrapper_id = Html::getUniqueId($id_prefix . '-add-more-wrapper');
        $elements['#prefix'] = '<div id="' . $wrapper_id . '">';
        $elements['#suffix'] = '</div>';
        $elements['add_more'] = [
          '#type' => 'submit',
          '#name' => strtr($id_prefix, '-', '_') . '_add_more',
          '#value' => t('Add another item'),
          '#attributes' => [
            'class' => [
              'field-add-more-submit',
            ],
          ],
          '#limit_validation_errors' => [
            array_merge($parents, [
              $field_name,
            ]),
          ],
          '#submit' => [
            [
              get_class($this),
              'addMoreSubmit',
            ],
          ],
          '#ajax' => [
            'callback' => [
              get_class($this),
              'addMoreAjax',
            ],
            'wrapper' => $wrapper_id,
            'effect' => 'fade',
          ],
        ];
      }
    }
    return $elements;
  }

}

Members

Name	Modifiers	Type	Description	Overrides
DateTimeWidgetBase::createDefaultValue	protected	function	Creates a date object for use as a default value.
DependencySerializationTrait::$_entityStorages	protected	property
DependencySerializationTrait::$_serviceIds	protected	property
DependencySerializationTrait::__sleep	public	function		2
DependencySerializationTrait::__wakeup	public	function		2
MessengerTrait::$messenger	protected	property	The messenger.	27
MessengerTrait::messenger	public	function	Gets the messenger.	27
MessengerTrait::setMessenger	public	function	Sets the messenger.
PluginBase::$configuration	protected	property	Configuration information passed into the plugin.	1
PluginBase::$pluginDefinition	protected	property	The plugin implementation definition.	1
PluginBase::$pluginId	protected	property	The plugin_id.
PluginBase::DERIVATIVE_SEPARATOR		constant	A string which is used to separate base plugin IDs from the derivative ID.
PluginBase::getBaseId	public	function	Gets the base_plugin_id of the plugin instance. Overrides DerivativeInspectionInterface::getBaseId
PluginBase::getDerivativeId	public	function	Gets the derivative_id of the plugin instance. Overrides DerivativeInspectionInterface::getDerivativeId
PluginBase::getPluginDefinition	public	function	Gets the definition of the plugin implementation. Overrides PluginInspectionInterface::getPluginDefinition	2
PluginBase::getPluginId	public	function	Gets the plugin_id of the plugin instance. Overrides PluginInspectionInterface::getPluginId
PluginBase::isConfigurable	public	function	Determines if the plugin is configurable.
PluginSettingsBase::$defaultSettingsMerged	protected	property	Whether default settings have been merged into the current $settings.
PluginSettingsBase::$thirdPartySettings	protected	property	The plugin settings injected by third party modules.
PluginSettingsBase::calculateDependencies	public	function	Calculates dependencies for the configured plugin. Overrides DependentPluginInterface::calculateDependencies	6
PluginSettingsBase::getSetting	public	function	Returns the value of a setting, or its default value if absent. Overrides PluginSettingsInterface::getSetting
PluginSettingsBase::getSettings	public	function	Returns the array of settings, including defaults for missing settings. Overrides PluginSettingsInterface::getSettings
PluginSettingsBase::getThirdPartyProviders	public	function	Gets the list of third parties that store information. Overrides ThirdPartySettingsInterface::getThirdPartyProviders
PluginSettingsBase::getThirdPartySetting	public	function	Gets the value of a third-party setting. Overrides ThirdPartySettingsInterface::getThirdPartySetting
PluginSettingsBase::getThirdPartySettings	public	function	Gets all third-party settings of a given module. Overrides ThirdPartySettingsInterface::getThirdPartySettings
PluginSettingsBase::mergeDefaults	protected	function	Merges default settings values into $settings.
PluginSettingsBase::onDependencyRemoval	public	function	Informs the plugin that some configuration it depends on will be deleted. Overrides PluginSettingsInterface::onDependencyRemoval	3
PluginSettingsBase::setSetting	public	function	Sets the value of a setting for the plugin. Overrides PluginSettingsInterface::setSetting
PluginSettingsBase::setSettings	public	function	Sets the settings for the plugin. Overrides PluginSettingsInterface::setSettings
PluginSettingsBase::setThirdPartySetting	public	function	Sets the value of a third-party setting. Overrides ThirdPartySettingsInterface::setThirdPartySetting
PluginSettingsBase::unsetThirdPartySetting	public	function	Unsets a third-party setting. Overrides ThirdPartySettingsInterface::unsetThirdPartySetting
SmartDateWidgetBase::createWidget	public static	function	Helper method to create SmartDate element.
SmartDateWidgetBase::defaultSettings	public static	function	Defines the default settings for this plugin. Overrides PluginSettingsBase::defaultSettings	2
SmartDateWidgetBase::formElement	public	function	Returns the form for a single field widget. Overrides DateTimeWidgetBase::formElement	2
SmartDateWidgetBase::formMultipleElements	protected	function	Special handling to create form elements for multiple values. Overrides WidgetBase::formMultipleElements
SmartDateWidgetBase::massageFormValues	public	function	Massages the form values into the format expected for field values. Overrides DateTimeWidgetBase::massageFormValues
SmartDateWidgetBase::remapDatetime	public static	function	Conditionally convert a DrupalDateTime object to a timestamp.
SmartDateWidgetBase::settingsForm	public	function	Returns a form to configure settings for the widget. Overrides WidgetBase::settingsForm	2
SmartDateWidgetBase::settingsSummary	public	function	Returns a short summary for the current widget settings. Overrides WidgetBase::settingsSummary	2
SmartDateWidgetBase::smartGetTimestamp	private	function	Conditionally convert a DrupalDateTime object to a timestamp.
SmartDateWidgetBase::validateStartEnd	public static	function	Ensure that the start date <= the end date via #element_validate callback.
StringTranslationTrait::$stringTranslation	protected	property	The string translation service.	4
StringTranslationTrait::formatPlural	protected	function	Formats a string containing a count of items.
StringTranslationTrait::getNumberOfPlurals	protected	function	Returns the number of plurals supported by a given language.
StringTranslationTrait::getStringTranslation	protected	function	Gets the string translation service.
StringTranslationTrait::setStringTranslation	public	function	Sets the string translation service to use.	2
StringTranslationTrait::t	protected	function	Translates a string to the current language or to a given language.
WidgetBase::$fieldDefinition	protected	property	The field definition.
WidgetBase::$settings	protected	property	The widget settings. Overrides PluginSettingsBase::$settings
WidgetBase::addMoreAjax	public static	function	Ajax callback for the "Add another item" button.
WidgetBase::addMoreSubmit	public static	function	Submission handler for the "Add another item" button.
WidgetBase::afterBuild	public static	function	After-build handler for field elements in a form.
WidgetBase::create	public static	function	Creates an instance of the plugin. Overrides ContainerFactoryPluginInterface::create	5
WidgetBase::errorElement	public	function	Assigns a field-level validation error to the right widget sub-element. Overrides WidgetInterface::errorElement	8
WidgetBase::extractFormValues	public	function	Extracts field values from submitted form values. Overrides WidgetBaseInterface::extractFormValues	2
WidgetBase::flagErrors	public	function	Reports field-level validation errors against actual form elements. Overrides WidgetBaseInterface::flagErrors	2
WidgetBase::form	public	function	Creates a form element for a field. Overrides WidgetBaseInterface::form	3
WidgetBase::formSingleElement	protected	function	Generates the form element for a single copy of the widget.
WidgetBase::getFieldSetting	protected	function	Returns the value of a field setting.
WidgetBase::getFieldSettings	protected	function	Returns the array of field settings.
WidgetBase::getFilteredDescription	protected	function	Returns the filtered field description.
WidgetBase::getWidgetState	public static	function	Retrieves processing information about the widget from $form_state. Overrides WidgetBaseInterface::getWidgetState
WidgetBase::getWidgetStateParents	protected static	function	Returns the location of processing information within $form_state.
WidgetBase::handlesMultipleValues	protected	function	Returns whether the widget handles multiple values.
WidgetBase::isApplicable	public static	function	Returns if the widget can be used for the provided field. Overrides WidgetInterface::isApplicable	4
WidgetBase::isDefaultValueWidget	protected	function	Returns whether the widget used for default value form.
WidgetBase::setWidgetState	public static	function	Stores processing information about the widget in $form_state. Overrides WidgetBaseInterface::setWidgetState
WidgetBase::__construct	public	function	Constructs a WidgetBase object. Overrides PluginBase::__construct	5