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