def _createToolTipText(self, isOwn, toolTip, messageTime, recvTime):
        if toolTip:
            toolTip += u"\n"
        else:
            toolTip = u""

        toolTip += u"Sent: " + formatTime(localtime(messageTime))
        if recvTime:
            if isOwn:
                toolTip += ",\nDelivered: " + formatTime(localtime(recvTime))
            else:
                toolTip += ",\nReceived: " + formatTime(localtime(recvTime))
        return toolTip
    def __init__(self, partnerID, rows):
        super(ChatHistoryModel, self).__init__()

        self.setHorizontalHeaderLabels([u"Sender", u"Send Time", u"Text"])
        
        if get_peers() is not None:
            partnerName = get_peers().getDisplayedPeerName(pID=partnerID)
        else:
            partnerName = partnerID
        for row in rows:
            # sender
            item1 = self._createItem()
            isOwn = row[ChatMessagesStorage.MSG_IS_OWN_MESSAGE_COL] != 0
            if isOwn:
                item1.setData(QVariant(u"You"), Qt.DisplayRole)
            else:
                item1.setData(partnerName, Qt.DisplayRole)
                
            # time
            item2 = self._createItem()
            mTime = localtime(row[ChatMessagesStorage.MSG_TIME_COL])
            item2.setData(QVariant(formatTime(mTime)), Qt.DisplayRole)
            
            # message
            item3 = self._createItem(True)
            item3.setData(QVariant(row[ChatMessagesStorage.MSG_TEXT_COL]), Qt.DisplayRole)
            item3.setData(QVariant(isOwn), ChatMessagesModel.OWN_MESSAGE_ROLE)
            
            self.appendRow([item1, item2, item3])
 def displayImage(self, cat, picID, picRow, hasPrev, hasNext):
     cat = convert_string(cat)
     picURL = convert_string(picRow[RemotePicturesStorage.PIC_URL_COL])
     picFile = convert_string(picRow[RemotePicturesStorage.PIC_FILE_COL])
     picDesc = convert_string(picRow[RemotePicturesStorage.PIC_DESC_COL])
     if picDesc is None:
         picDesc = u""
     picSender = convert_string(picRow[RemotePicturesStorage.PIC_SENDER_COL])
     picTime = picRow[RemotePicturesStorage.PIC_ADDED_COL]
     
     self.currentCategory = cat
     self.categoryLabel.setText(cat)
     
     self.curPicIndex = picID
     if picFile and os.path.exists(picFile):
         self.imageLabel.setImage(picFile)
     elif picURL:
         self.imageLabel.setURL(picURL)
     else:
         self.logger.warning("No image source specified")
         self.imageLabel.displayFallbackPic()
     
     if picSender:
         self.imageLabel.setToolTip(u"Sent to you by %s,\nSent %s" % (get_peers().getDisplayedPeerName(pID=picSender),
                                                                      formatTime(localtime(picTime))))
     else:
         self.imageLabel.setToolTip(u"")
         
     self.descriptionLabel.setText(picDesc)
     self.setCurrentIndex(1)
     
     self.prevButton.setEnabled(hasPrev)
     self.nextButton.setEnabled(hasNext)
     
     self._categoryOpened.emit()
 def _paintTime(self, painter, option, modelIndex):
     if modelIndex.column() != 1:
         return
     # total rect for us to paint in
     textRect = option.rect
     
     rtime, _ok = modelIndex.data(Qt.DisplayRole).toDouble()
     timeString = formatTime(localtime(rtime))
     
     painter.save()
     painter.setRenderHint(QPainter.Antialiasing)
     painter.translate(textRect.topLeft())
     painter.setFont(self._timeFont)
     textWidth = painter.fontMetrics().width(timeString)
     painter.drawText((textRect.size().width() - textWidth) / 2, 13, timeString)
     painter.restore()
 def data(self, index, role=Qt.DisplayRole):
     if role == Qt.DisplayRole:
         message = self._getMessage(index.row())
         if index.column() == self.TIME_COL:
             # time
             mTime = message[0]
             return QVariant(formatTime(mTime))
         elif index.column() == self.SENDER_COL:
             # sender
             peerID = message[1]
             # look in peers first, it's always up to date
             name = get_peers().getDisplayedPeerName(pID=peerID, lock=False)
             if not name:
                 # look up in stored peer names
                 name = get_peers().getDisplayedPeerName(pID=peerID) 
                 if not name:
                     # check if peerID is IP (from old version)
                     name = get_peers().getDisplayedPeerName(pIP=peerID, lock=False)
                     if not name:
                         name = peerID
             return QVariant(name)
         else:
             return QVariant(message[2])
     elif role == Qt.SizeHintRole:
         return QSize(0, 20)
     elif role == self.SORT_ROLE:
         if index.column() == self.TIME_COL:
             mTime = self._getMessage(index.row())[0]
             return QVariant(time.mktime(mTime))
         else:
             # return display role as fallback
             return self.data(index)
     elif role == Qt.ToolTipRole:
         if index.column() == self.MESSAGE_COL:
             return self.data(index, Qt.DisplayRole)
     return QVariant()