gemini-browser

dropdown.go (22943B)

---

 package tview
 
 import (
 	"regexp"
 	"strings"
 
 	"github.com/gdamore/tcell/v2"
 )
 
 // dropDownOption is one option that can be selected in a drop-down primitive.
 type dropDownOption struct {
 	Text     string // The text to be displayed in the drop-down.
 	Selected func() // The (optional) callback for when this option was selected.
 }
 
 // DropDown implements a selection widget whose options become visible in a
 // drop-down list when activated.
 //
 // See https://github.com/rivo/tview/wiki/DropDown for an example.
 type DropDown struct {
 	*Box
 
 	// Whether or not this drop-down is disabled/read-only.
 	disabled bool
 
 	// The options from which the user can choose.
 	options []*dropDownOption
 
 	// Strings to be placed before and after each drop-down option.
 	optionPrefix, optionSuffix string
 
 	// The index of the currently selected option. Negative if no option is
 	// currently selected.
 	currentOption int
 
 	// Strings to be placed before and after the current option.
 	currentOptionPrefix, currentOptionSuffix string
 
 	// The text to be displayed when no option has yet been selected.
 	noSelection string
 
 	// Set to true if the options are visible and selectable.
 	open bool
 
 	// The input field containing the entered prefix for the current selection.
 	// This is only visible when the drop-down is open. It never receives focus,
 	// however. And it only receives events, we never call its Draw method.
 	prefix *InputField
 
 	// The list element for the options.
 	list *List
 
 	// The text to be displayed before the input area.
 	label string
 
 	// The label style.
 	labelStyle tcell.Style
 
 	// The field style.
 	fieldStyle tcell.Style
 
 	// The style of the field when it is focused and the drop-down is closed.
 	focusedStyle tcell.Style
 
 	// The style of the field when it is disabled.
 	disabledStyle tcell.Style
 
 	// The style of the prefix.
 	prefixStyle tcell.Style
 
 	// The screen width of the label area. A value of 0 means use the width of
 	// the label text.
 	labelWidth int
 
 	// The screen width of the input area. A value of 0 means extend as much as
 	// possible.
 	fieldWidth int
 
 	// An optional function which is called when the user indicated that they
 	// are done selecting options. The key which was pressed is provided (tab,
 	// shift-tab, or escape).
 	done func(tcell.Key)
 
 	// A callback function set by the Form class and called when the user leaves
 	// this form item.
 	finished func(tcell.Key)
 
 	// A callback function which is called when the user changes the drop-down's
 	// selection.
 	selected func(text string, index int)
 
 	dragging bool // Set to true when mouse dragging is in progress.
 }
 
 // NewDropDown returns a new drop-down.
 func NewDropDown() *DropDown {
 	list := NewList()
 	list.ShowSecondaryText(false).
 		SetMainTextStyle(tcell.StyleDefault.Background(Styles.MoreContrastBackgroundColor).Foreground(Styles.PrimitiveBackgroundColor)).
 		SetSelectedStyle(tcell.StyleDefault.Background(Styles.PrimaryTextColor).Foreground(Styles.PrimitiveBackgroundColor)).
 		SetHighlightFullLine(true).
 		SetBackgroundColor(Styles.MoreContrastBackgroundColor)
 
 	prefix := NewInputField()
 
 	box := NewBox()
 	d := &DropDown{
 		Box:           box,
 		currentOption: -1,
 		list:          list,
 		prefix:        prefix,
 		labelStyle:    tcell.StyleDefault.Foreground(Styles.SecondaryTextColor),
 		fieldStyle:    tcell.StyleDefault.Background(Styles.ContrastBackgroundColor).Foreground(Styles.PrimaryTextColor),
 		focusedStyle:  tcell.StyleDefault.Background(Styles.PrimaryTextColor).Foreground(Styles.ContrastBackgroundColor),
 		disabledStyle: tcell.StyleDefault.Background(box.backgroundColor).Foreground(Styles.SecondaryTextColor),
 		prefixStyle:   tcell.StyleDefault.Background(Styles.PrimaryTextColor).Foreground(Styles.ContrastBackgroundColor),
 	}
 
 	return d
 }
 
 // SetCurrentOption sets the index of the currently selected option. This may
 // be a negative value to indicate that no option is currently selected. Calling
 // this function will also trigger the "selected" callback (if there is one).
 func (d *DropDown) SetCurrentOption(index int) *DropDown {
 	if index >= 0 && index < len(d.options) {
 		d.currentOption = index
 		d.list.SetCurrentItem(index)
 		if d.selected != nil {
 			d.selected(d.options[index].Text, index)
 		}
 		if d.options[index].Selected != nil {
 			d.options[index].Selected()
 		}
 	} else {
 		d.currentOption = -1
 		d.list.SetCurrentItem(0) // Set to 0 because -1 means "last item".
 		if d.selected != nil {
 			d.selected("", -1)
 		}
 	}
 	return d
 }
 
 // GetCurrentOption returns the index of the currently selected option as well
 // as its text. If no option was selected, -1 and an empty string is returned.
 func (d *DropDown) GetCurrentOption() (int, string) {
 	var text string
 	if d.currentOption >= 0 && d.currentOption < len(d.options) {
 		text = d.options[d.currentOption].Text
 	}
 	return d.currentOption, text
 }
 
 // SetTextOptions sets the text to be placed before and after each drop-down
 // option (prefix/suffix), the text placed before and after the currently
 // selected option (currentPrefix/currentSuffix) as well as the text to be
 // displayed when no option is currently selected. Per default, all of these
 // strings are empty.
 func (d *DropDown) SetTextOptions(prefix, suffix, currentPrefix, currentSuffix, noSelection string) *DropDown {
 	d.currentOptionPrefix = currentPrefix
 	d.currentOptionSuffix = currentSuffix
 	d.noSelection = noSelection
 	d.optionPrefix = prefix
 	d.optionSuffix = suffix
 	for index := 0; index < d.list.GetItemCount(); index++ {
 		d.list.SetItemText(index, prefix+d.options[index].Text+suffix, "")
 	}
 	return d
 }
 
 // SetUseStyleTags sets a flag that determines whether tags found in the option
 // texts are interpreted as tview tags. By default, this flag is enabled (for
 // backwards compatibility reasons).
 func (d *DropDown) SetUseStyleTags(useStyleTags bool) *DropDown {
 	d.list.SetUseStyleTags(useStyleTags, useStyleTags)
 	return d
 }
 
 // SetLabel sets the text to be displayed before the input area.
 func (d *DropDown) SetLabel(label string) *DropDown {
 	d.label = label
 	return d
 }
 
 // GetLabel returns the text to be displayed before the input area.
 func (d *DropDown) GetLabel() string {
 	return d.label
 }
 
 // SetLabelWidth sets the screen width of the label. A value of 0 will cause the
 // primitive to use the width of the label string.
 func (d *DropDown) SetLabelWidth(width int) *DropDown {
 	d.labelWidth = width
 	return d
 }
 
 // SetLabelColor sets the color of the label.
 func (d *DropDown) SetLabelColor(color tcell.Color) *DropDown {
 	d.labelStyle = d.labelStyle.Foreground(color)
 	return d
 }
 
 // SetLabelStyle sets the style of the label.
 func (d *DropDown) SetLabelStyle(style tcell.Style) *DropDown {
 	d.labelStyle = style
 	return d
 }
 
 // SetFieldBackgroundColor sets the background color of the selected field.
 // This also overrides the prefix background color.
 func (d *DropDown) SetFieldBackgroundColor(color tcell.Color) *DropDown {
 	d.fieldStyle = d.fieldStyle.Background(color)
 	d.prefix.SetFieldBackgroundColor(color)
 	return d
 }
 
 // SetFieldTextColor sets the text color of the options area.
 func (d *DropDown) SetFieldTextColor(color tcell.Color) *DropDown {
 	d.fieldStyle = d.fieldStyle.Foreground(color)
 	return d
 }
 
 // SetFieldStyle sets the style of the options area.
 func (d *DropDown) SetFieldStyle(style tcell.Style) *DropDown {
 	d.fieldStyle = style
 	return d
 }
 
 // SetFocusedStyle sets the style of the options area when the drop-down is
 // focused and closed.
 func (d *DropDown) SetFocusedStyle(style tcell.Style) *DropDown {
 	d.focusedStyle = style
 	return d
 }
 
 // SetDisabledStyle sets the style of the options area when the drop-down is
 // disabled.
 func (d *DropDown) SetDisabledStyle(style tcell.Style) *DropDown {
 	d.disabledStyle = style
 	return d
 }
 
 // SetPrefixTextColor sets the color of the prefix string. The prefix string is
 // shown when the user starts typing text, which directly selects the first
 // option that starts with the typed string.
 func (d *DropDown) SetPrefixTextColor(color tcell.Color) *DropDown {
 	d.prefixStyle = d.prefixStyle.Foreground(color)
 	return d
 }
 
 // SetPrefixStyle sets the style of the prefix string. The prefix string is
 // shown when the user starts typing text, which directly selects the first
 // option that starts with the typed string.
 func (d *DropDown) SetPrefixStyle(style tcell.Style) *DropDown {
 	d.prefixStyle = style
 	return d
 }
 
 // SetListStyles sets the styles of the items in the drop-down list (unselected
 // as well as selected items). Style attributes are currently ignored but may be
 // used in the future.
 func (d *DropDown) SetListStyles(unselected, selected tcell.Style) *DropDown {
 	d.list.SetMainTextStyle(unselected).SetSelectedStyle(selected)
 	_, bg, _ := unselected.Decompose()
 	d.list.SetBackgroundColor(bg)
 	return d
 }
 
 // SetFormAttributes sets attributes shared by all form items.
 func (d *DropDown) SetFormAttributes(labelWidth int, labelColor, bgColor, fieldTextColor, fieldBgColor tcell.Color) FormItem {
 	d.labelWidth = labelWidth
 	d.SetLabelColor(labelColor)
 	d.SetBackgroundColor(bgColor)
 	d.SetFieldStyle(tcell.StyleDefault.Foreground(fieldTextColor).Background(fieldBgColor))
 	return d
 }
 
 // SetFieldWidth sets the screen width of the options area. A value of 0 means
 // extend to as long as the longest option text.
 func (d *DropDown) SetFieldWidth(width int) *DropDown {
 	d.fieldWidth = width
 	return d
 }
 
 // GetFieldWidth returns this primitive's field screen width.
 func (d *DropDown) GetFieldWidth() int {
 	if d.fieldWidth > 0 {
 		return d.fieldWidth
 	}
 	fieldWidth := 0
 	for _, option := range d.options {
 		width := TaggedStringWidth(option.Text)
 		if width > fieldWidth {
 			fieldWidth = width
 		}
 	}
 	return fieldWidth
 }
 
 // GetFieldHeight returns this primitive's field height.
 func (d *DropDown) GetFieldHeight() int {
 	return 1
 }
 
 // SetDisabled sets whether or not the item is disabled / read-only.
 func (d *DropDown) SetDisabled(disabled bool) FormItem {
 	d.disabled = disabled
 	if d.finished != nil {
 		d.finished(-1)
 	}
 	return d
 }
 
 // AddOption adds a new selectable option to this drop-down. The "selected"
 // callback is called when this option was selected. It may be nil.
 func (d *DropDown) AddOption(text string, selected func()) *DropDown {
 	d.options = append(d.options, &dropDownOption{Text: text, Selected: selected})
 	d.list.AddItem(d.optionPrefix+text+d.optionSuffix, "", 0, nil)
 	return d
 }
 
 // SetOptions replaces all current options with the ones provided and installs
 // one callback function which is called when one of the options is selected.
 // It will be called with the option's text and its index into the options
 // slice. The "selected" parameter may be nil.
 func (d *DropDown) SetOptions(texts []string, selected func(text string, index int)) *DropDown {
 	d.list.Clear()
 	d.options = nil
 	for _, text := range texts {
 		d.AddOption(text, nil)
 	}
 	d.selected = selected
 	return d
 }
 
 // GetOptionCount returns the number of options in the drop-down.
 func (d *DropDown) GetOptionCount() int {
 	return len(d.options)
 }
 
 // RemoveOption removes the specified option from the drop-down. Panics if the
 // index is out of range. If the currently selected option is removed, no option
 // will be selected.
 func (d *DropDown) RemoveOption(index int) *DropDown {
 	if index == d.currentOption {
 		d.currentOption = -1
 	}
 	d.options = append(d.options[:index], d.options[index+1:]...)
 	d.list.RemoveItem(index)
 	return d
 }
 
 // SetSelectedFunc sets a handler which is called when the user changes the
 // drop-down's option. This handler will be called in addition and prior to
 // an option's optional individual handler. The handler is provided with the
 // selected option's text and index. If "no option" was selected, these values
 // are an empty string and -1.
 func (d *DropDown) SetSelectedFunc(handler func(text string, index int)) *DropDown {
 	d.selected = handler
 	return d
 }
 
 // SetDoneFunc sets a handler which is called when the user is done selecting
 // options. The callback function is provided with the key that was pressed,
 // which is one of the following:
 //
 //   - KeyEscape: Abort selection.
 //   - KeyTab: Move to the next field.
 //   - KeyBacktab: Move to the previous field.
 func (d *DropDown) SetDoneFunc(handler func(key tcell.Key)) *DropDown {
 	d.done = handler
 	return d
 }
 
 // SetFinishedFunc sets a callback invoked when the user leaves this form item.
 func (d *DropDown) SetFinishedFunc(handler func(key tcell.Key)) FormItem {
 	d.finished = handler
 	return d
 }
 
 // Draw draws this primitive onto the screen.
 func (d *DropDown) Draw(screen tcell.Screen) {
 	d.Box.DrawForSubclass(screen, d)
 
 	// Prepare.
 	x, y, width, height := d.GetInnerRect()
 	rightLimit := x + width
 	if height < 1 || rightLimit <= x {
 		return
 	}
 	useStyleTags, _ := d.list.GetUseStyleTags()
 
 	// Draw label.
 	if d.labelWidth > 0 {
 		labelWidth := d.labelWidth
 		if labelWidth > rightLimit-x {
 			labelWidth = rightLimit - x
 		}
 		printWithStyle(screen, d.label, x, y, 0, labelWidth, AlignLeft, d.labelStyle, true)
 		x += labelWidth
 	} else {
 		_, _, drawnWidth := printWithStyle(screen, d.label, x, y, 0, rightLimit-x, AlignLeft, d.labelStyle, true)
 		x += drawnWidth
 	}
 
 	// What's the longest option text?
 	maxWidth := 0
 	for _, option := range d.options {
 		str := d.optionPrefix + option.Text + d.optionSuffix
 		if !useStyleTags {
 			str = Escape(str)
 		}
 		strWidth := TaggedStringWidth(str)
 		if strWidth > maxWidth {
 			maxWidth = strWidth
 		}
 		str = d.currentOptionPrefix + option.Text + d.currentOptionSuffix
 		if !useStyleTags {
 			str = Escape(str)
 		}
 		strWidth = TaggedStringWidth(str)
 		if strWidth > maxWidth {
 			maxWidth = strWidth
 		}
 	}
 
 	// Draw selection area.
 	fieldWidth := d.fieldWidth
 	if fieldWidth == 0 {
 		fieldWidth = maxWidth
 		if d.currentOption < 0 {
 			noSelectionWidth := TaggedStringWidth(d.noSelection)
 			if noSelectionWidth > fieldWidth {
 				fieldWidth = noSelectionWidth
 			}
 		} else if d.currentOption < len(d.options) {
 			currentOptionWidth := TaggedStringWidth(d.currentOptionPrefix + d.options[d.currentOption].Text + d.currentOptionSuffix)
 			if currentOptionWidth > fieldWidth {
 				fieldWidth = currentOptionWidth
 			}
 		}
 	}
 	if rightLimit-x < fieldWidth {
 		fieldWidth = rightLimit - x
 	}
 	fieldStyle := d.fieldStyle
 	if d.disabled {
 		fieldStyle = d.disabledStyle
 	} else if d.HasFocus() && !d.open {
 		fieldStyle = d.focusedStyle
 	}
 	for index := 0; index < fieldWidth; index++ {
 		screen.SetContent(x+index, y, ' ', nil, fieldStyle)
 	}
 
 	// Draw selected text.
 	prefix := Escape(d.prefix.GetText())
 	if d.HasFocus() && d.open && len(prefix) > 0 {
 		// The drop-down is open and we have an input prefix.
 		//  Draw current option prefix first.
 		currentOptionPrefix := d.currentOptionPrefix
 		currentOptionSuffix := d.currentOptionSuffix
 		if !useStyleTags {
 			currentOptionPrefix = Escape(currentOptionPrefix)
 			currentOptionSuffix = Escape(currentOptionSuffix)
 		}
 		_, _, copWidth := printWithStyle(screen, currentOptionPrefix, x, y, 0, fieldWidth, AlignLeft, d.fieldStyle, false)
 		if copWidth < fieldWidth {
 			// Then draw the prefix.
 			_, _, prefixWidth := printWithStyle(screen, prefix, x+copWidth, y, 0, fieldWidth-copWidth, AlignLeft, d.prefixStyle, false)
 			if copWidth+prefixWidth < fieldWidth {
 				// Then the current option remainder.
 				var corWidth int
 				currentItem := d.list.GetCurrentItem()
 				if currentItem >= 0 && currentItem < len(d.options) {
 					text := d.options[currentItem].Text
 					if !useStyleTags {
 						text = Escape(text)
 					}
 					_, _, corWidth = printWithStyle(screen, text, x+copWidth+prefixWidth, y, prefixWidth, fieldWidth-copWidth-prefixWidth, AlignLeft, d.fieldStyle, false)
 				}
 				if copWidth+prefixWidth+corWidth < fieldWidth {
 					// And finally the current option suffix.
 					printWithStyle(screen, currentOptionSuffix, x+copWidth+prefixWidth+corWidth, y, 0, fieldWidth-copWidth-prefixWidth-corWidth, AlignLeft, d.fieldStyle, false)
 				}
 			}
 		}
 	} else {
 		// The drop-down is closed. Just draw the selected option.
 		text := d.noSelection
 		if d.currentOption >= 0 && d.currentOption < len(d.options) {
 			text = d.currentOptionPrefix + d.options[d.currentOption].Text + d.currentOptionSuffix
 		}
 		if !useStyleTags {
 			text = Escape(text)
 		}
 		printWithStyle(screen, text, x, y, 0, fieldWidth, AlignLeft, fieldStyle, false)
 	}
 
 	// Draw options list.
 	if d.HasFocus() && d.open {
 		lx := x
 		ly := y + 1
 		lwidth := maxWidth
 		lheight := len(d.options)
 		swidth, sheight := screen.Size()
 		// We prefer to align the left sides of the list and the main widget, but
 		// if there is no space to the right, then shift the list to the left.
 		if lx+lwidth >= swidth {
 			lx = swidth - lwidth
 			if lx < 0 {
 				lx = 0
 			}
 		}
 		// We prefer to drop down but if there is no space, maybe drop up?
 		if ly+lheight >= sheight && ly-2 > lheight-ly {
 			ly = y - lheight
 			if ly < 0 {
 				ly = 0
 			}
 		}
 		if ly+lheight >= sheight {
 			lheight = sheight - ly
 		}
 		d.list.SetRect(lx, ly, lwidth, lheight)
 		d.list.Draw(screen)
 	}
 }
 
 // InputHandler returns the handler for this primitive.
 func (d *DropDown) InputHandler() func(event *tcell.EventKey, setFocus func(p Primitive)) {
 	return d.WrapInputHandler(func(event *tcell.EventKey, setFocus func(p Primitive)) {
 		if d.disabled {
 			return
 		}
 
 		// Process key event.
 		switch key := event.Key(); key {
 		case tcell.KeyDown, tcell.KeyUp, tcell.KeyHome, tcell.KeyEnd, tcell.KeyPgDn, tcell.KeyPgUp:
 			// Open the list and forward the event to it.
 			d.openList(setFocus)
 			if handler := d.list.InputHandler(); handler != nil {
 				handler(event, setFocus)
 			}
 			d.prefix.SetText("")
 		case tcell.KeyEnter:
 			// If the list is closed, open it. Otherwise, forward the event to
 			// it.
 			if !d.open {
 				d.openList(setFocus)
 			} else if handler := d.list.InputHandler(); handler != nil {
 				handler(event, setFocus)
 			}
 		case tcell.KeyEscape, tcell.KeyTab, tcell.KeyBacktab:
 			// Done selecting.
 			if d.done != nil {
 				d.done(key)
 			}
 			if d.finished != nil {
 				d.finished(key)
 			}
 			d.closeList(setFocus)
 		default:
 			// Pass other key events to the input field.
 			if handler := d.prefix.InputHandler(); handler != nil {
 				handler(event, setFocus)
 			}
 			d.evalPrefix()
 			d.openList(setFocus)
 		}
 	})
 }
 
 // evalPrefix selects an item in the drop-down list based on the current prefix.
 func (d *DropDown) evalPrefix() {
 	prefix := strings.ToLower(d.prefix.GetText())
 	if len(prefix) == 0 {
 		return
 	}
 	useStyleTags, _ := d.list.GetUseStyleTags()
 	for index, option := range d.options {
 		text := option.Text
 		if useStyleTags {
 			text = stripTags(text)
 		}
 		if strings.HasPrefix(strings.ToLower(text), prefix) {
 			d.list.SetCurrentItem(index)
 			return
 		}
 	}
 }
 
 // openList hands control over to the embedded List primitive.
 func (d *DropDown) openList(setFocus func(Primitive)) {
 	if d.open {
 		return
 	}
 
 	d.open = true
 
 	d.list.SetSelectedFunc(func(index int, mainText, secondaryText string, shortcut rune) {
 		if d.dragging {
 			return // If we're dragging the mouse, we don't want to trigger any events.
 		}
 
 		// An option was selected. Close the list again.
 		d.currentOption = index
 		d.closeList(setFocus)
 
 		// Clear the prefix input field.
 		d.prefix.SetText("")
 
 		// Trigger "selected" event.
 		currentOption := d.options[d.currentOption]
 		if d.selected != nil {
 			d.selected(currentOption.Text, d.currentOption)
 		}
 		if currentOption.Selected != nil {
 			currentOption.Selected()
 		}
 	}).SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
 		switch key := event.Key(); key {
 		case tcell.KeyDown, tcell.KeyUp, tcell.KeyPgDn, tcell.KeyPgUp, tcell.KeyHome, tcell.KeyEnd, tcell.KeyEnter: // Basic list navigation.
 			break
 		case tcell.KeyEscape: // Abort selection.
 			d.closeList(setFocus)
 			return nil
 		default: // All other keys are passed to the input field.
 			if handler := d.prefix.InputHandler(); handler != nil {
 				handler(event, setFocus)
 			}
 			return nil
 		}
 
 		return event
 	})
 
 	setFocus(d.list)
 }
 
 // closeList closes the embedded List element by hiding it and removing focus
 // from it.
 func (d *DropDown) closeList(setFocus func(Primitive)) {
 	d.open = false
 	if d.list.HasFocus() {
 		setFocus(d)
 	}
 }
 
 // IsOpen returns true if the drop-down list is currently open.
 func (d *DropDown) IsOpen() bool {
 	return d.open
 }
 
 // Focus is called by the application when the primitive receives focus.
 func (d *DropDown) Focus(delegate func(p Primitive)) {
 	// If we're part of a form and this item is disabled, there's nothing the
 	// user can do here so we're finished.
 	if d.finished != nil && d.disabled {
 		d.finished(-1)
 		return
 	}
 
 	if d.open {
 		delegate(d.list)
 	} else {
 		d.Box.Focus(delegate)
 	}
 }
 
 // HasFocus returns whether or not this primitive has focus.
 func (d *DropDown) HasFocus() bool {
 	if d.open {
 		return d.list.HasFocus()
 	}
 	return d.Box.HasFocus()
 }
 
 // MouseHandler returns the mouse handler for this primitive.
 func (d *DropDown) MouseHandler() func(action MouseAction, event *tcell.EventMouse, setFocus func(p Primitive)) (consumed bool, capture Primitive) {
 	return d.WrapMouseHandler(func(action MouseAction, event *tcell.EventMouse, setFocus func(p Primitive)) (consumed bool, capture Primitive) {
 		if d.disabled {
 			return false, nil
 		}
 
 		// Was the mouse event in the drop-down box itself (or on its label)?
 		x, y := event.Position()
 		inRect := d.InInnerRect(x, y)
 		if !d.open && !inRect {
 			return d.InRect(x, y), nil // No, and it's not expanded either. Ignore.
 		}
 
 		// As long as the drop-down is open, we capture all mouse events.
 		if d.open {
 			capture = d
 		}
 
 		switch action {
 		case MouseLeftDown:
 			consumed = d.open || inRect
 			capture = d
 			if !d.open {
 				d.openList(setFocus)
 				d.dragging = true
 			} else if consumed, _ := d.list.MouseHandler()(MouseLeftClick, event, setFocus); !consumed {
 				d.closeList(setFocus) // Close drop-down if clicked outside of it.
 			}
 		case MouseMove:
 			if d.dragging {
 				// We pretend it's a left click so we can see the selection during
 				// dragging. Because we don't act upon it, it's not a problem.
 				d.list.MouseHandler()(MouseLeftClick, event, setFocus)
 				consumed = true
 			}
 		case MouseLeftUp:
 			if d.dragging {
 				d.dragging = false
 				d.list.MouseHandler()(MouseLeftClick, event, setFocus)
 				consumed = true
 			}
 		}
 
 		return
 	})
 }
 
 // PasteHandler returns the handler for this primitive.
 func (d *DropDown) PasteHandler() func(pastedText string, setFocus func(p Primitive)) {
 	return d.WrapPasteHandler(func(pastedText string, setFocus func(p Primitive)) {
 		if !d.open || d.disabled {
 			return
 		}
 
 		// Strip any newline characters (simple version).
 		pastedText = regexp.MustCompile(`\r?\n`).ReplaceAllString(pastedText, "")
 
 		// Forward the pasted text to the input field.
 		d.prefix.PasteHandler()(pastedText, setFocus)
 	})
 }