Example #1
0
    def data(self, index, role):
        source_index = self.mapToSource(index)
        source_data = self.sourceModel().data(source_index, role)
        expiration_col = self.sourceModel().columns_ids.index('expiration')
        expiration_index = self.sourceModel().index(source_index.row(), expiration_col)
        expiration_data = self.sourceModel().data(expiration_index, Qt.DisplayRole)
        current_time = QDateTime().currentDateTime().toMSecsSinceEpoch()
        sig_validity = self.community.parameters['sigValidity']
        warning_expiration_time = int(sig_validity / 3)
        #logging.debug("{0} > {1}".format(current_time, expiration_data))
        if expiration_data is not None:
            will_expire_soon = (current_time > expiration_data*1000 - warning_expiration_time*1000)
        if role == Qt.DisplayRole:
            if source_index.column() == self.sourceModel().columns_ids.index('renewed') \
                    or source_index.column() == self.sourceModel().columns_ids.index('expiration'):
                if source_data is not None:
                    return QLocale.toString(
                        QLocale(),
                        QDateTime.fromTime_t(source_data).date(),
                        QLocale.dateFormat(QLocale(), QLocale.ShortFormat)
                    )
                else:
                    return ""
            if source_index.column() == self.sourceModel().columns_ids.index('pubkey'):
                return "pub:{0}".format(source_data[:5])

        if role == Qt.ForegroundRole:
            if expiration_data:
                if will_expire_soon:
                    return QColor(Qt.red)
            else:
                return QColor(Qt.blue)
        return source_data
Example #2
0
 def expand(cls, language):
     """
     Class method to expand a language enum to a readable languages
     list.
     
     @param language language number (QLocale.Language)
     @return list of expanded language names (list of strings)
     """
     allLanguages = []
     countries = [l.country() for l in QLocale.matchingLocales(
         language, QLocale.AnyScript, QLocale.AnyCountry)]
     languageString = "{0} [{1}]"\
         .format(QLocale.languageToString(language),
                 QLocale(language).name().split('_')[0])
     allLanguages.append(languageString)
     for country in countries:
         languageString = "{0}/{1} [{2}]"\
             .format(QLocale.languageToString(language),
                     QLocale.countryToString(country),
                     '-'.join(QLocale(language, country).name()
                              .split('_')).lower())
         if languageString not in allLanguages:
             allLanguages.append(languageString)
     
     return allLanguages
    def setUp(self):
        self.setUpQuamash()
        QLocale.setDefault(QLocale("en_GB"))
        self.identities_registry = IdentitiesRegistry({})

        self.application = Application(self.qapplication, self.lp, self.identities_registry)
        self.application.preferences['notifications'] = False

        self.endpoint = BMAEndpoint(PyBMAEndpoint("", "127.0.0.1", "", 50000))
        self.node = Node("test_currency", [self.endpoint],
                         "", "HnFcSms8jzwngtVomTTnzudZx7SHUQY8sVE1y8yBmULk",
                         nice_blockchain.bma_blockchain_current, Node.ONLINE,
                         time.time(), {}, "ucoin", "0.14.0", 0)
        self.network = Network.create(self.node)
        self.bma_access = BmaAccess.create(self.network)
        self.community = Community("test_currency", self.network, self.bma_access)

        self.wallet = Wallet(0, "7Aqw6Efa9EzE7gtsc8SveLLrM7gm6NEGoywSv4FJx6pZ",
                             "Wallet 1", self.identities_registry)
        self.wallet.init_cache(self.application, self.community)

        # Salt/password : "******"
        # Pubkey : 7Aqw6Efa9EzE7gtsc8SveLLrM7gm6NEGoywSv4FJx6pZ
        self.account = Account("testsakia", "7Aqw6Efa9EzE7gtsc8SveLLrM7gm6NEGoywSv4FJx6pZ",
                               "john", [self.community], [self.wallet], [], self.identities_registry)
Example #4
0
    def parseTemplate(cls, searchTerm, searchTemplate):
        """
        Class method to parse a search template.
        
        @param searchTerm term to search for (string)
        @param searchTemplate template to be parsed (string)
        @return parsed template (string)
        """
        locale = QLocale(Preferences.getHelp("SearchLanguage"))
        language = locale.name().split("_")[0]
        country = language.lower()
        
        result = searchTemplate
        result = result.replace("{count}", "20")
        result = result.replace("{startIndex}", "0")
        result = result.replace("{startPage}", "0")
        result = result.replace("{language}", language)
        result = result.replace("{country}", country)
        result = result.replace("{inputEncoding}", "UTF-8")
        result = result.replace("{outputEncoding}", "UTF-8")
        result = result.replace(
            "{searchTerms}",
            bytes(QUrl.toPercentEncoding(searchTerm)).decode())
        result = re.sub(r"""\{([^\}]*:|)source\??\}""", Program, result)

        return result
Example #5
0
    def __init__(self, parent, dict, persepolis_setting):
        super().__init__(persepolis_setting)
        self.persepolis_setting = persepolis_setting
        self.dict = dict
        self.parent = parent

        # add support for other languages
        locale = str(self.persepolis_setting.value('settings/locale'))
        QLocale.setDefault(QLocale(locale))
        self.translator = QTranslator()
        if self.translator.load(':/translations/locales/ui_' + locale, 'ts'):
            QCoreApplication.installTranslator(self.translator)

        # connecting buttons
        self.open_pushButtun.clicked.connect(self.openFile)
        self.open_folder_pushButtun.clicked.connect(self.openFolder)
        self.ok_pushButton.clicked.connect(self.okButtonPressed)

        # labels
        # find gid
        gid = self.dict['gid']

        # get file_path from data base
        self.add_link_dict = self.parent.persepolis_db.searchGidInAddLinkTable(gid)
        file_path = self.add_link_dict['download_path']

        # save_as
        self.save_as_lineEdit.setText(file_path)
        self.save_as_lineEdit.setToolTip(file_path)

        # link
        link = str(self.dict['link'])
        self.link_lineEdit.setText(link)
        self.link_lineEdit.setToolTip(link)

        # file_name

        window_title = str(self.dict['file_name'])
        file_name = QCoreApplication.translate("after_download_src_ui_tr", "<b>File name</b>: ") + \
                window_title
 
        self.setWindowTitle(window_title)

        self.file_name_label.setText(file_name)

        # size
        size = QCoreApplication.translate("after_download_src_ui_tr", "<b>Size</b>: ") + str(self.dict['size'])
        self.size_label.setText(size)

        # disable link_lineEdit and save_as_lineEdit
        self.link_lineEdit.setEnabled(False)
        self.save_as_lineEdit.setEnabled(False)

         # set window size and position
        size = self.persepolis_setting.value(
            'AfterDownloadWindow/size', QSize(570, 290))
        position = self.persepolis_setting.value(
            'AfterDownloadWindow/position', QPoint(300, 300))
        self.resize(size)
        self.move(position)
Example #6
0
    def setUp(self):
        self.setUpQuamash()
        QLocale.setDefault(QLocale("en_GB"))
        self.identities_registry = IdentitiesRegistry()

        self.application = Application(self.qapplication, self.lp, self.identities_registry)
        self.application.preferences['notifications'] = False

        self.mock_nice_blockchain = nice_blockchain.get_mock(self.lp)
        self.node = Node(self.mock_nice_blockchain.peer(),
                         "", "HnFcSms8jzwngtVomTTnzudZx7SHUQY8sVE1y8yBmULk",
                         None, Node.ONLINE,
                         time.time(), {}, "ucoin", "0.14.0", 0)
        self.network = Network.create(self.node)
        self.bma_access = BmaAccess.create(self.network)
        self.community = Community("test_currency", self.network, self.bma_access)

        self.wallet = Wallet(0, "7Aqw6Efa9EzE7gtsc8SveLLrM7gm6NEGoywSv4FJx6pZ",
                             "Wallet 1", self.identities_registry)

        # Salt/password : "******"
        # Pubkey : 7Aqw6Efa9EzE7gtsc8SveLLrM7gm6NEGoywSv4FJx6pZ
        self.account = Account("testsakia", "7Aqw6Efa9EzE7gtsc8SveLLrM7gm6NEGoywSv4FJx6pZ",
                               "john", [self.community], [self.wallet], [], self.identities_registry)

        self.password_asker = PasswordAskerDialog(self.account)
        self.password_asker.password = "******"
        self.password_asker.remember = True
 async def exec_test():
     value = await referential.localized(units=True, international_system=True)
     self.assertEqual(value, "1.011000 mUD({0}) TC".format(QLocale.toString(
                     QLocale(),
                     QDateTime.fromTime_t(1452663088792).date(),
                     QLocale.dateFormat(QLocale(), QLocale.ShortFormat)
                 )))
 async def exec_test():
     value = await referential.diff_localized(units=True)
     self.assertEqual(value, "0.101100 UD({0}) TC".format(QLocale.toString(
                     QLocale(),
                     QDateTime.fromTime_t(1452663088792).date(),
                     QLocale.dateFormat(QLocale(), QLocale.ShortFormat)
                 )))
Example #9
0
    def setUp(self):
        self.setUpQuamash()
        QLocale.setDefault(QLocale("en_GB"))

        self.identity = Mock(spec='sakia.core.registry.Identity')
        self.identity.pubkey = "HnFcSms8jzwngtVomTTnzudZx7SHUQY8sVE1y8yBmULk"
        self.identity.uid = "A"

        self.app = MagicMock(autospec='sakia.core.Application')
        self.account_joe = Mock(spec='sakia.core.Account')
        self.account_joe.contacts_changed = Mock()
        self.account_joe.contacts_changed.disconnect = Mock()
        self.account_joe.contacts_changed.connect = Mock()
        self.account_doe = Mock(spec='sakia.core.Account')
        self.account_doe.contacts_changed = Mock()
        self.account_doe.contacts_changed.disconnect = Mock()
        self.account_doe.contacts_changed.connect = Mock()

        def change_current_account(account_name):
            type(self.app).current_account = PropertyMock(return_value=self.account_doe)
        self.app.get_account = Mock(side_effect=lambda name: self.app.accounts[name])
        self.app.change_current_account = Mock(side_effect=change_current_account)
        type(self.app).current_account = PropertyMock(return_value=self.account_joe)
        self.app.accounts = {'joe':self.account_joe,
                             'doe': self.account_doe}
        self.homescreen = MagicMock(autospec='sakia.gui.homescreen.Homescreen')
        self.community_view = MagicMock(autospec='sakia.gui.community_view.CommunityView')
        self.password_asker = MagicMock(autospec='sakia.gui.password_asker.PasswordAsker')
        self.node_manager = MagicMock(autospec='sakia.gui.node_manager.NodeManager')
Example #10
0
 def setUp(self):
     self.setUpQuamash()
     QLocale.setDefault(QLocale("en_GB"))
     self.identities_registry = Mock(spec='sakia.core.registry.IdentitiesRegistry')
     self.community = Mock(spec='sakia.core.Community')
     self.community.name = "test_brouzouf"
     self.community.bma_access = Mock(spec='sakia.core.net.api.bma.BmaAccess')
Example #11
0
def main():
    global app
    # register representation factories
    baseRepresentationFactories.registerAllFactories()
    representationFactories.registerAllFactories()
    # initialize the app
    app = Application(sys.argv)
    app.setOrganizationName("TruFont")
    app.setOrganizationDomain("trufont.github.io")
    app.setApplicationName("TruFont")
    app.setApplicationVersion(__version__)
    app.setWindowIcon(QIcon(":app.png"))
    app.setAttribute(Qt.AA_UseHighDpiPixmaps, True)

    # Install stream redirection
    app.outputWindow = OutputWindow()
    # Exception handling
    sys.excepthook = exceptionCallback

    # Qt's translation for itself. May not be installed.
    qtTranslator = QTranslator()
    qtTranslator.load("qt_" + QLocale.system().name(),
                      QLibraryInfo.location(QLibraryInfo.TranslationsPath))
    app.installTranslator(qtTranslator)

    appTranslator = QTranslator()
    appTranslator.load("trufont_" + QLocale.system().name(),
                       os.path.dirname(os.path.realpath(__file__)) +
                       "/resources")
    app.installTranslator(appTranslator)

    # parse options and open fonts
    parser = QCommandLineParser()
    parser.setApplicationDescription(QApplication.translate(
        "Command-line parser", "The TruFont font editor."))
    parser.addHelpOption()
    parser.addVersionOption()
    parser.addPositionalArgument(QApplication.translate(
        "Command-line parser", "files"), QApplication.translate(
        "Command-line parser", "The UFO files to open."))
    parser.process(app)
    args = parser.positionalArguments()
    if not args:
        fontPath = None
        # maybe load recent file
        settings = QSettings()
        loadRecentFile = settings.value("misc/loadRecentFile", False, bool)
        if loadRecentFile:
            recentFiles = settings.value("core/recentFiles", [], type=str)
            if len(recentFiles) and os.path.exists(recentFiles[0]):
                fontPath = recentFiles[0]
                app.openFile(fontPath)
        # otherwise, create a new file
        if fontPath is None:
            app.newFile()
    else:
        for fontPath in args:
            app.openFile(fontPath)
    sys.exit(app.exec_())
Example #12
0
    def data(self, index, role):
        source_index = self.mapToSource(index)
        model = self.sourceModel()
        source_data = model.data(source_index, role)
        state_col = model.columns_types.index('state')
        state_index = model.index(source_index.row(), state_col)
        state_data = model.data(state_index, Qt.DisplayRole)
        if role == Qt.DisplayRole:
            if source_index.column() == model.columns_types.index('uid'):
                return source_data
            if source_index.column() == model.columns_types.index('date'):
                return QLocale.toString(
                    QLocale(),
                    QDateTime.fromTime_t(source_data).date(),
                    QLocale.dateFormat(QLocale(), QLocale.ShortFormat)
                )
            if source_index.column() == model.columns_types.index('payment') or \
                    source_index.column() == model.columns_types.index('deposit'):
                if source_data is not "":
                    amount_ref = self.account.units_to_diff_ref(source_data,
                                                                self.community)
                    # if referential type is quantitative...
                    if self.account.ref_type() == 'q':
                        # display int values
                        return QLocale().toString(float(amount_ref), 'f', 0)
                    else:
                        # display float values
                        return QLocale().toString(amount_ref, 'f', 6)

        if role == Qt.FontRole:
            font = QFont()
            if state_data == Transfer.AWAITING:
                font.setItalic(True)
            elif state_data == Transfer.REFUSED:
                font.setItalic(True)
            elif state_data == Transfer.TO_SEND:
                font.setBold(True)
            else:
                font.setItalic(False)
            return font

        if role == Qt.ForegroundRole:
            if state_data == Transfer.REFUSED:
                return QColor(Qt.red)
            elif state_data == Transfer.TO_SEND:
                return QColor(Qt.blue)

        if role == Qt.TextAlignmentRole:
            if source_index.column() == self.sourceModel().columns_types.index(
                    'deposit') or source_index.column() == self.sourceModel().columns_types.index('payment'):
                return Qt.AlignRight | Qt.AlignVCenter
            if source_index.column() == self.sourceModel().columns_types.index('date'):
                return Qt.AlignCenter

        if role == Qt.ToolTipRole:
            if source_index.column() == self.sourceModel().columns_types.index('date'):
                return QDateTime.fromTime_t(source_data).toString(Qt.SystemLocaleLongDate)

        return source_data
Example #13
0
    def refresh_status(self):
        """
        Refresh status bar
        """
        logging.debug("Refresh status")
        if self.community:
            text = ""

            current_block_number = self.community.network.current_blockid.number
            if current_block_number:
                text += self.tr(" Block {0}").format(current_block_number)
                try:
                    block = yield from self.community.get_block(current_block_number)
                    text += " ({0})".format(QLocale.toString(
                                QLocale(),
                                QDateTime.fromTime_t(block['medianTime']),
                                QLocale.dateTimeFormat(QLocale(), QLocale.NarrowFormat)
                            ))
                except NoPeerAvailable as e:
                    logging.debug(str(e))
                    text += " ( ### ) "
                except ValueError as e:
                    logging.debug(str(e))

            if len(self.community.network.synced_nodes) == 0:
                self.button_membership.setEnabled(False)
                self.button_certification.setEnabled(False)
                self.button_send_money.setEnabled(False)
            else:
                self.button_membership.setEnabled(True)
                self.button_certification.setEnabled(True)
                self.button_send_money.setEnabled(True)

            if self.community.network.quality > 0.66:
                icon = '<img src=":/icons/connected" width="12" height="12"/>'
            elif self.community.network.quality > 0.33:
                icon = '<img src=":/icons/weak_connect" width="12" height="12"/>'
            else:
                icon = '<img src=":/icons/disconnected" width="12" height="12"/>'

            status_infotext = " - ".join([self.app.notifications[info][0] for info in self.status_info])
            label_text = "{0}{1}".format(icon, text)
            if status_infotext != "":
                label_text += " - {0}".format(status_infotext)

            if self.app.preferences['expert_mode']:
                try:
                    members_pubkeys = yield from self.community.members_pubkeys()
                    label_text += self.tr(" - Median fork window : {0}")\
                        .format(self.community.network.fork_window(members_pubkeys))
                except NoPeerAvailable as e:
                    logging.debug(str(e))
                    label_text += self.tr(" - Median fork window : {0}")\
                        .format("#")

            self.status_label.setText(label_text)
Example #14
0
 def switch_language(self):
     translator = QTranslator(self.qapp)
     logging.debug("Loading translations")
     locale = self.preferences["lang"]
     QLocale.setDefault(QLocale(locale))
     if translator.load(":/i18n/{0}".format(locale)):
         if QCoreApplication.installTranslator(translator):
             logging.debug("Loaded i18n/{0}".format(locale))
     else:
         logging.debug("Couldn't load translation")
Example #15
0
 def update_time(self):
     dateTime = QDateTime.currentDateTime()
     self.label_time.setText("{0}".format(QLocale.toString(
                     QLocale(),
                     QDateTime.currentDateTime(),
                     QLocale.dateTimeFormat(QLocale(), QLocale.NarrowFormat)
                 )))
     timer = QTimer()
     timer.timeout.connect(self.update_time)
     timer.start(1000)
