Python QtDo.do方法代码示例

# 需要导入模块: from weboob.tools.application.qt5 import QtDo [as 别名]
# 或者: from weboob.tools.application.qt5.QtDo import do [as 别名]
    def gotEvent(self, event):
        found = False
        for i in xrange(self.ui.typeBox.count()):
            s = self.ui.typeBox.itemData(i)
            if s == event.type:
                found = True
        if not found:
            print(event.type)
            self.ui.typeBox.addItem(event.type.capitalize(), event.type)
            if event.type == self.event_filter:
                self.ui.typeBox.setCurrentIndex(self.ui.typeBox.count()-1)

        if self.event_filter and self.event_filter != event.type:
            return

        if not event.contact:
            return

        contact = event.contact
        contact.backend = event.backend
        status = ''

        if contact.status == contact.STATUS_ONLINE:
            status = u'Online'
            status_color = 0x00aa00
        elif contact.status == contact.STATUS_OFFLINE:
            status = u'Offline'
            status_color = 0xff0000
        elif contact.status == contact.STATUS_AWAY:
            status = u'Away'
            status_color = 0xffad16
        else:
            status = u'Unknown'
            status_color = 0xaaaaaa

        if contact.status_msg:
            status += u' — %s' % contact.status_msg

        name = '<h2>%s</h2><font color="#%06X">%s</font><br /><i>%s</i>' % (contact.name, status_color, status, event.backend)
        date = event.date.strftime('%Y-%m-%d %H:%M')
        type = event.type
        message = event.message

        item = QTreeWidgetItem(None, [name, date, type, message])
        item.setData(0, Qt.UserRole, event)
        if contact.photos is NotLoaded:
            process = QtDo(self.weboob, lambda c: self.setPhoto(c, item))
            process.do('fillobj', contact, ['photos'], backends=contact.backend)
            self.photo_processes[contact.id] = process
        elif len(contact.photos) > 0:
            if not self.setPhoto(contact, item):
                photo = contact.photos.values()[0]
                process = QtDo(self.weboob, lambda p: self.setPhoto(contact, item))
                process.do('fillobj', photo, ['thumbnail_data'], backends=contact.backend)
                self.photo_processes[contact.id] = process

        self.ui.eventsList.addTopLevelItem(item)
        self.ui.eventsList.resizeColumnToContents(0)
        self.ui.eventsList.resizeColumnToContents(1)

# 需要导入模块: from weboob.tools.application.qt5 import QtDo [as 别名]
# 或者: from weboob.tools.application.qt5.QtDo import do [as 别名]
class ContactNotes(QWidget):
    """ Widget for storing notes about a contact """

    def __init__(self, weboob, contact, parent=None):
        super(ContactNotes, self).__init__(parent)
        self.ui = Ui_Notes()
        self.ui.setupUi(self)

        self.weboob = weboob
        self.contact = contact

        self.ui.textEdit.setEnabled(False)
        self.ui.saveButton.setEnabled(False)

        def finished():
            self.process = None
            self.ui.textEdit.setEnabled(True)
            self.ui.saveButton.setEnabled(True)

        self.process = QtDo(self.weboob, self._getNotes_cb, self._getNotes_eb, finished)
        self.process.do('get_notes', self.contact.id, backends=(self.contact.backend,))

        self.ui.saveButton.clicked.connect(self.saveNotes)

    def _getNotes_cb(self, data):
        if data:
            self.ui.textEdit.setText(data)

    def _getNotes_eb(self, backend, error, backtrace):
        if isinstance(error, NotImplementedError):
            return

        self.ui.textEdit.setEnabled(True)
        self.ui.saveButton.setEnabled(True)
        content = self.tr('Unable to load notes:\n%s\n') % to_unicode(error)
        if logging.root.level <= logging.DEBUG:
            content += '\n%s\n' % to_unicode(backtrace)
            QMessageBox.critical(self, self.tr('Error while loading notes'),
            content, QMessageBox.Ok)

    @Slot()
    def saveNotes(self):
        text = self.ui.textEdit.toPlainText()
        self.ui.saveButton.setEnabled(False)
        self.ui.textEdit.setEnabled(False)

        self.process = QtDo(self.weboob, None, self._saveNotes_eb, self._saveNotes_fb)
        self.process.do('save_notes', self.contact.id, text, backends=(self.contact.backend,))

    def _saveNotes_fb(self):
        self.ui.saveButton.setEnabled(True)
        self.ui.textEdit.setEnabled(True)

    def _saveNotes_eb(self, backend, error, backtrace):
        content = self.tr('Unable to save notes:\n%s\n') % to_unicode(error)
        if logging.root.level <= logging.DEBUG:
            content += '\n%s\n' % to_unicode(backtrace)
            QMessageBox.critical(self, self.tr('Error while saving notes'),
            content, QMessageBox.Ok)

