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