def __init__(self, sourceModel, parent = None):
     """
     Constructor
     
     @param sourceModel reference to the source model (QAbstractItemModel)
     @param parent reference to the parent object (QObject)
     """
     QAbstractProxyModel.__init__(self, parent)
     
     self.__sourceRowCache = []
     self.__removingDown = False
     
     self.setSourceModel(sourceModel)
 def __init__(self, sourceModel, parent = None):
     """
     Constructor
     
     @param sourceModel reference to the source model (QAbstractItemModel)
     @param parent reference to the parent object (QObject)
     """
     QAbstractProxyModel.__init__(self, parent)
     
     self.__loaded = False
     self.__filteredRows = []
     self.__historyDict = {}
     self.__scaleTime = QDateTime()
     
     self.setSourceModel(sourceModel)
 def data(self, index, role = Qt.DisplayRole):
     """
     Public method to get data from the model.
     
     @param index index of history entry to get data for (QModelIndex)
     @param role data role (integer)
     @return history entry data (QVariant)
     """
     if role in [Qt.DisplayRole, Qt.EditRole]:
         start = index.internalId()
         if start == 0:
             offset = self.__sourceDateRow(index.row())
             if index.column() == 0:
                 idx = self.sourceModel().index(offset, 0)
                 date = idx.data(HistoryModel.DateRole).toDate()
                 if date == QDate.currentDate():
                     return QVariant(self.trUtf8("Earlier Today"))
                 return QVariant(date.toString("yyyy-MM-dd"))
             if index.column() == 1:
                 return QVariant(self.trUtf8(
                     "%n item(s)", "", self.rowCount(index.sibling(index.row(), 0))))
     
     elif role == Qt.DecorationRole:
         if index.column() == 0 and not index.parent().isValid():
             return QVariant(UI.PixmapCache.getIcon("history.png"))
     
     elif role == HistoryModel.DateRole:
         if index.column() == 0 and index.internalId() == 0:
             offset = self.__sourceDateRow(index.row())
             idx = self.sourceModel().index(offset, 0)
             return idx.data(HistoryModel.DateRole)
     
     return QAbstractProxyModel.data(self, index, role)
Beispiel #4
0
 def flags(self, index):
     flags = QAbstractProxyModel.flags(self, index)
     if self.__flatteningMode == self.InternalNodesDisabled:
         sourceIndex = self.mapToSource(index)
         sourceModel = self.sourceModel()
         if sourceModel.rowCount(sourceIndex) > 0 and \
                 flags & Qt.ItemIsEnabled:
             # Internal node, enabled in the source model, disable it
             flags ^= Qt.ItemIsEnabled
     return flags
Beispiel #5
0
    def setSourceModel(self, model):
        self.beginResetModel()

        curr_model = self.sourceModel()

        if curr_model is not None:
            curr_model.dataChanged.disconnect(self._sourceDataChanged)
            curr_model.rowsInserted.disconnect(self._sourceRowsInserted)
            curr_model.rowsRemoved.disconnect(self._sourceRowsRemoved)
            curr_model.rowsMoved.disconnect(self._sourceRowsMoved)

        QAbstractProxyModel.setSourceModel(self, model)
        self._updateRowMapping()

        model.dataChanged.connect(self._sourceDataChanged)
        model.rowsInserted.connect(self._sourceRowsInserted)
        model.rowsRemoved.connect(self._sourceRowsRemoved)
        model.rowsMoved.connect(self._sourceRowsMoved)

        self.endResetModel()
 def data(self, index, role = Qt.DisplayRole):
     """
     Public method to get data from the model.
     
     @param index index of history entry to get data for (QModelIndex)
     @param role data role (integer)
     @return history entry data (QVariant)
     """
     if role == self.FrequencyRole and index.isValid():
         return QVariant(self.__filteredRows[index.row()].frequency)
     
     return QAbstractProxyModel.data(self, index, role)
 def setSourceModel(self, sourceModel):
     """
     Public method to set the source model.
     
     @param sourceModel reference to the source model (QAbstractItemModel)
     """
     if self.sourceModel() is not None:
         self.disconnect(self.sourceModel(), 
                         SIGNAL("modelReset()"), 
                         self.__sourceReset)
         self.disconnect(self.sourceModel(), 
                         SIGNAL("layoutChanged()"), 
                         self.__sourceReset)
         self.disconnect(self.sourceModel(), 
                         SIGNAL("rowsInserted(const QModelIndex &, int, int)"), 
                         self.__sourceRowsInserted)
         self.disconnect(self.sourceModel(), 
                         SIGNAL("rowsRemoved(const QModelIndex &, int, int)"), 
                         self.__sourceRowsRemoved)
     
     QAbstractProxyModel.setSourceModel(self, sourceModel)
     
     if self.sourceModel() is not None:
         self.__loaded = False
         self.connect(self.sourceModel(), 
                      SIGNAL("modelReset()"), 
                      self.__sourceReset)
         self.connect(self.sourceModel(), 
                      SIGNAL("layoutChanged()"), 
                      self.__sourceReset)
         self.connect(self.sourceModel(), 
                      SIGNAL("rowsInserted(const QModelIndex &, int, int)"), 
                      self.__sourceRowsInserted)
         self.connect(self.sourceModel(), 
                      SIGNAL("rowsRemoved(const QModelIndex &, int, int)"), 
                      self.__sourceRowsRemoved)
     
     self.reset()
Beispiel #8
0
 def __init__(self, parent=None):
     QAbstractProxyModel.__init__(self, parent)
     self.__sourceColumn = 0
     self.__flatteningMode = 1
     self.__sourceRootIndex = QModelIndex()
Beispiel #9
0
 def setSourceModel(self, sourceModel):
     self._sourceModel = sourceModel
     QAbstractProxyModel.setSourceModel(self, sourceModel)
Beispiel #10
0
 def __init__(self, sourceModel):
     QAbstractProxyModel.__init__(self)
     self.setSourceModel(sourceModel)
     self.shown = array.array('i', xrange(sourceModel.rowCount(QModelIndex())))
     self.connect(sourceModel, SIGNAL('modelReset()'), self.reset)