pyqttoolkit 0.9.1__py3-none-any.whl

pyqttoolkit/views/combo_box.py

@@ -0,0 +1,101 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+""":mod:`combo_box`
+Defines the ComboBox class
+"""
+from enum import Enum
+
+from PyQt5.QtWidgets import QComboBox
+from PyQt5.QtCore import Qt, pyqtSignal
+
+from pyqttoolkit.properties import AutoProperty
+from pyqttoolkit.models.roles import DataRole
+from pyqttoolkit.views.styleable import make_styleable
+
+class ComboBox(QComboBox):
+    def __init__(self, parent, padding=20):
+        QComboBox.__init__(self, parent)
+        self.setMaxVisibleItems(20)
+        self.setMinimumWidth(50)
+        self.setSizeAdjustPolicy(QComboBox.AdjustToContents)
+        self.view().setTextElideMode(Qt.ElideNone)
+        self._padding = padding
+    
+    def setModel(self, value):
+        QComboBox.setModel(self, value)
+        self._update_minimum_width()
+        value.dataChanged.connect(self._update_minimum_width)
+    
+    def _update_minimum_width(self):
+        width = self.minimumWidth()
+        if self.model():
+            for i in range(self.model().rowCount()):
+                index = self.model().createIndex(i, 0)
+                display_text = self.model().data(index, Qt.DisplayRole)
+                width = max(width, self.fontMetrics().width(display_text))
+            self.view().setMinimumWidth(width + self._padding)
+
+ComboBox = make_styleable(ComboBox)
+
+def typed_bindable_combo_box(type_):
+    class TypedBindableComboBox(ComboBox):
+        def __init__(self, parent):
+            ComboBox.__init__(self, parent)
+
+            self.currentIndexChanged.connect(self._handle_index_changed)
+            self.valueChanged.connect(self._update_index)
+        
+        valueChanged = pyqtSignal(type_)
+
+        value = AutoProperty(type_)
+
+        def setModel(self, value):
+            super().setModel(value)
+            if hasattr(value, 'dataChanged'):
+                value.dataChanged.connect(self._handle_data_changed)
+        
+        def _handle_data_changed(self):
+            self._update_index(self.value)
+            self._handle_index_changed(self.currentIndex())
+
+        def _handle_index_changed(self, index):
+            if 0 <= index < self.model().rowCount():
+                model_index = self.model().createIndex(index, 0)
+                self.value = self._get_data_value(model_index)
+
+        def _update_index(self, value):
+            index = self._get_index(value)
+            index = index if index is not None else -1
+            if -1 <= index < self.model().rowCount():
+                self.setCurrentIndex(index)
+
+        
+        def _get_index(self, value):
+            for i in range(self.model().rowCount()):
+                model_index = self.model().createIndex(i, 0)
+                if self._get_data_value(model_index) == value:
+                    return i
+            return None
+
+        def _get_data_value(self, model_index):
+            value = self.model().data(model_index, DataRole)
+            value = value if value is not None else self.model().data(model_index, Qt.DisplayRole)
+            return value if not isinstance(value, Enum) else value.name
+    
+    return make_styleable(TypedBindableComboBox)
+
+BindableComboBox = typed_bindable_combo_box(str)

pyqttoolkit/views/count_selector.py

@@ -0,0 +1,59 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+from PyQt5.QtCore import pyqtSignal, Qt
+from PyQt5.QtWidgets import QWidget, QHBoxLayout, QScrollBar, QLineEdit
+from PyQt5.QtGui import QIntValidator
+
+class CountSelectorWidget(QWidget):
+    def __init__(self, parent, minimum, maximum, initial=0):
+        QWidget.__init__(self, parent)
+
+        self._slider = QScrollBar(Qt.Horizontal, self)
+        self._slider.setMinimum(minimum)
+        self._slider.setMaximum(maximum)
+        self._slider.setSingleStep(1)
+        # self._slider.setTickInterval(1)
+
+        self._linedit = QLineEdit(self)
+        self._linedit.setValidator(QIntValidator(minimum, maximum, self))
+        self._linedit.setMinimumWidth(20)
+
+        self._layout = QHBoxLayout(self)
+        self._layout.setContentsMargins(0, 0, 0, 0)
+        self._layout.addWidget(self._slider, 4)
+        self._layout.addWidget(self._linedit, 1)
+
+        self._slider.valueChanged.connect(self._update_value)
+        self._linedit.textChanged.connect(self._update_value)
+        self._update_value(initial)
+    
+    valueChanged = pyqtSignal(int)
+    
+    def _update_value(self, value):
+        value = int(value) if value else 0
+        self.value = value
+        self.valueChanged.emit(value)
+    
+    @property
+    def value(self):
+        return self._slider.value()
+    
+    @value.setter
+    def value(self, value):
+        if self._slider.value() != value:
+            self._slider.setValue(value)
+        self._linedit.setText(str(value))

