diff --git a/src/Forms/DropdownField.php b/src/Forms/DropdownField.php
index 765b8a9df31..10db5f65820 100644
--- a/src/Forms/DropdownField.php
+++ b/src/Forms/DropdownField.php
@@ -2,145 +2,316 @@
 
 namespace SilverStripe\Forms;
 
-use SilverStripe\ORM\ArrayList;
-use SilverStripe\View\ArrayData;
+use ArrayAccess;
+use SilverStripe\ORM\Map;
+use SilverStripe\ORM\SS_List;
+use SilverStripe\Core\Convert;
+use SilverStripe\ORM\FieldType\DBHTMLText;
 
 /**
- * Dropdown field, created from a select tag.
- *
- * <b>Setting a $has_one relation</b>
- *
- * Using here an example of an art gallery, with Exhibition pages,
- * each of which has a Gallery they belong to.  The Gallery class is also user-defined.
- * <code>
- *  static $has_one = array(
- *      'Gallery' => 'Gallery',
- *  );
- *
- *  public function getCMSFields() {
- *      $fields = parent::getCMSFields();
- *      $field = DropdownField::create('GalleryID', 'Gallery', Gallery::get()->map('ID', 'Title'))
- *          ->setEmptyString('(Select one)');
- *      $fields->addFieldToTab('Root.Content', $field, 'Content');
- * </code>
- *
- * As you see, you need to put "GalleryID", rather than "Gallery" here.
- *
- * <b>Populate with Array</b>
- *
- * Example model definition:
- * <code>
- * class MyObject extends DataObject {
- *   static $db = array(
- *     'Country' => "Varchar(100)"
- *   );
- * }
- * </code>
- *
- * Example instantiation:
- * <code>
- * DropdownField::create(
- *   'Country',
- *   'Country',
- *   array(
- *     'NZ' => 'New Zealand',
- *     'US' => 'United States',
- *     'GEM'=> 'Germany'
- *   )
- * );
- * </code>
- *
- * <b>Populate with Enum-Values</b>
- *
- * You can automatically create a map of possible values from an {@link Enum} database column.
- *
- * Example model definition:
- * <code>
- * class MyObject extends DataObject {
- *   static $db = array(
- *     'Country' => "Enum('New Zealand,United States,Germany','New Zealand')"
- *   );
- * }
- * </code>
- *
- * Field construction:
- * <code>
- * DropdownField::create(
- *   'Country',
- *   'Country',
- *   singleton('MyObject')->dbObject('Country')->enumValues()
- * );
- * </code>
- *
- * <b>Disabling individual items</b>
- *
- * Individual items can be disabled by feeding their array keys to setDisabledItems.
- *
- * <code>
- * $DrDownField->setDisabledItems( array( 'US', 'GEM' ) );
- * </code>
- *
- * @see CheckboxSetField for multiple selections through checkboxes instead.
- * @see ListboxField for a single <select> box (with single or multiple selections).
- * @see TreeDropdownField for a rich and customizeable UI that can visualize a tree of selectable elements
+ * Represents a field that allows users to select one or more items from a list
  */
