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