0001 # THIS FILE IS AUTOMATICALLY GENERATED. EDIT THE SOURCE FILE NOT THIS ONE 0002 0003 """Various descriptions of data specific to LG 6200 (Sprint)""" 0004 0005 import re 0006 0007 from prototypes import * 0008 from prototypeslg import * 0009 0010 # Make all lg stuff available in this module as well 0011 from p_lg import * 0012 # very similar to the pm225 0013 from p_lgpm225 import * 0014 0015 0016 # We use LSB for all integer like fields 0017 UINT=UINTlsb 0018 BOOL=BOOLlsb 0019 0020 NUMSPEEDDIALS=99 0021 FIRSTSPEEDDIAL=1 0022 LASTSPEEDDIAL=99 0023 NUMPHONEBOOKENTRIES=200 0024 MEMOLENGTH=33 0025 0026 NORINGTONE=0 0027 NOMSGRINGTONE=0 0028 NOWALLPAPER=0 0029 0030 NUMEMAILS=3 0031 NUMPHONENUMBERS=5 0032 0033 SMS_CANNED_MAX_ITEMS=40 0034 SMS_CANNED_MAX_LENGTH=104 0035 SMS_CANNED_FILENAME="sms/canned_msg.dat" 0036 SMS_PATTERNS={'Inbox': re.compile(r"^.*/inbox[0-9][0-9][0-9]\.dat$"), 0037 'Sent': re.compile(r"^.*/outbox[0-9][0-9][0-9]\.dat$"), 0038 'Saved': re.compile(r"^.*/sf[0-9][0-9]\.dat$"), 0039 } 0040 0041 numbertypetab=( 'cell', 'home', 'office', 'fax', 'pager' ) 0042 0043 # Text Memo const 0044 text_memo_file='sch/memo.dat' 0045 content_file_name='ams/contentInfo' 0046 content_count_file_name='ams/realContent' 0047 0048 media_directory='ams' 0049 ringerindex='setas/amsRingerIndex.map' 0050 imageindex='setas/amsImageIndex.map' 0051 ringerconst=2 0052 imageconst=3 0053 max_ringers=100 0054 max_images=100 0055 0056 phonebook_media='pim/pbookcontact.dat' 0057 0058 # Calendar parameters 0059 NUMCALENDARENTRIES=300 # ?? for VX4400 0060 CAL_REP_NONE=0x10 0061 CAL_REP_DAILY=0x11 0062 CAL_REP_MONFRI=0x12 0063 CAL_REP_WEEKLY=0x13 0064 CAL_REP_MONTHLY=0x14 0065 CAL_REP_YEARLY=0x15 0066 CAL_DOW_SUN=0x0800 0067 CAL_DOW_MON=0x0400 0068 CAL_DOW_TUE=0x0200 0069 CAL_DOW_WED=0x0100 0070 CAL_DOW_THU=0x0080 0071 CAL_DOW_FRI=0x0040 0072 CAL_DOW_SAT=0x0020 0073 CAL_DOW_EXCEPTIONS=0x0010 0074 CAL_REMINDER_NONE=0 0075 CAL_REMINDER_ONTIME=1 0076 CAL_REMINDER_5MIN=2 0077 CAL_REMINDER_10MIN=3 0078 CAL_REMINDER_1HOUR=4 0079 CAL_REMINDER_1DAY=5 0080 CAL_REMINDER_2DAYS=6 0081 CAL_REPEAT_DATE=(2100, 12, 31) 0082 0083 cal_dir='sch' 0084 cal_data_file_name='sch/schedule.dat' 0085 cal_exception_file_name='sch/schexception.dat' 0086 cal_has_voice_id=False 0087 0088 PHONE_ENCODING='iso8859_1' 0089 0090 class pbreadentryresponse(BaseProtogenClass): 0091 "Results of reading one entry" 0092 __fields=['header', 'entry'] 0093 0094 def __init__(self, *args, **kwargs): 0095 dict={} 0096 # What was supplied to this function 0097 dict.update(kwargs) 0098 # Parent constructor 0099 super(pbreadentryresponse,self).__init__(**dict) 0100 if self.__class__ is pbreadentryresponse: 0101 self._update(args,dict) 0102 0103 0104 def getfields(self): 0105 return self.__fields 0106 0107 0108 def _update(self, args, kwargs): 0109 super(pbreadentryresponse,self)._update(args,kwargs) 0110 keys=kwargs.keys() 0111 for key in keys: 0112 if key in self.__fields: 0113 setattr(self, key, kwargs[key]) 0114 del kwargs[key] 0115 # Were any unrecognized kwargs passed in? 0116 if __debug__: 0117 self._complainaboutunusedargs(pbreadentryresponse,kwargs) 0118 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 0119 # Make all P fields that haven't already been constructed 0120 0121 0122 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0123 'Writes this packet to the supplied buffer' 0124 self._bufferstartoffset=buf.getcurrentoffset() 0125 self.__field_header.writetobuffer(buf) 0126 self.__field_entry.writetobuffer(buf) 0127 self._bufferendoffset=buf.getcurrentoffset() 0128 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0129 0130 0131 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0132 'Reads this packet from the supplied buffer' 0133 self._bufferstartoffset=buf.getcurrentoffset() 0134 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0135 self.__field_header=pbheader() 0136 self.__field_header.readfrombuffer(buf) 0137 self.__field_entry=pbentry() 0138 self.__field_entry.readfrombuffer(buf) 0139 self._bufferendoffset=buf.getcurrentoffset() 0140 0141 0142 def __getfield_header(self): 0143 return self.__field_header.getvalue() 0144 0145 def __setfield_header(self, value): 0146 if isinstance(value,pbheader): 0147 self.__field_header=value 0148 else: 0149 self.__field_header=pbheader(value,) 0150 0151 def __delfield_header(self): del self.__field_header 0152 0153 header=property(__getfield_header, __setfield_header, __delfield_header, None) 0154 0155 def __getfield_entry(self): 0156 return self.__field_entry.getvalue() 0157 0158 def __setfield_entry(self, value): 0159 if isinstance(value,pbentry): 0160 self.__field_entry=value 0161 else: 0162 self.__field_entry=pbentry(value,) 0163 0164 def __delfield_entry(self): del self.__field_entry 0165 0166 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 0167 0168 def iscontainer(self): 0169 return True 0170 0171 def containerelements(self): 0172 yield ('header', self.__field_header, None) 0173 yield ('entry', self.__field_entry, None) 0174 0175 0176 0177 0178 class pbupdateentryrequest(BaseProtogenClass): 0179 __fields=['header', 'entry'] 0180 0181 def __init__(self, *args, **kwargs): 0182 dict={} 0183 # What was supplied to this function 0184 dict.update(kwargs) 0185 # Parent constructor 0186 super(pbupdateentryrequest,self).__init__(**dict) 0187 if self.__class__ is pbupdateentryrequest: 0188 self._update(args,dict) 0189 0190 0191 def getfields(self): 0192 return self.__fields 0193 0194 0195 def _update(self, args, kwargs): 0196 super(pbupdateentryrequest,self)._update(args,kwargs) 0197 keys=kwargs.keys() 0198 for key in keys: 0199 if key in self.__fields: 0200 setattr(self, key, kwargs[key]) 0201 del kwargs[key] 0202 # Were any unrecognized kwargs passed in? 0203 if __debug__: 0204 self._complainaboutunusedargs(pbupdateentryrequest,kwargs) 0205 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 0206 # Make all P fields that haven't already been constructed 0207 0208 0209 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0210 'Writes this packet to the supplied buffer' 0211 self._bufferstartoffset=buf.getcurrentoffset() 0212 try: self.__field_header 0213 except: 0214 self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01}) 0215 self.__field_header.writetobuffer(buf) 0216 self.__field_entry.writetobuffer(buf) 0217 self._bufferendoffset=buf.getcurrentoffset() 0218 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0219 0220 0221 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0222 'Reads this packet from the supplied buffer' 0223 self._bufferstartoffset=buf.getcurrentoffset() 0224 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0225 self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01}) 0226 self.__field_header.readfrombuffer(buf) 0227 self.__field_entry=pbentry() 0228 self.__field_entry.readfrombuffer(buf) 0229 self._bufferendoffset=buf.getcurrentoffset() 0230 0231 0232 def __getfield_header(self): 0233 try: self.__field_header 0234 except: 0235 self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01}) 0236 return self.__field_header.getvalue() 0237 0238 def __setfield_header(self, value): 0239 if isinstance(value,pbheader): 0240 self.__field_header=value 0241 else: 0242 self.__field_header=pbheader(value,**{'command': 0x04, 'flag': 0x01}) 0243 0244 def __delfield_header(self): del self.__field_header 0245 0246 header=property(__getfield_header, __setfield_header, __delfield_header, None) 0247 0248 def __getfield_entry(self): 0249 return self.__field_entry.getvalue() 0250 0251 def __setfield_entry(self, value): 0252 if isinstance(value,pbentry): 0253 self.__field_entry=value 0254 else: 0255 self.__field_entry=pbentry(value,) 0256 0257 def __delfield_entry(self): del self.__field_entry 0258 0259 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 0260 0261 def iscontainer(self): 0262 return True 0263 0264 def containerelements(self): 0265 yield ('header', self.__field_header, None) 0266 yield ('entry', self.__field_entry, None) 0267 0268 0269 0270 0271 class pbappendentryrequest(BaseProtogenClass): 0272 __fields=['header', 'entry'] 0273 0274 def __init__(self, *args, **kwargs): 0275 dict={} 0276 # What was supplied to this function 0277 dict.update(kwargs) 0278 # Parent constructor 0279 super(pbappendentryrequest,self).__init__(**dict) 0280 if self.__class__ is pbappendentryrequest: 0281 self._update(args,dict) 0282 0283 0284 def getfields(self): 0285 return self.__fields 0286 0287 0288 def _update(self, args, kwargs): 0289 super(pbappendentryrequest,self)._update(args,kwargs) 0290 keys=kwargs.keys() 0291 for key in keys: 0292 if key in self.__fields: 0293 setattr(self, key, kwargs[key]) 0294 del kwargs[key] 0295 # Were any unrecognized kwargs passed in? 0296 if __debug__: 0297 self._complainaboutunusedargs(pbappendentryrequest,kwargs) 0298 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 0299 # Make all P fields that haven't already been constructed 0300 0301 0302 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0303 'Writes this packet to the supplied buffer' 0304 self._bufferstartoffset=buf.getcurrentoffset() 0305 try: self.__field_header 0306 except: 0307 self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01}) 0308 self.__field_header.writetobuffer(buf) 0309 self.__field_entry.writetobuffer(buf) 0310 self._bufferendoffset=buf.getcurrentoffset() 0311 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0312 0313 0314 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0315 'Reads this packet from the supplied buffer' 0316 self._bufferstartoffset=buf.getcurrentoffset() 0317 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0318 self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01}) 0319 self.__field_header.readfrombuffer(buf) 0320 self.__field_entry=pbentry() 0321 self.__field_entry.readfrombuffer(buf) 0322 self._bufferendoffset=buf.getcurrentoffset() 0323 0324 0325 def __getfield_header(self): 0326 try: self.__field_header 0327 except: 0328 self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01}) 0329 return self.__field_header.getvalue() 0330 0331 def __setfield_header(self, value): 0332 if isinstance(value,pbheader): 0333 self.__field_header=value 0334 else: 0335 self.__field_header=pbheader(value,**{'command': 0x03, 'flag': 0x01}) 0336 0337 def __delfield_header(self): del self.__field_header 0338 0339 header=property(__getfield_header, __setfield_header, __delfield_header, None) 0340 0341 def __getfield_entry(self): 0342 return self.__field_entry.getvalue() 0343 0344 def __setfield_entry(self, value): 0345 if isinstance(value,pbentry): 0346 self.__field_entry=value 0347 else: 0348 self.__field_entry=pbentry(value,) 0349 0350 def __delfield_entry(self): del self.__field_entry 0351 0352 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 0353 0354 def iscontainer(self): 0355 return True 0356 0357 def containerelements(self): 0358 yield ('header', self.__field_header, None) 0359 yield ('entry', self.__field_entry, None) 0360 0361 0362 0363 0364 class pbentry(BaseProtogenClass): 0365 __fields=['serial1', 'entrysize', 'entrynumber', 'unknown1', 'name', 'group', 'unknown2', 'secret', 'memo', 'emails', 'url', 'numberspeeds', 'numbertypes', 'numbers', 'EndOfRecord', 'ringtone', 'wallpaper'] 0366 0367 def __init__(self, *args, **kwargs): 0368 dict={} 0369 # What was supplied to this function 0370 dict.update(kwargs) 0371 # Parent constructor 0372 super(pbentry,self).__init__(**dict) 0373 if self.__class__ is pbentry: 0374 self._update(args,dict) 0375 0376 0377 def getfields(self): 0378 return self.__fields 0379 0380 0381 def _update(self, args, kwargs): 0382 super(pbentry,self)._update(args,kwargs) 0383 keys=kwargs.keys() 0384 for key in keys: 0385 if key in self.__fields: 0386 setattr(self, key, kwargs[key]) 0387 del kwargs[key] 0388 # Were any unrecognized kwargs passed in? 0389 if __debug__: 0390 self._complainaboutunusedargs(pbentry,kwargs) 0391 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 0392 # Make all P fields that haven't already been constructed 0393 try: self.__field_ringtone 0394 except: 0395 self.__field_ringtone=UINT(**{'default': 0x600}) 0396 try: self.__field_wallpaper 0397 except: 0398 self.__field_wallpaper=UINT(**{'default': 0x100}) 0399 0400 0401 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0402 'Writes this packet to the supplied buffer' 0403 self._bufferstartoffset=buf.getcurrentoffset() 0404 self.__field_serial1.writetobuffer(buf) 0405 try: self.__field_entrysize 0406 except: 0407 self.__field_entrysize=UINT(**{'sizeinbytes': 2, 'constant': 0x026e}) 0408 self.__field_entrysize.writetobuffer(buf) 0409 self.__field_entrynumber.writetobuffer(buf) 0410 try: self.__field_unknown1 0411 except: 0412 self.__field_unknown1=UINT(**{'sizeinbytes': 2, 'default': 0}) 0413 self.__field_unknown1.writetobuffer(buf) 0414 self.__field_name.writetobuffer(buf) 0415 self.__field_group.writetobuffer(buf) 0416 try: self.__field_unknown2 0417 except: 0418 self.__field_unknown2=UINT(**{'sizeinbytes': 2, 'default': 0x10}) 0419 self.__field_unknown2.writetobuffer(buf) 0420 self.__field_secret.writetobuffer(buf) 0421 self.__field_memo.writetobuffer(buf) 0422 try: self.__field_emails 0423 except: 0424 self.__field_emails=LIST(**{'elementclass': _gen_p_lglg6200_129, 'length': NUMEMAILS}) 0425 self.__field_emails.writetobuffer(buf) 0426 self.__field_url.writetobuffer(buf) 0427 try: self.__field_numberspeeds 0428 except: 0429 self.__field_numberspeeds=LIST(**{'elementclass': _gen_p_lglg6200_132, 'length': NUMPHONENUMBERS}) 0430 self.__field_numberspeeds.writetobuffer(buf) 0431 try: self.__field_numbertypes 0432 except: 0433 self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lglg6200_134, 'length': NUMPHONENUMBERS}) 0434 self.__field_numbertypes.writetobuffer(buf) 0435 try: self.__field_numbers 0436 except: 0437 self.__field_numbers=LIST(**{'elementclass': _gen_p_lglg6200_136, 'length': NUMPHONENUMBERS}) 0438 self.__field_numbers.writetobuffer(buf) 0439 try: self.__field_EndOfRecord 0440 except: 0441 self.__field_EndOfRecord=UINT(**{'sizeinbytes': 2, 'constant': 0x0278}) 0442 self.__field_EndOfRecord.writetobuffer(buf) 0443 self._bufferendoffset=buf.getcurrentoffset() 0444 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0445 0446 0447 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0448 'Reads this packet from the supplied buffer' 0449 self._bufferstartoffset=buf.getcurrentoffset() 0450 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0451 self.__field_serial1=UINT(**{'sizeinbytes': 4}) 0452 self.__field_serial1.readfrombuffer(buf) 0453 self.__field_entrysize=UINT(**{'sizeinbytes': 2, 'constant': 0x026e}) 0454 self.__field_entrysize.readfrombuffer(buf) 0455 self.__field_entrynumber=UINT(**{'sizeinbytes': 2}) 0456 self.__field_entrynumber.readfrombuffer(buf) 0457 self.__field_unknown1=UINT(**{'sizeinbytes': 2, 'default': 0}) 0458 self.__field_unknown1.readfrombuffer(buf) 0459 self.__field_name=USTRING(**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 0460 self.__field_name.readfrombuffer(buf) 0461 self.__field_group=UINT(**{'sizeinbytes': 2}) 0462 self.__field_group.readfrombuffer(buf) 0463 self.__field_unknown2=UINT(**{'sizeinbytes': 2, 'default': 0x10}) 0464 self.__field_unknown2.readfrombuffer(buf) 0465 self.__field_secret=BOOL(**{'sizeinbytes': 1}) 0466 self.__field_secret.readfrombuffer(buf) 0467 self.__field_memo=USTRING(**{'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'sizeinbytes': MEMOLENGTH}) 0468 self.__field_memo.readfrombuffer(buf) 0469 self.__field_emails=LIST(**{'elementclass': _gen_p_lglg6200_129, 'length': NUMEMAILS}) 0470 self.__field_emails.readfrombuffer(buf) 0471 self.__field_url=USTRING(**{'sizeinbytes': 73, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 0472 self.__field_url.readfrombuffer(buf) 0473 self.__field_numberspeeds=LIST(**{'elementclass': _gen_p_lglg6200_132, 'length': NUMPHONENUMBERS}) 0474 self.__field_numberspeeds.readfrombuffer(buf) 0475 self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lglg6200_134, 'length': NUMPHONENUMBERS}) 0476 self.__field_numbertypes.readfrombuffer(buf) 0477 self.__field_numbers=LIST(**{'elementclass': _gen_p_lglg6200_136, 'length': NUMPHONENUMBERS}) 0478 self.__field_numbers.readfrombuffer(buf) 0479 self.__field_EndOfRecord=UINT(**{'sizeinbytes': 2, 'constant': 0x0278}) 0480 self.__field_EndOfRecord.readfrombuffer(buf) 0481 self._bufferendoffset=buf.getcurrentoffset() 0482 0483 0484 def __getfield_serial1(self): 0485 return self.__field_serial1.getvalue() 0486 0487 def __setfield_serial1(self, value): 0488 if isinstance(value,UINT): 0489 self.__field_serial1=value 0490 else: 0491 self.__field_serial1=UINT(value,**{'sizeinbytes': 4}) 0492 0493 def __delfield_serial1(self): del self.__field_serial1 0494 0495 serial1=property(__getfield_serial1, __setfield_serial1, __delfield_serial1, None) 0496 0497 def __getfield_entrysize(self): 0498 try: self.__field_entrysize 0499 except: 0500 self.__field_entrysize=UINT(**{'sizeinbytes': 2, 'constant': 0x026e}) 0501 return self.__field_entrysize.getvalue() 0502 0503 def __setfield_entrysize(self, value): 0504 if isinstance(value,UINT): 0505 self.__field_entrysize=value 0506 else: 0507 self.__field_entrysize=UINT(value,**{'sizeinbytes': 2, 'constant': 0x026e}) 0508 0509 def __delfield_entrysize(self): del self.__field_entrysize 0510 0511 entrysize=property(__getfield_entrysize, __setfield_entrysize, __delfield_entrysize, None) 0512 0513 def __getfield_entrynumber(self): 0514 return self.__field_entrynumber.getvalue() 0515 0516 def __setfield_entrynumber(self, value): 0517 if isinstance(value,UINT): 0518 self.__field_entrynumber=value 0519 else: 0520 self.__field_entrynumber=UINT(value,**{'sizeinbytes': 2}) 0521 0522 def __delfield_entrynumber(self): del self.__field_entrynumber 0523 0524 entrynumber=property(__getfield_entrynumber, __setfield_entrynumber, __delfield_entrynumber, None) 0525 0526 def __getfield_unknown1(self): 0527 try: self.__field_unknown1 0528 except: 0529 self.__field_unknown1=UINT(**{'sizeinbytes': 2, 'default': 0}) 0530 return self.__field_unknown1.getvalue() 0531 0532 def __setfield_unknown1(self, value): 0533 if isinstance(value,UINT): 0534 self.__field_unknown1=value 0535 else: 0536 self.__field_unknown1=UINT(value,**{'sizeinbytes': 2, 'default': 0}) 0537 0538 def __delfield_unknown1(self): del self.__field_unknown1 0539 0540 unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None) 0541 0542 def __getfield_name(self): 0543 return self.__field_name.getvalue() 0544 0545 def __setfield_name(self, value): 0546 if isinstance(value,USTRING): 0547 self.__field_name=value 0548 else: 0549 self.__field_name=USTRING(value,**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 0550 0551 def __delfield_name(self): del self.__field_name 0552 0553 name=property(__getfield_name, __setfield_name, __delfield_name, None) 0554 0555 def __getfield_group(self): 0556 return self.__field_group.getvalue() 0557 0558 def __setfield_group(self, value): 0559 if isinstance(value,UINT): 0560 self.__field_group=value 0561 else: 0562 self.__field_group=UINT(value,**{'sizeinbytes': 2}) 0563 0564 def __delfield_group(self): del self.__field_group 0565 0566 group=property(__getfield_group, __setfield_group, __delfield_group, None) 0567 0568 def __getfield_unknown2(self): 0569 try: self.__field_unknown2 0570 except: 0571 self.__field_unknown2=UINT(**{'sizeinbytes': 2, 'default': 0x10}) 0572 return self.__field_unknown2.getvalue() 0573 0574 def __setfield_unknown2(self, value): 0575 if isinstance(value,UINT): 0576 self.__field_unknown2=value 0577 else: 0578 self.__field_unknown2=UINT(value,**{'sizeinbytes': 2, 'default': 0x10}) 0579 0580 def __delfield_unknown2(self): del self.__field_unknown2 0581 0582 unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None) 0583 0584 def __getfield_secret(self): 0585 return self.__field_secret.getvalue() 0586 0587 def __setfield_secret(self, value): 0588 if isinstance(value,BOOL): 0589 self.__field_secret=value 0590 else: 0591 self.__field_secret=BOOL(value,**{'sizeinbytes': 1}) 0592 0593 def __delfield_secret(self): del self.__field_secret 0594 0595 secret=property(__getfield_secret, __setfield_secret, __delfield_secret, None) 0596 0597 def __getfield_memo(self): 0598 return self.__field_memo.getvalue() 0599 0600 def __setfield_memo(self, value): 0601 if isinstance(value,USTRING): 0602 self.__field_memo=value 0603 else: 0604 self.__field_memo=USTRING(value,**{'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'sizeinbytes': MEMOLENGTH}) 0605 0606 def __delfield_memo(self): del self.__field_memo 0607 0608 memo=property(__getfield_memo, __setfield_memo, __delfield_memo, None) 0609 0610 def __getfield_emails(self): 0611 try: self.__field_emails 0612 except: 0613 self.__field_emails=LIST(**{'elementclass': _gen_p_lglg6200_129, 'length': NUMEMAILS}) 0614 return self.__field_emails.getvalue() 0615 0616 def __setfield_emails(self, value): 0617 if isinstance(value,LIST): 0618 self.__field_emails=value 0619 else: 0620 self.__field_emails=LIST(value,**{'elementclass': _gen_p_lglg6200_129, 'length': NUMEMAILS}) 0621 0622 def __delfield_emails(self): del self.__field_emails 0623 0624 emails=property(__getfield_emails, __setfield_emails, __delfield_emails, None) 0625 0626 def __getfield_url(self): 0627 return self.__field_url.getvalue() 0628 0629 def __setfield_url(self, value): 0630 if isinstance(value,USTRING): 0631 self.__field_url=value 0632 else: 0633 self.__field_url=USTRING(value,**{'sizeinbytes': 73, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 0634 0635 def __delfield_url(self): del self.__field_url 0636 0637 url=property(__getfield_url, __setfield_url, __delfield_url, None) 0638 0639 def __getfield_numberspeeds(self): 0640 try: self.__field_numberspeeds 0641 except: 0642 self.__field_numberspeeds=LIST(**{'elementclass': _gen_p_lglg6200_132, 'length': NUMPHONENUMBERS}) 0643 return self.__field_numberspeeds.getvalue() 0644 0645 def __setfield_numberspeeds(self, value): 0646 if isinstance(value,LIST): 0647 self.__field_numberspeeds=value 0648 else: 0649 self.__field_numberspeeds=LIST(value,**{'elementclass': _gen_p_lglg6200_132, 'length': NUMPHONENUMBERS}) 0650 0651 def __delfield_numberspeeds(self): del self.__field_numberspeeds 0652 0653 numberspeeds=property(__getfield_numberspeeds, __setfield_numberspeeds, __delfield_numberspeeds, None) 0654 0655 def __getfield_numbertypes(self): 0656 try: self.__field_numbertypes 0657 except: 0658 self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lglg6200_134, 'length': NUMPHONENUMBERS}) 0659 return self.__field_numbertypes.getvalue() 0660 0661 def __setfield_numbertypes(self, value): 0662 if isinstance(value,LIST): 0663 self.__field_numbertypes=value 0664 else: 0665 self.__field_numbertypes=LIST(value,**{'elementclass': _gen_p_lglg6200_134, 'length': NUMPHONENUMBERS}) 0666 0667 def __delfield_numbertypes(self): del self.__field_numbertypes 0668 0669 numbertypes=property(__getfield_numbertypes, __setfield_numbertypes, __delfield_numbertypes, None) 0670 0671 def __getfield_numbers(self): 0672 try: self.__field_numbers 0673 except: 0674 self.__field_numbers=LIST(**{'elementclass': _gen_p_lglg6200_136, 'length': NUMPHONENUMBERS}) 0675 return self.__field_numbers.getvalue() 0676 0677 def __setfield_numbers(self, value): 0678 if isinstance(value,LIST): 0679 self.__field_numbers=value 0680 else: 0681 self.__field_numbers=LIST(value,**{'elementclass': _gen_p_lglg6200_136, 'length': NUMPHONENUMBERS}) 0682 0683 def __delfield_numbers(self): del self.__field_numbers 0684 0685 numbers=property(__getfield_numbers, __setfield_numbers, __delfield_numbers, None) 0686 0687 def __getfield_EndOfRecord(self): 0688 try: self.__field_EndOfRecord 0689 except: 0690 self.__field_EndOfRecord=UINT(**{'sizeinbytes': 2, 'constant': 0x0278}) 0691 return self.__field_EndOfRecord.getvalue() 0692 0693 def __setfield_EndOfRecord(self, value): 0694 if isinstance(value,UINT): 0695 self.__field_EndOfRecord=value 0696 else: 0697 self.__field_EndOfRecord=UINT(value,**{'sizeinbytes': 2, 'constant': 0x0278}) 0698 0699 def __delfield_EndOfRecord(self): del self.__field_EndOfRecord 0700 0701 EndOfRecord=property(__getfield_EndOfRecord, __setfield_EndOfRecord, __delfield_EndOfRecord, None) 0702 0703 def __getfield_ringtone(self): 0704 try: self.__field_ringtone 0705 except: 0706 self.__field_ringtone=UINT(**{'default': 0x600}) 0707 return self.__field_ringtone.getvalue() 0708 0709 def __setfield_ringtone(self, value): 0710 if isinstance(value,UINT): 0711 self.__field_ringtone=value 0712 else: 0713 self.__field_ringtone=UINT(value,**{'default': 0x600}) 0714 0715 def __delfield_ringtone(self): del self.__field_ringtone 0716 0717 ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None) 0718 0719 def __getfield_wallpaper(self): 0720 try: self.__field_wallpaper 0721 except: 0722 self.__field_wallpaper=UINT(**{'default': 0x100}) 0723 return self.__field_wallpaper.getvalue() 0724 0725 def __setfield_wallpaper(self, value): 0726 if isinstance(value,UINT): 0727 self.__field_wallpaper=value 0728 else: 0729 self.__field_wallpaper=UINT(value,**{'default': 0x100}) 0730 0731 def __delfield_wallpaper(self): del self.__field_wallpaper 0732 0733 wallpaper=property(__getfield_wallpaper, __setfield_wallpaper, __delfield_wallpaper, None) 0734 0735 def iscontainer(self): 0736 return True 0737 0738 def containerelements(self): 0739 yield ('serial1', self.__field_serial1, None) 0740 yield ('entrysize', self.__field_entrysize, None) 0741 yield ('entrynumber', self.__field_entrynumber, None) 0742 yield ('unknown1', self.__field_unknown1, None) 0743 yield ('name', self.__field_name, None) 0744 yield ('group', self.__field_group, None) 0745 yield ('unknown2', self.__field_unknown2, None) 0746 yield ('secret', self.__field_secret, None) 0747 yield ('memo', self.__field_memo, None) 0748 yield ('emails', self.__field_emails, None) 0749 yield ('url', self.__field_url, None) 0750 yield ('numberspeeds', self.__field_numberspeeds, None) 0751 yield ('numbertypes', self.__field_numbertypes, None) 0752 yield ('numbers', self.__field_numbers, None) 0753 yield ('EndOfRecord', self.__field_EndOfRecord, None) 0754 yield ('ringtone', self.__field_ringtone, None) 0755 yield ('wallpaper', self.__field_wallpaper, None) 0756 0757 0758 0759 0760 class _gen_p_lglg6200_129(BaseProtogenClass): 0761 'Anonymous inner class' 0762 __fields=['email'] 0763 0764 def __init__(self, *args, **kwargs): 0765 dict={} 0766 # What was supplied to this function 0767 dict.update(kwargs) 0768 # Parent constructor 0769 super(_gen_p_lglg6200_129,self).__init__(**dict) 0770 if self.__class__ is _gen_p_lglg6200_129: 0771 self._update(args,dict) 0772 0773 0774 def getfields(self): 0775 return self.__fields 0776 0777 0778 def _update(self, args, kwargs): 0779 super(_gen_p_lglg6200_129,self)._update(args,kwargs) 0780 keys=kwargs.keys() 0781 for key in keys: 0782 if key in self.__fields: 0783 setattr(self, key, kwargs[key]) 0784 del kwargs[key] 0785 # Were any unrecognized kwargs passed in? 0786 if __debug__: 0787 self._complainaboutunusedargs(_gen_p_lglg6200_129,kwargs) 0788 if len(args): 0789 dict2={'sizeinbytes': 73, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False} 0790 dict2.update(kwargs) 0791 kwargs=dict2 0792 self.__field_email=USTRING(*args,**dict2) 0793 # Make all P fields that haven't already been constructed 0794 0795 0796 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0797 'Writes this packet to the supplied buffer' 0798 self._bufferstartoffset=buf.getcurrentoffset() 0799 self.__field_email.writetobuffer(buf) 0800 self._bufferendoffset=buf.getcurrentoffset() 0801 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0802 0803 0804 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0805 'Reads this packet from the supplied buffer' 0806 self._bufferstartoffset=buf.getcurrentoffset() 0807 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0808 self.__field_email=USTRING(**{'sizeinbytes': 73, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 0809 self.__field_email.readfrombuffer(buf) 0810 self._bufferendoffset=buf.getcurrentoffset() 0811 0812 0813 def __getfield_email(self): 0814 return self.__field_email.getvalue() 0815 0816 def __setfield_email(self, value): 0817 if isinstance(value,USTRING): 0818 self.__field_email=value 0819 else: 0820 self.__field_email=USTRING(value,**{'sizeinbytes': 73, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 0821 0822 def __delfield_email(self): del self.__field_email 0823 0824 email=property(__getfield_email, __setfield_email, __delfield_email, None) 0825 0826 def iscontainer(self): 0827 return True 0828 0829 def containerelements(self): 0830 yield ('email', self.__field_email, None) 0831 0832 0833 0834 0835 class _gen_p_lglg6200_132(BaseProtogenClass): 0836 'Anonymous inner class' 0837 __fields=['numberspeed'] 0838 0839 def __init__(self, *args, **kwargs): 0840 dict={} 0841 # What was supplied to this function 0842 dict.update(kwargs) 0843 # Parent constructor 0844 super(_gen_p_lglg6200_132,self).__init__(**dict) 0845 if self.__class__ is _gen_p_lglg6200_132: 0846 self._update(args,dict) 0847 0848 0849 def getfields(self): 0850 return self.__fields 0851 0852 0853 def _update(self, args, kwargs): 0854 super(_gen_p_lglg6200_132,self)._update(args,kwargs) 0855 keys=kwargs.keys() 0856 for key in keys: 0857 if key in self.__fields: 0858 setattr(self, key, kwargs[key]) 0859 del kwargs[key] 0860 # Were any unrecognized kwargs passed in? 0861 if __debug__: 0862 self._complainaboutunusedargs(_gen_p_lglg6200_132,kwargs) 0863 if len(args): 0864 dict2={'sizeinbytes': 1} 0865 dict2.update(kwargs) 0866 kwargs=dict2 0867 self.__field_numberspeed=UINT(*args,**dict2) 0868 # Make all P fields that haven't already been constructed 0869 0870 0871 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0872 'Writes this packet to the supplied buffer' 0873 self._bufferstartoffset=buf.getcurrentoffset() 0874 self.__field_numberspeed.writetobuffer(buf) 0875 self._bufferendoffset=buf.getcurrentoffset() 0876 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0877 0878 0879 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0880 'Reads this packet from the supplied buffer' 0881 self._bufferstartoffset=buf.getcurrentoffset() 0882 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0883 self.__field_numberspeed=UINT(**{'sizeinbytes': 1}) 0884 self.__field_numberspeed.readfrombuffer(buf) 0885 self._bufferendoffset=buf.getcurrentoffset() 0886 0887 0888 def __getfield_numberspeed(self): 0889 return self.__field_numberspeed.getvalue() 0890 0891 def __setfield_numberspeed(self, value): 0892 if isinstance(value,UINT): 0893 self.__field_numberspeed=value 0894 else: 0895 self.__field_numberspeed=UINT(value,**{'sizeinbytes': 1}) 0896 0897 def __delfield_numberspeed(self): del self.__field_numberspeed 0898 0899 numberspeed=property(__getfield_numberspeed, __setfield_numberspeed, __delfield_numberspeed, None) 0900 0901 def iscontainer(self): 0902 return True 0903 0904 def containerelements(self): 0905 yield ('numberspeed', self.__field_numberspeed, None) 0906 0907 0908 0909 0910 class _gen_p_lglg6200_134(BaseProtogenClass): 0911 'Anonymous inner class' 0912 __fields=['numbertype'] 0913 0914 def __init__(self, *args, **kwargs): 0915 dict={} 0916 # What was supplied to this function 0917 dict.update(kwargs) 0918 # Parent constructor 0919 super(_gen_p_lglg6200_134,self).__init__(**dict) 0920 if self.__class__ is _gen_p_lglg6200_134: 0921 self._update(args,dict) 0922 0923 0924 def getfields(self): 0925 return self.__fields 0926 0927 0928 def _update(self, args, kwargs): 0929 super(_gen_p_lglg6200_134,self)._update(args,kwargs) 0930 keys=kwargs.keys() 0931 for key in keys: 0932 if key in self.__fields: 0933 setattr(self, key, kwargs[key]) 0934 del kwargs[key] 0935 # Were any unrecognized kwargs passed in? 0936 if __debug__: 0937 self._complainaboutunusedargs(_gen_p_lglg6200_134,kwargs) 0938 if len(args): 0939 dict2={'sizeinbytes': 1} 0940 dict2.update(kwargs) 0941 kwargs=dict2 0942 self.__field_numbertype=UINT(*args,**dict2) 0943 # Make all P fields that haven't already been constructed 0944 0945 0946 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0947 'Writes this packet to the supplied buffer' 0948 self._bufferstartoffset=buf.getcurrentoffset() 0949 self.__field_numbertype.writetobuffer(buf) 0950 self._bufferendoffset=buf.getcurrentoffset() 0951 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0952 0953 0954 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0955 'Reads this packet from the supplied buffer' 0956 self._bufferstartoffset=buf.getcurrentoffset() 0957 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0958 self.__field_numbertype=UINT(**{'sizeinbytes': 1}) 0959 self.__field_numbertype.readfrombuffer(buf) 0960 self._bufferendoffset=buf.getcurrentoffset() 0961 0962 0963 def __getfield_numbertype(self): 0964 return self.__field_numbertype.getvalue() 0965 0966 def __setfield_numbertype(self, value): 0967 if isinstance(value,UINT): 0968 self.__field_numbertype=value 0969 else: 0970 self.__field_numbertype=UINT(value,**{'sizeinbytes': 1}) 0971 0972 def __delfield_numbertype(self): del self.__field_numbertype 0973 0974 numbertype=property(__getfield_numbertype, __setfield_numbertype, __delfield_numbertype, None) 0975 0976 def iscontainer(self): 0977 return True 0978 0979 def containerelements(self): 0980 yield ('numbertype', self.__field_numbertype, None) 0981 0982 0983 0984 0985 class _gen_p_lglg6200_136(BaseProtogenClass): 0986 'Anonymous inner class' 0987 __fields=['number'] 0988 0989 def __init__(self, *args, **kwargs): 0990 dict={} 0991 # What was supplied to this function 0992 dict.update(kwargs) 0993 # Parent constructor 0994 super(_gen_p_lglg6200_136,self).__init__(**dict) 0995 if self.__class__ is _gen_p_lglg6200_136: 0996 self._update(args,dict) 0997 0998 0999 def getfields(self): 1000 return self.__fields 1001 1002 1003 def _update(self, args, kwargs): 1004 super(_gen_p_lglg6200_136,self)._update(args,kwargs) 1005 keys=kwargs.keys() 1006 for key in keys: 1007 if key in self.__fields: 1008 setattr(self, key, kwargs[key]) 1009 del kwargs[key] 1010 # Were any unrecognized kwargs passed in? 1011 if __debug__: 1012 self._complainaboutunusedargs(_gen_p_lglg6200_136,kwargs) 1013 if len(args): 1014 dict2={'sizeinbytes': 49, 'raiseonunterminatedread': False} 1015 dict2.update(kwargs) 1016 kwargs=dict2 1017 self.__field_number=USTRING(*args,**dict2) 1018 # Make all P fields that haven't already been constructed 1019 1020 1021 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1022 'Writes this packet to the supplied buffer' 1023 self._bufferstartoffset=buf.getcurrentoffset() 1024 self.__field_number.writetobuffer(buf) 1025 self._bufferendoffset=buf.getcurrentoffset() 1026 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1027 1028 1029 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1030 'Reads this packet from the supplied buffer' 1031 self._bufferstartoffset=buf.getcurrentoffset() 1032 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1033 self.__field_number=USTRING(**{'sizeinbytes': 49, 'raiseonunterminatedread': False}) 1034 self.__field_number.readfrombuffer(buf) 1035 self._bufferendoffset=buf.getcurrentoffset() 1036 1037 1038 def __getfield_number(self): 1039 return self.__field_number.getvalue() 1040 1041 def __setfield_number(self, value): 1042 if isinstance(value,USTRING): 1043 self.__field_number=value 1044 else: 1045 self.__field_number=USTRING(value,**{'sizeinbytes': 49, 'raiseonunterminatedread': False}) 1046 1047 def __delfield_number(self): del self.__field_number 1048 1049 number=property(__getfield_number, __setfield_number, __delfield_number, None) 1050 1051 def iscontainer(self): 1052 return True 1053 1054 def containerelements(self): 1055 yield ('number', self.__field_number, None) 1056 1057 1058 1059 1060 class pbgroup(BaseProtogenClass): 1061 "A single group" 1062 __fields=['group_id', 'rectype', 'unknown2', 'unknown3', 'name'] 1063 1064 def __init__(self, *args, **kwargs): 1065 dict={} 1066 # What was supplied to this function 1067 dict.update(kwargs) 1068 # Parent constructor 1069 super(pbgroup,self).__init__(**dict) 1070 if self.__class__ is pbgroup: 1071 self._update(args,dict) 1072 1073 1074 def getfields(self): 1075 return self.__fields 1076 1077 1078 def _update(self, args, kwargs): 1079 super(pbgroup,self)._update(args,kwargs) 1080 keys=kwargs.keys() 1081 for key in keys: 1082 if key in self.__fields: 1083 setattr(self, key, kwargs[key]) 1084 del kwargs[key] 1085 # Were any unrecognized kwargs passed in? 1086 if __debug__: 1087 self._complainaboutunusedargs(pbgroup,kwargs) 1088 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 1089 # Make all P fields that haven't already been constructed 1090 1091 1092 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1093 'Writes this packet to the supplied buffer' 1094 self._bufferstartoffset=buf.getcurrentoffset() 1095 self.__field_group_id.writetobuffer(buf) 1096 self.__field_rectype.writetobuffer(buf) 1097 try: self.__field_unknown2 1098 except: 1099 self.__field_unknown2=UNKNOWN(**{'sizeinbytes': 3}) 1100 self.__field_unknown2.writetobuffer(buf) 1101 try: self.__field_unknown3 1102 except: 1103 self.__field_unknown3=UNKNOWN(**{'sizeinbytes': 3}) 1104 self.__field_unknown3.writetobuffer(buf) 1105 self.__field_name.writetobuffer(buf) 1106 self._bufferendoffset=buf.getcurrentoffset() 1107 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1108 1109 1110 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1111 'Reads this packet from the supplied buffer' 1112 self._bufferstartoffset=buf.getcurrentoffset() 1113 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1114 self.__field_group_id=UINT(**{'sizeinbytes': 1}) 1115 self.__field_group_id.readfrombuffer(buf) 1116 self.__field_rectype=UINT(**{'sizeinbytes': 1}) 1117 self.__field_rectype.readfrombuffer(buf) 1118 self.__field_unknown2=UNKNOWN(**{'sizeinbytes': 3}) 1119 self.__field_unknown2.readfrombuffer(buf) 1120 self.__field_unknown3=UNKNOWN(**{'sizeinbytes': 3}) 1121 self.__field_unknown3.readfrombuffer(buf) 1122 self.__field_name=USTRING(**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 1123 self.__field_name.readfrombuffer(buf) 1124 self._bufferendoffset=buf.getcurrentoffset() 1125 1126 1127 def __getfield_group_id(self): 1128 return self.__field_group_id.getvalue() 1129 1130 def __setfield_group_id(self, value): 1131 if isinstance(value,UINT): 1132 self.__field_group_id=value 1133 else: 1134 self.__field_group_id=UINT(value,**{'sizeinbytes': 1}) 1135 1136 def __delfield_group_id(self): del self.__field_group_id 1137 1138 group_id=property(__getfield_group_id, __setfield_group_id, __delfield_group_id, None) 1139 1140 def __getfield_rectype(self): 1141 return self.__field_rectype.getvalue() 1142 1143 def __setfield_rectype(self, value): 1144 if isinstance(value,UINT): 1145 self.__field_rectype=value 1146 else: 1147 self.__field_rectype=UINT(value,**{'sizeinbytes': 1}) 1148 1149 def __delfield_rectype(self): del self.__field_rectype 1150 1151 rectype=property(__getfield_rectype, __setfield_rectype, __delfield_rectype, None) 1152 1153 def __getfield_unknown2(self): 1154 try: self.__field_unknown2 1155 except: 1156 self.__field_unknown2=UNKNOWN(**{'sizeinbytes': 3}) 1157 return self.__field_unknown2.getvalue() 1158 1159 def __setfield_unknown2(self, value): 1160 if isinstance(value,UNKNOWN): 1161 self.__field_unknown2=value 1162 else: 1163 self.__field_unknown2=UNKNOWN(value,**{'sizeinbytes': 3}) 1164 1165 def __delfield_unknown2(self): del self.__field_unknown2 1166 1167 unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None) 1168 1169 def __getfield_unknown3(self): 1170 try: self.__field_unknown3 1171 except: 1172 self.__field_unknown3=UNKNOWN(**{'sizeinbytes': 3}) 1173 return self.__field_unknown3.getvalue() 1174 1175 def __setfield_unknown3(self, value): 1176 if isinstance(value,UNKNOWN): 1177 self.__field_unknown3=value 1178 else: 1179 self.__field_unknown3=UNKNOWN(value,**{'sizeinbytes': 3}) 1180 1181 def __delfield_unknown3(self): del self.__field_unknown3 1182 1183 unknown3=property(__getfield_unknown3, __setfield_unknown3, __delfield_unknown3, None) 1184 1185 def __getfield_name(self): 1186 return self.__field_name.getvalue() 1187 1188 def __setfield_name(self, value): 1189 if isinstance(value,USTRING): 1190 self.__field_name=value 1191 else: 1192 self.__field_name=USTRING(value,**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 1193 1194 def __delfield_name(self): del self.__field_name 1195 1196 name=property(__getfield_name, __setfield_name, __delfield_name, None) 1197 1198 def iscontainer(self): 1199 return True 1200 1201 def containerelements(self): 1202 yield ('group_id', self.__field_group_id, None) 1203 yield ('rectype', self.__field_rectype, None) 1204 yield ('unknown2', self.__field_unknown2, None) 1205 yield ('unknown3', self.__field_unknown3, None) 1206 yield ('name', self.__field_name, None) 1207 1208 1209 1210 1211 class pbgroups(BaseProtogenClass): 1212 "Phonebook groups" 1213 __fields=['groups'] 1214 1215 def __init__(self, *args, **kwargs): 1216 dict={} 1217 # What was supplied to this function 1218 dict.update(kwargs) 1219 # Parent constructor 1220 super(pbgroups,self).__init__(**dict) 1221 if self.__class__ is pbgroups: 1222 self._update(args,dict) 1223 1224 1225 def getfields(self): 1226 return self.__fields 1227 1228 1229 def _update(self, args, kwargs): 1230 super(pbgroups,self)._update(args,kwargs) 1231 keys=kwargs.keys() 1232 for key in keys: 1233 if key in self.__fields: 1234 setattr(self, key, kwargs[key]) 1235 del kwargs[key] 1236 # Were any unrecognized kwargs passed in? 1237 if __debug__: 1238 self._complainaboutunusedargs(pbgroups,kwargs) 1239 if len(args): 1240 dict2={'elementclass': pbgroup} 1241 dict2.update(kwargs) 1242 kwargs=dict2 1243 self.__field_groups=LIST(*args,**dict2) 1244 # Make all P fields that haven't already been constructed 1245 1246 1247 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1248 'Writes this packet to the supplied buffer' 1249 self._bufferstartoffset=buf.getcurrentoffset() 1250 try: self.__field_groups 1251 except: 1252 self.__field_groups=LIST(**{'elementclass': pbgroup}) 1253 self.__field_groups.writetobuffer(buf) 1254 self._bufferendoffset=buf.getcurrentoffset() 1255 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1256 1257 1258 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1259 'Reads this packet from the supplied buffer' 1260 self._bufferstartoffset=buf.getcurrentoffset() 1261 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1262 self.__field_groups=LIST(**{'elementclass': pbgroup}) 1263 self.__field_groups.readfrombuffer(buf) 1264 self._bufferendoffset=buf.getcurrentoffset() 1265 1266 1267 def __getfield_groups(self): 1268 try: self.__field_groups 1269 except: 1270 self.__field_groups=LIST(**{'elementclass': pbgroup}) 1271 return self.__field_groups.getvalue() 1272 1273 def __setfield_groups(self, value): 1274 if isinstance(value,LIST): 1275 self.__field_groups=value 1276 else: 1277 self.__field_groups=LIST(value,**{'elementclass': pbgroup}) 1278 1279 def __delfield_groups(self): del self.__field_groups 1280 1281 groups=property(__getfield_groups, __setfield_groups, __delfield_groups, None) 1282 1283 def iscontainer(self): 1284 return True 1285 1286 def containerelements(self): 1287 yield ('groups', self.__field_groups, None) 1288 1289 1290 1291 1292 class pb_contact_media_entry(BaseProtogenClass): 1293 """Reads the wallpaper/ringer info for each 1294 contact on the phone""" 1295 __fields=['index', 'dont_care1', 'ringer', 'name', 'dont_care2', 'wallpaper', 'dont_care3'] 1296 1297 def __init__(self, *args, **kwargs): 1298 dict={} 1299 # What was supplied to this function 1300 dict.update(kwargs) 1301 # Parent constructor 1302 super(pb_contact_media_entry,self).__init__(**dict) 1303 if self.__class__ is pb_contact_media_entry: 1304 self._update(args,dict) 1305 1306 1307 def getfields(self): 1308 return self.__fields 1309 1310 1311 def _update(self, args, kwargs): 1312 super(pb_contact_media_entry,self)._update(args,kwargs) 1313 keys=kwargs.keys() 1314 for key in keys: 1315 if key in self.__fields: 1316 setattr(self, key, kwargs[key]) 1317 del kwargs[key] 1318 # Were any unrecognized kwargs passed in? 1319 if __debug__: 1320 self._complainaboutunusedargs(pb_contact_media_entry,kwargs) 1321 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 1322 # Make all P fields that haven't already been constructed 1323 1324 1325 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1326 'Writes this packet to the supplied buffer' 1327 self._bufferstartoffset=buf.getcurrentoffset() 1328 self.__field_index.writetobuffer(buf) 1329 self.__field_dont_care1.writetobuffer(buf) 1330 self.__field_ringer.writetobuffer(buf) 1331 self.__field_name.writetobuffer(buf) 1332 self.__field_dont_care2.writetobuffer(buf) 1333 self.__field_wallpaper.writetobuffer(buf) 1334 self.__field_dont_care3.writetobuffer(buf) 1335 self._bufferendoffset=buf.getcurrentoffset() 1336 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1337 1338 1339 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1340 'Reads this packet from the supplied buffer' 1341 self._bufferstartoffset=buf.getcurrentoffset() 1342 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1343 self.__field_index=UINT(**{'sizeinbytes': 2}) 1344 self.__field_index.readfrombuffer(buf) 1345 self.__field_dont_care1=DATA(**{'sizeinbytes': 18}) 1346 self.__field_dont_care1.readfrombuffer(buf) 1347 self.__field_ringer=UINT(**{'sizeinbytes': 2}) 1348 self.__field_ringer.readfrombuffer(buf) 1349 self.__field_name=USTRING(**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING}) 1350 self.__field_name.readfrombuffer(buf) 1351 self.__field_dont_care2=DATA(**{'sizeinbytes': 182}) 1352 self.__field_dont_care2.readfrombuffer(buf) 1353 self.__field_wallpaper=UINT(**{'sizeinbytes': 2}) 1354 self.__field_wallpaper.readfrombuffer(buf) 1355 self.__field_dont_care3=DATA(**{'sizeinbytes': 4}) 1356 self.__field_dont_care3.readfrombuffer(buf) 1357 self._bufferendoffset=buf.getcurrentoffset() 1358 1359 1360 def __getfield_index(self): 1361 return self.__field_index.getvalue() 1362 1363 def __setfield_index(self, value): 1364 if isinstance(value,UINT): 1365 self.__field_index=value 1366 else: 1367 self.__field_index=UINT(value,**{'sizeinbytes': 2}) 1368 1369 def __delfield_index(self): del self.__field_index 1370 1371 index=property(__getfield_index, __setfield_index, __delfield_index, None) 1372 1373 def __getfield_dont_care1(self): 1374 return self.__field_dont_care1.getvalue() 1375 1376 def __setfield_dont_care1(self, value): 1377 if isinstance(value,DATA): 1378 self.__field_dont_care1=value 1379 else: 1380 self.__field_dont_care1=DATA(value,**{'sizeinbytes': 18}) 1381 1382 def __delfield_dont_care1(self): del self.__field_dont_care1 1383 1384 dont_care1=property(__getfield_dont_care1, __setfield_dont_care1, __delfield_dont_care1, None) 1385 1386 def __getfield_ringer(self): 1387 return self.__field_ringer.getvalue() 1388 1389 def __setfield_ringer(self, value): 1390 if isinstance(value,UINT): 1391 self.__field_ringer=value 1392 else: 1393 self.__field_ringer=UINT(value,**{'sizeinbytes': 2}) 1394 1395 def __delfield_ringer(self): del self.__field_ringer 1396 1397 ringer=property(__getfield_ringer, __setfield_ringer, __delfield_ringer, None) 1398 1399 def __getfield_name(self): 1400 return self.__field_name.getvalue() 1401 1402 def __setfield_name(self, value): 1403 if isinstance(value,USTRING): 1404 self.__field_name=value 1405 else: 1406 self.__field_name=USTRING(value,**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING}) 1407 1408 def __delfield_name(self): del self.__field_name 1409 1410 name=property(__getfield_name, __setfield_name, __delfield_name, None) 1411 1412 def __getfield_dont_care2(self): 1413 return self.__field_dont_care2.getvalue() 1414 1415 def __setfield_dont_care2(self, value): 1416 if isinstance(value,DATA): 1417 self.__field_dont_care2=value 1418 else: 1419 self.__field_dont_care2=DATA(value,**{'sizeinbytes': 182}) 1420 1421 def __delfield_dont_care2(self): del self.__field_dont_care2 1422 1423 dont_care2=property(__getfield_dont_care2, __setfield_dont_care2, __delfield_dont_care2, None) 1424 1425 def __getfield_wallpaper(self): 1426 return self.__field_wallpaper.getvalue() 1427 1428 def __setfield_wallpaper(self, value): 1429 if isinstance(value,UINT): 1430 self.__field_wallpaper=value 1431 else: 1432 self.__field_wallpaper=UINT(value,**{'sizeinbytes': 2}) 1433 1434 def __delfield_wallpaper(self): del self.__field_wallpaper 1435 1436 wallpaper=property(__getfield_wallpaper, __setfield_wallpaper, __delfield_wallpaper, None) 1437 1438 def __getfield_dont_care3(self): 1439 return self.__field_dont_care3.getvalue() 1440 1441 def __setfield_dont_care3(self, value): 1442 if isinstance(value,DATA): 1443 self.__field_dont_care3=value 1444 else: 1445 self.__field_dont_care3=DATA(value,**{'sizeinbytes': 4}) 1446 1447 def __delfield_dont_care3(self): del self.__field_dont_care3 1448 1449 dont_care3=property(__getfield_dont_care3, __setfield_dont_care3, __delfield_dont_care3, None) 1450 1451 def iscontainer(self): 1452 return True 1453 1454 def containerelements(self): 1455 yield ('index', self.__field_index, None) 1456 yield ('dont_care1', self.__field_dont_care1, None) 1457 yield ('ringer', self.__field_ringer, None) 1458 yield ('name', self.__field_name, None) 1459 yield ('dont_care2', self.__field_dont_care2, None) 1460 yield ('wallpaper', self.__field_wallpaper, None) 1461 yield ('dont_care3', self.__field_dont_care3, None) 1462 1463 1464 1465 1466 class pb_contact_media_file(BaseProtogenClass): 1467 __fields=['contacts'] 1468 1469 def __init__(self, *args, **kwargs): 1470 dict={} 1471 # What was supplied to this function 1472 dict.update(kwargs) 1473 # Parent constructor 1474 super(pb_contact_media_file,self).__init__(**dict) 1475 if self.__class__ is pb_contact_media_file: 1476 self._update(args,dict) 1477 1478 1479 def getfields(self): 1480 return self.__fields 1481 1482 1483 def _update(self, args, kwargs): 1484 super(pb_contact_media_file,self)._update(args,kwargs) 1485 keys=kwargs.keys() 1486 for key in keys: 1487 if key in self.__fields: 1488 setattr(self, key, kwargs[key]) 1489 del kwargs[key] 1490 # Were any unrecognized kwargs passed in? 1491 if __debug__: 1492 self._complainaboutunusedargs(pb_contact_media_file,kwargs) 1493 if len(args): 1494 dict2={'elementclass': pb_contact_media_entry} 1495 dict2.update(kwargs) 1496 kwargs=dict2 1497 self.__field_contacts=LIST(*args,**dict2) 1498 # Make all P fields that haven't already been constructed 1499 1500 1501 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1502 'Writes this packet to the supplied buffer' 1503 self._bufferstartoffset=buf.getcurrentoffset() 1504 try: self.__field_contacts 1505 except: 1506 self.__field_contacts=LIST(**{'elementclass': pb_contact_media_entry}) 1507 self.__field_contacts.writetobuffer(buf) 1508 self._bufferendoffset=buf.getcurrentoffset() 1509 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1510 1511 1512 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1513 'Reads this packet from the supplied buffer' 1514 self._bufferstartoffset=buf.getcurrentoffset() 1515 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1516 self.__field_contacts=LIST(**{'elementclass': pb_contact_media_entry}) 1517 self.__field_contacts.readfrombuffer(buf) 1518 self._bufferendoffset=buf.getcurrentoffset() 1519 1520 1521 def __getfield_contacts(self): 1522 try: self.__field_contacts 1523 except: 1524 self.__field_contacts=LIST(**{'elementclass': pb_contact_media_entry}) 1525 return self.__field_contacts.getvalue() 1526 1527 def __setfield_contacts(self, value): 1528 if isinstance(value,LIST): 1529 self.__field_contacts=value 1530 else: 1531 self.__field_contacts=LIST(value,**{'elementclass': pb_contact_media_entry}) 1532 1533 def __delfield_contacts(self): del self.__field_contacts 1534 1535 contacts=property(__getfield_contacts, __setfield_contacts, __delfield_contacts, None) 1536 1537 def iscontainer(self): 1538 return True 1539 1540 def containerelements(self): 1541 yield ('contacts', self.__field_contacts, None) 1542 1543 1544 1545 1546 class indexentry(BaseProtogenClass): 1547 __fields=['index', 'const', 'name'] 1548 1549 def __init__(self, *args, **kwargs): 1550 dict={} 1551 # What was supplied to this function 1552 dict.update(kwargs) 1553 # Parent constructor 1554 super(indexentry,self).__init__(**dict) 1555 if self.__class__ is indexentry: 1556 self._update(args,dict) 1557 1558 1559 def getfields(self): 1560 return self.__fields 1561 1562 1563 def _update(self, args, kwargs): 1564 super(indexentry,self)._update(args,kwargs) 1565 keys=kwargs.keys() 1566 for key in keys: 1567 if key in self.__fields: 1568 setattr(self, key, kwargs[key]) 1569 del kwargs[key] 1570 # Were any unrecognized kwargs passed in? 1571 if __debug__: 1572 self._complainaboutunusedargs(indexentry,kwargs) 1573 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 1574 # Make all P fields that haven't already been constructed 1575 1576 1577 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1578 'Writes this packet to the supplied buffer' 1579 self._bufferstartoffset=buf.getcurrentoffset() 1580 self.__field_index.writetobuffer(buf) 1581 self.__field_const.writetobuffer(buf) 1582 try: self.__field_name 1583 except: 1584 self.__field_name=USTRING(**{'sizeinbytes': 80, 'default': ""}) 1585 self.__field_name.writetobuffer(buf) 1586 self._bufferendoffset=buf.getcurrentoffset() 1587 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1588 1589 1590 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1591 'Reads this packet from the supplied buffer' 1592 self._bufferstartoffset=buf.getcurrentoffset() 1593 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1594 self.__field_index=UINT(**{'sizeinbytes': 1}) 1595 self.__field_index.readfrombuffer(buf) 1596 self.__field_const=UINT(**{'sizeinbytes': 1}) 1597 self.__field_const.readfrombuffer(buf) 1598 self.__field_name=USTRING(**{'sizeinbytes': 80, 'default': ""}) 1599 self.__field_name.readfrombuffer(buf) 1600 self._bufferendoffset=buf.getcurrentoffset() 1601 1602 1603 def __getfield_index(self): 1604 return self.__field_index.getvalue() 1605 1606 def __setfield_index(self, value): 1607 if isinstance(value,UINT): 1608 self.__field_index=value 1609 else: 1610 self.__field_index=UINT(value,**{'sizeinbytes': 1}) 1611 1612 def __delfield_index(self): del self.__field_index 1613 1614 index=property(__getfield_index, __setfield_index, __delfield_index, None) 1615 1616 def __getfield_const(self): 1617 return self.__field_const.getvalue() 1618 1619 def __setfield_const(self, value): 1620 if isinstance(value,UINT): 1621 self.__field_const=value 1622 else: 1623 self.__field_const=UINT(value,**{'sizeinbytes': 1}) 1624 1625 def __delfield_const(self): del self.__field_const 1626 1627 const=property(__getfield_const, __setfield_const, __delfield_const, None) 1628 1629 def __getfield_name(self): 1630 try: self.__field_name 1631 except: 1632 self.__field_name=USTRING(**{'sizeinbytes': 80, 'default': ""}) 1633 return self.__field_name.getvalue() 1634 1635 def __setfield_name(self, value): 1636 if isinstance(value,USTRING): 1637 self.__field_name=value 1638 else: 1639 self.__field_name=USTRING(value,**{'sizeinbytes': 80, 'default': ""}) 1640 1641 def __delfield_name(self): del self.__field_name 1642 1643 name=property(__getfield_name, __setfield_name, __delfield_name, None) 1644 1645 def iscontainer(self): 1646 return True 1647 1648 def containerelements(self): 1649 yield ('index', self.__field_index, None) 1650 yield ('const', self.__field_const, None) 1651 yield ('name', self.__field_name, None) 1652 1653 1654 1655 1656 class indexfile(BaseProtogenClass): 1657 "Used for tracking wallpaper and ringtones" 1658 __fields=['numactiveitems', 'items'] 1659 1660 def __init__(self, *args, **kwargs): 1661 dict={} 1662 # What was supplied to this function 1663 dict.update(kwargs) 1664 # Parent constructor 1665 super(indexfile,self).__init__(**dict) 1666 if self.__class__ is indexfile: 1667 self._update(args,dict) 1668 1669 1670 def getfields(self): 1671 return self.__fields 1672 1673 1674 def _update(self, args, kwargs): 1675 super(indexfile,self)._update(args,kwargs) 1676 keys=kwargs.keys() 1677 for key in keys: 1678 if key in self.__fields: 1679 setattr(self, key, kwargs[key]) 1680 del kwargs[key] 1681 # Were any unrecognized kwargs passed in? 1682 if __debug__: 1683 self._complainaboutunusedargs(indexfile,kwargs) 1684 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 1685 # Make all P fields that haven't already been constructed 1686 1687 1688 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1689 'Writes this packet to the supplied buffer' 1690 self._bufferstartoffset=buf.getcurrentoffset() 1691 self.__field_numactiveitems.writetobuffer(buf) 1692 try: self.__field_items 1693 except: 1694 self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True}) 1695 self.__field_items.writetobuffer(buf) 1696 self._bufferendoffset=buf.getcurrentoffset() 1697 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1698 1699 1700 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1701 'Reads this packet from the supplied buffer' 1702 self._bufferstartoffset=buf.getcurrentoffset() 1703 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1704 self.__field_numactiveitems=UINT(**{'sizeinbytes': 2}) 1705 self.__field_numactiveitems.readfrombuffer(buf) 1706 self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True}) 1707 self.__field_items.readfrombuffer(buf) 1708 self._bufferendoffset=buf.getcurrentoffset() 1709 1710 1711 def __getfield_numactiveitems(self): 1712 return self.__field_numactiveitems.getvalue() 1713 1714 def __setfield_numactiveitems(self, value): 1715 if isinstance(value,UINT): 1716 self.__field_numactiveitems=value 1717 else: 1718 self.__field_numactiveitems=UINT(value,**{'sizeinbytes': 2}) 1719 1720 def __delfield_numactiveitems(self): del self.__field_numactiveitems 1721 1722 numactiveitems=property(__getfield_numactiveitems, __setfield_numactiveitems, __delfield_numactiveitems, None) 1723 1724 def __getfield_items(self): 1725 try: self.__field_items 1726 except: 1727 self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True}) 1728 return self.__field_items.getvalue() 1729 1730 def __setfield_items(self, value): 1731 if isinstance(value,LIST): 1732 self.__field_items=value 1733 else: 1734 self.__field_items=LIST(value,**{'elementclass': indexentry, 'createdefault': True}) 1735 1736 def __delfield_items(self): del self.__field_items 1737 1738 items=property(__getfield_items, __setfield_items, __delfield_items, None) 1739 1740 def iscontainer(self): 1741 return True 1742 1743 def containerelements(self): 1744 yield ('numactiveitems', self.__field_numactiveitems, None) 1745 yield ('items', self.__field_items, None) 1746 1747 1748 1749 1750 class content_entry(BaseProtogenClass): 1751 __fields=['type', 'index1', 'name1', 'unknown1', 'unknown2', 'mime_type', 'content_type', 'url', 'unknown_int1', 'unknown3', 'unknown_int2', 'unknown4', 'unknown5', 'size', 'location_maybe', 'index2', 'name2', 'unknown6'] 1752 1753 def __init__(self, *args, **kwargs): 1754 dict={} 1755 # What was supplied to this function 1756 dict.update(kwargs) 1757 # Parent constructor 1758 super(content_entry,self).__init__(**dict) 1759 if self.__class__ is content_entry: 1760 self._update(args,dict) 1761 1762 1763 def getfields(self): 1764 return self.__fields 1765 1766 1767 def _update(self, args, kwargs): 1768 super(content_entry,self)._update(args,kwargs) 1769 keys=kwargs.keys() 1770 for key in keys: 1771 if key in self.__fields: 1772 setattr(self, key, kwargs[key]) 1773 del kwargs[key] 1774 # Were any unrecognized kwargs passed in? 1775 if __debug__: 1776 self._complainaboutunusedargs(content_entry,kwargs) 1777 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 1778 # Make all P fields that haven't already been constructed 1779 1780 1781 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1782 'Writes this packet to the supplied buffer' 1783 self._bufferstartoffset=buf.getcurrentoffset() 1784 self.__field_type.writetobuffer(buf) 1785 if self.type=='!C': 1786 self.__field_index1.writetobuffer(buf) 1787 self.__field_name1.writetobuffer(buf) 1788 try: self.__field_unknown1 1789 except: 1790 self.__field_unknown1=USTRING(**{'terminator': 0xA, 'default': '-1'}) 1791 self.__field_unknown1.writetobuffer(buf) 1792 try: self.__field_unknown2 1793 except: 1794 self.__field_unknown2=UINT(**{'sizeinbytes': 8, 'default' :0}) 1795 self.__field_unknown2.writetobuffer(buf) 1796 self.__field_mime_type.writetobuffer(buf) 1797 self.__field_content_type.writetobuffer(buf) 1798 try: self.__field_url 1799 except: 1800 self.__field_url=USTRING(**{'terminator': 0xA, 'default':'bitpim.org'}) 1801 self.__field_url.writetobuffer(buf) 1802 try: self.__field_unknown_int1 1803 except: 1804 self.__field_unknown_int1=UINT(**{'sizeinbytes': 2, 'default':0x08AA}) 1805 self.__field_unknown_int1.writetobuffer(buf) 1806 try: self.__field_unknown3 1807 except: 1808 self.__field_unknown3=USTRING(**{'terminator': 0xA, 'default':''}) 1809 self.__field_unknown3.writetobuffer(buf) 1810 try: self.__field_unknown_int2 1811 except: 1812 self.__field_unknown_int2=UINT(**{'sizeinbytes': 2, 'default':0x08AA}) 1813 self.__field_unknown_int2.writetobuffer(buf) 1814 try: self.__field_unknown4 1815 except: 1816 self.__field_unknown4=USTRING(**{'terminator': 0xA, 'default':''}) 1817 self.__field_unknown4.writetobuffer(buf) 1818 try: self.__field_unknown5 1819 except: 1820 self.__field_unknown5=USTRING(**{'terminator': 0xA, 'default':'0'}) 1821 self.__field_unknown5.writetobuffer(buf) 1822 self.__field_size.writetobuffer(buf) 1823 if self.type=='!E': 1824 try: self.__field_location_maybe 1825 except: 1826 self.__field_location_maybe=USTRING(**{'terminator': 0xA, 'default':'ams:'}) 1827 self.__field_location_maybe.writetobuffer(buf) 1828 self.__field_index2.writetobuffer(buf) 1829 self.__field_name2.writetobuffer(buf) 1830 try: self.__field_unknown6 1831 except: 1832 self.__field_unknown6=USTRING(**{'terminator': 0xA, 'default':''}) 1833 self.__field_unknown6.writetobuffer(buf) 1834 self._bufferendoffset=buf.getcurrentoffset() 1835 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1836 1837 1838 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1839 'Reads this packet from the supplied buffer' 1840 self._bufferstartoffset=buf.getcurrentoffset() 1841 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1842 self.__field_type=USTRING(**{'sizeinbytes': 3, 'terminator': 0xA}) 1843 self.__field_type.readfrombuffer(buf) 1844 if self.type=='!C': 1845 self.__field_index1=USTRING(**{'terminator': 0xA}) 1846 self.__field_index1.readfrombuffer(buf) 1847 self.__field_name1=USTRING(**{'terminator': 0xA}) 1848 self.__field_name1.readfrombuffer(buf) 1849 self.__field_unknown1=USTRING(**{'terminator': 0xA, 'default': '-1'}) 1850 self.__field_unknown1.readfrombuffer(buf) 1851 self.__field_unknown2=UINT(**{'sizeinbytes': 8, 'default' :0}) 1852 self.__field_unknown2.readfrombuffer(buf) 1853 self.__field_mime_type=USTRING(**{'terminator': 0xA}) 1854 self.__field_mime_type.readfrombuffer(buf) 1855 self.__field_content_type=USTRING(**{'terminator': 0xA}) 1856 self.__field_content_type.readfrombuffer(buf) 1857 self.__field_url=USTRING(**{'terminator': 0xA, 'default':'bitpim.org'}) 1858 self.__field_url.readfrombuffer(buf) 1859 self.__field_unknown_int1=UINT(**{'sizeinbytes': 2, 'default':0x08AA}) 1860 self.__field_unknown_int1.readfrombuffer(buf) 1861 self.__field_unknown3=USTRING(**{'terminator': 0xA, 'default':''}) 1862 self.__field_unknown3.readfrombuffer(buf) 1863 self.__field_unknown_int2=UINT(**{'sizeinbytes': 2, 'default':0x08AA}) 1864 self.__field_unknown_int2.readfrombuffer(buf) 1865 self.__field_unknown4=USTRING(**{'terminator': 0xA, 'default':''}) 1866 self.__field_unknown4.readfrombuffer(buf) 1867 self.__field_unknown5=USTRING(**{'terminator': 0xA, 'default':'0'}) 1868 self.__field_unknown5.readfrombuffer(buf) 1869 self.__field_size=USTRING(**{'terminator': 0xA}) 1870 self.__field_size.readfrombuffer(buf) 1871 if self.type=='!E': 1872 self.__field_location_maybe=USTRING(**{'terminator': 0xA, 'default':'ams:'}) 1873 self.__field_location_maybe.readfrombuffer(buf) 1874 self.__field_index2=USTRING(**{'terminator': 0xA}) 1875 self.__field_index2.readfrombuffer(buf) 1876 self.__field_name2=USTRING(**{'terminator': 0xA}) 1877 self.__field_name2.readfrombuffer(buf) 1878 self.__field_unknown6=USTRING(**{'terminator': 0xA, 'default':''}) 1879 self.__field_unknown6.readfrombuffer(buf) 1880 self._bufferendoffset=buf.getcurrentoffset() 1881 1882 1883 def __getfield_type(self): 1884 return self.__field_type.getvalue() 1885 1886 def __setfield_type(self, value): 1887 if isinstance(value,USTRING): 1888 self.__field_type=value 1889 else: 1890 self.__field_type=USTRING(value,**{'sizeinbytes': 3, 'terminator': 0xA}) 1891 1892 def __delfield_type(self): del self.__field_type 1893 1894 type=property(__getfield_type, __setfield_type, __delfield_type, None) 1895 1896 def __getfield_index1(self): 1897 return self.__field_index1.getvalue() 1898 1899 def __setfield_index1(self, value): 1900 if isinstance(value,USTRING): 1901 self.__field_index1=value 1902 else: 1903 self.__field_index1=USTRING(value,**{'terminator': 0xA}) 1904 1905 def __delfield_index1(self): del self.__field_index1 1906 1907 index1=property(__getfield_index1, __setfield_index1, __delfield_index1, None) 1908 1909 def __getfield_name1(self): 1910 return self.__field_name1.getvalue() 1911 1912 def __setfield_name1(self, value): 1913 if isinstance(value,USTRING): 1914 self.__field_name1=value 1915 else: 1916 self.__field_name1=USTRING(value,**{'terminator': 0xA}) 1917 1918 def __delfield_name1(self): del self.__field_name1 1919 1920 name1=property(__getfield_name1, __setfield_name1, __delfield_name1, None) 1921 1922 def __getfield_unknown1(self): 1923 try: self.__field_unknown1 1924 except: 1925 self.__field_unknown1=USTRING(**{'terminator': 0xA, 'default': '-1'}) 1926 return self.__field_unknown1.getvalue() 1927 1928 def __setfield_unknown1(self, value): 1929 if isinstance(value,USTRING): 1930 self.__field_unknown1=value 1931 else: 1932 self.__field_unknown1=USTRING(value,**{'terminator': 0xA, 'default': '-1'}) 1933 1934 def __delfield_unknown1(self): del self.__field_unknown1 1935 1936 unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None) 1937 1938 def __getfield_unknown2(self): 1939 try: self.__field_unknown2 1940 except: 1941 self.__field_unknown2=UINT(**{'sizeinbytes': 8, 'default' :0}) 1942 return self.__field_unknown2.getvalue() 1943 1944 def __setfield_unknown2(self, value): 1945 if isinstance(value,UINT): 1946 self.__field_unknown2=value 1947 else: 1948 self.__field_unknown2=UINT(value,**{'sizeinbytes': 8, 'default' :0}) 1949 1950 def __delfield_unknown2(self): del self.__field_unknown2 1951 1952 unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None) 1953 1954 def __getfield_mime_type(self): 1955 return self.__field_mime_type.getvalue() 1956 1957 def __setfield_mime_type(self, value): 1958 if isinstance(value,USTRING): 1959 self.__field_mime_type=value 1960 else: 1961 self.__field_mime_type=USTRING(value,**{'terminator': 0xA}) 1962 1963 def __delfield_mime_type(self): del self.__field_mime_type 1964 1965 mime_type=property(__getfield_mime_type, __setfield_mime_type, __delfield_mime_type, None) 1966 1967 def __getfield_content_type(self): 1968 return self.__field_content_type.getvalue() 1969 1970 def __setfield_content_type(self, value): 1971 if isinstance(value,USTRING): 1972 self.__field_content_type=value 1973 else: 1974 self.__field_content_type=USTRING(value,**{'terminator': 0xA}) 1975 1976 def __delfield_content_type(self): del self.__field_content_type 1977 1978 content_type=property(__getfield_content_type, __setfield_content_type, __delfield_content_type, None) 1979 1980 def __getfield_url(self): 1981 try: self.__field_url 1982 except: 1983 self.__field_url=USTRING(**{'terminator': 0xA, 'default':'bitpim.org'}) 1984 return self.__field_url.getvalue() 1985 1986 def __setfield_url(self, value): 1987 if isinstance(value,USTRING): 1988 self.__field_url=value 1989 else: 1990 self.__field_url=USTRING(value,**{'terminator': 0xA, 'default':'bitpim.org'}) 1991 1992 def __delfield_url(self): del self.__field_url 1993 1994 url=property(__getfield_url, __setfield_url, __delfield_url, None) 1995 1996 def __getfield_unknown_int1(self): 1997 try: self.__field_unknown_int1 1998 except: 1999 self.__field_unknown_int1=UINT(**{'sizeinbytes': 2, 'default':0x08AA}) 2000 return self.__field_unknown_int1.getvalue() 2001 2002 def __setfield_unknown_int1(self, value): 2003 if isinstance(value,UINT): 2004 self.__field_unknown_int1=value 2005 else: 2006 self.__field_unknown_int1=UINT(value,**{'sizeinbytes': 2, 'default':0x08AA}) 2007 2008 def __delfield_unknown_int1(self): del self.__field_unknown_int1 2009 2010 unknown_int1=property(__getfield_unknown_int1, __setfield_unknown_int1, __delfield_unknown_int1, None) 2011 2012 def __getfield_unknown3(self): 2013 try: self.__field_unknown3 2014 except: 2015 self.__field_unknown3=USTRING(**{'terminator': 0xA, 'default':''}) 2016 return self.__field_unknown3.getvalue() 2017 2018 def __setfield_unknown3(self, value): 2019 if isinstance(value,USTRING): 2020 self.__field_unknown3=value 2021 else: 2022 self.__field_unknown3=USTRING(value,**{'terminator': 0xA, 'default':''}) 2023 2024 def __delfield_unknown3(self): del self.__field_unknown3 2025 2026 unknown3=property(__getfield_unknown3, __setfield_unknown3, __delfield_unknown3, None) 2027 2028 def __getfield_unknown_int2(self): 2029 try: self.__field_unknown_int2 2030 except: 2031 self.__field_unknown_int2=UINT(**{'sizeinbytes': 2, 'default':0x08AA}) 2032 return self.__field_unknown_int2.getvalue() 2033 2034 def __setfield_unknown_int2(self, value): 2035 if isinstance(value,UINT): 2036 self.__field_unknown_int2=value 2037 else: 2038 self.__field_unknown_int2=UINT(value,**{'sizeinbytes': 2, 'default':0x08AA}) 2039 2040 def __delfield_unknown_int2(self): del self.__field_unknown_int2 2041 2042 unknown_int2=property(__getfield_unknown_int2, __setfield_unknown_int2, __delfield_unknown_int2, None) 2043 2044 def __getfield_unknown4(self): 2045 try: self.__field_unknown4 2046 except: 2047 self.__field_unknown4=USTRING(**{'terminator': 0xA, 'default':''}) 2048 return self.__field_unknown4.getvalue() 2049 2050 def __setfield_unknown4(self, value): 2051 if isinstance(value,USTRING): 2052 self.__field_unknown4=value 2053 else: 2054 self.__field_unknown4=USTRING(value,**{'terminator': 0xA, 'default':''}) 2055 2056 def __delfield_unknown4(self): del self.__field_unknown4 2057 2058 unknown4=property(__getfield_unknown4, __setfield_unknown4, __delfield_unknown4, None) 2059 2060 def __getfield_unknown5(self): 2061 try: self.__field_unknown5 2062 except: 2063 self.__field_unknown5=USTRING(**{'terminator': 0xA, 'default':'0'}) 2064 return self.__field_unknown5.getvalue() 2065 2066 def __setfield_unknown5(self, value): 2067 if isinstance(value,USTRING): 2068 self.__field_unknown5=value 2069 else: 2070 self.__field_unknown5=USTRING(value,**{'terminator': 0xA, 'default':'0'}) 2071 2072 def __delfield_unknown5(self): del self.__field_unknown5 2073 2074 unknown5=property(__getfield_unknown5, __setfield_unknown5, __delfield_unknown5, None) 2075 2076 def __getfield_size(self): 2077 return self.__field_size.getvalue() 2078 2079 def __setfield_size(self, value): 2080 if isinstance(value,USTRING): 2081 self.__field_size=value 2082 else: 2083 self.__field_size=USTRING(value,**{'terminator': 0xA}) 2084 2085 def __delfield_size(self): del self.__field_size 2086 2087 size=property(__getfield_size, __setfield_size, __delfield_size, None) 2088 2089 def __getfield_location_maybe(self): 2090 try: self.__field_location_maybe 2091 except: 2092 self.__field_location_maybe=USTRING(**{'terminator': 0xA, 'default':'ams:'}) 2093 return self.__field_location_maybe.getvalue() 2094 2095 def __setfield_location_maybe(self, value): 2096 if isinstance(value,USTRING): 2097 self.__field_location_maybe=value 2098 else: 2099 self.__field_location_maybe=USTRING(value,**{'terminator': 0xA, 'default':'ams:'}) 2100 2101 def __delfield_location_maybe(self): del self.__field_location_maybe 2102 2103 location_maybe=property(__getfield_location_maybe, __setfield_location_maybe, __delfield_location_maybe, None) 2104 2105 def __getfield_index2(self): 2106 return self.__field_index2.getvalue() 2107 2108 def __setfield_index2(self, value): 2109 if isinstance(value,USTRING): 2110 self.__field_index2=value 2111 else: 2112 self.__field_index2=USTRING(value,**{'terminator': 0xA}) 2113 2114 def __delfield_index2(self): del self.__field_index2 2115 2116 index2=property(__getfield_index2, __setfield_index2, __delfield_index2, None) 2117 2118 def __getfield_name2(self): 2119 return self.__field_name2.getvalue() 2120 2121 def __setfield_name2(self, value): 2122 if isinstance(value,USTRING): 2123 self.__field_name2=value 2124 else: 2125 self.__field_name2=USTRING(value,**{'terminator': 0xA}) 2126 2127 def __delfield_name2(self): del self.__field_name2 2128 2129 name2=property(__getfield_name2, __setfield_name2, __delfield_name2, None) 2130 2131 def __getfield_unknown6(self): 2132 try: self.__field_unknown6 2133 except: 2134 self.__field_unknown6=USTRING(**{'terminator': 0xA, 'default':''}) 2135 return self.__field_unknown6.getvalue() 2136 2137 def __setfield_unknown6(self, value): 2138 if isinstance(value,USTRING): 2139 self.__field_unknown6=value 2140 else: 2141 self.__field_unknown6=USTRING(value,**{'terminator': 0xA, 'default':''}) 2142 2143 def __delfield_unknown6(self): del self.__field_unknown6 2144 2145 unknown6=property(__getfield_unknown6, __setfield_unknown6, __delfield_unknown6, None) 2146 2147 def iscontainer(self): 2148 return True 2149 2150 def containerelements(self): 2151 yield ('type', self.__field_type, None) 2152 if self.type=='!C': 2153 yield ('index1', self.__field_index1, None) 2154 yield ('name1', self.__field_name1, None) 2155 yield ('unknown1', self.__field_unknown1, None) 2156 yield ('unknown2', self.__field_unknown2, None) 2157 yield ('mime_type', self.__field_mime_type, None) 2158 yield ('content_type', self.__field_content_type, None) 2159 yield ('url', self.__field_url, None) 2160 yield ('unknown_int1', self.__field_unknown_int1, None) 2161 yield ('unknown3', self.__field_unknown3, None) 2162 yield ('unknown_int2', self.__field_unknown_int2, None) 2163 yield ('unknown4', self.__field_unknown4, None) 2164 yield ('unknown5', self.__field_unknown5, None) 2165 yield ('size', self.__field_size, None) 2166 if self.type=='!E': 2167 yield ('location_maybe', self.__field_location_maybe, None) 2168 yield ('index2', self.__field_index2, None) 2169 yield ('name2', self.__field_name2, None) 2170 yield ('unknown6', self.__field_unknown6, None) 2171 2172 2173 2174 2175 class content_file(BaseProtogenClass): 2176 "Used to store all content on the phone, apps, ringers and images (with the exception of the camera)" 2177 __fields=['items'] 2178 2179 def __init__(self, *args, **kwargs): 2180 dict={} 2181 # What was supplied to this function 2182 dict.update(kwargs) 2183 # Parent constructor 2184 super(content_file,self).__init__(**dict) 2185 if self.__class__ is content_file: 2186 self._update(args,dict) 2187 2188 2189 def getfields(self): 2190 return self.__fields 2191 2192 2193 def _update(self, args, kwargs): 2194 super(content_file,self)._update(args,kwargs) 2195 keys=kwargs.keys() 2196 for key in keys: 2197 if key in self.__fields: 2198 setattr(self, key, kwargs[key]) 2199 del kwargs[key] 2200 # Were any unrecognized kwargs passed in? 2201 if __debug__: 2202 self._complainaboutunusedargs(content_file,kwargs) 2203 if len(args): 2204 dict2={'elementclass': content_entry, 'createdefault': True} 2205 dict2.update(kwargs) 2206 kwargs=dict2 2207 self.__field_items=LIST(*args,**dict2) 2208 # Make all P fields that haven't already been constructed 2209 2210 2211 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 2212 'Writes this packet to the supplied buffer' 2213 self._bufferstartoffset=buf.getcurrentoffset() 2214 try: self.__field_items 2215 except: 2216 self.__field_items=LIST(**{'elementclass': content_entry, 'createdefault': True}) 2217 self.__field_items.writetobuffer(buf) 2218 self._bufferendoffset=buf.getcurrentoffset() 2219 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 2220 2221 2222 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 2223 'Reads this packet from the supplied buffer' 2224 self._bufferstartoffset=buf.getcurrentoffset() 2225 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 2226 self.__field_items=LIST(**{'elementclass': content_entry, 'createdefault': True}) 2227 self.__field_items.readfrombuffer(buf) 2228 self._bufferendoffset=buf.getcurrentoffset() 2229 2230 2231 def __getfield_items(self): 2232 try: self.__field_items 2233 except: 2234 self.__field_items=LIST(**{'elementclass': content_entry, 'createdefault': True}) 2235 return self.__field_items.getvalue() 2236 2237 def __setfield_items(self, value): 2238 if isinstance(value,LIST): 2239 self.__field_items=value 2240 else: 2241 self.__field_items=LIST(value,**{'elementclass': content_entry, 'createdefault': True}) 2242 2243 def __delfield_items(self): del self.__field_items 2244 2245 items=property(__getfield_items, __setfield_items, __delfield_items, None) 2246 2247 def iscontainer(self): 2248 return True 2249 2250 def containerelements(self): 2251 yield ('items', self.__field_items, None) 2252 2253 2254 2255 2256 class content_count(BaseProtogenClass): 2257 "Stores the number of items in the content file" 2258 __fields=['count'] 2259 2260 def __init__(self, *args, **kwargs): 2261 dict={} 2262 # What was supplied to this function 2263 dict.update(kwargs) 2264 # Parent constructor 2265 super(content_count,self).__init__(**dict) 2266 if self.__class__ is content_count: 2267 self._update(args,dict) 2268 2269 2270 def getfields(self): 2271 return self.__fields 2272 2273 2274 def _update(self, args, kwargs): 2275 super(content_count,self)._update(args,kwargs) 2276 keys=kwargs.keys() 2277 for key in keys: 2278 if key in self.__fields: 2279 setattr(self, key, kwargs[key]) 2280 del kwargs[key] 2281 # Were any unrecognized kwargs passed in? 2282 if __debug__: 2283 self._complainaboutunusedargs(content_count,kwargs) 2284 if len(args): 2285 dict2={'terminator': None} 2286 dict2.update(kwargs) 2287 kwargs=dict2 2288 self.__field_count=USTRING(*args,**dict2) 2289 # Make all P fields that haven't already been constructed 2290 2291 2292 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 2293 'Writes this packet to the supplied buffer' 2294 self._bufferstartoffset=buf.getcurrentoffset() 2295 self.__field_count.writetobuffer(buf) 2296 self._bufferendoffset=buf.getcurrentoffset() 2297 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 2298 2299 2300 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 2301 'Reads this packet from the supplied buffer' 2302 self._bufferstartoffset=buf.getcurrentoffset() 2303 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 2304 self.__field_count=USTRING(**{'terminator': None}) 2305 self.__field_count.readfrombuffer(buf) 2306 self._bufferendoffset=buf.getcurrentoffset() 2307 2308 2309 def __getfield_count(self): 2310 return self.__field_count.getvalue() 2311 2312 def __setfield_count(self, value): 2313 if isinstance(value,USTRING): 2314 self.__field_count=value 2315 else: 2316 self.__field_count=USTRING(value,**{'terminator': None}) 2317 2318 def __delfield_count(self): del self.__field_count 2319 2320 count=property(__getfield_count, __setfield_count, __delfield_count, None) 2321 2322 def iscontainer(self): 2323 return True 2324 2325 def containerelements(self): 2326 yield ('count', self.__field_count, None) 2327 2328 2329 2330 2331 class textmemo(BaseProtogenClass): 2332 __fields=['text'] 2333 2334 def __init__(self, *args, **kwargs): 2335 dict={} 2336 # What was supplied to this function 2337 dict.update(kwargs) 2338 # Parent constructor 2339 super(textmemo,self).__init__(**dict) 2340 if self.__class__ is textmemo: 2341 self._update(args,dict) 2342 2343 2344 def getfields(self): 2345 return self.__fields 2346 2347 2348 def _update(self, args, kwargs): 2349 super(textmemo,self)._update(args,kwargs) 2350 keys=kwargs.keys() 2351 for key in keys: 2352 if key in self.__fields: 2353 setattr(self, key, kwargs[key]) 2354 del kwargs[key] 2355 # Were any unrecognized kwargs passed in? 2356 if __debug__: 2357 self._complainaboutunusedargs(textmemo,kwargs) 2358 if len(args): 2359 dict2={'sizeinbytes': 151, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False } 2360 dict2.update(kwargs) 2361 kwargs=dict2 2362 self.__field_text=USTRING(*args,**dict2) 2363 # Make all P fields that haven't already been constructed 2364 2365 2366 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 2367 'Writes this packet to the supplied buffer' 2368 self._bufferstartoffset=buf.getcurrentoffset() 2369 self.__field_text.writetobuffer(buf) 2370 self._bufferendoffset=buf.getcurrentoffset() 2371 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 2372 2373 2374 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 2375 'Reads this packet from the supplied buffer' 2376 self._bufferstartoffset=buf.getcurrentoffset() 2377 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 2378 self.__field_text=USTRING(**{'sizeinbytes': 151, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False }) 2379 self.__field_text.readfrombuffer(buf) 2380 self._bufferendoffset=buf.getcurrentoffset() 2381 2382 2383 def __getfield_text(self): 2384 return self.__field_text.getvalue() 2385 2386 def __setfield_text(self, value): 2387 if isinstance(value,USTRING): 2388 self.__field_text=value 2389 else: 2390 self.__field_text=USTRING(value,**{'sizeinbytes': 151, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False }) 2391 2392 def __delfield_text(self): del self.__field_text 2393 2394 text=property(__getfield_text, __setfield_text, __delfield_text, None) 2395 2396 def iscontainer(self): 2397 return True 2398 2399 def containerelements(self): 2400 yield ('text', self.__field_text, None) 2401 2402 2403 2404 2405 class textmemofile(BaseProtogenClass): 2406 __fields=['itemcount', 'items'] 2407 2408 def __init__(self, *args, **kwargs): 2409 dict={} 2410 # What was supplied to this function 2411 dict.update(kwargs) 2412 # Parent constructor 2413 super(textmemofile,self).__init__(**dict) 2414 if self.__class__ is textmemofile: 2415 self._update(args,dict) 2416 2417 2418 def getfields(self): 2419 return self.__fields 2420 2421 2422 def _update(self, args, kwargs): 2423 super(textmemofile,self)._update(args,kwargs) 2424 keys=kwargs.keys() 2425 for key in keys: 2426 if key in self.__fields: 2427 setattr(self, key, kwargs[key]) 2428 del kwargs[key] 2429 # Were any unrecognized kwargs passed in? 2430 if __debug__: 2431 self._complainaboutunusedargs(textmemofile,kwargs) 2432 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 2433 # Make all P fields that haven't already been constructed 2434 2435 2436 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 2437 'Writes this packet to the supplied buffer' 2438 self._bufferstartoffset=buf.getcurrentoffset() 2439 self.__field_itemcount.writetobuffer(buf) 2440 try: self.__field_items 2441 except: 2442 self.__field_items=LIST(**{ 'elementclass': textmemo }) 2443 self.__field_items.writetobuffer(buf) 2444 self._bufferendoffset=buf.getcurrentoffset() 2445 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 2446 2447 2448 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 2449 'Reads this packet from the supplied buffer' 2450 self._bufferstartoffset=buf.getcurrentoffset() 2451 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 2452 self.__field_itemcount=UINT(**{'sizeinbytes': 4}) 2453 self.__field_itemcount.readfrombuffer(buf) 2454 self.__field_items=LIST(**{ 'elementclass': textmemo }) 2455 self.__field_items.readfrombuffer(buf) 2456 self._bufferendoffset=buf.getcurrentoffset() 2457 2458 2459 def __getfield_itemcount(self): 2460 return self.__field_itemcount.getvalue() 2461 2462 def __setfield_itemcount(self, value): 2463 if isinstance(value,UINT): 2464 self.__field_itemcount=value 2465 else: 2466 self.__field_itemcount=UINT(value,**{'sizeinbytes': 4}) 2467 2468 def __delfield_itemcount(self): del self.__field_itemcount 2469 2470 itemcount=property(__getfield_itemcount, __setfield_itemcount, __delfield_itemcount, None) 2471 2472 def __getfield_items(self): 2473 try: self.__field_items 2474 except: 2475 self.__field_items=LIST(**{ 'elementclass': textmemo }) 2476 return self.__field_items.getvalue() 2477 2478 def __setfield_items(self, value): 2479 if isinstance(value,LIST): 2480 self.__field_items=value 2481 else: 2482 self.__field_items=LIST(value,**{ 'elementclass': textmemo }) 2483 2484 def __delfield_items(self): del self.__field_items 2485 2486 items=property(__getfield_items, __setfield_items, __delfield_items, None) 2487 2488 def iscontainer(self): 2489 return True 2490 2491 def containerelements(self): 2492 yield ('itemcount', self.__field_itemcount, None) 2493 yield ('items', self.__field_items, None) 2494 2495 2496 2497 2498
Generated by PyXR 0.9.4