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