symbian-qemu-0.9.1-12/python-2.6.1/Lib/plat-mac/ic.py
changeset 1 2fb8b9db1c86
equal deleted inserted replaced
0:ffa851df0825 1:2fb8b9db1c86
       
     1 """IC wrapper module, based on Internet Config 1.3"""
       
     2 
       
     3 from warnings import warnpy3k
       
     4 warnpy3k("In 3.x, the ic module is removed.", stacklevel=2)
       
     5 
       
     6 import icglue
       
     7 import string
       
     8 import sys
       
     9 import os
       
    10 from Carbon import Res
       
    11 import Carbon.File
       
    12 import macostools
       
    13 
       
    14 error=icglue.error
       
    15 
       
    16 # From ictypes.h:
       
    17 icPrefNotFoundErr = -666        # preference not found (duh!)
       
    18 icPermErr = -667                # cannot set preference
       
    19 icPrefDataErr = -668            # problem with preference data
       
    20 icInternalErr = -669            # hmm, this is not good
       
    21 icTruncatedErr = -670           # more data was present than was returned
       
    22 icNoMoreWritersErr = -671       # you cannot begin a write session because someone else is already doing it */
       
    23 icNothingToOverrideErr = -672   # no component for the override component to capture
       
    24 icNoURLErr = -673               # no URL found
       
    25 icConfigNotFoundErr = -674      # no configuration was found
       
    26 icConfigInappropriateErr = -675 # incorrect manufacturer code
       
    27 
       
    28 ICattr_no_change = -1
       
    29 
       
    30 icNoPerm = 0
       
    31 icReadOnlyPerm = 1
       
    32 icReadWritePerm = 2
       
    33 # End of ictypes.h
       
    34 
       
    35 class ICOpaqueData:
       
    36     """An unparseable IC entry"""
       
    37     def __init__(self, data):
       
    38         self.data = data
       
    39 
       
    40     def __repr__(self):
       
    41         return "ICOpaqueData(%r)"%(self.data,)
       
    42 
       
    43 _ICOpaqueDataType=type(ICOpaqueData(''))
       
    44 
       
    45 def _decode_default(data, key):
       
    46     if len(data) == 0:
       
    47         return data
       
    48     if ord(data[0]) == len(data)-1:
       
    49         # Assume Pstring
       
    50         return data[1:]
       
    51     return ICOpaqueData(data)
       
    52 
       
    53 
       
    54 def _decode_multistr(data, key):
       
    55     numstr = ord(data[0]) << 8 | ord(data[1])
       
    56     rv = []
       
    57     ptr = 2
       
    58     for i in range(numstr):
       
    59         strlen = ord(data[ptr])
       
    60         str = data[ptr+1:ptr+strlen+1]
       
    61         rv.append(str)
       
    62         ptr = ptr + strlen + 1
       
    63     return rv
       
    64 
       
    65 def _decode_fontrecord(data, key):
       
    66     size = ord(data[0]) << 8 | ord(data[1])
       
    67     face = ord(data[2])
       
    68     namelen = ord(data[4])
       
    69     return size, face, data[5:5+namelen]
       
    70 
       
    71 def _decode_boolean(data, key):
       
    72     return ord(data[0])
       
    73 
       
    74 def _decode_text(data, key):
       
    75     return data
       
    76 
       
    77 def _decode_charset(data, key):
       
    78     return data[:256], data[256:]
       
    79 
       
    80 def _decode_appspec(data, key):
       
    81     namelen = ord(data[4])
       
    82     return data[0:4], data[5:5+namelen]
       
    83 
       
    84 def _code_default(data, key):
       
    85     return chr(len(data)) + data
       
    86 
       
    87 def _code_multistr(data, key):
       
    88     numstr = len(data)
       
    89     rv = chr((numstr>>8) & 0xff) + chr(numstr & 0xff)
       
    90     for i in data:
       
    91         rv = rv + _code_default(i)
       
    92     return rv
       
    93 
       
    94 def _code_fontrecord(data, key):
       
    95     size, face, name = data
       
    96     return chr((size>>8) & 0xff) + chr(size & 0xff) + chr(face & 0xff) + \
       
    97         chr(0) + _code_default(name)
       
    98 
       
    99 def _code_boolean(data, key):
       
   100     print 'XXXX boolean:', repr(data)
       
   101     return chr(data)
       
   102 
       
   103 def _code_text(data, key):
       
   104     return data
       
   105 
       
   106 def _code_charset(data, key):
       
   107     return data[0] + data[1]
       
   108 
       
   109 def _code_appspec(data, key):
       
   110     return data[0] + _code_default(data[1])
       
   111 
       
   112 _decoder_table = {
       
   113     "ArchieAll" : (_decode_multistr , _code_multistr),
       
   114     "UMichAll" : (_decode_multistr , _code_multistr),
       
   115     "InfoMacAll" : (_decode_multistr , _code_multistr),
       
   116     "ListFont" : (_decode_fontrecord , _code_fontrecord),
       
   117     "ScreenFont" : (_decode_fontrecord , _code_fontrecord),
       
   118     "PrinterFont" : (_decode_fontrecord , _code_fontrecord),
       
   119 #   "DownloadFolder" : (_decode_filespec , _code_filespec),
       
   120     "Signature": (_decode_text , _code_text),
       
   121     "Plan" : (_decode_text , _code_text),
       
   122     "MailHeaders" : (_decode_text , _code_text),
       
   123     "NewsHeaders" : (_decode_text , _code_text),
       
   124 #   "Mapping"
       
   125     "CharacterSet" : (_decode_charset , _code_charset),
       
   126     "Helper\245" : (_decode_appspec , _code_appspec),
       
   127 #   "Services" : (_decode_services, ????),
       
   128     "NewMailFlashIcon" : (_decode_boolean , _code_boolean),
       
   129     "NewMailDialog" : (_decode_boolean , _code_boolean),
       
   130     "NewMailPlaySound" : (_decode_boolean , _code_boolean),
       
   131 #   "WebBackgroundColor" : _decode_color,
       
   132     "NoProxyDomains" : (_decode_multistr , _code_multistr),
       
   133     "UseHTTPProxy" : (_decode_boolean , _code_boolean),
       
   134     "UseGopherProxy": (_decode_boolean , _code_boolean),
       
   135     "UseFTPProxy" : (_decode_boolean , _code_boolean),
       
   136     "UsePassiveFTP" : (_decode_boolean , _code_boolean),
       
   137 }
       
   138 
       
   139 def _decode(data, key):
       
   140     if '\245' in key:
       
   141         key2 = key[:string.index(key, '\245')+1]
       
   142     else:
       
   143         key2 = key
       
   144     if _decoder_table.has_key(key2):
       
   145         decoder = _decoder_table[key2][0]
       
   146     else:
       
   147         decoder = _decode_default
       
   148     return decoder(data, key)
       
   149 
       
   150 def _code(data, key):
       
   151     if type(data) == _ICOpaqueDataType:
       
   152         return data.data
       
   153     if '\245' in key:
       
   154         key2 = key[:string.index(key, '\245')+1]
       
   155     else:
       
   156         key2 = key
       
   157     if _decoder_table.has_key(key2):
       
   158         coder = _decoder_table[key2][1]
       
   159     else:
       
   160         coder = _code_default
       
   161     return coder(data, key)
       
   162 
       
   163 class IC:
       
   164     def __init__(self, signature='Pyth', ic=None):
       
   165         if ic:
       
   166             self.ic = ic
       
   167         else:
       
   168             self.ic = icglue.ICStart(signature)
       
   169             if hasattr(self.ic, 'ICFindConfigFile'):
       
   170                 self.ic.ICFindConfigFile()
       
   171         self.h = Res.Resource('')
       
   172 
       
   173     def keys(self):
       
   174         rv = []
       
   175         self.ic.ICBegin(icReadOnlyPerm)
       
   176         num = self.ic.ICCountPref()
       
   177         for i in range(num):
       
   178             rv.append(self.ic.ICGetIndPref(i+1))
       
   179         self.ic.ICEnd()
       
   180         return rv
       
   181 
       
   182     def has_key(self, key):
       
   183         return self.__contains__(key)
       
   184 
       
   185     def __contains__(self, key):
       
   186         try:
       
   187             dummy = self.ic.ICFindPrefHandle(key, self.h)
       
   188         except icglue.error:
       
   189             return 0
       
   190         return 1
       
   191 
       
   192     def __getitem__(self, key):
       
   193         attr = self.ic.ICFindPrefHandle(key, self.h)
       
   194         return _decode(self.h.data, key)
       
   195 
       
   196     def __setitem__(self, key, value):
       
   197         value = _code(value, key)
       
   198         self.ic.ICSetPref(key, ICattr_no_change, value)
       
   199 
       
   200     def launchurl(self, url, hint=""):
       
   201         # Work around a bug in ICLaunchURL: file:/foo does
       
   202         # not work but file:///foo does.
       
   203         if url[:6] == 'file:/' and url[6] != '/':
       
   204             url = 'file:///' + url[6:]
       
   205         self.ic.ICLaunchURL(hint, url, 0, len(url))
       
   206 
       
   207     def parseurl(self, data, start=None, end=None, hint=""):
       
   208         if start is None:
       
   209             selStart = 0
       
   210             selEnd = len(data)
       
   211         else:
       
   212             selStart = selEnd = start
       
   213         if end is not None:
       
   214             selEnd = end
       
   215         selStart, selEnd = self.ic.ICParseURL(hint, data, selStart, selEnd, self.h)
       
   216         return self.h.data, selStart, selEnd
       
   217 
       
   218     def mapfile(self, file):
       
   219         if type(file) != type(''):
       
   220             file = file.as_tuple()[2]
       
   221         return self.ic.ICMapFilename(file)
       
   222 
       
   223     def maptypecreator(self, type, creator, filename=""):
       
   224         return self.ic.ICMapTypeCreator(type, creator, filename)
       
   225 
       
   226     def settypecreator(self, file):
       
   227         file = Carbon.File.pathname(file)
       
   228         record = self.mapfile(os.path.split(file)[1])
       
   229         MacOS.SetCreatorAndType(file, record[2], record[1])
       
   230         macostools.touched(fss)
       
   231 
       
   232 # Convenience routines
       
   233 _dft_ic = None
       
   234 
       
   235 def launchurl(url, hint=""):
       
   236     global _dft_ic
       
   237     if _dft_ic is None: _dft_ic = IC()
       
   238     return _dft_ic.launchurl(url, hint)
       
   239 
       
   240 def parseurl(data, start=None, end=None, hint=""):
       
   241     global _dft_ic
       
   242     if _dft_ic is None: _dft_ic = IC()
       
   243     return _dft_ic.parseurl(data, start, end, hint)
       
   244 
       
   245 def mapfile(filename):
       
   246     global _dft_ic
       
   247     if _dft_ic is None: _dft_ic = IC()
       
   248     return _dft_ic.mapfile(filename)
       
   249 
       
   250 def maptypecreator(type, creator, filename=""):
       
   251     global _dft_ic
       
   252     if _dft_ic is None: _dft_ic = IC()
       
   253     return _dft_ic.maptypecreator(type, creator, filename)
       
   254 
       
   255 def settypecreator(file):
       
   256     global _dft_ic
       
   257     if _dft_ic is None: _dft_ic = IC()
       
   258     return _dft_ic.settypecreator(file)
       
   259 
       
   260 def _test():
       
   261     ic = IC()
       
   262     for k in ic.keys():
       
   263         try:
       
   264             v = ic[k]
       
   265         except error:
       
   266             v = '????'
       
   267         print k, '\t', v
       
   268     sys.exit(1)
       
   269 
       
   270 if __name__ == '__main__':
       
   271     _test()