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