Example #16
0
    def data(self, index, role):
        source_index = self.mapToSource(index)
        if source_index.isValid():
            source_data = self.sourceModel().data(source_index, role)
            expiration_col = self.sourceModel().columns_ids.index('expiration')
            expiration_index = self.sourceModel().index(source_index.row(), expiration_col)

            STATUS_NOT_MEMBER = 0
            STATUS_MEMBER = 1
            STATUS_EXPIRE_SOON = 3
            status = STATUS_NOT_MEMBER
            expiration_data = self.sourceModel().data(expiration_index, Qt.DisplayRole)
            current_time = QDateTime().currentDateTime().toMSecsSinceEpoch()
            sig_validity = self.sourceModel().sig_validity()
            warning_expiration_time = int(sig_validity / 3)
            #logging.debug("{0} > {1}".format(current_time, expiration_data))

            if expiration_data is not None:
                status = STATUS_MEMBER
                if current_time > (expiration_data*1000):
                    status = STATUS_NOT_MEMBER
                elif current_time > ((expiration_data*1000) - (warning_expiration_time*1000)):
                    status = STATUS_EXPIRE_SOON

            if role == Qt.DisplayRole:
                if source_index.column() in (self.sourceModel().columns_ids.index('renewed'),
                                             self.sourceModel().columns_ids.index('expiration'),
                                             self.sourceModel().columns_ids.index('publication')):
                    if source_data is not None:
                        return QLocale.toString(
                            QLocale(),
                            QDateTime.fromTime_t(source_data).date(),
                            QLocale.dateFormat(QLocale(), QLocale.ShortFormat)
                        )
                    else:
                        return ""
                if source_index.column() == self.sourceModel().columns_ids.index('pubkey'):
                    return "pub:{0}".format(source_data[:5])

            if role == Qt.ForegroundRole:
                if status == STATUS_EXPIRE_SOON:
                    return QColor("darkorange").darker(120)
                elif status == STATUS_NOT_MEMBER:
                    return QColor(Qt.red)
                else:
                    return QColor(Qt.blue)
            if role == Qt.DecorationRole and source_index.column() == self.sourceModel().columns_ids.index('uid'):
                if status == STATUS_NOT_MEMBER:
                    return QIcon(":/icons/not_member")
                elif status == STATUS_MEMBER:
                    return QIcon(":/icons/member")
                elif status == STATUS_EXPIRE_SOON:
                    return QIcon(":/icons/member_warning")

            return source_data
Example #17
0
    def add_certifier_list(self, certifier_list, person, person_account):
        """
        Add list of certifiers to graph
        :param list certifier_list: List of certifiers from api
        :param Person person:   Person instance which is certified
        :param Person person_account:   Account person instance
        :return:
        """
        #  add certifiers of uid
        for certifier in tuple(certifier_list):
            # add only valid certification...
            if (time.time() - certifier['cert_time']['medianTime']) > self.signature_validity:
                continue
            # new node
            if certifier['pubkey'] not in self._graph.keys():
                node_status = 0
                if certifier['pubkey'] == person_account.pubkey:
                    node_status += NODE_STATUS_HIGHLIGHTED
                if certifier['isMember'] is False:
                    node_status += NODE_STATUS_OUT
                self._graph[certifier['pubkey']] = {
                    'id': certifier['pubkey'],
                    'arcs': list(),
                    'text': certifier['uid'],
                    'tooltip': certifier['pubkey'],
                    'status': node_status,
                    'connected': [person.pubkey]
                }

            # keep only the latest certification
            if self._graph[certifier['pubkey']]['arcs']:
                if certifier['cert_time']['medianTime'] < self._graph[certifier['pubkey']]['arcs'][0]['cert_time']:
                    continue
            # display validity status
            if (time.time() - certifier['cert_time']['medianTime']) > self.ARC_STATUS_STRONG_time:
                arc_status = ARC_STATUS_WEAK
            else:
                arc_status = ARC_STATUS_STRONG
            arc = {
                'id': person.pubkey,
                'status': arc_status,
                'tooltip': QLocale.toString(
                    QLocale(),
                    QDateTime.fromTime_t(certifier['cert_time']['medianTime'] + self.signature_validity).date(),
                    QLocale.dateFormat(QLocale(), QLocale.ShortFormat)
                ),
                'cert_time': certifier['cert_time']['medianTime']
            }
            #  add arc to certifier
            self._graph[certifier['pubkey']]['arcs'].append(arc)
            # if certifier node not in person nodes
            if certifier['pubkey'] not in tuple(self._graph[person.pubkey]['connected']):
                # add certifier node to person node
                self._graph[person.pubkey]['connected'].append(certifier['pubkey'])
Example #18
0
    def __init__(self, parent, gid, persepolis_setting):
        super().__init__(persepolis_setting)
        self.persepolis_setting = persepolis_setting
        self.parent = parent
        self.gid = gid
        self.status = None
        self.resume_pushButton.clicked.connect(self.resumePushButtonPressed)
        self.stop_pushButton.clicked.connect(self.stopPushButtonPressed)
        self.pause_pushButton.clicked.connect(self.pausePushButtonPressed)
        self.download_progressBar.setValue(0)
        self.limit_pushButton.clicked.connect(self.limitPushButtonPressed)

        self.limit_frame.setEnabled(False)
        self.limit_checkBox.toggled.connect(self.limitCheckBoxToggled)

        self.after_frame.setEnabled(False)
        self.after_checkBox.toggled.connect(self.afterCheckBoxToggled)

        self.after_pushButton.clicked.connect(self.afterPushButtonPressed)

# add support for other languages
        locale = str(self.persepolis_setting.value('settings/locale'))
        QLocale.setDefault(QLocale(locale))
        self.translator = QTranslator()
        if self.translator.load(':/translations/locales/ui_' + locale, 'ts'):
            QCoreApplication.installTranslator(self.translator)

# check if limit speed actived by user or not
        add_link_dictionary = self.parent.persepolis_db.searchGidInAddLinkTable(gid)

        limit = str(add_link_dictionary['limit_value'])
        if limit != '0':
            limit_number = limit[:-1]
            limit_unit = limit[-1]
            self.limit_spinBox.setValue(float(limit_number))
            if limit_unit == 'K':
                self.after_comboBox.setCurrentIndex(0)
            else:
                self.after_comboBox.setCurrentIndex(1)
            self.limit_checkBox.setChecked(True)

        self.after_comboBox.currentIndexChanged.connect(self.afterComboBoxChanged)

        self.limit_comboBox.currentIndexChanged.connect(self.limitComboBoxChanged)

        self.limit_spinBox.valueChanged.connect(self.limitComboBoxChanged)

  # set window size and position
        size = self.persepolis_setting.value(
            'ProgressWindow/size', QSize(595, 274))
        position = self.persepolis_setting.value(
            'ProgressWindow/position', QPoint(300, 300))
        self.resize(size)
        self.move(position)
Example #19
0
    def setUp(self):
        self.setUpQuamash()
        QLocale.setDefault(QLocale("en_GB"))

        self.identity = Mock(specs='sakia.core.registry.Identity')
        self.identity.pubkey = "HnFcSms8jzwngtVomTTnzudZx7SHUQY8sVE1y8yBmULk"
        self.identity.uid = "A"

        self.app = MagicMock(specs='sakia.core.Application')
        self.account = MagicMock(specs='sakia.core.Account')
        self.community = MagicMock(specs='sakia.core.Community')
        self.password_asker = MagicMock(specs='sakia.gui.password_asker.PasswordAsker')
Example #20
0
    def data(self, index, role):
        source_index = self.mapToSource(index)
        if source_index.isValid():
            source_data = self.sourceModel().data(source_index, role)
            publication_col = CertifiersTableModel.columns_ids.index('publication')
            publication_index = self.sourceModel().index(source_index.row(), publication_col)
            expiration_col = CertifiersTableModel.columns_ids.index('expiration')
            expiration_index = self.sourceModel().index(source_index.row(), expiration_col)
            written_col = CertifiersTableModel.columns_ids.index('written')
            written_index = self.sourceModel().index(source_index.row(), written_col)

            publication_data = self.sourceModel().data(publication_index, Qt.DisplayRole)
            expiration_data = self.sourceModel().data(expiration_index, Qt.DisplayRole)
            written_data = self.sourceModel().data(written_index, Qt.DisplayRole)
            current_time = QDateTime().currentDateTime().toMSecsSinceEpoch()
            warning_expiration_time = int((expiration_data - publication_data) / 3)
            #logging.debug("{0} > {1}".format(current_time, expiration_data))

            if role == Qt.DisplayRole:
                if source_index.column() == CertifiersTableModel.columns_ids.index('expiration'):
                    if source_data:
                        ts = self.blockchain_processor.adjusted_ts(self.app.currency, source_data)
                        return QLocale.toString(
                            QLocale(),
                            QDateTime.fromTime_t(ts),
                            QLocale.dateTimeFormat(QLocale(), QLocale.ShortFormat)
                        ) + " BAT"
                    else:
                        return ""
                if source_index.column() == CertifiersTableModel.columns_ids.index('publication'):
                    if source_data:
                        ts = self.blockchain_processor.adjusted_ts(self.app.currency, source_data)
                        return QLocale.toString(
                            QLocale(),
                            QDateTime.fromTime_t(ts),
                            QLocale.dateTimeFormat(QLocale(), QLocale.ShortFormat)
                        ) + " BAT"
                    else:
                        return ""
                if source_index.column() == CertifiersTableModel.columns_ids.index('pubkey'):
                    return source_data

            if role == Qt.FontRole:
                font = QFont()
                if not written_data:
                    font.setItalic(True)
                return font

            if role == Qt.ForegroundRole:
                if current_time > ((expiration_data*1000) - (warning_expiration_time*1000)):
                    return QColor("darkorange").darker(120)

            return source_data
    def loadLanguage(self, language):
        if not self.language == language:
            self.language = language

            locale = QLocale(language)
            QLocale.setDefault(locale)

            self.switchTranslator(self.qtTl, "qtbase", language)
            self.switchTranslator(self.appTl, "wuchshuellenrechner", language)

            # update gui
            self.retranslateUi()
            self.dataWidget.retranslateUi()
Example #22
0
 def switch_language(self):
     logging.debug("Loading translations")
     locale = self.preferences['lang']
     QLocale.setDefault(QLocale(locale))
     QCoreApplication.removeTranslator(self._translator)
     self._translator = QTranslator(self.qapp)
     if locale == "en_GB":
         QCoreApplication.installTranslator(self._translator)
     elif self._translator.load(":/i18n/{0}".format(locale)):
         if QCoreApplication.installTranslator(self._translator):
             logging.debug("Loaded i18n/{0}".format(locale))
         else:
             logging.debug("Couldn't load translation")
Example #23
0
    def setUp(self):
        self.setUpQuamash()
        QLocale.setDefault(QLocale("en_GB"))
        self.identities_registry = IdentitiesRegistry({})

        self.application = Application(self.qapplication, self.lp, self.identities_registry)
        self.application.preferences['notifications'] = False
        # Salt/password : "******"
        # Pubkey : 7Aqw6Efa9EzE7gtsc8SveLLrM7gm6NEGoywSv4FJx6pZ
        self.account = Account("testsakia", "B7J4sopyfqzi3uh4Gzsdnp1XHc87NaxY7rqW2exgivCa",
                               "test", [], [], [], self.identities_registry)
        self.password_asker = PasswordAskerDialog(self.account)
        self.password_asker.password = "******"
        self.password_asker.remember = True
Example #24
0
def main():
    locale = QLocale(QLocale.C)
    locale.setNumberOptions(QLocale.RejectGroupSeparator)
    QLocale.setDefault(locale)

    config = Config()
    config.removeOldFiles()

    app = QApplication([])

    window = MainWindow()
    window.show()

    sys.exit(app.exec_())
Example #25
0
    async def refresh(self):
        if self.identity and self.identity.local_state != LocalState.NOT_FOUND:
            self.ui.busy.show()
            self.ui.label_uid.setText(self.identity.uid)
            self.ui.label_properties.setText("")
            try:
                identity_selfcert = await self.identity.selfcert(self.community)
                publish_time = await self.community.time(identity_selfcert.timestamp.number)

                join_date = await self.identity.get_join_date(self.community)
                if join_date is None:
                    join_date = self.tr('not a member')
                else:
                    join_date = datetime.datetime.fromtimestamp(join_date).strftime("%d/%m/%Y %I:%M")

            except MembershipNotFoundError:
                join_date = "###"
            except (LookupFailureError, NoPeerAvailable):
                publish_time = None
                join_date = "###"

            if publish_time:
                uid_publish_date = QLocale.toString(
                        QLocale(),
                        QDateTime.fromTime_t(publish_time),
                        QLocale.dateTimeFormat(QLocale(), QLocale.ShortFormat)
                    )
            else:
                uid_publish_date = "###"

            text = self.tr("""
                <table cellpadding="5">
                <tr><td align="right"><b>{:}</b></div></td><td>{:}</td></tr>
                <tr><td align="right"><b>{:}</b></div></td><td>{:}</td></tr>
                <tr><td align="right"><b>{:}</b></div></td><td>{:}</td></tr>
                """).format(
                self.tr('Public key'),
                self.identity.pubkey,
                self.tr('UID Published on'),
                uid_publish_date,
                self.tr('Join date'),
                join_date
            )
            # close html text
            text += "</table>"

            # set text in label
            self.ui.label_properties.setText(text)
            self.ui.busy.hide()
Example #26
0
    def __init__(self, filepath=None):
        QObject.__init__(self)
        QTimer.singleShot(0, self.__launchTimerTimedOut)
        self.prefs = Preferences()
        self.prefs.load()
        global APP_PREFS
        APP_PREFS = self.prefs
        locale = QLocale.system()
        dateFormat = self.prefs.dateFormat
        decimalSep = locale.decimalPoint()
        groupingSep = locale.groupSeparator()
        cachePath = QStandardPaths.standardLocations(QStandardPaths.CacheLocation)[0]
        DateEdit.DATE_FORMAT = dateFormat
        self.model = MoneyGuruModel(
            view=self, date_format=dateFormat, decimal_sep=decimalSep,
            grouping_sep=groupingSep, cache_path=cachePath
        )
        self.mainWindow = MainWindow(app=self)
        self.preferencesPanel = PreferencesPanel(self.mainWindow, app=self)
        self.aboutBox = AboutBox(self.mainWindow, self)
        self.initialFilePath = None
        if filepath and op.exists(filepath):
            self.initialFilePath = filepath
        elif self.prefs.recentDocuments:
            self.initialFilePath = self.prefs.recentDocuments[0]

        self.finishedLaunching.connect(self.applicationFinishedLaunching)
        QCoreApplication.instance().aboutToQuit.connect(self.applicationWillTerminate)
Example #27
0
	def getExportExtensionsList(self):
		extensions = []
		for extsprefix in datadirs:
			extsdir = QDir(extsprefix+'/export-extensions/')
			if extsdir.exists():
				for fileInfo in extsdir.entryInfoList(['*.desktop', '*.ini'],
				QDir.Files | QDir.Readable):
					extensions.append(self.readExtension(fileInfo.filePath()))
		locale = QLocale.system().name()
		self.extensionActions = []
		for extension in extensions:
			try:
				if ('Name[%s]' % locale) in extension:
					name = extension['Name[%s]' % locale]
				elif ('Name[%s]' % locale.split('_')[0]) in extension:
					name = extension['Name[%s]' % locale.split('_')[0]]
				else:
					name = extension['Name']
				data = {}
				for prop in ('FileFilter', 'DefaultExtension', 'Exec'):
					if 'X-ReText-'+prop in extension:
						data[prop] = extension['X-ReText-'+prop]
					elif prop in extension:
						data[prop] = extension[prop]
					else:
						data[prop] = ''
				action = self.act(name, trig=self.extensionFunction(data))
				if 'Icon' in extension:
					action.setIcon(self.actIcon(extension['Icon']))
				mimetype = extension['MimeType'] if 'MimeType' in extension else None
			except KeyError:
				print('Failed to parse extension: Name is required', file=sys.stderr)
			else:
				self.extensionActions.append((action, mimetype))
Example #28
0
    def __init__(self, filepath=None):
        ApplicationBase.__init__(self)
        self.prefs = Preferences()
        self.prefs.load()
        global APP_PREFS
        APP_PREFS = self.prefs
        locale = QLocale.system()
        dateFormat = self.prefs.dateFormat
        decimalSep = locale.decimalPoint()
        groupingSep = locale.groupSeparator()
        cachePath = QStandardPaths.standardLocations(QStandardPaths.CacheLocation)[0]
        appdata = getAppData()
        DateEdit.DATE_FORMAT = dateFormat
        self.model = MoneyGuruModel(
            view=self, date_format=dateFormat, decimal_sep=decimalSep,
            grouping_sep=groupingSep, cache_path=cachePath, appdata_path=appdata,
        )
        # on the Qt side, we're single document based, so it's one doc per app.
        self.doc = Document(app=self)
        self.doc.model.connect()
        self.mainWindow = MainWindow(doc=self.doc)
        self.preferencesPanel = PreferencesPanel(self.mainWindow, app=self)
        self.aboutBox = AboutBox(self.mainWindow, self)
        self.initialFilePath = None
        if filepath and op.exists(filepath):
            self.initialFilePath = filepath
        elif self.prefs.recentDocuments:
            self.initialFilePath = self.prefs.recentDocuments[0]

        self.finishedLaunching.connect(self.applicationFinishedLaunching)
        QCoreApplication.instance().aboutToQuit.connect(self.applicationWillTerminate)
 def __init__(self):
     """
     Constructor
     """
     super(SnapshotFreehandGrabber, self).__init__(
         None,
         Qt.X11BypassWindowManagerHint | Qt.WindowStaysOnTopHint |
         Qt.FramelessWindowHint | Qt.Tool)
     
     self.__selection = QPolygon()
     self.__mouseDown = False
     self.__newSelection = False
     self.__handleSize = 10
     self.__showHelp = True
     self.__grabbing = False
     self.__dragStartPoint = QPoint()
     self.__selectionBeforeDrag = QPolygon()
     self.__locale = QLocale()
     
     self.__helpTextRect = QRect()
     self.__helpText = self.tr(
         "Select a region using the mouse. To take the snapshot,"
         " press the Enter key or double click. Press Esc to quit.")
     
     self.__pixmap = QPixmap()
     self.__pBefore = QPoint()
     
     self.setMouseTracking(True)
     
     QTimer.singleShot(200, self.__initialize)
    def save(self):
        """
        Public slot to save the Help Viewers configuration.
        """
        Preferences.setHelp("SingleHelpWindow",
                            self.singleHelpWindowCheckBox.isChecked())
        Preferences.setHelp("SaveGeometry",
                            self.saveGeometryCheckBox.isChecked())
        Preferences.setHelp("WebSearchSuggestions",
                            self.webSuggestionsCheckBox.isChecked())
        Preferences.setHelp("ShowPreview", self.showTabPreviews.isChecked())
        Preferences.setHelp("AccessKeysEnabled",
                            self.accessKeysCheckBox.isChecked())

        Preferences.setHelp("JavaEnabled", self.javaCheckBox.isChecked())
        Preferences.setHelp("JavaScriptEnabled",
                            self.javaScriptCheckBox.isChecked())
        Preferences.setHelp("JavaScriptCanOpenWindows",
                            self.jsOpenWindowsCheckBox.isChecked())
        Preferences.setHelp("JavaScriptCanAccessClipboard",
                            self.jsClipboardCheckBox.isChecked())
        Preferences.setHelp("PluginsEnabled", self.pluginsCheckBox.isChecked())
        Preferences.setHelp("ClickToFlashEnabled",
                            self.clickToFlashCheckBox.isChecked())
        Preferences.setHelp("DoNotTrack", self.doNotTrackCheckBox.isChecked())
        Preferences.setHelp("SendReferer",
                            self.sendRefererCheckBox.isChecked())

        Preferences.setHelp("DiskCacheEnabled",
                            self.diskCacheCheckBox.isChecked())
        Preferences.setHelp("DiskCacheSize", self.cacheSizeSpinBox.value())
        if self.cacheKeepButton.isChecked():
            Preferences.setHelp("CachePolicy", QNetworkRequest.PreferNetwork)
        elif self.cachePreferButton.isChecked():
            Preferences.setHelp("CachePolicy", QNetworkRequest.PreferCache)
        elif self.cacheOfflineButton.isChecked():
            Preferences.setHelp("CachePolicy", QNetworkRequest.AlwaysCache)

        Preferences.setHelp("PrintBackgrounds",
                            self.printBackgroundsCheckBox.isChecked())

        Preferences.setHelp("StartupBehavior",
                            self.startupCombo.currentIndex())
        Preferences.setHelp("HomePage", self.homePageEdit.text())

        Preferences.setHelp("DefaultScheme",
                            self.defaultSchemeCombo.currentText())

        idx = self.expireHistory.currentIndex()
        if idx == 0:
            historyLimit = 1
        elif idx == 1:
            historyLimit = 7
        elif idx == 2:
            historyLimit = 14
        elif idx == 3:
            historyLimit = 30
        elif idx == 4:
            historyLimit = 365
        elif idx == 5:
            historyLimit = -1
        elif idx == 6:
            historyLimit = -2
        Preferences.setHelp("HistoryLimit", historyLimit)

        languageIndex = self.languageCombo.currentIndex()
        if languageIndex > -1:
            language = self.languageCombo.itemData(languageIndex)
        else:
            # fall back to system default
            language = QLocale.system().language()
        Preferences.setHelp("SearchLanguage", language)

        if hasattr(QWebSettings, "SpatialNavigationEnabled"):
            Preferences.setHelp("SpatialNavigationEnabled",
                                self.spatialCheckBox.isChecked())
        if hasattr(QWebSettings, "LinksIncludedInFocusChain"):
            Preferences.setHelp("LinksIncludedInFocusChain",
                                self.linksInFocusChainCheckBox.isChecked())
        if hasattr(QWebSettings, "XSSAuditingEnabled"):
            Preferences.setHelp("XSSAuditingEnabled",
                                self.xssAuditingCheckBox.isChecked())
        if hasattr(QWebSettings, "SiteSpecificQuirksEnabled"):
            Preferences.setHelp("SiteSpecificQuirksEnabled",
                                self.quirksCheckBox.isChecked())