pyqttoolkit/views/datetime.py

@@ -0,0 +1,111 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+""":mod:`datetime`
+Defines the DateTimeEdit class
+"""
+from enum import Enum
+
+from PyQt5.QtCore import QDateTime, QTime, pyqtSignal
+from PyQt5.QtWidgets import QDateTimeEdit
+
+from pyqttoolkit.properties import auto_property, AutoProperty
+
+from .styleable import make_styleable
+
+class DateTimeEdit(QDateTimeEdit):
+    class Limit(Enum):
+        min = 0
+        max = 1
+
+    def __init__(self, parent, default=Limit.min, calendar_popup=True):
+        QDateTimeEdit.__init__(self, parent)
+        self.setDisplayFormat('dd-MMM-yyyy hh:mm')
+        self.setButtonSymbols(QDateTimeEdit.NoButtons)
+        self._min_date = self._max_date = None
+        self._start_date = self._end_date = None
+        self.isLimit = False
+        self._default = default
+        self.isLimitChanged.connect(self._handle_is_limit_changed)
+        self.editingFinished.connect(self._handle_date_time_editing_finished)
+        self.setCalendarPopup(calendar_popup)
+        if calendar_popup:
+            self.calendarWidget().clicked.connect(self._handle_date_changed_from_calendar)
+
+    valueChanged = pyqtSignal(QDateTime)
+    isLimitChanged = pyqtSignal(bool)
+
+    isLimit = AutoProperty(bool)
+    
+    def focusOutEvent(self, event=None):
+        if self._start_date and self.dateTime() < self._start_date:
+            self.setDateTime(self._start_date)
+        elif self._min_date and self.dateTime() < self._min_date:
+            self.setDateTime(self._min_date)
+        elif self._end_date and self.dateTime() > self._end_date:
+            self.setDateTime(self._end_date)
+        elif self._max_date and self.dateTime() > self._max_date:
+            self.setDateTime(self._max_date)
+        return event and QDateTimeEdit.focusOutEvent(self, event)
+    
+    def setDateTimeRange(self, start_date, end_date):
+        self._start_date = start_date
+        self._end_date = end_date
+    
+    def setMinimumDateTime(self, min_date):
+        self._min_date = min_date
+        super().setMinimumDateTime(min_date)
+    
+    def setMaximumDateTime(self, max_date):
+        self._max_date = max_date
+        super().setMaximumDateTime(max_date)
+    
+    @auto_property(QDateTime)
+    def value(self):
+        return QDateTime() if self.isLimit else self.dateTime()
+
+    @value.setter
+    def value(self, value):
+        value = value or QDateTime()
+        if not value.isValid() and self._start_date is not None and self._end_date is not None:
+            date_time = self._start_date if self._default == self.Limit.min else self._end_date
+            is_limit = True
+        else:
+            date_time = value
+            is_limit = False
+        if self.dateTime() != date_time:
+            self.setDateTime(date_time)
+        self.isLimit = is_limit
+        self.valueChanged.emit(value)
+
+    def reset(self):
+        self.value = QDateTime()
+    
+    def _handle_is_limit_changed(self, is_limit):
+        stylesheet = 'DateTimeEdit {font: italic}' if is_limit else 'DateTimeEdit {font: normal}'
+        self.setStyleSheet(stylesheet)
+    
+    def _handle_date_time_editing_finished(self):
+        value = self.dateTime()
+        if value is not None or (isinstance(value, QDateTime) and value.isValid()):
+            self.isLimit = False
+        self.valueChanged.emit(self.value)
+        self.focusOutEvent()
+
+    def _handle_date_changed_from_calendar(self, value):
+        self.value = QDateTime(value, QTime(0, 0))
+
+DateTimeEdit = make_styleable(DateTimeEdit)

pyqttoolkit/views/datetime_range_selector.py