# 需要导入模块: from weboob.tools.application.qt5 import QtDo [as 别名]
# 或者: from weboob.tools.application.qt5.QtDo import do [as 别名]
    def doOpen(self):
        qidxes = self.ui.bugList.selectionModel().selectedIndexes()
        rows = set()
        for qidx in qidxes:
            if qidx.row() in rows:
                continue
            rows.add(qidx.row())

            issue = qidx.data(ResultModel.RoleObject)

            def onFillobj(issue):
                dlg = DetailDialog(issue, parent=self)
                dlg.show()

            process = QtDo(self.weboob, onFillobj)
            process.do('fillobj', issue, ['history'], backends=(issue.backend,))

# 需要导入模块: from weboob.tools.application.qt5 import QtDo [as 别名]
# 或者: from weboob.tools.application.qt5.QtDo import do [as 别名]
    def addContact(self, contact):
        if not contact:
            self.ui.refreshButton.setEnabled(True)
            return

        status = ''
        if contact.status == Contact.STATUS_ONLINE:
            status = u'Online'
            status_color = 0x00aa00
        elif contact.status == Contact.STATUS_OFFLINE:
            status = u'Offline'
            status_color = 0xff0000
        elif contact.status == Contact.STATUS_AWAY:
            status = u'Away'
            status_color = 0xffad16
        else:
            status = u'Unknown'
            status_color = 0xaaaaaa

        if contact.status_msg:
            status += u' — %s' % contact.status_msg

        item = QListWidgetItem()
        item.setText('<h2>%s</h2><font color="#%06X">%s</font><br /><i>%s</i>' % (contact.name, status_color, status, contact.backend))
        item.setData(Qt.UserRole, contact)

        if contact.photos is NotLoaded:
            process = QtDo(self.weboob, lambda c: self.setPhoto(c, item))
            process.do('fillobj', contact, ['photos'], backends=contact.backend)
            self.photo_processes[contact.id] = process
        elif len(contact.photos) > 0:
            if not self.setPhoto(contact, item):
                photo = contact.photos.values()[0]
                process = QtDo(self.weboob, lambda p: self.setPhoto(contact, item))
                process.do('fillobj', photo, ['thumbnail_data'], backends=contact.backend)
                self.photo_processes[contact.id] = process

        for i in xrange(self.ui.contactList.count()):
            if self.ui.contactList.item(i).data(Qt.UserRole).status > contact.status:
                self.ui.contactList.insertItem(i, item)
                return

        self.ui.contactList.addItem(item)

# 需要导入模块: from weboob.tools.application.qt5 import QtDo [as 别名]
# 或者: from weboob.tools.application.qt5.QtDo import do [as 别名]
class MiniVideo(QFrame):
    def __init__(self, weboob, backend, video, parent=None):
        super(MiniVideo, self).__init__(parent)
        self.ui = Ui_MiniVideo()
        self.ui.setupUi(self)

        self.weboob = weboob
        self.backend = backend
        self.video = video
        self.ui.titleLabel.setText(video.title)
        self.ui.backendLabel.setText(backend.name)
        self.ui.durationLabel.setText(unicode(video.duration))
        self.ui.authorLabel.setText(unicode(video.author))
        self.ui.dateLabel.setText(video.date and unicode(video.date) or '')
        if video.rating_max:
            self.ui.ratingLabel.setText('%s / %s' % (video.rating, video.rating_max))
        else:
            self.ui.ratingLabel.setText('%s' % video.rating)

        self.process_thumbnail = QtDo(self.weboob, self.gotThumbnail)
        self.process_thumbnail.do('fillobj', self.video, ['thumbnail'], backends=backend)

    def gotThumbnail(self, video):
        if video.thumbnail and video.thumbnail.data:
            img = QImage.fromData(video.thumbnail.data)
            self.ui.imageLabel.setPixmap(QPixmap.fromImage(img))

    def enterEvent(self, event):
        self.setFrameShadow(self.Sunken)
        QFrame.enterEvent(self, event)

    def leaveEvent(self, event):
        self.setFrameShadow(self.Raised)
        QFrame.leaveEvent(self, event)

    def mousePressEvent(self, event):
        QFrame.mousePressEvent(self, event)

        video = self.backend.fillobj(self.video)
        if video:
            video_widget = Video(video, self)
            video_widget.show()

# 需要导入模块: from weboob.tools.application.qt5 import QtDo [as 别名]
# 或者: from weboob.tools.application.qt5.QtDo import do [as 别名]
class MetaGroup(IGroup):
    def iter_contacts(self, cb):
        if self.id == 'online':
            status = Contact.STATUS_ONLINE|Contact.STATUS_AWAY
        elif self.id == 'offline':
            status = Contact.STATUS_OFFLINE
        else:
            status = Contact.STATUS_ALL

        self.process = QtDo(self.weboob, lambda d: self.cb(cb, d), fb=lambda: self.fb(cb))
        self.process.do('iter_contacts', status, caps=CapContact)

    def cb(self, cb, contact):
        if contact:
            cb(contact)

    def fb(self, fb):
        self.process = None
        if fb:
            fb(None)