Example #31
0
t1 = QTime(18, 50, 59)
dt1 = QDateTime(d1, t1, Qt.LocalTime)
print("Datetime: {0}".format(dt1.toString()))
print("Date: {0}".format(d1.toString()))
print("Time: {0}".format(t1.toString()))

now = QDate.currentDate()
print(now.toString(Qt.ISODate))
print(now.toString(Qt.DefaultLocaleLongDate))
datetime = QDateTime.currentDateTime()
print(datetime.toString())

dayOfWeek = now.dayOfWeek()
print(QDate.shortDayName(dayOfWeek))
print(QDate.longDayName(dayOfWeek))
locale = QLocale(QLocale.Russian, QLocale.RussianFederation)
print(locale.toString(now, 'dddd'))

# prints current time
time = QTime.currentTime()
print(time.toString(Qt.DefaultLocaleLongDate))

now = QDateTime.currentDateTime()
print("Local datetime: ", now.toString(Qt.ISODate))
print("Universal datetime: ", now.toUTC().toString(Qt.ISODate))
print("The offset from UTC is: {0} seconds".format(now.offsetFromUtc()))

# comparing two dates
d1 = QDate(2017, 4, 5)
d2 = QDate(2016, 4, 5)
if d1 < d2:
Example #32
0
    def __init__(self,
                 parent,
                 title="pymodaq Move",
                 preset=None,
                 init=False,
                 controller_ID=-1):

        # DAQ_Move object is a module used to control one motor from a specified list.
        # managers is an optional list of dicts used to managers programatically settings such as the name of the controller from the list of possible controllers, COM address...
        # init is a boolean to tell the programm to initialize the controller at the start of the programm given the managers options
        # controller_ID is a unique random integer generated by the parent caller. To differenciate various instance of this class
        self.logger = utils.set_logger(f'{logger.name}.{title}')
        self.logger.info(f'Initializing DAQ_Move: {title}')
        QLocale.setDefault(QLocale(QLocale.English, QLocale.UnitedStates))
        super(DAQ_Move, self).__init__()

        self.ui = Ui_Form()
        self.ui.setupUi(parent)
        self.ui.Moveto_pb_bis_2.setVisible(False)
        self.parent = parent
        self.ui.title_label.setText(title)
        self.title = title
        self.ui.statusbar = QtWidgets.QStatusBar(parent)
        self.ui.StatusBarLayout.addWidget(self.ui.statusbar)
        self.ui.statusbar.setMaximumHeight(20)

        self.send_to_tcpip = False
        self.tcpclient_thread = None

        self.wait_time = 1000
        self.ui.Ini_state_LED

        self.ui.Ini_state_LED.clickable = False
        self.ui.Ini_state_LED.set_as_false()
        self.ui.Move_Done_LED.clickable = False
        self.ui.Move_Done_LED.set_as_false()
        self.initialized_state = False
        self.ui.Current_position_sb.setReadOnly(False)
        self.move_done_bool = True

        ############IMPORTANT############################
        self.controller = None  # the hardware controller/set after initialization and to be used by other modules
        #################################################

        self.current_position = 0
        self.target_position = 0
        self.wait_position_flag = True

        self.ui.Current_position_sb.setValue(self.current_position)
        self.set_enabled_move_buttons(enable=False)
        self.ui.groupBox.hide()
        self.parent.resize(150, 200)

        ##Setting stages types
        self.stage_types = DAQ_Move_Stage_type.names('daq_move')
        self.ui.Stage_type_combo.clear()
        self.ui.Stage_type_combo.addItems(self.stage_types)

        #create main parameter tree
        self.ui.settings_tree = ParameterTree()
        self.ui.verticalLayout_2.addWidget(self.ui.settings_tree)
        self.ui.settings_tree.setMinimumWidth(300)

        self.settings = Parameter.create(name='Settings',
                                         type='group',
                                         children=self.params)
        self.ui.settings_tree.setParameters(self.settings, showTop=False)

        #connecting from tree
        self.settings.sigTreeStateChanged.connect(
            self.parameter_tree_changed
        )  #any changes on the settings will update accordingly the detector
        self.ui.settings_tree.setVisible(False)
        self.set_setting_tree()
        self.settings.child('main_settings',
                            'controller_ID').setValue(controller_ID)

        QtWidgets.QApplication.processEvents()
        ##Connecting buttons:
        self.ui.Stage_type_combo.currentIndexChanged.connect(
            self.set_setting_tree)
        self.ui.Stage_type_combo.currentIndexChanged.connect(
            self.stage_changed)

        self.ui.Quit_pb.clicked.connect(self.quit_fun)
        self.ui.IniStage_pb.clicked.connect(self.ini_stage_fun)

        self.update_status("Ready", wait_time=self.wait_time)
        self.ui.Move_Abs_pb.clicked.connect(
            lambda: self.move_Abs(self.ui.Abs_position_sb.value()))
        self.ui.Move_Rel_plus_pb.clicked.connect(
            lambda: self.move_Rel(self.ui.Rel_position_sb.value()))
        self.ui.Move_Rel_minus_pb.clicked.connect(
            lambda: self.move_Rel(-self.ui.Rel_position_sb.value()))
        self.ui.Find_Home_pb.clicked.connect(self.move_Home)
        self.ui.Get_position_pb.clicked.connect(self.get_position)
        self.ui.Stop_pb.clicked.connect(self.stop_Motion)

        self.ui.parameters_pb.clicked.connect(self.show_settings)
        self.ui.fine_tuning_pb.clicked.connect(self.show_fine_tuning)
        self.ui.Abs_position_sb.valueChanged.connect(
            self.ui.Abs_position_sb_bis.setValue)
        self.ui.Abs_position_sb_bis.valueChanged.connect(
            self.ui.Abs_position_sb.setValue)
        self.ui.Moveto_pb_bis.clicked.connect(
            lambda: self.move_Abs(self.ui.Abs_position_sb_bis.value()))

        # set managers options
        if preset is not None:
            for preset_dict in preset:
                # fo instance preset_dict=dict(object='Stage_type_combo',method='setCurrentIndex',value=1)
                if hasattr(self.ui, preset_dict['object']):
                    obj = getattr(self.ui, preset_dict['object'])
                    if hasattr(obj, preset_dict['method']):
                        setattr(obj, preset_dict['method'],
                                preset_dict['value'])
            QtWidgets.QApplication.processEvents()
        #initialize the controller if init=True
        if init:
            self.ui.IniStage_pb.click()
Example #33
0
def init_language():
    """ Find the current locale, and install the correct translators """

    # Get app instance
    app = QCoreApplication.instance()

    # Setup of our list of translators and paths
    translator_types = (
        {
            "type": 'QT',
            "prefix":
            'qt_',  # Older versions of Qt use this file (built-in translations)
            "path": QLibraryInfo.location(QLibraryInfo.TranslationsPath)
        },
        {
            "type": 'QT',
            "prefix":
            'qtbase_',  # Newer versions of Qt use this file (built-in translations)
            "path": QLibraryInfo.location(QLibraryInfo.TranslationsPath)
        },
        {
            "type": 'QT',
            "prefix": 'qt_',
            "path": os.path.join(info.PATH, 'language')
        },  # Optional path where we package QT translations
        {
            "type": 'QT',
            "prefix": 'qtbase_',
            "path": os.path.join(info.PATH, 'language')
        },  # Optional path where we package QT translations
        {
            "type": 'OpenShot',
            "prefix": 'OpenShot_',  # Our custom translations
            "path": language_path
        },
    )

    # Determine the environment locale, or default to system locale name
    locale_names = [
        os.environ.get('LANG',
                       QLocale().system().name()),
        os.environ.get('LOCALE',
                       QLocale().system().name())
    ]

    # Get the user's configured language preference
    settings = app.get_settings()
    if settings:
        preference_lang = settings.get('default-language')
    else:
        preference_lang = "Default"

    # Output all languages detected from various sources
    log.info("Qt Detected Languages: {}".format(
        QLocale().system().uiLanguages()))
    log.info("LANG Environment Variable: {}".format(os.environ.get('LANG',
                                                                   "")))
    log.info("LOCALE Environment Variable: {}".format(
        os.environ.get('LOCALE', "")))
    log.info("OpenShot Preference Language: {}".format(preference_lang))

    # Check if the language preference is something other than "Default"
    if preference_lang == "en_US":
        # Override language list with en_US, don't add to it
        locale_names = ["en_US"]
    elif preference_lang != "Default":
        # Prepend preference setting to list
        locale_names.insert(0, preference_lang)

    # If the user has used the --lang command line arg, override with that
    # (We've already checked that it's in SUPPORTED_LANGUAGES)
    if info.CMDLINE_LANGUAGE:
        locale_names = [info.CMDLINE_LANGUAGE]
        log.info("Language overridden on command line, using: {}".format(
            info.CMDLINE_LANGUAGE))

    # Default the locale to C, for number formatting
    locale.setlocale(locale.LC_ALL, 'C')

    # Loop through environment variables
    found_language = False
    for locale_name in locale_names:

        # Go through each translator and try to add for current locale
        for type in translator_types:
            trans = QTranslator(app)
            if find_language_match(type["prefix"], type["path"], trans,
                                   locale_name):
                # Install translation
                app.installTranslator(trans)
                found_language = True

        # Exit if found language for type: "OpenShot"
        if found_language:
            log.debug(
                "Exiting translation system (since we successfully loaded: {})"
                .format(locale_name))
            info.CURRENT_LANGUAGE = locale_name
            break
