0001
0003 """Various descriptions of data specific to LG PM325 (Sprint)"""
0004
0005 import re
0006
0007 from prototypes import *
0008 from prototypeslg import *
0009
0010 from p_lg import *
0012
0013
0014 UINT=UINTlsb
0016 BOOL=BOOLlsb
0017
0018 NUMSPEEDDIALS=99
0019 FIRSTSPEEDDIAL=1
0020 LASTSPEEDDIAL=99
0021 NUMPHONEBOOKENTRIES=200
0022 MEMOLENGTH=33
0023
0024 NUMEMAILS=3
0025 NUMPHONENUMBERS=5
0026
0027 NORINGTONE=0
0028 NOMSGRINGTONE=0
0029 NOWALLPAPER=0
0030
0031 PHONE_ENCODING='iso8859_1'
0032
0033 numbertypetab=( 'cell', 'home', 'office', 'fax', 'pager' )
0034
0035 media_directory='ams'
0036 ringerindex='setas/amsRingerIndex.map'
0037 imageindex='setas/amsImageIndex.map'
0038 ringerconst=2
0039 imageconst=3
0040 max_ringers=100
0041 max_images=100
0042
0043 phonebook_media='pim/pbookcontact.dat'
0044
0045 NUMCALENDARENTRIES=300
0047 CAL_REP_NONE=0x10
0048 CAL_REP_DAILY=0x11
0049 CAL_REP_MONFRI=0x12
0050 CAL_REP_WEEKLY=0x13
0051 CAL_REP_MONTHLY=0x14
0052 CAL_REP_YEARLY=0x15
0053 CAL_DOW_SUN=0x0800
0054 CAL_DOW_MON=0x0400
0055 CAL_DOW_TUE=0x0200
0056 CAL_DOW_WED=0x0100
0057 CAL_DOW_THU=0x0080
0058 CAL_DOW_FRI=0x0040
0059 CAL_DOW_SAT=0x0020
0060 CAL_DOW_EXCEPTIONS=0x0010
0061 CAL_REMINDER_NONE=0
0062 CAL_REMINDER_ONTIME=1
0063 CAL_REMINDER_5MIN=2
0064 CAL_REMINDER_10MIN=3
0065 CAL_REMINDER_1HOUR=4
0066 CAL_REMINDER_1DAY=5
0067 CAL_REMINDER_2DAYS=6
0068 CAL_REPEAT_DATE=(2100, 12, 31)
0069
0070 cal_dir='sch'
0071 cal_data_file_name='sch/schedule.dat'
0072 cal_exception_file_name='sch/schexception.dat'
0073 cal_has_voice_id=False
0074
0075 SMS_CANNED_MAX_ITEMS=40
0077 SMS_CANNED_MAX_LENGTH=104
0078 SMS_CANNED_FILENAME="sms/canned_msg.dat"
0079 SMS_PATTERNS={'Inbox': re.compile(r"^.*/inbox[0-9][0-9][0-9]\.dat$"),
0080 'Sent': re.compile(r"^.*/outbox[0-9][0-9][0-9]\.dat$"),
0081 'Saved': re.compile(r"^.*/sf[0-9][0-9]\.dat$"),
0082 }
0083
0084 text_memo_file='sch/memo.dat'
0086 content_file_name='ams/contentInfo'
0087 content_count_file_name='ams/realContent'
0088
0089 class firmwareresponse(BaseProtogenClass):
0090 __fields=['command', 'date1', 'time1', 'date2', 'time2', 'firmware', 'dunno']
0091
0092 def __init__(self, *args, **kwargs):
0093 dict={}
0094 dict.update(kwargs)
0096 super(firmwareresponse,self).__init__(**dict)
0098 if self.__class__ is firmwareresponse:
0099 self._update(args,dict)
0100
0101
0102 def getfields(self):
0103 return self.__fields
0104
0105
0106 def _update(self, args, kwargs):
0107 super(firmwareresponse,self)._update(args,kwargs)
0108 keys=kwargs.keys()
0109 for key in keys:
0110 if key in self.__fields:
0111 setattr(self, key, kwargs[key])
0112 del kwargs[key]
0113 if __debug__:
0115 self._complainaboutunusedargs(firmwareresponse,kwargs)
0116 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0117
0119
0120 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0121 'Writes this packet to the supplied buffer'
0122 self._bufferstartoffset=buf.getcurrentoffset()
0123 self.__field_command.writetobuffer(buf)
0124 self.__field_date1.writetobuffer(buf)
0125 self.__field_time1.writetobuffer(buf)
0126 self.__field_date2.writetobuffer(buf)
0127 self.__field_time2.writetobuffer(buf)
0128 self.__field_firmware.writetobuffer(buf)
0129 self.__field_dunno.writetobuffer(buf)
0130 self._bufferendoffset=buf.getcurrentoffset()
0131 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0132
0133
0134 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0135 'Reads this packet from the supplied buffer'
0136 self._bufferstartoffset=buf.getcurrentoffset()
0137 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0138 self.__field_command=UINT(**{'sizeinbytes': 1})
0139 self.__field_command.readfrombuffer(buf)
0140 self.__field_date1=USTRING(**{'sizeinbytes': 11, 'terminator': None})
0141 self.__field_date1.readfrombuffer(buf)
0142 self.__field_time1=USTRING(**{'sizeinbytes': 8, 'terminator': None})
0143 self.__field_time1.readfrombuffer(buf)
0144 self.__field_date2=USTRING(**{'sizeinbytes': 11, 'terminator': None})
0145 self.__field_date2.readfrombuffer(buf)
0146 self.__field_time2=USTRING(**{'sizeinbytes': 8, 'terminator': None})
0147 self.__field_time2.readfrombuffer(buf)
0148 self.__field_firmware=USTRING(**{'sizeinbytes': 8, 'terminator': None})
0149 self.__field_firmware.readfrombuffer(buf)
0150 self.__field_dunno=DATA()
0151 self.__field_dunno.readfrombuffer(buf)
0152 self._bufferendoffset=buf.getcurrentoffset()
0153
0154
0155 def __getfield_command(self):
0156 return self.__field_command.getvalue()
0157
0158 def __setfield_command(self, value):
0159 if isinstance(value,UINT):
0160 self.__field_command=value
0161 else:
0162 self.__field_command=UINT(value,**{'sizeinbytes': 1})
0163
0164 def __delfield_command(self): del self.__field_command
0165
0166 command=property(__getfield_command, __setfield_command, __delfield_command, None)
0167
0168 def __getfield_date1(self):
0169 return self.__field_date1.getvalue()
0170
0171 def __setfield_date1(self, value):
0172 if isinstance(value,USTRING):
0173 self.__field_date1=value
0174 else:
0175 self.__field_date1=USTRING(value,**{'sizeinbytes': 11, 'terminator': None})
0176
0177 def __delfield_date1(self): del self.__field_date1
0178
0179 date1=property(__getfield_date1, __setfield_date1, __delfield_date1, None)
0180
0181 def __getfield_time1(self):
0182 return self.__field_time1.getvalue()
0183
0184 def __setfield_time1(self, value):
0185 if isinstance(value,USTRING):
0186 self.__field_time1=value
0187 else:
0188 self.__field_time1=USTRING(value,**{'sizeinbytes': 8, 'terminator': None})
0189
0190 def __delfield_time1(self): del self.__field_time1
0191
0192 time1=property(__getfield_time1, __setfield_time1, __delfield_time1, None)
0193
0194 def __getfield_date2(self):
0195 return self.__field_date2.getvalue()
0196
0197 def __setfield_date2(self, value):
0198 if isinstance(value,USTRING):
0199 self.__field_date2=value
0200 else:
0201 self.__field_date2=USTRING(value,**{'sizeinbytes': 11, 'terminator': None})
0202
0203 def __delfield_date2(self): del self.__field_date2
0204
0205 date2=property(__getfield_date2, __setfield_date2, __delfield_date2, None)
0206
0207 def __getfield_time2(self):
0208 return self.__field_time2.getvalue()
0209
0210 def __setfield_time2(self, value):
0211 if isinstance(value,USTRING):
0212 self.__field_time2=value
0213 else:
0214 self.__field_time2=USTRING(value,**{'sizeinbytes': 8, 'terminator': None})
0215
0216 def __delfield_time2(self): del self.__field_time2
0217
0218 time2=property(__getfield_time2, __setfield_time2, __delfield_time2, None)
0219
0220 def __getfield_firmware(self):
0221 return self.__field_firmware.getvalue()
0222
0223 def __setfield_firmware(self, value):
0224 if isinstance(value,USTRING):
0225 self.__field_firmware=value
0226 else:
0227 self.__field_firmware=USTRING(value,**{'sizeinbytes': 8, 'terminator': None})
0228
0229 def __delfield_firmware(self): del self.__field_firmware
0230
0231 firmware=property(__getfield_firmware, __setfield_firmware, __delfield_firmware, None)
0232
0233 def __getfield_dunno(self):
0234 return self.__field_dunno.getvalue()
0235
0236 def __setfield_dunno(self, value):
0237 if isinstance(value,DATA):
0238 self.__field_dunno=value
0239 else:
0240 self.__field_dunno=DATA(value,)
0241
0242 def __delfield_dunno(self): del self.__field_dunno
0243
0244 dunno=property(__getfield_dunno, __setfield_dunno, __delfield_dunno, None)
0245
0246 def iscontainer(self):
0247 return True
0248
0249 def containerelements(self):
0250 yield ('command', self.__field_command, None)
0251 yield ('date1', self.__field_date1, None)
0252 yield ('time1', self.__field_time1, None)
0253 yield ('date2', self.__field_date2, None)
0254 yield ('time2', self.__field_time2, None)
0255 yield ('firmware', self.__field_firmware, None)
0256 yield ('dunno', self.__field_dunno, None)
0257
0258
0259
0260
0261 class pbreadentryresponse(BaseProtogenClass):
0262 "Results of reading one entry"
0263 __fields=['header', 'entry']
0264
0265 def __init__(self, *args, **kwargs):
0266 dict={}
0267 dict.update(kwargs)
0269 super(pbreadentryresponse,self).__init__(**dict)
0271 if self.__class__ is pbreadentryresponse:
0272 self._update(args,dict)
0273
0274
0275 def getfields(self):
0276 return self.__fields
0277
0278
0279 def _update(self, args, kwargs):
0280 super(pbreadentryresponse,self)._update(args,kwargs)
0281 keys=kwargs.keys()
0282 for key in keys:
0283 if key in self.__fields:
0284 setattr(self, key, kwargs[key])
0285 del kwargs[key]
0286 if __debug__:
0288 self._complainaboutunusedargs(pbreadentryresponse,kwargs)
0289 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0290
0292
0293 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0294 'Writes this packet to the supplied buffer'
0295 self._bufferstartoffset=buf.getcurrentoffset()
0296 self.__field_header.writetobuffer(buf)
0297 self.__field_entry.writetobuffer(buf)
0298 self._bufferendoffset=buf.getcurrentoffset()
0299 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0300
0301
0302 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0303 'Reads this packet from the supplied buffer'
0304 self._bufferstartoffset=buf.getcurrentoffset()
0305 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0306 self.__field_header=pbheader()
0307 self.__field_header.readfrombuffer(buf)
0308 self.__field_entry=pbentry()
0309 self.__field_entry.readfrombuffer(buf)
0310 self._bufferendoffset=buf.getcurrentoffset()
0311
0312
0313 def __getfield_header(self):
0314 return self.__field_header.getvalue()
0315
0316 def __setfield_header(self, value):
0317 if isinstance(value,pbheader):
0318 self.__field_header=value
0319 else:
0320 self.__field_header=pbheader(value,)
0321
0322 def __delfield_header(self): del self.__field_header
0323
0324 header=property(__getfield_header, __setfield_header, __delfield_header, None)
0325
0326 def __getfield_entry(self):
0327 return self.__field_entry.getvalue()
0328
0329 def __setfield_entry(self, value):
0330 if isinstance(value,pbentry):
0331 self.__field_entry=value
0332 else:
0333 self.__field_entry=pbentry(value,)
0334
0335 def __delfield_entry(self): del self.__field_entry
0336
0337 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
0338
0339 def iscontainer(self):
0340 return True
0341
0342 def containerelements(self):
0343 yield ('header', self.__field_header, None)
0344 yield ('entry', self.__field_entry, None)
0345
0346
0347
0348
0349 class pbupdateentryrequest(BaseProtogenClass):
0350 __fields=['header', 'entry']
0351
0352 def __init__(self, *args, **kwargs):
0353 dict={}
0354 dict.update(kwargs)
0356 super(pbupdateentryrequest,self).__init__(**dict)
0358 if self.__class__ is pbupdateentryrequest:
0359 self._update(args,dict)
0360
0361
0362 def getfields(self):
0363 return self.__fields
0364
0365
0366 def _update(self, args, kwargs):
0367 super(pbupdateentryrequest,self)._update(args,kwargs)
0368 keys=kwargs.keys()
0369 for key in keys:
0370 if key in self.__fields:
0371 setattr(self, key, kwargs[key])
0372 del kwargs[key]
0373 if __debug__:
0375 self._complainaboutunusedargs(pbupdateentryrequest,kwargs)
0376 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0377
0379
0380 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0381 'Writes this packet to the supplied buffer'
0382 self._bufferstartoffset=buf.getcurrentoffset()
0383 try: self.__field_header
0384 except:
0385 self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01})
0386 self.__field_header.writetobuffer(buf)
0387 self.__field_entry.writetobuffer(buf)
0388 self._bufferendoffset=buf.getcurrentoffset()
0389 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0390
0391
0392 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0393 'Reads this packet from the supplied buffer'
0394 self._bufferstartoffset=buf.getcurrentoffset()
0395 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0396 self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01})
0397 self.__field_header.readfrombuffer(buf)
0398 self.__field_entry=pbentry()
0399 self.__field_entry.readfrombuffer(buf)
0400 self._bufferendoffset=buf.getcurrentoffset()
0401
0402
0403 def __getfield_header(self):
0404 try: self.__field_header
0405 except:
0406 self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01})
0407 return self.__field_header.getvalue()
0408
0409 def __setfield_header(self, value):
0410 if isinstance(value,pbheader):
0411 self.__field_header=value
0412 else:
0413 self.__field_header=pbheader(value,**{'command': 0x04, 'flag': 0x01})
0414
0415 def __delfield_header(self): del self.__field_header
0416
0417 header=property(__getfield_header, __setfield_header, __delfield_header, None)
0418
0419 def __getfield_entry(self):
0420 return self.__field_entry.getvalue()
0421
0422 def __setfield_entry(self, value):
0423 if isinstance(value,pbentry):
0424 self.__field_entry=value
0425 else:
0426 self.__field_entry=pbentry(value,)
0427
0428 def __delfield_entry(self): del self.__field_entry
0429
0430 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
0431
0432 def iscontainer(self):
0433 return True
0434
0435 def containerelements(self):
0436 yield ('header', self.__field_header, None)
0437 yield ('entry', self.__field_entry, None)
0438
0439
0440
0441
0442 class pbappendentryrequest(BaseProtogenClass):
0443 __fields=['header', 'entry']
0444
0445 def __init__(self, *args, **kwargs):
0446 dict={}
0447 dict.update(kwargs)
0449 super(pbappendentryrequest,self).__init__(**dict)
0451 if self.__class__ is pbappendentryrequest:
0452 self._update(args,dict)
0453
0454
0455 def getfields(self):
0456 return self.__fields
0457
0458
0459 def _update(self, args, kwargs):
0460 super(pbappendentryrequest,self)._update(args,kwargs)
0461 keys=kwargs.keys()
0462 for key in keys:
0463 if key in self.__fields:
0464 setattr(self, key, kwargs[key])
0465 del kwargs[key]
0466 if __debug__:
0468 self._complainaboutunusedargs(pbappendentryrequest,kwargs)
0469 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0470
0472
0473 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0474 'Writes this packet to the supplied buffer'
0475 self._bufferstartoffset=buf.getcurrentoffset()
0476 try: self.__field_header
0477 except:
0478 self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01})
0479 self.__field_header.writetobuffer(buf)
0480 self.__field_entry.writetobuffer(buf)
0481 self._bufferendoffset=buf.getcurrentoffset()
0482 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0483
0484
0485 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0486 'Reads this packet from the supplied buffer'
0487 self._bufferstartoffset=buf.getcurrentoffset()
0488 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0489 self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01})
0490 self.__field_header.readfrombuffer(buf)
0491 self.__field_entry=pbentry()
0492 self.__field_entry.readfrombuffer(buf)
0493 self._bufferendoffset=buf.getcurrentoffset()
0494
0495
0496 def __getfield_header(self):
0497 try: self.__field_header
0498 except:
0499 self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01})
0500 return self.__field_header.getvalue()
0501
0502 def __setfield_header(self, value):
0503 if isinstance(value,pbheader):
0504 self.__field_header=value
0505 else:
0506 self.__field_header=pbheader(value,**{'command': 0x03, 'flag': 0x01})
0507
0508 def __delfield_header(self): del self.__field_header
0509
0510 header=property(__getfield_header, __setfield_header, __delfield_header, None)
0511
0512 def __getfield_entry(self):
0513 return self.__field_entry.getvalue()
0514
0515 def __setfield_entry(self, value):
0516 if isinstance(value,pbentry):
0517 self.__field_entry=value
0518 else:
0519 self.__field_entry=pbentry(value,)
0520
0521 def __delfield_entry(self): del self.__field_entry
0522
0523 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
0524
0525 def iscontainer(self):
0526 return True
0527
0528 def containerelements(self):
0529 yield ('header', self.__field_header, None)
0530 yield ('entry', self.__field_entry, None)
0531
0532
0533
0534
0535 class pbentry(BaseProtogenClass):
0536 __fields=['serial1', 'entrysize', 'entrynumber', 'name', 'group', 'unknown2', 'secret', 'memo', 'emails', 'url', 'numberspeeds', 'numbertypes', 'numbers', 'EndOfRecord', 'ringtone', 'wallpaper']
0537
0538 def __init__(self, *args, **kwargs):
0539 dict={}
0540 dict.update(kwargs)
0542 super(pbentry,self).__init__(**dict)
0544 if self.__class__ is pbentry:
0545 self._update(args,dict)
0546
0547
0548 def getfields(self):
0549 return self.__fields
0550
0551
0552 def _update(self, args, kwargs):
0553 super(pbentry,self)._update(args,kwargs)
0554 keys=kwargs.keys()
0555 for key in keys:
0556 if key in self.__fields:
0557 setattr(self, key, kwargs[key])
0558 del kwargs[key]
0559 if __debug__:
0561 self._complainaboutunusedargs(pbentry,kwargs)
0562 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0563 try: self.__field_ringtone
0565 except:
0566 self.__field_ringtone=UINT(**{'default': 0x600})
0567 try: self.__field_wallpaper
0568 except:
0569 self.__field_wallpaper=UINT(**{'default': 0x100})
0570
0571
0572 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0573 'Writes this packet to the supplied buffer'
0574 self._bufferstartoffset=buf.getcurrentoffset()
0575 self.__field_serial1.writetobuffer(buf)
0576 try: self.__field_entrysize
0577 except:
0578 self.__field_entrysize=UINT(**{'sizeinbytes': 2, 'constant': 0x026E})
0579 self.__field_entrysize.writetobuffer(buf)
0580 self.__field_entrynumber.writetobuffer(buf)
0581 self.__field_name.writetobuffer(buf)
0582 self.__field_group.writetobuffer(buf)
0583 try: self.__field_unknown2
0584 except:
0585 self.__field_unknown2=UINT(**{'sizeinbytes': 2, 'default': 0})
0586 self.__field_unknown2.writetobuffer(buf)
0587 self.__field_secret.writetobuffer(buf)
0588 self.__field_memo.writetobuffer(buf)
0589 try: self.__field_emails
0590 except:
0591 self.__field_emails=LIST(**{'elementclass': _gen_p_lgpm325_139, 'length': NUMEMAILS})
0592 self.__field_emails.writetobuffer(buf)
0593 self.__field_url.writetobuffer(buf)
0594 try: self.__field_numberspeeds
0595 except:
0596 self.__field_numberspeeds=LIST(**{'elementclass': _gen_p_lgpm325_142, 'length': NUMPHONENUMBERS})
0597 self.__field_numberspeeds.writetobuffer(buf)
0598 try: self.__field_numbertypes
0599 except:
0600 self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lgpm325_144, 'length': NUMPHONENUMBERS})
0601 self.__field_numbertypes.writetobuffer(buf)
0602 try: self.__field_numbers
0603 except:
0604 self.__field_numbers=LIST(**{'elementclass': _gen_p_lgpm325_146, 'length': NUMPHONENUMBERS})
0605 self.__field_numbers.writetobuffer(buf)
0606 try: self.__field_EndOfRecord
0607 except:
0608 self.__field_EndOfRecord=UINT(**{'sizeinbytes': 1, 'constant': 0x78})
0609 self.__field_EndOfRecord.writetobuffer(buf)
0610 self._bufferendoffset=buf.getcurrentoffset()
0611 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0612
0613
0614 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0615 'Reads this packet from the supplied buffer'
0616 self._bufferstartoffset=buf.getcurrentoffset()
0617 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0618 self.__field_serial1=UINT(**{'sizeinbytes': 4})
0619 self.__field_serial1.readfrombuffer(buf)
0620 self.__field_entrysize=UINT(**{'sizeinbytes': 2, 'constant': 0x026E})
0621 self.__field_entrysize.readfrombuffer(buf)
0622 self.__field_entrynumber=UINT(**{'sizeinbytes': 4})
0623 self.__field_entrynumber.readfrombuffer(buf)
0624 self.__field_name=USTRING(**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})
0625 self.__field_name.readfrombuffer(buf)
0626 self.__field_group=UINT(**{'sizeinbytes': 2})
0627 self.__field_group.readfrombuffer(buf)
0628 self.__field_unknown2=UINT(**{'sizeinbytes': 2, 'default': 0})
0629 self.__field_unknown2.readfrombuffer(buf)
0630 self.__field_secret=BOOL(**{'sizeinbytes': 1})
0631 self.__field_secret.readfrombuffer(buf)
0632 self.__field_memo=USTRING(**{'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'sizeinbytes': MEMOLENGTH})
0633 self.__field_memo.readfrombuffer(buf)
0634 self.__field_emails=LIST(**{'elementclass': _gen_p_lgpm325_139, 'length': NUMEMAILS})
0635 self.__field_emails.readfrombuffer(buf)
0636 self.__field_url=USTRING(**{'sizeinbytes': 73, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})
0637 self.__field_url.readfrombuffer(buf)
0638 self.__field_numberspeeds=LIST(**{'elementclass': _gen_p_lgpm325_142, 'length': NUMPHONENUMBERS})
0639 self.__field_numberspeeds.readfrombuffer(buf)
0640 self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lgpm325_144, 'length': NUMPHONENUMBERS})
0641 self.__field_numbertypes.readfrombuffer(buf)
0642 self.__field_numbers=LIST(**{'elementclass': _gen_p_lgpm325_146, 'length': NUMPHONENUMBERS})
0643 self.__field_numbers.readfrombuffer(buf)
0644 self.__field_EndOfRecord=UINT(**{'sizeinbytes': 1, 'constant': 0x78})
0645 self.__field_EndOfRecord.readfrombuffer(buf)
0646 self._bufferendoffset=buf.getcurrentoffset()
0647
0648
0649 def __getfield_serial1(self):
0650 return self.__field_serial1.getvalue()
0651
0652 def __setfield_serial1(self, value):
0653 if isinstance(value,UINT):
0654 self.__field_serial1=value
0655 else:
0656 self.__field_serial1=UINT(value,**{'sizeinbytes': 4})
0657
0658 def __delfield_serial1(self): del self.__field_serial1
0659
0660 serial1=property(__getfield_serial1, __setfield_serial1, __delfield_serial1, None)
0661
0662 def __getfield_entrysize(self):
0663 try: self.__field_entrysize
0664 except:
0665 self.__field_entrysize=UINT(**{'sizeinbytes': 2, 'constant': 0x026E})
0666 return self.__field_entrysize.getvalue()
0667
0668 def __setfield_entrysize(self, value):
0669 if isinstance(value,UINT):
0670 self.__field_entrysize=value
0671 else:
0672 self.__field_entrysize=UINT(value,**{'sizeinbytes': 2, 'constant': 0x026E})
0673
0674 def __delfield_entrysize(self): del self.__field_entrysize
0675
0676 entrysize=property(__getfield_entrysize, __setfield_entrysize, __delfield_entrysize, None)
0677
0678 def __getfield_entrynumber(self):
0679 return self.__field_entrynumber.getvalue()
0680
0681 def __setfield_entrynumber(self, value):
0682 if isinstance(value,UINT):
0683 self.__field_entrynumber=value
0684 else:
0685 self.__field_entrynumber=UINT(value,**{'sizeinbytes': 4})
0686
0687 def __delfield_entrynumber(self): del self.__field_entrynumber
0688
0689 entrynumber=property(__getfield_entrynumber, __setfield_entrynumber, __delfield_entrynumber, None)
0690
0691 def __getfield_name(self):
0692 return self.__field_name.getvalue()
0693
0694 def __setfield_name(self, value):
0695 if isinstance(value,USTRING):
0696 self.__field_name=value
0697 else:
0698 self.__field_name=USTRING(value,**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})
0699
0700 def __delfield_name(self): del self.__field_name
0701
0702 name=property(__getfield_name, __setfield_name, __delfield_name, None)
0703
0704 def __getfield_group(self):
0705 return self.__field_group.getvalue()
0706
0707 def __setfield_group(self, value):
0708 if isinstance(value,UINT):
0709 self.__field_group=value
0710 else:
0711 self.__field_group=UINT(value,**{'sizeinbytes': 2})
0712
0713 def __delfield_group(self): del self.__field_group
0714
0715 group=property(__getfield_group, __setfield_group, __delfield_group, None)
0716
0717 def __getfield_unknown2(self):
0718 try: self.__field_unknown2
0719 except:
0720 self.__field_unknown2=UINT(**{'sizeinbytes': 2, 'default': 0})
0721 return self.__field_unknown2.getvalue()
0722
0723 def __setfield_unknown2(self, value):
0724 if isinstance(value,UINT):
0725 self.__field_unknown2=value
0726 else:
0727 self.__field_unknown2=UINT(value,**{'sizeinbytes': 2, 'default': 0})
0728
0729 def __delfield_unknown2(self): del self.__field_unknown2
0730
0731 unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None)
0732
0733 def __getfield_secret(self):
0734 return self.__field_secret.getvalue()
0735
0736 def __setfield_secret(self, value):
0737 if isinstance(value,BOOL):
0738 self.__field_secret=value
0739 else:
0740 self.__field_secret=BOOL(value,**{'sizeinbytes': 1})
0741
0742 def __delfield_secret(self): del self.__field_secret
0743
0744 secret=property(__getfield_secret, __setfield_secret, __delfield_secret, None)
0745
0746 def __getfield_memo(self):
0747 return self.__field_memo.getvalue()
0748
0749 def __setfield_memo(self, value):
0750 if isinstance(value,USTRING):
0751 self.__field_memo=value
0752 else:
0753 self.__field_memo=USTRING(value,**{'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'sizeinbytes': MEMOLENGTH})
0754
0755 def __delfield_memo(self): del self.__field_memo
0756
0757 memo=property(__getfield_memo, __setfield_memo, __delfield_memo, None)
0758
0759 def __getfield_emails(self):
0760 try: self.__field_emails
0761 except:
0762 self.__field_emails=LIST(**{'elementclass': _gen_p_lgpm325_139, 'length': NUMEMAILS})
0763 return self.__field_emails.getvalue()
0764
0765 def __setfield_emails(self, value):
0766 if isinstance(value,LIST):
0767 self.__field_emails=value
0768 else:
0769 self.__field_emails=LIST(value,**{'elementclass': _gen_p_lgpm325_139, 'length': NUMEMAILS})
0770
0771 def __delfield_emails(self): del self.__field_emails
0772
0773 emails=property(__getfield_emails, __setfield_emails, __delfield_emails, None)
0774
0775 def __getfield_url(self):
0776 return self.__field_url.getvalue()
0777
0778 def __setfield_url(self, value):
0779 if isinstance(value,USTRING):
0780 self.__field_url=value
0781 else:
0782 self.__field_url=USTRING(value,**{'sizeinbytes': 73, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})
0783
0784 def __delfield_url(self): del self.__field_url
0785
0786 url=property(__getfield_url, __setfield_url, __delfield_url, None)
0787
0788 def __getfield_numberspeeds(self):
0789 try: self.__field_numberspeeds
0790 except:
0791 self.__field_numberspeeds=LIST(**{'elementclass': _gen_p_lgpm325_142, 'length': NUMPHONENUMBERS})
0792 return self.__field_numberspeeds.getvalue()
0793
0794 def __setfield_numberspeeds(self, value):
0795 if isinstance(value,LIST):
0796 self.__field_numberspeeds=value
0797 else:
0798 self.__field_numberspeeds=LIST(value,**{'elementclass': _gen_p_lgpm325_142, 'length': NUMPHONENUMBERS})
0799
0800 def __delfield_numberspeeds(self): del self.__field_numberspeeds
0801
0802 numberspeeds=property(__getfield_numberspeeds, __setfield_numberspeeds, __delfield_numberspeeds, None)
0803
0804 def __getfield_numbertypes(self):
0805 try: self.__field_numbertypes
0806 except:
0807 self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lgpm325_144, 'length': NUMPHONENUMBERS})
0808 return self.__field_numbertypes.getvalue()
0809
0810 def __setfield_numbertypes(self, value):
0811 if isinstance(value,LIST):
0812 self.__field_numbertypes=value
0813 else:
0814 self.__field_numbertypes=LIST(value,**{'elementclass': _gen_p_lgpm325_144, 'length': NUMPHONENUMBERS})
0815
0816 def __delfield_numbertypes(self): del self.__field_numbertypes
0817
0818 numbertypes=property(__getfield_numbertypes, __setfield_numbertypes, __delfield_numbertypes, None)
0819
0820 def __getfield_numbers(self):
0821 try: self.__field_numbers
0822 except:
0823 self.__field_numbers=LIST(**{'elementclass': _gen_p_lgpm325_146, 'length': NUMPHONENUMBERS})
0824 return self.__field_numbers.getvalue()
0825
0826 def __setfield_numbers(self, value):
0827 if isinstance(value,LIST):
0828 self.__field_numbers=value
0829 else:
0830 self.__field_numbers=LIST(value,**{'elementclass': _gen_p_lgpm325_146, 'length': NUMPHONENUMBERS})
0831
0832 def __delfield_numbers(self): del self.__field_numbers
0833
0834 numbers=property(__getfield_numbers, __setfield_numbers, __delfield_numbers, None)
0835
0836 def __getfield_EndOfRecord(self):
0837 try: self.__field_EndOfRecord
0838 except:
0839 self.__field_EndOfRecord=UINT(**{'sizeinbytes': 1, 'constant': 0x78})
0840 return self.__field_EndOfRecord.getvalue()
0841
0842 def __setfield_EndOfRecord(self, value):
0843 if isinstance(value,UINT):
0844 self.__field_EndOfRecord=value
0845 else:
0846 self.__field_EndOfRecord=UINT(value,**{'sizeinbytes': 1, 'constant': 0x78})
0847
0848 def __delfield_EndOfRecord(self): del self.__field_EndOfRecord
0849
0850 EndOfRecord=property(__getfield_EndOfRecord, __setfield_EndOfRecord, __delfield_EndOfRecord, None)
0851
0852 def __getfield_ringtone(self):
0853 try: self.__field_ringtone
0854 except:
0855 self.__field_ringtone=UINT(**{'default': 0x600})
0856 return self.__field_ringtone.getvalue()
0857
0858 def __setfield_ringtone(self, value):
0859 if isinstance(value,UINT):
0860 self.__field_ringtone=value
0861 else:
0862 self.__field_ringtone=UINT(value,**{'default': 0x600})
0863
0864 def __delfield_ringtone(self): del self.__field_ringtone
0865
0866 ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None)
0867
0868 def __getfield_wallpaper(self):
0869 try: self.__field_wallpaper
0870 except:
0871 self.__field_wallpaper=UINT(**{'default': 0x100})
0872 return self.__field_wallpaper.getvalue()
0873
0874 def __setfield_wallpaper(self, value):
0875 if isinstance(value,UINT):
0876 self.__field_wallpaper=value
0877 else:
0878 self.__field_wallpaper=UINT(value,**{'default': 0x100})
0879
0880 def __delfield_wallpaper(self): del self.__field_wallpaper
0881
0882 wallpaper=property(__getfield_wallpaper, __setfield_wallpaper, __delfield_wallpaper, None)
0883
0884 def iscontainer(self):
0885 return True
0886
0887 def containerelements(self):
0888 yield ('serial1', self.__field_serial1, None)
0889 yield ('entrysize', self.__field_entrysize, None)
0890 yield ('entrynumber', self.__field_entrynumber, None)
0891 yield ('name', self.__field_name, None)
0892 yield ('group', self.__field_group, None)
0893 yield ('unknown2', self.__field_unknown2, None)
0894 yield ('secret', self.__field_secret, None)
0895 yield ('memo', self.__field_memo, None)
0896 yield ('emails', self.__field_emails, None)
0897 yield ('url', self.__field_url, None)
0898 yield ('numberspeeds', self.__field_numberspeeds, None)
0899 yield ('numbertypes', self.__field_numbertypes, None)
0900 yield ('numbers', self.__field_numbers, None)
0901 yield ('EndOfRecord', self.__field_EndOfRecord, None)
0902 yield ('ringtone', self.__field_ringtone, None)
0903 yield ('wallpaper', self.__field_wallpaper, None)
0904
0905
0906
0907
0908 class _gen_p_lgpm325_139(BaseProtogenClass):
0909 'Anonymous inner class'
0910 __fields=['email']
0911
0912 def __init__(self, *args, **kwargs):
0913 dict={}
0914 dict.update(kwargs)
0916 super(_gen_p_lgpm325_139,self).__init__(**dict)
0918 if self.__class__ is _gen_p_lgpm325_139:
0919 self._update(args,dict)
0920
0921
0922 def getfields(self):
0923 return self.__fields
0924
0925
0926 def _update(self, args, kwargs):
0927 super(_gen_p_lgpm325_139,self)._update(args,kwargs)
0928 keys=kwargs.keys()
0929 for key in keys:
0930 if key in self.__fields:
0931 setattr(self, key, kwargs[key])
0932 del kwargs[key]
0933 if __debug__:
0935 self._complainaboutunusedargs(_gen_p_lgpm325_139,kwargs)
0936 if len(args):
0937 dict2={'sizeinbytes': 73, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}
0938 dict2.update(kwargs)
0939 kwargs=dict2
0940 self.__field_email=USTRING(*args,**dict2)
0941
0943
0944 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0945 'Writes this packet to the supplied buffer'
0946 self._bufferstartoffset=buf.getcurrentoffset()
0947 self.__field_email.writetobuffer(buf)
0948 self._bufferendoffset=buf.getcurrentoffset()
0949 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0950
0951
0952 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0953 'Reads this packet from the supplied buffer'
0954 self._bufferstartoffset=buf.getcurrentoffset()
0955 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0956 self.__field_email=USTRING(**{'sizeinbytes': 73, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})
0957 self.__field_email.readfrombuffer(buf)
0958 self._bufferendoffset=buf.getcurrentoffset()
0959
0960
0961 def __getfield_email(self):
0962 return self.__field_email.getvalue()
0963
0964 def __setfield_email(self, value):
0965 if isinstance(value,USTRING):
0966 self.__field_email=value
0967 else:
0968 self.__field_email=USTRING(value,**{'sizeinbytes': 73, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})
0969
0970 def __delfield_email(self): del self.__field_email
0971
0972 email=property(__getfield_email, __setfield_email, __delfield_email, None)
0973
0974 def iscontainer(self):
0975 return True
0976
0977 def containerelements(self):
0978 yield ('email', self.__field_email, None)
0979
0980
0981
0982
0983 class _gen_p_lgpm325_142(BaseProtogenClass):
0984 'Anonymous inner class'
0985 __fields=['numberspeed']
0986
0987 def __init__(self, *args, **kwargs):
0988 dict={}
0989 dict.update(kwargs)
0991 super(_gen_p_lgpm325_142,self).__init__(**dict)
0993 if self.__class__ is _gen_p_lgpm325_142:
0994 self._update(args,dict)
0995
0996
0997 def getfields(self):
0998 return self.__fields
0999
1000
1001 def _update(self, args, kwargs):
1002 super(_gen_p_lgpm325_142,self)._update(args,kwargs)
1003 keys=kwargs.keys()
1004 for key in keys:
1005 if key in self.__fields:
1006 setattr(self, key, kwargs[key])
1007 del kwargs[key]
1008 if __debug__:
1010 self._complainaboutunusedargs(_gen_p_lgpm325_142,kwargs)
1011 if len(args):
1012 dict2={'sizeinbytes': 1}
1013 dict2.update(kwargs)
1014 kwargs=dict2
1015 self.__field_numberspeed=UINT(*args,**dict2)
1016
1018
1019 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1020 'Writes this packet to the supplied buffer'
1021 self._bufferstartoffset=buf.getcurrentoffset()
1022 self.__field_numberspeed.writetobuffer(buf)
1023 self._bufferendoffset=buf.getcurrentoffset()
1024 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1025
1026
1027 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1028 'Reads this packet from the supplied buffer'
1029 self._bufferstartoffset=buf.getcurrentoffset()
1030 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1031 self.__field_numberspeed=UINT(**{'sizeinbytes': 1})
1032 self.__field_numberspeed.readfrombuffer(buf)
1033 self._bufferendoffset=buf.getcurrentoffset()
1034
1035
1036 def __getfield_numberspeed(self):
1037 return self.__field_numberspeed.getvalue()
1038
1039 def __setfield_numberspeed(self, value):
1040 if isinstance(value,UINT):
1041 self.__field_numberspeed=value
1042 else:
1043 self.__field_numberspeed=UINT(value,**{'sizeinbytes': 1})
1044
1045 def __delfield_numberspeed(self): del self.__field_numberspeed
1046
1047 numberspeed=property(__getfield_numberspeed, __setfield_numberspeed, __delfield_numberspeed, None)
1048
1049 def iscontainer(self):
1050 return True
1051
1052 def containerelements(self):
1053 yield ('numberspeed', self.__field_numberspeed, None)
1054
1055
1056
1057
1058 class _gen_p_lgpm325_144(BaseProtogenClass):
1059 'Anonymous inner class'
1060 __fields=['numbertype']
1061
1062 def __init__(self, *args, **kwargs):
1063 dict={}
1064 dict.update(kwargs)
1066 super(_gen_p_lgpm325_144,self).__init__(**dict)
1068 if self.__class__ is _gen_p_lgpm325_144:
1069 self._update(args,dict)
1070
1071
1072 def getfields(self):
1073 return self.__fields
1074
1075
1076 def _update(self, args, kwargs):
1077 super(_gen_p_lgpm325_144,self)._update(args,kwargs)
1078 keys=kwargs.keys()
1079 for key in keys:
1080 if key in self.__fields:
1081 setattr(self, key, kwargs[key])
1082 del kwargs[key]
1083 if __debug__:
1085 self._complainaboutunusedargs(_gen_p_lgpm325_144,kwargs)
1086 if len(args):
1087 dict2={'sizeinbytes': 1}
1088 dict2.update(kwargs)
1089 kwargs=dict2
1090 self.__field_numbertype=UINT(*args,**dict2)
1091
1093
1094 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1095 'Writes this packet to the supplied buffer'
1096 self._bufferstartoffset=buf.getcurrentoffset()
1097 self.__field_numbertype.writetobuffer(buf)
1098 self._bufferendoffset=buf.getcurrentoffset()
1099 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1100
1101
1102 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1103 'Reads this packet from the supplied buffer'
1104 self._bufferstartoffset=buf.getcurrentoffset()
1105 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1106 self.__field_numbertype=UINT(**{'sizeinbytes': 1})
1107 self.__field_numbertype.readfrombuffer(buf)
1108 self._bufferendoffset=buf.getcurrentoffset()
1109
1110
1111 def __getfield_numbertype(self):
1112 return self.__field_numbertype.getvalue()
1113
1114 def __setfield_numbertype(self, value):
1115 if isinstance(value,UINT):
1116 self.__field_numbertype=value
1117 else:
1118 self.__field_numbertype=UINT(value,**{'sizeinbytes': 1})
1119
1120 def __delfield_numbertype(self): del self.__field_numbertype
1121
1122 numbertype=property(__getfield_numbertype, __setfield_numbertype, __delfield_numbertype, None)
1123
1124 def iscontainer(self):
1125 return True
1126
1127 def containerelements(self):
1128 yield ('numbertype', self.__field_numbertype, None)
1129
1130
1131
1132
1133 class _gen_p_lgpm325_146(BaseProtogenClass):
1134 'Anonymous inner class'
1135 __fields=['number']
1136
1137 def __init__(self, *args, **kwargs):
1138 dict={}
1139 dict.update(kwargs)
1141 super(_gen_p_lgpm325_146,self).__init__(**dict)
1143 if self.__class__ is _gen_p_lgpm325_146:
1144 self._update(args,dict)
1145
1146
1147 def getfields(self):
1148 return self.__fields
1149
1150
1151 def _update(self, args, kwargs):
1152 super(_gen_p_lgpm325_146,self)._update(args,kwargs)
1153 keys=kwargs.keys()
1154 for key in keys:
1155 if key in self.__fields:
1156 setattr(self, key, kwargs[key])
1157 del kwargs[key]
1158 if __debug__:
1160 self._complainaboutunusedargs(_gen_p_lgpm325_146,kwargs)
1161 if len(args):
1162 dict2={'sizeinbytes': 49, 'raiseonunterminatedread': False}
1163 dict2.update(kwargs)
1164 kwargs=dict2
1165 self.__field_number=USTRING(*args,**dict2)
1166
1168
1169 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1170 'Writes this packet to the supplied buffer'
1171 self._bufferstartoffset=buf.getcurrentoffset()
1172 self.__field_number.writetobuffer(buf)
1173 self._bufferendoffset=buf.getcurrentoffset()
1174 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1175
1176
1177 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1178 'Reads this packet from the supplied buffer'
1179 self._bufferstartoffset=buf.getcurrentoffset()
1180 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1181 self.__field_number=USTRING(**{'sizeinbytes': 49, 'raiseonunterminatedread': False})
1182 self.__field_number.readfrombuffer(buf)
1183 self._bufferendoffset=buf.getcurrentoffset()
1184
1185
1186 def __getfield_number(self):
1187 return self.__field_number.getvalue()
1188
1189 def __setfield_number(self, value):
1190 if isinstance(value,USTRING):
1191 self.__field_number=value
1192 else:
1193 self.__field_number=USTRING(value,**{'sizeinbytes': 49, 'raiseonunterminatedread': False})
1194
1195 def __delfield_number(self): del self.__field_number
1196
1197 number=property(__getfield_number, __setfield_number, __delfield_number, None)
1198
1199 def iscontainer(self):
1200 return True
1201
1202 def containerelements(self):
1203 yield ('number', self.__field_number, None)
1204
1205
1206
1207
1208 class pbgroup(BaseProtogenClass):
1209 "A single group"
1210 __fields=['group_id', 'rectype', 'unknown2', 'unknown3', 'name']
1211
1212 def __init__(self, *args, **kwargs):
1213 dict={}
1214 dict.update(kwargs)
1216 super(pbgroup,self).__init__(**dict)
1218 if self.__class__ is pbgroup:
1219 self._update(args,dict)
1220
1221
1222 def getfields(self):
1223 return self.__fields
1224
1225
1226 def _update(self, args, kwargs):
1227 super(pbgroup,self)._update(args,kwargs)
1228 keys=kwargs.keys()
1229 for key in keys:
1230 if key in self.__fields:
1231 setattr(self, key, kwargs[key])
1232 del kwargs[key]
1233 if __debug__:
1235 self._complainaboutunusedargs(pbgroup,kwargs)
1236 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1237
1239
1240 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1241 'Writes this packet to the supplied buffer'
1242 self._bufferstartoffset=buf.getcurrentoffset()
1243 self.__field_group_id.writetobuffer(buf)
1244 self.__field_rectype.writetobuffer(buf)
1245 try: self.__field_unknown2
1246 except:
1247 self.__field_unknown2=UNKNOWN(**{'sizeinbytes': 3})
1248 self.__field_unknown2.writetobuffer(buf)
1249 try: self.__field_unknown3
1250 except:
1251 self.__field_unknown3=UNKNOWN(**{'sizeinbytes': 3})
1252 self.__field_unknown3.writetobuffer(buf)
1253 self.__field_name.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_group_id=UINT(**{'sizeinbytes': 1})
1263 self.__field_group_id.readfrombuffer(buf)
1264 self.__field_rectype=UINT(**{'sizeinbytes': 1})
1265 self.__field_rectype.readfrombuffer(buf)
1266 self.__field_unknown2=UNKNOWN(**{'sizeinbytes': 3})
1267 self.__field_unknown2.readfrombuffer(buf)
1268 self.__field_unknown3=UNKNOWN(**{'sizeinbytes': 3})
1269 self.__field_unknown3.readfrombuffer(buf)
1270 self.__field_name=USTRING(**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})
1271 self.__field_name.readfrombuffer(buf)
1272 self._bufferendoffset=buf.getcurrentoffset()
1273
1274
1275 def __getfield_group_id(self):
1276 return self.__field_group_id.getvalue()
1277
1278 def __setfield_group_id(self, value):
1279 if isinstance(value,UINT):
1280 self.__field_group_id=value
1281 else:
1282 self.__field_group_id=UINT(value,**{'sizeinbytes': 1})
1283
1284 def __delfield_group_id(self): del self.__field_group_id
1285
1286 group_id=property(__getfield_group_id, __setfield_group_id, __delfield_group_id, None)
1287
1288 def __getfield_rectype(self):
1289 return self.__field_rectype.getvalue()
1290
1291 def __setfield_rectype(self, value):
1292 if isinstance(value,UINT):
1293 self.__field_rectype=value
1294 else:
1295 self.__field_rectype=UINT(value,**{'sizeinbytes': 1})
1296
1297 def __delfield_rectype(self): del self.__field_rectype
1298
1299 rectype=property(__getfield_rectype, __setfield_rectype, __delfield_rectype, None)
1300
1301 def __getfield_unknown2(self):
1302 try: self.__field_unknown2
1303 except:
1304 self.__field_unknown2=UNKNOWN(**{'sizeinbytes': 3})
1305 return self.__field_unknown2.getvalue()
1306
1307 def __setfield_unknown2(self, value):
1308 if isinstance(value,UNKNOWN):
1309 self.__field_unknown2=value
1310 else:
1311 self.__field_unknown2=UNKNOWN(value,**{'sizeinbytes': 3})
1312
1313 def __delfield_unknown2(self): del self.__field_unknown2
1314
1315 unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None)
1316
1317 def __getfield_unknown3(self):
1318 try: self.__field_unknown3
1319 except:
1320 self.__field_unknown3=UNKNOWN(**{'sizeinbytes': 3})
1321 return self.__field_unknown3.getvalue()
1322
1323 def __setfield_unknown3(self, value):
1324 if isinstance(value,UNKNOWN):
1325 self.__field_unknown3=value
1326 else:
1327 self.__field_unknown3=UNKNOWN(value,**{'sizeinbytes': 3})
1328
1329 def __delfield_unknown3(self): del self.__field_unknown3
1330
1331 unknown3=property(__getfield_unknown3, __setfield_unknown3, __delfield_unknown3, None)
1332
1333 def __getfield_name(self):
1334 return self.__field_name.getvalue()
1335
1336 def __setfield_name(self, value):
1337 if isinstance(value,USTRING):
1338 self.__field_name=value
1339 else:
1340 self.__field_name=USTRING(value,**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})
1341
1342 def __delfield_name(self): del self.__field_name
1343
1344 name=property(__getfield_name, __setfield_name, __delfield_name, None)
1345
1346 def iscontainer(self):
1347 return True
1348
1349 def containerelements(self):
1350 yield ('group_id', self.__field_group_id, None)
1351 yield ('rectype', self.__field_rectype, None)
1352 yield ('unknown2', self.__field_unknown2, None)
1353 yield ('unknown3', self.__field_unknown3, None)
1354 yield ('name', self.__field_name, None)
1355
1356
1357
1358
1359 class pbgroups(BaseProtogenClass):
1360 "Phonebook groups"
1361 __fields=['groups']
1362
1363 def __init__(self, *args, **kwargs):
1364 dict={}
1365 dict.update(kwargs)
1367 super(pbgroups,self).__init__(**dict)
1369 if self.__class__ is pbgroups:
1370 self._update(args,dict)
1371
1372
1373 def getfields(self):
1374 return self.__fields
1375
1376
1377 def _update(self, args, kwargs):
1378 super(pbgroups,self)._update(args,kwargs)
1379 keys=kwargs.keys()
1380 for key in keys:
1381 if key in self.__fields:
1382 setattr(self, key, kwargs[key])
1383 del kwargs[key]
1384 if __debug__:
1386 self._complainaboutunusedargs(pbgroups,kwargs)
1387 if len(args):
1388 dict2={'elementclass': pbgroup}
1389 dict2.update(kwargs)
1390 kwargs=dict2
1391 self.__field_groups=LIST(*args,**dict2)
1392
1394
1395 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1396 'Writes this packet to the supplied buffer'
1397 self._bufferstartoffset=buf.getcurrentoffset()
1398 try: self.__field_groups
1399 except:
1400 self.__field_groups=LIST(**{'elementclass': pbgroup})
1401 self.__field_groups.writetobuffer(buf)
1402 self._bufferendoffset=buf.getcurrentoffset()
1403 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1404
1405
1406 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1407 'Reads this packet from the supplied buffer'
1408 self._bufferstartoffset=buf.getcurrentoffset()
1409 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1410 self.__field_groups=LIST(**{'elementclass': pbgroup})
1411 self.__field_groups.readfrombuffer(buf)
1412 self._bufferendoffset=buf.getcurrentoffset()
1413
1414
1415 def __getfield_groups(self):
1416 try: self.__field_groups
1417 except:
1418 self.__field_groups=LIST(**{'elementclass': pbgroup})
1419 return self.__field_groups.getvalue()
1420
1421 def __setfield_groups(self, value):
1422 if isinstance(value,LIST):
1423 self.__field_groups=value
1424 else:
1425 self.__field_groups=LIST(value,**{'elementclass': pbgroup})
1426
1427 def __delfield_groups(self): del self.__field_groups
1428
1429 groups=property(__getfield_groups, __setfield_groups, __delfield_groups, None)
1430
1431 def iscontainer(self):
1432 return True
1433
1434 def containerelements(self):
1435 yield ('groups', self.__field_groups, None)
1436
1437
1438
1439
1440 class pb_contact_media_entry(BaseProtogenClass):
1441 """Reads the wallpaper/ringer info for each contact on the phone"""
1442 __fields=['index', 'dont_care1', 'ringer', 'name', 'dont_care2', 'wallpaper', 'dont_care3']
1443
1444 def __init__(self, *args, **kwargs):
1445 dict={}
1446 dict.update(kwargs)
1448 super(pb_contact_media_entry,self).__init__(**dict)
1450 if self.__class__ is pb_contact_media_entry:
1451 self._update(args,dict)
1452
1453
1454 def getfields(self):
1455 return self.__fields
1456
1457
1458 def _update(self, args, kwargs):
1459 super(pb_contact_media_entry,self)._update(args,kwargs)
1460 keys=kwargs.keys()
1461 for key in keys:
1462 if key in self.__fields:
1463 setattr(self, key, kwargs[key])
1464 del kwargs[key]
1465 if __debug__:
1467 self._complainaboutunusedargs(pb_contact_media_entry,kwargs)
1468 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1469
1471
1472 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1473 'Writes this packet to the supplied buffer'
1474 self._bufferstartoffset=buf.getcurrentoffset()
1475 self.__field_index.writetobuffer(buf)
1476 self.__field_dont_care1.writetobuffer(buf)
1477 self.__field_ringer.writetobuffer(buf)
1478 self.__field_name.writetobuffer(buf)
1479 self.__field_dont_care2.writetobuffer(buf)
1480 self.__field_wallpaper.writetobuffer(buf)
1481 self.__field_dont_care3.writetobuffer(buf)
1482 self._bufferendoffset=buf.getcurrentoffset()
1483 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1484
1485
1486 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1487 'Reads this packet from the supplied buffer'
1488 self._bufferstartoffset=buf.getcurrentoffset()
1489 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1490 self.__field_index=UINT(**{'sizeinbytes': 2})
1491 self.__field_index.readfrombuffer(buf)
1492 self.__field_dont_care1=DATA(**{'sizeinbytes': 18})
1493 self.__field_dont_care1.readfrombuffer(buf)
1494 self.__field_ringer=UINT(**{'sizeinbytes': 2})
1495 self.__field_ringer.readfrombuffer(buf)
1496 self.__field_name=USTRING(**{'sizeinbytes': 33})
1497 self.__field_name.readfrombuffer(buf)
1498 self.__field_dont_care2=DATA(**{'sizeinbytes': 182})
1499 self.__field_dont_care2.readfrombuffer(buf)
1500 self.__field_wallpaper=UINT(**{'sizeinbytes': 2})
1501 self.__field_wallpaper.readfrombuffer(buf)
1502 self.__field_dont_care3=DATA(**{'sizeinbytes': 4})
1503 self.__field_dont_care3.readfrombuffer(buf)
1504 self._bufferendoffset=buf.getcurrentoffset()
1505
1506
1507 def __getfield_index(self):
1508 return self.__field_index.getvalue()
1509
1510 def __setfield_index(self, value):
1511 if isinstance(value,UINT):
1512 self.__field_index=value
1513 else:
1514 self.__field_index=UINT(value,**{'sizeinbytes': 2})
1515
1516 def __delfield_index(self): del self.__field_index
1517
1518 index=property(__getfield_index, __setfield_index, __delfield_index, None)
1519
1520 def __getfield_dont_care1(self):
1521 return self.__field_dont_care1.getvalue()
1522
1523 def __setfield_dont_care1(self, value):
1524 if isinstance(value,DATA):
1525 self.__field_dont_care1=value
1526 else:
1527 self.__field_dont_care1=DATA(value,**{'sizeinbytes': 18})
1528
1529 def __delfield_dont_care1(self): del self.__field_dont_care1
1530
1531 dont_care1=property(__getfield_dont_care1, __setfield_dont_care1, __delfield_dont_care1, None)
1532
1533 def __getfield_ringer(self):
1534 return self.__field_ringer.getvalue()
1535
1536 def __setfield_ringer(self, value):
1537 if isinstance(value,UINT):
1538 self.__field_ringer=value
1539 else:
1540 self.__field_ringer=UINT(value,**{'sizeinbytes': 2})
1541
1542 def __delfield_ringer(self): del self.__field_ringer
1543
1544 ringer=property(__getfield_ringer, __setfield_ringer, __delfield_ringer, None)
1545
1546 def __getfield_name(self):
1547 return self.__field_name.getvalue()
1548
1549 def __setfield_name(self, value):
1550 if isinstance(value,USTRING):
1551 self.__field_name=value
1552 else:
1553 self.__field_name=USTRING(value,**{'sizeinbytes': 33})
1554
1555 def __delfield_name(self): del self.__field_name
1556
1557 name=property(__getfield_name, __setfield_name, __delfield_name, None)
1558
1559 def __getfield_dont_care2(self):
1560 return self.__field_dont_care2.getvalue()
1561
1562 def __setfield_dont_care2(self, value):
1563 if isinstance(value,DATA):
1564 self.__field_dont_care2=value
1565 else:
1566 self.__field_dont_care2=DATA(value,**{'sizeinbytes': 182})
1567
1568 def __delfield_dont_care2(self): del self.__field_dont_care2
1569
1570 dont_care2=property(__getfield_dont_care2, __setfield_dont_care2, __delfield_dont_care2, None)
1571
1572 def __getfield_wallpaper(self):
1573 return self.__field_wallpaper.getvalue()
1574
1575 def __setfield_wallpaper(self, value):
1576 if isinstance(value,UINT):
1577 self.__field_wallpaper=value
1578 else:
1579 self.__field_wallpaper=UINT(value,**{'sizeinbytes': 2})
1580
1581 def __delfield_wallpaper(self): del self.__field_wallpaper
1582
1583 wallpaper=property(__getfield_wallpaper, __setfield_wallpaper, __delfield_wallpaper, None)
1584
1585 def __getfield_dont_care3(self):
1586 return self.__field_dont_care3.getvalue()
1587
1588 def __setfield_dont_care3(self, value):
1589 if isinstance(value,DATA):
1590 self.__field_dont_care3=value
1591 else:
1592 self.__field_dont_care3=DATA(value,**{'sizeinbytes': 4})
1593
1594 def __delfield_dont_care3(self): del self.__field_dont_care3
1595
1596 dont_care3=property(__getfield_dont_care3, __setfield_dont_care3, __delfield_dont_care3, None)
1597
1598 def iscontainer(self):
1599 return True
1600
1601 def containerelements(self):
1602 yield ('index', self.__field_index, None)
1603 yield ('dont_care1', self.__field_dont_care1, None)
1604 yield ('ringer', self.__field_ringer, None)
1605 yield ('name', self.__field_name, None)
1606 yield ('dont_care2', self.__field_dont_care2, None)
1607 yield ('wallpaper', self.__field_wallpaper, None)
1608 yield ('dont_care3', self.__field_dont_care3, None)
1609
1610
1611
1612
1613 class pb_contact_media_file(BaseProtogenClass):
1614 __fields=['contacts']
1615
1616 def __init__(self, *args, **kwargs):
1617 dict={}
1618 dict.update(kwargs)
1620 super(pb_contact_media_file,self).__init__(**dict)
1622 if self.__class__ is pb_contact_media_file:
1623 self._update(args,dict)
1624
1625
1626 def getfields(self):
1627 return self.__fields
1628
1629
1630 def _update(self, args, kwargs):
1631 super(pb_contact_media_file,self)._update(args,kwargs)
1632 keys=kwargs.keys()
1633 for key in keys:
1634 if key in self.__fields:
1635 setattr(self, key, kwargs[key])
1636 del kwargs[key]
1637 if __debug__:
1639 self._complainaboutunusedargs(pb_contact_media_file,kwargs)
1640 if len(args):
1641 dict2={'elementclass': pb_contact_media_entry}
1642 dict2.update(kwargs)
1643 kwargs=dict2
1644 self.__field_contacts=LIST(*args,**dict2)
1645
1647
1648 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1649 'Writes this packet to the supplied buffer'
1650 self._bufferstartoffset=buf.getcurrentoffset()
1651 try: self.__field_contacts
1652 except:
1653 self.__field_contacts=LIST(**{'elementclass': pb_contact_media_entry})
1654 self.__field_contacts.writetobuffer(buf)
1655 self._bufferendoffset=buf.getcurrentoffset()
1656 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1657
1658
1659 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1660 'Reads this packet from the supplied buffer'
1661 self._bufferstartoffset=buf.getcurrentoffset()
1662 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1663 self.__field_contacts=LIST(**{'elementclass': pb_contact_media_entry})
1664 self.__field_contacts.readfrombuffer(buf)
1665 self._bufferendoffset=buf.getcurrentoffset()
1666
1667
1668 def __getfield_contacts(self):
1669 try: self.__field_contacts
1670 except:
1671 self.__field_contacts=LIST(**{'elementclass': pb_contact_media_entry})
1672 return self.__field_contacts.getvalue()
1673
1674 def __setfield_contacts(self, value):
1675 if isinstance(value,LIST):
1676 self.__field_contacts=value
1677 else:
1678 self.__field_contacts=LIST(value,**{'elementclass': pb_contact_media_entry})
1679
1680 def __delfield_contacts(self): del self.__field_contacts
1681
1682 contacts=property(__getfield_contacts, __setfield_contacts, __delfield_contacts, None)
1683
1684 def iscontainer(self):
1685 return True
1686
1687 def containerelements(self):
1688 yield ('contacts', self.__field_contacts, None)
1689
1690
1691
1692
1693 class scheduleexception(BaseProtogenClass):
1694 __fields=['pos', 'day', 'month', 'year']
1695
1696 def __init__(self, *args, **kwargs):
1697 dict={}
1698 dict.update(kwargs)
1700 super(scheduleexception,self).__init__(**dict)
1702 if self.__class__ is scheduleexception:
1703 self._update(args,dict)
1704
1705
1706 def getfields(self):
1707 return self.__fields
1708
1709
1710 def _update(self, args, kwargs):
1711 super(scheduleexception,self)._update(args,kwargs)
1712 keys=kwargs.keys()
1713 for key in keys:
1714 if key in self.__fields:
1715 setattr(self, key, kwargs[key])
1716 del kwargs[key]
1717 if __debug__:
1719 self._complainaboutunusedargs(scheduleexception,kwargs)
1720 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1721
1723
1724 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1725 'Writes this packet to the supplied buffer'
1726 self._bufferstartoffset=buf.getcurrentoffset()
1727 self.__field_pos.writetobuffer(buf)
1728 self.__field_day.writetobuffer(buf)
1729 self.__field_month.writetobuffer(buf)
1730 self.__field_year.writetobuffer(buf)
1731 self._bufferendoffset=buf.getcurrentoffset()
1732 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1733
1734
1735 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1736 'Reads this packet from the supplied buffer'
1737 self._bufferstartoffset=buf.getcurrentoffset()
1738 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1739 self.__field_pos=UINT(**{'sizeinbytes': 4})
1740 self.__field_pos.readfrombuffer(buf)
1741 self.__field_day=UINT(**{'sizeinbytes': 1})
1742 self.__field_day.readfrombuffer(buf)
1743 self.__field_month=UINT(**{'sizeinbytes': 1})
1744 self.__field_month.readfrombuffer(buf)
1745 self.__field_year=UINT(**{'sizeinbytes': 2})
1746 self.__field_year.readfrombuffer(buf)
1747 self._bufferendoffset=buf.getcurrentoffset()
1748
1749
1750 def __getfield_pos(self):
1751 return self.__field_pos.getvalue()
1752
1753 def __setfield_pos(self, value):
1754 if isinstance(value,UINT):
1755 self.__field_pos=value
1756 else:
1757 self.__field_pos=UINT(value,**{'sizeinbytes': 4})
1758
1759 def __delfield_pos(self): del self.__field_pos
1760
1761 pos=property(__getfield_pos, __setfield_pos, __delfield_pos, "Refers to event id (position in schedule file) that this suppresses")
1762
1763 def __getfield_day(self):
1764 return self.__field_day.getvalue()
1765
1766 def __setfield_day(self, value):
1767 if isinstance(value,UINT):
1768 self.__field_day=value
1769 else:
1770 self.__field_day=UINT(value,**{'sizeinbytes': 1})
1771
1772 def __delfield_day(self): del self.__field_day
1773
1774 day=property(__getfield_day, __setfield_day, __delfield_day, None)
1775
1776 def __getfield_month(self):
1777 return self.__field_month.getvalue()
1778
1779 def __setfield_month(self, value):
1780 if isinstance(value,UINT):
1781 self.__field_month=value
1782 else:
1783 self.__field_month=UINT(value,**{'sizeinbytes': 1})
1784
1785 def __delfield_month(self): del self.__field_month
1786
1787 month=property(__getfield_month, __setfield_month, __delfield_month, None)
1788
1789 def __getfield_year(self):
1790 return self.__field_year.getvalue()
1791
1792 def __setfield_year(self, value):
1793 if isinstance(value,UINT):
1794 self.__field_year=value
1795 else:
1796 self.__field_year=UINT(value,**{'sizeinbytes': 2})
1797
1798 def __delfield_year(self): del self.__field_year
1799
1800 year=property(__getfield_year, __setfield_year, __delfield_year, None)
1801
1802 def iscontainer(self):
1803 return True
1804
1805 def containerelements(self):
1806 yield ('pos', self.__field_pos, "Refers to event id (position in schedule file) that this suppresses")
1807 yield ('day', self.__field_day, None)
1808 yield ('month', self.__field_month, None)
1809 yield ('year', self.__field_year, None)
1810
1811
1812
1813
1814 class scheduleexceptionfile(BaseProtogenClass):
1815 __fields=['items']
1816
1817 def __init__(self, *args, **kwargs):
1818 dict={}
1819 dict.update(kwargs)
1821 super(scheduleexceptionfile,self).__init__(**dict)
1823 if self.__class__ is scheduleexceptionfile:
1824 self._update(args,dict)
1825
1826
1827 def getfields(self):
1828 return self.__fields
1829
1830
1831 def _update(self, args, kwargs):
1832 super(scheduleexceptionfile,self)._update(args,kwargs)
1833 keys=kwargs.keys()
1834 for key in keys:
1835 if key in self.__fields:
1836 setattr(self, key, kwargs[key])
1837 del kwargs[key]
1838 if __debug__:
1840 self._complainaboutunusedargs(scheduleexceptionfile,kwargs)
1841 if len(args):
1842 dict2={'elementclass': scheduleexception}
1843 dict2.update(kwargs)
1844 kwargs=dict2
1845 self.__field_items=LIST(*args,**dict2)
1846
1848
1849 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1850 'Writes this packet to the supplied buffer'
1851 self._bufferstartoffset=buf.getcurrentoffset()
1852 try: self.__field_items
1853 except:
1854 self.__field_items=LIST(**{'elementclass': scheduleexception})
1855 self.__field_items.writetobuffer(buf)
1856 self._bufferendoffset=buf.getcurrentoffset()
1857 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1858
1859
1860 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1861 'Reads this packet from the supplied buffer'
1862 self._bufferstartoffset=buf.getcurrentoffset()
1863 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1864 self.__field_items=LIST(**{'elementclass': scheduleexception})
1865 self.__field_items.readfrombuffer(buf)
1866 self._bufferendoffset=buf.getcurrentoffset()
1867
1868
1869 def __getfield_items(self):
1870 try: self.__field_items
1871 except:
1872 self.__field_items=LIST(**{'elementclass': scheduleexception})
1873 return self.__field_items.getvalue()
1874
1875 def __setfield_items(self, value):
1876 if isinstance(value,LIST):
1877 self.__field_items=value
1878 else:
1879 self.__field_items=LIST(value,**{'elementclass': scheduleexception})
1880
1881 def __delfield_items(self): del self.__field_items
1882
1883 items=property(__getfield_items, __setfield_items, __delfield_items, None)
1884
1885 def iscontainer(self):
1886 return True
1887
1888 def containerelements(self):
1889 yield ('items', self.__field_items, None)
1890
1891
1892
1893
1894 class scheduleevent(BaseProtogenClass):
1895 __fields=['packet_size', 'pos', 'start', 'end', 'repeat', 'daybitmap', 'pad2', 'alarmminutes', 'alarmhours', 'alarmtype', 'snoozedelay', 'ringtone', 'pad3', 'description']
1896
1897 def __init__(self, *args, **kwargs):
1898 dict={}
1899 dict.update(kwargs)
1901 super(scheduleevent,self).__init__(**dict)
1903 if self.__class__ is scheduleevent:
1904 self._update(args,dict)
1905
1906
1907 def getfields(self):
1908 return self.__fields
1909
1910
1911 def _update(self, args, kwargs):
1912 super(scheduleevent,self)._update(args,kwargs)
1913 keys=kwargs.keys()
1914 for key in keys:
1915 if key in self.__fields:
1916 setattr(self, key, kwargs[key])
1917 del kwargs[key]
1918 if __debug__:
1920 self._complainaboutunusedargs(scheduleevent,kwargs)
1921 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1922 try: self.__field_packet_size
1924 except:
1925 self.__field_packet_size=UINT(**{ 'constant': 64 })
1926
1927
1928 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1929 'Writes this packet to the supplied buffer'
1930 self._bufferstartoffset=buf.getcurrentoffset()
1931 self.__field_pos.writetobuffer(buf)
1932 self.__field_start.writetobuffer(buf)
1933 self.__field_end.writetobuffer(buf)
1934 self.__field_repeat.writetobuffer(buf)
1935 self.__field_daybitmap.writetobuffer(buf)
1936 try: self.__field_pad2
1937 except:
1938 self.__field_pad2=UINT(**{'sizeinbytes': 1, 'default': 0 })
1939 self.__field_pad2.writetobuffer(buf)
1940 self.__field_alarmminutes.writetobuffer(buf)
1941 self.__field_alarmhours.writetobuffer(buf)
1942 self.__field_alarmtype.writetobuffer(buf)
1943 try: self.__field_snoozedelay
1944 except:
1945 self.__field_snoozedelay=UINT(**{'sizeinbytes': 1, 'default': 0 })
1946 self.__field_snoozedelay.writetobuffer(buf)
1947 self.__field_ringtone.writetobuffer(buf)
1948 try: self.__field_pad3
1949 except:
1950 self.__field_pad3=UINT(**{'sizeinbytes': 1, 'default': 0 })
1951 self.__field_pad3.writetobuffer(buf)
1952 self.__field_description.writetobuffer(buf)
1953 self._bufferendoffset=buf.getcurrentoffset()
1954 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1955
1956
1957 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1958 'Reads this packet from the supplied buffer'
1959 self._bufferstartoffset=buf.getcurrentoffset()
1960 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1961 self.__field_pos=UINT(**{'sizeinbytes': 4})
1962 self.__field_pos.readfrombuffer(buf)
1963 self.__field_start=LGCALDATE(**{'sizeinbytes': 4})
1964 self.__field_start.readfrombuffer(buf)
1965 self.__field_end=LGCALDATE(**{'sizeinbytes': 4})
1966 self.__field_end.readfrombuffer(buf)
1967 self.__field_repeat=UINT(**{'sizeinbytes': 1})
1968 self.__field_repeat.readfrombuffer(buf)
1969 self.__field_daybitmap=UINT(**{'sizeinbytes': 2})
1970 self.__field_daybitmap.readfrombuffer(buf)
1971 self.__field_pad2=UINT(**{'sizeinbytes': 1, 'default': 0 })
1972 self.__field_pad2.readfrombuffer(buf)
1973 self.__field_alarmminutes=UINT(**{'sizeinbytes': 1})
1974 self.__field_alarmminutes.readfrombuffer(buf)
1975 self.__field_alarmhours=UINT(**{'sizeinbytes': 1})
1976 self.__field_alarmhours.readfrombuffer(buf)
1977 self.__field_alarmtype=UINT(**{'sizeinbytes': 1})
1978 self.__field_alarmtype.readfrombuffer(buf)
1979 self.__field_snoozedelay=UINT(**{'sizeinbytes': 1, 'default': 0 })
1980 self.__field_snoozedelay.readfrombuffer(buf)
1981 self.__field_ringtone=UINT(**{'sizeinbytes': 1})
1982 self.__field_ringtone.readfrombuffer(buf)
1983 self.__field_pad3=UINT(**{'sizeinbytes': 1, 'default': 0 })
1984 self.__field_pad3.readfrombuffer(buf)
1985 self.__field_description=USTRING(**{'sizeinbytes': 42, 'encoding': PHONE_ENCODING, 'raiseontruncate': False, 'raiseonunterminatedread': False })
1986 self.__field_description.readfrombuffer(buf)
1987 self._bufferendoffset=buf.getcurrentoffset()
1988
1989
1990 def __getfield_packet_size(self):
1991 return self.__field_packet_size.getvalue()
1992
1993 def __setfield_packet_size(self, value):
1994 if isinstance(value,UINT):
1995 self.__field_packet_size=value
1996 else:
1997 self.__field_packet_size=UINT(value,**{ 'constant': 64 })
1998
1999 def __delfield_packet_size(self): del self.__field_packet_size
2000
2001 packet_size=property(__getfield_packet_size, __setfield_packet_size, __delfield_packet_size, "Faster than packetsize()")
2002
2003 def __getfield_pos(self):
2004 return self.__field_pos.getvalue()
2005
2006 def __setfield_pos(self, value):
2007 if isinstance(value,UINT):
2008 self.__field_pos=value
2009 else:
2010 self.__field_pos=UINT(value,**{'sizeinbytes': 4})
2011
2012 def __delfield_pos(self): del self.__field_pos
2013
2014 pos=property(__getfield_pos, __setfield_pos, __delfield_pos, "position within file, used as an event id")
2015
2016 def __getfield_start(self):
2017 return self.__field_start.getvalue()
2018
2019 def __setfield_start(self, value):
2020 if isinstance(value,LGCALDATE):
2021 self.__field_start=value
2022 else:
2023 self.__field_start=LGCALDATE(value,**{'sizeinbytes': 4})
2024
2025 def __delfield_start(self): del self.__field_start
2026
2027 start=property(__getfield_start, __setfield_start, __delfield_start, None)
2028
2029 def __getfield_end(self):
2030 return self.__field_end.getvalue()
2031
2032 def __setfield_end(self, value):
2033 if isinstance(value,LGCALDATE):
2034 self.__field_end=value
2035 else:
2036 self.__field_end=LGCALDATE(value,**{'sizeinbytes': 4})
2037
2038 def __delfield_end(self): del self.__field_end
2039
2040 end=property(__getfield_end, __setfield_end, __delfield_end, None)
2041
2042 def __getfield_repeat(self):
2043 return self.__field_repeat.getvalue()
2044
2045 def __setfield_repeat(self, value):
2046 if isinstance(value,UINT):
2047 self.__field_repeat=value
2048 else:
2049 self.__field_repeat=UINT(value,**{'sizeinbytes': 1})
2050
2051 def __delfield_repeat(self): del self.__field_repeat
2052
2053 repeat=property(__getfield_repeat, __setfield_repeat, __delfield_repeat, None)
2054
2055 def __getfield_daybitmap(self):
2056 return self.__field_daybitmap.getvalue()
2057
2058 def __setfield_daybitmap(self, value):
2059 if isinstance(value,UINT):
2060 self.__field_daybitmap=value
2061 else:
2062 self.__field_daybitmap=UINT(value,**{'sizeinbytes': 2})
2063
2064 def __delfield_daybitmap(self): del self.__field_daybitmap
2065
2066 daybitmap=property(__getfield_daybitmap, __setfield_daybitmap, __delfield_daybitmap, "which days a weekly repeat event happens on")
2067
2068 def __getfield_pad2(self):
2069 try: self.__field_pad2
2070 except:
2071 self.__field_pad2=UINT(**{'sizeinbytes': 1, 'default': 0 })
2072 return self.__field_pad2.getvalue()
2073
2074 def __setfield_pad2(self, value):
2075 if isinstance(value,UINT):
2076 self.__field_pad2=value
2077 else:
2078 self.__field_pad2=UINT(value,**{'sizeinbytes': 1, 'default': 0 })
2079
2080 def __delfield_pad2(self): del self.__field_pad2
2081
2082 pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None)
2083
2084 def __getfield_alarmminutes(self):
2085 return self.__field_alarmminutes.getvalue()
2086
2087 def __setfield_alarmminutes(self, value):
2088 if isinstance(value,UINT):
2089 self.__field_alarmminutes=value
2090 else:
2091 self.__field_alarmminutes=UINT(value,**{'sizeinbytes': 1})
2092
2093 def __delfield_alarmminutes(self): del self.__field_alarmminutes
2094
2095 alarmminutes=property(__getfield_alarmminutes, __setfield_alarmminutes, __delfield_alarmminutes, "a value of 100 indicates not set")
2096
2097 def __getfield_alarmhours(self):
2098 return self.__field_alarmhours.getvalue()
2099
2100 def __setfield_alarmhours(self, value):
2101 if isinstance(value,UINT):
2102 self.__field_alarmhours=value
2103 else:
2104 self.__field_alarmhours=UINT(value,**{'sizeinbytes': 1})
2105
2106 def __delfield_alarmhours(self): del self.__field_alarmhours
2107
2108 alarmhours=property(__getfield_alarmhours, __setfield_alarmhours, __delfield_alarmhours, "a value of 100 indicates not set")
2109
2110 def __getfield_alarmtype(self):
2111 return self.__field_alarmtype.getvalue()
2112
2113 def __setfield_alarmtype(self, value):
2114 if isinstance(value,UINT):
2115 self.__field_alarmtype=value
2116 else:
2117 self.__field_alarmtype=UINT(value,**{'sizeinbytes': 1})
2118
2119 def __delfield_alarmtype(self): del self.__field_alarmtype
2120
2121 alarmtype=property(__getfield_alarmtype, __setfield_alarmtype, __delfield_alarmtype, "preset alarm reminder type")
2122
2123 def __getfield_snoozedelay(self):
2124 try: self.__field_snoozedelay
2125 except:
2126 self.__field_snoozedelay=UINT(**{'sizeinbytes': 1, 'default': 0 })
2127 return self.__field_snoozedelay.getvalue()
2128
2129 def __setfield_snoozedelay(self, value):
2130 if isinstance(value,UINT):
2131 self.__field_snoozedelay=value
2132 else:
2133 self.__field_snoozedelay=UINT(value,**{'sizeinbytes': 1, 'default': 0 })
2134
2135 def __delfield_snoozedelay(self): del self.__field_snoozedelay
2136
2137 snoozedelay=property(__getfield_snoozedelay, __setfield_snoozedelay, __delfield_snoozedelay, "in minutes, not for this phone")
2138
2139 def __getfield_ringtone(self):
2140 return self.__field_ringtone.getvalue()
2141
2142 def __setfield_ringtone(self, value):
2143 if isinstance(value,UINT):
2144 self.__field_ringtone=value
2145 else:
2146 self.__field_ringtone=UINT(value,**{'sizeinbytes': 1})
2147
2148 def __delfield_ringtone(self): del self.__field_ringtone
2149
2150 ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None)
2151
2152 def __getfield_pad3(self):
2153 try: self.__field_pad3
2154 except:
2155 self.__field_pad3=UINT(**{'sizeinbytes': 1, 'default': 0 })
2156 return self.__field_pad3.getvalue()
2157
2158 def __setfield_pad3(self, value):
2159 if isinstance(value,UINT):
2160 self.__field_pad3=value
2161 else:
2162 self.__field_pad3=UINT(value,**{'sizeinbytes': 1, 'default': 0 })
2163
2164 def __delfield_pad3(self): del self.__field_pad3
2165
2166 pad3=property(__getfield_pad3, __setfield_pad3, __delfield_pad3, None)
2167
2168 def __getfield_description(self):
2169 return self.__field_description.getvalue()
2170
2171 def __setfield_description(self, value):
2172 if isinstance(value,USTRING):
2173 self.__field_description=value
2174 else:
2175 self.__field_description=USTRING(value,**{'sizeinbytes': 42, 'encoding': PHONE_ENCODING, 'raiseontruncate': False, 'raiseonunterminatedread': False })
2176
2177 def __delfield_description(self): del self.__field_description
2178
2179 description=property(__getfield_description, __setfield_description, __delfield_description, None)
2180
2181 def iscontainer(self):
2182 return True
2183
2184 def containerelements(self):
2185 yield ('packet_size', self.__field_packet_size, "Faster than packetsize()")
2186 yield ('pos', self.__field_pos, "position within file, used as an event id")
2187 yield ('start', self.__field_start, None)
2188 yield ('end', self.__field_end, None)
2189 yield ('repeat', self.__field_repeat, None)
2190 yield ('daybitmap', self.__field_daybitmap, "which days a weekly repeat event happens on")
2191 yield ('pad2', self.__field_pad2, None)
2192 yield ('alarmminutes', self.__field_alarmminutes, "a value of 100 indicates not set")
2193 yield ('alarmhours', self.__field_alarmhours, "a value of 100 indicates not set")
2194 yield ('alarmtype', self.__field_alarmtype, "preset alarm reminder type")
2195 yield ('snoozedelay', self.__field_snoozedelay, "in minutes, not for this phone")
2196 yield ('ringtone', self.__field_ringtone, None)
2197 yield ('pad3', self.__field_pad3, None)
2198 yield ('description', self.__field_description, None)
2199
2200
2201
2202
2203 class schedulefile(BaseProtogenClass):
2204 __fields=['numactiveitems', 'events']
2205
2206 def __init__(self, *args, **kwargs):
2207 dict={}
2208 dict.update(kwargs)
2210 super(schedulefile,self).__init__(**dict)
2212 if self.__class__ is schedulefile:
2213 self._update(args,dict)
2214
2215
2216 def getfields(self):
2217 return self.__fields
2218
2219
2220 def _update(self, args, kwargs):
2221 super(schedulefile,self)._update(args,kwargs)
2222 keys=kwargs.keys()
2223 for key in keys:
2224 if key in self.__fields:
2225 setattr(self, key, kwargs[key])
2226 del kwargs[key]
2227 if __debug__:
2229 self._complainaboutunusedargs(schedulefile,kwargs)
2230 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2231
2233
2234 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2235 'Writes this packet to the supplied buffer'
2236 self._bufferstartoffset=buf.getcurrentoffset()
2237 self.__field_numactiveitems.writetobuffer(buf)
2238 try: self.__field_events
2239 except:
2240 self.__field_events=LIST(**{'elementclass': scheduleevent})
2241 self.__field_events.writetobuffer(buf)
2242 self._bufferendoffset=buf.getcurrentoffset()
2243 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2244
2245
2246 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2247 'Reads this packet from the supplied buffer'
2248 self._bufferstartoffset=buf.getcurrentoffset()
2249 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2250 self.__field_numactiveitems=UINT(**{'sizeinbytes': 2})
2251 self.__field_numactiveitems.readfrombuffer(buf)
2252 self.__field_events=LIST(**{'elementclass': scheduleevent})
2253 self.__field_events.readfrombuffer(buf)
2254 self._bufferendoffset=buf.getcurrentoffset()
2255
2256
2257 def __getfield_numactiveitems(self):
2258 return self.__field_numactiveitems.getvalue()
2259
2260 def __setfield_numactiveitems(self, value):
2261 if isinstance(value,UINT):
2262 self.__field_numactiveitems=value
2263 else:
2264 self.__field_numactiveitems=UINT(value,**{'sizeinbytes': 2})
2265
2266 def __delfield_numactiveitems(self): del self.__field_numactiveitems
2267
2268 numactiveitems=property(__getfield_numactiveitems, __setfield_numactiveitems, __delfield_numactiveitems, None)
2269
2270 def __getfield_events(self):
2271 try: self.__field_events
2272 except:
2273 self.__field_events=LIST(**{'elementclass': scheduleevent})
2274 return self.__field_events.getvalue()
2275
2276 def __setfield_events(self, value):
2277 if isinstance(value,LIST):
2278 self.__field_events=value
2279 else:
2280 self.__field_events=LIST(value,**{'elementclass': scheduleevent})
2281
2282 def __delfield_events(self): del self.__field_events
2283
2284 events=property(__getfield_events, __setfield_events, __delfield_events, None)
2285
2286 def iscontainer(self):
2287 return True
2288
2289 def containerelements(self):
2290 yield ('numactiveitems', self.__field_numactiveitems, None)
2291 yield ('events', self.__field_events, None)
2292
2293
2294
2295
2296 class call(BaseProtogenClass):
2297 __fields=['GPStime', 'unknown1', 'duration', 'number', 'name', 'numberlength', 'unknown2', 'pbnumbertype', 'unknown3']
2298
2299 def __init__(self, *args, **kwargs):
2300 dict={}
2301 dict.update(kwargs)
2303 super(call,self).__init__(**dict)
2305 if self.__class__ is call:
2306 self._update(args,dict)
2307
2308
2309 def getfields(self):
2310 return self.__fields
2311
2312
2313 def _update(self, args, kwargs):
2314 super(call,self)._update(args,kwargs)
2315 keys=kwargs.keys()
2316 for key in keys:
2317 if key in self.__fields:
2318 setattr(self, key, kwargs[key])
2319 del kwargs[key]
2320 if __debug__:
2322 self._complainaboutunusedargs(call,kwargs)
2323 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2324
2326
2327 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2328 'Writes this packet to the supplied buffer'
2329 self._bufferstartoffset=buf.getcurrentoffset()
2330 self.__field_GPStime.writetobuffer(buf)
2331 self.__field_unknown1.writetobuffer(buf)
2332 self.__field_duration.writetobuffer(buf)
2333 self.__field_number.writetobuffer(buf)
2334 self.__field_name.writetobuffer(buf)
2335 self.__field_numberlength.writetobuffer(buf)
2336 self.__field_unknown2.writetobuffer(buf)
2337 self.__field_pbnumbertype.writetobuffer(buf)
2338 self.__field_unknown3.writetobuffer(buf)
2339 self._bufferendoffset=buf.getcurrentoffset()
2340 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2341
2342
2343 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2344 'Reads this packet from the supplied buffer'
2345 self._bufferstartoffset=buf.getcurrentoffset()
2346 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2347 self.__field_GPStime=GPSDATE(**{'sizeinbytes': 4})
2348 self.__field_GPStime.readfrombuffer(buf)
2349 self.__field_unknown1=UINT(**{'sizeinbytes': 4})
2350 self.__field_unknown1.readfrombuffer(buf)
2351 self.__field_duration=UINT(**{'sizeinbytes': 4})
2352 self.__field_duration.readfrombuffer(buf)
2353 self.__field_number=USTRING(**{'sizeinbytes': 49, 'raiseonunterminatedread': False})
2354 self.__field_number.readfrombuffer(buf)
2355 self.__field_name=USTRING(**{'sizeinbytes': 36, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})
2356 self.__field_name.readfrombuffer(buf)
2357 self.__field_numberlength=UINT(**{'sizeinbytes': 1})
2358 self.__field_numberlength.readfrombuffer(buf)
2359 self.__field_unknown2=UINT(**{'sizeinbytes': 1})
2360 self.__field_unknown2.readfrombuffer(buf)
2361 self.__field_pbnumbertype=UINT(**{'sizeinbytes': 1})
2362 self.__field_pbnumbertype.readfrombuffer(buf)
2363 self.__field_unknown3=UINT(**{'sizeinbytes': 5})
2364 self.__field_unknown3.readfrombuffer(buf)
2365 self._bufferendoffset=buf.getcurrentoffset()
2366
2367
2368 def __getfield_GPStime(self):
2369 return self.__field_GPStime.getvalue()
2370
2371 def __setfield_GPStime(self, value):
2372 if isinstance(value,GPSDATE):
2373 self.__field_GPStime=value
2374 else:
2375 self.__field_GPStime=GPSDATE(value,**{'sizeinbytes': 4})
2376
2377 def __delfield_GPStime(self): del self.__field_GPStime
2378
2379 GPStime=property(__getfield_GPStime, __setfield_GPStime, __delfield_GPStime, None)
2380
2381 def __getfield_unknown1(self):
2382 return self.__field_unknown1.getvalue()
2383
2384 def __setfield_unknown1(self, value):
2385 if isinstance(value,UINT):
2386 self.__field_unknown1=value
2387 else:
2388 self.__field_unknown1=UINT(value,**{'sizeinbytes': 4})
2389
2390 def __delfield_unknown1(self): del self.__field_unknown1
2391
2392 unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None)
2393
2394 def __getfield_duration(self):
2395 return self.__field_duration.getvalue()
2396
2397 def __setfield_duration(self, value):
2398 if isinstance(value,UINT):
2399 self.__field_duration=value
2400 else:
2401 self.__field_duration=UINT(value,**{'sizeinbytes': 4})
2402
2403 def __delfield_duration(self): del self.__field_duration
2404
2405 duration=property(__getfield_duration, __setfield_duration, __delfield_duration, None)
2406
2407 def __getfield_number(self):
2408 return self.__field_number.getvalue()
2409
2410 def __setfield_number(self, value):
2411 if isinstance(value,USTRING):
2412 self.__field_number=value
2413 else:
2414 self.__field_number=USTRING(value,**{'sizeinbytes': 49, 'raiseonunterminatedread': False})
2415
2416 def __delfield_number(self): del self.__field_number
2417
2418 number=property(__getfield_number, __setfield_number, __delfield_number, None)
2419
2420 def __getfield_name(self):
2421 return self.__field_name.getvalue()
2422
2423 def __setfield_name(self, value):
2424 if isinstance(value,USTRING):
2425 self.__field_name=value
2426 else:
2427 self.__field_name=USTRING(value,**{'sizeinbytes': 36, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})
2428
2429 def __delfield_name(self): del self.__field_name
2430
2431 name=property(__getfield_name, __setfield_name, __delfield_name, None)
2432
2433 def __getfield_numberlength(self):
2434 return self.__field_numberlength.getvalue()
2435
2436 def __setfield_numberlength(self, value):
2437 if isinstance(value,UINT):
2438 self.__field_numberlength=value
2439 else:
2440 self.__field_numberlength=UINT(value,**{'sizeinbytes': 1})
2441
2442 def __delfield_numberlength(self): del self.__field_numberlength
2443
2444 numberlength=property(__getfield_numberlength, __setfield_numberlength, __delfield_numberlength, None)
2445
2446 def __getfield_unknown2(self):
2447 return self.__field_unknown2.getvalue()
2448
2449 def __setfield_unknown2(self, value):
2450 if isinstance(value,UINT):
2451 self.__field_unknown2=value
2452 else:
2453 self.__field_unknown2=UINT(value,**{'sizeinbytes': 1})
2454
2455 def __delfield_unknown2(self): del self.__field_unknown2
2456
2457 unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None)
2458
2459 def __getfield_pbnumbertype(self):
2460 return self.__field_pbnumbertype.getvalue()
2461
2462 def __setfield_pbnumbertype(self, value):
2463 if isinstance(value,UINT):
2464 self.__field_pbnumbertype=value
2465 else:
2466 self.__field_pbnumbertype=UINT(value,**{'sizeinbytes': 1})
2467
2468 def __delfield_pbnumbertype(self): del self.__field_pbnumbertype
2469
2470 pbnumbertype=property(__getfield_pbnumbertype, __setfield_pbnumbertype, __delfield_pbnumbertype, None)
2471
2472 def __getfield_unknown3(self):
2473 return self.__field_unknown3.getvalue()
2474
2475 def __setfield_unknown3(self, value):
2476 if isinstance(value,UINT):
2477 self.__field_unknown3=value
2478 else:
2479 self.__field_unknown3=UINT(value,**{'sizeinbytes': 5})
2480
2481 def __delfield_unknown3(self): del self.__field_unknown3
2482
2483 unknown3=property(__getfield_unknown3, __setfield_unknown3, __delfield_unknown3, None)
2484
2485 def iscontainer(self):
2486 return True
2487
2488 def containerelements(self):
2489 yield ('GPStime', self.__field_GPStime, None)
2490 yield ('unknown1', self.__field_unknown1, None)
2491 yield ('duration', self.__field_duration, None)
2492 yield ('number', self.__field_number, None)
2493 yield ('name', self.__field_name, None)
2494 yield ('numberlength', self.__field_numberlength, None)
2495 yield ('unknown2', self.__field_unknown2, None)
2496 yield ('pbnumbertype', self.__field_pbnumbertype, None)
2497 yield ('unknown3', self.__field_unknown3, None)
2498
2499
2500
2501
2502 class callhistory(BaseProtogenClass):
2503 __fields=['numcalls', 'unknown1', 'calls']
2504
2505 def __init__(self, *args, **kwargs):
2506 dict={}
2507 dict.update(kwargs)
2509 super(callhistory,self).__init__(**dict)
2511 if self.__class__ is callhistory:
2512 self._update(args,dict)
2513
2514
2515 def getfields(self):
2516 return self.__fields
2517
2518
2519 def _update(self, args, kwargs):
2520 super(callhistory,self)._update(args,kwargs)
2521 keys=kwargs.keys()
2522 for key in keys:
2523 if key in self.__fields:
2524 setattr(self, key, kwargs[key])
2525 del kwargs[key]
2526 if __debug__:
2528 self._complainaboutunusedargs(callhistory,kwargs)
2529 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2530
2532
2533 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2534 'Writes this packet to the supplied buffer'
2535 self._bufferstartoffset=buf.getcurrentoffset()
2536 self.__field_numcalls.writetobuffer(buf)
2537 self.__field_unknown1.writetobuffer(buf)
2538 try: self.__field_calls
2539 except:
2540 self.__field_calls=LIST(**{'elementclass': call})
2541 self.__field_calls.writetobuffer(buf)
2542 self._bufferendoffset=buf.getcurrentoffset()
2543 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2544
2545
2546 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2547 'Reads this packet from the supplied buffer'
2548 self._bufferstartoffset=buf.getcurrentoffset()
2549 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2550 self.__field_numcalls=UINT(**{'sizeinbytes': 4})
2551 self.__field_numcalls.readfrombuffer(buf)
2552 self.__field_unknown1=UINT(**{'sizeinbytes': 1})
2553 self.__field_unknown1.readfrombuffer(buf)
2554 self.__field_calls=LIST(**{'elementclass': call})
2555 self.__field_calls.readfrombuffer(buf)
2556 self._bufferendoffset=buf.getcurrentoffset()
2557
2558
2559 def __getfield_numcalls(self):
2560 return self.__field_numcalls.getvalue()
2561
2562 def __setfield_numcalls(self, value):
2563 if isinstance(value,UINT):
2564 self.__field_numcalls=value
2565 else:
2566 self.__field_numcalls=UINT(value,**{'sizeinbytes': 4})
2567
2568 def __delfield_numcalls(self): del self.__field_numcalls
2569
2570 numcalls=property(__getfield_numcalls, __setfield_numcalls, __delfield_numcalls, None)
2571
2572 def __getfield_unknown1(self):
2573 return self.__field_unknown1.getvalue()
2574
2575 def __setfield_unknown1(self, value):
2576 if isinstance(value,UINT):
2577 self.__field_unknown1=value
2578 else:
2579 self.__field_unknown1=UINT(value,**{'sizeinbytes': 1})
2580
2581 def __delfield_unknown1(self): del self.__field_unknown1
2582
2583 unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None)
2584
2585 def __getfield_calls(self):
2586 try: self.__field_calls
2587 except:
2588 self.__field_calls=LIST(**{'elementclass': call})
2589 return self.__field_calls.getvalue()
2590
2591 def __setfield_calls(self, value):
2592 if isinstance(value,LIST):
2593 self.__field_calls=value
2594 else:
2595 self.__field_calls=LIST(value,**{'elementclass': call})
2596
2597 def __delfield_calls(self): del self.__field_calls
2598
2599 calls=property(__getfield_calls, __setfield_calls, __delfield_calls, None)
2600
2601 def iscontainer(self):
2602 return True
2603
2604 def containerelements(self):
2605 yield ('numcalls', self.__field_numcalls, None)
2606 yield ('unknown1', self.__field_unknown1, None)
2607 yield ('calls', self.__field_calls, None)
2608
2609
2610
2611
2612 class indexentry(BaseProtogenClass):
2613 __fields=['index', 'const', 'name']
2614
2615 def __init__(self, *args, **kwargs):
2616 dict={}
2617 dict.update(kwargs)
2619 super(indexentry,self).__init__(**dict)
2621 if self.__class__ is indexentry:
2622 self._update(args,dict)
2623
2624
2625 def getfields(self):
2626 return self.__fields
2627
2628
2629 def _update(self, args, kwargs):
2630 super(indexentry,self)._update(args,kwargs)
2631 keys=kwargs.keys()
2632 for key in keys:
2633 if key in self.__fields:
2634 setattr(self, key, kwargs[key])
2635 del kwargs[key]
2636 if __debug__:
2638 self._complainaboutunusedargs(indexentry,kwargs)
2639 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2640
2642
2643 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2644 'Writes this packet to the supplied buffer'
2645 self._bufferstartoffset=buf.getcurrentoffset()
2646 self.__field_index.writetobuffer(buf)
2647 self.__field_const.writetobuffer(buf)
2648 try: self.__field_name
2649 except:
2650 self.__field_name=USTRING(**{'sizeinbytes': 40, 'default': ""})
2651 self.__field_name.writetobuffer(buf)
2652 self._bufferendoffset=buf.getcurrentoffset()
2653 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2654
2655
2656 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2657 'Reads this packet from the supplied buffer'
2658 self._bufferstartoffset=buf.getcurrentoffset()
2659 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2660 self.__field_index=UINT(**{'sizeinbytes': 1})
2661 self.__field_index.readfrombuffer(buf)
2662 self.__field_const=UINT(**{'sizeinbytes': 1})
2663 self.__field_const.readfrombuffer(buf)
2664 self.__field_name=USTRING(**{'sizeinbytes': 40, 'default': ""})
2665 self.__field_name.readfrombuffer(buf)
2666 self._bufferendoffset=buf.getcurrentoffset()
2667
2668
2669 def __getfield_index(self):
2670 return self.__field_index.getvalue()
2671
2672 def __setfield_index(self, value):
2673 if isinstance(value,UINT):
2674 self.__field_index=value
2675 else:
2676 self.__field_index=UINT(value,**{'sizeinbytes': 1})
2677
2678 def __delfield_index(self): del self.__field_index
2679
2680 index=property(__getfield_index, __setfield_index, __delfield_index, None)
2681
2682 def __getfield_const(self):
2683 return self.__field_const.getvalue()
2684
2685 def __setfield_const(self, value):
2686 if isinstance(value,UINT):
2687 self.__field_const=value
2688 else:
2689 self.__field_const=UINT(value,**{'sizeinbytes': 1})
2690
2691 def __delfield_const(self): del self.__field_const
2692
2693 const=property(__getfield_const, __setfield_const, __delfield_const, None)
2694
2695 def __getfield_name(self):
2696 try: self.__field_name
2697 except:
2698 self.__field_name=USTRING(**{'sizeinbytes': 40, 'default': ""})
2699 return self.__field_name.getvalue()
2700
2701 def __setfield_name(self, value):
2702 if isinstance(value,USTRING):
2703 self.__field_name=value
2704 else:
2705 self.__field_name=USTRING(value,**{'sizeinbytes': 40, 'default': ""})
2706
2707 def __delfield_name(self): del self.__field_name
2708
2709 name=property(__getfield_name, __setfield_name, __delfield_name, None)
2710
2711 def iscontainer(self):
2712 return True
2713
2714 def containerelements(self):
2715 yield ('index', self.__field_index, None)
2716 yield ('const', self.__field_const, None)
2717 yield ('name', self.__field_name, None)
2718
2719
2720
2721
2722 class indexfile(BaseProtogenClass):
2723 "Used for tracking wallpaper and ringtones"
2724 __fields=['numactiveitems', 'items']
2725
2726 def __init__(self, *args, **kwargs):
2727 dict={}
2728 dict.update(kwargs)
2730 super(indexfile,self).__init__(**dict)
2732 if self.__class__ is indexfile:
2733 self._update(args,dict)
2734
2735
2736 def getfields(self):
2737 return self.__fields
2738
2739
2740 def _update(self, args, kwargs):
2741 super(indexfile,self)._update(args,kwargs)
2742 keys=kwargs.keys()
2743 for key in keys:
2744 if key in self.__fields:
2745 setattr(self, key, kwargs[key])
2746 del kwargs[key]
2747 if __debug__:
2749 self._complainaboutunusedargs(indexfile,kwargs)
2750 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2751
2753
2754 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2755 'Writes this packet to the supplied buffer'
2756 self._bufferstartoffset=buf.getcurrentoffset()
2757 self.__field_numactiveitems.writetobuffer(buf)
2758 try: self.__field_items
2759 except:
2760 self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True})
2761 self.__field_items.writetobuffer(buf)
2762 self._bufferendoffset=buf.getcurrentoffset()
2763 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2764
2765
2766 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2767 'Reads this packet from the supplied buffer'
2768 self._bufferstartoffset=buf.getcurrentoffset()
2769 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2770 self.__field_numactiveitems=UINT(**{'sizeinbytes': 2})
2771 self.__field_numactiveitems.readfrombuffer(buf)
2772 self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True})
2773 self.__field_items.readfrombuffer(buf)
2774 self._bufferendoffset=buf.getcurrentoffset()
2775
2776
2777 def __getfield_numactiveitems(self):
2778 return self.__field_numactiveitems.getvalue()
2779
2780 def __setfield_numactiveitems(self, value):
2781 if isinstance(value,UINT):
2782 self.__field_numactiveitems=value
2783 else:
2784 self.__field_numactiveitems=UINT(value,**{'sizeinbytes': 2})
2785
2786 def __delfield_numactiveitems(self): del self.__field_numactiveitems
2787
2788 numactiveitems=property(__getfield_numactiveitems, __setfield_numactiveitems, __delfield_numactiveitems, None)
2789
2790 def __getfield_items(self):
2791 try: self.__field_items
2792 except:
2793 self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True})
2794 return self.__field_items.getvalue()
2795
2796 def __setfield_items(self, value):
2797 if isinstance(value,LIST):
2798 self.__field_items=value
2799 else:
2800 self.__field_items=LIST(value,**{'elementclass': indexentry, 'createdefault': True})
2801
2802 def __delfield_items(self): del self.__field_items
2803
2804 items=property(__getfield_items, __setfield_items, __delfield_items, None)
2805
2806 def iscontainer(self):
2807 return True
2808
2809 def containerelements(self):
2810 yield ('numactiveitems', self.__field_numactiveitems, None)
2811 yield ('items', self.__field_items, None)
2812
2813
2814
2815
2816 class content_entry(BaseProtogenClass):
2817 __fields=['type', 'index1', 'name1', 'unknown1', 'unknown2', 'mime_type', 'content_type', 'url', 'unknown_int1', 'unknown3', 'unknown_int2', 'unknown4', 'unknown5', 'size', 'location_maybe', 'index2', 'name2', 'unknown6']
2818
2819 def __init__(self, *args, **kwargs):
2820 dict={}
2821 dict.update(kwargs)
2823 super(content_entry,self).__init__(**dict)
2825 if self.__class__ is content_entry:
2826 self._update(args,dict)
2827
2828
2829 def getfields(self):
2830 return self.__fields
2831
2832
2833 def _update(self, args, kwargs):
2834 super(content_entry,self)._update(args,kwargs)
2835 keys=kwargs.keys()
2836 for key in keys:
2837 if key in self.__fields:
2838 setattr(self, key, kwargs[key])
2839 del kwargs[key]
2840 if __debug__:
2842 self._complainaboutunusedargs(content_entry,kwargs)
2843 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2844
2846
2847 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2848 'Writes this packet to the supplied buffer'
2849 self._bufferstartoffset=buf.getcurrentoffset()
2850 self.__field_type.writetobuffer(buf)
2851 if self.type=='!C':
2852 self.__field_index1.writetobuffer(buf)
2853 self.__field_name1.writetobuffer(buf)
2854 try: self.__field_unknown1
2855 except:
2856 self.__field_unknown1=USTRING(**{'terminator': 0xA, 'default': '-1'})
2857 self.__field_unknown1.writetobuffer(buf)
2858 try: self.__field_unknown2
2859 except:
2860 self.__field_unknown2=UINT(**{'sizeinbytes': 8, 'default' :0})
2861 self.__field_unknown2.writetobuffer(buf)
2862 self.__field_mime_type.writetobuffer(buf)
2863 self.__field_content_type.writetobuffer(buf)
2864 try: self.__field_url
2865 except:
2866 self.__field_url=USTRING(**{'terminator': 0xA, 'default':'bitpim.org'})
2867 self.__field_url.writetobuffer(buf)
2868 try: self.__field_unknown_int1
2869 except:
2870 self.__field_unknown_int1=UINT(**{'sizeinbytes': 1, 'default':0x14})
2871 self.__field_unknown_int1.writetobuffer(buf)
2872 try: self.__field_unknown3
2873 except:
2874 self.__field_unknown3=USTRING(**{'terminator': 0xA, 'default':''})
2875 self.__field_unknown3.writetobuffer(buf)
2876 try: self.__field_unknown_int2
2877 except:
2878 self.__field_unknown_int2=UINT(**{'sizeinbytes': 1, 'default':0x14})
2879 self.__field_unknown_int2.writetobuffer(buf)
2880 try: self.__field_unknown4
2881 except:
2882 self.__field_unknown4=USTRING(**{'terminator': 0xA, 'default':''})
2883 self.__field_unknown4.writetobuffer(buf)
2884 try: self.__field_unknown5
2885 except:
2886 self.__field_unknown5=USTRING(**{'terminator': 0xA, 'default':'0'})
2887 self.__field_unknown5.writetobuffer(buf)
2888 self.__field_size.writetobuffer(buf)
2889 if self.type=='!E':
2890 try: self.__field_location_maybe
2891 except:
2892 self.__field_location_maybe=USTRING(**{'terminator': 0xA, 'default':'ams:'})
2893 self.__field_location_maybe.writetobuffer(buf)
2894 self.__field_index2.writetobuffer(buf)
2895 self.__field_name2.writetobuffer(buf)
2896 try: self.__field_unknown6
2897 except:
2898 self.__field_unknown6=USTRING(**{'terminator': 0xA, 'default':''})
2899 self.__field_unknown6.writetobuffer(buf)
2900 self._bufferendoffset=buf.getcurrentoffset()
2901 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2902
2903
2904 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2905 'Reads this packet from the supplied buffer'
2906 self._bufferstartoffset=buf.getcurrentoffset()
2907 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2908 self.__field_type=USTRING(**{'sizeinbytes': 3, 'terminator': 0xA})
2909 self.__field_type.readfrombuffer(buf)
2910 if self.type=='!C':
2911 self.__field_index1=USTRING(**{'terminator': 0xA})
2912 self.__field_index1.readfrombuffer(buf)
2913 self.__field_name1=USTRING(**{'terminator': 0xA})
2914 self.__field_name1.readfrombuffer(buf)
2915 self.__field_unknown1=USTRING(**{'terminator': 0xA, 'default': '-1'})
2916 self.__field_unknown1.readfrombuffer(buf)
2917 self.__field_unknown2=UINT(**{'sizeinbytes': 8, 'default' :0})
2918 self.__field_unknown2.readfrombuffer(buf)
2919 self.__field_mime_type=USTRING(**{'terminator': 0xA})
2920 self.__field_mime_type.readfrombuffer(buf)
2921 self.__field_content_type=USTRING(**{'terminator': 0xA})
2922 self.__field_content_type.readfrombuffer(buf)
2923 self.__field_url=USTRING(**{'terminator': 0xA, 'default':'bitpim.org'})
2924 self.__field_url.readfrombuffer(buf)
2925 self.__field_unknown_int1=UINT(**{'sizeinbytes': 1, 'default':0x14})
2926 self.__field_unknown_int1.readfrombuffer(buf)
2927 self.__field_unknown3=USTRING(**{'terminator': 0xA, 'default':''})
2928 self.__field_unknown3.readfrombuffer(buf)
2929 self.__field_unknown_int2=UINT(**{'sizeinbytes': 1, 'default':0x14})
2930 self.__field_unknown_int2.readfrombuffer(buf)
2931 self.__field_unknown4=USTRING(**{'terminator': 0xA, 'default':''})
2932 self.__field_unknown4.readfrombuffer(buf)
2933 self.__field_unknown5=USTRING(**{'terminator': 0xA, 'default':'0'})
2934 self.__field_unknown5.readfrombuffer(buf)
2935 self.__field_size=USTRING(**{'terminator': 0xA})
2936 self.__field_size.readfrombuffer(buf)
2937 if self.type=='!E':
2938 self.__field_location_maybe=USTRING(**{'terminator': 0xA, 'default':'ams:'})
2939 self.__field_location_maybe.readfrombuffer(buf)
2940 self.__field_index2=USTRING(**{'terminator': 0xA})
2941 self.__field_index2.readfrombuffer(buf)
2942 self.__field_name2=USTRING(**{'terminator': 0xA})
2943 self.__field_name2.readfrombuffer(buf)
2944 self.__field_unknown6=USTRING(**{'terminator': 0xA, 'default':''})
2945 self.__field_unknown6.readfrombuffer(buf)
2946 self._bufferendoffset=buf.getcurrentoffset()
2947
2948
2949 def __getfield_type(self):
2950 return self.__field_type.getvalue()
2951
2952 def __setfield_type(self, value):
2953 if isinstance(value,USTRING):
2954 self.__field_type=value
2955 else:
2956 self.__field_type=USTRING(value,**{'sizeinbytes': 3, 'terminator': 0xA})
2957
2958 def __delfield_type(self): del self.__field_type
2959
2960 type=property(__getfield_type, __setfield_type, __delfield_type, None)
2961
2962 def __getfield_index1(self):
2963 return self.__field_index1.getvalue()
2964
2965 def __setfield_index1(self, value):
2966 if isinstance(value,USTRING):
2967 self.__field_index1=value
2968 else:
2969 self.__field_index1=USTRING(value,**{'terminator': 0xA})
2970
2971 def __delfield_index1(self): del self.__field_index1
2972
2973 index1=property(__getfield_index1, __setfield_index1, __delfield_index1, None)
2974
2975 def __getfield_name1(self):
2976 return self.__field_name1.getvalue()
2977
2978 def __setfield_name1(self, value):
2979 if isinstance(value,USTRING):
2980 self.__field_name1=value
2981 else:
2982 self.__field_name1=USTRING(value,**{'terminator': 0xA})
2983
2984 def __delfield_name1(self): del self.__field_name1
2985
2986 name1=property(__getfield_name1, __setfield_name1, __delfield_name1, None)
2987
2988 def __getfield_unknown1(self):
2989 try: self.__field_unknown1
2990 except:
2991 self.__field_unknown1=USTRING(**{'terminator': 0xA, 'default': '-1'})
2992 return self.__field_unknown1.getvalue()
2993
2994 def __setfield_unknown1(self, value):
2995 if isinstance(value,USTRING):
2996 self.__field_unknown1=value
2997 else:
2998 self.__field_unknown1=USTRING(value,**{'terminator': 0xA, 'default': '-1'})
2999
3000 def __delfield_unknown1(self): del self.__field_unknown1
3001
3002 unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None)
3003
3004 def __getfield_unknown2(self):
3005 try: self.__field_unknown2
3006 except:
3007 self.__field_unknown2=UINT(**{'sizeinbytes': 8, 'default' :0})
3008 return self.__field_unknown2.getvalue()
3009
3010 def __setfield_unknown2(self, value):
3011 if isinstance(value,UINT):
3012 self.__field_unknown2=value
3013 else:
3014 self.__field_unknown2=UINT(value,**{'sizeinbytes': 8, 'default' :0})
3015
3016 def __delfield_unknown2(self): del self.__field_unknown2
3017