# 需要导入模块: from weboob.tools.application.qt5 import QtDo [as 别名]
# 或者: from weboob.tools.application.qt5.QtDo import do [as 别名]
    def addHousing(self, housing):
        if not housing:
            return

        item = HousingListWidgetItem(housing)
        item.setAttrs(self.storage)

        if housing.photos is NotLoaded:
            process = QtDo(self.weboob, lambda c: self.setPhoto(c, item))
            process.do('fillobj', housing, ['photos'], backends=housing.backend)
            self.process_photo[housing.id] = process
        elif housing.photos is not NotAvailable and len(housing.photos) > 0:
            if not self.setPhoto(housing, item):
                photo = housing.photos[0]
                process = QtDo(self.weboob, lambda p: self.setPhoto(housing, item))
                process.do('fillobj', photo, ['data'], backends=housing.backend)
                self.process_photo[housing.id] = process

        self.ui.housingsList.addItem(item)

        if housing.fullid in self.process_bookmarks:
            self.process_bookmarks.pop(housing.fullid)

# 需要导入模块: from weboob.tools.application.qt5 import QtDo [as 别名]
# 或者: from weboob.tools.application.qt5.QtDo import do [as 别名]
class MainWindow(QtMainWindow):
    def __init__(self, config, storage, weboob, app, parent=None):
        super(MainWindow, self).__init__(parent)
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)

        self.config = config
        self.storage = storage
        self.weboob = weboob
        self.app = app
        self.process = None
        self.housing = None
        self.displayed_photo_idx = 0
        self.process_photo = {}
        self.process_bookmarks = {}

        self.ui.housingsList.setItemDelegate(HTMLDelegate())
        self.ui.housingFrame.hide()

        self.ui.actionBackends.triggered.connect(self.backendsConfig)
        self.ui.queriesList.currentIndexChanged.connect(self.queryChanged)
        self.ui.addQueryButton.clicked.connect(self.addQuery)
        self.ui.editQueryButton.clicked.connect(self.editQuery)
        self.ui.removeQueryButton.clicked.connect(self.removeQuery)
        self.ui.bookmarksButton.clicked.connect(self.displayBookmarks)
        self.ui.housingsList.currentItemChanged.connect(self.housingSelected)
        self.ui.previousButton.clicked.connect(self.previousClicked)
        self.ui.nextButton.clicked.connect(self.nextClicked)
        self.ui.bookmark.stateChanged.connect(self.bookmarkChanged)

        self.reloadQueriesList()
        self.refreshHousingsList()

        if self.weboob.count_backends() == 0:
            self.backendsConfig()

        if len(self.config.get('queries')) == 0:
            self.addQuery()

    def closeEvent(self, event):
        self.setHousing(None)
        QtMainWindow.closeEvent(self, event)

    @Slot()
    def backendsConfig(self):
        bckndcfg = BackendCfg(self.weboob, (CapHousing,), self)
        if bckndcfg.run():
            pass

    def reloadQueriesList(self, select_name=None):
        self.ui.queriesList.currentIndexChanged.disconnect(self.queryChanged)
        self.ui.queriesList.clear()
        for name in self.config.get('queries', default={}).iterkeys():
            self.ui.queriesList.addItem(name)
            if name == select_name:
                self.ui.queriesList.setCurrentIndex(len(self.ui.queriesList)-1)
        self.ui.queriesList.currentIndexChanged.connect(self.queryChanged)

        if select_name is not None:
            self.queryChanged()

    @Slot()
    def removeQuery(self):
        name = self.ui.queriesList.itemText(self.ui.queriesList.currentIndex())
        queries = self.config.get('queries')
        queries.pop(name, None)
        self.config.set('queries', queries)
        self.config.save()

        self.reloadQueriesList()
        self.queryChanged()

    @Slot()
    def editQuery(self):
        name = self.ui.queriesList.itemText(self.ui.queriesList.currentIndex())
        self.addQuery(name)

    @Slot()
    def addQuery(self, name=None):
        querydlg = QueryDialog(self.weboob, self)
        if name is not None:
            query = self.config.get('queries', name)
            querydlg.ui.nameEdit.setText(name)
            querydlg.ui.nameEdit.setEnabled(False)
            for c in query['cities']:
                city = City(c['id'])
                city.backend = c['backend']
                city.name = c['name']
                item = querydlg.buildCityItem(city)
                querydlg.ui.citiesList.addItem(item)

            querydlg.ui.typeBox.setCurrentIndex(int(query.get('type', 0)))
            querydlg.ui.areaMin.setValue(query['area_min'])
            querydlg.ui.areaMax.setValue(query['area_max'])
            querydlg.ui.costMin.setValue(query['cost_min'])
            querydlg.ui.costMax.setValue(query['cost_max'])
            querydlg.selectComboValue(querydlg.ui.nbRooms, query['nb_rooms'])

        if querydlg.exec_():
            name = querydlg.ui.nameEdit.text()
