0001
0003 """Various descriptions of data specific to the Samsung SCH-A950 Phone"""
0004
0005 from prototypes import *
0006 from prototypes_samsung import *
0007 from p_brew import *
0008
0009 UINT=UINTlsb
0011 BOOL=BOOLlsb
0012
0013 ENCODING='latin_1'
0014
0015 RT_PATH='brew/16452/mr'
0016 RT_PATH2='brew/16452/lk/mr'
0017 RT_INDEX_FILE_NAME=RT_PATH+'/MrInfo.db'
0018 RT_EXCLUDED_FILES=('MrInfo.db',)
0019 SND_PATH='brew/16452/ms'
0020 SND_PATH2='brew/16452/lk/ms'
0021 SND_INDEX_FILE_NAME=SND_PATH+'/MsInfo.db'
0022 SND_EXCLUDED_FILES=('MsInfo.db', 'ExInfo.db')
0023 PIC_PATH='brew/16452/mp'
0024 PIC_PATH2='brew/16452/lk/mp'
0025 PIC_INDEX_FILE_NAME=PIC_PATH+'/Default Album.alb'
0026 PIC_EXCLUDED_FILES=('Default Album.alb', 'Graphics.alb')
0027 PREF_DB_FILE_NAME='current_prefs.db'
0028
0029 GROUP_INDEX_FILE_NAME='pb/pbgroups_'
0030
0031 CAL_PATH='sch_event'
0033 CAL_INDEX_FILE_NAME=CAL_PATH+'/usr_tsk'
0034 CAL_FILE_NAME_PREFIX=CAL_PATH+'/usr_tsk_'
0035 CAL_MAX_EVENTS=100
0036
0037 NP_MAX_ENTRIES=30
0038 NP_MAX_LEN=130
0039 NP_PATH=CAL_PATH
0040 NP_FILE_NAME_PREFIX=CAL_FILE_NAME_PREFIX
0041
0042 PB_PATH='pb'
0044 PB_JRNL_FILE_PREFIX=PB_PATH+'/jrnl_'
0045 PB_ENTRY_FILE_PREFIX=PB_PATH+'/recs_'
0046 PB_MAIN_FILE_PREFIX=PB_PATH+'/main_'
0047 PB_WP_CACHE_PATH='cache/pb'
0048 PB_MAX_NAME_LEN=32
0049 PB_MAX_EMAIL_LEN=48
0050 PB_MAX_NUMBER_LEN=48
0051
0052 PB_FLG_NONE=0x0000
0053 PB_FLG_NAME=0x0001
0054 PB_FLG_DATE=0x0400
0055 PB_FLG_FAX=0x0080
0056 PB_FLG_CELL=0x0020
0057 PB_FLG_WORK=0x0010
0058 PB_FLG_HOME=0X0008
0059 PB_FLG_EMAIL2=0X0004
0060 PB_FLG_EMAIL=0X0002
0061 PB_FLG_WP=0X8000
0062 PB_FLG_GROUP=0X0800
0063 PB_FLG_CELL2=0X0100
0064 PB_FLG_SPEEDDIAL=0x01
0065 PB_FLG_RINGTONE=0x10
0066 PB_FLG_PRIMARY=0x02
0067
0068 SS_CMD_SW_VERSION=0
0070 SS_CMD_HW_VERSION=1
0071 SS_CMD_PB_COUNT=2
0072 SS_CMD_PB_VOICEMAIL_READ=5
0073 SS_CMD_PB_VOICEMAIL_WRITE=6
0074 SS_CMD_PB_READ=0x14
0075 SS_CMD_PB_WRITE=0x15
0076 SS_CMD_PB_CLEAR=0x1D
0077 SS_CMD_PB_VOICEMAIL_PARAM=0x19
0078 PB_DEFAULT_VOICEMAIL_NUMBER='*86'
0079
0080 CL_PATH='clog'
0082 CL_PREFIX=CL_PATH+'/clog_'
0083 CL_INDEX_FILE=CL_PATH+'/clog_master'
0084 CL_MAX_ENTRIES=20
0085 CL_TYPE_INCOMING=1
0086 CL_TYPE_OUTGOING=2
0087 CL_TYPE_MISSED=3
0088 CL_TYPE_DELETED=5
0089 CL_VALID_TYPE=frozenset((CL_TYPE_INCOMING, CL_TYPE_OUTGOING, CL_TYPE_MISSED))
0090
0091 SMS_PATH='nvm/sms_wp_os'
0093
0094 SMS_TXT_TYPE=0x0200
0095 SMS_TYPE_IN=1
0096 SMS_TYPE_SENT=3
0097 SMS_TYPE_DRAFT=4
0098 SMS_VALID_TYPE=(SMS_TYPE_IN, SMS_TYPE_SENT, SMS_TYPE_DRAFT)
0099 SMS_FLG1_DEFERREDDEL=0x40
0100 SMS_FLG1_VALIDPERIOD=0x10
0101 SMS_FLG1_HAS40=SMS_FLG1_DEFERREDDEL | SMS_FLG1_VALIDPERIOD
0102 SMS_FLG2_CALLBACK=0x40
0103 SMS_FLG2_MSG=0x04
0104 SMS_FLG2_PRIORITY=0x01
0105 SMS_FLG2_SOMETHING=0x08
0106 SMS_STATUS_SENT=0x10
0107 SMS_STATUS_DELIVERED=0x11
0108 SMS_STATUS_READ=0x05
0109 SMS_STATUS_NOTREAD=0x01
0110 SMS_STATUS_LOCKED=0x100
0111
0112 broken_filelist_date=True
0113 class DefaultResponse(BaseProtogenClass):
0114 __fields=['data']
0115
0116 def __init__(self, *args, **kwargs):
0117 dict={}
0118 dict.update(kwargs)
0120 super(DefaultResponse,self).__init__(**dict)
0122 if self.__class__ is DefaultResponse:
0123 self._update(args,dict)
0124
0125
0126 def getfields(self):
0127 return self.__fields
0128
0129
0130 def _update(self, args, kwargs):
0131 super(DefaultResponse,self)._update(args,kwargs)
0132 keys=kwargs.keys()
0133 for key in keys:
0134 if key in self.__fields:
0135 setattr(self, key, kwargs[key])
0136 del kwargs[key]
0137 if __debug__:
0139 self._complainaboutunusedargs(DefaultResponse,kwargs)
0140 if len(args):
0141 dict2={}
0142 dict2.update(kwargs)
0143 kwargs=dict2
0144 self.__field_data=DATA(*args,**dict2)
0145
0147
0148 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0149 'Writes this packet to the supplied buffer'
0150 self._bufferstartoffset=buf.getcurrentoffset()
0151 self.__field_data.writetobuffer(buf)
0152 self._bufferendoffset=buf.getcurrentoffset()
0153 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0154
0155
0156 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0157 'Reads this packet from the supplied buffer'
0158 self._bufferstartoffset=buf.getcurrentoffset()
0159 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0160 self.__field_data=DATA()
0161 self.__field_data.readfrombuffer(buf)
0162 self._bufferendoffset=buf.getcurrentoffset()
0163
0164
0165 def __getfield_data(self):
0166 return self.__field_data.getvalue()
0167
0168 def __setfield_data(self, value):
0169 if isinstance(value,DATA):
0170 self.__field_data=value
0171 else:
0172 self.__field_data=DATA(value,)
0173
0174 def __delfield_data(self): del self.__field_data
0175
0176 data=property(__getfield_data, __setfield_data, __delfield_data, None)
0177
0178 def iscontainer(self):
0179 return True
0180
0181 def containerelements(self):
0182 yield ('data', self.__field_data, None)
0183
0184
0185
0186
0187 class WRingtoneIndexEntry(BaseProtogenClass):
0188 __fields=['name', 'path_prefix', 'pathname', 'eor']
0189
0190 def __init__(self, *args, **kwargs):
0191 dict={}
0192 dict.update(kwargs)
0194 super(WRingtoneIndexEntry,self).__init__(**dict)
0196 if self.__class__ is WRingtoneIndexEntry:
0197 self._update(args,dict)
0198
0199
0200 def getfields(self):
0201 return self.__fields
0202
0203
0204 def _update(self, args, kwargs):
0205 super(WRingtoneIndexEntry,self)._update(args,kwargs)
0206 keys=kwargs.keys()
0207 for key in keys:
0208 if key in self.__fields:
0209 setattr(self, key, kwargs[key])
0210 del kwargs[key]
0211 if __debug__:
0213 self._complainaboutunusedargs(WRingtoneIndexEntry,kwargs)
0214 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0215 try: self.__field_name
0217 except:
0218 self.__field_name=STRING()
0219
0220
0221 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0222 'Writes this packet to the supplied buffer'
0223 self._bufferstartoffset=buf.getcurrentoffset()
0224 try: self.__field_path_prefix
0225 except:
0226 self.__field_path_prefix=STRING(**{ 'terminator': None, 'default': '/ff/' })
0227 self.__field_path_prefix.writetobuffer(buf)
0228 self.__field_pathname.writetobuffer(buf)
0229 try: self.__field_eor
0230 except:
0231 self.__field_eor=STRING(**{ 'terminator': None, 'default': '|2\x0A' })
0232 self.__field_eor.writetobuffer(buf)
0233 self._bufferendoffset=buf.getcurrentoffset()
0234 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0235
0236
0237 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0238 'Reads this packet from the supplied buffer'
0239 self._bufferstartoffset=buf.getcurrentoffset()
0240 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0241 self.__field_path_prefix=STRING(**{ 'terminator': None, 'default': '/ff/' })
0242 self.__field_path_prefix.readfrombuffer(buf)
0243 self.__field_pathname=STRING(**{ 'terminator': None })
0244 self.__field_pathname.readfrombuffer(buf)
0245 self.__field_eor=STRING(**{ 'terminator': None, 'default': '|2\x0A' })
0246 self.__field_eor.readfrombuffer(buf)
0247 self._bufferendoffset=buf.getcurrentoffset()
0248
0249
0250 def __getfield_name(self):
0251 return self.__field_name.getvalue()
0252
0253 def __setfield_name(self, value):
0254 if isinstance(value,STRING):
0255 self.__field_name=value
0256 else:
0257 self.__field_name=STRING(value,)
0258
0259 def __delfield_name(self): del self.__field_name
0260
0261 name=property(__getfield_name, __setfield_name, __delfield_name, None)
0262
0263 def __getfield_path_prefix(self):
0264 try: self.__field_path_prefix
0265 except:
0266 self.__field_path_prefix=STRING(**{ 'terminator': None, 'default': '/ff/' })
0267 return self.__field_path_prefix.getvalue()
0268
0269 def __setfield_path_prefix(self, value):
0270 if isinstance(value,STRING):
0271 self.__field_path_prefix=value
0272 else:
0273 self.__field_path_prefix=STRING(value,**{ 'terminator': None, 'default': '/ff/' })
0274
0275 def __delfield_path_prefix(self): del self.__field_path_prefix
0276
0277 path_prefix=property(__getfield_path_prefix, __setfield_path_prefix, __delfield_path_prefix, None)
0278
0279 def __getfield_pathname(self):
0280 return self.__field_pathname.getvalue()
0281
0282 def __setfield_pathname(self, value):
0283 if isinstance(value,STRING):
0284 self.__field_pathname=value
0285 else:
0286 self.__field_pathname=STRING(value,**{ 'terminator': None })
0287
0288 def __delfield_pathname(self): del self.__field_pathname
0289
0290 pathname=property(__getfield_pathname, __setfield_pathname, __delfield_pathname, None)
0291
0292 def __getfield_eor(self):
0293 try: self.__field_eor
0294 except:
0295 self.__field_eor=STRING(**{ 'terminator': None, 'default': '|2\x0A' })
0296 return self.__field_eor.getvalue()
0297
0298 def __setfield_eor(self, value):
0299 if isinstance(value,STRING):
0300 self.__field_eor=value
0301 else:
0302 self.__field_eor=STRING(value,**{ 'terminator': None, 'default': '|2\x0A' })
0303
0304 def __delfield_eor(self): del self.__field_eor
0305
0306 eor=property(__getfield_eor, __setfield_eor, __delfield_eor, None)
0307
0308 def iscontainer(self):
0309 return True
0310
0311 def containerelements(self):
0312 yield ('name', self.__field_name, None)
0313 yield ('path_prefix', self.__field_path_prefix, None)
0314 yield ('pathname', self.__field_pathname, None)
0315 yield ('eor', self.__field_eor, None)
0316
0317
0318
0319
0320 class WRingtoneIndexFile(BaseProtogenClass):
0321 __fields=['items']
0322
0323 def __init__(self, *args, **kwargs):
0324 dict={}
0325 dict.update(kwargs)
0327 super(WRingtoneIndexFile,self).__init__(**dict)
0329 if self.__class__ is WRingtoneIndexFile:
0330 self._update(args,dict)
0331
0332
0333 def getfields(self):
0334 return self.__fields
0335
0336
0337 def _update(self, args, kwargs):
0338 super(WRingtoneIndexFile,self)._update(args,kwargs)
0339 keys=kwargs.keys()
0340 for key in keys:
0341 if key in self.__fields:
0342 setattr(self, key, kwargs[key])
0343 del kwargs[key]
0344 if __debug__:
0346 self._complainaboutunusedargs(WRingtoneIndexFile,kwargs)
0347 if len(args):
0348 dict2={ 'elementclass': WRingtoneIndexEntry }
0349 dict2.update(kwargs)
0350 kwargs=dict2
0351 self.__field_items=LIST(*args,**dict2)
0352
0354
0355 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0356 'Writes this packet to the supplied buffer'
0357 self._bufferstartoffset=buf.getcurrentoffset()
0358 try: self.__field_items
0359 except:
0360 self.__field_items=LIST(**{ 'elementclass': WRingtoneIndexEntry })
0361 self.__field_items.writetobuffer(buf)
0362 self._bufferendoffset=buf.getcurrentoffset()
0363 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0364
0365
0366 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0367 'Reads this packet from the supplied buffer'
0368 self._bufferstartoffset=buf.getcurrentoffset()
0369 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0370 self.__field_items=LIST(**{ 'elementclass': WRingtoneIndexEntry })
0371 self.__field_items.readfrombuffer(buf)
0372 self._bufferendoffset=buf.getcurrentoffset()
0373
0374
0375 def __getfield_items(self):
0376 try: self.__field_items
0377 except:
0378 self.__field_items=LIST(**{ 'elementclass': WRingtoneIndexEntry })
0379 return self.__field_items.getvalue()
0380
0381 def __setfield_items(self, value):
0382 if isinstance(value,LIST):
0383 self.__field_items=value
0384 else:
0385 self.__field_items=LIST(value,**{ 'elementclass': WRingtoneIndexEntry })
0386
0387 def __delfield_items(self): del self.__field_items
0388
0389 items=property(__getfield_items, __setfield_items, __delfield_items, None)
0390
0391 def iscontainer(self):
0392 return True
0393
0394 def containerelements(self):
0395 yield ('items', self.__field_items, None)
0396
0397
0398
0399
0400 class RRingtoneIndexEntry(BaseProtogenClass):
0401 __fields=['pathname', 'misc']
0402
0403 def __init__(self, *args, **kwargs):
0404 dict={}
0405 dict.update(kwargs)
0407 super(RRingtoneIndexEntry,self).__init__(**dict)
0409 if self.__class__ is RRingtoneIndexEntry:
0410 self._update(args,dict)
0411
0412
0413 def getfields(self):
0414 return self.__fields
0415
0416
0417 def _update(self, args, kwargs):
0418 super(RRingtoneIndexEntry,self)._update(args,kwargs)
0419 keys=kwargs.keys()
0420 for key in keys:
0421 if key in self.__fields:
0422 setattr(self, key, kwargs[key])
0423 del kwargs[key]
0424 if __debug__:
0426 self._complainaboutunusedargs(RRingtoneIndexEntry,kwargs)
0427 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0428
0430
0431 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0432 'Writes this packet to the supplied buffer'
0433 self._bufferstartoffset=buf.getcurrentoffset()
0434 self.__field_pathname.writetobuffer(buf)
0435 self.__field_misc.writetobuffer(buf)
0436 self._bufferendoffset=buf.getcurrentoffset()
0437 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0438
0439
0440 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0441 'Reads this packet from the supplied buffer'
0442 self._bufferstartoffset=buf.getcurrentoffset()
0443 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0444 self.__field_pathname=STRING(**{ 'terminator': 0x7C })
0445 self.__field_pathname.readfrombuffer(buf)
0446 self.__field_misc=STRING(**{ 'terminator': 0x0A })
0447 self.__field_misc.readfrombuffer(buf)
0448 self._bufferendoffset=buf.getcurrentoffset()
0449
0450
0451 def __getfield_pathname(self):
0452 return self.__field_pathname.getvalue()
0453
0454 def __setfield_pathname(self, value):
0455 if isinstance(value,STRING):
0456 self.__field_pathname=value
0457 else:
0458 self.__field_pathname=STRING(value,**{ 'terminator': 0x7C })
0459
0460 def __delfield_pathname(self): del self.__field_pathname
0461
0462 pathname=property(__getfield_pathname, __setfield_pathname, __delfield_pathname, None)
0463
0464 def __getfield_misc(self):
0465 return self.__field_misc.getvalue()
0466
0467 def __setfield_misc(self, value):
0468 if isinstance(value,STRING):
0469 self.__field_misc=value
0470 else:
0471 self.__field_misc=STRING(value,**{ 'terminator': 0x0A })
0472
0473 def __delfield_misc(self): del self.__field_misc
0474
0475 misc=property(__getfield_misc, __setfield_misc, __delfield_misc, None)
0476
0477 def iscontainer(self):
0478 return True
0479
0480 def containerelements(self):
0481 yield ('pathname', self.__field_pathname, None)
0482 yield ('misc', self.__field_misc, None)
0483
0484
0485
0486
0487 class RRingtoneIndexFile(BaseProtogenClass):
0488 __fields=['items']
0489
0490 def __init__(self, *args, **kwargs):
0491 dict={}
0492 dict.update(kwargs)
0494 super(RRingtoneIndexFile,self).__init__(**dict)
0496 if self.__class__ is RRingtoneIndexFile:
0497 self._update(args,dict)
0498
0499
0500 def getfields(self):
0501 return self.__fields
0502
0503
0504 def _update(self, args, kwargs):
0505 super(RRingtoneIndexFile,self)._update(args,kwargs)
0506 keys=kwargs.keys()
0507 for key in keys:
0508 if key in self.__fields:
0509 setattr(self, key, kwargs[key])
0510 del kwargs[key]
0511 if __debug__:
0513 self._complainaboutunusedargs(RRingtoneIndexFile,kwargs)
0514 if len(args):
0515 dict2={ 'elementclass': RRingtoneIndexEntry }
0516 dict2.update(kwargs)
0517 kwargs=dict2
0518 self.__field_items=LIST(*args,**dict2)
0519
0521
0522 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0523 'Writes this packet to the supplied buffer'
0524 self._bufferstartoffset=buf.getcurrentoffset()
0525 try: self.__field_items
0526 except:
0527 self.__field_items=LIST(**{ 'elementclass': RRingtoneIndexEntry })
0528 self.__field_items.writetobuffer(buf)
0529 self._bufferendoffset=buf.getcurrentoffset()
0530 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0531
0532
0533 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0534 'Reads this packet from the supplied buffer'
0535 self._bufferstartoffset=buf.getcurrentoffset()
0536 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0537 self.__field_items=LIST(**{ 'elementclass': RRingtoneIndexEntry })
0538 self.__field_items.readfrombuffer(buf)
0539 self._bufferendoffset=buf.getcurrentoffset()
0540
0541
0542 def __getfield_items(self):
0543 try: self.__field_items
0544 except:
0545 self.__field_items=LIST(**{ 'elementclass': RRingtoneIndexEntry })
0546 return self.__field_items.getvalue()
0547
0548 def __setfield_items(self, value):
0549 if isinstance(value,LIST):
0550 self.__field_items=value
0551 else:
0552 self.__field_items=LIST(value,**{ 'elementclass': RRingtoneIndexEntry })
0553
0554 def __delfield_items(self): del self.__field_items
0555
0556 items=property(__getfield_items, __setfield_items, __delfield_items, None)
0557
0558 def iscontainer(self):
0559 return True
0560
0561 def containerelements(self):
0562 yield ('items', self.__field_items, None)
0563
0564
0565
0566
0567 class WSoundsIndexEntry(BaseProtogenClass):
0568 __fields=['name', 'path_prefix', 'pathname', 'eor']
0569
0570 def __init__(self, *args, **kwargs):
0571 dict={}
0572 dict.update(kwargs)
0574 super(WSoundsIndexEntry,self).__init__(**dict)
0576 if self.__class__ is WSoundsIndexEntry:
0577 self._update(args,dict)
0578
0579
0580 def getfields(self):
0581 return self.__fields
0582
0583
0584 def _update(self, args, kwargs):
0585 super(WSoundsIndexEntry,self)._update(args,kwargs)
0586 keys=kwargs.keys()
0587 for key in keys:
0588 if key in self.__fields:
0589 setattr(self, key, kwargs[key])
0590 del kwargs[key]
0591 if __debug__:
0593 self._complainaboutunusedargs(WSoundsIndexEntry,kwargs)
0594 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0595 try: self.__field_name
0597 except:
0598 self.__field_name=STRING()
0599
0600
0601 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0602 'Writes this packet to the supplied buffer'
0603 self._bufferstartoffset=buf.getcurrentoffset()
0604 try: self.__field_path_prefix
0605 except:
0606 self.__field_path_prefix=STRING(**{ 'terminator': None, 'default': '/ff/' })
0607 self.__field_path_prefix.writetobuffer(buf)
0608 self.__field_pathname.writetobuffer(buf)
0609 try: self.__field_eor
0610 except:
0611 self.__field_eor=STRING(**{ 'terminator': None, 'default': '|0|7\x0A' })
0612 self.__field_eor.writetobuffer(buf)
0613 self._bufferendoffset=buf.getcurrentoffset()
0614 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0615
0616
0617 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0618 'Reads this packet from the supplied buffer'
0619 self._bufferstartoffset=buf.getcurrentoffset()
0620 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0621 self.__field_path_prefix=STRING(**{ 'terminator': None, 'default': '/ff/' })
0622 self.__field_path_prefix.readfrombuffer(buf)
0623 self.__field_pathname=STRING(**{ 'terminator': None })
0624 self.__field_pathname.readfrombuffer(buf)
0625 self.__field_eor=STRING(**{ 'terminator': None, 'default': '|0|7\x0A' })
0626 self.__field_eor.readfrombuffer(buf)
0627 self._bufferendoffset=buf.getcurrentoffset()
0628
0629
0630 def __getfield_name(self):
0631 return self.__field_name.getvalue()
0632
0633 def __setfield_name(self, value):
0634 if isinstance(value,STRING):
0635 self.__field_name=value
0636 else:
0637 self.__field_name=STRING(value,)
0638
0639 def __delfield_name(self): del self.__field_name
0640
0641 name=property(__getfield_name, __setfield_name, __delfield_name, None)
0642
0643 def __getfield_path_prefix(self):
0644 try: self.__field_path_prefix
0645 except:
0646 self.__field_path_prefix=STRING(**{ 'terminator': None, 'default': '/ff/' })
0647 return self.__field_path_prefix.getvalue()
0648
0649 def __setfield_path_prefix(self, value):
0650 if isinstance(value,STRING):
0651 self.__field_path_prefix=value
0652 else:
0653 self.__field_path_prefix=STRING(value,**{ 'terminator': None, 'default': '/ff/' })
0654
0655 def __delfield_path_prefix(self): del self.__field_path_prefix
0656
0657 path_prefix=property(__getfield_path_prefix, __setfield_path_prefix, __delfield_path_prefix, None)
0658
0659 def __getfield_pathname(self):
0660 return self.__field_pathname.getvalue()
0661
0662 def __setfield_pathname(self, value):
0663 if isinstance(value,STRING):
0664 self.__field_pathname=value
0665 else:
0666 self.__field_pathname=STRING(value,**{ 'terminator': None })
0667
0668 def __delfield_pathname(self): del self.__field_pathname
0669
0670 pathname=property(__getfield_pathname, __setfield_pathname, __delfield_pathname, None)
0671
0672 def __getfield_eor(self):
0673 try: self.__field_eor
0674 except:
0675 self.__field_eor=STRING(**{ 'terminator': None, 'default': '|0|7\x0A' })
0676 return self.__field_eor.getvalue()
0677
0678 def __setfield_eor(self, value):
0679 if isinstance(value,STRING):
0680 self.__field_eor=value
0681 else:
0682 self.__field_eor=STRING(value,**{ 'terminator': None, 'default': '|0|7\x0A' })
0683
0684 def __delfield_eor(self): del self.__field_eor
0685
0686 eor=property(__getfield_eor, __setfield_eor, __delfield_eor, None)
0687
0688 def iscontainer(self):
0689 return True
0690
0691 def containerelements(self):
0692 yield ('name', self.__field_name, None)
0693 yield ('path_prefix', self.__field_path_prefix, None)
0694 yield ('pathname', self.__field_pathname, None)
0695 yield ('eor', self.__field_eor, None)
0696
0697
0698
0699
0700 class WSoundsIndexFile(BaseProtogenClass):
0701 __fields=['items']
0702
0703 def __init__(self, *args, **kwargs):
0704 dict={}
0705 dict.update(kwargs)
0707 super(WSoundsIndexFile,self).__init__(**dict)
0709 if self.__class__ is WSoundsIndexFile:
0710 self._update(args,dict)
0711
0712
0713 def getfields(self):
0714 return self.__fields
0715
0716
0717 def _update(self, args, kwargs):
0718 super(WSoundsIndexFile,self)._update(args,kwargs)
0719 keys=kwargs.keys()
0720 for key in keys:
0721 if key in self.__fields:
0722 setattr(self, key, kwargs[key])
0723 del kwargs[key]
0724 if __debug__:
0726 self._complainaboutunusedargs(WSoundsIndexFile,kwargs)
0727 if len(args):
0728 dict2={ 'elementclass': WSoundsIndexEntry }
0729 dict2.update(kwargs)
0730 kwargs=dict2
0731 self.__field_items=LIST(*args,**dict2)
0732
0734
0735 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0736 'Writes this packet to the supplied buffer'
0737 self._bufferstartoffset=buf.getcurrentoffset()
0738 try: self.__field_items
0739 except:
0740 self.__field_items=LIST(**{ 'elementclass': WSoundsIndexEntry })
0741 self.__field_items.writetobuffer(buf)
0742 self._bufferendoffset=buf.getcurrentoffset()
0743 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0744
0745
0746 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0747 'Reads this packet from the supplied buffer'
0748 self._bufferstartoffset=buf.getcurrentoffset()
0749 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0750 self.__field_items=LIST(**{ 'elementclass': WSoundsIndexEntry })
0751 self.__field_items.readfrombuffer(buf)
0752 self._bufferendoffset=buf.getcurrentoffset()
0753
0754
0755 def __getfield_items(self):
0756 try: self.__field_items
0757 except:
0758 self.__field_items=LIST(**{ 'elementclass': WSoundsIndexEntry })
0759 return self.__field_items.getvalue()
0760
0761 def __setfield_items(self, value):
0762 if isinstance(value,LIST):
0763 self.__field_items=value
0764 else:
0765 self.__field_items=LIST(value,**{ 'elementclass': WSoundsIndexEntry })
0766
0767 def __delfield_items(self): del self.__field_items
0768
0769 items=property(__getfield_items, __setfield_items, __delfield_items, None)
0770
0771 def iscontainer(self):
0772 return True
0773
0774 def containerelements(self):
0775 yield ('items', self.__field_items, None)
0776
0777
0778
0779
0780 class RSoundIndexEntry(BaseProtogenClass):
0781 __fields=['pathname', 'misc']
0782
0783 def __init__(self, *args, **kwargs):
0784 dict={}
0785 dict.update(kwargs)
0787 super(RSoundIndexEntry,self).__init__(**dict)
0789 if self.__class__ is RSoundIndexEntry:
0790 self._update(args,dict)
0791
0792
0793 def getfields(self):
0794 return self.__fields
0795
0796
0797 def _update(self, args, kwargs):
0798 super(RSoundIndexEntry,self)._update(args,kwargs)
0799 keys=kwargs.keys()
0800 for key in keys:
0801 if key in self.__fields:
0802 setattr(self, key, kwargs[key])
0803 del kwargs[key]
0804 if __debug__:
0806 self._complainaboutunusedargs(RSoundIndexEntry,kwargs)
0807 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0808
0810
0811 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0812 'Writes this packet to the supplied buffer'
0813 self._bufferstartoffset=buf.getcurrentoffset()
0814 self.__field_pathname.writetobuffer(buf)
0815 self.__field_misc.writetobuffer(buf)
0816 self._bufferendoffset=buf.getcurrentoffset()
0817 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0818
0819
0820 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0821 'Reads this packet from the supplied buffer'
0822 self._bufferstartoffset=buf.getcurrentoffset()
0823 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0824 self.__field_pathname=STRING(**{ 'terminator': 0x7C })
0825 self.__field_pathname.readfrombuffer(buf)
0826 self.__field_misc=STRING(**{ 'terminator': 0x0A })
0827 self.__field_misc.readfrombuffer(buf)
0828 self._bufferendoffset=buf.getcurrentoffset()
0829
0830
0831 def __getfield_pathname(self):
0832 return self.__field_pathname.getvalue()
0833
0834 def __setfield_pathname(self, value):
0835 if isinstance(value,STRING):
0836 self.__field_pathname=value
0837 else:
0838 self.__field_pathname=STRING(value,**{ 'terminator': 0x7C })
0839
0840 def __delfield_pathname(self): del self.__field_pathname
0841
0842 pathname=property(__getfield_pathname, __setfield_pathname, __delfield_pathname, None)
0843
0844 def __getfield_misc(self):
0845 return self.__field_misc.getvalue()
0846
0847 def __setfield_misc(self, value):
0848 if isinstance(value,STRING):
0849 self.__field_misc=value
0850 else:
0851 self.__field_misc=STRING(value,**{ 'terminator': 0x0A })
0852
0853 def __delfield_misc(self): del self.__field_misc
0854
0855 misc=property(__getfield_misc, __setfield_misc, __delfield_misc, None)
0856
0857 def iscontainer(self):
0858 return True
0859
0860 def containerelements(self):
0861 yield ('pathname', self.__field_pathname, None)
0862 yield ('misc', self.__field_misc, None)
0863
0864
0865
0866
0867 class RSoundsIndexFile(BaseProtogenClass):
0868 __fields=['items']
0869
0870 def __init__(self, *args, **kwargs):
0871 dict={}
0872 dict.update(kwargs)
0874 super(RSoundsIndexFile,self).__init__(**dict)
0876 if self.__class__ is RSoundsIndexFile:
0877 self._update(args,dict)
0878
0879
0880 def getfields(self):
0881 return self.__fields
0882
0883
0884 def _update(self, args, kwargs):
0885 super(RSoundsIndexFile,self)._update(args,kwargs)
0886 keys=kwargs.keys()
0887 for key in keys:
0888 if key in self.__fields:
0889 setattr(self, key, kwargs[key])
0890 del kwargs[key]
0891 if __debug__:
0893 self._complainaboutunusedargs(RSoundsIndexFile,kwargs)
0894 if len(args):
0895 dict2={ 'elementclass': RSoundIndexEntry }
0896 dict2.update(kwargs)
0897 kwargs=dict2
0898 self.__field_items=LIST(*args,**dict2)
0899
0901
0902 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0903 'Writes this packet to the supplied buffer'
0904 self._bufferstartoffset=buf.getcurrentoffset()
0905 try: self.__field_items
0906 except:
0907 self.__field_items=LIST(**{ 'elementclass': RSoundIndexEntry })
0908 self.__field_items.writetobuffer(buf)
0909 self._bufferendoffset=buf.getcurrentoffset()
0910 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0911
0912
0913 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0914 'Reads this packet from the supplied buffer'
0915 self._bufferstartoffset=buf.getcurrentoffset()
0916 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0917 self.__field_items=LIST(**{ 'elementclass': RSoundIndexEntry })
0918 self.__field_items.readfrombuffer(buf)
0919 self._bufferendoffset=buf.getcurrentoffset()
0920
0921
0922 def __getfield_items(self):
0923 try: self.__field_items
0924 except:
0925 self.__field_items=LIST(**{ 'elementclass': RSoundIndexEntry })
0926 return self.__field_items.getvalue()
0927
0928 def __setfield_items(self, value):
0929 if isinstance(value,LIST):
0930 self.__field_items=value
0931 else:
0932 self.__field_items=LIST(value,**{ 'elementclass': RSoundIndexEntry })
0933
0934 def __delfield_items(self): del self.__field_items
0935
0936 items=property(__getfield_items, __setfield_items, __delfield_items, None)
0937
0938 def iscontainer(self):
0939 return True
0940
0941 def containerelements(self):
0942 yield ('items', self.__field_items, None)
0943
0944
0945
0946
0947 class WPictureIndexEntry(BaseProtogenClass):
0948 __fields=['name', 'path_prefix', 'pathname', 'eor']
0949
0950 def __init__(self, *args, **kwargs):
0951 dict={}
0952 dict.update(kwargs)
0954 super(WPictureIndexEntry,self).__init__(**dict)
0956 if self.__class__ is WPictureIndexEntry:
0957 self._update(args,dict)
0958
0959
0960 def getfields(self):
0961 return self.__fields
0962
0963
0964 def _update(self, args, kwargs):
0965 super(WPictureIndexEntry,self)._update(args,kwargs)
0966 keys=kwargs.keys()
0967 for key in keys:
0968 if key in self.__fields:
0969 setattr(self, key, kwargs[key])
0970 del kwargs[key]
0971 if __debug__:
0973 self._complainaboutunusedargs(WPictureIndexEntry,kwargs)
0974 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0975
0977
0978 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0979 'Writes this packet to the supplied buffer'
0980 self._bufferstartoffset=buf.getcurrentoffset()
0981 self.__field_name.writetobuffer(buf)
0982 try: self.__field_path_prefix
0983 except:
0984 self.__field_path_prefix=STRING(**{ 'terminator': None, 'default': '|/ff/' })
0985 self.__field_path_prefix.writetobuffer(buf)
0986 self.__field_pathname.writetobuffer(buf)
0987 try: self.__field_eor
0988 except:
0989 self.__field_eor=STRING(**{ 'terminator': None, 'default': '|0|0|3|>\x0A\xF4' })
0990 self.__field_eor.writetobuffer(buf)
0991 self._bufferendoffset=buf.getcurrentoffset()
0992 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0993
0994
0995 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0996 'Reads this packet from the supplied buffer'
0997 self._bufferstartoffset=buf.getcurrentoffset()
0998 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0999 self.__field_name=STRING(**{ 'terminator': None })
1000 self.__field_name.readfrombuffer(buf)
1001 self.__field_path_prefix=STRING(**{ 'terminator': None, 'default': '|/ff/' })
1002 self.__field_path_prefix.readfrombuffer(buf)
1003 self.__field_pathname=STRING(**{ 'terminator': None })
1004 self.__field_pathname.readfrombuffer(buf)
1005 self.__field_eor=STRING(**{ 'terminator': None, 'default': '|0|0|3|>\x0A\xF4' })
1006 self.__field_eor.readfrombuffer(buf)
1007 self._bufferendoffset=buf.getcurrentoffset()
1008
1009
1010 def __getfield_name(self):
1011 return self.__field_name.getvalue()
1012
1013 def __setfield_name(self, value):
1014 if isinstance(value,STRING):
1015 self.__field_name=value
1016 else:
1017 self.__field_name=STRING(value,**{ 'terminator': None })
1018
1019 def __delfield_name(self): del self.__field_name
1020
1021 name=property(__getfield_name, __setfield_name, __delfield_name, None)
1022
1023 def __getfield_path_prefix(self):
1024 try: self.__field_path_prefix
1025 except:
1026 self.__field_path_prefix=STRING(**{ 'terminator': None, 'default': '|/ff/' })
1027 return self.__field_path_prefix.getvalue()
1028
1029 def __setfield_path_prefix(self, value):
1030 if isinstance(value,STRING):
1031 self.__field_path_prefix=value
1032 else:
1033 self.__field_path_prefix=STRING(value,**{ 'terminator': None, 'default': '|/ff/' })
1034
1035 def __delfield_path_prefix(self): del self.__field_path_prefix
1036
1037 path_prefix=property(__getfield_path_prefix, __setfield_path_prefix, __delfield_path_prefix, None)
1038
1039 def __getfield_pathname(self):
1040 return self.__field_pathname.getvalue()
1041
1042 def __setfield_pathname(self, value):
1043 if isinstance(value,STRING):
1044 self.__field_pathname=value
1045 else:
1046 self.__field_pathname=STRING(value,**{ 'terminator': None })
1047
1048 def __delfield_pathname(self): del self.__field_pathname
1049
1050 pathname=property(__getfield_pathname, __setfield_pathname, __delfield_pathname, None)
1051
1052 def __getfield_eor(self):
1053 try: self.__field_eor
1054 except:
1055 self.__field_eor=STRING(**{ 'terminator': None, 'default': '|0|0|3|>\x0A\xF4' })
1056 return self.__field_eor.getvalue()
1057
1058 def __setfield_eor(self, value):
1059 if isinstance(value,STRING):
1060 self.__field_eor=value
1061 else:
1062 self.__field_eor=STRING(value,**{ 'terminator': None, 'default': '|0|0|3|>\x0A\xF4' })
1063
1064 def __delfield_eor(self): del self.__field_eor
1065
1066 eor=property(__getfield_eor, __setfield_eor, __delfield_eor, None)
1067
1068 def iscontainer(self):
1069 return True
1070
1071 def containerelements(self):
1072 yield ('name', self.__field_name, None)
1073 yield ('path_prefix', self.__field_path_prefix, None)
1074 yield ('pathname', self.__field_pathname, None)
1075 yield ('eor', self.__field_eor, None)
1076
1077
1078
1079
1080 class WPictureIndexFile(BaseProtogenClass):
1081 __fields=['header', 'items']
1082
1083 def __init__(self, *args, **kwargs):
1084 dict={}
1085 dict.update(kwargs)
1087 super(WPictureIndexFile,self).__init__(**dict)
1089 if self.__class__ is WPictureIndexFile:
1090 self._update(args,dict)
1091
1092
1093 def getfields(self):
1094 return self.__fields
1095
1096
1097 def _update(self, args, kwargs):
1098 super(WPictureIndexFile,self)._update(args,kwargs)
1099 keys=kwargs.keys()
1100 for key in keys:
1101 if key in self.__fields:
1102 setattr(self, key, kwargs[key])
1103 del kwargs[key]
1104 if __debug__:
1106 self._complainaboutunusedargs(WPictureIndexFile,kwargs)
1107 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1108
1110
1111 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1112 'Writes this packet to the supplied buffer'
1113 self._bufferstartoffset=buf.getcurrentoffset()
1114 try: self.__field_header
1115 except:
1116 self.__field_header=STRING(**{ 'terminator': None, 'default': '0|/ff/brew/16452/mp/Default Album|\x0A\x0A\xF4' })
1117 self.__field_header.writetobuffer(buf)
1118 try: self.__field_items
1119 except:
1120 self.__field_items=LIST(**{ 'elementclass': WPictureIndexEntry })
1121 self.__field_items.writetobuffer(buf)
1122 self._bufferendoffset=buf.getcurrentoffset()
1123 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1124
1125
1126 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1127 'Reads this packet from the supplied buffer'
1128 self._bufferstartoffset=buf.getcurrentoffset()
1129 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1130 self.__field_header=STRING(**{ 'terminator': None, 'default': '0|/ff/brew/16452/mp/Default Album|\x0A\x0A\xF4' })
1131 self.__field_header.readfrombuffer(buf)
1132 self.__field_items=LIST(**{ 'elementclass': WPictureIndexEntry })
1133 self.__field_items.readfrombuffer(buf)
1134 self._bufferendoffset=buf.getcurrentoffset()
1135
1136
1137 def __getfield_header(self):
1138 try: self.__field_header
1139 except:
1140 self.__field_header=STRING(**{ 'terminator': None, 'default': '0|/ff/brew/16452/mp/Default Album|\x0A\x0A\xF4' })
1141 return self.__field_header.getvalue()
1142
1143 def __setfield_header(self, value):
1144 if isinstance(value,STRING):
1145 self.__field_header=value
1146 else:
1147 self.__field_header=STRING(value,**{ 'terminator': None, 'default': '0|/ff/brew/16452/mp/Default Album|\x0A\x0A\xF4' })
1148
1149 def __delfield_header(self): del self.__field_header
1150
1151 header=property(__getfield_header, __setfield_header, __delfield_header, None)
1152
1153 def __getfield_items(self):
1154 try: self.__field_items
1155 except:
1156 self.__field_items=LIST(**{ 'elementclass': WPictureIndexEntry })
1157 return self.__field_items.getvalue()
1158
1159 def __setfield_items(self, value):
1160 if isinstance(value,LIST):
1161 self.__field_items=value
1162 else:
1163 self.__field_items=LIST(value,**{ 'elementclass': WPictureIndexEntry })
1164
1165 def __delfield_items(self): del self.__field_items
1166
1167 items=property(__getfield_items, __setfield_items, __delfield_items, None)
1168
1169 def iscontainer(self):
1170 return True
1171
1172 def containerelements(self):
1173 yield ('header', self.__field_header, None)
1174 yield ('items', self.__field_items, None)
1175
1176
1177
1178
1179 class RPictureIndexEntry(BaseProtogenClass):
1180 __fields=['name', 'pathname', 'misc']
1181
1182 def __init__(self, *args, **kwargs):
1183 dict={}
1184 dict.update(kwargs)
1186 super(RPictureIndexEntry,self).__init__(**dict)
1188 if self.__class__ is RPictureIndexEntry:
1189 self._update(args,dict)
1190
1191
1192 def getfields(self):
1193 return self.__fields
1194
1195
1196 def _update(self, args, kwargs):
1197 super(RPictureIndexEntry,self)._update(args,kwargs)
1198 keys=kwargs.keys()
1199 for key in keys:
1200 if key in self.__fields:
1201 setattr(self, key, kwargs[key])
1202 del kwargs[key]
1203 if __debug__:
1205 self._complainaboutunusedargs(RPictureIndexEntry,kwargs)
1206 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1207
1209
1210 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1211 'Writes this packet to the supplied buffer'
1212 self._bufferstartoffset=buf.getcurrentoffset()
1213 self.__field_name.writetobuffer(buf)
1214 self.__field_pathname.writetobuffer(buf)
1215 self.__field_misc.writetobuffer(buf)
1216 self._bufferendoffset=buf.getcurrentoffset()
1217 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1218
1219
1220 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1221 'Reads this packet from the supplied buffer'
1222 self._bufferstartoffset=buf.getcurrentoffset()
1223 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1224 self.__field_name=STRING(**{ 'terminator': 0x7C })
1225 self.__field_name.readfrombuffer(buf)
1226 self.__field_pathname=STRING(**{ 'terminator': 0x7C })
1227 self.__field_pathname.readfrombuffer(buf)
1228 self.__field_misc=STRING(**{ 'terminator': 0xF4, 'raiseonunterminatedread': False })
1229 self.__field_misc.readfrombuffer(buf)
1230 self._bufferendoffset=buf.getcurrentoffset()
1231
1232
1233 def __getfield_name(self):
1234 return self.__field_name.getvalue()
1235
1236 def __setfield_name(self, value):
1237 if isinstance(value,STRING):
1238 self.__field_name=value
1239 else:
1240 self.__field_name=STRING(value,**{ 'terminator': 0x7C })
1241
1242 def __delfield_name(self): del self.__field_name
1243
1244 name=property(__getfield_name, __setfield_name, __delfield_name, None)
1245
1246 def __getfield_pathname(self):
1247 return self.__field_pathname.getvalue()
1248
1249 def __setfield_pathname(self, value):
1250 if isinstance(value,STRING):
1251 self.__field_pathname=value
1252 else:
1253 self.__field_pathname=STRING(value,**{ 'terminator': 0x7C })
1254
1255 def __delfield_pathname(self): del self.__field_pathname
1256
1257 pathname=property(__getfield_pathname, __setfield_pathname, __delfield_pathname, None)
1258
1259 def __getfield_misc(self):
1260 return self.__field_misc.getvalue()
1261
1262 def __setfield_misc(self, value):
1263 if isinstance(value,STRING):
1264 self.__field_misc=value
1265 else:
1266 self.__field_misc=STRING(value,**{ 'terminator': 0xF4, 'raiseonunterminatedread': False })
1267
1268 def __delfield_misc(self): del self.__field_misc
1269
1270 misc=property(__getfield_misc, __setfield_misc, __delfield_misc, None)
1271
1272 def iscontainer(self):
1273 return True
1274
1275 def containerelements(self):
1276 yield ('name', self.__field_name, None)
1277 yield ('pathname', self.__field_pathname, None)
1278 yield ('misc', self.__field_misc, None)
1279
1280
1281
1282
1283 class RPictureIndexFile(BaseProtogenClass):
1284 __fields=['items']
1285
1286 def __init__(self, *args, **kwargs):
1287 dict={}
1288 dict.update(kwargs)
1290 super(RPictureIndexFile,self).__init__(**dict)
1292 if self.__class__ is RPictureIndexFile:
1293 self._update(args,dict)
1294
1295
1296 def getfields(self):
1297 return self.__fields
1298
1299
1300 def _update(self, args, kwargs):
1301 super(RPictureIndexFile,self)._update(args,kwargs)
1302 keys=kwargs.keys()
1303 for key in keys:
1304 if key in self.__fields:
1305 setattr(self, key, kwargs[key])
1306 del kwargs[key]
1307 if __debug__:
1309 self._complainaboutunusedargs(RPictureIndexFile,kwargs)
1310 if len(args):
1311 dict2={ 'elementclass': RPictureIndexEntry }
1312 dict2.update(kwargs)
1313 kwargs=dict2
1314 self.__field_items=LIST(*args,**dict2)
1315
1317
1318 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1319 'Writes this packet to the supplied buffer'
1320 self._bufferstartoffset=buf.getcurrentoffset()
1321 try: self.__field_items
1322 except:
1323 self.__field_items=LIST(**{ 'elementclass': RPictureIndexEntry })
1324 self.__field_items.writetobuffer(buf)
1325 self._bufferendoffset=buf.getcurrentoffset()
1326 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1327
1328
1329 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1330 'Reads this packet from the supplied buffer'
1331 self._bufferstartoffset=buf.getcurrentoffset()
1332 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1333 self.__field_items=LIST(**{ 'elementclass': RPictureIndexEntry })
1334 self.__field_items.readfrombuffer(buf)
1335 self._bufferendoffset=buf.getcurrentoffset()
1336
1337
1338 def __getfield_items(self):
1339 try: self.__field_items
1340 except:
1341 self.__field_items=LIST(**{ 'elementclass': RPictureIndexEntry })
1342 return self.__field_items.getvalue()
1343
1344 def __setfield_items(self, value):
1345 if isinstance(value,LIST):
1346 self.__field_items=value
1347 else:
1348 self.__field_items=LIST(value,**{ 'elementclass': RPictureIndexEntry })
1349
1350 def __delfield_items(self): del self.__field_items
1351
1352 items=property(__getfield_items, __setfield_items, __delfield_items, None)
1353
1354 def iscontainer(self):
1355 return True
1356
1357 def containerelements(self):
1358 yield ('items', self.__field_items, None)
1359
1360
1361
1362
1363 class GroupEntry(BaseProtogenClass):
1364 __fields=['index', 'dunno1', 'datetime', 'name', 'numofmembers', 'members']
1365
1366 def __init__(self, *args, **kwargs):
1367 dict={}
1368 dict.update(kwargs)
1370 super(GroupEntry,self).__init__(**dict)
1372 if self.__class__ is GroupEntry:
1373 self._update(args,dict)
1374
1375
1376 def getfields(self):
1377 return self.__fields
1378
1379
1380 def _update(self, args, kwargs):
1381 super(GroupEntry,self)._update(args,kwargs)
1382 keys=kwargs.keys()
1383 for key in keys:
1384 if key in self.__fields:
1385 setattr(self, key, kwargs[key])
1386 del kwargs[key]
1387 if __debug__:
1389 self._complainaboutunusedargs(GroupEntry,kwargs)
1390 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1391
1393
1394 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1395 'Writes this packet to the supplied buffer'
1396 self._bufferstartoffset=buf.getcurrentoffset()
1397 self.__field_index.writetobuffer(buf)
1398 self.__field_dunno1.writetobuffer(buf)
1399 self.__field_datetime.writetobuffer(buf)
1400 self.__field_name.writetobuffer(buf)
1401 self.__field_numofmembers.writetobuffer(buf)
1402 if self.numofmembers:
1403 self.__field_members.writetobuffer(buf)
1404 self._bufferendoffset=buf.getcurrentoffset()
1405 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1406
1407
1408 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1409 'Reads this packet from the supplied buffer'
1410 self._bufferstartoffset=buf.getcurrentoffset()
1411 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1412 self.__field_index=UINT(**{'sizeinbytes': 1})
1413 self.__field_index.readfrombuffer(buf)
1414 self.__field_dunno1=UNKNOWN(**{'sizeinbytes': 4})
1415 self.__field_dunno1.readfrombuffer(buf)
1416 self.__field_datetime=DateTime(**{'sizeinbytes': 4})
1417 self.__field_datetime.readfrombuffer(buf)
1418 self.__field_name=USTRING(**{'sizeinbytes': 68, 'encoding': ENCODING, 'terminator': 0 })
1419 self.__field_name.readfrombuffer(buf)
1420 self.__field_numofmembers=UINT(**{'sizeinbytes': 2})
1421 self.__field_numofmembers.readfrombuffer(buf)
1422 if self.numofmembers:
1423 self.__field_members=LIST(**{'elementclass': _gen_p_samsungscha950_186, 'length': self.numofmembers })
1424 self.__field_members.readfrombuffer(buf)
1425 self._bufferendoffset=buf.getcurrentoffset()
1426
1427
1428 def __getfield_index(self):
1429 return self.__field_index.getvalue()
1430
1431 def __setfield_index(self, value):
1432 if isinstance(value,UINT):
1433 self.__field_index=value
1434 else:
1435 self.__field_index=UINT(value,**{'sizeinbytes': 1})
1436
1437 def __delfield_index(self): del self.__field_index
1438
1439 index=property(__getfield_index, __setfield_index, __delfield_index, None)
1440
1441 def __getfield_dunno1(self):
1442 return self.__field_dunno1.getvalue()
1443
1444 def __setfield_dunno1(self, value):
1445 if isinstance(value,UNKNOWN):
1446 self.__field_dunno1=value
1447 else:
1448 self.__field_dunno1=UNKNOWN(value,**{'sizeinbytes': 4})
1449
1450 def __delfield_dunno1(self): del self.__field_dunno1
1451
1452 dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None)
1453
1454 def __getfield_datetime(self):
1455 return self.__field_datetime.getvalue()
1456
1457 def __setfield_datetime(self, value):
1458 if isinstance(value,DateTime):
1459 self.__field_datetime=value
1460 else:
1461 self.__field_datetime=DateTime(value,**{'sizeinbytes': 4})
1462
1463 def __delfield_datetime(self): del self.__field_datetime
1464
1465 datetime=property(__getfield_datetime, __setfield_datetime, __delfield_datetime, None)
1466
1467 def __getfield_name(self):
1468 return self.__field_name.getvalue()
1469
1470 def __setfield_name(self, value):
1471 if isinstance(value,USTRING):
1472 self.__field_name=value
1473 else:
1474 self.__field_name=USTRING(value,**{'sizeinbytes': 68, 'encoding': ENCODING, 'terminator': 0 })
1475
1476 def __delfield_name(self): del self.__field_name
1477
1478 name=property(__getfield_name, __setfield_name, __delfield_name, None)
1479
1480 def __getfield_numofmembers(self):
1481 return self.__field_numofmembers.getvalue()
1482
1483 def __setfield_numofmembers(self, value):
1484 if isinstance(value,UINT):
1485 self.__field_numofmembers=value
1486 else:
1487 self.__field_numofmembers=UINT(value,**{'sizeinbytes': 2})
1488
1489 def __delfield_numofmembers(self): del self.__field_numofmembers
1490
1491 numofmembers=property(__getfield_numofmembers, __setfield_numofmembers, __delfield_numofmembers, None)
1492
1493 def __getfield_members(self):
1494 return self.__field_members.getvalue()
1495
1496 def __setfield_members(self, value):
1497 if isinstance(value,LIST):
1498 self.__field_members=value
1499 else:
1500 self.__field_members=LIST(value,**{'elementclass': _gen_p_samsungscha950_186, 'length': self.numofmembers })
1501
1502 def __delfield_members(self): del self.__field_members
1503
1504 members=property(__getfield_members, __setfield_members, __delfield_members, None)
1505
1506 def iscontainer(self):
1507 return True
1508
1509 def containerelements(self):
1510 yield ('index', self.__field_index, None)
1511 yield ('dunno1', self.__field_dunno1, None)
1512 yield ('datetime', self.__field_datetime, None)
1513 yield ('name', self.__field_name, None)
1514 yield ('numofmembers', self.__field_numofmembers, None)
1515 if self.numofmembers:
1516 yield ('members', self.__field_members, None)
1517
1518
1519
1520
1521 class _gen_p_samsungscha950_186(BaseProtogenClass):
1522 'Anonymous inner class'
1523 __fields=['index']
1524
1525 def __init__(self, *args, **kwargs):
1526 dict={}
1527 dict.update(kwargs)
1529 super(_gen_p_samsungscha950_186,self).__init__(**dict)
1531 if self.__class__ is _gen_p_samsungscha950_186:
1532 self._update(args,dict)
1533
1534
1535 def getfields(self):
1536 return self.__fields
1537
1538
1539 def _update(self, args, kwargs):
1540 super(_gen_p_samsungscha950_186,self)._update(args,kwargs)
1541 keys=kwargs.keys()
1542 for key in keys:
1543 if key in self.__fields:
1544 setattr(self, key, kwargs[key])
1545 del kwargs[key]
1546 if __debug__:
1548 self._complainaboutunusedargs(_gen_p_samsungscha950_186,kwargs)
1549 if len(args):
1550 dict2={'sizeinbytes': 2}
1551 dict2.update(kwargs)
1552 kwargs=dict2
1553 self.__field_index=UINT(*args,**dict2)
1554
1556
1557 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1558 'Writes this packet to the supplied buffer'
1559 self._bufferstartoffset=buf.getcurrentoffset()
1560 self.__field_index.writetobuffer(buf)
1561 self._bufferendoffset=buf.getcurrentoffset()
1562 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1563
1564
1565 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1566 'Reads this packet from the supplied buffer'
1567 self._bufferstartoffset=buf.getcurrentoffset()
1568 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1569 self.__field_index=UINT(**{'sizeinbytes': 2})
1570 self.__field_index.readfrombuffer(buf)
1571 self._bufferendoffset=buf.getcurrentoffset()
1572
1573
1574 def __getfield_index(self):
1575 return self.__field_index.getvalue()
1576
1577 def __setfield_index(self, value):
1578 if isinstance(value,UINT):
1579 self.__field_index=value
1580 else:
1581 self.__field_index=UINT(value,**{'sizeinbytes': 2})
1582
1583 def __delfield_index(self): del self.__field_index
1584
1585 index=property(__getfield_index, __setfield_index, __delfield_index, None)
1586
1587 def iscontainer(self):
1588 return True
1589
1590 def containerelements(self):
1591 yield ('index', self.__field_index, None)
1592
1593
1594
1595
1596 class GroupIndexFile(BaseProtogenClass):
1597 __fields=['num_of_entries', 'items']
1598
1599 def __init__(self, *args, **kwargs):
1600 dict={}
1601 dict.update(kwargs)
1603 super(GroupIndexFile,self).__init__(**dict)
1605 if self.__class__ is GroupIndexFile:
1606 self._update(args,dict)
1607
1608
1609 def getfields(self):
1610 return self.__fields
1611
1612
1613 def _update(self, args, kwargs):
1614 super(GroupIndexFile,self)._update(args,kwargs)
1615 keys=kwargs.keys()
1616 for key in keys:
1617 if key in self.__fields:
1618 setattr(self, key, kwargs[key])
1619 del kwargs[key]
1620 if __debug__:
1622 self._complainaboutunusedargs(GroupIndexFile,kwargs)
1623 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1624
1626
1627 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1628 'Writes this packet to the supplied buffer'
1629 self._bufferstartoffset=buf.getcurrentoffset()
1630 self.__field_num_of_entries.writetobuffer(buf)
1631 try: self.__field_items
1632 except:
1633 self.__field_items=LIST(**{ 'elementclass': GroupEntry })
1634 self.__field_items.writetobuffer(buf)
1635 self._bufferendoffset=buf.getcurrentoffset()
1636 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1637
1638
1639 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1640 'Reads this packet from the supplied buffer'
1641 self._bufferstartoffset=buf.getcurrentoffset()
1642 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1643 self.__field_num_of_entries=UINT(**{'sizeinbytes': 1})
1644 self.__field_num_of_entries.readfrombuffer(buf)
1645 self.__field_items=LIST(**{ 'elementclass': GroupEntry })
1646 self.__field_items.readfrombuffer(buf)
1647 self._bufferendoffset=buf.getcurrentoffset()
1648
1649
1650 def __getfield_num_of_entries(self):
1651 return self.__field_num_of_entries.getvalue()
1652
1653 def __setfield_num_of_entries(self, value):
1654 if isinstance(value,UINT):
1655 self.__field_num_of_entries=value
1656 else:
1657 self.__field_num_of_entries=UINT(value,**{'sizeinbytes': 1})
1658
1659 def __delfield_num_of_entries(self): del self.__field_num_of_entries
1660
1661 num_of_entries=property(__getfield_num_of_entries, __setfield_num_of_entries, __delfield_num_of_entries, None)
1662
1663 def __getfield_items(self):
1664 try: self.__field_items
1665 except:
1666 self.__field_items=LIST(**{ 'elementclass': GroupEntry })
1667 return self.__field_items.getvalue()
1668
1669 def __setfield_items(self, value):
1670 if isinstance(value,LIST):
1671 self.__field_items=value
1672 else:
1673 self.__field_items=LIST(value,**{ 'elementclass': GroupEntry })
1674
1675 def __delfield_items(self): del self.__field_items
1676
1677 items=property(__getfield_items, __setfield_items, __delfield_items, None)
1678
1679 def iscontainer(self):
1680 return True
1681
1682 def containerelements(self):
1683 yield ('num_of_entries', self.__field_num_of_entries, None)
1684 yield ('items', self.__field_items, None)
1685
1686
1687
1688
1689 class CalIndexEntry(BaseProtogenClass):
1690 __fields=['index']
1691
1692 def __init__(self, *args, **kwargs):
1693 dict={}
1694 dict.update(kwargs)
1696 super(CalIndexEntry,self).__init__(**dict)
1698 if self.__class__ is CalIndexEntry:
1699 self._update(args,dict)
1700
1701
1702 def getfields(self):
1703 return self.__fields
1704
1705
1706 def _update(self, args, kwargs):
1707 super(CalIndexEntry,self)._update(args,kwargs)
1708 keys=kwargs.keys()
1709 for key in keys:
1710 if key in self.__fields:
1711 setattr(self, key, kwargs[key])
1712 del kwargs[key]
1713 if __debug__:
1715 self._complainaboutunusedargs(CalIndexEntry,kwargs)
1716 if len(args):
1717 dict2={'sizeinbytes': 2, 'default': 0 }
1718 dict2.update(kwargs)
1719 kwargs=dict2
1720 self.__field_index=UINT(*args,**dict2)
1721
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 try: self.__field_index
1728 except:
1729 self.__field_index=UINT(**{'sizeinbytes': 2, 'default': 0 })
1730 self.__field_index.writetobuffer(buf)
1731 self._bufferendoffset=buf.getcurrentoffset()
1732 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1733
1734
1735 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1736 'Reads this packet from the supplied buffer'
1737 self._bufferstartoffset=buf.getcurrentoffset()
1738 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1739 self.__field_index=UINT(**{'sizeinbytes': 2, 'default': 0 })
1740 self.__field_index.readfrombuffer(buf)
1741 self._bufferendoffset=buf.getcurrentoffset()
1742
1743
1744 def __getfield_index(self):
1745 try: self.__field_index
1746 except:
1747 self.__field_index=UINT(**{'sizeinbytes': 2, 'default': 0 })
1748 return self.__field_index.getvalue()
1749
1750 def __setfield_index(self, value):
1751 if isinstance(value,UINT):
1752 self.__field_index=value
1753 else:
1754 self.__field_index=UINT(value,**{'sizeinbytes': 2, 'default': 0 })
1755
1756 def __delfield_index(self): del self.__field_index
1757
1758 index=property(__getfield_index, __setfield_index, __delfield_index, None)
1759
1760 def iscontainer(self):
1761 return True
1762
1763 def containerelements(self):
1764 yield ('index', self.__field_index, None)
1765
1766
1767
1768
1769 class CalIndexFile(BaseProtogenClass):
1770 __fields=['next_index', 'zero1', 'numofevents', 'zero2', 'numofnotes', 'zero3', 'numofactiveevents', 'zero4', 'events', 'notes', 'activeevents']
1771
1772 def __init__(self, *args, **kwargs):
1773 dict={}
1774 dict.update(kwargs)
1776 super(CalIndexFile,self).__init__(**dict)
1778 if self.__class__ is CalIndexFile:
1779 self._update(args,dict)
1780
1781
1782 def getfields(self):
1783 return self.__fields
1784
1785
1786 def _update(self, args, kwargs):
1787 super(CalIndexFile,self)._update(args,kwargs)
1788 keys=kwargs.keys()
1789 for key in keys:
1790 if key in self.__fields:
1791 setattr(self, key, kwargs[key])
1792 del kwargs[key]
1793 if __debug__:
1795 self._complainaboutunusedargs(CalIndexFile,kwargs)
1796 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1797
1799
1800 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1801 'Writes this packet to the supplied buffer'
1802 self._bufferstartoffset=buf.getcurrentoffset()
1803 self.__field_next_index.writetobuffer(buf)
1804 try: self.__field_zero1
1805 except:
1806 self.__field_zero1=UNKNOWN(**{'sizeinbytes': 12, 'pad': 0 })
1807 self.__field_zero1.writetobuffer(buf)
1808 self.__field_numofevents.writetobuffer(buf)
1809 try: self.__field_zero2
1810 except:
1811 self.__field_zero2=UNKNOWN(**{'sizeinbytes': 6, 'pad': 0 })
1812 self.__field_zero2.writetobuffer(buf)
1813 self.__field_numofnotes.writetobuffer(buf)
1814 try: self.__field_zero3
1815 except:
1816 self.__field_zero3=UNKNOWN(**{'sizeinbytes': 2, 'pad': 0 })
1817 self.__field_zero3.writetobuffer(buf)
1818 self.__field_numofactiveevents.writetobuffer(buf)
1819 try: self.__field_zero4
1820 except:
1821 self.__field_zero4=UNKNOWN(**{'sizeinbytes': 112, 'pad': 0 })
1822 self.__field_zero4.writetobuffer(buf)
1823 try: self.__field_events
1824 except:
1825 self.__field_events=LIST(**{ 'elementclass': CalIndexEntry, 'length': 103, 'createdefault': True })
1826 self.__field_events.writetobuffer(buf)
1827 try: self.__field_notes
1828 except:
1829 self.__field_notes=LIST(**{ 'elementclass': CalIndexEntry, 'length': 30, 'createdefault': True })
1830 self.__field_notes.writetobuffer(buf)
1831 try: self.__field_activeevents
1832 except:
1833 self.__field_activeevents=LIST(**{ 'elementclass': CalIndexEntry, 'length': 324, 'createdefault': True })
1834 self.__field_activeevents.writetobuffer(buf)
1835 self._bufferendoffset=buf.getcurrentoffset()
1836 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1837
1838
1839 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1840 'Reads this packet from the supplied buffer'
1841 self._bufferstartoffset=buf.getcurrentoffset()
1842 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1843 self.__field_next_index=UINT(**{'sizeinbytes': 2})
1844 self.__field_next_index.readfrombuffer(buf)
1845 self.__field_zero1=UNKNOWN(**{'sizeinbytes': 12, 'pad': 0 })
1846 self.__field_zero1.readfrombuffer(buf)
1847 self.__field_numofevents=UINT(**{'sizeinbytes': 2})
1848 self.__field_numofevents.readfrombuffer(buf)
1849 self.__field_zero2=UNKNOWN(**{'sizeinbytes': 6, 'pad': 0 })
1850 self.__field_zero2.readfrombuffer(buf)
1851 self.__field_numofnotes=UINT(**{'sizeinbytes': 2})
1852 self.__field_numofnotes.readfrombuffer(buf)
1853 self.__field_zero3=UNKNOWN(**{'sizeinbytes': 2, 'pad': 0 })
1854 self.__field_zero3.readfrombuffer(buf)
1855 self.__field_numofactiveevents=UINT(**{'sizeinbytes': 2})
1856 self.__field_numofactiveevents.readfrombuffer(buf)
1857 self.__field_zero4=UNKNOWN(**{'sizeinbytes': 112, 'pad': 0 })
1858 self.__field_zero4.readfrombuffer(buf)
1859 self.__field_events=LIST(**{ 'elementclass': CalIndexEntry, 'length': 103, 'createdefault': True })
1860 self.__field_events.readfrombuffer(buf)
1861 self.__field_notes=LIST(**{ 'elementclass': CalIndexEntry, 'length': 30, 'createdefault': True })
1862 self.__field_notes.readfrombuffer(buf)
1863 self.__field_activeevents=LIST(**{ 'elementclass': CalIndexEntry, 'length': 324, 'createdefault': True })
1864 self.__field_activeevents.readfrombuffer(buf)
1865 self._bufferendoffset=buf.getcurrentoffset()
1866
1867
1868 def __getfield_next_index(self):
1869 return self.__field_next_index.getvalue()
1870
1871 def __setfield_next_index(self, value):
1872 if isinstance(value,UINT):
1873 self.__field_next_index=value
1874 else:
1875 self.__field_next_index=UINT(value,**{'sizeinbytes': 2})
1876
1877 def __delfield_next_index(self): del self.__field_next_index
1878
1879 next_index=property(__getfield_next_index, __setfield_next_index, __delfield_next_index, None)
1880
1881 def __getfield_zero1(self):
1882 try: self.__field_zero1
1883 except:
1884 self.__field_zero1=UNKNOWN(**{'sizeinbytes': 12, 'pad': 0 })
1885 return self.__field_zero1.getvalue()
1886
1887 def __setfield_zero1(self, value):
1888 if isinstance(value,UNKNOWN):
1889 self.__field_zero1=value
1890 else:
1891 self.__field_zero1=UNKNOWN(value,**{'sizeinbytes': 12, 'pad': 0 })
1892
1893 def __delfield_zero1(self): del self.__field_zero1
1894
1895 zero1=property(__getfield_zero1, __setfield_zero1, __delfield_zero1, None)
1896
1897 def __getfield_numofevents(self):
1898 return self.__field_numofevents.getvalue()
1899
1900 def __setfield_numofevents(self, value):
1901 if isinstance(value,UINT):
1902 self.__field_numofevents=value
1903 else:
1904 self.__field_numofevents=UINT(value,**{'sizeinbytes': 2})
1905
1906 def __delfield_numofevents(self): del self.__field_numofevents
1907
1908 numofevents=property(__getfield_numofevents, __setfield_numofevents, __delfield_numofevents, None)
1909
1910 def __getfield_zero2(self):
1911 try: self.__field_zero2
1912 except:
1913 self.__field_zero2=UNKNOWN(**{'sizeinbytes': 6, 'pad': 0 })
1914 return self.__field_zero2.getvalue()
1915
1916 def __setfield_zero2(self, value):
1917 if isinstance(value,UNKNOWN):
1918 self.__field_zero2=value
1919 else:
1920 self.__field_zero2=UNKNOWN(value,**{'sizeinbytes': 6, 'pad': 0 })
1921
1922 def __delfield_zero2(self): del self.__field_zero2
1923
1924 zero2=property(__getfield_zero2, __setfield_zero2, __delfield_zero2, None)
1925
1926 def __getfield_numofnotes(self):
1927 return self.__field_numofnotes.getvalue()
1928
1929 def __setfield_numofnotes(self, value):
1930 if isinstance(value,UINT):
1931 self.__field_numofnotes=value
1932 else:
1933 self.__field_numofnotes=UINT(value,**{'sizeinbytes': 2})
1934
1935 def __delfield_numofnotes(self): del self.__field_numofnotes
1936
1937 numofnotes=property(__getfield_numofnotes, __setfield_numofnotes, __delfield_numofnotes, None)
1938
1939 def __getfield_zero3(self):
1940 try: self.__field_zero3
1941 except:
1942 self.__field_zero3=UNKNOWN(**{'sizeinbytes': 2, 'pad': 0 })
1943 return self.__field_zero3.getvalue()
1944
1945 def __setfield_zero3(self, value):
1946 if isinstance(value,UNKNOWN):
1947 self.__field_zero3=value
1948 else:
1949 self.__field_zero3=UNKNOWN(value,**{'sizeinbytes': 2, 'pad': 0 })
1950
1951 def __delfield_zero3(self): del self.__field_zero3
1952
1953 zero3=property(__getfield_zero3, __setfield_zero3, __delfield_zero3, None)
1954
1955 def __getfield_numofactiveevents(self):
1956 return self.__field_numofactiveevents.getvalue()
1957
1958 def __setfield_numofactiveevents(self, value):
1959 if isinstance(value,UINT):
1960 self.__field_numofactiveevents=value
1961 else:
1962 self.__field_numofactiveevents=UINT(value,**{'sizeinbytes': 2})
1963
1964 def __delfield_numofactiveevents(self): del self.__field_numofactiveevents
1965
1966 numofactiveevents=property(__getfield_numofactiveevents, __setfield_numofactiveevents, __delfield_numofactiveevents, None)
1967
1968 def __getfield_zero4(self):
1969 try: self.__field_zero4
1970 except:
1971 self.__field_zero4=UNKNOWN(**{'sizeinbytes': 112, 'pad': 0 })
1972 return self.__field_zero4.getvalue()
1973
1974 def __setfield_zero4(self, value):
1975 if isinstance(value,UNKNOWN):
1976 self.__field_zero4=value
1977 else:
1978 self.__field_zero4=UNKNOWN(value,**{'sizeinbytes': 112, 'pad': 0 })
1979
1980 def __delfield_zero4(self): del self.__field_zero4
1981
1982 zero4=property(__getfield_zero4, __setfield_zero4, __delfield_zero4, None)
1983
1984 def __getfield_events(self):
1985 try: self.__field_events
1986 except:
1987 self.__field_events=LIST(**{ 'elementclass': CalIndexEntry, 'length': 103, 'createdefault': True })
1988 return self.__field_events.getvalue()
1989
1990 def __setfield_events(self, value):
1991 if isinstance(value,LIST):
1992 self.__field_events=value
1993 else:
1994 self.__field_events=LIST(value,**{ 'elementclass': CalIndexEntry, 'length': 103, 'createdefault': True })
1995
1996 def __delfield_events(self): del self.__field_events
1997
1998 events=property(__getfield_events, __setfield_events, __delfield_events, None)
1999
2000 def __getfield_notes(self):
2001 try: self.__field_notes
2002 except:
2003 self.__field_notes=LIST(**{ 'elementclass': CalIndexEntry, 'length': 30, 'createdefault': True })
2004 return self.__field_notes.getvalue()
2005
2006 def __setfield_notes(self, value):
2007 if isinstance(value,LIST):
2008 self.__field_notes=value
2009 else:
2010 self.__field_notes=LIST(value,**{ 'elementclass': CalIndexEntry, 'length': 30, 'createdefault': True })
2011
2012 def __delfield_notes(self): del self.__field_notes
2013
2014 notes=property(__getfield_notes, __setfield_notes, __delfield_notes, None)
2015
2016 def __getfield_activeevents(self):
2017 try: self.__field_activeevents
2018 except:
2019 self.__field_activeevents=LIST(**{ 'elementclass': CalIndexEntry, 'length': 324, 'createdefault': True })
2020 return self.__field_activeevents.getvalue()
2021
2022 def __setfield_activeevents(self, value):
2023 if isinstance(value,LIST):
2024 self.__field_activeevents=value
2025 else:
2026 self.__field_activeevents=LIST(value,**{ 'elementclass': CalIndexEntry, 'length': 324, 'createdefault': True })
2027
2028 def __delfield_activeevents(self): del self.__field_activeevents
2029
2030 activeevents=property(__getfield_activeevents, __setfield_activeevents, __delfield_activeevents, None)
2031
2032 def iscontainer(self):
2033 return True
2034
2035 def containerelements(self):
2036 yield ('next_index', self.__field_next_index, None)
2037 yield ('zero1', self.__field_zero1, None)
2038 yield ('numofevents', self.__field_numofevents, None)
2039 yield ('zero2', self.__field_zero2, None)
2040 yield ('numofnotes', self.__field_numofnotes, None)
2041 yield ('zero3', self.__field_zero3, None)
2042 yield ('numofactiveevents', self.__field_numofactiveevents, None)
2043 yield ('zero4', self.__field_zero4, None)
2044 yield ('events', self.__field_events, None)
2045 yield ('notes', self.__field_notes, None)
2046 yield ('activeevents', self.__field_activeevents, None)
2047
2048
2049
2050
2051 class CalEntry(BaseProtogenClass):
2052 __fields=['titlelen', 'title', 'start', 'zero1', 'start2', 'zero2', 'exptime', 'zero3', 'one', 'repeat', 'three', 'alarm', 'alert', 'zero4', 'duration', 'timezone', 'creationtime', 'zero5', 'modifiedtime', 'zero6', 'ringtonelen', 'ringtone', 'zero7']
2053
2054 def __init__(self, *args, **kwargs):
2055 dict={}
2056 dict.update(kwargs)
2058 super(CalEntry,self).__init__(**dict)
2060 if self.__class__ is CalEntry:
2061 self._update(args,dict)
2062
2063
2064 def getfields(self):
2065 return self.__fields
2066
2067
2068 def _update(self, args, kwargs):
2069 super(CalEntry,self)._update(args,kwargs)
2070 keys=kwargs.keys()
2071 for key in keys:
2072 if key in self.__fields:
2073 setattr(self, key, kwargs[key])
2074 del kwargs[key]
2075 if __debug__:
2077 self._complainaboutunusedargs(CalEntry,kwargs)
2078 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2079
2081
2082 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2083 'Writes this packet to the supplied buffer'
2084 self._bufferstartoffset=buf.getcurrentoffset()
2085 self.__field_titlelen.writetobuffer(buf)
2086 self.__field_title.writetobuffer(buf)
2087 self.__field_start.writetobuffer(buf)
2088 try: self.__field_zero1
2089 except:
2090 self.__field_zero1=UNKNOWN(**{'sizeinbytes': 4, 'pad': 0 })
2091 self.__field_zero1.writetobuffer(buf)
2092 try: self.__field_start2
2093 except:
2094 self.__field_start2=DateTime(**{'sizeinbytes': 4, 'default': self.start })
2095 self.__field_start2.writetobuffer(buf)
2096 try: self.__field_zero2
2097 except:
2098 self.__field_zero2=UNKNOWN(**{'sizeinbytes': 4, 'pad': 0 })
2099 self.__field_zero2.writetobuffer(buf)
2100 self.__field_exptime.writetobuffer(buf)
2101 try: self.__field_zero3
2102 except:
2103 self.__field_zero3=UNKNOWN(**{'sizeinbytes': 4, 'pad': 0 })
2104 self.__field_zero3.writetobuffer(buf)
2105 try: self.__field_one
2106 except:
2107 self.__field_one=UINT(**{'sizeinbytes': 1, 'default': 1 })
2108 self.__field_one.writetobuffer(buf)
2109 self.__field_repeat.writetobuffer(buf)
2110 try: self.__field_three
2111 except:
2112 self.__field_three=UINT(**{'sizeinbytes': 1, 'default': 3 })
2113 self.__field_three.writetobuffer(buf)
2114 self.__field_alarm.writetobuffer(buf)
2115 self.__field_alert.writetobuffer(buf)
2116 try: self.__field_zero4
2117 except:
2118 self.__field_zero4=UNKNOWN(**{'sizeinbytes': 6, 'pad': 0 })
2119 self.__field_zero4.writetobuffer(buf)
2120 self.__field_duration.writetobuffer(buf)
2121 self.__field_timezone.writetobuffer(buf)
2122 self.__field_creationtime.writetobuffer(buf)
2123 try: self.__field_zero5
2124 except:
2125 self.__field_zero5=UNKNOWN(**{'sizeinbytes': 4, 'pad': 0 })
2126 self.__field_zero5.writetobuffer(buf)
2127 self.__field_modifiedtime.writetobuffer(buf)
2128 try: self.__field_zero6
2129 except:
2130 self.__field_zero6=UNKNOWN(**{'sizeinbytes': 4, 'pad': 0 })
2131 self.__field_zero6.writetobuffer(buf)
2132 self.__field_ringtonelen.writetobuffer(buf)
2133 self.__field_ringtone.writetobuffer(buf)
2134 try: self.__field_zero7
2135 except:
2136 self.__field_zero7=UNKNOWN(**{'sizeinbytes': 2, 'pad': 0 })
2137 self.__field_zero7.writetobuffer(buf)
2138 self._bufferendoffset=buf.getcurrentoffset()
2139 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2140
2141
2142 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2143 'Reads this packet from the supplied buffer'
2144 self._bufferstartoffset=buf.getcurrentoffset()
2145 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2146 self.__field_titlelen=UINT(**{'sizeinbytes': 2})
2147 self.__field_titlelen.readfrombuffer(buf)
2148 self.__field_title=USTRING(**{ 'sizeinbytes': self.titlelen, 'encoding': ENCODING, 'terminator': None })
2149 self.__field_title.readfrombuffer(buf)
2150 self.__field_start=DateTime(**{'sizeinbytes': 4})
2151 self.__field_start.readfrombuffer(buf)
2152 self.__field_zero1=UNKNOWN(**{'sizeinbytes': 4, 'pad': 0 })
2153 self.__field_zero1.readfrombuffer(buf)
2154 self.__field_start2=DateTime(**{'sizeinbytes': 4, 'default': self.start })
2155 self.__field_start2.readfrombuffer(buf)
2156 self.__field_zero2=UNKNOWN(**{'sizeinbytes': 4, 'pad': 0 })
2157 self.__field_zero2.readfrombuffer(buf)
2158 self.__field_exptime=ExpiringTime(**{'sizeinbytes': 4})
2159 self.__field_exptime.readfrombuffer(buf)
2160 self.__field_zero3=UNKNOWN(**{'sizeinbytes': 4, 'pad': 0 })
2161 self.__field_zero3.readfrombuffer(buf)
2162 self.__field_one=UINT(**{'sizeinbytes': 1, 'default': 1 })
2163 self.__field_one.readfrombuffer(buf)
2164 self.__field_repeat=UINT(**{'sizeinbytes': 1})
2165 self.__field_repeat.readfrombuffer(buf)
2166 self.__field_three=UINT(**{'sizeinbytes': 1, 'default': 3 })
2167 self.__field_three.readfrombuffer(buf)
2168 self.__field_alarm=UINT(**{'sizeinbytes': 1})
2169 self.__field_alarm.readfrombuffer(buf)
2170 self.__field_alert=UINT(**{'sizeinbytes': 1})
2171 self.__field_alert.readfrombuffer(buf)
2172 self.__field_zero4=UNKNOWN(**{'sizeinbytes': 6, 'pad': 0 })
2173 self.__field_zero4.readfrombuffer(buf)
2174 self.__field_duration=UINT(**{'sizeinbytes': 4})
2175 self.__field_duration.readfrombuffer(buf)
2176 self.__field_timezone=UINT(**{'sizeinbytes': 1})
2177 self.__field_timezone.readfrombuffer(buf)
2178 self.__field_creationtime=DateTime(**{'sizeinbytes': 4})
2179 self.__field_creationtime.readfrombuffer(buf)
2180 self.__field_zero5=UNKNOWN(**{'sizeinbytes': 4, 'pad': 0 })
2181 self.__field_zero5.readfrombuffer(buf)
2182 self.__field_modifiedtime=DateTime(**{'sizeinbytes': 4})
2183 self.__field_modifiedtime.readfrombuffer(buf)
2184 self.__field_zero6=UNKNOWN(**{'sizeinbytes': 4, 'pad': 0 })
2185 self.__field_zero6.readfrombuffer(buf)
2186 self.__field_ringtonelen=UINT(**{'sizeinbytes': 2})
2187 self.__field_ringtonelen.readfrombuffer(buf)
2188 self.__field_ringtone=STRING(**{ 'sizeinbytes': self.ringtonelen, 'terminator': None })
2189 self.__field_ringtone.readfrombuffer(buf)
2190 self.__field_zero7=UNKNOWN(**{'sizeinbytes': 2, 'pad': 0 })
2191 self.__field_zero7.readfrombuffer(buf)
2192 self._bufferendoffset=buf.getcurrentoffset()
2193
2194
2195 def __getfield_titlelen(self):
2196 return self.__field_titlelen.getvalue()
2197
2198 def __setfield_titlelen(self, value):
2199 if isinstance(value,UINT):
2200 self.__field_titlelen=value
2201 else:
2202 self.__field_titlelen=UINT(value,**{'sizeinbytes': 2})
2203
2204 def __delfield_titlelen(self): del self.__field_titlelen
2205
2206 titlelen=property(__getfield_titlelen, __setfield_titlelen, __delfield_titlelen, None)
2207
2208 def __getfield_title(self):
2209 return self.__field_title.getvalue()
2210
2211 def __setfield_title(self, value):
2212 if isinstance(value,USTRING):
2213 self.__field_title=value
2214 else:
2215 self.__field_title=USTRING(value,**{ 'sizeinbytes': self.titlelen, 'encoding': ENCODING, 'terminator': None })
2216
2217 def __delfield_title(self): del self.__field_title
2218
2219 title=property(__getfield_title, __setfield_title, __delfield_title, None)
2220
2221 def __getfield_start(self):
2222 return self.__field_start.getvalue()
2223
2224 def __setfield_start(self, value):
2225 if isinstance(value,DateTime):
2226 self.__field_start=value
2227 else:
2228 self.__field_start=DateTime(value,**{'sizeinbytes': 4})
2229
2230 def __delfield_start(self): del self.__field_start
2231
2232 start=property(__getfield_start, __setfield_start, __delfield_start, None)
2233
2234 def __getfield_zero1(self):
2235 try: self.__field_zero1
2236 except:
2237 self.__field_zero1=UNKNOWN(**{'sizeinbytes': 4, 'pad': 0 })
2238 return self.__field_zero1.getvalue()
2239
2240 def __setfield_zero1(self, value):
2241 if isinstance(value,UNKNOWN):
2242 self.__field_zero1=value
2243 else:
2244 self.__field_zero1=UNKNOWN(value,**{'sizeinbytes': 4, 'pad': 0 })
2245
2246 def __delfield_zero1(self): del self.__field_zero1
2247
2248 zero1=property(__getfield_zero1, __setfield_zero1, __delfield_zero1, None)
2249
2250 def __getfield_start2(self):
2251 try: self.__field_start2
2252 except:
2253 self.__field_start2=DateTime(**{'sizeinbytes': 4, 'default': self.start })
2254 return self.__field_start2.getvalue()
2255
2256 def __setfield_start2(self, value):
2257 if isinstance(value,DateTime):
2258 self.__field_start2=value
2259 else:
2260 self.__field_start2=DateTime(value,**{'sizeinbytes': 4, 'default': self.start })
2261
2262 def __delfield_start2(self): del self.__field_start2
2263
2264 start2=property(__getfield_start2, __setfield_start2, __delfield_start2, None)
2265
2266 def __getfield_zero2(self):
2267 try: self.__field_zero2
2268 except:
2269 self.__field_zero2=UNKNOWN(**{'sizeinbytes': 4, 'pad': 0 })
2270 return self.__field_zero2.getvalue()
2271
2272 def __setfield_zero2(self, value):
2273 if isinstance(value,UNKNOWN):
2274 self.__field_zero2=value
2275 else:
2276 self.__field_zero2=UNKNOWN(value,**{'sizeinbytes': 4, 'pad': 0 })
2277
2278 def __delfield_zero2(self): del self.__field_zero2
2279
2280 zero2=property(__getfield_zero2, __setfield_zero2, __delfield_zero2, None)
2281
2282 def __getfield_exptime(self):
2283 return self.__field_exptime.getvalue()
2284
2285 def __setfield_exptime(self, value):
2286 if isinstance(value,ExpiringTime):
2287 self.__field_exptime=value
2288 else:
2289 self.__field_exptime=ExpiringTime(value,**{'sizeinbytes': 4})
2290
2291 def __delfield_exptime(self): del self.__field_exptime
2292
2293 exptime=property(__getfield_exptime, __setfield_exptime, __delfield_exptime, None)
2294
2295 def __getfield_zero3(self):
2296 try: self.__field_zero3
2297 except:
2298 self.__field_zero3=UNKNOWN(**{'sizeinbytes': 4, 'pad': 0 })
2299 return self.__field_zero3.getvalue()
2300
2301 def __setfield_zero3(self, value):
2302 if isinstance(value,UNKNOWN):
2303 self.__field_zero3=value
2304 else:
2305 self.__field_zero3=UNKNOWN(value,**{'sizeinbytes': 4, 'pad': 0 })
2306
2307 def __delfield_zero3(self): del self.__field_zero3
2308
2309 zero3=property(__getfield_zero3, __setfield_zero3, __delfield_zero3, None)
2310
2311 def __getfield_one(self):
2312 try: self.__field_one
2313 except:
2314 self.__field_one=UINT(**{'sizeinbytes': 1, 'default': 1 })
2315 return self.__field_one.getvalue()
2316
2317 def __setfield_one(self, value):
2318 if isinstance(value,UINT):
2319 self.__field_one=value
2320 else:
2321 self.__field_one=UINT(value,**{'sizeinbytes': 1, 'default': 1 })
2322
2323 def __delfield_one(self): del self.__field_one
2324
2325 one=property(__getfield_one, __setfield_one, __delfield_one, None)
2326
2327 def __getfield_repeat(self):
2328 return self.__field_repeat.getvalue()
2329
2330 def __setfield_repeat(self, value):
2331 if isinstance(value,UINT):
2332 self.__field_repeat=value
2333 else:
2334 self.__field_repeat=UINT(value,**{'sizeinbytes': 1})
2335
2336 def __delfield_repeat(self): del self.__field_repeat
2337
2338 repeat=property(__getfield_repeat, __setfield_repeat, __delfield_repeat, None)
2339
2340 def __getfield_three(self):
2341 try: self.__field_three
2342 except:
2343 self.__field_three=UINT(**{'sizeinbytes': 1, 'default': 3 })
2344 return self.__field_three.getvalue()
2345
2346 def __setfield_three(self, value):
2347 if isinstance(value,UINT):
2348 self.__field_three=value
2349 else:
2350 self.__field_three=UINT(value,**{'sizeinbytes': 1, 'default': 3 })
2351
2352 def __delfield_three(self): del self.__field_three
2353
2354 three=property(__getfield_three, __setfield_three, __delfield_three, None)
2355
2356 def __getfield_alarm(self):
2357 return self.__field_alarm.getvalue()
2358
2359 def __setfield_alarm(self, value):
2360 if isinstance(value,UINT):
2361 self.__field_alarm=value
2362 else:
2363 self.__field_alarm=UINT(value,**{'sizeinbytes': 1})
2364
2365 def __delfield_alarm(self): del self.__field_alarm
2366
2367 alarm=property(__getfield_alarm, __setfield_alarm, __delfield_alarm, None)
2368
2369 def __getfield_alert(self):
2370 return self.__field_alert.getvalue()
2371
2372 def __setfield_alert(self, value):
2373 if isinstance(value,UINT):
2374 self.__field_alert=value
2375 else:
2376 self.__field_alert=UINT(value,**{'sizeinbytes': 1})
2377
2378 def __delfield_alert(self): del self.__field_alert
2379
2380 alert=property(__getfield_alert, __setfield_alert, __delfield_alert, None)
2381
2382 def __getfield_zero4(self):
2383 try: self.__field_zero4
2384 except:
2385 self.__field_zero4=UNKNOWN(**{'sizeinbytes': 6, 'pad': 0 })
2386 return self.__field_zero4.getvalue()
2387
2388 def __setfield_zero4(self, value):
2389 if isinstance(value,UNKNOWN):
2390 self.__field_zero4=value
2391 else:
2392 self.__field_zero4=UNKNOWN(value,**{'sizeinbytes': 6, 'pad': 0 })
2393
2394 def __delfield_zero4(self): del self.__field_zero4
2395
2396 zero4=property(__getfield_zero4, __setfield_zero4, __delfield_zero4, None)
2397
2398 def __getfield_duration(self):
2399 return self.__field_duration.getvalue()
2400
2401 def __setfield_duration(self, value):
2402 if isinstance(value,UINT):
2403 self.__field_duration=value
2404 else:
2405 self.__field_duration=UINT(value,**{'sizeinbytes': 4})
2406
2407 def __delfield_duration(self): del self.__field_duration
2408
2409 duration=property(__getfield_duration, __setfield_duration, __delfield_duration, None)
2410
2411 def __getfield_timezone(self):
2412 return self.__field_timezone.getvalue()
2413
2414 def __setfield_timezone(self, value):
2415 if isinstance(value,UINT):
2416 self.__field_timezone=value
2417 else:
2418 self.__field_timezone=UINT(value,**{'sizeinbytes': 1})
2419
2420 def __delfield_timezone(self): del self.__field_timezone
2421
2422 timezone=property(__getfield_timezone, __setfield_timezone, __delfield_timezone, None)
2423
2424 def __getfield_creationtime(self):
2425 return self.__field_creationtime.getvalue()
2426
2427 def __setfield_creationtime(self, value):
2428 if isinstance(value,DateTime):
2429 self.__field_creationtime=value
2430 else:
2431 self.__field_creationtime=DateTime(value,**{'sizeinbytes': 4})
2432
2433 def __delfield_creationtime(self): del self.__field_creationtime
2434
2435 creationtime=property(__getfield_creationtime, __setfield_creationtime, __delfield_creationtime, None)
2436
2437 def __getfield_zero5(self):
2438 try: self.__field_zero5
2439 except:
2440 self.__field_zero5=UNKNOWN(**{'sizeinbytes': 4, 'pad': 0 })
2441 return self.__field_zero5.getvalue()
2442
2443 def __setfield_zero5(self, value):
2444 if isinstance(value,UNKNOWN):
2445 self.__field_zero5=value
2446 else:
2447 self.__field_zero5=UNKNOWN(value,**{'sizeinbytes': 4, 'pad': 0 })
2448
2449 def __delfield_zero5(self): del self.__field_zero5
2450
2451 zero5=property(__getfield_zero5, __setfield_zero5, __delfield_zero5, None)
2452
2453 def __getfield_modifiedtime(self):
2454 return self.__field_modifiedtime.getvalue()
2455
2456 def __setfield_modifiedtime(self, value):
2457 if isinstance(value,DateTime):
2458 self.__field_modifiedtime=value
2459 else:
2460 self.__field_modifiedtime=DateTime(value,**{'sizeinbytes': 4})
2461
2462 def __delfield_modifiedtime(self): del self.__field_modifiedtime
2463
2464 modifiedtime=property(__getfield_modifiedtime, __setfield_modifiedtime, __delfield_modifiedtime, None)
2465
2466 def __getfield_zero6(self):
2467 try: self.__field_zero6
2468 except:
2469 self.__field_zero6=UNKNOWN(**{'sizeinbytes': 4, 'pad': 0 })
2470 return self.__field_zero6.getvalue()
2471
2472 def __setfield_zero6(self, value):
2473 if isinstance(value,UNKNOWN):
2474 self.__field_zero6=value
2475 else:
2476 self.__field_zero6=UNKNOWN(value,**{'sizeinbytes': 4, 'pad': 0 })
2477
2478 def __delfield_zero6(self): del self.__field_zero6
2479
2480 zero6=property(__getfield_zero6, __setfield_zero6, __delfield_zero6, None)
2481
2482 def __getfield_ringtonelen(self):
2483 return self.__field_ringtonelen.getvalue()
2484
2485 def __setfield_ringtonelen(self, value):
2486 if isinstance(value,UINT):
2487 self.__field_ringtonelen=value
2488 else:
2489 self.__field_ringtonelen=UINT(value,**{'sizeinbytes': 2})
2490
2491 def __delfield_ringtonelen(self): del self.__field_ringtonelen
2492
2493 ringtonelen=property(__getfield_ringtonelen, __setfield_ringtonelen, __delfield_ringtonelen, None)
2494
2495 def __getfield_ringtone(self):
2496 return self.__field_ringtone.getvalue()
2497
2498 def __setfield_ringtone(self, value):
2499 if isinstance(value,STRING):
2500 self.__field_ringtone=value
2501 else:
2502 self.__field_ringtone=STRING(value,**{ 'sizeinbytes': self.ringtonelen, 'terminator': None })
2503
2504 def __delfield_ringtone(self): del self.__field_ringtone
2505
2506 ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None)
2507
2508 def __getfield_zero7(self):
2509 try: self.__field_zero7
2510 except:
2511 self.__field_zero7=UNKNOWN(**{'sizeinbytes': 2, 'pad': 0 })
2512 return self.__field_zero7.getvalue()
2513
2514 def __setfield_zero7(self, value):
2515 if isinstance(value,UNKNOWN):
2516 self.__field_zero7=value
2517 else:
2518 self.__field_zero7=UNKNOWN(value,**{'sizeinbytes': 2, 'pad': 0 })
2519
2520 def __delfield_zero7(self): del self.__field_zero7
2521
2522 zero7=property(__getfield_zero7, __setfield_zero7, __delfield_zero7, None)
2523
2524 def iscontainer(self):
2525 return True
2526
2527 def containerelements(self):
2528 yield ('titlelen', self.__field_titlelen, None)
2529 yield ('title', self.__field_title, None)
2530 yield ('start', self.__field_start, None)
2531 yield ('zero1', self.__field_zero1, None)
2532 yield ('start2', self.__field_start2, None)
2533 yield ('zero2', self.__field_zero2, None)
2534 yield ('exptime', self.__field_exptime, None)
2535 yield ('zero3', self.__field_zero3, None)
2536 yield ('one', self.__field_one, None)
2537 yield ('repeat', self.__field_repeat, None)
2538 yield ('three', self.__field_three, None)
2539 yield ('alarm', self.__field_alarm, None)
2540 yield ('alert', self.__field_alert, None)
2541 yield ('zero4', self.__field_zero4, None)
2542 yield ('duration', self.__field_duration, None)
2543 yield ('timezone', self.__field_timezone, None)
2544 yield ('creationtime', self.__field_creationtime, None)
2545 yield ('zero5', self.__field_zero5, None)
2546 yield ('modifiedtime', self.__field_modifiedtime, None)
2547 yield ('zero6', self.__field_zero6, None)
2548 yield ('ringtonelen', self.__field_ringtonelen, None)
2549 yield ('ringtone', self.__field_ringtone, None)
2550 yield ('zero7', self.__field_zero7, None)
2551
2552
2553
2554
2555 class NotePadEntry(BaseProtogenClass):
2556 __fields=['textlen', 'text', 'creation', 'zero1', 'creation2', 'zero2', 'five', 'zero3', 'modified', 'zero4', 'modified2', 'zero5']
2557
2558 def __init__(self, *args, **kwargs):
2559 dict={}
2560 dict.update(kwargs)
2562 super(NotePadEntry,self).__init__(**dict)
2564 if self.__class__ is NotePadEntry:
2565 self._update(args,dict)
2566
2567
2568 def getfields(self):
2569 return self.__fields
2570
2571
2572 def _update(self, args, kwargs):
2573 super(NotePadEntry,self)._update(args,kwargs)
2574 keys=kwargs.keys()
2575 for key in keys:
2576 if key in self.__fields:
2577 setattr(self, key, kwargs[key])
2578 del kwargs[key]
2579 if __debug__:
2581 self._complainaboutunusedargs(NotePadEntry,kwargs)
2582 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2583
2585
2586 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2587 'Writes this packet to the supplied buffer'
2588 self._bufferstartoffset=buf.getcurrentoffset()
2589 self.__field_textlen.writetobuffer(buf)
2590 self.__field_text.writetobuffer(buf)
2591 self.__field_creation.writetobuffer(buf)
2592 try: self.__field_zero1
2593 except:
2594 self.__field_zero1=UNKNOWN(**{'sizeinbytes': 4, 'pad': 0 })
2595 self.__field_zero1.writetobuffer(buf)
2596 try: self.__field_creation2
2597 except:
2598 self.__field_creation2=DateTime(**{'sizeinbytes': 4, 'default': self.creation })
2599 self.__field_creation2.writetobuffer(buf)
2600 try: self.__field_zero2
2601 except:
2602 self.__field_zero2=UNKNOWN(**{'sizeinbytes': 14, 'pad': 0 })
2603 self.__field_zero2.writetobuffer(buf)
2604 try: self.__field_five
2605 except:
2606 self.__field_five=UINT(**{'sizeinbytes': 1, 'default': 5 })
2607 self.__field_five.writetobuffer(buf)
2608 try: self.__field_zero3
2609 except:
2610 self.__field_zero3=UNKNOWN(**{'sizeinbytes': 13, 'pad': 0 })
2611 self.__field_zero3.writetobuffer(buf)
2612 try: self.__field_modified
2613 except:
2614 self.__field_modified=DateTime(**{'sizeinbytes': 4, 'default': self.creation })
2615 self.__field_modified.writetobuffer(buf)
2616 try: self.__field_zero4
2617 except:
2618 self.__field_zero4=UNKNOWN(**{'sizeinbytes': 4, 'pad': 0 })
2619 self.__field_zero4.writetobuffer(buf)
2620 try: self.__field_modified2
2621 except:
2622 self.__field_modified2=DateTime(**{'sizeinbytes': 4, 'default': self.modified })
2623 self.__field_modified2.writetobuffer(buf)
2624 try: self.__field_zero5
2625 except:
2626 self.__field_zero5=UNKNOWN(**{'sizeinbytes': 8, 'pad': 0 })
2627 self.__field_zero5.writetobuffer(buf)
2628 self._bufferendoffset=buf.getcurrentoffset()
2629 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2630
2631
2632 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2633 'Reads this packet from the supplied buffer'
2634 self._bufferstartoffset=buf.getcurrentoffset()
2635 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2636 self.__field_textlen=UINT(**{'sizeinbytes': 2})
2637 self.__field_textlen.readfrombuffer(buf)
2638 self.__field_text=USTRING(**{ 'terminator': None, 'encoding': ENCODING, 'sizeinbytes': self.textlen })
2639 self.__field_text.readfrombuffer(buf)
2640 self.__field_creation=DateTime(**{'sizeinbytes': 4})
2641 self.__field_creation.readfrombuffer(buf)
2642 self.__field_zero1=UNKNOWN(**{'sizeinbytes': 4, 'pad': 0 })
2643 self.__field_zero1.readfrombuffer(buf)
2644 self.__field_creation2=DateTime(**{'sizeinbytes': 4, 'default': self.creation })
2645 self.__field_creation2.readfrombuffer(buf)
2646 self.__field_zero2=UNKNOWN(**{'sizeinbytes': 14, 'pad': 0 })
2647 self.__field_zero2.readfrombuffer(buf)
2648 self.__field_five=UINT(**{'sizeinbytes': 1, 'default': 5 })
2649 self.__field_five.readfrombuffer(buf)
2650 self.__field_zero3=UNKNOWN(**{'sizeinbytes': 13, 'pad': 0 })
2651 self.__field_zero3.readfrombuffer(buf)
2652 self.__field_modified=DateTime(**{'sizeinbytes': 4, 'default': self.creation })
2653 self.__field_modified.readfrombuffer(buf)
2654 self.__field_zero4=UNKNOWN(**{'sizeinbytes': 4, 'pad': 0 })
2655 self.__field_zero4.readfrombuffer(buf)
2656 self.__field_modified2=DateTime(**{'sizeinbytes': 4, 'default': self.modified })
2657 self.__field_modified2.readfrombuffer(buf)
2658 self.__field_zero5=UNKNOWN(**{'sizeinbytes': 8, 'pad': 0 })
2659 self.__field_zero5.readfrombuffer(buf)
2660 self._bufferendoffset=buf.getcurrentoffset()
2661
2662
2663 def __getfield_textlen(self):
2664 return self.__field_textlen.getvalue()
2665
2666 def __setfield_textlen(self, value):
2667 if isinstance(value,UINT):
2668 self.__field_textlen=value
2669 else:
2670 self.__field_textlen=UINT(value,**{'sizeinbytes': 2})
2671
2672 def __delfield_textlen(self): del self.__field_textlen
2673
2674 textlen=property(__getfield_textlen, __setfield_textlen, __delfield_textlen, None)
2675
2676 def __getfield_text(self):
2677 return self.__field_text.getvalue()
2678
2679 def __setfield_text(self, value):
2680 if isinstance(value,USTRING):
2681 self.__field_text=value
2682 else:
2683 self.__field_text=USTRING(value,**{ 'terminator': None, 'encoding': ENCODING, 'sizeinbytes': self.textlen })
2684
2685 def __delfield_text(self): del self.__field_text
2686
2687 text=property(__getfield_text, __setfield_text, __delfield_text, None)
2688
2689 def __getfield_creation(self):
2690 return self.__field_creation.getvalue()
2691
2692 def __setfield_creation(self, value):
2693 if isinstance(value,DateTime):
2694 self.__field_creation=value
2695 else:
2696 self.__field_creation=DateTime(value,**{'sizeinbytes': 4})
2697
2698 def __delfield_creation(self): del self.__field_creation
2699
2700 creation=property(__getfield_creation, __setfield_creation, __delfield_creation, None)
2701
2702 def __getfield_zero1(self):
2703 try: self.__field_zero1
2704 except:
2705 self.__field_zero1=UNKNOWN(**{'sizeinbytes': 4, 'pad': 0 })
2706 return self.__field_zero1.getvalue()
2707
2708 def __setfield_zero1(self, value):
2709 if isinstance(value,UNKNOWN):
2710 self.__field_zero1=value
2711 else:
2712 self.__field_zero1=UNKNOWN(value,**{'sizeinbytes': 4, 'pad': 0 })
2713
2714 def __delfield_zero1(self): del self.__field_zero1
2715
2716 zero1=property(__getfield_zero1, __setfield_zero1, __delfield_zero1, None)
2717
2718 def __getfield_creation2(self):
2719 try: self.__field_creation2
2720 except:
2721 self.__field_creation2=DateTime(**{'sizeinbytes': 4, 'default': self.creation })
2722 return self.__field_creation2.getvalue()
2723
2724 def __setfield_creation2(self, value):
2725 if isinstance(value,DateTime):
2726 self.__field_creation2=value
2727 else:
2728 self.__field_creation2=DateTime(value,**{'sizeinbytes': 4, 'default': self.creation })
2729
2730 def __delfield_creation2(self): del self.__field_creation2
2731
2732 creation2=property(__getfield_creation2, __setfield_creation2, __delfield_creation2, None)
2733
2734 def __getfield_zero2(self):
2735 try: self.__field_zero2
2736 except:
2737 self.__field_zero2=UNKNOWN(**{'sizeinbytes': 14, 'pad': 0 })
2738 return self.__field_zero2.getvalue()
2739
2740 def __setfield_zero2(self, value):
2741 if isinstance(value,UNKNOWN):
2742 self.__field_zero2=value
2743 else:
2744 self.__field_zero2=UNKNOWN(value,**{'sizeinbytes': 14, 'pad': 0 })
2745
2746 def __delfield_zero2(self): del self.__field_zero2
2747
2748 zero2=property(__getfield_zero2, __setfield_zero2, __delfield_zero2, None)
2749
2750 def __getfield_five(self):
2751 try: self.__field_five
2752 except:
2753 self.__field_five=UINT(**{'sizeinbytes': 1, 'default': 5 })
2754 return self.__field_five.getvalue()
2755
2756 def __setfield_five(self, value):
2757 if isinstance(value,UINT):
2758 self.__field_five=value
2759 else:
2760 self.__field_five=UINT(value,**{'sizeinbytes': 1, 'default': 5 })
2761
2762 def __delfield_five(self): del self.__field_five
2763
2764 five=property(__getfield_five, __setfield_five, __delfield_five, None)
2765
2766 def __getfield_zero3(self):
2767 try: self.__field_zero3
2768 except:
2769 self.__field_zero3=UNKNOWN(**{'sizeinbytes': 13, 'pad': 0 })
2770 return self.__field_zero3.getvalue()
2771
2772 def __setfield_zero3(self, value):
2773 if isinstance(value,UNKNOWN):
2774 self.__field_zero3=value
2775 else:
2776 self.__field_zero3=UNKNOWN(value,**{'sizeinbytes': 13, 'pad': 0 })
2777
2778 def __delfield_zero3(self): del self.__field_zero3
2779
2780 zero3=property(__getfield_zero3, __setfield_zero3, __delfield_zero3, None)
2781
2782 def __getfield_modified(self):
2783 try: self.__field_modified
2784 except:
2785 self.__field_modified=DateTime(**{'sizeinbytes': 4, 'default': self.creation })
2786 return self.__field_modified.getvalue()
2787
2788 def __setfield_modified(self, value):
2789 if isinstance(value,DateTime):
2790 self.__field_modified=value
2791 else:
2792 self.__field_modified=DateTime(value,**{'sizeinbytes': 4, 'default': self.creation })
2793
2794 def __delfield_modified(self): del self.__field_modified
2795
2796 modified=property(__getfield_modified, __setfield_modified, __delfield_modified, None)
2797
2798 def __getfield_zero4(self):
2799 try: self.__field_zero4
2800 except:
2801 self.__field_zero4=UNKNOWN(**{'sizeinbytes': 4, 'pad': 0 })
2802 return self.__field_zero4.getvalue()
2803
2804 def __setfield_zero4(self, value):
2805 if isinstance(value,UNKNOWN):
2806 self.__field_zero4=value
2807 else:
2808 self.__field_zero4=UNKNOWN(value,**{'sizeinbytes': 4, 'pad': 0 })
2809
2810 def __delfield_zero4(self): del self.__field_zero4
2811
2812 zero4=property(__getfield_zero4, __setfield_zero4, __delfield_zero4, None)
2813
2814 def __getfield_modified2(self):
2815 try: self.__field_modified2
2816 except:
2817 self.__field_modified2=DateTime(**{'sizeinbytes': 4, 'default': self.modified })
2818 return self.__field_modified2.getvalue()
2819
2820 def __setfield_modified2(self, value):
2821 if isinstance(value,DateTime):
2822 self.__field_modified2=value
2823 else:
2824 self.__field_modified2=DateTime(value,**{'sizeinbytes': 4, 'default': self.modified })
2825
2826 def __delfield_modified2(self): del self.__field_modified2
2827
2828 modified2=property(__getfield_modified2, __setfield_modified2, __delfield_modified2, None)
2829
2830 def __getfield_zero5(self):
2831 try: self.__field_zero5
2832 except:
2833 self.__field_zero5=UNKNOWN(**{'sizeinbytes': 8, 'pad': 0 })
2834 return self.__field_zero5.getvalue()
2835
2836 def __setfield_zero5(self, value):
2837 if isinstance(value,UNKNOWN):
2838 self.__field_zero5=value
2839 else:
2840 self.__field_zero5=UNKNOWN(value,**{'sizeinbytes': 8, 'pad': 0 })
2841
2842 def __delfield_zero5(self): del self.__field_zero5
2843
2844 zero5=property(__getfield_zero5, __setfield_zero5, __delfield_zero5, None)
2845
2846 def iscontainer(self):
2847 return True
2848
2849 def containerelements(self):
2850 yield ('textlen', self.__field_textlen, None)
2851 yield ('text', self.__field_text, None)
2852 yield ('creation', self.__field_creation, None)
2853 yield ('zero1', self.__field_zero1, None)
2854 yield ('creation2', self.__field_creation2, None)
2855 yield ('zero2', self.__field_zero2, None)
2856 yield ('five', self.__field_five, None)
2857 yield ('zero3', self.__field_zero3, None)
2858 yield ('modified', self.__field_modified, None)
2859 yield ('zero4', self.__field_zero4, None)
2860 yield ('modified2', self.__field_modified2, None)
2861 yield ('zero5', self.__field_zero5, None)
2862
2863
2864
2865
2866 class JournalNumber(BaseProtogenClass):
2867 __fields=['index', 'bitmap']
2868
2869 def __init__(self, *args, **kwargs):
2870 dict={}
2871 dict.update(kwargs)
2873 super(JournalNumber,self).__init__(**dict)
2875 if self.__class__ is JournalNumber:
2876 self._update(args,dict)
2877
2878
2879 def getfields(self):
2880 return self.__fields
2881
2882
2883 def _update(self, args, kwargs):
2884 super(JournalNumber,self)._update(args,kwargs)
2885 keys=kwargs.keys()
2886 for key in keys:
2887 if key in self.__fields:
2888 setattr(self, key, kwargs[key])
2889 del kwargs[key]
2890 if __debug__:
2892 self._complainaboutunusedargs(JournalNumber,kwargs)
2893 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2894
2896
2897 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2898 'Writes this packet to the supplied buffer'
2899 self._bufferstartoffset=buf.getcurrentoffset()
2900 self.__field_index.writetobuffer(buf)
2901 self.__field_bitmap.writetobuffer(buf)
2902 self._bufferendoffset=buf.getcurrentoffset()
2903 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2904
2905
2906 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2907 'Reads this packet from the supplied buffer'
2908 self._bufferstartoffset=buf.getcurrentoffset()
2909 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2910 self.__field_index=UINT(**{'sizeinbytes': 2})
2911 self.__field_index.readfrombuffer(buf)
2912 self.__field_bitmap=UINT(**{'sizeinbytes': 2})
2913 self.__field_bitmap.readfrombuffer(buf)
2914 self._bufferendoffset=buf.getcurrentoffset()
2915
2916
2917 def __getfield_index(self):
2918 return self.__field_index.getvalue()
2919
2920 def __setfield_index(self, value):
2921 if isinstance(value,UINT):
2922 self.__field_index=value
2923 else:
2924 self.__field_index=UINT(value,**{'sizeinbytes': 2})
2925
2926 def __delfield_index(self): del self.__field_index
2927
2928 index=property(__getfield_index, __setfield_index, __delfield_index, None)
2929
2930 def __getfield_bitmap(self):
2931 return self.__field_bitmap.getvalue()
2932
2933 def __setfield_bitmap(self, value):
2934 if isinstance(value,UINT):
2935 self.__field_bitmap=value
2936 else:
2937 self.__field_bitmap=UINT(value,**{'sizeinbytes': 2})
2938
2939 def __delfield_bitmap(self): del self.__field_bitmap
2940
2941 bitmap=property(__getfield_bitmap, __setfield_bitmap, __delfield_bitmap, None)
2942
2943 def iscontainer(self):
2944 return True
2945
2946 def containerelements(self):
2947 yield ('index', self.__field_index, None)
2948 yield ('bitmap', self.__field_bitmap, None)
2949
2950
2951
2952
2953 class JournalSpeeddial(BaseProtogenClass):
2954 __fields=['index', 'speeddial', 'bitmap']
2955
2956 def __init__(self, *args, **kwargs):
2957 dict={}
2958 dict.update(kwargs)
2960 super(JournalSpeeddial,self).__init__(**dict)
2962 if self.__class__ is JournalSpeeddial:
2963 self._update(args,dict)
2964
2965
2966 def getfields(self):
2967 return self.__fields
2968
2969
2970 def _update(self, args, kwargs):
2971 super(JournalSpeeddial,self)._update(args,kwargs)
2972 keys=kwargs.keys()
2973 for key in keys:
2974 if key in self.__fields:
2975 setattr(self, key, kwargs[key])
2976 del kwargs[key]
2977 if __debug__:
2979 self._complainaboutunusedargs(JournalSpeeddial,kwargs)
2980 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2981
2983
2984 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2985 'Writes this packet to the supplied buffer'
2986 self._bufferstartoffset=buf.getcurrentoffset()
2987 self.__field_index.writetobuffer(buf)
2988 self.__field_speeddial.writetobuffer(buf)
2989 self.__field_bitmap.writetobuffer(buf)
2990 self._bufferendoffset=buf.getcurrentoffset()
2991 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2992
2993
2994 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2995 'Reads this packet from the supplied buffer'
2996 self._bufferstartoffset=buf.getcurrentoffset()
2997 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2998 self.__field_index=UINT(**{'sizeinbytes': 2})
2999 self.__field_index.readfrombuffer(buf)
3000 self.__field_speeddial=UINT(**{'sizeinbytes': 2})
3001