Example #34
0
    def __init__(self, persepolis_setting):
        super().__init__()
        self.persepolis_setting = persepolis_setting

        # add support for other languages
        locale = str(self.persepolis_setting.value('settings/locale'))
        QLocale.setDefault(QLocale(locale))
        self.translator = QTranslator()
        if self.translator.load(':/translations/locales/ui_' + locale, 'ts'):
            QCoreApplication.installTranslator(self.translator)

        # set ui direction
        ui_direction = self.persepolis_setting.value('ui_direction')

        if ui_direction == 'rtl':
            self.setLayoutDirection(Qt.RightToLeft)

        elif ui_direction in 'ltr':
            self.setLayoutDirection(Qt.LeftToRight)

        # get icons name
        icons = ':/' + \
            str(self.persepolis_setting.value('settings/icons')) + '/'

        self.setMinimumSize(QtCore.QSize(520, 425))
        self.setWindowIcon(
            QIcon.fromTheme('persepolis', QIcon(':/persepolis.svg')))

        window_verticalLayout = QVBoxLayout()

        # add link tab widget
        self.add_link_tabWidget = QTabWidget(self)
        window_verticalLayout.addWidget(self.add_link_tabWidget)

        # link tab
        self.link_tab = QWidget()

        link_tab_verticalLayout = QVBoxLayout(self.link_tab)
        link_tab_verticalLayout.setContentsMargins(21, 21, 21, 81)

        self.link_frame = QFrame(self.link_tab)
        self.link_frame.setFrameShape(QFrame.StyledPanel)
        self.link_frame.setFrameShadow(QFrame.Raised)

        horizontalLayout_2 = QHBoxLayout(self.link_frame)

        self.link_verticalLayout = QVBoxLayout()

        # link ->
        self.link_horizontalLayout = QHBoxLayout()
        self.link_label = QLabel(self.link_frame)
        self.link_horizontalLayout.addWidget(self.link_label)

        self.link_lineEdit = QLineEdit(self.link_frame)
        self.link_horizontalLayout.addWidget(self.link_lineEdit)

        self.link_verticalLayout.addLayout(self.link_horizontalLayout)

        horizontalLayout_2.addLayout(self.link_verticalLayout)
        link_tab_verticalLayout.addWidget(self.link_frame)

        # add change_name field ->
        change_name_horizontalLayout = QHBoxLayout()
        self.change_name_checkBox = QCheckBox(self.link_frame)
        change_name_horizontalLayout.addWidget(self.change_name_checkBox)

        self.change_name_lineEdit = QLineEdit(self.link_frame)
        change_name_horizontalLayout.addWidget(self.change_name_lineEdit)

        self.link_verticalLayout.addLayout(change_name_horizontalLayout)

        # add_category ->
        queue_horizontalLayout = QHBoxLayout()

        self.queue_frame = QFrame(self)
        self.queue_frame.setFrameShape(QFrame.StyledPanel)
        self.queue_frame.setFrameShadow(QFrame.Raised)

        add_queue_horizontalLayout = QHBoxLayout(self.queue_frame)

        self.add_queue_label = QLabel(self.queue_frame)
        add_queue_horizontalLayout.addWidget(self.add_queue_label)

        self.add_queue_comboBox = QComboBox(self.queue_frame)
        add_queue_horizontalLayout.addWidget(self.add_queue_comboBox)

        queue_horizontalLayout.addWidget(self.queue_frame)
        queue_horizontalLayout.addStretch(1)

        self.size_label = QLabel(self)
        queue_horizontalLayout.addWidget(self.size_label)

        link_tab_verticalLayout.addLayout(queue_horizontalLayout)

        self.add_link_tabWidget.addTab(self.link_tab, '')

        # proxy tab
        self.proxy_tab = QWidget(self)

        proxy_verticalLayout = QVBoxLayout(self.proxy_tab)
        proxy_verticalLayout.setContentsMargins(21, 21, 21, 171)

        proxy_horizontalLayout = QHBoxLayout()

        self.proxy_checkBox = QCheckBox(self.proxy_tab)
        self.detect_proxy_pushButton = QPushButton(self.proxy_tab)
        self.detect_proxy_label = QLabel(self.proxy_tab)

        proxy_horizontalLayout.addWidget(self.proxy_checkBox)
        proxy_horizontalLayout.addWidget(self.detect_proxy_label)
        proxy_horizontalLayout.addWidget(self.detect_proxy_pushButton)

        proxy_verticalLayout.addLayout(proxy_horizontalLayout)

        self.proxy_frame = QFrame(self.proxy_tab)
        self.proxy_frame.setFrameShape(QFrame.StyledPanel)
        self.proxy_frame.setFrameShadow(QFrame.Raised)

        gridLayout = QGridLayout(self.proxy_frame)

        self.ip_label = QLabel(self.proxy_frame)
        gridLayout.addWidget(self.ip_label, 0, 0, 1, 1)

        self.ip_lineEdit = QLineEdit(self.proxy_frame)
        self.ip_lineEdit.setInputMethodHints(QtCore.Qt.ImhNone)
        gridLayout.addWidget(self.ip_lineEdit, 0, 1, 1, 1)

        self.port_label = QLabel(self.proxy_frame)
        gridLayout.addWidget(self.port_label, 0, 2, 1, 1)

        self.port_spinBox = QSpinBox(self.proxy_frame)
        self.port_spinBox.setMaximum(65535)
        self.port_spinBox.setSingleStep(1)
        gridLayout.addWidget(self.port_spinBox, 0, 3, 1, 1)

        self.proxy_user_label = QLabel(self.proxy_frame)
        gridLayout.addWidget(self.proxy_user_label, 2, 0, 1, 1)

        self.proxy_user_lineEdit = QLineEdit(self.proxy_frame)
        gridLayout.addWidget(self.proxy_user_lineEdit, 2, 1, 1, 1)

        self.proxy_pass_label = QLabel(self.proxy_frame)
        gridLayout.addWidget(self.proxy_pass_label, 2, 2, 1, 1)

        self.proxy_pass_lineEdit = QLineEdit(self.proxy_frame)
        self.proxy_pass_lineEdit.setEchoMode(QLineEdit.Password)
        gridLayout.addWidget(self.proxy_pass_lineEdit, 2, 3, 1, 1)

        proxy_verticalLayout.addWidget(self.proxy_frame)

        self.add_link_tabWidget.addTab(self.proxy_tab, '')

        # more options tab
        self.more_options_tab = QWidget(self)

        more_options_tab_verticalLayout = QVBoxLayout(self.more_options_tab)

        # download UserName & Password ->
        download_horizontalLayout = QHBoxLayout()
        download_horizontalLayout.setContentsMargins(-1, 10, -1, -1)

        download_verticalLayout = QVBoxLayout()
        self.download_checkBox = QCheckBox(self.more_options_tab)
        download_verticalLayout.addWidget(self.download_checkBox)

        self.download_frame = QFrame(self.more_options_tab)
        self.download_frame.setFrameShape(QFrame.StyledPanel)
        self.download_frame.setFrameShadow(QFrame.Raised)

        gridLayout_2 = QGridLayout(self.download_frame)

        self.download_user_lineEdit = QLineEdit(self.download_frame)
        gridLayout_2.addWidget(self.download_user_lineEdit, 0, 1, 1, 1)

        self.download_user_label = QLabel(self.download_frame)
        gridLayout_2.addWidget(self.download_user_label, 0, 0, 1, 1)

        self.download_pass_label = QLabel(self.download_frame)
        gridLayout_2.addWidget(self.download_pass_label, 1, 0, 1, 1)

        self.download_pass_lineEdit = QLineEdit(self.download_frame)
        self.download_pass_lineEdit.setEchoMode(QLineEdit.Password)
        gridLayout_2.addWidget(self.download_pass_lineEdit, 1, 1, 1, 1)
        download_verticalLayout.addWidget(self.download_frame)
        download_horizontalLayout.addLayout(download_verticalLayout)

        # select folder ->
        self.folder_frame = QFrame(self.more_options_tab)
        self.folder_frame.setFrameShape(QFrame.StyledPanel)
        self.folder_frame.setFrameShadow(QFrame.Raised)

        gridLayout_3 = QGridLayout(self.folder_frame)

        self.download_folder_lineEdit = QLineEdit(self.folder_frame)
        gridLayout_3.addWidget(self.download_folder_lineEdit, 2, 0, 1, 1)

        self.folder_pushButton = QPushButton(self.folder_frame)
        gridLayout_3.addWidget(self.folder_pushButton, 3, 0, 1, 1)
        self.folder_pushButton.setIcon(QIcon(icons + 'folder'))

        self.folder_label = QLabel(self.folder_frame)
        self.folder_label.setAlignment(QtCore.Qt.AlignCenter)
        gridLayout_3.addWidget(self.folder_label, 1, 0, 1, 1)
        download_horizontalLayout.addWidget(self.folder_frame)
        more_options_tab_verticalLayout.addLayout(download_horizontalLayout)

        # start time ->
        time_limit_horizontalLayout = QHBoxLayout()
        time_limit_horizontalLayout.setContentsMargins(-1, 10, -1, -1)

        start_verticalLayout = QVBoxLayout()
        self.start_checkBox = QCheckBox(self.more_options_tab)
        start_verticalLayout.addWidget(self.start_checkBox)

        self.start_frame = QFrame(self.more_options_tab)
        self.start_frame.setFrameShape(QFrame.StyledPanel)
        self.start_frame.setFrameShadow(QFrame.Raised)

        horizontalLayout_5 = QHBoxLayout(self.start_frame)

        self.start_time_qDataTimeEdit = QDateTimeEdit(self.start_frame)
        self.start_time_qDataTimeEdit.setDisplayFormat('H:mm')
        horizontalLayout_5.addWidget(self.start_time_qDataTimeEdit)

        start_verticalLayout.addWidget(self.start_frame)
        time_limit_horizontalLayout.addLayout(start_verticalLayout)

        # end time ->
        end_verticalLayout = QVBoxLayout()

        self.end_checkBox = QCheckBox(self.more_options_tab)
        end_verticalLayout.addWidget(self.end_checkBox)

        self.end_frame = QFrame(self.more_options_tab)
        self.end_frame.setFrameShape(QFrame.StyledPanel)
        self.end_frame.setFrameShadow(QFrame.Raised)

        horizontalLayout_6 = QHBoxLayout(self.end_frame)

        self.end_time_qDateTimeEdit = QDateTimeEdit(self.end_frame)
        self.end_time_qDateTimeEdit.setDisplayFormat('H:mm')
        horizontalLayout_6.addWidget(self.end_time_qDateTimeEdit)

        end_verticalLayout.addWidget(self.end_frame)
        time_limit_horizontalLayout.addLayout(end_verticalLayout)

        # limit Speed ->
        limit_verticalLayout = QVBoxLayout()

        self.limit_checkBox = QCheckBox(self.more_options_tab)
        limit_verticalLayout.addWidget(self.limit_checkBox)

        self.limit_frame = QFrame(self.more_options_tab)
        self.limit_frame.setFrameShape(QFrame.StyledPanel)
        self.limit_frame.setFrameShadow(QFrame.Raised)

        horizontalLayout_4 = QHBoxLayout(self.limit_frame)

        self.limit_spinBox = QDoubleSpinBox(self.limit_frame)
        self.limit_spinBox.setMinimum(1)
        self.limit_spinBox.setMaximum(1023)
        horizontalLayout_4.addWidget(self.limit_spinBox)

        self.limit_comboBox = QComboBox(self.limit_frame)
        self.limit_comboBox.addItem("")
        self.limit_comboBox.addItem("")
        horizontalLayout_4.addWidget(self.limit_comboBox)
        limit_verticalLayout.addWidget(self.limit_frame)
        time_limit_horizontalLayout.addLayout(limit_verticalLayout)
        more_options_tab_verticalLayout.addLayout(time_limit_horizontalLayout)

        # number of connections ->
        connections_horizontalLayout = QHBoxLayout()
        connections_horizontalLayout.setContentsMargins(-1, 10, -1, -1)

        self.connections_frame = QFrame(self.more_options_tab)
        self.connections_frame.setFrameShape(QFrame.StyledPanel)
        self.connections_frame.setFrameShadow(QFrame.Raised)

        horizontalLayout_3 = QHBoxLayout(self.connections_frame)
        self.connections_label = QLabel(self.connections_frame)
        horizontalLayout_3.addWidget(self.connections_label)

        self.connections_spinBox = QSpinBox(self.connections_frame)
        self.connections_spinBox.setMinimum(1)
        self.connections_spinBox.setMaximum(16)
        self.connections_spinBox.setProperty("value", 16)
        horizontalLayout_3.addWidget(self.connections_spinBox)
        connections_horizontalLayout.addWidget(self.connections_frame)
        connections_horizontalLayout.addStretch(1)

        more_options_tab_verticalLayout.addLayout(connections_horizontalLayout)

        self.add_link_tabWidget.addTab(self.more_options_tab, '')

        # advance options
        self.advance_options_tab = QWidget(self)

        advance_options_tab_verticalLayout = QVBoxLayout(
            self.advance_options_tab)

        # referer
        referer_horizontalLayout = QHBoxLayout()

        self.referer_label = QLabel(self.advance_options_tab)
        referer_horizontalLayout.addWidget(self.referer_label)

        self.referer_lineEdit = QLineEdit(self.advance_options_tab)
        referer_horizontalLayout.addWidget(self.referer_lineEdit)

        advance_options_tab_verticalLayout.addLayout(referer_horizontalLayout)

        # header
        header_horizontalLayout = QHBoxLayout()

        self.header_label = QLabel(self.advance_options_tab)
        header_horizontalLayout.addWidget(self.header_label)

        self.header_lineEdit = QLineEdit(self.advance_options_tab)
        header_horizontalLayout.addWidget(self.header_lineEdit)

        advance_options_tab_verticalLayout.addLayout(header_horizontalLayout)

        # user_agent
        user_agent_horizontalLayout = QHBoxLayout()

        self.user_agent_label = QLabel(self.advance_options_tab)
        user_agent_horizontalLayout.addWidget(self.user_agent_label)

        self.user_agent_lineEdit = QLineEdit(self.advance_options_tab)
        user_agent_horizontalLayout.addWidget(self.user_agent_lineEdit)

        advance_options_tab_verticalLayout.addLayout(
            user_agent_horizontalLayout)

        # load_cookies
        load_cookies_horizontalLayout = QHBoxLayout()

        self.load_cookies_label = QLabel(self.advance_options_tab)
        load_cookies_horizontalLayout.addWidget(self.load_cookies_label)

        self.load_cookies_lineEdit = QLineEdit(self.advance_options_tab)
        load_cookies_horizontalLayout.addWidget(self.load_cookies_lineEdit)

        advance_options_tab_verticalLayout.addLayout(
            load_cookies_horizontalLayout)

        self.add_link_tabWidget.addTab(self.advance_options_tab, '')

        # ok cancel download_later buttons ->
        buttons_horizontalLayout = QHBoxLayout()
        buttons_horizontalLayout.addStretch(1)

        self.download_later_pushButton = QPushButton(self)
        self.download_later_pushButton.setIcon(QIcon(icons + 'stop'))

        self.cancel_pushButton = QPushButton(self)
        self.cancel_pushButton.setIcon(QIcon(icons + 'remove'))

        self.ok_pushButton = QPushButton(self)
        self.ok_pushButton.setIcon(QIcon(icons + 'ok'))

        buttons_horizontalLayout.addWidget(self.download_later_pushButton)
        buttons_horizontalLayout.addWidget(self.cancel_pushButton)
        buttons_horizontalLayout.addWidget(self.ok_pushButton)

        window_verticalLayout.addLayout(buttons_horizontalLayout)

        self.setLayout(window_verticalLayout)

        # labels ->
        self.setWindowTitle(
            QCoreApplication.translate("addlink_ui_tr", "Enter Your Link"))

        self.link_label.setText(
            QCoreApplication.translate("addlink_ui_tr", "Download Link : "))

        self.add_queue_label.setText(
            QCoreApplication.translate("addlink_ui_tr", "Add to category : "))

        self.change_name_checkBox.setText(
            QCoreApplication.translate("addlink_ui_tr", "Change File Name : "))

        self.detect_proxy_pushButton.setText(
            QCoreApplication.translate("addlink_ui_tr",
                                       "Detect system proxy setting"))
        self.proxy_checkBox.setText(
            QCoreApplication.translate("addlink_ui_tr", "Proxy"))
        self.proxy_pass_label.setText(
            QCoreApplication.translate("addlink_ui_tr", "Proxy PassWord : "******"addlink_ui_tr", "IP : "))
        self.proxy_user_label.setText(
            QCoreApplication.translate("addlink_ui_tr", "Proxy UserName : "******"addlink_ui_tr", "Port:"))

        self.download_checkBox.setText(
            QCoreApplication.translate("addlink_ui_tr",
                                       "Download UserName and PassWord"))
        self.download_user_label.setText(
            QCoreApplication.translate("addlink_ui_tr",
                                       "Download UserName : "******"addlink_ui_tr",
                                       "Download PassWord : "******"addlink_ui_tr",
                                       "Change Download Folder"))
        self.folder_label.setText(
            QCoreApplication.translate("addlink_ui_tr", "Download Folder : "))

        self.start_checkBox.setText(
            QCoreApplication.translate("addlink_ui_tr", "Start Time"))
        self.end_checkBox.setText(
            QCoreApplication.translate("addlink_ui_tr", "End Time"))

        self.limit_checkBox.setText(
            QCoreApplication.translate("addlink_ui_tr", "Limit Speed"))
        self.limit_comboBox.setItemText(
            0, QCoreApplication.translate("addlink_ui_tr", "KB/S"))
        self.limit_comboBox.setItemText(
            1, QCoreApplication.translate("addlink_ui_tr", "MB/S"))

        self.connections_label.setText(
            QCoreApplication.translate("addlink_ui_tr",
                                       "Number Of Connections :"))

        self.cancel_pushButton.setText(
            QCoreApplication.translate("addlink_ui_tr", "Cancel"))
        self.ok_pushButton.setText(
            QCoreApplication.translate("addlink_ui_tr", "OK"))

        self.download_later_pushButton.setText(
            QCoreApplication.translate("addlink_ui_tr", "Download later"))

        self.add_link_tabWidget.setTabText(
            self.add_link_tabWidget.indexOf(self.link_tab),
            QCoreApplication.translate("addlink_ui_tr", "Link"))

        self.add_link_tabWidget.setTabText(
            self.add_link_tabWidget.indexOf(self.proxy_tab),
            QCoreApplication.translate("addlink_ui_tr", "Proxy"))

        self.add_link_tabWidget.setTabText(
            self.add_link_tabWidget.indexOf(self.more_options_tab),
            QCoreApplication.translate("addlink_ui_tr", "More Options"))

        self.add_link_tabWidget.setTabText(
            self.add_link_tabWidget.indexOf(self.advance_options_tab),
            QCoreApplication.translate("addlink_ui_tr", "Advanced Options"))

        self.referer_label.setText(
            QCoreApplication.translate("addlink_ui_tr", 'Referrer: '))

        self.header_label.setText(
            QCoreApplication.translate("addlink_ui_tr", 'Header: '))

        self.load_cookies_label.setText(
            QCoreApplication.translate("addlink_ui_tr", 'Load cookies: '))

        self.user_agent_label.setText(
            QCoreApplication.translate("addlink_ui_tr", 'User agent: '))
Example #35
0
    def __init__(self, persepolis_setting):
        super().__init__()
        self.persepolis_setting = persepolis_setting
        icons = ':/' + str(persepolis_setting.value('settings/icons')) + '/'

        # add support for other languages
        locale = str(self.persepolis_setting.value('settings/locale'))
        QLocale.setDefault(QLocale(locale))
        self.translator = QTranslator()
        if self.translator.load(':/translations/locales/ui_' + locale, 'ts'):
            QCoreApplication.installTranslator(self.translator)
            
        # set ui direction
        ui_direction = self.persepolis_setting.value('ui_direction')

        if ui_direction == 'rtl':
            self.setLayoutDirection(Qt.RightToLeft)
        
        elif ui_direction in 'ltr':
            self.setLayoutDirection(Qt.LeftToRight)


# window
        self.setMinimumSize(QtCore.QSize(595, 284))

        self.setWindowIcon(QIcon.fromTheme('persepolis', QIcon(':/persepolis.svg')))
        self.setWindowTitle(QCoreApplication.translate("progress_ui_tr", "Persepolis Download Manager"))

        verticalLayout = QVBoxLayout(self)

# progress_tabWidget
        self.progress_tabWidget = QTabWidget(self)

# information_tab
        self.information_tab = QWidget()
        information_verticalLayout = QVBoxLayout(self.information_tab)

# link_label
        self.link_label = QLabel(self.information_tab)
        information_verticalLayout.addWidget(self.link_label)

# status_label
        self.status_label = QLabel(self.information_tab)
        information_verticalLayout.addWidget(self.status_label)

# downloaded_label
        self.downloaded_label = QLabel(self.information_tab)
        information_verticalLayout.addWidget(self.downloaded_label)

# rate_label
        self.rate_label = QLabel(self.information_tab)
        information_verticalLayout.addWidget(self.rate_label)

# time_label
        self.time_label = QLabel(self.information_tab)
        information_verticalLayout.addWidget(self.time_label)

# connections_label
        self.connections_label = QLabel(self.information_tab)
        information_verticalLayout.addWidget(self.connections_label)

# add information_tab to progress_tabWidget
        self.progress_tabWidget.addTab(self.information_tab, "")

# options_tab
        self.options_tab = QWidget()
        options_tab_horizontalLayout = QHBoxLayout(self.options_tab)
        options_tab_horizontalLayout.setContentsMargins(11, 11, 11, 11)

        
# limit_checkBox
        self.limit_checkBox = QCheckBox(self.options_tab)

        limit_verticalLayout = QVBoxLayout()
        limit_verticalLayout.addWidget(self.limit_checkBox)

# limit_frame
        self.limit_frame = QFrame(self.options_tab)
        self.limit_frame.setFrameShape(QtWidgets.QFrame.StyledPanel)
        self.limit_frame.setFrameShadow(QtWidgets.QFrame.Raised)
        limit_frame_verticalLayout = QVBoxLayout(self.limit_frame)
        limit_frame_horizontalLayout = QHBoxLayout()

# limit_spinBox
        self.limit_spinBox = QDoubleSpinBox(self.options_tab)
        self.limit_spinBox.setMinimum(1)
        self.limit_spinBox.setMaximum(1023)
        limit_frame_horizontalLayout.addWidget(self.limit_spinBox)

# limit_comboBox
        self.limit_comboBox = QComboBox(self.options_tab)
        self.limit_comboBox.addItem("")
        self.limit_comboBox.addItem("")

        limit_frame_horizontalLayout.addWidget(self.limit_comboBox)

# limit_pushButton
        self.limit_pushButton = QPushButton(self.options_tab)
        
        limit_frame_verticalLayout.addLayout(limit_frame_horizontalLayout)
        limit_frame_verticalLayout.addWidget(self.limit_pushButton)

        limit_verticalLayout.addWidget(self.limit_frame)

        limit_verticalLayout.setContentsMargins(11, 11, 11, 11)


        options_tab_horizontalLayout.addLayout(limit_verticalLayout)

# after_checkBox
        self.after_checkBox = QCheckBox(self.options_tab)

        after_verticalLayout = QVBoxLayout()
        after_verticalLayout.addWidget(self.after_checkBox)

# after_frame
        self.after_frame = QFrame(self.options_tab)
        self.after_frame.setFrameShape(QtWidgets.QFrame.StyledPanel)
        self.after_frame.setFrameShadow(QtWidgets.QFrame.Raised)

        after_frame_verticalLayout = QVBoxLayout(self.after_frame)



# after_comboBox
        self.after_comboBox = QComboBox(self.options_tab)
        self.after_comboBox.addItem("")

        after_frame_verticalLayout.addWidget(self.after_comboBox)

# after_pushButton
        self.after_pushButton = QPushButton(self.options_tab)
        after_frame_verticalLayout.addWidget(self.after_pushButton)

        after_verticalLayout.addWidget(self.after_frame)

        after_verticalLayout.setContentsMargins(11, 11, 11, 11)
        options_tab_horizontalLayout.addLayout(after_verticalLayout)

        self.progress_tabWidget.addTab(self.options_tab, "")

        verticalLayout.addWidget(self.progress_tabWidget)


# download_progressBar
        self.download_progressBar = QProgressBar(self)
        verticalLayout.addWidget(self.download_progressBar)

# buttons
        button_horizontalLayout = QHBoxLayout()
        button_horizontalLayout.addStretch(1)

# resume_pushButton
        self.resume_pushButton = QPushButton(self)
        self.resume_pushButton.setIcon(QIcon(icons + 'play'))
        button_horizontalLayout.addWidget(self.resume_pushButton)

# pause_pushButton
        self.pause_pushButton = QtWidgets.QPushButton(self)
        self.pause_pushButton.setIcon(QIcon(icons + 'pause'))
        button_horizontalLayout.addWidget(self.pause_pushButton)

# stop_pushButton
        self.stop_pushButton = QtWidgets.QPushButton(self)
        self.stop_pushButton.setIcon(QIcon(icons + 'stop'))
        button_horizontalLayout.addWidget(self.stop_pushButton)


        verticalLayout.addLayout(button_horizontalLayout)

        self.progress_tabWidget.setCurrentIndex(0)