#.........这里部分代码省略.........

# 需要导入模块: from weboob.tools.application.qt5 import QtDo [as 别名]
# 或者: from weboob.tools.application.qt5.QtDo import do [as 别名]
class MainWindow(QtMainWindow):
    def __init__(self, config, storage, weboob, parent=None):
        super(MainWindow, self).__init__(parent)
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)

        self.config = config
        self.storage = storage
        self.weboob = weboob
        self.process = None
        self.displayed_photo_idx = 0
        self.process_photo = {}
        self.process_bookmarks = {}

        # search history is a list of patterns which have been searched
        history_path = os.path.join(self.weboob.workdir, 'qhandjoob_history')
        qc = HistoryCompleter(history_path, self)
        qc.load()
        qc.setCaseSensitivity(Qt.CaseInsensitive)
        self.ui.searchEdit.setCompleter(qc)

        self.ui.jobFrame.hide()

        self.ui.actionBackends.triggered.connect(self.backendsConfig)

        self.ui.searchEdit.returnPressed.connect(self.doSearch)
        self.ui.jobList.currentItemChanged.connect(self.jobSelected)
        self.ui.searchButton.clicked.connect(self.doSearch)

        self.ui.refreshButton.clicked.connect(self.doAdvancedSearch)
        self.ui.queriesTabWidget.currentChanged.connect(self.tabChange)
        self.ui.jobListAdvancedSearch.currentItemChanged.connect(self.jobSelected)

        self.ui.idEdit.returnPressed.connect(self.openJob)

        if self.weboob.count_backends() == 0:
            self.backendsConfig()

    @Slot(int)
    def tabChange(self, index):
        if index == 1:
            self.doAdvancedSearch()

    def searchFinished(self):
        self.process = None
        QApplication.restoreOverrideCursor()

    @Slot()
    def doAdvancedSearch(self):
        QApplication.setOverrideCursor(Qt.WaitCursor)
        self.ui.jobListAdvancedSearch.clear()

        self.process = QtDo(self.weboob, self.addJobAdvancedSearch, fb=self.searchFinished)
        self.process.do('advanced_search_job')

    @Slot()
    def doSearch(self):
        QApplication.setOverrideCursor(Qt.WaitCursor)
        pattern = self.ui.searchEdit.text()

        self.ui.searchEdit.completer().addString(pattern)

        self.ui.jobList.clear()
        self.process = QtDo(self.weboob, self.addJobSearch, fb=self.searchFinished)
        self.process.do('search_job', pattern)

    def addJobSearch(self, job):
        item = self.addJob(job)
        if item:
            self.ui.jobList.addItem(item)

    def addJobAdvancedSearch(self, job):
        item = self.addJob(job)
        if item:
            self.ui.jobListAdvancedSearch.addItem(item)

    def addJob(self, job):
        if not job:
            return

        item = JobListWidgetItem(job)
        item.setAttrs(self.storage)
        return item

    def closeEvent(self, event):
        self.ui.searchEdit.completer().save()
        QtMainWindow.closeEvent(self, event)

    @Slot()
    def backendsConfig(self):
        bckndcfg = BackendCfg(self.weboob, (CapJob,), self)
        if bckndcfg.run():
            pass

    @Slot(QListWidgetItem, QListWidgetItem)
    def jobSelected(self, item, prev):
        QApplication.setOverrideCursor(Qt.WaitCursor)
        if item is not None:
            job = item.job
            self.ui.queriesTabWidget.setEnabled(False)
#.........这里部分代码省略.........

