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