# labels
        self.link_label.setText(QCoreApplication.translate("progress_ui_tr", "Link:"))
        self.status_label.setText(QCoreApplication.translate("progress_ui_tr", "Status: "))
        self.downloaded_label.setText(QCoreApplication.translate("progress_ui_tr", "Downloaded:"))
        self.rate_label.setText(QCoreApplication.translate("progress_ui_tr", "Transfer rate: "))
        self.time_label.setText(QCoreApplication.translate("progress_ui_tr", "Estimated time left:"))
        self.connections_label.setText(QCoreApplication.translate("progress_ui_tr", "Number of connections: "))
        self.progress_tabWidget.setTabText(self.progress_tabWidget.indexOf(
            self.information_tab),  QCoreApplication.translate("progress_ui_tr", "Download Information"))
        self.limit_checkBox.setText(QCoreApplication.translate("progress_ui_tr", "Limit Speed"))
        self.after_checkBox.setText(QCoreApplication.translate("progress_ui_tr", "After download"))
        self.limit_comboBox.setItemText(0, "KiB/s")
        self.limit_comboBox.setItemText(1, "MiB/s")
        self.limit_pushButton.setText(QCoreApplication.translate("progress_ui_tr", "Apply"))

        self.after_comboBox.setItemText(0,  QCoreApplication.translate("progress_ui_tr", "Shut Down"))

        self.progress_tabWidget.setTabText(
            self.progress_tabWidget.indexOf(self.options_tab),  QCoreApplication.translate("progress_ui_tr", "Download Options"))
        self.resume_pushButton.setText(QCoreApplication.translate("progress_ui_tr", "Resume"))
        self.pause_pushButton.setText(QCoreApplication.translate("progress_ui_tr", "Pause"))
        self.stop_pushButton.setText(QCoreApplication.translate("progress_ui_tr", "Stop"))
        self.after_pushButton.setText(QCoreApplication.translate("progress_ui_tr", "Apply"))
Example #36
0
    def data(self, index, role):
        source_index = self.mapToSource(index)
        source_model = self.sourceModel()
        if not source_index.isValid():
            return QVariant()
        source_data = source_model.data(source_index, role)

        if role == Qt.DisplayRole:
            if index.column() == NetworkTableModel.columns_types.index(
                    'is_member'):
                value = {
                    True: QT_TRANSLATE_NOOP("NetworkTableModel", 'yes'),
                    False: QT_TRANSLATE_NOOP("NetworkTableModel", 'no'),
                    None: QT_TRANSLATE_NOOP("NetworkTableModel", 'offline')
                }
                return value[source_data]

            if index.column() == NetworkTableModel.columns_types.index(
                    'pubkey'):
                return source_data[:5]

            if index.column() == NetworkTableModel.columns_types.index(
                    'current_block'):
                if source_data == -1:
                    return ""
                else:
                    return source_data

            if index.column() == NetworkTableModel.columns_types.index('address') \
                    or index.column() == NetworkTableModel.columns_types.index('port'):
                return "<p>" + source_data.replace('\n', "<br>") + "</p>"

            if index.column() == NetworkTableModel.columns_types.index(
                    'current_hash'):
                return source_data[:10]

            if index.column() == NetworkTableModel.columns_types.index(
                    'current_time') and source_data:
                ts = self.blockchain_processor.adjusted_ts(
                    self.app.currency, source_data)
                return QLocale.toString(
                    QLocale(), QDateTime.fromTime_t(ts),
                    QLocale.dateTimeFormat(QLocale(), QLocale.ShortFormat))

        if role == Qt.TextAlignmentRole:
            if source_index.column() == NetworkTableModel.columns_types.index(
                    'address') or source_index.column() == self.sourceModel(
                    ).columns_types.index('current_block'):
                return Qt.AlignRight | Qt.AlignVCenter
            if source_index.column() == NetworkTableModel.columns_types.index(
                    'is_member'):
                return Qt.AlignCenter

        if role == Qt.FontRole:
            is_root_col = NetworkTableModel.columns_types.index('is_root')
            index_root_col = source_model.index(source_index.row(),
                                                is_root_col)
            if source_model.data(index_root_col, Qt.DisplayRole):
                font = QFont()
                font.setBold(True)
                return font

        return source_data
Example #37
0
    def __init__(self, datadir=None, logdir=None):
        DistUpgradeView.__init__(self)

        get_telemetry().set_updater_type('KDE')
        # silence the PyQt4 logger
        logger = logging.getLogger("PyQt4")
        logger.setLevel(logging.INFO)
        if not datadir or datadir == '.':
          localedir=os.path.join(os.getcwd(),"mo")
        else:
          localedir="/usr/share/locale/ubuntu-release-upgrader"

        # FIXME: i18n must be somewhere relative do this dir
        try:
          gettext.bindtextdomain("ubuntu-release-upgrader", localedir)
          gettext.textdomain("ubuntu-release-upgrader")
        except Exception as e:
          logging.warning("Error setting locales (%s)" % e)

        # we test for DISPLAY here, QApplication does not throw a
        # exception when run without DISPLAY but dies instead
        if not "DISPLAY" in os.environ:
            raise Exception("No DISPLAY in os.environ found")

        # Force environment to make sure Qt uses suitable theming and UX.
        os.environ["QT_PLATFORM_PLUGIN"] = "kde"
        # For above settings to apply automatically we need to indicate that we
        # are inside a full KDE session.
        os.environ["KDE_FULL_SESSION"] = "TRUE"
        # We also need to indicate version as otherwise KDElibs3 compatibility
        # might kick in such as in QIconLoader.cpp:QString fallbackTheme.
        os.environ["KDE_SESSION_VERSION"] = "5"
        # Pretty much all of the above but for Qt5
        os.environ["QT_QPA_PLATFORMTHEME"] = "kde"

        self.app = QApplication(["ubuntu-release-upgrader"])

        # Try to load default Qt translations so we don't have to worry about
        # QStandardButton translations.
        translator = QTranslator(self.app)
        if type(PYQT_VERSION) == int:
            translator.load(QLocale.system(), 'qt', '_', '/usr/share/qt5/translations')
        else:
            translator.load(QLocale.system(), 'qt', '_', '/usr/share/qt4/translations')
        self.app.installTranslator(translator)

        QUrlOpener().setupUrlHandles()

        messageIcon = _icon("system-software-update",
                            fallbacks=["/usr/share/icons/oxygen/48x48/apps/system-software-update.png",
                                       "/usr/share/icons/hicolor/48x48/apps/adept_manager.png"])
        self.app.setWindowIcon(messageIcon)

        self.window_main = UpgraderMainWindow()
        self.window_main.setParent(self)
        self.window_main.show()

        self.prev_step = None # keep a record of the latest step

        self._opCacheProgress = KDEOpProgress(self.window_main.progressbar_cache, self.window_main.progress_text)
        self._acquireProgress = KDEAcquireProgressAdapter(self)
        self._cdromProgress = KDECdromProgressAdapter(self)

        self._installProgress = KDEInstallProgressAdapter(self)

        # reasonable fault handler
        sys.excepthook = self._handleException

        self.window_main.showTerminalButton.setEnabled(False)
        self.window_main.showTerminalButton.clicked.connect(self.showTerminal)

        # init gettext
        gettext.bindtextdomain("ubuntu-release-upgrader",localedir)
        gettext.textdomain("ubuntu-release-upgrader")
        self.translate_widget_children()
        name = _OSRelease().result["PRETTY_NAME"]
        if not name or name == "Ubuntu":
            name = "Kubuntu"
        title_string = self.window_main.label_title.text()
        title_string = title_string.replace("Ubuntu", name)
        title_string = title_string.replace("%s", "19.10")
        self.window_main.label_title.setText(title_string)

        # setup terminal text in hidden by default spot
        self.window_main.konsole_frame.hide()
        self.konsole_frame_layout = QHBoxLayout(self.window_main.konsole_frame)
        self.window_main.konsole_frame.setMinimumSize(600, 400)
        self.terminal_text = DumbTerminal(self._installProgress, self.window_main.konsole_frame)
        self.konsole_frame_layout.addWidget(self.terminal_text)
        self.terminal_text.show()

        self.inhibitScreenlock()
        atexit.register(self.uninhibitScreenlock)

        # for some reason we need to start the main loop to get everything displayed
        # this app mostly works with processEvents but run main loop briefly to keep it happily displaying all widgets
        QTimer.singleShot(10, self.exitMainLoopMidFlight)
        self.app.exec_()
Example #38
0
        labelVersion = QLabel(self)
        labelVersion.setText(" Vima versión beta: 1.0  ")

        self.statusBar = self.statusBar()
        self.statusBar.addPermanentWidget(labelVersion, 0)


# ==================================================================

if __name__ == '__main__':

    import sys

    aplicacion = QApplication(sys.argv)

    traductor = QTranslator(aplicacion)
    lugar = QLocale.system().name()
    path = QLibraryInfo.location(QLibraryInfo.TranslationsPath)
    traductor.load("qtbase_%s" % lugar, path)
    aplicacion.installTranslator(traductor)

    fuente = QFont()
    fuente.setPointSize(10)
    aplicacion.setFont(fuente)

    ventana = visorImagenes()
    ventana.show()

    sys.exit(aplicacion.exec_())
Example #39
0
        import proyectoFINAL
        proyectoFINAL.mainFunction()

    def AboutMessage(self):
        alert = QMessageBox()
        alert.setWindowIcon(QIcon('C:/PROYECTO FINAL/coche.png'))
        alert.setWindowTitle('Saliendo...')
        alert.setText('¡HASTA PRONTO!')
        alert.exec_()
        sys.exit()


# ********************************************************************
if __name__ == "__main__":
    import sys
    app = QtWidgets.QApplication(sys.argv)
    app.setStyle('Fusion')
    # Traducimos al idioma del SO
    qt_traductor = QTranslator()
    qt_traductor.load("qtbase_" + QLocale.system().name(),
                      QLibraryInfo.location(QLibraryInfo.TranslationsPath))
    app.installTranslator(qt_traductor)
    MainWindow = QtWidgets.QMainWindow()
    ui = Ui_MainWindow()
    ui.setupUi(MainWindow)
    # Icono de aplicación
    MainWindow.setWindowIcon(QIcon('C:/PROYECTO FINAL/coche.png'))

    MainWindow.show()
    sys.exit(app.exec_())
Example #40
0
 def __init__(self, *args, **kwargs):
     QLocale.setDefault(QLocale(QLocale.English, QLocale.UnitedStates))
     super().__init__(*args, **kwargs)
     self.setupview()
Example #41
0
import os
import sys
import json
import signal
import weakref

from PyQt5 import QtCore
from PyQt5.QtCore import QCoreApplication
if os.name == 'posix':
    QCoreApplication.setAttribute(QtCore.Qt.AA_X11InitThreads, True)

# from PyQt5.QtGui import QFont
from PyQt5.QtCore import pyqtSlot, QObject, QTranslator, QLocale, QLibraryInfo
from PyQt5.QtWidgets import QApplication
appTranslator = QTranslator()
translationsPath = "qt_" + QLocale.system().name()
appTranslator.load("qt_zh_CN.qm",
                   QLibraryInfo.location(QLibraryInfo.TranslationsPath))
app = QApplication(sys.argv)
app.setApplicationVersion("2.1")
app.installTranslator(appTranslator)
app.setQuitOnLastWindowClosed(True)

from window import Window
from database import database
from config import config
from movie_info import movie_info
from browser import Browser
from utils import utils, FindVideoThreadManager
from constant import MAIN_QML
from menu_controller import MenuController
Example #42
0
class ImapServer(QObject):
    socket.setdefaulttimeout(1)
    imap_signal = pyqtSignal()

    def __init__(self):
        super().__init__()
        self.serverIMAP = None
        self.mailbox = 'INBOX'
        self.is_connected = False
        self.is_first_connection = True
        self.running = False
        self.log = "?"
        self.server_id = -1
        self.thread = None
        self.db = DataBaseConnection(init_table=True)
        self.locale = QLocale(QLocale.English, QLocale.UnitedStates)
        self.start_sync = None
        self.last_mail_datetime = None

    def __del__(self):
        # with self.lock:
        self.running = False
        if (threading.active_count() != 0 and self.thread != None):
            self.thread.join()
        self.close_server()

    def start_server(self):
        # with self.lock:
        self.running = True
        self.thread = threading.Thread(target=self.update_imap, daemon=True)
        self.thread.start()

    def stop_server(self):
        # with self.lock:
        if (self.running == True):
            self.running = False
        if (self.thread != None):
            self.thread.join()

    def close_server(self):
        if self.is_connected == True:
            self.is_connected = False
            self.is_first_connection = True
            try:
                self.serverIMAP.close()
                self.serverIMAP.logout()
            except imaplib.IMAP4.error as err:
                print(err, flush=True)

    def update_imap(self):
        self.db = DataBaseConnection(init_table=True)
        while self.running:
            if (not self.is_connected):
                self.connect_imap()
            if (self.is_connected and self.is_first_connection):
                self.update_first_connection()
            if (self.is_connected and not self.is_first_connection):
                self.update_recent()
            time.sleep(5.0)

    def set_server_id(self, server_id):
        self.server_id = server_id

    def connect_imap(self):
        print("Try connect")
        try:
            # Retreive data from DB
            login_data = self.db.get_server_data(self.server_id)
            if (len(login_data) == 0):
                raise Exception('wrong server_id ', self.server_id)

            self.serverIMAP = imaplib.IMAP4_SSL(login_data["server_ip"],
                                                login_data["server_port"])
            rsp = self.serverIMAP.login(login_data["email"],
                                        login_data["password"])

            if (rsp[1][0].decode() == "LOGIN completed."):
                self.is_connected = True
                self.is_first_connection = True
                rsp, nb_message_inbox = self.serverIMAP.select(
                    mailbox=self.mailbox, readonly=False)
                print("select rsp = ", rsp, " nb_message = ",
                      nb_message_inbox[0].decode())
                self.log = "Connected"
            else:
                raise Exception('Failed to select')

            return True

        except imaplib.IMAP4.error as err:
            print("Error imap ", err)
            self.log = "Error IMAP"
            self.close_server()
            return False
        except sqlite3.Error as error:
            print("Error sqlite ", error)
            self.log = "Error SQLITE"
            self.close_server()
            return False
        except:
            print("Error ", sys.exc_info())
            self.log = "Error - No connection"
            self.close_server()
            return False

    def process_msg(self, msgnums):
        if (msgnums[0] != None):
            k = 1
            list_msg_num = msgnums[0].split()
            for num in list_msg_num:
                if (not self.download_msg(num.decode())):
                    return False
                self.log = "Update " + str(k) + "/" + str(
                    len(list_msg_num)) + " (" + str(num.decode()) + ")"
                k += 1
            self.imap_signal.emit()
            return True

    def update_recent(self):
        self.log = "Update " + str(
            datetime.datetime.now().replace(microsecond=0))
        try:
            t = datetime.datetime.now()
            rsp, msgnums = self.serverIMAP.recent()
            if (not self.process_msg(msgnums)):
                return False

            self.db.update_last_sync(
                self.server_id,
                t.replace(microsecond=0).isoformat())  # without microsecond
            return True
        except imaplib.IMAP4.error as err:
            self.close_server()
            print(err, flush=True)
            self.log = "Error imaplib"
            return False
        except:
            print("Error ", sys.exc_info())
            self.close_server()
            self.log = "Error (timeout)"
            return False

    def update_first_connection(self):
        print("Try update_first_connection")
        t = datetime.datetime.now()

        try:
            # Search for email since last sync date
            self.start_sync = self.db.get_last_sync(self.server_id)
            date_string = self.locale.toString(self.start_sync, "dd-MMM-yyyy")
            print(date_string)
            typ, msgnums = self.serverIMAP.search(
                None, 'SINCE {date}'.format(date=date_string),
                'FROM "*****@*****.**"')
            if (not self.process_msg(msgnums)):
                return False

            self.is_first_connection = False
            self.db.update_last_sync(self.server_id, t)
            self.log = "Connected"
            return True
        except imaplib.IMAP4.error as err:
            self.close_server()
            self.log = "Error IMAP"
            print(err)
            return False
        except sqlite3.Error as error:
            self.close_server()
            self.log = "Error SQLITE"
            print(error)
            return False
        except:
            print("Error ", sys.exc_info())
            self.close_server()
            self.log = "Error - No connection"
            return False

    def download_msg(self, msgnum):
        if (msgnum == "0"):
            return True
        print("Download msg ", msgnum)
        try:
            typ, data_msg = self.serverIMAP.fetch(msgnum, '(BODY.PEEK[])')
        except imaplib.IMAP4.error as err:
            self.close_server()
            self.log = "Error IMAP"
            print(err)
            return False

        # Parse received part (starting with "Received: ")
        mail = email.message_from_bytes(data_msg[0][1], policy=default)

        if (mail["From"] == "*****@*****.**"):
            # imei = mail["Subject"].split(": ")[1]
            print(mail["Subject"])
            imei = re.search("SBD (.*): (.*)", mail["Subject"]).group(2)
            time_connection = calendar.timegm(parsedate(mail["Date"]))

            # Check timed received
            mail_datetime = QDateTime.fromString(mail["Date"], Qt.RFC2822Date)
            # if(self.last_mail_datetime>=mail_datetime):
            # 	print("Before last mail datetime")
            # 	return True

            if mail.get_content_maintype() != 'multipart':
                print("No attachment")
                return True

            self.db.add_new_robot(imei)  # Add new robot if not existing
            ## Extract enclosed file
            for part in mail.iter_attachments():
                if part.get_content_maintype() == 'application':
                    # Extract momsn from attached file
                    print(part.get_filename())
                    momsn = int(
                        re.search("_(.*)\.", part.get_filename()).group(1))

                    # Add new entry to the database with the association of the imei and momsn
                    message_id = self.db.add_sbd_received(
                        imei, momsn, time_connection)

                    # Test if message is already saved
                    if (message_id != None):
                        msg_data = part.get_payload(decode=True)
                        IridiumMessageParser(msg_data, self.db, message_id,
                                             time_connection)
        return True

    def get_log(self):
        return self.log

    def get_is_connected(self):
        return self.is_connected
    def ajoutRechercheBonDeTravail(self):
        # Recuperation des differents attributs
        self.bonDeTravailManager = BonTravailManager(pathBonTravailDatabase)
        try:
            fichierConf = open(pathFichierConf,
                               'r')  # try: ouvrir le fichier et le lire
            with fichierConf:
                self._conf = yaml.load(fichierConf)
        except IOError:  # attrape l'erreur IOError si elle se présente et renvoie
            print("Could not read file: ",
                  pathFichierConf)  # définir ce qu'il faut faire pour corriger

        self.listeCategorieEquipement = list(self._conf['CategorieEquipement'])
        self.listeCategorieEquipement.sort()
        self.listeUnite = list(self._conf['Unite'])
        self.listeUnite.sort()
        self.listeEtatService = list(self._conf['EtatService'])
        self.listeEtatService.sort()

        #Mise a jour des differentes listes deroulantes
        self.comboBoxCategorieEquipement.clear()
        self.comboBoxCategorieEquipement.addItem("")
        self.comboBoxCategorieEquipement.addItems(
            self.listeCategorieEquipement)
        self.comboBoxEtat.clear()
        self.comboBoxEtat.addItem("")
        self.comboBoxEtat.addItems(self.listeEtatService)
        self.comboBoxUnite.clear()
        self.comboBoxUnite.addItem("")
        self.comboBoxUnite.addItems(self.listeUnite)

        fichierConf.close()

        self.signalRechercheBon = Communicate()
        self.signalRechercheBon.aucunResultat.connect(self.aucunResultat)
        self.signalRechercheBon.remplirTableau.connect(self.remplirTableau)
        self.signalRechercheBon.nouvelleRecherche.connect(
            self.nouvelleRecherche)

        #modification calendrier
        calendrierApres = QCalendarWidget()
        calendrierApres.setStyleSheet("background :#F5F5F5;\n color: black;")
        calendrierApres.setGridVisible(True)
        self.calendrierApres.setCalendarWidget(calendrierApres)
        calendrierApres.setVerticalHeaderFormat(
            QCalendarWidget.NoVerticalHeader)
        self.calendrierApres.setLocale(QLocale(QLocale.French, QLocale.France))
        calendrierAvant = QCalendarWidget()
        calendrierAvant.setStyleSheet("background :#F5F5F5;\n color: black;")
        calendrierAvant.setVerticalHeaderFormat(
            QCalendarWidget.NoVerticalHeader)
        calendrierAvant.setGridVisible(True)
        self.calendrierAvant.setCalendarWidget(calendrierAvant)
        self.calendrierAvant.setLocale(QLocale(QLocale.French, QLocale.France))

        self.calendrierAvant.setDate(QDate.currentDate())
        self.calendrierApres.setDate(QDate.currentDate())

        #Creation des differents colonnes pour le tableau de resultat
        self.listeCleDonnees = list([
            "IdEquipement", "NumeroBonTravail", "CategorieEquipement",
            "Modele", "Unite", "EtatBDT", "Date", "DescriptionSituation"
        ])

        #liste contenant les bons résultant de la recherche
        self.listeResultat = list()
        #liste contenant les informations des bons a afficher
        self.listeDonnees = list()

        self.tableResultats.setColumnCount(len(self.listeCleDonnees))
        self.listeHeaders = [
            "Id de l'équipement", "Numero du bon de travail",
            "Catégorie d'équipement", "Modèle", "Unité", "État BDT", "Date",
            "Description de la situation"
        ]
        self.tableResultats.setHorizontalHeaderLabels(self.listeHeaders)
        self.tableResultats.resizeColumnsToContents()
        self.tableResultats.setRowCount(0)
        self.dictionnaireRecherche = dict()

        #Connexion des differentes recherches pour la mise a jour automatique
        self.comboBoxCategorieEquipement.currentTextChanged.connect(
            self.rechercheCategorieEquipement)
        self.comboBoxEtat.currentTextChanged.connect(
            self.rechercheEtatDeService)
        self.comboBoxUnite.currentTextChanged.connect(self.rechercheUnite)
        self.calendrierAvant.dateChanged.connect(self.rechercheDateAvant)
        self.lineEditDescriptionSituation.returnPressed.connect(
            self.rechercheDescriptionSituation)
        self.calendrierApres.dateChanged.connect(self.rechercheDateApres)
        self.boutonNouvelleRecherche.clicked.connect(
            self.signalRechercheBon.nouvelleRecherche.emit)
        self.tableResultats.horizontalHeader().sectionClicked.connect(
            self.trier)
        self.boutonActualiser.clicked.connect(self.rechercherBonTravailThread)
        self.colonneClique = None
        self.nombreClique = 0
        # Empeche la modification de la table
        self.tableResultats.setEditTriggers(
            QtWidgets.QAbstractItemView.NoEditTriggers)
        self.tableResultats.setSelectionBehavior(
            QtWidgets.QAbstractItemView.SelectRows)
        self.tableResultats.cellDoubleClicked.connect(self.choisirBonDeTravail)
        self.bonDeTravailSelectionne = None