@@ -0,0 +1,231 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+""":mod:`datetime_range_selector`
+Defines the DatetimeRangeSelectorWidget
+"""
+import weakref
+
+from PyQt5.QtCore import pyqtSignal, QDateTime, QSize
+from PyQt5.QtWidgets import QGridLayout, QSizePolicy, QMenu, QAction, QPushButton
+
+from datetime import timedelta, datetime
+from typing import Optional, Tuple
+
+from pyqttoolkit.properties import auto_property, bind, unbind
+from pyqttoolkit.datetime.qdatetime import step_qdatetime
+from pyqttoolkit.services.link_manager import IncompatibleWidgets
+from .linkable import LinkableWidget
+from .datetime import DateTimeEdit
+from .icon_button import IconButton
+
+class DatetimeRangeSelectorWidget(LinkableWidget):
+    """class::DatetimeRangeSelectorWidget
+    Widget to select a datetime range
+    """
+    def __init__(self, parent, paging=False, link_manager=None, reset_enabled=True, link_type=None,
+                    update_limits_on_value_change: bool = True,
+                    default_limits: Optional[Tuple[datetime, datetime]]=None,
+                    set_to_limit_buttons: bool = False):
+        LinkableWidget.__init__(self, parent, link_manager, link_type)
+        self._date_range_start = self._date_range_end = None
+        self._interval = None
+        self._update_limits_on_value_change = update_limits_on_value_change
+        
+        if paging:
+            self._back_one = IconButton('left.svg', self.tr('Scroll Left'), self, QSize(8, 30))
+            self._back_one.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding)
+            self._back_one.clicked.connect(self._step(-1))
+        self._from_selector = DateTimeEdit(self, DateTimeEdit.Limit.min)
+        self._to_selector = DateTimeEdit(self, DateTimeEdit.Limit.max)
+        if default_limits:
+            self._from_selector.setDateTimeRange(*default_limits)
+            self._to_selector.setDateTimeRange(*default_limits)
+        if paging:
+            self._forward_one = IconButton('right.svg', self.tr('Scroll Right'), self, QSize(8, 30))
+            self._forward_one.clicked.connect(self._step(1))
+            self._forward_one.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding)
+
+        self._layout = QGridLayout(self)
+        self._layout.setContentsMargins(0, 0, 0, 0)
+        self._layout.addWidget(self._from_selector, 0, 1)
+        self._layout.addWidget(self._to_selector, 1, 1)
+
+        if paging:
+            self._layout.addWidget(self._back_one, 0, 0, 2, 1)
+            self._layout.addWidget(self._forward_one, 0, 2, 2, 1)
+
+        if set_to_limit_buttons:
+            self._set_to_start = QPushButton(self.tr('Set to Start'), self)
+            self._set_to_start.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
+            self._set_to_start.setFixedWidth(65)
+            self._set_to_end = QPushButton(self.tr('Set to End'), self)
+            self._set_to_end.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
+            self._set_to_end.setFixedWidth(65)
+
+            self._layout.addWidget(self._set_to_start, 0, 2)
+            self._layout.addWidget(self._set_to_end, 1, 2)
+
+            def _handle_set_to_limit_clicked(widget, prop):
+                view_ref = weakref.ref(self)
+                def _():
+                    view = view_ref()
+                    if view:
+                        widget.reset()
+                        prop.__get__(view).emit(widget.value)
+                return _
+
+            self._set_to_start.clicked.connect(
+                _handle_set_to_limit_clicked(
+                    self._from_selector, DatetimeRangeSelectorWidget.dateFromChanged))
+            self._set_to_end.clicked.connect(
+                _handle_set_to_limit_clicked(
+                    self._to_selector, DatetimeRangeSelectorWidget.dateToChanged))
+
+        self._from_selector.editingFinished.connect(self._date_from_editing_finished)
+        self._to_selector.editingFinished.connect(self._date_to_editing_finished)
+
+        self._menu = QMenu(self)
+        self._reset = QAction(self.tr('Reset'), self)
+        self._reset.triggered.connect(self._handle_reset)
+        self._menu.addAction(self._reset)
+        self._reset_enabled = reset_enabled
+
+    dateFromChanged = pyqtSignal(QDateTime)
+    dateToChanged = pyqtSignal(QDateTime)
+    datesChanged = pyqtSignal(QDateTime, QDateTime)
+
+    @property
+    def date_from_selector(self):
+        return self._from_selector
+
+    @property
+    def date_to_selector(self):
+        return self._to_selector
+
+    def contextMenuEvent(self, event):
+        if self._reset_enabled:
+            self._menu.exec_(event.globalPos())
+        
+    def _handle_reset(self):
+        self.setDates(self._date_range_start, self._date_range_end)
+
+    def link(self, other):
+        if not isinstance(other, DatetimeRangeSelectorWidget):
+            raise IncompatibleWidgets()
+        bind(self, other, 'dateFrom')
+        bind(self, other, 'dateTo')
+        self.datesChanged.connect(other.setDates)
+        other.datesChanged.connect(self.setDates)
+    
+    def unlink(self, other):
+        unbind(self, other, 'dateFrom')
+        unbind(self, other, 'dateTo')
+        self.datesChanged.disconnect(other.setDates)
+        other.datesChanged.disconnect(self.setDates)
+
+    def setDates(self, dateFrom, dateTo):
+        if self.dateFrom != dateFrom or self.dateTo != dateTo:
+            signals_blocked = self.blockSignals(True)
+            self.dateFrom = dateFrom
+            self.dateTo = dateTo
+            self.blockSignals(signals_blocked)
+            self.datesChanged.emit(dateFrom, dateTo)
+
+    def setDateRange(self, start_date, end_date):
+        """function::setDateRange(self, start_data, end_date)
+        Set the date range for this widget
+        """
+        self._from_selector.setDateTimeRange(start_date, end_date)
+        self._to_selector.setDateTimeRange(start_date, end_date)
+        self._date_range_start = start_date
+        self._date_range_end = end_date
+    
+    def setInterval(self, interval):
+        self._interval = interval
+
+        if interval < timedelta(seconds=1):
+            display_format = 'dd-MMM-yyyy hh:mm:ss.zz'
+        elif interval < timedelta(minutes=1):
+            display_format = 'dd-MMM-yyyy hh:mm:ss'
+        else:
+            display_format = 'dd-MMM-yyyy hh:mm'
+
+        for selector in self._from_selector, self._to_selector:
+            selector.setDisplayFormat(display_format)
+
+    @auto_property(QDateTime)
+    def dateFrom(self):
+        """function::dateFrom(self)
+        Auto property accessor for dateFrom
+        """
+        return self._from_selector.dateTime()
+
+    @dateFrom.setter
+    def dateFrom(self, value):
+        """function::dateFrom(self, value)
+        Auto property setter for dateFrom
+        """
+        value = value or QDateTime()
+        if self._from_selector.dateTime() != value:
+            self._from_selector.setDateTime(value)
+            self.dateFromChanged.emit(value)
+
+    @auto_property(QDateTime)
+    def dateTo(self):
+        """function::dateTo(self)
+        Auto property accessor for dateTo
+        """
+        return self._to_selector.dateTime()
+
+    @dateTo.setter
+    def dateTo(self, value):
+        """function::dateTo(self, value)
+        Auto property setter for dateTo
+        """
+        value = value or QDateTime()
+        if self._to_selector.dateTime() != value:
+            self._to_selector.setDateTime(value)
+            self.dateToChanged.emit(value)
+
+    def sizeHint(self):
+        """function::sizeHint(self)
+        Override the QWidget.sizeHint method to provide a size hint
+        """
+        return self._layout.sizeHint()
+
+    def _date_from_editing_finished(self):
+        value = self._from_selector.dateTime()
+        if self._update_limits_on_value_change:
+            self._to_selector.setMinimumDateTime(value)
+        self.dateFromChanged.emit(value)
+
+    def _date_to_editing_finished(self):
+        value = self._to_selector.dateTime()
+        if self._update_limits_on_value_change:
+            self._from_selector.setMaximumDateTime(value)
+        self.dateToChanged.emit(value)
+    
+    def _step(self, fraction):
+        def _():
+            signals_blocked = self.blockSignals(True)
+            step_qdatetime(self, fraction, self._interval, self._date_range_start, self._date_range_end)
+            self.blockSignals(signals_blocked)
+            self.datesChanged.emit(self.dateFrom, self.dateTo)
+        return _
+
+    def step(self, fraction):
+        return self._step(fraction)()