-class DropdownField extends SingleSelectField
+abstract class SelectField extends FormField
 {
+    /**
+     * Associative or numeric array of all dropdown items,
+     * with array key as the submitted field value, and the array value as a
+     * natural language description shown in the interface element.
+     *
+     * @var array|ArrayAccess
+     */
+    protected $source;
 
     /**
-     * Build a field option for template rendering
+     * The values for items that should be disabled (greyed out) in the dropdown.
+     * This is a non-associative array
      *
-     * @param mixed $value Value of the option
-     * @param string $title Title of the option
-     * @return ArrayData Field option
+     * @var array
      */
-    protected function getFieldOption($value, $title)
-    {
-        // Check selection
-        $selected = $this->isSelectedValue($value, $this->Value());
+    protected $disabledItems = [];
 
-        // Check disabled
-        $disabled = false;
-        if ($this->isDisabledValue($value) && $title != $this->getEmptyString()) {
-            $disabled = 'disabled';
+    /**
+     * @param string $name The field name
+     * @param string $title The field title
+     * @param array|ArrayAccess $source A map of the dropdown items
+     * @param mixed $value The current value
+     */
+    public function __construct($name, $title = null, $source = [], $value = null)
+    {
+        $this->setSource($source);
+        if (!isset($title)) {
+            $title = $name;
         }
+        parent::__construct($name, $title, $value);
+    }
 
-        return new ArrayData([
-            'Title' => (string)$title,
-            'Value' => $value,
-            'Selected' => $selected,
-            'Disabled' => $disabled,
-        ]);
+    public function getSchemaStateDefaults()
+    {
+        $data = parent::getSchemaStateDefaults();
+        $disabled = $this->getDisabledItems();
+
+        // Add options to 'data'
+        $source = $this->getSource();
+        $data['source'] = (is_array($source))
+            ? array_map(function ($value, $title) use ($disabled) {
+                return [
+                    'value' => $value,
+                    'title' => $title,
+                    'disabled' => in_array($value, $disabled),
+                ];
+            }, array_keys($source), $source)
+            : [];
+
+        return $data;
     }
 
     /**
-     * A required DropdownField must have a user selected attribute,
-     * so require an empty default for a required field
+     * Mark certain elements as disabled,
+     * regardless of the {@link setDisabled()} settings.
+     *
+     * These should be items that appear in the source list, not in addition to them.
      *
+     * @param array|SS_List $items Collection of values or items
+     * @return $this
+     */
+    public function setDisabledItems($items)
+    {
+        $this->disabledItems = $this->getListValues($items);
+        return $this;
+    }
+
+    /**
+     * Non-associative list of disabled item values
+     *
+     * @return array
+     */
+    public function getDisabledItems()
+    {
+        return $this->disabledItems;
+    }
+
+    /**
+     * Check if the given value is disabled
+     *
+     * @param string $value
      * @return bool
      */
-    public function getHasEmptyDefault()
+    protected function isDisabledValue($value)
     {
-        return parent::getHasEmptyDefault() || $this->Required();
+        if ($this->isDisabled()) {
+            return true;
+        }
+        return in_array($value, $this->getDisabledItems() ?? []);
+    }
+
+    public function getAttributes()
+    {
+        return array_merge(
+            parent::getAttributes(),
+            ['type' => null, 'value' => null]
+        );
     }
 
     /**
-     * @param array $properties
+     * Retrieve all values in the source array
+     *
+     * @return array
+     */
+    protected function getSourceValues()
+    {
+        return array_keys($this->getSource() ?? []);
+    }
+
+    /**
+     * Gets all valid values for this field.
+     *
+     * Does not include "empty" value if specified
+     *
+     * @return array
+     */
+    public function getValidValues()
+    {
+        $valid = array_diff($this->getSourceValues() ?? [], $this->getDisabledItems());
+        // Renumber indexes from 0
+        return array_values($valid ?? []);
+    }
+
+    /**
+     * Gets the source array not including any empty default values.
+     *
+     * @return array|ArrayAccess
+     */
+    public function getSource()
+    {
+        return $this->source;
+    }
+
+    /**
+     * Set the source for this list
+     *
+     * @param mixed $source
+     * @return $this
+     */
+    public function setSource($source)
+    {
+        $this->source = $this->getListMap($source);
+        return $this;
+    }
+
+    /**
+     * Given a list of values, extract the associative map of id => title
+     *
+     * @param mixed $source
+     * @return array Associative array of ids and titles
+     */
+    protected function getListMap($source)
+    {
+        // Extract source as an array
+        if ($source instanceof SS_List) {
+            $source = $source->map();
+        }
+        if ($source instanceof Map) {
+            $source = $source->toArray();
+        }
+        if (!is_array($source) && !($source instanceof ArrayAccess)) {
+            throw new \InvalidArgumentException('$source passed in as invalid type');
+        }
+
+        return $source;
+    }
+
+    /**
+     * Given a non-array collection, extract the non-associative list of ids
+     * If passing as array, treat the array values (not the keys) as the ids
+     *
+     * @param mixed $values
+     * @return array Non-associative list of values
+     */
+    protected function getListValues($values)
+    {
+        // Empty values
+        if (empty($values)) {
+            return [];
+        }
+
+        // Direct array
+        if (is_array($values)) {
+            return array_values($values ?? []);
+        }
+
+        // Extract lists
+        if ($values instanceof SS_List) {
+            return $values->column('ID');
+        }
+
+        return [trim($values ?? '')];
+    }
+
+    /**
+     * Determine if the current value of this field matches the given option value
+     *
+     * @param mixed $dataValue The value as extracted from the source of this field (or empty value if available)
+     * @param mixed $userValue The value as submitted by the user
+     * @return boolean True if the selected value matches the given option value
+     */
+    public function isSelectedValue($dataValue, $userValue)
+    {
+        if ($dataValue === $userValue) {
+            return true;
+        }
+
+        // Allow null to match empty strings
+        if ($dataValue === '' && $userValue === null) {
+            return true;
+        }
+
+        // Safety check against casting arrays as strings in PHP>5.4
+        if (is_array($dataValue) || is_array($userValue)) {
+            return false;
+        }
+
+        // For non-falsey values do loose comparison
+        if ($dataValue) {
+            return $dataValue == $userValue;
+        }
+
+        // For empty values, use string comparison to perform visible value match
+        return ((string) $dataValue) === ((string) $userValue);
+    }
+
+    public function performReadonlyTransformation()
+    {
+        /** @var LookupField $field */
+        $field = $this->castedCopy('SilverStripe\\Forms\\LookupField');
+        $field->setSource($this->getSource());
+        $field->setReadonly(true);
+
+        return $field;
+    }
+
+    public function performDisabledTransformation()
+    {
+        $clone = clone $this;
+        $clone->setDisabled(true);
+        return $clone;
+    }
+
+    /**
+     * Returns another instance of this field, but "cast" to a different class.
+     *
+     * @see FormField::castedCopy()
+     *
+     * @param string $classOrCopy
+     * @return FormField
+     */
+    public function castedCopy($classOrCopy)
+    {
+        $field = parent::castedCopy($classOrCopy);
+        if ($field instanceof SelectField) {
+            $field->setSource($this->getSource());
+        }
+        return $field;
+    }
+
+    /**
+     * Provides <option> list for the template
+     * This allows for a faster rendering of dropdowns with lots of options
+     *
      * @return string
      */
-    public function Field($properties = [])
+    public function renderOptionsHTML(): string
     {
-        $options = [];
+        // Some methods only exists for single selects
+        $source = $this->hasMethod('getSourceEmpty') ? $this->getSourceEmpty() : $this->getSource();
+        $emptyString = $this->hasMethod('getEmptyString') ? $this->getEmptyString() : '';
 
-        // Add all options
-        foreach ($this->getSourceEmpty() as $value => $title) {
-            $options[] = $this->getFieldOption($value, $title);
+        $currentValue = $this->Value();
+        foreach ($source as $value => $title) {
+            $selected = '';
+            if ($this->isSelectedValue($value, $currentValue)) {
+                $selected = ' selected="selected"';
+            }
+            $disabled = '';
+            if ($this->isDisabledValue($value) && $title != $emptyString) {
+                $disabled = ' disabled="disabled"';
+            }
+            $item = '<option value="' . Convert::raw2xml($value) . '"' . $selected . $disabled . '>' . Convert::raw2xml($title) . '</option>';
+            $options[] = $item;
         }
 
-        $properties = array_merge($properties, [
-            'Options' => new ArrayList($options)
-        ]);
+        return implode("\n", $options);
+    }
 
+    /**
+     * @param array $properties
+     * @return string
+     */
+    public function Field($properties = [])
+    {
+        // Without this, changing the source will render the previous list due to cache
+        $OptionsHTML = new DBHTMLText('Options');
+        $OptionsHTML->setValue($this->renderOptionsHTML());
+        $properties['OptionsHTML'] = $OptionsHTML;
         return parent::Field($properties);
     }
 }