Example #44
0
def get_default_language():
    name = QLocale.system().name()
    return name if name in languages else 'en_UK'
Example #45
0
    def __init__(self, parent, persepolis_setting):
        super().__init__(persepolis_setting)
        self.persepolis_setting = persepolis_setting
        self.parent = parent
        self.grandparent = parent.persepolis_main

        self.persepolis_setting.beginGroup('settings')

        # initialization
        self.tries_spinBox.setValue(
            int(self.persepolis_setting.value('max-tries')))
        self.wait_spinBox.setValue(
            int(self.persepolis_setting.value('retry-wait')))
        self.time_out_spinBox.setValue(
            int(self.persepolis_setting.value('timeout')))
        self.connections_spinBox.setValue(
            int(self.persepolis_setting.value('connections')))
        self.rpc_port_spinbox.setValue(
            int(self.persepolis_setting.value('rpc-port')))

        # add support for other languages
        locale = str(self.persepolis_setting.value('settings/locale'))
        QLocale.setDefault(QLocale(locale))
        self.translator = QTranslator()
        if self.translator.load(':/translations/locales/ui_' + locale, 'ts'):
            QCoreApplication.installTranslator(self.translator)

        # wait_queue
        wait_queue_list = self.persepolis_setting.value('wait-queue')
        q_time = QTime(int(wait_queue_list[0]), int(wait_queue_list[1]))
        self.wait_queue_time.setTime(q_time)

        # change aria2 path
        self.aria2_path_pushButton.clicked.connect(self.changeAria2Path)
        self.aria2_path_checkBox.toggled.connect(self.ariaCheckBoxToggled)
        aria2_path = self.persepolis_setting.value('settings/aria2_path')

        self.aria2_path_lineEdit.setEnabled(False)
        if aria2_path != None:
            self.aria2_path_checkBox.setChecked(True)
            self.aria2_path_lineEdit.setText(str(aria2_path))

        self.ariaCheckBoxToggled('aria2')

        if os_type == 'Linux' or os_type == 'FreeBSD' or os_type == 'OpenBSD':
            for widget in self.aria2_path_checkBox, self.aria2_path_lineEdit, self.aria2_path_pushButton:
                widget.hide()

        # save_as_tab
        self.download_folder_lineEdit.setText(
            str(self.persepolis_setting.value('download_path')))
        self.temp_download_lineEdit.setText(
            str(self.persepolis_setting.value('download_path_temp')))

        # subfolder
        if str(self.persepolis_setting.value('subfolder')) == 'yes':
            self.subfolder_checkBox.setChecked(True)
        else:
            self.subfolder_checkBox.setChecked(False)

        # notifications_tab
        self.volume_label.setText(
            'Volume : ' + str(self.persepolis_setting.value('sound-volume')))
        self.volume_dial.setValue(
            int(self.persepolis_setting.value('sound-volume')))

        # set style
        # if style_comboBox is changed, self.styleComboBoxChanged is called.
        self.style_comboBox.currentIndexChanged.connect(
            self.styleComboBoxChanged)

        # find available styles(It's depends on operating system and desktop environments).
        available_styles = QStyleFactory.keys()
        for style in available_styles:
            # 'GTK' or 'gtk' styles may cause to crashing! Eliminate them!
            if 'gtk' not in str(style) and 'GTK' not in str(style):
                self.style_comboBox.addItem(style)

        # System >> for system default style
        # when user select System for style section, the default system style is using.
        self.style_comboBox.addItem('System')

        current_style_index = self.style_comboBox.findText(
            str(self.persepolis_setting.value('style')))
        if current_style_index != -1:
            self.style_comboBox.setCurrentIndex(current_style_index)

        # available language
        available_language = [
            'en_US', 'fa_IR', 'zh_CN', 'fr_FR', 'pl_PL', 'nl_NL'
        ]
        for lang in available_language:
            self.lang_comboBox.addItem(str(QLocale(lang).nativeLanguageName()),
                                       lang)

        current_locale = self.lang_comboBox.findData(
            str(self.persepolis_setting.value('locale')))
        self.lang_comboBox.setCurrentIndex(current_locale)
        self.lang_comboBox.currentIndexChanged.connect(
            self.styleComboBoxChanged)
        self.styleComboBoxChanged()

        current_color_index = self.color_comboBox.findText(
            str(self.persepolis_setting.value('color-scheme')))
        self.color_comboBox.setCurrentIndex(current_color_index)

        self.current_icon = self.persepolis_setting.value('icons')

        # icon size
        size = ['128', '64', '48', '32', '24', '16']
        self.icons_size_comboBox.addItems(size)
        current_icons_size_index = self.icons_size_comboBox.findText(
            str(self.persepolis_setting.value('toolbar_icon_size')))
        self.icons_size_comboBox.setCurrentIndex(current_icons_size_index)

        # call iconSizeComboBoxCanged if index is changed
        self.icons_size_comboBox.currentIndexChanged.connect(
            self.iconSizeComboBoxCanged)

        self.iconSizeComboBoxCanged(1)

        # set notification
        notifications = ['Native notification', 'QT notification']
        self.notification_comboBox.addItems(notifications)
        current_notification_index = self.notification_comboBox.findText(
            str(self.persepolis_setting.value('notification')))
        self.notification_comboBox.setCurrentIndex(current_notification_index)

        # set font
        font_setting = QFont()
        font_setting.setFamily(str(self.persepolis_setting.value('font')))
        self.fontComboBox.setCurrentFont(font_setting)

        self.font_size_spinBox.setValue(
            int(self.persepolis_setting.value('font-size')))

        # sound frame
        self.sound_frame.setEnabled(False)
        self.enable_notifications_checkBox.toggled.connect(self.soundFrame)
        if str(self.persepolis_setting.value('sound')) == 'yes':
            self.enable_notifications_checkBox.setChecked(True)
        else:
            self.enable_notifications_checkBox.setChecked(False)

        # connect folder buttons
        self.download_folder_lineEdit.setEnabled(False)
        self.download_folder_pushButton.clicked.connect(
            self.downloadFolderPushButtonClicked)
        self.temp_download_lineEdit.setEnabled(False)
        self.temp_download_pushButton.clicked.connect(
            self.tempDownloadPushButtonClicked)

        # dial
        self.volume_dial.setNotchesVisible(True)
        self.volume_dial.valueChanged.connect(self.dialChanged)

        # start_persepolis_if_browser_executed_checkBox
        if str(self.persepolis_setting.value('browser-persepolis')) == 'yes':
            self.start_persepolis_if_browser_executed_checkBox.setChecked(True)
        else:
            self.start_persepolis_if_browser_executed_checkBox.setChecked(
                False)

        # hide window
        if str(self.persepolis_setting.value('hide-window')) == 'yes':
            self.hide_window_checkBox.setChecked(True)
        else:
            self.hide_window_checkBox.setChecked(False)

        # tray icon
        if str(self.persepolis_setting.value('tray-icon')) == 'yes':
            self.enable_system_tray_checkBox.setChecked(True)
        else:
            self.enable_notifications_checkBox.setChecked(False)

        # show_menubar
        if str(self.persepolis_setting.value('show-menubar')) == 'yes':
            self.show_menubar_checkbox.setChecked(True)
        else:
            self.show_menubar_checkbox.setChecked(False)

        if platform.system() == 'Darwin':
            self.show_menubar_checkbox.setChecked(True)
            self.show_menubar_checkbox.hide()

        # show_sidepanel
        if str(self.persepolis_setting.value('show-sidepanel')) == 'yes':
            self.show_sidepanel_checkbox.setChecked(True)
        else:
            self.show_sidepanel_checkbox.setChecked(False)

        # show ProgressWindow
        if str(self.persepolis_setting.value('show-progress')) == 'yes':
            self.show_progress_window_checkbox.setChecked(True)
        else:
            self.show_progress_window_checkbox.setChecked(False)

        # after download dialog
        if str(self.persepolis_setting.value('after-dialog')) == 'yes':
            self.after_download_checkBox.setChecked(True)
        else:
            self.after_download_checkBox.setChecked(False)

        # run persepolis at startup checkBox
        if str(self.persepolis_setting.value('startup')) == 'yes':
            self.startup_checkbox.setChecked(True)
        else:
            self.startup_checkbox.setChecked(False)

        # font_checkBox
        if str(self.persepolis_setting.value('custom-font')) == 'yes':
            self.font_checkBox.setChecked(True)
        else:
            self.font_checkBox.setChecked(False)

        self.fontCheckBoxState(self.font_checkBox)

        # keep_awake_checkBox
        if str(self.persepolis_setting.value('awake')) == 'yes':
            self.keep_awake_checkBox.setChecked(True)
        else:
            self.keep_awake_checkBox.setChecked(False)

        # columns_tab
        if str(self.persepolis_setting.value('column0')) == 'yes':
            self.column0_checkBox.setChecked(True)
        else:
            self.column0_checkBox.setChecked(False)

        if str(self.persepolis_setting.value('column1')) == 'yes':
            self.column1_checkBox.setChecked(True)
        else:
            self.column1_checkBox.setChecked(False)

        if str(self.persepolis_setting.value('column2')) == 'yes':
            self.column2_checkBox.setChecked(True)
        else:
            self.column2_checkBox.setChecked(False)

        if str(self.persepolis_setting.value('column3')) == 'yes':
            self.column3_checkBox.setChecked(True)
        else:
            self.column3_checkBox.setChecked(False)

        if str(self.persepolis_setting.value('column4')) == 'yes':
            self.column4_checkBox.setChecked(True)
        else:
            self.column4_checkBox.setChecked(False)

        if str(self.persepolis_setting.value('column5')) == 'yes':
            self.column5_checkBox.setChecked(True)
        else:
            self.column5_checkBox.setChecked(False)

        if str(self.persepolis_setting.value('column6')) == 'yes':
            self.column6_checkBox.setChecked(True)
        else:
            self.column6_checkBox.setChecked(False)

        if str(self.persepolis_setting.value('column7')) == 'yes':
            self.column7_checkBox.setChecked(True)
        else:
            self.column7_checkBox.setChecked(False)

        if str(self.persepolis_setting.value('column10')) == 'yes':
            self.column10_checkBox.setChecked(True)
        else:
            self.column10_checkBox.setChecked(False)

        if str(self.persepolis_setting.value('column11')) == 'yes':
            self.column11_checkBox.setChecked(True)
        else:
            self.column11_checkBox.setChecked(False)

        if str(self.persepolis_setting.value('column12')) == 'yes':
            self.column12_checkBox.setChecked(True)
        else:
            self.column12_checkBox.setChecked(False)

        # video_finder
        try:  # Integer casting may raise exception.
            self.max_links_spinBox.setValue(
                int(persepolis_setting.value('video_finder/max_links', 3)))
        except:
            pass

        # shortcuts
        self.qshortcuts_list = [
            self.parent.exitAction_shortcut,
            self.parent.minimizeAction_shortcut,
            self.parent.removeSelectedAction_shortcut,
            self.parent.deleteSelectedAction_shortcut,
            self.parent.moveUpSelectedAction_shortcut,
            self.parent.moveDownSelectedAction_shortcut,
            self.parent.addlinkAction_shortcut,
            self.parent.videoFinderAddLinkAction_shortcut,
            self.parent.addtextfileAction_shortcut
        ]

        self.shortcuts_list = [
            self.parent.exitAction_shortcut.key().toString(),
            self.parent.minimizeAction_shortcut.key().toString(),
            self.parent.removeSelectedAction_shortcut.key().toString(),
            self.parent.deleteSelectedAction_shortcut.key().toString(),
            self.parent.moveUpSelectedAction_shortcut.key().toString(),
            self.parent.moveDownSelectedAction_shortcut.key().toString(),
            self.parent.addlinkAction_shortcut.key().toString(),
            self.parent.videoFinderAddLinkAction_shortcut.key().toString(),
            self.parent.addtextfileAction_shortcut.key().toString()
        ]

        # add shortcuts to the shortcut_table
        j = 0
        for shortcut in self.shortcuts_list:
            item = QTableWidgetItem(shortcut)

            # align center
            item.setTextAlignment(0x0004 | 0x0080)

            # insert item in shortcut_table
            self.shortcut_table.setItem(j, 1, item)

            j = j + 1

        # If user doubleclicks on a row, then run showCaptureKeyboardWindow method
        self.shortcut_table.itemDoubleClicked.connect(
            self.showCaptureKeyboardWindow)

        # ok cancel default button
        self.cancel_pushButton.clicked.connect(self.close)
        self.defaults_pushButton.clicked.connect(
            self.defaultsPushButtonPressed)
        self.ok_pushButton.clicked.connect(self.okPushButtonPressed)

        # font_checkBox connect
        self.font_checkBox.stateChanged.connect(self.fontCheckBoxState)

        # saving initial value of self.persepolis_setting in self.first_key_value_dict
        # at the end! in the okPushButtonPressed method, first_key_value_dict will compared with second_key_value_dict.
        # if any thing changed , then a message box notify user about "some changes take effect after restarting persepolis".
        self.first_key_value_dict = {}
        for member in self.persepolis_setting.allKeys():
            self.first_key_value_dict[member] = str(
                self.persepolis_setting.value(member))

        self.persepolis_setting.endGroup()

        # setting window size and position
        size = self.persepolis_setting.value('PreferencesWindow/size',
                                             QSize(578, 565))
        position = self.persepolis_setting.value('PreferencesWindow/position',
                                                 QPoint(300, 300))

        self.resize(size)
        self.move(position)
Example #46
0
def l10nDecimal(dec, digits=2):
    from PyQt5.QtCore import QLocale
    l=QLocale()
    return l.toCurrencyString(float(dec))
