Python Qt.QSettings类代码示例

class MicroblogThread(QThread):

    def __init__(self, app, user, service, updateusers = True):
        QThread.__init__(self, app)
        self.app = app
        self.user = user
        self.service = service
        self.updateusers = updateusers
        self.friends = QSettings("blain", "%s-%s-friends" % (user, service))


    def run(self):
        if not self.service or not self.user:
            self.quit()
            return
        trys = 0
        page = -1
        new_friends = None
        try:
            friendscount = api_call(self.service, 'users/show',
                {'id': self.user})['friends_count']
        except:
            print_exc()
            self.end()
            return
        while friendscount > 0:
            page = next_page(self.service, page, new_friends)
            print "Fetching from friends page %i, %i updates remaining (%s)" % \
                (page, friendscount, self.service),"[%i]"%trys
            new_friends = get_friends(self.service, self.user, page)
            stop = False
            friendscount -= len(new_friends)
            if len(new_friends) == 0:
                trys += 1
            for friend in new_friends:
                id = str(friend['screen_name'])
                if self.friends.contains(id):
                    print id, "(found)", self.service
                    stop = True
                else:
                    print id, "(new)", self.service
                dump = json.dumps(friend)
                self.friends.setValue(id, dump)
            if stop or trys > 3: break
            #self.yieldCurrentThread()
        print "friends list up-to-date. (%s)" % self.service
        self.end()

    def end(self):
        self.app.killThread.emit("__%s__" % self.service)
        # update all users
        if self.updateusers:
            for user in self.friends.allKeys() + [self.user]:
                self.app.updateUser.emit(self.service, user)
        self.app.updates.updates.friends(self.service, user)
        print "done."
        self.quit()

 def settingsValue( key, default):
     syslog.syslog( syslog.LOG_DEBUG,
                    "DEBUG  settingsValue %s, default: %s" %
                    (key, str(default)))
     s = QSettings()
     var = s.value(key, default)
     if not s.contains(key): s.setValue( key, var)
     syslog.syslog( syslog.LOG_DEBUG,
                    "DEBUG  settingsValue %s, value:   %s" %
                    (key, var.toString()))
     return var

    def read_settings(self):
        logging.debug('Reading settings')

        settings = QSettings()
        read_settings = self.defaults.copy()
        keys = settings.allKeys()

        for k in keys:
            setting_type = QTouTvSettings._settings_types[k]
            read_settings[k] = settings.value(k, type=setting_type)

        self.apply_settings(read_settings)

 def __new__(cls, clear_cache = False):
     if not cls._instance:
         cls._instance = super(Settings, cls).__new__(cls)
         cls._instance.signals = Settings.signals()
         QSettings.setDefaultFormat(QSettings.IniFormat)
         log.DEBUG("saving settings in file %s" %(QSettings().fileName()));
         cls._instance._settings = QSettings()
         cls._defaults = {
              Settings.DOTA_PATH_KEY: dota_path_default,
              Settings.STEAM_PATH_KEY: steam_path_default,
          }
     if clear_cache:
         cls._instance._cache = {}
     return cls._instance

 def __init__(self, app, user, service, updateusers = True):
     QThread.__init__(self, app)
     self.app = app
     self.user = user
     self.service = service
     self.updateusers = updateusers
     self.friends = QSettings("blain", "%s-%s-friends" % (user, service))

 def __init__(self, app):
     if not hasattr(app, 'db'):
         print("filters: need 'db' from app.")
         exit(1)
     self.app = app
     self._filters = {}
     self._keys = []
     self._instances = ([], [])
     self.settings = QSettings("blain", "filters")

