0001
0003 """Various descriptions of data specific to LG UX5000"""
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', 'unknown1', '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_lgux5000_94, '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_unknown1
0630 except:
0631 self.__field_unknown1=UINT(**{'sizeinbytes': 9, 'default': 0 })
0632 self.__field_unknown1.writetobuffer(buf)
0633 try: self.__field_numbertypes
0634 except:
0635 self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lgux5000_103, 'length': NUMPHONENUMBERS})
0636 self.__field_numbertypes.writetobuffer(buf)
0637 try: self.__field_numbers
0638 except:
0639 self.__field_numbers=LIST(**{'elementclass': _gen_p_lgux5000_105, 'length': NUMPHONENUMBERS})
0640 self.__field_numbers.writetobuffer(buf)
0641 try: self.__field_unknown20c
0642 except:
0643 self.__field_unknown20c=UNKNOWN()
0644 self.__field_unknown20c.writetobuffer(buf)
0645 self._bufferendoffset=buf.getcurrentoffset()
0646 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0647
0648
0649 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0650 'Reads this packet from the supplied buffer'
0651 self._bufferstartoffset=buf.getcurrentoffset()
0652 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0653 self.__field_serial1=UINT(**{'sizeinbytes': 4})
0654 self.__field_serial1.readfrombuffer(buf)
0655 self.__field_entrysize=UINT(**{'sizeinbytes': 2})
0656 self.__field_entrysize.readfrombuffer(buf)
0657 self.__field_serial2=UINT(**{'sizeinbytes': 4})
0658 self.__field_serial2.readfrombuffer(buf)
0659 self.__field_entrynumber=UINT(**{'sizeinbytes': 2})
0660 self.__field_entrynumber.readfrombuffer(buf)
0661 self.__field_name=USTRING(**{'sizeinbytes': 23, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})
0662 self.__field_name.readfrombuffer(buf)
0663 self.__field_group=UINT(**{'sizeinbytes': 2})
0664 self.__field_group.readfrombuffer(buf)
0665 self.__field_emails=LIST(**{'elementclass': _gen_p_lgux5000_94, 'length': NUMEMAILS})
0666 self.__field_emails.readfrombuffer(buf)
0667 self.__field_url=USTRING(**{'sizeinbytes': 49, 'raiseonunterminatedread': False})
0668 self.__field_url.readfrombuffer(buf)
0669 self.__field_ringtone=UINT(**{'sizeinbytes': 1})
0670 self.__field_ringtone.readfrombuffer(buf)
0671 self.__field_msgringtone=UINT(**{'sizeinbytes': 1})
0672 self.__field_msgringtone.readfrombuffer(buf)
0673 self.__field_secret=BOOL(**{'sizeinbytes': 1})
0674 self.__field_secret.readfrombuffer(buf)
0675 self.__field_memo=USTRING(**{'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'sizeinbytes': MEMOLENGTH})
0676 self.__field_memo.readfrombuffer(buf)
0677 self.__field_wallpaper=UINT(**{'sizeinbytes': 1})
0678 self.__field_wallpaper.readfrombuffer(buf)
0679 self.__field_unknown1=UINT(**{'sizeinbytes': 9, 'default': 0 })
0680 self.__field_unknown1.readfrombuffer(buf)
0681 self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lgux5000_103, 'length': NUMPHONENUMBERS})
0682 self.__field_numbertypes.readfrombuffer(buf)
0683 self.__field_numbers=LIST(**{'elementclass': _gen_p_lgux5000_105, 'length': NUMPHONENUMBERS})
0684 self.__field_numbers.readfrombuffer(buf)
0685 self.__field_unknown20c=UNKNOWN()
0686 self.__field_unknown20c.readfrombuffer(buf)
0687 self._bufferendoffset=buf.getcurrentoffset()
0688
0689
0690 def __getfield_serial1(self):
0691 return self.__field_serial1.getvalue()
0692
0693 def __setfield_serial1(self, value):
0694 if isinstance(value,UINT):
0695 self.__field_serial1=value
0696 else:
0697 self.__field_serial1=UINT(value,**{'sizeinbytes': 4})
0698
0699 def __delfield_serial1(self): del self.__field_serial1
0700
0701 serial1=property(__getfield_serial1, __setfield_serial1, __delfield_serial1, None)
0702
0703 def __getfield_entrysize(self):
0704 return self.__field_entrysize.getvalue()
0705
0706 def __setfield_entrysize(self, value):
0707 if isinstance(value,UINT):
0708 self.__field_entrysize=value
0709 else:
0710 self.__field_entrysize=UINT(value,**{'sizeinbytes': 2})
0711
0712 def __delfield_entrysize(self): del self.__field_entrysize
0713
0714 entrysize=property(__getfield_entrysize, __setfield_entrysize, __delfield_entrysize, None)
0715
0716 def __getfield_serial2(self):
0717 return self.__field_serial2.getvalue()
0718
0719 def __setfield_serial2(self, value):
0720 if isinstance(value,UINT):
0721 self.__field_serial2=value
0722 else:
0723 self.__field_serial2=UINT(value,**{'sizeinbytes': 4})
0724
0725 def __delfield_serial2(self): del self.__field_serial2
0726
0727 serial2=property(__getfield_serial2, __setfield_serial2, __delfield_serial2, None)
0728
0729 def __getfield_entrynumber(self):
0730 return self.__field_entrynumber.getvalue()
0731
0732 def __setfield_entrynumber(self, value):
0733 if isinstance(value,UINT):
0734 self.__field_entrynumber=value
0735 else:
0736 self.__field_entrynumber=UINT(value,**{'sizeinbytes': 2})
0737
0738 def __delfield_entrynumber(self): del self.__field_entrynumber
0739
0740 entrynumber=property(__getfield_entrynumber, __setfield_entrynumber, __delfield_entrynumber, None)
0741
0742 def __getfield_name(self):
0743 return self.__field_name.getvalue()
0744
0745 def __setfield_name(self, value):
0746 if isinstance(value,USTRING):
0747 self.__field_name=value
0748 else:
0749 self.__field_name=USTRING(value,**{'sizeinbytes': 23, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})
0750
0751 def __delfield_name(self): del self.__field_name
0752
0753 name=property(__getfield_name, __setfield_name, __delfield_name, None)
0754
0755 def __getfield_group(self):
0756 return self.__field_group.getvalue()
0757
0758 def __setfield_group(self, value):
0759 if isinstance(value,UINT):
0760 self.__field_group=value
0761 else:
0762 self.__field_group=UINT(value,**{'sizeinbytes': 2})
0763
0764 def __delfield_group(self): del self.__field_group
0765
0766 group=property(__getfield_group, __setfield_group, __delfield_group, None)
0767
0768 def __getfield_emails(self):
0769 try: self.__field_emails
0770 except:
0771 self.__field_emails=LIST(**{'elementclass': _gen_p_lgux5000_94, 'length': NUMEMAILS})
0772 return self.__field_emails.getvalue()
0773
0774 def __setfield_emails(self, value):
0775 if isinstance(value,LIST):
0776 self.__field_emails=value
0777 else:
0778 self.__field_emails=LIST(value,**{'elementclass': _gen_p_lgux5000_94, 'length': NUMEMAILS})
0779
0780 def __delfield_emails(self): del self.__field_emails
0781
0782 emails=property(__getfield_emails, __setfield_emails, __delfield_emails, None)
0783
0784 def __getfield_url(self):
0785 return self.__field_url.getvalue()
0786
0787 def __setfield_url(self, value):
0788 if isinstance(value,USTRING):
0789 self.__field_url=value
0790 else:
0791 self.__field_url=USTRING(value,**{'sizeinbytes': 49, 'raiseonunterminatedread': False})
0792
0793 def __delfield_url(self): del self.__field_url
0794
0795 url=property(__getfield_url, __setfield_url, __delfield_url, None)
0796
0797 def __getfield_ringtone(self):
0798 return self.__field_ringtone.getvalue()
0799
0800 def __setfield_ringtone(self, value):
0801 if isinstance(value,UINT):
0802 self.__field_ringtone=value
0803 else:
0804 self.__field_ringtone=UINT(value,**{'sizeinbytes': 1})
0805
0806 def __delfield_ringtone(self): del self.__field_ringtone
0807
0808 ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, "ringtone index for a call")
0809
0810 def __getfield_msgringtone(self):
0811 return self.__field_msgringtone.getvalue()
0812
0813 def __setfield_msgringtone(self, value):
0814 if isinstance(value,UINT):
0815 self.__field_msgringtone=value
0816 else:
0817 self.__field_msgringtone=UINT(value,**{'sizeinbytes': 1})
0818
0819 def __delfield_msgringtone(self): del self.__field_msgringtone
0820
0821 msgringtone=property(__getfield_msgringtone, __setfield_msgringtone, __delfield_msgringtone, "ringtone index for a text message")
0822
0823 def __getfield_secret(self):
0824 return self.__field_secret.getvalue()
0825
0826 def __setfield_secret(self, value):
0827 if isinstance(value,BOOL):
0828 self.__field_secret=value
0829 else:
0830 self.__field_secret=BOOL(value,**{'sizeinbytes': 1})
0831
0832 def __delfield_secret(self): del self.__field_secret
0833
0834 secret=property(__getfield_secret, __setfield_secret, __delfield_secret, None)
0835
0836 def __getfield_memo(self):
0837 return self.__field_memo.getvalue()
0838
0839 def __setfield_memo(self, value):
0840 if isinstance(value,USTRING):
0841 self.__field_memo=value
0842 else:
0843 self.__field_memo=USTRING(value,**{'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'sizeinbytes': MEMOLENGTH})
0844
0845 def __delfield_memo(self): del self.__field_memo
0846
0847 memo=property(__getfield_memo, __setfield_memo, __delfield_memo, None)
0848
0849 def __getfield_wallpaper(self):
0850 return self.__field_wallpaper.getvalue()
0851
0852 def __setfield_wallpaper(self, value):
0853 if isinstance(value,UINT):
0854 self.__field_wallpaper=value
0855 else:
0856 self.__field_wallpaper=UINT(value,**{'sizeinbytes': 1})
0857
0858 def __delfield_wallpaper(self): del self.__field_wallpaper
0859
0860 wallpaper=property(__getfield_wallpaper, __setfield_wallpaper, __delfield_wallpaper, None)
0861
0862 def __getfield_unknown1(self):
0863 try: self.__field_unknown1
0864 except:
0865 self.__field_unknown1=UINT(**{'sizeinbytes': 9, 'default': 0 })
0866 return self.__field_unknown1.getvalue()
0867
0868 def __setfield_unknown1(self, value):
0869 if isinstance(value,UINT):
0870 self.__field_unknown1=value
0871 else:
0872 self.__field_unknown1=UINT(value,**{'sizeinbytes': 9, 'default': 0 })
0873
0874 def __delfield_unknown1(self): del self.__field_unknown1
0875
0876 unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None)
0877
0878 def __getfield_numbertypes(self):
0879 try: self.__field_numbertypes
0880 except:
0881 self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lgux5000_103, 'length': NUMPHONENUMBERS})
0882 return self.__field_numbertypes.getvalue()
0883
0884 def __setfield_numbertypes(self, value):
0885 if isinstance(value,LIST):
0886 self.__field_numbertypes=value
0887 else:
0888 self.__field_numbertypes=LIST(value,**{'elementclass': _gen_p_lgux5000_103, 'length': NUMPHONENUMBERS})
0889
0890 def __delfield_numbertypes(self): del self.__field_numbertypes
0891
0892 numbertypes=property(__getfield_numbertypes, __setfield_numbertypes, __delfield_numbertypes, None)
0893
0894 def __getfield_numbers(self):
0895 try: self.__field_numbers
0896 except:
0897 self.__field_numbers=LIST(**{'elementclass': _gen_p_lgux5000_105, 'length': NUMPHONENUMBERS})
0898 return self.__field_numbers.getvalue()
0899
0900 def __setfield_numbers(self, value):
0901 if isinstance(value,LIST):
0902 self.__field_numbers=value
0903 else:
0904 self.__field_numbers=LIST(value,**{'elementclass': _gen_p_lgux5000_105, 'length': NUMPHONENUMBERS})
0905
0906 def __delfield_numbers(self): del self.__field_numbers
0907
0908 numbers=property(__getfield_numbers, __setfield_numbers, __delfield_numbers, None)
0909
0910 def __getfield_unknown20c(self):
0911 try: self.__field_unknown20c
0912 except:
0913 self.__field_unknown20c=UNKNOWN()
0914 return self.__field_unknown20c.getvalue()
0915
0916 def __setfield_unknown20c(self, value):
0917 if isinstance(value,UNKNOWN):
0918 self.__field_unknown20c=value
0919 else:
0920 self.__field_unknown20c=UNKNOWN(value,)
0921
0922 def __delfield_unknown20c(self): del self.__field_unknown20c
0923
0924 unknown20c=property(__getfield_unknown20c, __setfield_unknown20c, __delfield_unknown20c, None)
0925
0926 def iscontainer(self):
0927 return True
0928
0929 def containerelements(self):
0930 yield ('serial1', self.__field_serial1, None)
0931 yield ('entrysize', self.__field_entrysize, None)
0932 yield ('serial2', self.__field_serial2, None)
0933 yield ('entrynumber', self.__field_entrynumber, None)
0934 yield ('name', self.__field_name, None)
0935 yield ('group', self.__field_group, None)
0936 yield ('emails', self.__field_emails, None)
0937 yield ('url', self.__field_url, None)
0938 yield ('ringtone', self.__field_ringtone, "ringtone index for a call")
0939 yield ('msgringtone', self.__field_msgringtone, "ringtone index for a text message")
0940 yield ('secret', self.__field_secret, None)
0941 yield ('memo', self.__field_memo, None)
0942 yield ('wallpaper', self.__field_wallpaper, None)
0943 yield ('unknown1', self.__field_unknown1, None)
0944 yield ('numbertypes', self.__field_numbertypes, None)
0945 yield ('numbers', self.__field_numbers, None)
0946 yield ('unknown20c', self.__field_unknown20c, None)
0947
0948
0949
0950
0951 class _gen_p_lgux5000_94(BaseProtogenClass):
0952 'Anonymous inner class'
0953 __fields=['email']
0954
0955 def __init__(self, *args, **kwargs):
0956 dict={}
0957 dict.update(kwargs)
0959 super(_gen_p_lgux5000_94,self).__init__(**dict)
0961 if self.__class__ is _gen_p_lgux5000_94:
0962 self._update(args,dict)
0963
0964
0965 def getfields(self):
0966 return self.__fields
0967
0968
0969 def _update(self, args, kwargs):
0970 super(_gen_p_lgux5000_94,self)._update(args,kwargs)
0971 keys=kwargs.keys()
0972 for key in keys:
0973 if key in self.__fields:
0974 setattr(self, key, kwargs[key])
0975 del kwargs[key]
0976 if __debug__:
0978 self._complainaboutunusedargs(_gen_p_lgux5000_94,kwargs)
0979 if len(args):
0980 dict2={'sizeinbytes': 49, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}
0981 dict2.update(kwargs)
0982 kwargs=dict2
0983 self.__field_email=USTRING(*args,**dict2)
0984
0986
0987 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0988 'Writes this packet to the supplied buffer'
0989 self._bufferstartoffset=buf.getcurrentoffset()
0990 self.__field_email.writetobuffer(buf)
0991 self._bufferendoffset=buf.getcurrentoffset()
0992 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0993
0994
0995 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0996 'Reads this packet from the supplied buffer'
0997 self._bufferstartoffset=buf.getcurrentoffset()
0998 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0999 self.__field_email=USTRING(**{'sizeinbytes': 49, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})
1000 self.__field_email.readfrombuffer(buf)
1001 self._bufferendoffset=buf.getcurrentoffset()
1002
1003
1004 def __getfield_email(self):
1005 return self.__field_email.getvalue()
1006
1007 def __setfield_email(self, value):
1008 if isinstance(value,USTRING):
1009 self.__field_email=value
1010 else:
1011 self.__field_email=USTRING(value,**{'sizeinbytes': 49, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})
1012
1013 def __delfield_email(self): del self.__field_email
1014
1015 email=property(__getfield_email, __setfield_email, __delfield_email, None)
1016
1017 def iscontainer(self):
1018 return True
1019
1020 def containerelements(self):
1021 yield ('email', self.__field_email, None)
1022
1023
1024
1025
1026 class _gen_p_lgux5000_103(BaseProtogenClass):
1027 'Anonymous inner class'
1028 __fields=['numbertype']
1029
1030 def __init__(self, *args, **kwargs):
1031 dict={}
1032 dict.update(kwargs)
1034 super(_gen_p_lgux5000_103,self).__init__(**dict)
1036 if self.__class__ is _gen_p_lgux5000_103:
1037 self._update(args,dict)
1038
1039
1040 def getfields(self):
1041 return self.__fields
1042
1043
1044 def _update(self, args, kwargs):
1045 super(_gen_p_lgux5000_103,self)._update(args,kwargs)
1046 keys=kwargs.keys()
1047 for key in keys:
1048 if key in self.__fields:
1049 setattr(self, key, kwargs[key])
1050 del kwargs[key]
1051 if __debug__:
1053 self._complainaboutunusedargs(_gen_p_lgux5000_103,kwargs)
1054 if len(args):
1055 dict2={'sizeinbytes': 1}
1056 dict2.update(kwargs)
1057 kwargs=dict2
1058 self.__field_numbertype=UINT(*args,**dict2)
1059
1061
1062 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1063 'Writes this packet to the supplied buffer'
1064 self._bufferstartoffset=buf.getcurrentoffset()
1065 self.__field_numbertype.writetobuffer(buf)
1066 self._bufferendoffset=buf.getcurrentoffset()
1067 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1068
1069
1070 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1071 'Reads this packet from the supplied buffer'
1072 self._bufferstartoffset=buf.getcurrentoffset()
1073 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1074 self.__field_numbertype=UINT(**{'sizeinbytes': 1})
1075 self.__field_numbertype.readfrombuffer(buf)
1076 self._bufferendoffset=buf.getcurrentoffset()
1077
1078
1079 def __getfield_numbertype(self):
1080 return self.__field_numbertype.getvalue()
1081
1082 def __setfield_numbertype(self, value):
1083 if isinstance(value,UINT):
1084 self.__field_numbertype=value
1085 else:
1086 self.__field_numbertype=UINT(value,**{'sizeinbytes': 1})
1087
1088 def __delfield_numbertype(self): del self.__field_numbertype
1089
1090 numbertype=property(__getfield_numbertype, __setfield_numbertype, __delfield_numbertype, None)
1091
1092 def iscontainer(self):
1093 return True
1094
1095 def containerelements(self):
1096 yield ('numbertype', self.__field_numbertype, None)
1097
1098
1099
1100
1101 class _gen_p_lgux5000_105(BaseProtogenClass):
1102 'Anonymous inner class'
1103 __fields=['number']
1104
1105 def __init__(self, *args, **kwargs):
1106 dict={}
1107 dict.update(kwargs)
1109 super(_gen_p_lgux5000_105,self).__init__(**dict)
1111 if self.__class__ is _gen_p_lgux5000_105:
1112 self._update(args,dict)
1113
1114
1115 def getfields(self):
1116 return self.__fields
1117
1118
1119 def _update(self, args, kwargs):
1120 super(_gen_p_lgux5000_105,self)._update(args,kwargs)
1121 keys=kwargs.keys()
1122 for key in keys:
1123 if key in self.__fields:
1124 setattr(self, key, kwargs[key])
1125 del kwargs[key]
1126 if __debug__:
1128 self._complainaboutunusedargs(_gen_p_lgux5000_105,kwargs)
1129 if len(args):
1130 dict2={'sizeinbytes': 49, 'raiseonunterminatedread': False}
1131 dict2.update(kwargs)
1132 kwargs=dict2
1133 self.__field_number=USTRING(*args,**dict2)
1134
1136
1137 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1138 'Writes this packet to the supplied buffer'
1139 self._bufferstartoffset=buf.getcurrentoffset()
1140 self.__field_number.writetobuffer(buf)
1141 self._bufferendoffset=buf.getcurrentoffset()
1142 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1143
1144
1145 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1146 'Reads this packet from the supplied buffer'
1147 self._bufferstartoffset=buf.getcurrentoffset()
1148 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1149 self.__field_number=USTRING(**{'sizeinbytes': 49, 'raiseonunterminatedread': False})
1150 self.__field_number.readfrombuffer(buf)
1151 self._bufferendoffset=buf.getcurrentoffset()
1152
1153
1154 def __getfield_number(self):
1155 return self.__field_number.getvalue()
1156
1157 def __setfield_number(self, value):
1158 if isinstance(value,USTRING):
1159 self.__field_number=value
1160 else:
1161 self.__field_number=USTRING(value,**{'sizeinbytes': 49, 'raiseonunterminatedread': False})
1162
1163 def __delfield_number(self): del self.__field_number
1164
1165 number=property(__getfield_number, __setfield_number, __delfield_number, None)
1166
1167 def iscontainer(self):
1168 return True
1169
1170 def containerelements(self):
1171 yield ('number', self.__field_number, None)
1172
1173
1174
1175
1176 class pbreadentryresponse(BaseProtogenClass):
1177 "Results of reading one entry"
1178 __fields=['header', 'entry']
1179
1180 def __init__(self, *args, **kwargs):
1181 dict={}
1182 dict.update(kwargs)
1184 super(pbreadentryresponse,self).__init__(**dict)
1186 if self.__class__ is pbreadentryresponse:
1187 self._update(args,dict)
1188
1189
1190 def getfields(self):
1191 return self.__fields
1192
1193
1194 def _update(self, args, kwargs):
1195 super(pbreadentryresponse,self)._update(args,kwargs)
1196 keys=kwargs.keys()
1197 for key in keys:
1198 if key in self.__fields:
1199 setattr(self, key, kwargs[key])
1200 del kwargs[key]
1201 if __debug__:
1203 self._complainaboutunusedargs(pbreadentryresponse,kwargs)
1204 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1205
1207
1208 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1209 'Writes this packet to the supplied buffer'
1210 self._bufferstartoffset=buf.getcurrentoffset()
1211 self.__field_header.writetobuffer(buf)
1212 self.__field_entry.writetobuffer(buf)
1213 self._bufferendoffset=buf.getcurrentoffset()
1214 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1215
1216
1217 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1218 'Reads this packet from the supplied buffer'
1219 self._bufferstartoffset=buf.getcurrentoffset()
1220 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1221 self.__field_header=pbheader()
1222 self.__field_header.readfrombuffer(buf)
1223 self.__field_entry=pbentry()
1224 self.__field_entry.readfrombuffer(buf)
1225 self._bufferendoffset=buf.getcurrentoffset()
1226
1227
1228 def __getfield_header(self):
1229 return self.__field_header.getvalue()
1230
1231 def __setfield_header(self, value):
1232 if isinstance(value,pbheader):
1233 self.__field_header=value
1234 else:
1235 self.__field_header=pbheader(value,)
1236
1237 def __delfield_header(self): del self.__field_header
1238
1239 header=property(__getfield_header, __setfield_header, __delfield_header, None)
1240
1241 def __getfield_entry(self):
1242 return self.__field_entry.getvalue()
1243
1244 def __setfield_entry(self, value):
1245 if isinstance(value,pbentry):
1246 self.__field_entry=value
1247 else:
1248 self.__field_entry=pbentry(value,)
1249
1250 def __delfield_entry(self): del self.__field_entry
1251
1252 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
1253
1254 def iscontainer(self):
1255 return True
1256
1257 def containerelements(self):
1258 yield ('header', self.__field_header, None)
1259 yield ('entry', self.__field_entry, None)
1260
1261
1262
1263
1264 class pbupdateentryrequest(BaseProtogenClass):
1265 __fields=['header', 'entry']
1266
1267 def __init__(self, *args, **kwargs):
1268 dict={}
1269 dict.update(kwargs)
1271 super(pbupdateentryrequest,self).__init__(**dict)
1273 if self.__class__ is pbupdateentryrequest:
1274 self._update(args,dict)
1275
1276
1277 def getfields(self):
1278 return self.__fields
1279
1280
1281 def _update(self, args, kwargs):
1282 super(pbupdateentryrequest,self)._update(args,kwargs)
1283 keys=kwargs.keys()
1284 for key in keys:
1285 if key in self.__fields:
1286 setattr(self, key, kwargs[key])
1287 del kwargs[key]
1288 if __debug__:
1290 self._complainaboutunusedargs(pbupdateentryrequest,kwargs)
1291 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1292
1294
1295 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1296 'Writes this packet to the supplied buffer'
1297 self._bufferstartoffset=buf.getcurrentoffset()
1298 try: self.__field_header
1299 except:
1300 self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01})
1301 self.__field_header.writetobuffer(buf)
1302 self.__field_entry.writetobuffer(buf)
1303 self._bufferendoffset=buf.getcurrentoffset()
1304 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1305
1306
1307 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1308 'Reads this packet from the supplied buffer'
1309 self._bufferstartoffset=buf.getcurrentoffset()
1310 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1311 self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01})
1312 self.__field_header.readfrombuffer(buf)
1313 self.__field_entry=pbentry()
1314 self.__field_entry.readfrombuffer(buf)
1315 self._bufferendoffset=buf.getcurrentoffset()
1316
1317
1318 def __getfield_header(self):
1319 try: self.__field_header
1320 except:
1321 self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01})
1322 return self.__field_header.getvalue()
1323
1324 def __setfield_header(self, value):
1325 if isinstance(value,pbheader):
1326 self.__field_header=value
1327 else:
1328 self.__field_header=pbheader(value,**{'command': 0x04, 'flag': 0x01})
1329
1330 def __delfield_header(self): del self.__field_header
1331
1332 header=property(__getfield_header, __setfield_header, __delfield_header, None)
1333
1334 def __getfield_entry(self):
1335 return self.__field_entry.getvalue()
1336
1337 def __setfield_entry(self, value):
1338 if isinstance(value,pbentry):
1339 self.__field_entry=value
1340 else:
1341 self.__field_entry=pbentry(value,)
1342
1343 def __delfield_entry(self): del self.__field_entry
1344
1345 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
1346
1347 def iscontainer(self):
1348 return True
1349
1350 def containerelements(self):
1351 yield ('header', self.__field_header, None)
1352 yield ('entry', self.__field_entry, None)
1353
1354
1355
1356
1357 class pbappendentryrequest(BaseProtogenClass):
1358 __fields=['header', 'entry']
1359
1360 def __init__(self, *args, **kwargs):
1361 dict={}
1362 dict.update(kwargs)
1364 super(pbappendentryrequest,self).__init__(**dict)
1366 if self.__class__ is pbappendentryrequest:
1367 self._update(args,dict)
1368
1369
1370 def getfields(self):
1371 return self.__fields
1372
1373
1374 def _update(self, args, kwargs):
1375 super(pbappendentryrequest,self)._update(args,kwargs)
1376 keys=kwargs.keys()
1377 for key in keys:
1378 if key in self.__fields:
1379 setattr(self, key, kwargs[key])
1380 del kwargs[key]
1381 if __debug__:
1383 self._complainaboutunusedargs(pbappendentryrequest,kwargs)
1384 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1385
1387
1388 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1389 'Writes this packet to the supplied buffer'
1390 self._bufferstartoffset=buf.getcurrentoffset()
1391 try: self.__field_header
1392 except:
1393 self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01})
1394 self.__field_header.writetobuffer(buf)
1395 self.__field_entry.writetobuffer(buf)
1396 self._bufferendoffset=buf.getcurrentoffset()
1397 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1398
1399
1400 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1401 'Reads this packet from the supplied buffer'
1402 self._bufferstartoffset=buf.getcurrentoffset()
1403 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1404 self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01})
1405 self.__field_header.readfrombuffer(buf)
1406 self.__field_entry=pbentry()
1407 self.__field_entry.readfrombuffer(buf)
1408 self._bufferendoffset=buf.getcurrentoffset()
1409
1410
1411 def __getfield_header(self):
1412 try: self.__field_header
1413 except:
1414 self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01})
1415 return self.__field_header.getvalue()
1416
1417 def __setfield_header(self, value):
1418 if isinstance(value,pbheader):
1419 self.__field_header=value
1420 else:
1421 self.__field_header=pbheader(value,**{'command': 0x03, 'flag': 0x01})
1422
1423 def __delfield_header(self): del self.__field_header
1424
1425 header=property(__getfield_header, __setfield_header, __delfield_header, None)
1426
1427 def __getfield_entry(self):
1428 return self.__field_entry.getvalue()
1429
1430 def __setfield_entry(self, value):
1431 if isinstance(value,pbentry):
1432 self.__field_entry=value
1433 else:
1434 self.__field_entry=pbentry(value,)
1435
1436 def __delfield_entry(self): del self.__field_entry
1437
1438 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
1439
1440 def iscontainer(self):
1441 return True
1442
1443 def containerelements(self):
1444 yield ('header', self.__field_header, None)
1445 yield ('entry', self.__field_entry, None)
1446
1447
1448
1449
1450 class scheduleexception(BaseProtogenClass):
1451 __fields=['pos', 'day', 'month', 'year']
1452
1453 def __init__(self, *args, **kwargs):
1454 dict={}
1455 dict.update(kwargs)
1457 super(scheduleexception,self).__init__(**dict)
1459 if self.__class__ is scheduleexception:
1460 self._update(args,dict)
1461
1462
1463 def getfields(self):
1464 return self.__fields
1465
1466
1467 def _update(self, args, kwargs):
1468 super(scheduleexception,self)._update(args,kwargs)
1469 keys=kwargs.keys()
1470 for key in keys:
1471 if key in self.__fields:
1472 setattr(self, key, kwargs[key])
1473 del kwargs[key]
1474 if __debug__:
1476 self._complainaboutunusedargs(scheduleexception,kwargs)
1477 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1478
1480
1481 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1482 'Writes this packet to the supplied buffer'
1483 self._bufferstartoffset=buf.getcurrentoffset()
1484 self.__field_pos.writetobuffer(buf)
1485 self.__field_day.writetobuffer(buf)
1486 self.__field_month.writetobuffer(buf)
1487 self.__field_year.writetobuffer(buf)
1488 self._bufferendoffset=buf.getcurrentoffset()
1489 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1490
1491
1492 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1493 'Reads this packet from the supplied buffer'
1494 self._bufferstartoffset=buf.getcurrentoffset()
1495 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1496 self.__field_pos=UINT(**{'sizeinbytes': 4})
1497 self.__field_pos.readfrombuffer(buf)
1498 self.__field_day=UINT(**{'sizeinbytes': 1})
1499 self.__field_day.readfrombuffer(buf)
1500 self.__field_month=UINT(**{'sizeinbytes': 1})
1501 self.__field_month.readfrombuffer(buf)
1502 self.__field_year=UINT(**{'sizeinbytes': 2})
1503 self.__field_year.readfrombuffer(buf)
1504 self._bufferendoffset=buf.getcurrentoffset()
1505
1506
1507 def __getfield_pos(self):
1508 return self.__field_pos.getvalue()
1509
1510 def __setfield_pos(self, value):
1511 if isinstance(value,UINT):
1512 self.__field_pos=value
1513 else:
1514 self.__field_pos=UINT(value,**{'sizeinbytes': 4})
1515
1516 def __delfield_pos(self): del self.__field_pos
1517
1518 pos=property(__getfield_pos, __setfield_pos, __delfield_pos, "Refers to event id (position in schedule file) that this suppresses")
1519
1520 def __getfield_day(self):
1521 return self.__field_day.getvalue()
1522
1523 def __setfield_day(self, value):
1524 if isinstance(value,UINT):
1525 self.__field_day=value
1526 else:
1527 self.__field_day=UINT(value,**{'sizeinbytes': 1})
1528
1529 def __delfield_day(self): del self.__field_day
1530
1531 day=property(__getfield_day, __setfield_day, __delfield_day, None)
1532
1533 def __getfield_month(self):
1534 return self.__field_month.getvalue()
1535
1536 def __setfield_month(self, value):
1537 if isinstance(value,UINT):
1538 self.__field_month=value
1539 else:
1540 self.__field_month=UINT(value,**{'sizeinbytes': 1})
1541
1542 def __delfield_month(self): del self.__field_month
1543
1544 month=property(__getfield_month, __setfield_month, __delfield_month, None)
1545
1546 def __getfield_year(self):
1547 return self.__field_year.getvalue()
1548
1549 def __setfield_year(self, value):
1550 if isinstance(value,UINT):
1551 self.__field_year=value
1552 else:
1553 self.__field_year=UINT(value,**{'sizeinbytes': 2})
1554
1555 def __delfield_year(self): del self.__field_year
1556
1557 year=property(__getfield_year, __setfield_year, __delfield_year, None)
1558
1559 def iscontainer(self):
1560 return True
1561
1562 def containerelements(self):
1563 yield ('pos', self.__field_pos, "Refers to event id (position in schedule file) that this suppresses")
1564 yield ('day', self.__field_day, None)
1565 yield ('month', self.__field_month, None)
1566 yield ('year', self.__field_year, None)
1567
1568
1569
1570
1571 class scheduleexceptionfile(BaseProtogenClass):
1572 __fields=['items']
1573
1574 def __init__(self, *args, **kwargs):
1575 dict={}
1576 dict.update(kwargs)
1578 super(scheduleexceptionfile,self).__init__(**dict)
1580 if self.__class__ is scheduleexceptionfile:
1581 self._update(args,dict)
1582
1583
1584 def getfields(self):
1585 return self.__fields
1586
1587
1588 def _update(self, args, kwargs):
1589 super(scheduleexceptionfile,self)._update(args,kwargs)
1590 keys=kwargs.keys()
1591 for key in keys:
1592 if key in self.__fields:
1593 setattr(self, key, kwargs[key])
1594 del kwargs[key]
1595 if __debug__:
1597 self._complainaboutunusedargs(scheduleexceptionfile,kwargs)
1598 if len(args):
1599 dict2={'elementclass': scheduleexception}
1600 dict2.update(kwargs)
1601 kwargs=dict2
1602 self.__field_items=LIST(*args,**dict2)
1603
1605
1606 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1607 'Writes this packet to the supplied buffer'
1608 self._bufferstartoffset=buf.getcurrentoffset()
1609 try: self.__field_items
1610 except:
1611 self.__field_items=LIST(**{'elementclass': scheduleexception})
1612 self.__field_items.writetobuffer(buf)
1613 self._bufferendoffset=buf.getcurrentoffset()
1614 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1615
1616
1617 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1618 'Reads this packet from the supplied buffer'
1619 self._bufferstartoffset=buf.getcurrentoffset()
1620 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1621 self.__field_items=LIST(**{'elementclass': scheduleexception})
1622 self.__field_items.readfrombuffer(buf)
1623 self._bufferendoffset=buf.getcurrentoffset()
1624
1625
1626 def __getfield_items(self):
1627 try: self.__field_items
1628 except:
1629 self.__field_items=LIST(**{'elementclass': scheduleexception})
1630 return self.__field_items.getvalue()
1631
1632 def __setfield_items(self, value):
1633 if isinstance(value,LIST):
1634 self.__field_items=value
1635 else:
1636 self.__field_items=LIST(value,**{'elementclass': scheduleexception})
1637
1638 def __delfield_items(self): del self.__field_items
1639
1640 items=property(__getfield_items, __setfield_items, __delfield_items, None)
1641
1642 def iscontainer(self):
1643 return True
1644
1645 def containerelements(self):
1646 yield ('items', self.__field_items, None)
1647
1648
1649
1650
1651 class scheduleevent(BaseProtogenClass):
1652 __fields=['pos', 'start', 'end', 'repeat', 'daybitmap', 'alarmminutes', 'alarmhours', 'alarmtype', 'snoozedelay', 'ringtone', 'description', 'unknown1', 'hasvoice', 'voiceid', 'unknown2']
1653
1654 def __init__(self, *args, **kwargs):
1655 dict={}
1656 dict.update(kwargs)
1658 super(scheduleevent,self).__init__(**dict)
1660 if self.__class__ is scheduleevent:
1661 self._update(args,dict)
1662
1663
1664 def getfields(self):
1665 return self.__fields
1666
1667
1668 def _update(self, args, kwargs):
1669 super(scheduleevent,self)._update(args,kwargs)
1670 keys=kwargs.keys()
1671 for key in keys:
1672 if key in self.__fields:
1673 setattr(self, key, kwargs[key])
1674 del kwargs[key]
1675 if __debug__:
1677 self._complainaboutunusedargs(scheduleevent,kwargs)
1678 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1679
1681
1682 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1683 'Writes this packet to the supplied buffer'
1684 self._bufferstartoffset=buf.getcurrentoffset()
1685 self.__field_pos.writetobuffer(buf)
1686 self.__field_start.writetobuffer(buf)
1687 self.__field_end.writetobuffer(buf)
1688 self.__field_repeat.writetobuffer(buf)
1689 self.__field_daybitmap.writetobuffer(buf)
1690 self.__field_alarmminutes.writetobuffer(buf)
1691 self.__field_alarmhours.writetobuffer(buf)
1692 self.__field_alarmtype.writetobuffer(buf)
1693 try: self.__field_snoozedelay
1694 except:
1695 self.__field_snoozedelay=UINT(**{'sizeinbytes': 1, 'default': 0 })
1696 self.__field_snoozedelay.writetobuffer(buf)
1697 self.__field_ringtone.writetobuffer(buf)
1698 self.__field_description.writetobuffer(buf)
1699 try: self.__field_unknown1
1700 except:
1701 self.__field_unknown1=UINT(**{'sizeinbytes': 2, 'default': 0 })
1702 self.__field_unknown1.writetobuffer(buf)
1703 self.__field_hasvoice.writetobuffer(buf)
1704 self.__field_voiceid.writetobuffer(buf)
1705 try: self.__field_unknown2
1706 except:
1707 self.__field_unknown2=UINT(**{'sizeinbytes': 2, 'default': 0 })
1708 self.__field_unknown2.writetobuffer(buf)
1709 self._bufferendoffset=buf.getcurrentoffset()
1710 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1711
1712
1713 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1714 'Reads this packet from the supplied buffer'
1715 self._bufferstartoffset=buf.getcurrentoffset()
1716 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1717 self.__field_pos=UINT(**{'sizeinbytes': 4})
1718 self.__field_pos.readfrombuffer(buf)
1719 self.__field_start=LGCALDATE(**{'sizeinbytes': 4})
1720 self.__field_start.readfrombuffer(buf)
1721 self.__field_end=LGCALDATE(**{'sizeinbytes': 4})
1722 self.__field_end.readfrombuffer(buf)
1723 self.__field_repeat=UINT(**{'sizeinbytes': 1})
1724 self.__field_repeat.readfrombuffer(buf)
1725 self.__field_daybitmap=UINT(**{'sizeinbytes': 3})
1726 self.__field_daybitmap.readfrombuffer(buf)
1727 self.__field_alarmminutes=UINT(**{'sizeinbytes': 1})
1728 self.__field_alarmminutes.readfrombuffer(buf)
1729 self.__field_alarmhours=UINT(**{'sizeinbytes': 1})
1730 self.__field_alarmhours.readfrombuffer(buf)
1731 self.__field_alarmtype=UINT(**{'sizeinbytes': 1})
1732 self.__field_alarmtype.readfrombuffer(buf)
1733 self.__field_snoozedelay=UINT(**{'sizeinbytes': 1, 'default': 0 })
1734 self.__field_snoozedelay.readfrombuffer(buf)
1735 self.__field_ringtone=UINT(**{'sizeinbytes': 1})
1736 self.__field_ringtone.readfrombuffer(buf)
1737 self.__field_description=USTRING(**{'sizeinbytes': 35, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False })
1738 self.__field_description.readfrombuffer(buf)
1739 self.__field_unknown1=UINT(**{'sizeinbytes': 2, 'default': 0 })
1740 self.__field_unknown1.readfrombuffer(buf)
1741 self.__field_hasvoice=UINT(**{'sizeinbytes': 2})
1742 self.__field_hasvoice.readfrombuffer(buf)
1743 self.__field_voiceid=UINT(**{'sizeinbytes': 2})
1744 self.__field_voiceid.readfrombuffer(buf)
1745 self.__field_unknown2=UINT(**{'sizeinbytes': 2, 'default': 0 })
1746 self.__field_unknown2.readfrombuffer(buf)
1747 self._bufferendoffset=buf.getcurrentoffset()
1748
1749
1750 def __getfield_pos(self):
1751 return self.__field_pos.getvalue()
1752
1753 def __setfield_pos(self, value):
1754 if isinstance(value,UINT):
1755 self.__field_pos=value
1756 else:
1757 self.__field_pos=UINT(value,**{'sizeinbytes': 4})
1758
1759 def __delfield_pos(self): del self.__field_pos
1760
1761 pos=property(__getfield_pos, __setfield_pos, __delfield_pos, "position within file, used as an event id")
1762
1763 def __getfield_start(self):
1764 return self.__field_start.getvalue()
1765
1766 def __setfield_start(self, value):
1767 if isinstance(value,LGCALDATE):
1768 self.__field_start=value
1769 else:
1770 self.__field_start=LGCALDATE(value,**{'sizeinbytes': 4})
1771
1772 def __delfield_start(self): del self.__field_start
1773
1774 start=property(__getfield_start, __setfield_start, __delfield_start, None)
1775
1776 def __getfield_end(self):
1777 return self.__field_end.getvalue()
1778
1779 def __setfield_end(self, value):
1780 if isinstance(value,LGCALDATE):
1781 self.__field_end=value
1782 else:
1783 self.__field_end=LGCALDATE(value,**{'sizeinbytes': 4})
1784
1785 def __delfield_end(self): del self.__field_end
1786
1787 end=property(__getfield_end, __setfield_end, __delfield_end, None)
1788
1789 def __getfield_repeat(self):
1790 return self.__field_repeat.getvalue()
1791
1792 def __setfield_repeat(self, value):
1793 if isinstance(value,UINT):
1794 self.__field_repeat=value
1795 else:
1796 self.__field_repeat=UINT(value,**{'sizeinbytes': 1})
1797
1798 def __delfield_repeat(self): del self.__field_repeat
1799
1800 repeat=property(__getfield_repeat, __setfield_repeat, __delfield_repeat, "Repeat?")
1801
1802 def __getfield_daybitmap(self):
1803 return self.__field_daybitmap.getvalue()
1804
1805 def __setfield_daybitmap(self, value):
1806 if isinstance(value,UINT):
1807 self.__field_daybitmap=value
1808 else:
1809 self.__field_daybitmap=UINT(value,**{'sizeinbytes': 3})
1810
1811 def __delfield_daybitmap(self): del self.__field_daybitmap
1812
1813 daybitmap=property(__getfield_daybitmap, __setfield_daybitmap, __delfield_daybitmap, "which days a weekly repeat event happens on?")
1814
1815 def __getfield_alarmminutes(self):
1816 return self.__field_alarmminutes.getvalue()
1817
1818 def __setfield_alarmminutes(self, value):
1819 if isinstance(value,UINT):
1820 self.__field_alarmminutes=value
1821 else:
1822 self.__field_alarmminutes=UINT(value,**{'sizeinbytes': 1})
1823
1824 def __delfield_alarmminutes(self): del self.__field_alarmminutes
1825
1826 alarmminutes=property(__getfield_alarmminutes, __setfield_alarmminutes, __delfield_alarmminutes, "a value of 100 indicates not set")
1827
1828 def __getfield_alarmhours(self):
1829 return self.__field_alarmhours.getvalue()
1830
1831 def __setfield_alarmhours(self, value):
1832 if isinstance(value,UINT):
1833 self.__field_alarmhours=value
1834 else:
1835 self.__field_alarmhours=UINT(value,**{'sizeinbytes': 1})
1836
1837 def __delfield_alarmhours(self): del self.__field_alarmhours
1838
1839 alarmhours=property(__getfield_alarmhours, __setfield_alarmhours, __delfield_alarmhours, "a value of 100 indicates not set")
1840
1841 def __getfield_alarmtype(self):
1842 return self.__field_alarmtype.getvalue()
1843
1844 def __setfield_alarmtype(self, value):
1845 if isinstance(value,UINT):
1846 self.__field_alarmtype=value
1847 else:
1848 self.__field_alarmtype=UINT(value,**{'sizeinbytes': 1})
1849
1850 def __delfield_alarmtype(self): del self.__field_alarmtype
1851
1852 alarmtype=property(__getfield_alarmtype, __setfield_alarmtype, __delfield_alarmtype, "preset alarm reminder type")
1853
1854 def __getfield_snoozedelay(self):
1855 try: self.__field_snoozedelay
1856 except:
1857 self.__field_snoozedelay=UINT(**{'sizeinbytes': 1, 'default': 0 })
1858 return self.__field_snoozedelay.getvalue()
1859
1860 def __setfield_snoozedelay(self, value):
1861 if isinstance(value,UINT):
1862 self.__field_snoozedelay=value
1863 else:
1864 self.__field_snoozedelay=UINT(value,**{'sizeinbytes': 1, 'default': 0 })
1865
1866 def __delfield_snoozedelay(self): del self.__field_snoozedelay
1867
1868 snoozedelay=property(__getfield_snoozedelay, __setfield_snoozedelay, __delfield_snoozedelay, "in minutes?")
1869
1870 def __getfield_ringtone(self):
1871 return self.__field_ringtone.getvalue()
1872
1873 def __setfield_ringtone(self, value):
1874 if isinstance(value,UINT):
1875 self.__field_ringtone=value
1876 else:
1877 self.__field_ringtone=UINT(value,**{'sizeinbytes': 1})
1878
1879 def __delfield_ringtone(self): del self.__field_ringtone
1880
1881 ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None)
1882
1883 def __getfield_description(self):
1884 return self.__field_description.getvalue()
1885
1886 def __setfield_description(self, value):
1887 if isinstance(value,USTRING):
1888 self.__field_description=value
1889 else:
1890 self.__field_description=USTRING(value,**{'sizeinbytes': 35, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False })
1891
1892 def __delfield_description(self): del self.__field_description
1893
1894 description=property(__getfield_description, __setfield_description, __delfield_description, None)
1895
1896 def __getfield_unknown1(self):
1897 try: self.__field_unknown1
1898 except:
1899 self.__field_unknown1=UINT(**{'sizeinbytes': 2, 'default': 0 })
1900 return self.__field_unknown1.getvalue()
1901
1902 def __setfield_unknown1(self, value):
1903 if isinstance(value,UINT):
1904 self.__field_unknown1=value
1905 else:
1906 self.__field_unknown1=UINT(value,**{'sizeinbytes': 2, 'default': 0 })
1907
1908 def __delfield_unknown1(self): del self.__field_unknown1
1909
1910 unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, "This seems to always be two zeros")
1911
1912 def __getfield_hasvoice(self):
1913 return self.__field_hasvoice.getvalue()
1914
1915 def __setfield_hasvoice(self, value):
1916 if isinstance(value,UINT):
1917 self.__field_hasvoice=value
1918 else:
1919 self.__field_hasvoice=UINT(value,**{'sizeinbytes': 2})
1920
1921 def __delfield_hasvoice(self): del self.__field_hasvoice
1922
1923 hasvoice=property(__getfield_hasvoice, __setfield_hasvoice, __delfield_hasvoice, "This event has an associated voice memo if 1")
1924
1925 def __getfield_voiceid(self):
1926 return self.__field_voiceid.getvalue()
1927
1928 def __setfield_voiceid(self, value):
1929 if isinstance(value,UINT):
1930 self.__field_voiceid=value
1931 else:
1932 self.__field_voiceid=UINT(value,**{'sizeinbytes': 2})
1933
1934 def __delfield_voiceid(self): del self.__field_voiceid
1935
1936 voiceid=property(__getfield_voiceid, __setfield_voiceid, __delfield_voiceid, "sch/schexxx.qcp is the voice memo (xxx = voiceid - 0x0f)")
1937
1938 def __getfield_unknown2(self):
1939 try: self.__field_unknown2
1940 except:
1941 self.__field_unknown2=UINT(**{'sizeinbytes': 2, 'default': 0 })
1942 return self.__field_unknown2.getvalue()
1943
1944 def __setfield_unknown2(self, value):
1945 if isinstance(value,UINT):
1946 self.__field_unknown2=value
1947 else:
1948 self.__field_unknown2=UINT(value,**{'sizeinbytes': 2, 'default': 0 })
1949
1950 def __delfield_unknown2(self): del self.__field_unknown2
1951
1952 unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, "This seems to always be yet two more zeros")
1953
1954 def iscontainer(self):
1955 return True
1956
1957 def containerelements(self):
1958 yield ('pos', self.__field_pos, "position within file, used as an event id")
1959 yield ('start', self.__field_start, None)
1960 yield ('end', self.__field_end, None)
1961 yield ('repeat', self.__field_repeat, "Repeat?")
1962 yield ('daybitmap', self.__field_daybitmap, "which days a weekly repeat event happens on?")
1963 yield ('alarmminutes', self.__field_alarmminutes, "a value of 100 indicates not set")
1964 yield ('alarmhours', self.__field_alarmhours, "a value of 100 indicates not set")
1965 yield ('alarmtype', self.__field_alarmtype, "preset alarm reminder type")
1966 yield ('snoozedelay', self.__field_snoozedelay, "in minutes?")
1967 yield ('ringtone', self.__field_ringtone, None)
1968 yield ('description', self.__field_description, None)
1969 yield ('unknown1', self.__field_unknown1, "This seems to always be two zeros")
1970 yield ('hasvoice', self.__field_hasvoice, "This event has an associated voice memo if 1")
1971 yield ('voiceid', self.__field_voiceid, "sch/schexxx.qcp is the voice memo (xxx = voiceid - 0x0f)")
1972 yield ('unknown2', self.__field_unknown2, "This seems to always be yet two more zeros")
1973
1974
1975
1976
1977 class schedulefile(BaseProtogenClass):
1978 __fields=['numactiveitems', 'events']
1979
1980 def __init__(self, *args, **kwargs):
1981 dict={}
1982 dict.update(kwargs)
1984 super(schedulefile,self).__init__(**dict)
1986 if self.__class__ is schedulefile:
1987 self._update(args,dict)
1988
1989
1990 def getfields(self):
1991 return self.__fields
1992
1993
1994 def _update(self, args, kwargs):
1995 super(schedulefile,self)._update(args,kwargs)
1996 keys=kwargs.keys()
1997 for key in keys:
1998 if key in self.__fields:
1999 setattr(self, key, kwargs[key])
2000 del kwargs[key]
2001 if __debug__:
2003 self._complainaboutunusedargs(schedulefile,kwargs)
2004 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2005
2007
2008 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2009 'Writes this packet to the supplied buffer'
2010 self._bufferstartoffset=buf.getcurrentoffset()
2011 self.__field_numactiveitems.writetobuffer(buf)
2012 try: self.__field_events
2013 except:
2014 self.__field_events=LIST(**{'elementclass': scheduleevent})
2015 self.__field_events.writetobuffer(buf)
2016 self._bufferendoffset=buf.getcurrentoffset()
2017 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2018
2019
2020 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2021 'Reads this packet from the supplied buffer'
2022 self._bufferstartoffset=buf.getcurrentoffset()
2023 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2024 self.__field_numactiveitems=UINT(**{'sizeinbytes': 2})
2025 self.__field_numactiveitems.readfrombuffer(buf)
2026 self.__field_events=LIST(**{'elementclass': scheduleevent})
2027 self.__field_events.readfrombuffer(buf)
2028 self._bufferendoffset=buf.getcurrentoffset()
2029
2030
2031 def __getfield_numactiveitems(self):
2032 return self.__field_numactiveitems.getvalue()
2033
2034 def __setfield_numactiveitems(self, value):
2035 if isinstance(value,UINT):
2036 self.__field_numactiveitems=value
2037 else:
2038 self.__field_numactiveitems=UINT(value,**{'sizeinbytes': 2})
2039
2040 def __delfield_numactiveitems(self): del self.__field_numactiveitems
2041
2042 numactiveitems=property(__getfield_numactiveitems, __setfield_numactiveitems, __delfield_numactiveitems, None)
2043
2044 def __getfield_events(self):
2045 try: self.__field_events
2046 except:
2047 self.__field_events=LIST(**{'elementclass': scheduleevent})
2048 return self.__field_events.getvalue()
2049
2050 def __setfield_events(self, value):
2051 if isinstance(value,LIST):
2052 self.__field_events=value
2053 else:
2054 self.__field_events=LIST(value,**{'elementclass': scheduleevent})
2055
2056 def __delfield_events(self): del self.__field_events
2057
2058 events=property(__getfield_events, __setfield_events, __delfield_events, None)
2059
2060 def iscontainer(self):
2061 return True
2062
2063 def containerelements(self):
2064 yield ('numactiveitems', self.__field_numactiveitems, None)
2065 yield ('events', self.__field_events, None)
2066
2067
2068
2069
2070 class camindexentry(BaseProtogenClass):
2071 __fields=['index', 'name', 'taken', 'dunno']
2072
2073 def __init__(self, *args, **kwargs):
2074 dict={}
2075 dict.update(kwargs)
2077 super(camindexentry,self).__init__(**dict)
2079 if self.__class__ is camindexentry:
2080 self._update(args,dict)
2081
2082
2083 def getfields(self):
2084 return self.__fields
2085
2086
2087 def _update(self, args, kwargs):
2088 super(camindexentry,self)._update(args,kwargs)
2089 keys=kwargs.keys()
2090 for key in keys:
2091 if key in self.__fields:
2092 setattr(self, key, kwargs[key])
2093 del kwargs[key]
2094 if __debug__:
2096 self._complainaboutunusedargs(camindexentry,kwargs)
2097 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2098
2100
2101 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2102 'Writes this packet to the supplied buffer'
2103 self._bufferstartoffset=buf.getcurrentoffset()
2104 try: self.__field_index
2105 except:
2106 self.__field_index=UINT(**{'sizeinbytes': 1, 'default': 0})
2107 self.__field_index.writetobuffer(buf)
2108 try: self.__field_name
2109 except:
2110 self.__field_name=USTRING(**{'sizeinbytes': 11, 'default': ""})
2111 self.__field_name.writetobuffer(buf)
2112 try: self.__field_taken
2113 except:
2114 self.__field_taken=LGCALDATE(**{'sizeinbytes': 4})
2115 self.__field_taken.writetobuffer(buf)
2116 try: self.__field_dunno
2117 except:
2118 self.__field_dunno=UINT(**{'sizeinbytes': 4, 'default': 0x00ff0100})
2119 self.__field_dunno.writetobuffer(buf)
2120 self._bufferendoffset=buf.getcurrentoffset()
2121 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2122
2123
2124 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2125 'Reads this packet from the supplied buffer'
2126 self._bufferstartoffset=buf.getcurrentoffset()
2127 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2128 self.__field_index=UINT(**{'sizeinbytes': 1, 'default': 0})
2129 self.__field_index.readfrombuffer(buf)
2130 self.__field_name=USTRING(**{'sizeinbytes': 11, 'default': ""})
2131 self.__field_name.readfrombuffer(buf)
2132 self.__field_taken=LGCALDATE(**{'sizeinbytes': 4})
2133 self.__field_taken.readfrombuffer(buf)
2134 self.__field_dunno=UINT(**{'sizeinbytes': 4, 'default': 0x00ff0100})
2135 self.__field_dunno.readfrombuffer(buf)
2136 self._bufferendoffset=buf.getcurrentoffset()
2137
2138
2139 def __getfield_index(self):
2140 try: self.__field_index
2141 except:
2142 self.__field_index=UINT(**{'sizeinbytes': 1, 'default': 0})
2143 return self.__field_index.getvalue()
2144
2145 def __setfield_index(self, value):
2146 if isinstance(value,UINT):
2147 self.__field_index=value
2148 else:
2149 self.__field_index=UINT(value,**{'sizeinbytes': 1, 'default': 0})
2150
2151 def __delfield_index(self): del self.__field_index
2152
2153 index=property(__getfield_index, __setfield_index, __delfield_index, None)
2154
2155 def __getfield_name(self):
2156 try: self.__field_name
2157 except:
2158 self.__field_name=USTRING(**{'sizeinbytes': 11, 'default': ""})
2159 return self.__field_name.getvalue()
2160
2161 def __setfield_name(self, value):
2162 if isinstance(value,USTRING):
2163 self.__field_name=value
2164 else:
2165 self.__field_name=USTRING(value,**{'sizeinbytes': 11, 'default': ""})
2166
2167 def __delfield_name(self): del self.__field_name
2168
2169 name=property(__getfield_name, __setfield_name, __delfield_name, None)
2170
2171 def __getfield_taken(self):
2172 try: self.__field_taken
2173 except:
2174 self.__field_taken=LGCALDATE(**{'sizeinbytes': 4})
2175 return self.__field_taken.getvalue()
2176
2177 def __setfield_taken(self, value):
2178 if isinstance(value,LGCALDATE):
2179 self.__field_taken=value
2180 else:
2181 self.__field_taken=LGCALDATE(value,**{'sizeinbytes': 4})
2182
2183 def __delfield_taken(self): del self.__field_taken
2184
2185 taken=property(__getfield_taken, __setfield_taken, __delfield_taken, None)
2186
2187 def __getfield_dunno(self):
2188 try: self.__field_dunno
2189 except:
2190 self.__field_dunno=UINT(**{'sizeinbytes': 4, 'default': 0x00ff0100})
2191 return self.__field_dunno.getvalue()
2192
2193 def __setfield_dunno(self, value):
2194 if isinstance(value,UINT):
2195 self.__field_dunno=value
2196 else:
2197 self.__field_dunno=UINT(value,**{'sizeinbytes': 4, 'default': 0x00ff0100})
2198
2199 def __delfield_dunno(self): del self.__field_dunno
2200
2201 dunno=property(__getfield_dunno, __setfield_dunno, __delfield_dunno, None)
2202
2203 def iscontainer(self):
2204 return True
2205
2206 def containerelements(self):
2207 yield ('index', self.__field_index, None)
2208 yield ('name', self.__field_name, None)
2209 yield ('taken', self.__field_taken, None)
2210 yield ('dunno', self.__field_dunno, None)
2211
2212
2213
2214
2215 class campicsdat(BaseProtogenClass):
2216 "the cam/pics.dat file"
2217 __fields=['items']
2218
2219 def __init__(self, *args, **kwargs):
2220 dict={}
2221 dict.update(kwargs)
2223 super(campicsdat,self).__init__(**dict)
2225 if self.__class__ is campicsdat:
2226 self._update(args,dict)
2227
2228
2229 def getfields(self):
2230 return self.__fields
2231
2232
2233 def _update(self, args, kwargs):
2234 super(campicsdat,self)._update(args,kwargs)
2235 keys=kwargs.keys()
2236 for key in keys:
2237 if key in self.__fields:
2238 setattr(self, key, kwargs[key])
2239 del kwargs[key]
2240 if __debug__:
2242 self._complainaboutunusedargs(campicsdat,kwargs)
2243 if len(args):
2244 dict2={'length': 60, 'elementclass': camindexentry, 'createdefault': True}
2245 dict2.update(kwargs)
2246 kwargs=dict2
2247 self.__field_items=LIST(*args,**dict2)
2248
2250
2251 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2252 'Writes this packet to the supplied buffer'
2253 self._bufferstartoffset=buf.getcurrentoffset()
2254 try: self.__field_items
2255 except:
2256 self.__field_items=LIST(**{'length': 60, 'elementclass': camindexentry, 'createdefault': True})
2257 self.__field_items.writetobuffer(buf)
2258 self._bufferendoffset=buf.getcurrentoffset()
2259 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2260
2261
2262 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2263 'Reads this packet from the supplied buffer'
2264 self._bufferstartoffset=buf.getcurrentoffset()
2265 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2266 self.__field_items=LIST(**{'length': 60, 'elementclass': camindexentry, 'createdefault': True})
2267 self.__field_items.readfrombuffer(buf)
2268 self._bufferendoffset=buf.getcurrentoffset()
2269
2270
2271 def __getfield_items(self):
2272 try: self.__field_items
2273 except:
2274 self.__field_items=LIST(**{'length': 60, 'elementclass': camindexentry, 'createdefault': True})
2275 return self.__field_items.getvalue()
2276
2277 def __setfield_items(self, value):
2278 if isinstance(value,LIST):
2279 self.__field_items=value
2280 else:
2281 self.__field_items=LIST(value,**{'length': 60, 'elementclass': camindexentry, 'createdefault': True})
2282
2283 def __delfield_items(self): del self.__field_items
2284
2285 items=property(__getfield_items, __setfield_items, __delfield_items, None)
2286
2287 def iscontainer(self):
2288 return True
2289
2290 def containerelements(self):
2291 yield ('items', self.__field_items, None)
2292
2293
2294
2295
2296 class call(BaseProtogenClass):
2297 __fields=['GPStime', 'unknown1', 'duration', 'number', 'name', 'numberlength', 'unknown2', 'pbnumbertype', 'unknown3', 'pbentrynum', 'unknown9']
2298
2299 def __init__(self, *args, **kwargs):
2300 dict={}
2301 dict.update(kwargs)
2303 super(call,self).__init__(**dict)
2305 if self.__class__ is call:
2306 self._update(args,dict)
2307
2308
2309 def getfields(self):
2310 return self.__fields
2311
2312
2313 def _update(self, args, kwargs):
2314 super(call,self)._update(args,kwargs)
2315 keys=kwargs.keys()
2316 for key in keys:
2317 if key in self.__fields:
2318 setattr(self, key, kwargs[key])
2319 del kwargs[key]
2320 if __debug__:
2322 self._complainaboutunusedargs(call,kwargs)
2323 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2324
2326
2327 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2328 'Writes this packet to the supplied buffer'
2329 self._bufferstartoffset=buf.getcurrentoffset()
2330 self.__field_GPStime.writetobuffer(buf)
2331 self.__field_unknown1.writetobuffer(buf)
2332 self.__field_duration.writetobuffer(buf)
2333 self.__field_number.writetobuffer(buf)
2334 self.__field_name.writetobuffer(buf)
2335 self.__field_numberlength.writetobuffer(buf)
2336 self.__field_unknown2.writetobuffer(buf)
2337 self.__field_pbnumbertype.writetobuffer(buf)
2338 self.__field_unknown3.writetobuffer(buf)
2339 self.__field_pbentrynum.writetobuffer(buf)
2340 self.__field_unknown9.writetobuffer(buf)
2341 self._bufferendoffset=buf.getcurrentoffset()
2342 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2343
2344
2345 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2346 'Reads this packet from the supplied buffer'
2347 self._bufferstartoffset=buf.getcurrentoffset()
2348 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2349 self.__field_GPStime=GPSDATE(**{'sizeinbytes': 4})
2350 self.__field_GPStime.readfrombuffer(buf)
2351 self.__field_unknown1=UINT(**{'sizeinbytes': 4})
2352 self.__field_unknown1.readfrombuffer(buf)
2353 self.__field_duration=UINT(**{'sizeinbytes': 4})
2354 self.__field_duration.readfrombuffer(buf)
2355 self.__field_number=USTRING(**{'sizeinbytes': 49, 'raiseonunterminatedread': False})
2356 self.__field_number.readfrombuffer(buf)
2357 self.__field_name=USTRING(**{'sizeinbytes': 36, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})
2358 self.__field_name.readfrombuffer(buf)
2359 self.__field_numberlength=UINT(**{'sizeinbytes': 1})
2360 self.__field_numberlength.readfrombuffer(buf)
2361 self.__field_unknown2=UINT(**{'sizeinbytes': 1})
2362 self.__field_unknown2.readfrombuffer(buf)
2363 self.__field_pbnumbertype=UINT(**{'sizeinbytes': 1})
2364 self.__field_pbnumbertype.readfrombuffer(buf)
2365 self.__field_unknown3=UINT(**{'sizeinbytes': 2})
2366 self.__field_unknown3.readfrombuffer(buf)
2367 self.__field_pbentrynum=UINT(**{'sizeinbytes': 2})
2368 self.__field_pbentrynum.readfrombuffer(buf)
2369 self.__field_unknown9=UINT(**{'sizeinbytes': 9})
2370 self.__field_unknown9.readfrombuffer(buf)
2371 self._bufferendoffset=buf.getcurrentoffset()
2372
2373
2374 def __getfield_GPStime(self):
2375 return self.__field_GPStime.getvalue()
2376
2377 def __setfield_GPStime(self, value):
2378 if isinstance(value,GPSDATE):
2379 self.__field_GPStime=value
2380 else:
2381 self.__field_GPStime=GPSDATE(value,**{'sizeinbytes': 4})
2382
2383 def __delfield_GPStime(self): del self.__field_GPStime
2384
2385 GPStime=property(__getfield_GPStime, __setfield_GPStime, __delfield_GPStime, None)
2386
2387 def __getfield_unknown1(self):
2388 return self.__field_unknown1.getvalue()
2389
2390 def __setfield_unknown1(self, value):
2391 if isinstance(value,UINT):
2392 self.__field_unknown1=value
2393 else:
2394 self.__field_unknown1=UINT(value,**{'sizeinbytes': 4})
2395
2396 def __delfield_unknown1(self): del self.__field_unknown1
2397
2398 unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None)
2399
2400 def __getfield_duration(self):
2401 return self.__field_duration.getvalue()
2402
2403 def __setfield_duration(self, value):
2404 if isinstance(value,UINT):
2405 self.__field_duration=value
2406 else:
2407 self.__field_duration=UINT(value,**{'sizeinbytes': 4})
2408
2409 def __delfield_duration(self): del self.__field_duration
2410
2411 duration=property(__getfield_duration, __setfield_duration, __delfield_duration, None)
2412
2413 def __getfield_number(self):
2414 return self.__field_number.getvalue()
2415
2416 def __setfield_number(self, value):
2417 if isinstance(value,USTRING):
2418 self.__field_number=value
2419 else:
2420 self.__field_number=USTRING(value,**{'sizeinbytes': 49, 'raiseonunterminatedread': False})
2421
2422 def __delfield_number(self): del self.__field_number
2423
2424 number=property(__getfield_number, __setfield_number, __delfield_number, None)
2425
2426 def __getfield_name(self):
2427 return self.__field_name.getvalue()
2428
2429 def __setfield_name(self, value):
2430 if isinstance(value,USTRING):
2431 self.__field_name=value
2432 else:
2433 self.__field_name=USTRING(value,**{'sizeinbytes': 36, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})
2434
2435 def __delfield_name(self): del self.__field_name
2436
2437 name=property(__getfield_name, __setfield_name, __delfield_name, None)
2438
2439 def __getfield_numberlength(self):
2440 return self.__field_numberlength.getvalue()
2441
2442 def __setfield_numberlength(self, value):
2443 if isinstance(value,UINT):
2444 self.__field_numberlength=value
2445 else:
2446 self.__field_numberlength=UINT(value,**{'sizeinbytes': 1})
2447
2448 def __delfield_numberlength(self): del self.__field_numberlength
2449
2450 numberlength=property(__getfield_numberlength, __setfield_numberlength, __delfield_numberlength, None)
2451
2452 def __getfield_unknown2(self):
2453 return self.__field_unknown2.getvalue()
2454
2455 def __setfield_unknown2(self, value):
2456 if isinstance(value,UINT):
2457 self.__field_unknown2=value
2458 else:
2459 self.__field_unknown2=UINT(value,**{'sizeinbytes': 1})
2460
2461 def __delfield_unknown2(self): del self.__field_unknown2
2462
2463 unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None)
2464
2465 def __getfield_pbnumbertype(self):
2466 return self.__field_pbnumbertype.getvalue()
2467
2468 def __setfield_pbnumbertype(self, value):
2469 if isinstance(value,UINT):
2470 self.__field_pbnumbertype=value
2471 else:
2472 self.__field_pbnumbertype=UINT(value,**{'sizeinbytes': 1})
2473
2474 def __delfield_pbnumbertype(self): del self.__field_pbnumbertype
2475
2476 pbnumbertype=property(__getfield_pbnumbertype, __setfield_pbnumbertype, __delfield_pbnumbertype, None)
2477
2478 def __getfield_unknown3(self):
2479 return self.__field_unknown3.getvalue()
2480
2481 def __setfield_unknown3(self, value):
2482 if isinstance(value,UINT):
2483 self.__field_unknown3=value
2484 else:
2485 self.__field_unknown3=UINT(value,**{'sizeinbytes': 2})
2486
2487 def __delfield_unknown3(self): del self.__field_unknown3
2488
2489 unknown3=property(__getfield_unknown3, __setfield_unknown3, __delfield_unknown3, None)
2490
2491 def __getfield_pbentrynum(self):
2492 return self.__field_pbentrynum.getvalue()
2493
2494 def __setfield_pbentrynum(self, value):
2495 if isinstance(value,UINT):
2496 self.__field_pbentrynum=value
2497 else:
2498 self.__field_pbentrynum=UINT(value,**{'sizeinbytes': 2})
2499
2500 def __delfield_pbentrynum(self): del self.__field_pbentrynum
2501
2502 pbentrynum=property(__getfield_pbentrynum, __setfield_pbentrynum, __delfield_pbentrynum, None)
2503
2504 def __getfield_unknown9(self):
2505 return self.__field_unknown9.getvalue()
2506
2507 def __setfield_unknown9(self, value):
2508 if isinstance(value,UINT):
2509 self.__field_unknown9=value
2510 else:
2511 self.__field_unknown9=UINT(value,**{'sizeinbytes': 9})
2512
2513 def __delfield_unknown9(self): del self.__field_unknown9
2514
2515 unknown9=property(__getfield_unknown9, __setfield_unknown9, __delfield_unknown9, None)
2516
2517 def iscontainer(self):
2518 return True
2519
2520 def containerelements(self):
2521 yield ('GPStime', self.__field_GPStime, None)
2522 yield ('unknown1', self.__field_unknown1, None)
2523 yield ('duration', self.__field_duration, None)
2524 yield ('number', self.__field_number, None)
2525 yield ('name', self.__field_name, None)
2526 yield ('numberlength', self.__field_numberlength, None)
2527 yield ('unknown2', self.__field_unknown2, None)
2528 yield ('pbnumbertype', self.__field_pbnumbertype, None)
2529 yield ('unknown3', self.__field_unknown3, None)
2530 yield ('pbentrynum', self.__field_pbentrynum, None)
2531 yield ('unknown9', self.__field_unknown9, None)
2532
2533
2534
2535
2536 class callhistory(BaseProtogenClass):
2537 __fields=['numcalls', 'unknown1', 'calls']
2538
2539 def __init__(self, *args, **kwargs):
2540 dict={}
2541 dict.update(kwargs)
2543 super(callhistory,self).__init__(**dict)
2545 if self.__class__ is callhistory:
2546 self._update(args,dict)
2547
2548
2549 def getfields(self):
2550 return self.__fields
2551
2552
2553 def _update(self, args, kwargs):
2554 super(callhistory,self)._update(args,kwargs)
2555 keys=kwargs.keys()
2556 for key in keys:
2557 if key in self.__fields:
2558 setattr(self, key, kwargs[key])
2559 del kwargs[key]
2560 if __debug__:
2562 self._complainaboutunusedargs(callhistory,kwargs)
2563 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2564
2566
2567 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2568 'Writes this packet to the supplied buffer'
2569 self._bufferstartoffset=buf.getcurrentoffset()
2570 self.__field_numcalls.writetobuffer(buf)
2571 self.__field_unknown1.writetobuffer(buf)
2572 try: self.__field_calls
2573 except:
2574 self.__field_calls=LIST(**{'elementclass': call})
2575 self.__field_calls.writetobuffer(buf)
2576 self._bufferendoffset=buf.getcurrentoffset()
2577 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2578
2579
2580 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2581 'Reads this packet from the supplied buffer'
2582 self._bufferstartoffset=buf.getcurrentoffset()
2583 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2584 self.__field_numcalls=UINT(**{'sizeinbytes': 4})
2585 self.__field_numcalls.readfrombuffer(buf)
2586 self.__field_unknown1=UINT(**{'sizeinbytes': 1})
2587 self.__field_unknown1.readfrombuffer(buf)
2588 self.__field_calls=LIST(**{'elementclass': call})
2589 self.__field_calls.readfrombuffer(buf)
2590 self._bufferendoffset=buf.getcurrentoffset()
2591
2592
2593 def __getfield_numcalls(self):
2594 return self.__field_numcalls.getvalue()
2595
2596 def __setfield_numcalls(self, value):
2597 if isinstance(value,UINT):
2598 self.__field_numcalls=value
2599 else:
2600 self.__field_numcalls=UINT(value,**{'sizeinbytes': 4})
2601
2602 def __delfield_numcalls(self): del self.__field_numcalls
2603
2604 numcalls=property(__getfield_numcalls, __setfield_numcalls, __delfield_numcalls, None)
2605
2606 def __getfield_unknown1(self):
2607 return self.__field_unknown1.getvalue()
2608
2609 def __setfield_unknown1(self, value):
2610 if isinstance(value,UINT):
2611 self.__field_unknown1=value
2612 else:
2613 self.__field_unknown1=UINT(value,**{'sizeinbytes': 1})
2614
2615 def __delfield_unknown1(self): del self.__field_unknown1
2616
2617 unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None)
2618
2619 def __getfield_calls(self):
2620 try: self.__field_calls
2621 except:
2622 self.__field_calls=LIST(**{'elementclass': call})
2623 return self.__field_calls.getvalue()
2624
2625 def __setfield_calls(self, value):
2626 if isinstance(value,LIST):
2627 self.__field_calls=value
2628 else:
2629 self.__field_calls=LIST(value,**{'elementclass': call})
2630
2631 def __delfield_calls(self): del self.__field_calls
2632
2633 calls=property(__getfield_calls, __setfield_calls, __delfield_calls, None)
2634
2635 def iscontainer(self):
2636 return True
2637
2638 def containerelements(self):
2639 yield ('numcalls', self.__field_numcalls, None)
2640 yield ('unknown1', self.__field_unknown1, None)
2641 yield ('calls', self.__field_calls, None)
2642
2643
2644
2645
2646 class firmwareresponse(BaseProtogenClass):
2647 __fields=['command', 'date1', 'time1', 'date2', 'time2', 'firmware']
2648
2649 def __init__(self, *args, **kwargs):
2650 dict={}
2651 dict.update(kwargs)
2653 super(firmwareresponse,self).__init__(**dict)
2655 if self.__class__ is firmwareresponse:
2656 self._update(args,dict)
2657
2658
2659 def getfields(self):
2660 return self.__fields
2661
2662
2663 def _update(self, args, kwargs):
2664 super(firmwareresponse,self)._update(args,kwargs)
2665 keys=kwargs.keys()
2666 for key in keys:
2667 if key in self.__fields:
2668 setattr(self, key, kwargs[key])
2669 del kwargs[key]
2670 if __debug__:
2672 self._complainaboutunusedargs(firmwareresponse,kwargs)
2673 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2674
2676
2677 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2678 'Writes this packet to the supplied buffer'
2679 self._bufferstartoffset=buf.getcurrentoffset()
2680 self.__field_command.writetobuffer(buf)
2681 self.__field_date1.writetobuffer(buf)
2682 self.__field_time1.writetobuffer(buf)
2683 self.__field_date2.writetobuffer(buf)
2684 self.__field_time2.writetobuffer(buf)
2685 self.__field_firmware.writetobuffer(buf)
2686 self._bufferendoffset=buf.getcurrentoffset()
2687 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2688
2689
2690 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2691 'Reads this packet from the supplied buffer'
2692 self._bufferstartoffset=buf.getcurrentoffset()
2693 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2694 self.__field_command=UINT(**{'sizeinbytes': 1})
2695 self.__field_command.readfrombuffer(buf)
2696 self.__field_date1=USTRING(**{'sizeinbytes': 11, 'terminator': None})
2697 self.__field_date1.readfrombuffer(buf)
2698 self.__field_time1=USTRING(**{'sizeinbytes': 8, 'terminator': None})
2699 self.__field_time1.readfrombuffer(buf)
2700 self.__field_date2=USTRING(**{'sizeinbytes': 11, 'terminator': None})
2701 self.__field_date2.readfrombuffer(buf)
2702 self.__field_time2=USTRING(**{'sizeinbytes': 8, 'terminator': None})
2703 self.__field_time2.readfrombuffer(buf)
2704 self.__field_firmware=USTRING(**{'sizeinbytes': 8, 'terminator': None})
2705 self.__field_firmware.readfrombuffer(buf)
2706 self._bufferendoffset=buf.getcurrentoffset()
2707
2708
2709 def __getfield_command(self):
2710 return self.__field_command.getvalue()
2711
2712 def __setfield_command(self, value):
2713 if isinstance(value,UINT):
2714 self.__field_command=value
2715 else:
2716 self.__field_command=UINT(value,**{'sizeinbytes': 1})
2717
2718 def __delfield_command(self): del self.__field_command
2719
2720 command=property(__getfield_command, __setfield_command, __delfield_command, None)
2721
2722 def __getfield_date1(self):
2723 return self.__field_date1.getvalue()
2724
2725 def __setfield_date1(self, value):
2726 if isinstance(value,USTRING):
2727 self.__field_date1=value
2728 else:
2729 self.__field_date1=USTRING(value,**{'sizeinbytes': 11, 'terminator': None})
2730
2731 def __delfield_date1(self): del self.__field_date1
2732
2733 date1=property(__getfield_date1, __setfield_date1, __delfield_date1, None)
2734
2735 def __getfield_time1(self):
2736 return self.__field_time1.getvalue()
2737
2738 def __setfield_time1(self, value):
2739 if isinstance(value,USTRING):
2740 self.__field_time1=value
2741 else:
2742 self.__field_time1=USTRING(value,**{'sizeinbytes': 8, 'terminator': None})
2743
2744 def __delfield_time1(self): del self.__field_time1
2745
2746 time1=property(__getfield_time1, __setfield_time1, __delfield_time1, None)
2747
2748 def __getfield_date2(self):
2749 return self.__field_date2.getvalue()
2750
2751 def __setfield_date2(self, value):
2752 if isinstance(value,USTRING):
2753 self.__field_date2=value
2754 else:
2755 self.__field_date2=USTRING(value,**{'sizeinbytes': 11, 'terminator': None})
2756
2757 def __delfield_date2(self): del self.__field_date2
2758
2759 date2=property(__getfield_date2, __setfield_date2, __delfield_date2, None)
2760
2761 def __getfield_time2(self):
2762 return self.__field_time2.getvalue()
2763
2764 def __setfield_time2(self, value):
2765 if isinstance(value,USTRING):
2766 self.__field_time2=value
2767 else:
2768 self.__field_time2=USTRING(value,**{'sizeinbytes': 8, 'terminator': None})
2769
2770 def __delfield_time2(self): del self.__field_time2
2771
2772 time2=property(__getfield_time2, __setfield_time2, __delfield_time2, None)
2773
2774 def __getfield_firmware(self):
2775 return self.__field_firmware.getvalue()
2776
2777 def __setfield_firmware(self, value):
2778 if isinstance(value,USTRING):
2779 self.__field_firmware=value
2780 else:
2781 self.__field_firmware=USTRING(value,**{'sizeinbytes': 8, 'terminator': None})
2782
2783 def __delfield_firmware(self): del self.__field_firmware
2784
2785 firmware=property(__getfield_firmware, __setfield_firmware, __delfield_firmware, None)
2786
2787 def iscontainer(self):
2788 return True
2789
2790 def containerelements(self):
2791 yield ('command', self.__field_command, None)
2792 yield ('date1', self.__field_date1, None)
2793 yield ('time1', self.__field_time1, None)
2794 yield ('date2', self.__field_date2, None)
2795 yield ('time2', self.__field_time2, None)
2796 yield ('firmware', self.__field_firmware, None)
2797
2798
2799
2800
2801 class recipient_record(BaseProtogenClass):
2802 __fields=['unknown1', 'number', 'status', 'timesent', 'timereceived', 'unknown2']
2803
2804 def __init__(self, *args, **kwargs):
2805 dict={}
2806 dict.update(kwargs)
2808 super(recipient_record,self).__init__(**dict)
2810 if self.__class__ is recipient_record:
2811 self._update(args,dict)
2812
2813
2814 def getfields(self):
2815 return self.__fields
2816
2817
2818 def _update(self, args, kwargs):
2819 super(recipient_record,self)._update(args,kwargs)
2820 keys=kwargs.keys()
2821 for key in keys:
2822 if key in self.__fields:
2823 setattr(self, key, kwargs[key])
2824 del kwargs[key]
2825 if __debug__:
2827 self._complainaboutunusedargs(recipient_record,kwargs)
2828 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2829
2831
2832 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2833 'Writes this packet to the supplied buffer'
2834 self._bufferstartoffset=buf.getcurrentoffset()
2835 self.__field_unknown1.writetobuffer(buf)
2836 self.__field_number.writetobuffer(buf)
2837 self.__field_status.writetobuffer(buf)
2838 self.__field_timesent.writetobuffer(buf)
2839 self.__field_timereceived.writetobuffer(buf)
2840 self.__field_unknown2.writetobuffer(buf)
2841 self._bufferendoffset=buf.getcurrentoffset()
2842 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2843
2844
2845 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2846 'Reads this packet from the supplied buffer'
2847 self._bufferstartoffset=buf.getcurrentoffset()
2848 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2849 self.__field_unknown1=UINT(**{'sizeinbytes': 14})
2850 self.__field_unknown1.readfrombuffer(buf)
2851 self.__field_number=USTRING(**{'sizeinbytes': 49})
2852 self.__field_number.readfrombuffer(buf)
2853 self.__field_status=UINT(**{'sizeinbytes': 1})
2854 self.__field_status.readfrombuffer(buf)
2855 self.__field_timesent=LGCALDATE(**{'sizeinbytes': 4})
2856 self.__field_timesent.readfrombuffer(buf)
2857 self.__field_timereceived=LGCALDATE(**{'sizeinbytes': 4})
2858 self.__field_timereceived.readfrombuffer(buf)
2859 self.__field_unknown2=DATA(**{'sizeinbytes': 40})
2860 self.__field_unknown2.readfrombuffer(buf)
2861 self._bufferendoffset=buf.getcurrentoffset()
2862
2863
2864 def __getfield_unknown1(self):
2865 return self.__field_unknown1.getvalue()
2866
2867 def __setfield_unknown1(self, value):
2868 if isinstance(value,UINT):
2869 self.__field_unknown1=value
2870 else:
2871 self.__field_unknown1=UINT(value,**{'sizeinbytes': 14})
2872
2873 def __delfield_unknown1(self): del self.__field_unknown1
2874
2875 unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None)
2876
2877 def __getfield_number(self):
2878 return self.__field_number.getvalue()
2879
2880 def __setfield_number(self, value):
2881 if isinstance(value,USTRING):
2882 self.__field_number=value
2883 else:
2884 self.__field_number=USTRING(value,**{'sizeinbytes': 49})
2885
2886 def __delfield_number(self): del self.__field_number
2887
2888 number=property(__getfield_number, __setfield_number, __delfield_number, None)
2889
2890 def __getfield_status(self):
2891 return self.__field_status.getvalue()
2892
2893 def __setfield_status(self, value):
2894 if isinstance(value,UINT):
2895 self.__field_status=value
2896 else:
2897 self.__field_status=UINT(value,**{'sizeinbytes': 1})
2898
2899 def __delfield_status(self): del self.__field_status
2900
2901 status=property(__getfield_status, __setfield_status, __delfield_status, None)
2902
2903 def __getfield_timesent(self):
2904 return self.__field_timesent.getvalue()
2905
2906 def __setfield_timesent(self, value):
2907 if isinstance(value,LGCALDATE):
2908 self.__field_timesent=value
2909 else:
2910 self.__field_timesent=LGCALDATE(value,**{'sizeinbytes': 4})
2911
2912 def __delfield_timesent(self): del self.__field_timesent
2913
2914 timesent=property(__getfield_timesent, __setfield_timesent, __delfield_timesent, None)
2915
2916 def __getfield_timereceived(self):
2917 return self.__field_timereceived.getvalue()
2918
2919 def __setfield_timereceived(self, value):
2920 if isinstance(value,LGCALDATE):
2921 self.__field_timereceived=value
2922 else:
2923 self.__field_timereceived=LGCALDATE(value,**{'sizeinbytes': 4})
2924
2925 def __delfield_timereceived(self): del self.__field_timereceived
2926
2927 timereceived=property(__getfield_timereceived, __setfield_timereceived, __delfield_timereceived, None)
2928
2929 def __getfield_unknown2(self):
2930 return self.__field_unknown2.getvalue()
2931
2932 def __setfield_unknown2(self, value):
2933 if isinstance(value,DATA):
2934 self.__field_unknown2=value
2935 else:
2936 self.__field_unknown2=DATA(value,**{'sizeinbytes': 40})
2937
2938 def __delfield_unknown2(self): del self.__field_unknown2
2939
2940 unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None)
2941
2942 def iscontainer(self):
2943 return True
2944
2945 def containerelements(self):
2946 yield ('unknown1', self.__field_unknown1, None)
2947 yield ('number', self.__field_number, None)
2948 yield ('status', self.__field_status, None)
2949 yield ('timesent', self.__field_timesent, None)
2950 yield ('timereceived', self.__field_timereceived, None)
2951 yield ('unknown2', self.__field_unknown2, None)
2952
2953
2954
2955
2956 class sms_saved(BaseProtogenClass):
2957 __fields=['outboxmsg', 'GPStime', 'outbox', 'inbox']
2958
2959 def __init__(self, *args, **kwargs):
2960 dict={}
2961 dict.update(kwargs)
2963 super(sms_saved,self).__init__(**dict)
2965 if self.__class__ is sms_saved:
2966 self._update(args,dict)
2967
2968
2969 def getfields(self):
2970 return self.__fields
2971
2972
2973 def _update(self, args, kwargs):
2974 super(sms_saved,self)._update(args,kwargs)
2975 keys=kwargs.keys()
2976 for key in keys:
2977 if key in self.__fields:
2978 setattr(self, key, kwargs[key])
2979 del kwargs[key]
2980 if __debug__:
2982 self._complainaboutunusedargs(sms_saved,kwargs)
2983 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2984
2986
2987 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2988 'Writes this packet to the supplied buffer'
2989 self._bufferstartoffset=buf.getcurrentoffset()
2990 self.__field_outboxmsg.writetobuffer(buf)
2991 self.__field_GPStime.writetobuffer(buf)
2992 if self.outboxmsg:
2993 self.__field_outbox.writetobuffer(buf)
2994 if not self.outboxmsg:
2995 self.__field_inbox.writetobuffer(buf)
2996 self._bufferendoffset=buf.getcurrentoffset()
2997 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2998
2999
3000 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3001 'Reads this packet from the supplied buffer'
3002 self._bufferstartoffset=buf.getcurrentoffset()
3003 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3004 self.__field_outboxmsg=UINT(**{'sizeinbytes': 4})
3005 self.__field_outboxmsg.readfrombuffer(buf)
3006 self.__field_GPStime=GPSDATE(**{'sizeinbytes': 4})
3007 self.__field_GPStime.readfrombuffer(buf)
3008 if self.outboxmsg:
3009 self.__field_outbox=sms_out()
3010 self.__field_outbox.readfrombuffer(buf)
3011 if not self.outboxmsg:
3012 self.__field_inbox=sms_in()
3013 self.__field_inbox.readfrombuffer(buf)
3014 self._bufferendoffset=buf.getcurrentoffset()
3015
3016
3017 def __getfield_outboxmsg(self):
3018 return self.__field_outboxmsg.getvalue()
3019
3020 def __setfield_outboxmsg(self, value):
3021 if isinstance(value,UINT):
3022 self.__field_outboxmsg=value
3023 else:
3024