Example #47
0
    def createGeneralOptionsGroupBox(self):
        self.generalOptionsGroupBox = QGroupBox("General Options")

        self.localeCombo = QComboBox()

        curLocaleIndex = -1
        index = 0

        for lid in range(QLocale.C, QLocale.LastLanguage + 1):
            lang = QLocale.Language(lid)
            countries = QLocale.countriesForLanguage(lang)
            for country in countries:
                label = "%s/%s" % (QLocale.languageToString(lang),
                                   QLocale.countryToString(country))
                locale = QLocale(lang, country)
                if self.locale().language() == lang and self.locale().country(
                ) == country:
                    curLocaleIndex = index

                self.localeCombo.addItem(label, locale)
                index += 1

        if curLocaleIndex != -1:
            self.localeCombo.setCurrentIndex(curLocaleIndex)

        self.localeLabel = QLabel("&Locale")
        self.localeLabel.setBuddy(self.localeCombo)

        self.firstDayCombo = QComboBox()
        self.firstDayCombo.addItem("Sunday", Qt.Sunday)
        self.firstDayCombo.addItem("Monday", Qt.Monday)
        self.firstDayCombo.addItem("Tuesday", Qt.Tuesday)
        self.firstDayCombo.addItem("Wednesday", Qt.Wednesday)
        self.firstDayCombo.addItem("Thursday", Qt.Thursday)
        self.firstDayCombo.addItem("Friday", Qt.Friday)
        self.firstDayCombo.addItem("Saturday", Qt.Saturday)

        self.firstDayLabel = QLabel("Wee&k starts on:")
        self.firstDayLabel.setBuddy(self.firstDayCombo)

        self.selectionModeCombo = QComboBox()
        self.selectionModeCombo.addItem("Single selection",
                                        QCalendarWidget.SingleSelection)
        self.selectionModeCombo.addItem("None", QCalendarWidget.NoSelection)
        self.selectionModeLabel = QLabel("&Selection mode:")
        self.selectionModeLabel.setBuddy(self.selectionModeCombo)

        self.gridCheckBox = QCheckBox("&Grid")
        self.gridCheckBox.setChecked(self.calendar.isGridVisible())

        self.navigationCheckBox = QCheckBox("&Navigation bar")
        self.navigationCheckBox.setChecked(True)

        self.horizontalHeaderCombo = QComboBox()
        self.horizontalHeaderCombo.addItem(
            "Single letter day names", QCalendarWidget.SingleLetterDayNames)
        self.horizontalHeaderCombo.addItem("Short day names",
                                           QCalendarWidget.ShortDayNames)
        self.horizontalHeaderCombo.addItem("Long day names",
                                           QCalendarWidget.LongDayNames)
        self.horizontalHeaderCombo.addItem("None",
                                           QCalendarWidget.NoHorizontalHeader)
        self.horizontalHeaderCombo.setCurrentIndex(1)

        self.horizontalHeaderLabel = QLabel("&Horizontal header:")
        self.horizontalHeaderLabel.setBuddy(self.horizontalHeaderCombo)

        self.verticalHeaderCombo = QComboBox()
        self.verticalHeaderCombo.addItem("ISO week numbers",
                                         QCalendarWidget.ISOWeekNumbers)
        self.verticalHeaderCombo.addItem("None",
                                         QCalendarWidget.NoVerticalHeader)

        self.verticalHeaderLabel = QLabel("&Vertical header:")
        self.verticalHeaderLabel.setBuddy(self.verticalHeaderCombo)

        self.localeCombo.currentIndexChanged.connect(self.localeChanged)
        self.firstDayCombo.currentIndexChanged.connect(self.firstDayChanged)
        self.selectionModeCombo.currentIndexChanged.connect(
            self.selectionModeChanged)
        self.gridCheckBox.toggled.connect(self.calendar.setGridVisible)
        self.navigationCheckBox.toggled.connect(
            self.calendar.setNavigationBarVisible)
        self.horizontalHeaderCombo.currentIndexChanged.connect(
            self.horizontalHeaderChanged)
        self.verticalHeaderCombo.currentIndexChanged.connect(
            self.verticalHeaderChanged)

        checkBoxLayout = QHBoxLayout()
        checkBoxLayout.addWidget(self.gridCheckBox)
        checkBoxLayout.addStretch()
        checkBoxLayout.addWidget(self.navigationCheckBox)

        outerLayout = QGridLayout()
        outerLayout.addWidget(self.localeLabel, 0, 0)
        outerLayout.addWidget(self.localeCombo, 0, 1)
        outerLayout.addWidget(self.firstDayLabel, 1, 0)
        outerLayout.addWidget(self.firstDayCombo, 1, 1)
        outerLayout.addWidget(self.selectionModeLabel, 2, 0)
        outerLayout.addWidget(self.selectionModeCombo, 2, 1)
        outerLayout.addLayout(checkBoxLayout, 3, 0, 1, 2)
        outerLayout.addWidget(self.horizontalHeaderLabel, 4, 0)
        outerLayout.addWidget(self.horizontalHeaderCombo, 4, 1)
        outerLayout.addWidget(self.verticalHeaderLabel, 5, 0)
        outerLayout.addWidget(self.verticalHeaderCombo, 5, 1)
        self.generalOptionsGroupBox.setLayout(outerLayout)

        self.firstDayChanged(self.firstDayCombo.currentIndex())
        self.selectionModeChanged(self.selectionModeCombo.currentIndex())
        self.horizontalHeaderChanged(self.horizontalHeaderCombo.currentIndex())
        self.verticalHeaderChanged(self.verticalHeaderCombo.currentIndex())
Example #48
0
    def data(self, index, role):
        source_index = self.mapToSource(index)
        if source_index.isValid():
            source_data = self.sourceModel().data(source_index, role)
            publication_col = CertifiersTableModel.columns_ids.index(
                'publication')
            publication_index = self.sourceModel().index(
                source_index.row(), publication_col)
            expiration_col = CertifiersTableModel.columns_ids.index(
                'expiration')
            expiration_index = self.sourceModel().index(
                source_index.row(), expiration_col)
            written_col = CertifiersTableModel.columns_ids.index('written')
            written_index = self.sourceModel().index(source_index.row(),
                                                     written_col)

            publication_data = self.sourceModel().data(publication_index,
                                                       Qt.DisplayRole)
            expiration_data = self.sourceModel().data(expiration_index,
                                                      Qt.DisplayRole)
            written_data = self.sourceModel().data(written_index,
                                                   Qt.DisplayRole)
            current_time = QDateTime().currentDateTime().toMSecsSinceEpoch()
            warning_expiration_time = int(
                (expiration_data - publication_data) / 3)
            #logging.debug("{0} > {1}".format(current_time, expiration_data))

            if role == Qt.DisplayRole:
                if source_index.column(
                ) == CertifiersTableModel.columns_ids.index('expiration'):
                    if source_data:
                        ts = self.blockchain_processor.adjusted_ts(
                            self.app.currency, source_data)
                        return QLocale.toString(
                            QLocale(), QDateTime.fromTime_t(ts),
                            QLocale.dateTimeFormat(
                                QLocale(), QLocale.ShortFormat)) + " BAT"
                    else:
                        return ""
                if source_index.column(
                ) == CertifiersTableModel.columns_ids.index('publication'):
                    if source_data:
                        ts = self.blockchain_processor.adjusted_ts(
                            self.app.currency, source_data)
                        return QLocale.toString(
                            QLocale(), QDateTime.fromTime_t(ts),
                            QLocale.dateTimeFormat(
                                QLocale(), QLocale.ShortFormat)) + " BAT"
                    else:
                        return ""
                if source_index.column(
                ) == CertifiersTableModel.columns_ids.index('pubkey'):
                    return source_data

            if role == Qt.FontRole:
                font = QFont()
                if not written_data:
                    font.setItalic(True)
                return font

            if role == Qt.ForegroundRole:
                if current_time > ((expiration_data * 1000) -
                                   (warning_expiration_time * 1000)):
                    return QColor("darkorange").darker(120)

            return source_data
Example #49
0
#   You should have received a copy of the GNU General Public License
#   along with this program.  If not, see <https://www.gnu.org/licenses/>.
#

# -*- coding: utf-8 -*-

# Form implementation generated from reading ui file 'Main_hydra_dev.ui'
#
# Created by: PyQt4 UI code generator 4.12.1
#
# WARNING! All changes made in this file will be lost!

from PyQt5 import QtCore, QtGui
from PyQt5.QtCore import QLocale

QLocale.setDefault(QLocale(QLocale.C))


class Ui_MainWindow(object):
    def setupUi(self, MainWindow):
        MainWindow.setObjectName("KerberosSDR")
        MainWindow.resize(1366, 870)
        self.centralwidget = QtGui.QWidget(MainWindow)
        self.centralwidget.setObjectName("centralwidget")
        self.horizontalLayout = QtGui.QHBoxLayout(self.centralwidget)
        self.horizontalLayout.setObjectName("horizontalLayout")
        self.verticalLayout_6 = QtGui.QVBoxLayout()
        self.verticalLayout_6.setObjectName("verticalLayout_6")
        self.stackedWidget_config = QtGui.QStackedWidget(self.centralwidget)
        self.stackedWidget_config.setMaximumSize(QtCore.QSize(290, 16777215))
        self.stackedWidget_config.setObjectName("stackedWidget_config")
Example #50
0
            if res == True:
                return True
            elif res == "UNIQUE constraint failed: fournisseurs.NOM":
                QMessageBox.warning(self, "Erreur", "Ce nom existe déjà.")
            else:
                QMessageBox.warning(self, "Erreur",
                                    "Erreur de requette inconnue!")

    def add_code_compta(self):
        name, code, ok = CodeComptaDialog.getCode()
        if ok and name != "":
            datas = {'code': code, 'nom': name}
            response = self.model.add(datas, 'codecompta')
            if response == "UNIQUE constraint failed: codecompta.CODE":
                QMessageBox.warning(self, "Erreur", "Ce code existe déjà")

    def add_input(self):
        res = AddInputDialog(self)

    def about_d(self):
        QMessageBox.information(self, "Diabolik Compta", "version 0.0.4")


app = QApplication(sys.argv)
translator = QTranslator()
translator.load('qt_' + QLocale.system().name(),
                QLibraryInfo.location(QLibraryInfo.TranslationsPath))
app.installTranslator(translator)
main_window = MainWindow()
sys.exit(app.exec_())
    def __init__(self, configDialog):
        """
        Constructor
        
        @param configDialog reference to the configuration dialog
            (ConfigurationDialog)
        """
        super(HelpWebBrowserPage, self).__init__()
        self.setupUi(self)
        self.setObjectName("HelpWebBrowserPage")

        self.__configDlg = configDialog
        mw = configDialog.parent().parent()
        if hasattr(mw, "helpWindow") and mw.helpWindow is not None:
            self.__helpWindow = mw.helpWindow
        elif hasattr(mw, "currentBrowser"):
            self.__helpWindow = mw
        else:
            self.__helpWindow = None
        self.setCurrentPageButton.setEnabled(self.__helpWindow is not None)

        defaultSchemes = ["file://", "http://", "https://"]
        self.defaultSchemeCombo.addItems(defaultSchemes)

        self.clickToFlashCheckBox.setIcon(
            UI.PixmapCache.getIcon("flashBlock.png"))

        # set initial values
        self.singleHelpWindowCheckBox.setChecked(
            Preferences.getHelp("SingleHelpWindow"))
        self.saveGeometryCheckBox.setChecked(
            Preferences.getHelp("SaveGeometry"))
        self.webSuggestionsCheckBox.setChecked(
            Preferences.getHelp("WebSearchSuggestions"))
        self.showTabPreviews.setChecked(Preferences.getHelp("ShowPreview"))
        self.accessKeysCheckBox.setChecked(
            Preferences.getHelp("AccessKeysEnabled"))

        self.javaCheckBox.setChecked(Preferences.getHelp("JavaEnabled"))
        self.javaScriptCheckBox.setChecked(
            Preferences.getHelp("JavaScriptEnabled"))
        self.jsOpenWindowsCheckBox.setChecked(
            Preferences.getHelp("JavaScriptCanOpenWindows"))
        self.jsClipboardCheckBox.setChecked(
            Preferences.getHelp("JavaScriptCanAccessClipboard"))
        self.pluginsCheckBox.setChecked(Preferences.getHelp("PluginsEnabled"))
        self.clickToFlashCheckBox.setChecked(
            Preferences.getHelp("ClickToFlashEnabled"))
        self.doNotTrackCheckBox.setChecked(Preferences.getHelp("DoNotTrack"))
        self.sendRefererCheckBox.setChecked(Preferences.getHelp("SendReferer"))

        self.diskCacheCheckBox.setChecked(
            Preferences.getHelp("DiskCacheEnabled"))
        self.cacheSizeSpinBox.setValue(Preferences.getHelp("DiskCacheSize"))
        cachePolicy = Preferences.getHelp("CachePolicy")
        if cachePolicy == QNetworkRequest.PreferNetwork:
            self.cacheKeepButton.setChecked(True)
        elif cachePolicy == QNetworkRequest.PreferCache:
            self.cachePreferButton.setChecked(True)
        elif cachePolicy == QNetworkRequest.AlwaysCache:
            self.cacheOfflineButton.setChecked(True)

        self.printBackgroundsCheckBox.setChecked(
            Preferences.getHelp("PrintBackgrounds"))

        self.startupCombo.setCurrentIndex(
            Preferences.getHelp("StartupBehavior"))
        self.homePageEdit.setText(Preferences.getHelp("HomePage"))

        self.defaultSchemeCombo.setCurrentIndex(
            self.defaultSchemeCombo.findText(
                Preferences.getHelp("DefaultScheme")))

        historyLimit = Preferences.getHelp("HistoryLimit")
        idx = 0
        if historyLimit == 1:
            idx = 0
        elif historyLimit == 7:
            idx = 1
        elif historyLimit == 14:
            idx = 2
        elif historyLimit == 30:
            idx = 3
        elif historyLimit == 365:
            idx = 4
        elif historyLimit == -1:
            idx = 5
        elif historyLimit == -2:
            idx = 6
        else:
            idx = 5
        self.expireHistory.setCurrentIndex(idx)

        for language in range(2, QLocale.LastLanguage + 1):
            countries = [
                l.country() for l in QLocale.matchingLocales(
                    language, QLocale.AnyScript, QLocale.AnyCountry)
            ]
            if len(countries) > 0:
                self.languageCombo.addItem(QLocale.languageToString(language),
                                           language)
        self.languageCombo.model().sort(0)
        self.languageCombo.insertSeparator(0)
        self.languageCombo.insertItem(0, QLocale.languageToString(0), 0)
        index = self.languageCombo.findData(
            Preferences.getHelp("SearchLanguage"))
        if index > -1:
            self.languageCombo.setCurrentIndex(index)

        if hasattr(QWebSettings, "SpatialNavigationEnabled"):
            self.spatialCheckBox.setChecked(
                Preferences.getHelp("SpatialNavigationEnabled"))
        else:
            self.spatialCheckBox.setEnabled(False)
        if hasattr(QWebSettings, "LinksIncludedInFocusChain"):
            self.linksInFocusChainCheckBox.setChecked(
                Preferences.getHelp("LinksIncludedInFocusChain"))
        else:
            self.linksInFocusChainCheckBox.setEnabled(False)
        if hasattr(QWebSettings, "XSSAuditingEnabled"):
            self.xssAuditingCheckBox.setChecked(
                Preferences.getHelp("XSSAuditingEnabled"))
        else:
            self.xssAuditingCheckBox.setEnabled(False)
        if hasattr(QWebSettings, "SiteSpecificQuirksEnabled"):
            self.quirksCheckBox.setChecked(
                Preferences.getHelp("SiteSpecificQuirksEnabled"))
        else:
            self.quirksCheckBox.setEnabled(False)
def get_default_locale():
    return QLocale.system()
Example #53
0
def init_language():
    """ Find the current locale, and install the correct translators """

    # Get app instance
    app = QCoreApplication.instance()

    # Setup of our list of translators and paths
    translator_types = (
        {
            "type": 'QT',
            "pattern":
            'qt_%s',  # Older versions of Qt use this file (built-in translations)
            "path": QLibraryInfo.location(QLibraryInfo.TranslationsPath)
        },
        {
            "type": 'QT',
            "pattern":
            'qtbase_%s',  # Newer versions of Qt use this file (built-in translations)
            "path": QLibraryInfo.location(QLibraryInfo.TranslationsPath)
        },
        {
            "type": 'QT',
            "pattern": 'qt_%s',
            "path": os.path.join(info.PATH, 'locale', 'QT')
        },  # Optional path where we package QT translations
        {
            "type": 'QT',
            "pattern": 'qtbase_%s',
            "path": os.path.join(info.PATH, 'locale', 'QT')
        },  # Optional path where we package QT translations
        {
            "type": 'OpenShot',
            "pattern": os.path.join('%s', 'LC_MESSAGES',
                                    'OpenShot'),  # Our custom translations
            "path": os.path.join(info.PATH, 'locale')
        },
    )

    # Determine the environment locale, or default to system locale name
    locale_names = [
        os.environ.get('LANG',
                       QLocale().system().name()),
        os.environ.get('LOCALE',
                       QLocale().system().name())
    ]

    # Determine if the user has overwritten the language (in the preferences)
    preference_lang = settings.get_settings().get('default-language')
    if preference_lang != "Default":
        # Append preference lang to top of list
        locale_names.insert(0, preference_lang)

    # Output all system languages detected
    log.info("Qt Detected Languages: {}".format(
        QLocale().system().uiLanguages()))
    log.info("LANG Environment Variable: {}".format(
        os.environ.get('LANG',
                       QLocale().system().name())))
    log.info("LOCALE Environment Variable: {}".format(
        os.environ.get('LOCALE',
                       QLocale().system().name())))

    # Default the locale to C, for number formatting
    locale.setlocale(locale.LC_ALL, 'C')

    # Loop through environment variables
    found_language = False
    for locale_name in locale_names:

        # Don't try on default locale, since it fails to load what is the default language
        if 'en_US' in locale_name:
            log.info("Skipping English language (no need for translation): {}".
                     format(locale_name))
            continue

        # Go through each translator and try to add for current locale
        for type in translator_types:
            trans = QTranslator(app)
            if find_language_match(type["pattern"], type["path"], trans,
                                   locale_name):
                # Install translation
                app.installTranslator(trans)
                found_language = True

        # Exit if found language
        if found_language:
            log.info(
                "Exiting translation system (since we successfully loaded: {})"
                .format(locale_name))
            info.CURRENT_LANGUAGE = locale_name
            break
Example #54
0
    def __init__(self, parent, receiver_slot, settings, video_dict={}):
        super().__init__(parent, receiver_slot, settings, video_dict)
        self.setWindowTitle(
            QCoreApplication.translate("ytaddlink_src_ui_tr", 'Video Finder'))
        self.size_label.hide()

        # add support for other languages
        locale = str(self.persepolis_setting.value('settings/locale'))
        QLocale.setDefault(QLocale(locale))
        self.translator = QTranslator()
        if self.translator.load(':/translations/locales/ui_' + locale, 'ts'):
            QCoreApplication.installTranslator(self.translator)

        # Fetch Button
        self.url_submit_button = QPushButton(self.link_frame)
        self.link_horizontalLayout.addWidget(self.url_submit_button)

        # Status Box
        self.status_box = QTextEdit(self.link_frame)
        self.status_box.setMaximumHeight(150)
        self.link_verticalLayout.addWidget(self.status_box)

        # Select format horizontal layout
        select_format_hl = QHBoxLayout()

        # Selection Label
        select_format_label = QLabel(self.link_frame)
        select_format_hl.addWidget(select_format_label)

        # Selection combobox
        self.media_combo = QComboBox(self.link_frame)
        self.media_combo.setMinimumWidth(200)
        select_format_hl.addWidget(self.media_combo)

        # Duration label
        self.duration_label = QLabel(self.link_frame)
        select_format_hl.addWidget(self.duration_label)

        self.selection_line = QFrame(self)
        self.selection_line.setLayout(select_format_hl)
        self.link_verticalLayout.addWidget(self.selection_line)

        # Set Texts
        self.url_submit_button.setText(
            QCoreApplication.translate("ytaddlink_src_ui_tr",
                                       'Fetch Media List'))
        self.ok_pushButton.setText(
            QCoreApplication.translate("ytaddlink_src_ui_tr", 'Download Now'))
        select_format_label.setText(
            QCoreApplication.translate("ytaddlink_src_ui_tr",
                                       'Select a format'))

        # Add Slot Connections
        self.url_submit_button.setEnabled(False)
        self.change_name_lineEdit.setEnabled(False)
        self.ok_pushButton.setEnabled(False)
        self.download_later_pushButton.setEnabled(False)

        self.url_submit_button.clicked.connect(self.submit_clicked)
        self.media_combo.currentIndexChanged.connect(
            self.media_selection_changed)
        self.link_lineEdit.textChanged.disconnect(
            super().linkLineChanged)  # Should be disconnected.
        self.link_lineEdit.textChanged.connect(self.linkLineChangedHere)

        self.setMinimumSize(500, 400)

        self.status_box.hide()
        self.selection_line.hide()

        if 'link' in video_dict.keys() and video_dict['link']:
            self.link_lineEdit.setText(video_dict['link'])
            self.url_submit_button.setEnabled(True)
        else:
            # check clipboard
            clipboard = QApplication.clipboard()
            text = clipboard.text()
            if (("tp:/" in text[2:6]) or ("tps:/" in text[2:7])):
                self.link_lineEdit.setText(str(text))

            self.url_submit_button.setEnabled(True)
