Lib/plat-mac/ic.py

   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()