# 需要导入模块: from weboob.tools.application.qt5 import QtDo [as 别名]
# 或者: from weboob.tools.application.qt5.QtDo import do [as 别名]
class ContactThread(QWidget):
    """
    The thread of the selected contact.
    """

    def __init__(self, weboob, contact, support_reply, parent=None):
        super(ContactThread, self).__init__(parent)
        self.ui = Ui_ContactThread()
        self.ui.setupUi(self)

        self.weboob = weboob
        self.contact = contact
        self.thread = None
        self.messages = []
        self.process_msg = None
        self.ui.refreshButton.clicked.connect(self.refreshMessages)

        if support_reply:
            self.ui.sendButton.clicked.connect(self.postReply)
        else:
            self.ui.frame.hide()

        self.refreshMessages()

    @Slot()
    def refreshMessages(self, fillobj=False):
        if self.process_msg:
            return

        self.ui.refreshButton.setEnabled(False)

        def finished():
            #v = self.ui.scrollArea.verticalScrollBar()
            #print v.minimum(), v.value(), v.maximum(), v.sliderPosition()
            #self.ui.scrollArea.verticalScrollBar().setValue(self.ui.scrollArea.verticalScrollBar().maximum())
            self.process_msg = None

        self.process_msg = QtDo(self.weboob, self.gotThread, self.gotError, finished)
        if fillobj and self.thread:
            self.process_msg.do('fillobj', self.thread, ['root'], backends=self.contact.backend)
        else:
            self.process_msg.do('get_thread', self.contact.id, backends=self.contact.backend)

    def gotError(self, backend, error, backtrace):
        self.ui.textEdit.setEnabled(False)
        self.ui.sendButton.setEnabled(False)
        self.ui.refreshButton.setEnabled(True)

    def gotThread(self, thread):
        self.ui.textEdit.setEnabled(True)
        self.ui.sendButton.setEnabled(True)
        self.ui.refreshButton.setEnabled(True)

        self.thread = thread

        if thread.root is NotLoaded:
            self._insert_load_button(0)
        else:
            for message in thread.iter_all_messages():
                self._insert_message(message)

    def _insert_message(self, message):
        widget = ThreadMessage(message)
        if widget in self.messages:
            old_widget = self.messages[self.messages.index(widget)]
            if old_widget.message.flags != widget.message.flags:
                old_widget.set_message(widget.message)
            return

        for i, m in enumerate(self.messages):
            if widget.message.date > m.message.date:
                self.ui.scrollAreaContent.layout().insertWidget(i, widget)
                self.messages.insert(i, widget)
                if message.parent is NotLoaded:
                    self._insert_load_button(i)
                return

        self.ui.scrollAreaContent.layout().addWidget(widget)
        self.messages.append(widget)
        if message.parent is NotLoaded:
            self._insert_load_button(-1)

    def _insert_load_button(self, pos):
        button = QPushButton(self.tr('More messages...'))
        button.clicked.connect(self._load_button_pressed)
        if pos >= 0:
            self.ui.scrollAreaContent.layout().insertWidget(pos, button)
        else:
            self.ui.scrollAreaContent.layout().addWidget(button)

    @Slot()
    def _load_button_pressed(self):
        button = self.sender()
        self.ui.scrollAreaContent.layout().removeWidget(button)
        button.hide()
        button.deleteLater()

        self.refreshMessages(fillobj=True)

    @Slot()
#.........这里部分代码省略.........

# 需要导入模块: from weboob.tools.application.qt5 import QtDo [as 别名]
# 或者: from weboob.tools.application.qt5.QtDo import do [as 别名]
class Result(QFrame):
    def __init__(self, weboob, app, parent=None):
        super(Result, self).__init__(parent)
        self.ui = Ui_Result()
        self.ui.setupUi(self)

        self.parent = parent
        self.weboob = weboob
        self.app = app
        self.minis = []
        self.current_info_widget = None

        # action history is composed by the last action and the action list
        # An action is a function, a list of arguments and a description string
        self.action_history = {'last_action': None, 'action_list': []}
        self.ui.backButton.clicked.connect(self.doBack)
        self.ui.backButton.hide()

    def doAction(self, description, fun, args):
        ''' Call fun with args as arguments
        and save it in the action history
        '''
        self.ui.currentActionLabel.setText(description)
        if self.action_history['last_action'] is not None:
            self.action_history['action_list'].append(self.action_history['last_action'])
            self.ui.backButton.setToolTip(self.action_history['last_action']['description'])
            self.ui.backButton.show()
        self.action_history['last_action'] = {'function': fun, 'args': args, 'description': description}
        return fun(*args)

    @Slot()
    def doBack(self):
        ''' Go back in action history
        Basically call previous function and update history
        '''
        if len(self.action_history['action_list']) > 0:
            todo = self.action_history['action_list'].pop()
            self.ui.currentActionLabel.setText(todo['description'])
            self.action_history['last_action'] = todo
            if len(self.action_history['action_list']) == 0:
                self.ui.backButton.hide()
            else:
                self.ui.backButton.setToolTip(self.action_history['action_list'][-1]['description'])
            return todo['function'](*todo['args'])

    def processFinished(self):
        self.parent.ui.searchEdit.setEnabled(True)
        QApplication.restoreOverrideCursor()
        self.process = None
        self.parent.ui.stopButton.hide()

    def searchRecipe(self,pattern):
        if not pattern:
            return
        self.doAction(u'Search recipe "%s"' % pattern, self.searchRecipeAction, [pattern])

    def searchRecipeAction(self, pattern):
        self.ui.stackedWidget.setCurrentWidget(self.ui.list_page)
        for mini in self.minis:
            self.ui.list_content.layout().removeWidget(mini)
            mini.hide()
            mini.deleteLater()

        self.minis = []
        self.parent.ui.searchEdit.setEnabled(False)
        QApplication.setOverrideCursor(Qt.WaitCursor)

        backend_name = self.parent.ui.backendEdit.itemData(self.parent.ui.backendEdit.currentIndex())

        self.process = QtDo(self.weboob, self.addRecipe, fb=self.processFinished)
        self.process.do(self.app._do_complete, self.parent.getCount(), ('title'), 'iter_recipes', pattern, backends=backend_name, caps=CapRecipe)
        self.parent.ui.stopButton.show()

    def addRecipe(self, recipe):
        minirecipe = MiniRecipe(self.weboob, self.weboob[recipe.backend], recipe, self)
        self.ui.list_content.layout().insertWidget(self.ui.list_content.layout().count()-1,minirecipe)
        self.minis.append(minirecipe)

    def displayRecipe(self, recipe, backend):
        self.ui.stackedWidget.setCurrentWidget(self.ui.info_page)
        if self.current_info_widget is not None:
            self.ui.info_content.layout().removeWidget(self.current_info_widget)
            self.current_info_widget.hide()
            self.current_info_widget.deleteLater()
        wrecipe = Recipe(recipe, backend, self)
        self.ui.info_content.layout().addWidget(wrecipe)
        self.current_info_widget = wrecipe
        QApplication.restoreOverrideCursor()

    def searchId(self, id):
        QApplication.setOverrideCursor(Qt.WaitCursor)
        if '@' in id:
            backend_name = id.split('@')[1]
            id = id.split('@')[0]
        else:
            backend_name = None
        for backend in self.weboob.iter_backends():
            if (backend_name and backend.name == backend_name) or not backend_name:
                recipe = backend.get_recipe(id)
                if recipe:
