Changeset 11300:306fd82d04e3 in orange


Ignore:
Timestamp:
02/04/13 12:28:42 (15 months ago)
Author:
Ales Erjavec <ales.erjavec@…>
Branch:
default
Message:

Removed PyQt < v4.8.3 compatibility code from settings module.

Relying instead on utils.qtcompat to export a compatible interface.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • Orange/OrangeCanvas/utils/settings.py

    r11249 r11300  
    1212from collections import namedtuple, MutableMapping 
    1313 
    14 from PyQt4.QtCore import QObject, QVariant, QString, QChar, QEvent, \ 
    15                          QSettings, QCoreApplication 
     14from PyQt4.QtCore import QObject, QString, QChar, QEvent, QCoreApplication 
    1615 
    1716from PyQt4.QtCore import pyqtSignal as Signal 
    18 from PyQt4.QtCore import PYQT_VERSION, pyqtWrapperType 
     17from PyQt4.QtCore import pyqtWrapperType 
    1918 
    2019from . import toPyObject 
     20 
     21# Import QSettings from qtcompat module (compatibility with PyQt < 4.8.3 
     22from .qtcompat import QSettings 
    2123 
    2224log = logging.getLogger(__name__) 
     
    6870 
    6971 
    70 class _Settings(QSettings): 
    71     def __init__(self, parent=None): 
    72         QSettings.__init__(self, parent) 
    73  
    74     def _fullKey(self, key): 
    75         group = unicode(self.group()) 
    76         if group: 
    77             return "{0}/{1}".format(group.rstrip("/"), unicode(key)) 
    78         else: 
    79             return unicode(key) 
    80  
    81     def _value(self, key, defaultValue, type): 
    82         if PYQT_VERSION < 0x40803: 
    83             # QSettings.value does not have `type` argument before PyQt4 4.8.3 
    84             value = QSettings.value(self, key, defaultValue) 
    85  
    86             if type is not None: 
    87                 value = qvariant_to_py(value, type) 
    88         else: 
    89             value = QSettings.value(self, key, defaultValue, type) 
    90  
    91         return value 
    92  
    93     def value(self, key, defaultValue=None, type=None): 
    94         """ 
    95         """ 
    96         if QSettings.contains(self, key): 
    97             value = self._value(key, defaultValue, type) 
    98         else: 
    99             value = QSettings.value(self, key, defaultValue) 
    100         return value 
    101  
    102  
    103 def _check_error((val, status)): 
    104     if not status: 
    105         raise TypeError() 
    106     else: 
    107         return val 
    108  
    109  
    110 def qvariant_to_py(variant, py_type): 
    111     """Convert a QVariant object to a python object of type `py_type`. 
    112     """ 
    113     vtype = variant.type() 
    114  
    115     if vtype == QVariant.Invalid: 
    116         if py_type is not None: 
    117             raise TypeError("Invalid variant type") 
    118         else: 
    119             return None 
    120  
    121     elif vtype in [QVariant.Hash, QVariant.Map]: 
    122         variant = variant.toPyObject() 
    123         return dict((unicode(key), py_type(value)) 
    124                     for key, value in variant.items()) 
    125  
    126     elif vtype == QVariant.List: 
    127         variant = variant.toPyObject() 
    128         return [py_type(item) for item in variant] 
    129  
    130     if issubclass(py_type, basestring): 
    131         return py_type(variant.toString()) 
    132     elif py_type == bool: 
    133         return variant.toBool() 
    134     elif py_type == int: 
    135         return _check_error(variant.toInt()) 
    136     elif py_type == float: 
    137         return _check_error(variant.toDouble()) 
    138     else: 
    139         raise NotImplementedError 
    140  
    141  
    14272def qt_to_mapped_type(value): 
    143     """Try to convert a Qt value to the corresponding python 
    144     mapped type (i.e. QString to unicode, etc.) 
     73    """ 
     74    Try to convert a Qt value to the corresponding python mapped type 
     75    (i.e. QString to unicode, etc.). 
    14576 
    14677    """ 
     
    16596 
    16697class Settings(QObject, MutableMapping): 
     98    """ 
     99    A `dict` like interface to a QSettings store. 
     100    """ 
    167101    __metaclass__ = QABCMeta 
    168102 
     
    184118 
    185119    def __key(self, key): 
     120        """ 
     121        Return the full key (including group path). 
     122        """ 
    186123        if self.__path: 
    187124            return "/".join([self.__path, key]) 
     
    227164    def __value(self, fullkey, value_type): 
    228165        typesafe = value_type is not None 
    229         if PYQT_VERSION < 0x40803: 
    230             # QSettings.value does not have `type` argument. 
     166 
     167        if value_type is None: 
    231168            value = toPyObject(self.__store.value(fullkey)) 
    232             typesafe = False 
    233         else: 
    234             if value_type is None: 
     169        else: 
     170            try: 
     171                value = self.__store.value(fullkey, type=value_type) 
     172            except TypeError: 
     173                # In case the value was pickled in a type unsafe mode 
    235174                value = toPyObject(self.__store.value(fullkey)) 
    236             else: 
    237                 try: 
    238                     value = self.__store.value(fullkey, type=value_type) 
    239                 except TypeError: 
    240                     # In case the value was pickled in a type unsafe mode 
    241                     value = toPyObject(self.__store.value(fullkey)) 
    242                     typesafe = False 
     175                typesafe = False 
    243176 
    244177        if not typesafe: 
     
    255188    def __setValue(self, fullkey, value, value_type=None): 
    256189        typesafe = value_type is not None 
    257         if PYQT_VERSION < 0x40803: 
    258             # QSettings.value does not have `type` argument. 
    259             typesafe = False 
    260  
    261190        if not typesafe: 
    262191            # value is stored in a _pickledvalue wrapper to force PyQt 
     
    275204 
    276205        if self.isgroup(key): 
    277             raise KeyError("is a group") 
     206            raise KeyError("{0!r} is a group".format(key)) 
    278207 
    279208        fullkey = self.__key(key) 
     
    350279 
    351280    def isgroup(self, key): 
    352         """Is the `key` a settings group i.e. does it have subkeys. 
     281        """ 
     282        Is the `key` a settings group i.e. does it have subkeys. 
    353283        """ 
    354284        if key not in self: 
     
    358288 
    359289    def isdefault(self, key): 
    360         """Is the value for key the default. 
     290        """ 
     291        Is the value for key the default. 
    361292        """ 
    362293        if key not in self: 
     
    365296 
    366297    def clear(self): 
    367         """Clear the settings and restore the defaults. 
     298        """ 
     299        Clear the settings and restore the defaults. 
    368300        """ 
    369301        self.__store.clear() 
    370302 
    371303    def add_default_slot(self, default): 
    372         """Add a default slot to the settings This also replaces any 
     304        """ 
     305        Add a default slot to the settings This also replaces any 
    373306        previously set value for the key. 
    374307 
     
    394327 
    395328    def values(self): 
    396         """Return a list over of all values in the settings. 
     329        """ 
     330        Return a list over of all values in the settings. 
    397331        """ 
    398332        return MutableMapping.values(self) 
Note: See TracChangeset for help on using the changeset viewer.