# -*- coding: utf-8 -*- """ Copyright (c) 2015, Jairus Martin. Distributed under the terms of the MIT License. The full license is in the file COPYING.txt, distributed with this software. Created on Aug 20, 2015 """ from atom.api import Instance, Int from enaml.application import timed_call from enaml.qt.q_resource_helpers import get_cached_qcolor, get_cached_qicon from enaml.qt.qt_control import QtControl from qtpy.QtCore import QAbstractItemModel, QItemSelectionModel, Qt from qtpy.QtWidgets import QAbstractItemView from enamlx.qt.qt_abstract_item import TEXT_H_ALIGNMENTS, TEXT_V_ALIGNMENTS from enamlx.widgets.abstract_item_view import ProxyAbstractItemView SELECTION_MODES = { "extended": QAbstractItemView.ExtendedSelection, "single": QAbstractItemView.SingleSelection, "contiguous": QAbstractItemView.ContiguousSelection, "multi": QAbstractItemView.MultiSelection, "none": QAbstractItemView.NoSelection, } SELECTION_BEHAVIORS = { "items": QAbstractItemView.SelectItems, "rows": QAbstractItemView.SelectRows, "columns": QAbstractItemView.SelectColumns, } class QAbstractAtomItemModel(object): """A mixin for an ItemModel""" declaration = None def setDeclaration(self, declaration): """Set the declaration this model will use for rendering the the headers. """ assert isinstance(declaration.proxy, ProxyAbstractItemView), ( "The model declaration must be a QtAbstractItemView subclass. " "Got {}".format(declaration) ) self.declaration = declaration def data(self, index, role): """Retrieve the data for the item at the given index""" item = self.itemAt(index) if not item: return None d = item.declaration if role == Qt.DisplayRole: return d.text elif role == Qt.ToolTipRole: return d.tool_tip elif role == Qt.CheckStateRole and d.checkable: return d.checked and Qt.Checked or Qt.Unchecked elif role == Qt.DecorationRole and d.icon: return get_cached_qicon(d.icon) elif role == Qt.EditRole and d.editable: return d.text elif role == Qt.StatusTipRole: return d.status_tip elif role == Qt.TextAlignmentRole: h, v = d.text_alignment return TEXT_H_ALIGNMENTS[h] | TEXT_V_ALIGNMENTS[v] elif role == Qt.ForegroundRole and d.foreground: return get_cached_qcolor(d.foreground) elif role == Qt.BackgroundRole and d.background: return get_cached_qcolor(d.background) # elif role == Qt.SizeHintRole and d.minimum_size: # return d.minimum_size return None def itemAt(self, index): """Get the item at the given model index. Returns ------- item: """ raise NotImplementedError def flags(self, index): item = self.itemAt(index) if not item: return Qt.NoItemFlags d = item.declaration flags = Qt.ItemIsEnabled if d.editable: flags |= Qt.ItemIsEditable if d.checkable: flags |= Qt.ItemIsUserCheckable if d.selectable: flags |= Qt.ItemIsSelectable return flags def setData(self, index, value, role=Qt.EditRole): """Set the data for the item at the given index to the given value.""" item = self.itemAt(index) if not item: return False d = item.declaration if role == Qt.CheckStateRole: checked = Qt.CheckState(value) == Qt.CheckState.Checked if checked != d.checked: d.checked = checked d.toggled(checked) return True elif role == Qt.EditRole: if value != d.text: d.text = value return True return super(QAbstractAtomItemModel, self).setData(index, value, role) def headerData(self, index, orientation, role): """QHeaderView respects the following item data roles: TextAlignmentRole, DisplayRole, FontRole, DecorationRole, ForegroundRole, BackgroundRole. """ d = self.declaration if orientation == Qt.Horizontal and role == Qt.DisplayRole: try: return d.horizontal_headers[index] if d.horizontal_headers else index except IndexError: return index elif orientation == Qt.Vertical and role == Qt.DisplayRole: try: return d.vertical_headers[index] if d.vertical_headers else index except IndexError: return index return None def clear(self): self.beginResetModel() d = self.declaration if d.items: d.items = [] self.endResetModel() class QtAbstractItemView(QtControl, ProxyAbstractItemView): #: Reference to the view widget = Instance(QAbstractItemView) #: View model model = Instance(QAbstractItemModel) #: Hold reference to selection model to PySide segfault selection_model = Instance(QItemSelectionModel) #: Refreshing the view on every update makes it really slow #: So if we defer refreshing until everything is added it's fast :) _pending_timeout = Int(100) _pending_view_refreshes = Int(0) _pending_row_refreshes = Int(0) _pending_column_refreshes = Int(0) def init_widget(self): super(QtAbstractItemView, self).init_widget() self.init_model() d = self.declaration #: Enable context menus self.widget.setContextMenuPolicy(Qt.CustomContextMenu) self.set_selection_mode(d.selection_mode) self.set_selection_behavior(d.selection_behavior) self.set_alternating_row_colors(d.alternating_row_colors) self.set_word_wrap(d.word_wrap) self.set_resize_mode(d.resize_mode) self.set_show_vertical_header(d.show_vertical_header) self.set_show_horizontal_header(d.show_horizontal_header) self.set_horizontal_stretch(d.horizontal_stretch) self.set_vertical_stretch(d.vertical_stretch) if d.cell_padding: self.set_cell_padding(d.cell_padding) if d.vertical_minimum_section_size: self.set_vertical_minimum_section_size(d.vertical_minimum_section_size) if d.vertical_sizes: self.set_vertical_sizes(d.vertical_sizes) if d.horizontal_minimum_section_size: self.set_horizontal_minimum_section_size(d.horizontal_minimum_section_size) if d.horizontal_sizes: self.set_horizontal_sizes(d.horizontal_sizes) self.init_signals() def init_model(self): raise NotImplementedError def init_signals(self): """Connect signals""" self.widget.activated.connect(self.on_item_activated) self.widget.clicked.connect(self.on_item_clicked) self.widget.doubleClicked.connect(self.on_item_double_clicked) self.widget.entered.connect(self.on_item_entered) self.widget.pressed.connect(self.on_item_pressed) self.widget.customContextMenuRequested.connect( self.on_custom_context_menu_requested ) self.selection_model = self.widget.selectionModel() self.selection_model.selectionChanged.connect(self.on_selection_changed) self.widget.horizontalScrollBar().valueChanged.connect( self.on_horizontal_scrollbar_moved ) self.widget.verticalScrollBar().valueChanged.connect( self.on_vertical_scrollbar_moved ) def item_at(self, index): return self.model.itemAt(index) def destroy(self): """Make sure all the table widgets are destroyed first.""" self.model.clear() super(QtAbstractItemView, self).destroy() # ------------------------------------------------------------------------- # Widget Setters # ------------------------------------------------------------------------- def set_selection_mode(self, mode): self.widget.setSelectionMode(SELECTION_MODES[mode]) def set_selection_behavior(self, behavior): self.widget.setSelectionBehavior(SELECTION_BEHAVIORS[behavior]) def set_scroll_to_bottom(self, enabled): if enabled: self.widget.scrollToBottom() def set_alternating_row_colors(self, enabled): self.widget.setAlternatingRowColors(enabled) def set_sortable(self, sortable): self.widget.setSortingEnabled(sortable) def set_word_wrap(self, wrap): self.widget.setWordWrap(wrap) def set_auto_resize_columns(self, enabled): if enabled: self.widget.resizeColumnsToContents() def set_visible_row(self, row): self.widget.verticalScrollBar().setValue(row) def set_visible_column(self, column): self.widget.horizontalScrollBar().setValue(column) def set_model(self, model): if isinstance(model, QAbstractAtomItemModel): model.setDeclaration(self.declaration) self.widget.setModel(model) self.model = self.widget.model() def set_items(self, items): """Defer until later so the view is only updated after all items are added. """ self.model.beginResetModel() self._pending_view_refreshes += 1 timed_call(self._pending_timeout, self._refresh_layout) self.model.endResetModel() def set_selection(self, items): pass def set_horizontal_sizes(self, sizes): header = self.widget.horizontalHeader() for i, s in enumerate(sizes): if s is not None and s >= 0: header.resizeSection(i, s) def set_vertical_sizes(self, sizes): header = self.widget.verticalHeader() for i, s in enumerate(sizes): if s is not None and s >= 0: header.resizeSection(i, s) # ------------------------------------------------------------------------- # Widget Events # ------------------------------------------------------------------------- def on_horizontal_scrollbar_moved(self, value): """When the scrollbar moves, queue a refresh of the visible columns. This makes it only update the view when needed making scrolling much smoother. """ self._pending_column_refreshes += 1 timed_call(0, self._refresh_visible_column, value) def on_vertical_scrollbar_moved(self, value): """When the scrollbar moves, queue a refresh of the visible rows. This makes it only update the view when needed making scrolling much smoother. """ self._pending_row_refreshes += 1 timed_call(0, self._refresh_visible_row, value) def on_item_activated(self, index): item = self.item_at(index) if not item: return parent = item.parent() if parent != self: parent.declaration.activated() item.declaration.activated() def on_item_clicked(self, index): item = self.item_at(index) if not item: return parent = item.parent() if parent != self: parent.declaration.clicked() item.declaration.clicked() def on_item_double_clicked(self, index): item = self.item_at(index) if not item: return parent = item.parent() if parent != self: parent.declaration.double_clicked() item.declaration.double_clicked() def on_item_pressed(self, index): item = self.item_at(index) if not item: return parent = item.parent() if parent != self: parent.declaration.pressed() item.declaration.pressed() def on_item_entered(self, index): item = self.item_at(index) if not item: return parent = item.parent() if parent != self: parent.declaration.entered() item.declaration.entered() def on_selection_changed(self, selected, deselected): selection = self.declaration.selection[:] for index in selected.indexes(): item = self.item_at(index) if not item: continue d = item.declaration selection.append(d) if not d.selected: d.selected = True d.selection_changed(d.selected) for index in deselected.indexes(): item = self.item_at(index) if not item: continue d = item.declaration try: selection.remove(d) except ValueError: pass if d.selected: d.selected = False d.selection_changed(d.selected) self.declaration.selection = selection def on_custom_context_menu_requested(self, pos): item = self.item_at(self.widget.indexAt(pos)) if not item: return if item.menu: item.menu.popup() return parent = item.parent() if parent and hasattr(parent, "menu") and parent.menu: parent.menu.popup() def on_layout_refreshed(self): pass # ------------------------------------------------------------------------- # View refresh handlers # ------------------------------------------------------------------------- def _refresh_layout(self): """This queues and batches model changes so that the layout is only refreshed after the `_pending_timeout` expires. This prevents the UI from refreshing when inserting or removing a large number of items until the operation is complete. """ self._pending_view_refreshes -= 1 if self._pending_view_refreshes == 0: try: self.model.layoutChanged.emit() self.on_layout_refreshed() except RuntimeError: # View can be destroyed before we get here return self._refresh_sizes() def _refresh_sizes(self): """Refresh column sizes when the data changes.""" pass # header = self.widget.horizontalHeader() # # for i,item in enumerate(self.items[0]): # header.setResizeMode(i,RESIZE_MODES[item.declaration.resize_mode]) # if item.declaration.width: # header.resizeSection(i,item.declaration.width) def _refresh_visible_row(self, value): """Subclasses must implement this method to refresh the content in the row with the content at the given index. Parameters ---------- value: int Index of the row that needs to be refreshed """ raise NotImplementedError def _refresh_visible_column(self, value): """Subclasses must implement this method to refresh the content in the column with the content at the given index. Parameters ---------- value: int Index of the column that needs to be refreshed """ raise NotImplementedError