#.........这里部分代码省略.........

# 需要导入模块: from weboob.tools.application.qt5 import QtDo [as 别名]
# 或者: from weboob.tools.application.qt5.QtDo import do [as 别名]
class MainWindow(QtMainWindow):
    def __init__(self, config, weboob, app, parent=None):
        super(MainWindow, self).__init__(parent)
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)

        self.config = config
        self.weboob = weboob
        self.backend = None
        self.app = app

        self.ui.idEdit.returnPressed.connect(self.loadPage)
        self.ui.loadButton.clicked.connect(self.loadPage)
        self.ui.tabWidget.currentChanged.connect(self._currentTabChanged)
        self.ui.saveButton.clicked.connect(self.savePage)
        self.ui.actionBackends.triggered.connect(self.backendsConfig)
        self.ui.contentEdit.textChanged.connect(self._textChanged)
        self.ui.loadHistoryButton.clicked.connect(self.loadHistory)

        if hasattr(self.ui.descriptionEdit, "setPlaceholderText"):
            self.ui.descriptionEdit.setPlaceholderText("Edit summary")

        if self.weboob.count_backends() == 0:
            self.backendsConfig()
        else:
            self.loadBackends()

    @Slot()
    def backendsConfig(self):
        """ Opens backends configuration dialog when 'Backends' is clicked """
        bckndcfg = BackendCfg(self.weboob, (CapContent,), self)
        if bckndcfg.run():
            self.loadBackends()

    def loadBackends(self):
        """ Fills the backends comboBox with available backends """
        model = BackendListModel(self.weboob)
        model.addBackends(entry_all=False)
        self.ui.backendBox.setModel(model)

    @Slot()
    def _currentTabChanged(self):
        """ Loads history or preview when the corresponding tabs are shown """
        if self.ui.tabWidget.currentIndex() == 1:
            if self.backend is not None:
                self.loadPreview()
        elif self.ui.tabWidget.currentIndex() == 2:
            if self.backend is not None:
                self.loadHistory()

    @Slot()
    def _textChanged(self):
        """ The text in the content QPlainTextEdit has changed """
        if self.backend:
            self.ui.saveButton.setEnabled(True)
            self.ui.saveButton.setText('Save')

    @Slot()
    def loadPage(self):
        """ Loads a page's source into the 'content' QPlainTextEdit """
        _id = self.ui.idEdit.text()
        if not _id:
            return

        self.ui.loadButton.setEnabled(False)
        self.ui.loadButton.setText('Loading...')
        self.ui.contentEdit.setReadOnly(True)

        backend = self.ui.backendBox.currentText()

        def finished():
            self.process = None
            if self.backend:
                self.ui.contentEdit.setReadOnly(False)
                self.ui.loadButton.setEnabled(True)
                self.ui.loadButton.setText('Load')

        self.process = QtDo(self.weboob,
                            self._loadedPage,
                            self._errorLoadPage,
                            finished)
        self.process.do('get_content', _id, backends=(backend,))

    def _loadedPage(self, data):
        """ Callback for loadPage """
        if not data:
            self.content = None
            self.backend = None
            QMessageBox.critical(self, self.tr('Unable to open page'),
                                 'Unable to open page "%s" on %s: it does not exist.'
                                 % (self.ui.idEdit.text(),
                                    self.ui.backendBox.currentText()),
                                 QMessageBox.Ok)
            return

        self.content = data
        self.ui.contentEdit.setPlainText(self.content.content)
        self.setWindowTitle("QWebcontentedit - %[email protected]%s" %(self.content.id,
                                                        self.content.backend))
        self.backend = self.weboob[self.content.backend]