class GroupsThread(QThread):

    def __init__(self, app, user, updategroups = True):
        QThread.__init__(self, app)
        self.app = app
        self.user = user
        self.updategroups = updategroups
        self.groups = QSettings("blain", "%s-groups" % user)


    def run(self):
        if not self.user:
            self.quit()
            return
        trys = 0
        new_groups = None
        while trys < 4:
            trys += 1
            new_groups = get_group(self.user)
            if new_groups is not None:
                break
        if new_groups is None:
            self.end()
            return
        for group in new_groups:
            id = str(group['nickname'])
            if self.groups.contains(id):
                print id, "(found)"
            else:
                print id, "(new)"
            dump = json.dumps(clean_urls(group))
            self.groups.setValue(id, dump)
        print "groups list up-to-date. (%s)" % self.user
        self.end()

    def end(self):
        self.app.killThread.emit("%s groups" % self.user)
        # update all groups
        if self.updategroups:
            for group in self.groups.allKeys():
                self.app.updateGroup.emit(group)
        self.app.updates.updates.groups(self.user)
        print "done."
        self.quit()

 def __init__(self, app):
     if not hasattr(app, 'preferences'):
         print("update: need 'preferences' from app.")
         exit(1)
     self.app = app
     self.update = {}
     self.timers = []
     self.updates = drug()
     self.timer = QTimer(app)
     self.settings = QSettings("blain", "timers")

 def setup(self):
     st = QSettings("blain", "blain")
     st.setValue("_", 0)
     st.sync()
     settingspath = dirname(str(st.fileName()))
     self.db = db = Database(location=pathjoin(settingspath, "blain.sqlite"))
     setup_models(db)

 def __init__(self, app):
     if not hasattr(app, 'preferences'):
         print("accounts: need 'preferences' from app.")
         exit(1)
     if not hasattr(app, 'icons'):
         print("accounts: need 'icons' from app.")
         exit(1)
     self.app = app
     self.urls = {}
     self.services = {}
     self.accounts = {}
     self._accounts = []
     self.settings = QSettings("blain", "accounts")

    def __set_backup_path(self):

        settings = QSettings("GCI", "vertex-tools")
        settings.beginGroup("BackupSettings")
        default_path = QDir.tempPath()
        backup_path = settings.value("backup_path", default_path)
        self.backup_folder_edit.setText(backup_path)
        settings.endGroup()

    def write_settings(self):
        logging.debug('Writing settings')

        settings = QSettings()
        settings.clear()

        for k in self._settings_dict:
            if k in self.defaults:
                if self._settings_dict[k] != self.defaults[k]:
                    settings.setValue(k, self._settings_dict[k])
            else:
                msg = 'Setting key {} not found in defaults'.format(k)
                logging.warning(msg)
                settings.setValue(k, self._settings_dict[k])

    def on_backup_folder_button_clicked(self):

        backup_path = self.backup_folder_edit.text()
        if len(backup_path) == 0:
            backup_path = QDir.tempPath()

        backup_path = QFileDialog.getExistingDirectory(self, self.tr("Select Backup Folder"), backup_path,
                                                       QFileDialog.ShowDirsOnly | QFileDialog.DontResolveSymlinks)
        if len(backup_path) == 0:
            return

        self.backup_folder_edit.setText(backup_path)
        settings = QSettings("GCI", "vertex-tools")
        settings.beginGroup("BackupSettings")
        settings.setValue("backup_path", backup_path)
        settings.endGroup()

class Config:
    def __init__(self, organization, product):
        self.config = QSettings(organization, product)

    def setValue(self, option, value):
        self.config.setValue(option, QVariant(value))
        self.config.sync()

    def getBoolValue(self, option):
        default = self._initValue(option, False)
        return self.config.value(option, QVariant(default)).toBool()

    def getNumValue(self, option):
        default = self._initValue(option, 0)
        return self.config.value(option, QVariant(default)).toInt()[0]

    def _initValue(self, option, value):
        if defaults.has_key(option):
            return defaults[option]
        return value

            help=_('Show the average rating per item indication in the tag browser'))
    c.add_opt('disable_animations', default=False,
            help=_('Disable UI animations'))

    # This option is no longer used. It remains for compatibility with upgrades
    # so the value can be migrated
    c.add_opt('tag_browser_hidden_categories', default=set(),
            help=_('tag browser categories not to display'))

    c.add_opt
    return ConfigProxy(c)

config = _config()
# }}}

QSettings.setPath(QSettings.IniFormat, QSettings.UserScope, config_dir)
QSettings.setPath(QSettings.IniFormat, QSettings.SystemScope,
        config_dir)
QSettings.setDefaultFormat(QSettings.IniFormat)

# Turn off DeprecationWarnings in windows GUI
if iswindows:
    import warnings
    warnings.simplefilter('ignore', DeprecationWarning)

def available_heights():
    desktop  = QCoreApplication.instance().desktop()
    return map(lambda x: x.height(), map(desktop.availableGeometry, range(desktop.numScreens())))

def available_height():
    desktop  = QCoreApplication.instance().desktop()