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