Example #55
0
    def __init__(self, parent=None):
        super().__init__()
        self.parent = parent
        self.setWindowTitle(self.tr("Welcome"))

        self.setLayout(QVBoxLayout())
        self.layout().setAlignment(Qt.AlignCenter)

        titleLabel = QLabel()
        titleLabel.setAlignment(Qt.AlignCenter)
        titleLabel.setText(self.tr("<h1>Welcome to Lime GNU/Linux System Installer.</h1>"))
        self.layout().addWidget(titleLabel)

        descLabel = QLabel()
        descLabel.setAlignment(Qt.AlignCenter)
        descLabel.setText(self.tr("This program is going to ask you some questions and then will install the Lime GNU/Linux to your device."))
        self.layout().addWidget(descLabel)

        lLayout = QHBoxLayout()
        lLayout.setAlignment(Qt.AlignCenter)
        self.layout().addLayout(lLayout)

        imageLabel = QLabel()
        imageLabel.setPixmap(QPixmap(":/images/welcome.svg"))
        imageLabel.setScaledContents(True)
        imageLabel.setFixedSize(256, 256)
        lLayout.addWidget(imageLabel)

        langLayout = QHBoxLayout()
        langLayout.setAlignment(Qt.AlignCenter)
        self.layout().addLayout(langLayout)

        langLabel = QLabel()
        langLabel.setText(self.tr("Language:"))
        langLayout.addWidget(langLabel)

        langComboBox = QComboBox()
        langComboBox.setFixedWidth(250)
        langLayout.addWidget(langComboBox)

        linkLayout = QHBoxLayout()
        linkLayout.setAlignment(Qt.AlignCenter)
        self.layout().addLayout(linkLayout)

        aboutButton = QPushButton()
        aboutButton.setFlat(True)
        aboutButton.setText(self.tr("About"))
        aboutButton.setIcon(QIcon(":/images/about.svg"))
        aboutButton.setIconSize(QSize(18, 18))
        linkLayout.addWidget(aboutButton)

        bugButton = QPushButton()
        bugButton.setFlat(True)
        bugButton.setText(self.tr("Found Bugs"))
        bugButton.setIcon(QIcon(":/images/bug.svg"))
        bugButton.setIconSize(QSize(18, 18))
        linkLayout.addWidget(bugButton)

        releaseButton = QPushButton()
        releaseButton.setFlat(True)
        releaseButton.setText(self.tr("Release Notes"))
        releaseButton.setIcon(QIcon(":/images/release-note.svg"))
        releaseButton.setIconSize(QSize(18, 18))
        linkLayout.addWidget(releaseButton)

        langComboBox.addItems(["Català", "Deutsch", "English (US)", "Español", "Français", "Magyar", "Italiano",
                               "Nederlands", "Polski", "Português (Brasil)", "Pусский", "Svenska", "Türkçe"])

        for k, v in self.lang_list.items():
            if QLocale.system().name()+".UTF-8" == k:
                langComboBox.setCurrentText(v)
                self.parent.lilii_settings["lang"] = k

        langComboBox.currentTextChanged.connect(self.langSelect)
        aboutButton.clicked.connect(self.aboutDialog)
        bugButton.clicked.connect(self.bugAdressConnect)
        releaseButton.clicked.connect(self.releaseInfoConnect)
Example #56
0
    'highlightCurrentLine': False,
    'iconTheme': '',
    'lineNumbersEnabled': False,
    'livePreviewByDefault': False,
    'markdownDefaultFileExtension': '.mkd',
    'pygmentsStyle': 'default',
    'restDefaultFileExtension': '.rst',
    'rightMargin': 0,
    'saveWindowGeometry': False,
    'spellCheck': False,
    'spellCheckLocale': '',
    'styleSheet': '',
    'syncScroll': True,
    'tabInsertsSpaces': True,
    'tabWidth': 4,
    'uiLanguage': QLocale.system().name(),
    'useFakeVim': False,
    'useWebKit': False,
    'windowGeometry': QByteArray(),
}


def readFromSettings(key, keytype, settings=settings, default=None):
    if isinstance(default, QFont):
        family = readFromSettings(key, str, settings, default.family())
        size = readFromSettings(key + 'Size', int, settings, 0)
        return QFont(family, size)
    if not settings.contains(key):
        return default
    try:
        value = settings.value(key, type=keytype)
Example #57
0
    def value_updated(self, item, interpolation=-1, value=None, interpolation_details=[]):
        """ Table cell change event - also handles context menu to update interpolation value """

        if self.ignore_update_signal:
            return

        # Get translation method
        _ = get_app()._tr

        # Determine what was changed
        property = self.model.item(item.row(), 0).data()
        property_name = property[1]["name"]
        closest_point_x = property[1]["closest_point_x"]
        previous_point_x = property[1]["previous_point_x"]
        property_type = property[1]["type"]
        property_key = property[0]
        clip_id, item_type = item.data()

        # Get value (if any)
        if item.text():
            # Set and format value based on property type
            if value != None:
                # Override value
                new_value = value
            elif property_type == "string":
                # Use string value
                new_value = item.text()
            elif property_type == "bool":
                # Use boolean value
                if item.text() == _("False"):
                    new_value = False
                else:
                    new_value = True
            elif property_type == "int":
                # Use int value
                new_value = QLocale().system().toInt(item.text())[0]
            else:
                # Use decimal value
                new_value = QLocale().system().toFloat(item.text())[0]
        else:
            new_value = None

        log.info("%s for %s changed to %s at frame %s with interpolation: %s at closest x: %s" % (property_key, clip_id, new_value, self.frame_number, interpolation, closest_point_x))


        # Find this clip
        c = None
        clip_updated = False

        if item_type == "clip":
            # Get clip object
            c = Clip.get(id=clip_id)
        elif item_type == "transition":
            # Get transition object
            c = Transition.get(id=clip_id)
        elif item_type == "effect":
            # Get effect object
            c = Effect.get(id=clip_id)

        if c:
            # Update clip attribute
            if property_key in c.data:
                log.info("value updated: %s" % c.data)

                # Check the type of property (some are keyframe, and some are not)
                if type(c.data[property_key]) == dict:
                    # Keyframe
                    # Loop through points, find a matching points on this frame
                    found_point = False
                    point_to_delete = None
                    for point in c.data[property_key]["Points"]:
                        log.info("looping points: co.X = %s" % point["co"]["X"])
                        if interpolation == -1 and point["co"]["X"] == self.frame_number:
                            # Found point, Update value
                            found_point = True
                            clip_updated = True
                            # Update or delete point
                            if new_value != None:
                                point["co"]["Y"] = float(new_value)
                                log.info("updating point: co.X = %s to value: %s" % (point["co"]["X"], float(new_value)))
                            else:
                                point_to_delete = point
                            break

                        elif interpolation > -1 and point["co"]["X"] == previous_point_x:
                            # Only update interpolation type (and the LEFT side of the curve)
                            found_point = True
                            clip_updated = True
                            point["interpolation"] = interpolation
                            if interpolation == 0:
                                point["handle_right"] = point.get("handle_right") or {"Y": 0.0, "X": 0.0}
                                point["handle_right"]["X"] = interpolation_details[0]
                                point["handle_right"]["Y"] = interpolation_details[1]

                            log.info("updating interpolation mode point: co.X = %s to %s" % (point["co"]["X"], interpolation))
                            log.info("use interpolation preset: %s" % str(interpolation_details))

                        elif interpolation > -1 and point["co"]["X"] == closest_point_x:
                            # Only update interpolation type (and the RIGHT side of the curve)
                            found_point = True
                            clip_updated = True
                            point["interpolation"] = interpolation
                            if interpolation == 0:
                                point["handle_left"] = point.get("handle_left") or {"Y": 0.0, "X": 0.0}
                                point["handle_left"]["X"] = interpolation_details[2]
                                point["handle_left"]["Y"] = interpolation_details[3]

                            log.info("updating interpolation mode point: co.X = %s to %s" % (point["co"]["X"], interpolation))
                            log.info("use interpolation preset: %s" % str(interpolation_details))

                    # Delete point (if needed)
                    if point_to_delete:
                        clip_updated = True
                        log.info("Found point to delete at X=%s" % point_to_delete["co"]["X"])
                        c.data[property_key]["Points"].remove(point_to_delete)

                    # Create new point (if needed)
                    elif not found_point and new_value != None:
                        clip_updated = True
                        log.info("Created new point at X=%s" % self.frame_number)
                        c.data[property_key]["Points"].append({'co': {'X': self.frame_number, 'Y': new_value}, 'interpolation': 1})

                elif property_type == "int":
                    # Integer
                    clip_updated = True
                    c.data[property_key] = int(new_value)

                elif property_type == "float":
                    # Float
                    clip_updated = True
                    c.data[property_key] = new_value

                elif property_type == "bool":
                    # Boolean
                    clip_updated = True
                    c.data[property_key] = bool(new_value)

                elif property_type == "string":
                    # String
                    clip_updated = True
                    c.data[property_key] = str(new_value)


            # Reduce # of clip properties we are saving (performance boost)
            c.data = {property_key: c.data.get(property_key)}

            # Save changes
            if clip_updated:
                # Save
                c.save()

                # Update the preview
                get_app().window.refreshFrameSignal.emit()

            # Clear selection
            self.parent.clearSelection()
Example #58
0
    def createEditor(self, userType, parent):
        if userType == QVariant.Double:
            doubleSpinBox = QtWidgets.QDoubleSpinBox(parent)
            doubleSpinBox.setDecimals(4)
            doubleSpinBox.setMaximum(-10000000)
            doubleSpinBox.setMaximum(
                10000000)  # The default maximum value is 99.99.所以要设置一下
            return doubleSpinBox
        else:
            return super().createEditor(userType, parent)


if __name__ == '__main__':
    import sys
    app = QtWidgets.QApplication([])
    QLocale.setDefault(QLocale(QLocale.English, QLocale.UnitedStates))
    w = QtWidgets.QMainWindow()
    table = TableView(w)
    styledItemDelegate = QtWidgets.QStyledItemDelegate()
    styledItemDelegate.setItemEditorFactory(SpinBoxDelegate())
    table.setItemDelegate(styledItemDelegate)

    table.setModel(
        TableModel([[name, 0., 1., 0.1]
                    for name in ['X_axis', 'Y_axis', 'theta_axis']],
                   header=['Actuator', 'Start', 'Stop', 'Step'],
                   editable=[False, True, True, True]))
    w.setCentralWidget(table)
    w.show()
    sys.exit(app.exec_())
Example #59
0
    def update_model(self, filter=""):
        log.info("updating clip properties model.")
        app = get_app()
        _ = app._tr

        # Stop QTimer
        self.update_timer.stop()

        # Check for a selected clip
        if self.selected and self.selected[0]:
            c, item_type = self.selected[0]

            # Skip blank clips
            # TODO: Determine why c is occasional = None
            if not c:
                return

            # Get raw unordered JSON properties
            raw_properties = json.loads(c.PropertiesJSON(self.frame_number))
            all_properties = OrderedDict(sorted(raw_properties.items(), key=lambda x: x[1]['name']))
            log.info("Getting properties for frame %s: %s" % (self.frame_number, str(all_properties)))

            # Check if filter was changed (if so, wipe previous model data)
            if self.previous_filter != filter:
                self.previous_filter = filter
                self.new_item = True  # filter changed, so we need to regenerate the entire model

            # Ignore any events from this method
            self.ignore_update_signal = True

            # Clear previous model data (if item is different)
            if self.new_item:
                # Prepare for new properties
                self.items = {}
                self.model.clear()

                # Add Headers
                self.model.setHorizontalHeaderLabels([_("Property"), _("Value")])


            # Loop through properties, and build a model
            for property in all_properties.items():
                label = property[1]["name"]
                name = property[0]
                value = property[1]["value"]
                type = property[1]["type"]
                memo = property[1]["memo"]
                readonly = property[1]["readonly"]
                keyframe = property[1]["keyframe"]
                points = property[1]["points"]
                interpolation = property[1]["interpolation"]
                closest_point_x = property[1]["closest_point_x"]
                choices = property[1]["choices"]

                # Adding Transparency to translation file
                transparency_label = _("Transparency")

                selected_choice = None
                if choices:
                    selected_choice = [c for c in choices if c["selected"] == True][0]["name"]

                # Hide filtered out properties
                if filter and filter.lower() not in name.lower():
                    continue

                # Hide unused base properties (if any)
                if name in self.filter_base_properties:
                    continue

                # Insert new data into model, or update existing values
                row = []
                if self.new_item:

                    # Append Property Name
                    col = QStandardItem("Property")
                    col.setText(_(label))
                    col.setData(property)
                    if keyframe and points > 1:
                        col.setBackground(QColor("green"))  # Highlight keyframe background
                    elif points > 1:
                        col.setBackground(QColor(42, 130, 218))  # Highlight interpolated value background
                    if readonly:
                        col.setFlags(Qt.ItemIsEnabled)
                    else:
                        col.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled | Qt.ItemIsUserCheckable)
                    row.append(col)

                    # Append Value
                    col = QStandardItem("Value")
                    if selected_choice:
                        col.setText(_(selected_choice))
                    elif type == "string":
                        # Use string value
                        col.setText(memo)
                    elif type == "bool":
                        # Use boolean value
                        if value:
                            col.setText(_("True"))
                        else:
                            col.setText(_("False"))
                    elif type == "color":
                        # Don't output a value for colors
                        col.setText("")
                    elif type == "int":
                        col.setText("%d" % value)
                    else:
                        # Use numeric value
                        col.setText(QLocale().system().toString(float(value), "f", precision=2))
                    col.setData((c.Id(), item_type))
                    if points > 1:
                        # Apply icon to cell
                        my_icon = QPixmap(os.path.join(info.IMAGES_PATH, "keyframe-%s.png" % interpolation))
                        col.setData(my_icon, Qt.DecorationRole)

                        log.info(os.path.join(info.IMAGES_PATH, "keyframe-%s.png" % interpolation))

                        # Set the background color of the cell
                        if keyframe:
                            col.setBackground(QColor("green"))  # Highlight keyframe background
                        else:
                            col.setBackground(QColor(42, 130, 218))  # Highlight interpolated value background

                    if type == "color":
                        # Color needs to be handled special
                        red = property[1]["red"]["value"]
                        green = property[1]["green"]["value"]
                        blue = property[1]["blue"]["value"]
                        col.setBackground(QColor(red, green, blue))

                    if readonly or type == "color" or choices:
                        col.setFlags(Qt.ItemIsEnabled)
                    else:
                        col.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled | Qt.ItemIsUserCheckable | Qt.ItemIsEditable)
                    row.append(col)

                    # Append ROW to MODEL (if does not already exist in model)
                    self.model.appendRow(row)

                else:
                    # Update the value of the existing model
                    # Get 1st Column
                    col = self.items[name]["row"][0]
                    col.setData(property)

                    # For non-color types, update the background color
                    if keyframe and points > 1:
                        col.setBackground(QColor("green"))  # Highlight keyframe background
                    elif points > 1:
                        col.setBackground(QColor(42, 130, 218))  # Highlight interpolated value background
                    else:
                        col.setBackground(QStandardItem("Empty").background())

                    # Update helper dictionary
                    row.append(col)

                    # Get 2nd Column
                    col = self.items[name]["row"][1]
                    if selected_choice:
                        col.setText(_(selected_choice))
                    elif type == "string":
                        # Use string value
                        col.setText(memo)
                    elif type == "bool":
                        # Use boolean value
                        if value:
                            col.setText(_("True"))
                        else:
                            col.setText(_("False"))
                    elif type == "color":
                        # Don't output a value for colors
                        col.setText("")
                    elif type == "int":
                        col.setText("%d" % value)
                    else:
                        # Use numeric value
                        col.setText(QLocale().system().toString(float(value), "f", precision=2))

                    if points > 1:
                        # Apply icon to cell
                        my_icon = QPixmap(os.path.join(info.IMAGES_PATH, "keyframe-%s.png" % interpolation))
                        col.setData(my_icon, Qt.DecorationRole)

                        # Set the background color of the cell
                        if keyframe:
                            col.setBackground(QColor("green"))  # Highlight keyframe background
                        else:
                            col.setBackground(QColor(42, 130, 218))  # Highlight interpolated value background

                    else:
                        # clear background color
                        col.setBackground(QStandardItem("Empty").background())

                        # clear icon
                        my_icon = QPixmap()
                        col.setData(my_icon, Qt.DecorationRole)

                    if type == "color":
                        # Update the color based on the color curves
                        red = property[1]["red"]["value"]
                        green = property[1]["green"]["value"]
                        blue = property[1]["blue"]["value"]
                        col.setBackground(QColor(red, green, blue))

                    # Update helper dictionary
                    row.append(col)

                # Keep track of items in a dictionary (for quick look up)
                self.items[name] = {"row": row, "property": property}

            # Update the values on the next call to this method (instead of adding rows)
            self.new_item = False

        else:
            # Clear previous properties hash
            self.previous_hash = ""

            # Clear previous model data (if any)
            self.model.clear()

            # Add Headers
            self.model.setHorizontalHeaderLabels([_("Property"), _("Value")])


        # Done updating model
        self.ignore_update_signal = False
Example #60
-5
    def __init__(self, argv, qapp):
        '''
        Create a new "cutecoin" application

        :param argv: The argv parameters of the call
        '''
        super().__init__()
        self.accounts = {}
        self.current_account = None
        self.monitor = None
        self.available_version = (True,
                                  __version__,
                                  "")
        config.parse_arguments(argv)
        self._network_manager = QNetworkAccessManager()
        self._network_manager.finished.connect(self.read_available_version)
        self.preferences = {'account': "",
                            'lang': 'en_GB',
                            'ref': 0
                            }

        self.load()

        translator = QTranslator(qapp)
        logging.debug("Loading translations")
        locale = self.preferences['lang']
        QLocale.setDefault(QLocale(locale))
        if translator.load(":/i18n/{0}".format(locale)):
            if QCoreApplication.installTranslator(translator):
                logging.debug("Loaded i18n/{0}".format(locale))
        else:
            logging.debug("Couldn't load translation")