pyqttoolkit/views/default_text_line_edit.py

@@ -0,0 +1,50 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+from PyQt5.QtCore import pyqtSignal
+#pylint: enable=no-name-in-module
+
+from pyqttoolkit.properties import AutoProperty
+from pyqttoolkit.views import LineEdit
+
+class DefaultTextLineEdit(LineEdit):
+    def __init__(self, parent):
+        LineEdit.__init__(self, parent)
+        self.editComplete.connect(self._update_name)
+        self.nameChanged.connect(self._handle_name_changed)
+        self.defaultNameChanged.connect(self._handle_name_changed)
+    
+    defaultNameChanged = pyqtSignal(str)
+    nameChanged = pyqtSignal(str)
+
+    defaultName = AutoProperty(str)
+    name = AutoProperty(str)
+
+    def focusInEvent(self, event):
+        self._handle_interaction()
+        LineEdit.focusInEvent(self, event)
+
+    def _update_name(self, value):
+        self.name = value
+
+    def _handle_name_changed(self):
+        self.setText(self.name)
+        if not self.name:
+            self.setPlaceholderText(self.defaultName)
+
+    def _handle_interaction(self):
+        if not self.name:
+            self.name = self.defaultName

pyqttoolkit/views/delegates.py

@@ -0,0 +1,117 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+from enum import Enum
+
+from PyQt5.QtCore import QStringListModel, Qt, QDateTime
+from PyQt5.QtWidgets import QStyledItemDelegate, QTableView, QWidget, QHBoxLayout, QPushButton
+
+from pyqttoolkit.models.roles import DataRole, EditorAuxDataRole
+from pyqttoolkit.views import BindableComboBox, DateTimeEdit, BulkValueSelectorWidget, Popup
+
+class ComboBoxItemDelegate(QStyledItemDelegate):
+    def __init__(self, parent):
+        super().__init__(parent)
+    
+    def setComboBoxModel(self, model):
+        self._combo_box_model = model
+
+    def createEditor(self, parent, option, index):
+        combo_box = BindableComboBox(parent)
+        combo_box.setModel(self._combo_box_model)
+        combo_box.move(parent.pos())
+        value = self.parent().model().data(index, DataRole)
+        if isinstance(self.parent(), QTableView):
+            combo_box.setFixedWidth(self.parent().columnWidth(index.column()) * self.parent().columnSpan(index.row(), index.column()))
+            combo_box.setFixedHeight(self.parent().rowHeight(index.row()) * self.parent().rowSpan(index.row(), index.column()))
+        else:
+            combo_box.setFixedWidth(self.parent().columnWidth(index.column()))
+            combo_box.setFixedHeight(self.parent().rowHeight(index))
+        if isinstance(value, Enum):
+            value = value.name
+        combo_box.value = value
+        combo_box.currentIndexChanged.connect(self.closeEditor(combo_box))
+        return combo_box
+    
+    def setEditorData(self, editor, index):
+        editor.showPopup()
+
+    def closeEditor(self, control):
+        def _handler():
+            self.parent().commitData(control)
+            self.parent().closeEditor(control, QStyledItemDelegate.NoHint)
+        return _handler
+
+class DateTimeItemDelegate(QStyledItemDelegate):
+    def __init__(self, parent):
+        super().__init__(parent)
+        self._popup = None
+    
+    def createEditor(self, parent, option, index):
+        date_range, default = self.parent().model().data(index, EditorAuxDataRole)
+        editor = DateTimeEdit(parent, default)
+        editor.setDateTimeRange(*date_range)
+        value = self.parent().model().data(index, DataRole)
+        editor.value = QDateTime(value) if value is not None else None
+        if default is not None:
+            reset_button_text = self.tr('Set to Start') if default == DateTimeEdit.Limit.min else self.tr('Set to End')
+            start_end_buttons = QWidget(parent)
+            start_end_buttons_layout = QHBoxLayout(start_end_buttons)
+            start_end_buttons_layout.setContentsMargins(0, 0, 0, 0)
+            button = QPushButton(reset_button_text, start_end_buttons)
+            button.clicked.connect(editor.reset)
+            start_end_buttons_layout.addWidget(button)
+            self._popup = Popup(editor, start_end_buttons)
+
+        return editor
+    
+    def setEditorData(self, editor, index):
+        if self._popup is not None:
+            cell_rect = editor.rect()
+            self._popup.popupAtPosition(editor, cell_rect.bottomLeft())
+        return super().setEditorData(editor, index)
+    
+    def setModelData(self, editor, model, index):
+        if self._popup is not None:
+            self._popup.close()
+            self._popup = None
+        model.setData(index, editor.value, Qt.EditRole)
+
+
+class BulkValueSelectorItemDelegate(QStyledItemDelegate):
+    def __init__(self, parent):
+        super().__init__(parent)
+    
+    def createEditor(self, parent, option, index):
+        editor = BulkValueSelectorWidget(parent)
+        editor.setFixedHeight(int(self.parent().height() * 0.8))
+        editor.setFixedWidth(200)
+        editor.values = QStringListModel(self.parent().model().data(index, EditorAuxDataRole), self)
+        editor.selectedValues = self.parent().model().data(index, DataRole)
+        popup = Popup(parent, editor)
+        editor.dataCommitted.connect(self.closePopup(popup))
+        return popup
+    
+    def setEditorData(self, editor, index):
+        editor.popupAtPosition(self.parent(), self.parent().visualRect(index))
+    
+    def setModelData(self, editor, model, index):
+        model.setData(index, sorted(editor.contents.selectedValues))
+
+    def closePopup(self, popup):
+        def _handler(selected_values):
+            self.parent().closeEditor(popup, QStyledItemDelegate.NoHint)
+        return _handler