#.........这里部分代码省略.........

# 需要导入模块: from weboob.tools.application.qt5 import QtDo [as 别名]
# 或者: from weboob.tools.application.qt5.QtDo import do [as 别名]
class SearchWidget(QWidget):
    def __init__(self, weboob, parent=None):
        super(SearchWidget, self).__init__(parent)
        self.ui = Ui_Search()
        self.ui.setupUi(self)

        self.weboob = weboob
        self.contacts = []
        self.accounts = []
        self.current = None

        self.ui.nextButton.clicked.connect(self.next)
        self.ui.queryButton.clicked.connect(self.sendQuery)

    def load(self):
        while self.ui.statusFrame.layout().count() > 0:
            item = self.ui.statusFrame.layout().takeAt(0)
            if item.widget():
                item.widget().deinit()
                item.widget().hide()
                item.widget().deleteLater()

        self.accounts = []

        for backend in self.weboob.iter_backends():
            account = Account(self.weboob, backend)
            account.title.setText(u'<h2>%s</h2>' % backend.name)
            self.accounts.append(account)
            self.ui.statusFrame.layout().addWidget(account)
        self.ui.statusFrame.layout().addStretch()

        self.getNewProfiles()

    def updateStats(self):
        for account in self.accounts:
            account.updateStats()

    def getNewProfiles(self):
        self.newprofiles_process = QtDo(self.weboob, self.retrieveNewContacts_cb)
        self.newprofiles_process.do('iter_new_contacts')

    def retrieveNewContacts_cb(self, contact):
        self.contacts.insert(0, contact)
        self.ui.queueLabel.setText('%d' % len(self.contacts))
        if self.current is None:
            next(self)

    @Slot()
    def next(self):
        try:
            contact = self.contacts.pop()
        except IndexError:
            contact = None

        self.ui.queueLabel.setText('%d' % len(self.contacts))
        self.setContact(contact)
        self.updateStats()

    def setContact(self, contact):
        self.current = contact
        if contact is not None:
            widget = ContactProfile(self.weboob, contact)
            self.ui.scrollArea.setWidget(widget)
        else:
            self.ui.scrollArea.setWidget(None)

    @Slot()
    def sendQuery(self):
        self.newprofiles_process = QtDo(self.weboob, None, fb=self.next)
        self.newprofiles_process.do('send_query', self.current.id, backends=[self.current.backend])

# 需要导入模块: from weboob.tools.application.qt5 import QtDo [as 别名]
# 或者: from weboob.tools.application.qt5.QtDo import do [as 别名]
class QueryDialog(QDialog):
    def __init__(self, weboob, parent=None):
        super(QueryDialog, self).__init__(parent)
        self.ui = Ui_QueryDialog()
        self.ui.setupUi(self)

        self.weboob = weboob
        self.ui.resultsList.setItemDelegate(HTMLDelegate())
        self.ui.citiesList.setItemDelegate(HTMLDelegate())

        self.search_process = None

        self.ui.cityEdit.returnPressed.connect(self.searchCity)
        self.ui.resultsList.itemDoubleClicked.connect(self.insertCity)
        self.ui.citiesList.itemDoubleClicked.connect(self.removeCity)
        self.ui.buttonBox.accepted.connect(self.okButton)

        if hasattr(self.ui.cityEdit, "setPlaceholderText"):
            self.ui.cityEdit.setPlaceholderText("Press enter to search city")

    def keyPressEvent(self, event):
        """
        Disable handler <Enter> and <Escape> to prevent closing the window.
        """
        event.ignore()

    def selectComboValue(self, box, value):
        for i in range(box.count()):
            if box.itemText(i) == str(value):
                box.setCurrentIndex(i)
                break

    @Slot()
    def searchCity(self):
        pattern = self.ui.cityEdit.text()
        self.ui.resultsList.clear()
        self.ui.cityEdit.clear()
        self.ui.cityEdit.setEnabled(False)

        self.search_process = QtDo(self.weboob, self.addResult, fb=self.addResultEnd)
        self.search_process.do('search_city', pattern)

    def addResultEnd(self):
        self.search_process = None
        self.ui.cityEdit.setEnabled(True)

    def addResult(self, city):
        if not city:
            return
        item = self.buildCityItem(city)
        self.ui.resultsList.addItem(item)
        self.ui.resultsList.sortItems()

    def buildCityItem(self, city):
        item = QListWidgetItem()
        item.setText('<b>%s</b> (%s)' % (city.name, city.backend))
        item.setData(Qt.UserRole, city)
        return item

    @Slot(QListWidgetItem)
    def insertCity(self, i):
        item = QListWidgetItem()
        item.setText(i.text())
        item.setData(Qt.UserRole, i.data(Qt.UserRole))
        self.ui.citiesList.addItem(item)

    @Slot(QListWidgetItem)
    def removeCity(self, item):
        self.ui.citiesList.removeItemWidget(item)

    @Slot()
    def okButton(self):
        if not self.ui.nameEdit.text():
            QMessageBox.critical(self, self.tr('Error'), self.tr('Please enter a name to your query.'), QMessageBox.Ok)
            return

        if self.ui.citiesList.count() == 0:
            QMessageBox.critical(self, self.tr('Error'), self.tr('Please add at least one city.'), QMessageBox.Ok)
            return

        self.accept()

