def _delayedDelivery(self, otherID, msgID, recvTime, error, errorMessage): otherID = convert_string(otherID) errorMessage = convert_string(errorMessage) if otherID in self._openChats: chatWindow = self._openChats[otherID] chatWindow.getChatWidget().delayedDelivery(msgID, recvTime, error, errorMessage)
def _loadIndex(self): try: self.settings = QSettings(get_settings().get_config("remote_pictures", "index"), QSettings.NativeFormat) storedThumbnails = self.settings.value("categoryThumbnails", None) if storedThumbnails != None: storedThumbnails = storedThumbnails.toMap() for aCat in storedThumbnails: thumbnailPath = convert_string(storedThumbnails[aCat].toString()) aCat = convert_string(aCat) if aCat == u"Not Categorized": aCat = PrivacySettings.NO_CATEGORY self._addCategory(aCat, thumbnailPath) categoryPictures = self.settings.value("categoryPictures", None) if categoryPictures != None: tmpDict = categoryPictures.toMap() added = time() for aCat in tmpDict: newKey = convert_string(aCat) if newKey == u"Not Categorized": newKey = PrivacySettings.NO_CATEGORY picTupleList = tmpDict[aCat].toList() for picTuple in picTupleList: tupleList = picTuple.toList() picURL = convert_string(tupleList[0].toString()) picDesc = convert_string(tupleList[1].toString()) self.addPicture(newKey, picURL, picDesc, None, added, None, None) if not picDesc: picDesc = None except: self.logger.exception("Could not load thumbnail index.")
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 sendMessage(self, otherID, msgHTML, msgID=None, msgTime=None, isNoResend=False): otherID = convert_string(otherID) msgHTML = convert_string(msgHTML) if msgID == None: msgID = self._getNextMessageID() isResend = False else: isResend = True if isNoResend: isResend = False if msgTime == None: msgTime = time() msgDict = {u"id": msgID, u"format": u"html", u"data": msgHTML, u"time": msgTime} try: msgDictJSON = json.dumps(msgDict) except: self.logger.exception("Error serializing private message: %s", msgDict) return get_server().call("HELO_PM " + msgDictJSON, peerIDs=[otherID]) self._waitingForAck[msgID] = (otherID, time() if isResend else msgTime, msgHTML, isResend)
def _addLogMessage(self, record): self._records.append(record) msg = record.msg if not isinstance(msg, basestring): msg = unicode(msg) try: msg = convert_string(msg) % record.args except: msg = u"(Error formatting log message) " +\ convert_string(msg) +\ ', '.join(unicode(v) for v in record.args) dirname = os.path.dirname(record.pathname) source = u"%s:%d" % (os.path.join(os.path.basename(dirname), os.path.basename(record.pathname)), record.lineno) fullsource = u"%s:%d" % (record.pathname, record.lineno) component = record.name if component.startswith("lunchinator."): component = component[12:] error = 1 if record.levelno == logging.WARNING else 2 if record.levelno == logging.ERROR else 0 self._logModel.appendRow([self._createItem(strftime("%H:%M:%S", localtime(record.created)), error), self._createItem(record.levelname, error), self._createItem(component, error), self._createItem(msg, error), self._createItem(source, error, fullsource)])
def set_next_lunch_time(self, begin_time, end_time): if begin_time == None: self._next_lunch_begin, self._next_lunch_end = None, None begin_time = convert_string(begin_time) self._next_lunch_begin = self._check_lunch_time(begin_time, self._next_lunch_begin) end_time = convert_string(end_time) self._next_lunch_end = self._check_lunch_time(end_time, self._next_lunch_end)
def _checkSendInfoDict(self, pluginName, category): pluginName = convert_string(pluginName) category = convert_string(category) pi = get_plugin_manager().getPluginByName(pluginName, category) if pi != None: po = pi.plugin_object if po.extendsInfoDict(): get_server().call_info()
def _avatarChanged(self, peerID, newFile): peerID = convert_string(peerID) newFile = convert_string(newFile) if peerID == self._otherID: self.setOtherIconPath(get_peers().getPeerAvatarFile(pID=peerID)) if peerID == get_settings().get_ID(): self.setOwnIconPath(get_peers().getPeerAvatarFile(pID=peerID))
def _pluginDeactivated(self, pluginName, category): pluginName = convert_string(pluginName) category = convert_string(category) pi = get_plugin_manager().getPluginByName(pluginName, category) if pi: with self._lock: removed = self._removeActionsForPlugin(pi) if removed: get_notification_center().emitPeerActionsRemoved(removed)
def _pluginActivated(self, pluginName, category): pluginName = convert_string(pluginName) category = convert_string(category) pi = get_plugin_manager().getPluginByName(pluginName, category) if pi: with self._lock: added = self._addActionsForPlugin(pi) if added: get_notification_center().emitPeerActionsAdded(added)
def _pluginActivated(self, pName, pCat): pName = convert_string(pName) pCat = convert_string(pCat) if pCat == "gui": try: pluginInfo = get_plugin_manager().getPluginByName(pName, u"gui") self.addPluginWidget(pluginInfo.plugin_object, pName) except: getCoreLogger().exception("while including plugins %s", str(sys.exc_info()))
def _pluginWillBeDeactivated(self, pName, pCat): pName = convert_string(pName) pCat = convert_string(pCat) if pCat == "gui": pluginInfo = get_plugin_manager().getPluginByName(pName, pCat) try: pluginInfo.plugin_object.destroy_widget() except: getCoreLogger().exception("Error destroying plugin widget for plugin %s", pName) self.removePluginWidget(pName)
def _displayedPeerNameChanged(self, pID, newName, _infoDict): pID = convert_string(pID) newName = convert_string(newName) if pID == self._otherID: self._otherName = newName self._updateOtherName() if pID == get_settings().get_ID(): self._ownName = newName self._updateOwnName()
def link_clicked(self, url): if not url.host(): if url.hasQueryItem("reply-to") and url.hasQueryItem("screen-name"): self._reply_to_id = long(convert_string(url.queryItemValue("reply-to"))) self.post_field.setPlainText("@"+convert_string(url.queryItemValue("screen-name"))+" ") self.set_status("Reply to @"+convert_string(url.queryItemValue("screen-name"))) else: self.logger.error("Unknown command from link: "+str(url.toString())) else: webbrowser.open(str(url.toString()))
def categoryThumbnailChanged(self, cat, thumbnailPath, thumbnailSize): cat = convert_string(cat) thumbnailPath = convert_string(thumbnailPath) row = self._categoryToRow.get(cat, None) if row is None: self.logger.warning("Invalid category (%s), cannot set thumbnail", cat) return item = self.item(row) self._initializeItem(item, thumbnailPath, thumbnailSize, cat, adding=False)
def toggle_plugin(self, p_name, p_cat, new_state): try: p_cat = convert_string(p_cat) p_name = convert_string(p_name) if new_state: get_plugin_manager().activatePluginByName(p_name, p_cat) else: get_plugin_manager().deactivatePluginByName(p_name, p_cat) except: getCoreLogger().exception("Error toggling plugin")
def save_options_widget_data(self, **_kwargs): from PyQt4.QtCore import Qt from logging_level_settings.logging_level_gui import LogLevelModel get_settings().set_logging_level(self._ui.getGlobalLevelText()) model = self._ui.getModel() for row in xrange(model.rowCount()): loggerName = convert_string(model.item(row, LogLevelModel.NAME_COLUMN).data(LogLevelModel.KEY_ROLE).toString()) levelText = convert_string(model.item(row, LogLevelModel.LEVEL_COLUMN).data(Qt.DisplayRole).toString()) level = self._getLevelFromText(levelText) setLoggingLevel(loggerName, level)
def receiveFileSlot(self, addr, file_size, file_name, tcp_port, successFunc, errorFunc): addr = convert_string(addr) file_name = convert_string(file_name) dr = DataReceiverThread.receiveSingleFile(addr, file_name, file_size, tcp_port, getCoreLogger(), "avatar%s" % addr, True, parent=self) if successFunc: dr.successfullyTransferred.connect(lambda _thread, _path : successFunc()) if errorFunc: dr.errorOnTransfer.connect(lambda _thread, _msg : errorFunc()) dr.successfullyTransferred.connect(self.successfullyReceivedFile) dr.errorOnTransfer.connect(self.errorOnTransfer) dr.finished.connect(dr.deleteLater) dr.start()
def _displayOwnMessage(self, otherID, msgID, recvTime, msgHTML, msgTime, status, errorMsg): otherID = convert_string(otherID) msgHTML = convert_string(msgHTML) errorMsg = convert_string(errorMsg) if recvTime == -1: recvTime = None if not errorMsg: errorMsg = None if otherID in self._openChats: chatWindow = self._openChats[otherID] chatWindow.getChatWidget().addOwnMessage(msgID, recvTime, msgHTML, msgTime, status, errorMsg)
def convertDict(cls, aDict): newDict = {} for aKey in aDict: newKey = aKey if type(aKey) == QString: newKey = convert_string(aKey) aValue = aDict[aKey] if type(aValue) == QString: aValue = convert_string(aValue) elif type(aValue) == QVariant: aValue = convert_string(aValue.toString()) newDict[newKey] = aValue return newDict
def _receivedSuccessfullySlot(self, otherID, msgHTML, msgTime, msgDict, recvTime): otherID = convert_string(otherID) msgHTML = convert_string(msgHTML) try: self._getStorage().addOtherMessage(msgDict[u"id"], otherID, msgTime, msgHTML, recvTime) self._displayMessageLock.lock() try: self._currentlyDisplaying[otherID].remove(msgDict[u"id"]) finally: self._displayMessageLock.unlock() except: self.logger.exception("Error storing partner message") self._sendAnswer(otherID, msgDict, recvTime=recvTime)
def addCategory(self, cat, thumbnailPath, thumbnailSize): cat = convert_string(cat) thumbnailPath = convert_string(thumbnailPath) item = QStandardItem() item.setEditable(False) item.setData(QVariant(cat if cat != PrivacySettings.NO_CATEGORY else u"Not Categorized"), Qt.DisplayRole) self._initializeItem(item, thumbnailPath, thumbnailSize, cat, True) item.setData(QVariant() if thumbnailPath is None else QVariant(thumbnailPath), self.PATH_ROLE) catv = QVariant(cat) item.setData(catv, self.SORT_ROLE) item.setData(catv, self.CAT_ROLE) self._categoryToRow[cat] = self.rowCount() self.appendRow([item])
def externalRowRemoved(self, key): if type(key) == QString: key = convert_string(key) if key in self.keys: index = self.keys.index(key) del self.keys[index] self.removeRow(index)
def _getSelectedPeer(self, selection=None): if selection is None: selection = self._peerList.selectionModel().selection() if len(selection.indexes()) > 0: index = iter(selection.indexes()).next() return convert_string(index.data(HistoryPeersModel.KEY_ROLE).toString()) return None
def updateLogList(self, logsAdded=None, logsRenamed=None): selectedMember = self.get_selected_log_member() if logsAdded == None: self.log_tree_view.clear() logsAdded = [] for index, logFile in enumerate(reversed(self.listLogFilesForMember(selectedMember))): logsAdded.append((index, logFile)) if len(logsAdded) == 0: self.log_tree_view.clear() self.log_tree_view.addTopLevelItem( QTreeWidgetItem(self.log_tree_view, QStringList("No logs available.")) ) self.log_tree_view.setSelectionMode(QTreeWidget.NoSelection) self.logSizeLabel.setText("No logs") self.clearLogsButton.setEnabled(False) return if logsRenamed != None: for index, oldName, newName in logsRenamed: # index + 1 because of the "requesting" item item = self.log_tree_view.topLevelItem(index + 1) if item != None: itemLogFile = convert_string(item.data(0, Qt.UserRole).toString()) if itemLogFile != oldName: self.logger.warning( "index does not correspond to item in list:\n\t%s\n\t%s", itemLogFile, oldName ) self.initializeLogItem(item, newName) if len(logsAdded) == 0: self.log_tree_view.takeTopLevelItem(0) else: for index, logFile in logsAdded: oldItem = self.log_tree_view.topLevelItem(index) item = None if oldItem != None and oldItem.data(0, Qt.UserRole) == None: # requested item has been received item = oldItem else: item = QTreeWidgetItem() oldItem = None if logFile == None: item.setData(0, Qt.DisplayRole, QVariant("Requesting...")) QTimer.singleShot(6000, partial(self.requestTimedOut, item)) else: self.initializeLogItem(item, logFile) if oldItem == None: # else, the old item is being modified self.log_tree_view.insertTopLevelItem(index, item) self.log_tree_view.setSelectionMode(QTreeWidget.SingleSelection) totalSize = 0 for aLogFile in self.listLogFilesForMember(selectedMember): totalSize += os.path.getsize(aLogFile) self.logSizeLabel.setText("%s consumed" % self.formatFileSize(totalSize)) self.clearLogsButton.setEnabled(True)
def getSelectedRequirements(self): reqs = [] for row in xrange(self._reqTable.topLevelItemCount()): rowItem = self._reqTable.topLevelItem(row) if rowItem.checkState(0) == Qt.Checked: reqs.append(convert_string(rowItem.data(0, self._REQUIREMENT_ROLE).toString())) return reqs
def externalRowUpdated(self, key, data): if type(key) == QString: key = convert_string(key) data = self._checkDict(data) if key in self.keys: index = self.keys.index(key) self.updateRow(key, data, index)
def _convertOption(self, o, v, new_v): try: choiceOptions = self.option_choice.get(o, None) if choiceOptions is not None: if not choiceOptions: choiceOptions = self._getChoiceOptions(o) finalValue = None for aValue in choiceOptions: if new_v.upper() == aValue.upper(): finalValue = aValue break if finalValue != None: return finalValue else: # keep old value return self._getOptionValue(o) elif type(v) == types.IntType: return int(new_v) elif type(v) == types.BooleanType: if new_v.strip().upper() in ["TRUE", "YES", "1"]: return True else: return False elif type(v) in (types.StringType, types.UnicodeType): return convert_string(new_v) else: self.logger.error("type of value %s %s not supported, using default", o, v) except: self.logger.exception("could not convert value of %s from config to type %s (%s) using default", o, type(v), new_v)
def _checkLogMessage(self, record): try: if self._notAgain.checkState() == Qt.Checked: return if record.levelno >= logging.ERROR: recMsg = record.msg if not isinstance(recMsg, basestring): recMsg = unicode(recMsg) err = convert_string(recMsg) % record.args component = record.name if component.startswith("lunchinator."): component = component[12:] msg = u"%s - In component %s (%s:%d):\n%s" % (strftime("%H:%M:%S", localtime(record.created)), component, record.pathname, record.lineno, err) if record.exc_info: out = StringIO() traceback.print_tb(record.exc_info[2], file=out) msg += u"\nStack trace:\n" + out.getvalue() + formatException(record.exc_info) + u"\n" self._errorLog.append(msg) self._empty = False if not self.isVisible(): self.showNormal() self.raise_() self.activateWindow() except: from lunchinator.log import getCoreLogger getCoreLogger().info(formatException())
def editorEvent(self, event, _model, option_, modelIndex): if self._column and modelIndex.column() != self._column: return False option = QStyleOptionViewItemV4(option_) self.initStyleOption(option, modelIndex) text = QString(option.text) if not text: self.parent().unsetCursor() return False if event.type() not in (QEvent.MouseMove, QEvent.MouseButtonRelease, QEvent.MouseButtonPress) \ or not (option.state & QStyle.State_Enabled): return False if modelIndex.row() != self.mouseOverDocumentRow: return False # Get the link at the mouse position pos = event.pos() messageRect = self._getMessageRect(option, self.mouseOverDocument, modelIndex) anchor = convert_string(self.mouseOverDocument.documentLayout().anchorAt(QPointF(pos) - QPointF(messageRect.topLeft()))) if anchor == "": if messageRect.contains(pos): self.parent().setCursor(Qt.IBeamCursor) else: self.parent().unsetCursor() else: self.parent().setCursor(Qt.PointingHandCursor) if event.type() == QEvent.MouseButtonRelease: if anchor.startswith(u"www."): anchor = u"http://" + anchor webbrowser.open(anchor) return True return False
def append(self, text, additives): if additives: text += u" (" selfText = convert_string(self.toPlainText()) if selfText: selfLen = len(selfText) + 1 # newline at end else: selfLen = 0 textLen = selfLen + len(text) first = True for additive in additives: if not first: text += u", " textLen += 2 for pos in xrange(textLen, textLen + len(additive)): self.additives[pos] = additive text += additive textLen += len(additive) first = False text += u")" super(GrowingTextEdit, self).append(text)