# 需要导入模块: from weboob.tools.application.qt5 import QtDo [as 别名]
# 或者: from weboob.tools.application.qt5.QtDo import do [as 别名]
class ContactProfile(QWidget):
    def __init__(self, weboob, contact, parent=None):
        super(ContactProfile, self).__init__(parent)
        self.ui = Ui_Profile()
        self.ui.setupUi(self)

        self.ui.previousButton.clicked.connect(self.previousClicked)
        self.ui.nextButton.clicked.connect(self.nextClicked)

        self.weboob = weboob
        self.contact = contact
        self.loaded_profile = False
        self.displayed_photo_idx = 0
        self.process_photo = {}

        missing_fields = self.gotProfile(contact)
        if len(missing_fields) > 0:
            self.process_contact = QtDo(self.weboob, self.gotProfile, self.gotError)
            self.process_contact.do('fillobj', self.contact, missing_fields, backends=self.contact.backend)

    def gotError(self, backend, error, backtrace):
        self.ui.frame_photo.hide()
        self.ui.descriptionEdit.setText('<h1>Unable to show profile</h1><p>%s</p>' % to_unicode(error))

    def gotProfile(self, contact):
        missing_fields = set()

        self.display_photo()

        self.ui.nicknameLabel.setText('<h1>%s</h1>' % contact.name)
        if contact.status == Contact.STATUS_ONLINE:
            status_color = 0x00aa00
        elif contact.status == Contact.STATUS_OFFLINE:
            status_color = 0xff0000
        elif contact.status == Contact.STATUS_AWAY:
            status_color = 0xffad16
        else:
            status_color = 0xaaaaaa

        self.ui.statusLabel.setText('<font color="#%06X">%s</font>' % (status_color, contact.status_msg))
        self.ui.contactUrlLabel.setText('<b>URL:</b> <a href="%s">%s</a>' % (contact.url, contact.url))
        if contact.summary is NotLoaded:
            self.ui.descriptionEdit.setText('<h1>Description</h1><p><i>Receiving...</i></p>')
            missing_fields.add('summary')
        else:
            self.ui.descriptionEdit.setText('<h1>Description</h1><p>%s</p>' % contact.summary.replace('\n', '<br />'))

        if not contact.profile:
            missing_fields.add('profile')
        elif not self.loaded_profile:
            self.loaded_profile = True
            for head in contact.profile.itervalues():
                if head.flags & head.HEAD:
                    widget = self.ui.headWidget
                else:
                    widget = self.ui.profileTab
                self.process_node(head, widget)

        return missing_fields

    def process_node(self, node, widget):
        # Set the value widget
        value = None
        if node.flags & node.SECTION:
            value = QWidget()
            value.setLayout(QFormLayout())
            for sub in node.value.itervalues():
                self.process_node(sub, value)
        elif isinstance(node.value, list):
            value = QLabel('<br />'.join(unicode(s) for s in node.value))
            value.setWordWrap(True)
        elif isinstance(node.value, tuple):
            value = QLabel(', '.join(unicode(s) for s in node.value))
            value.setWordWrap(True)
        elif isinstance(node.value, (basestring,int,long,float)):
            value = QLabel(unicode(node.value))
        else:
            logging.warning('Not supported value: %r' % node.value)
            return

        if isinstance(value, QLabel):
            value.setTextInteractionFlags(Qt.TextSelectableByMouse|Qt.TextSelectableByKeyboard|Qt.LinksAccessibleByMouse)

        # Insert the value widget into the parent widget, depending
        # of its type.
        if isinstance(widget, QTabWidget):
            widget.addTab(value, node.label)
        elif isinstance(widget.layout(), QFormLayout):
            label = QLabel(u'<b>%s:</b> ' % node.label)
            widget.layout().addRow(label, value)
        elif isinstance(widget.layout(), QVBoxLayout):
            widget.layout().addWidget(QLabel(u'<h3>%s</h3>' % node.label))
            widget.layout().addWidget(value)
        else:
            logging.warning('Not supported widget: %r' % widget)

    @Slot()
    def previousClicked(self):
        if len(self.contact.photos) == 0:
            return
#.........这里部分代码省略.........