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 from p_samsungscha950 import *
0009
0010 RT_PATH='brew/mod/mr'
0011 RT_INDEX_FILE_NAME=RT_PATH+'/MrInfo.db'
0012 RT_EXCLUDED_FILES=('MrInfo.db',)
0013
0014 SND_PATH='brew/mod/18067'
0015 SND_INDEX_FILE_NAME=SND_PATH+'/MsInfo.db'
0016 SND_EXCLUDED_FILES=('MsInfo.db', 'ExInfo.db')
0017
0018 PIC_PATH='brew/mod/10888'
0019 PIC_INDEX_FILE_NAME=PIC_PATH+'/Default Album.alb'
0020 PIC_EXCLUDED_FILES=('Default Album.alb',)
0021 PIC_TYPE_HEADER=0
0022 PIC_TYPE_BUILTIN=4
0023 PIC_TYPE_USERS=3
0024
0025 VIDEO_PATH='brew/mod/10890'
0026 VIDEO_INDEX_FILE_NAME=VIDEO_PATH+'/Default Album.alb'
0027
0028 PB_FLG_NOTE=0x0200
0029 PB_MAX_NOTE_LEN=64
0030
0031 CL_MAX_ENTRIES=90
0032 CL_TYPE_INCOMING=2
0033 CL_TYPE_OUTGOING=1
0034 CL_TYPE_MISSED=3
0035 CL_TYPE_DELETED=5
0036 CL_VALID_TYPE=frozenset((CL_TYPE_INCOMING, CL_TYPE_OUTGOING, CL_TYPE_MISSED))
0037
0038 class WRingtoneIndexEntry(BaseProtogenClass):
0039 __fields=['name', 'path_prefix', 'pathname', 'eor']
0040
0041 def __init__(self, *args, **kwargs):
0042 dict={}
0043 dict.update(kwargs)
0045 super(WRingtoneIndexEntry,self).__init__(**dict)
0047 if self.__class__ is WRingtoneIndexEntry:
0048 self._update(args,dict)
0049
0050
0051 def getfields(self):
0052 return self.__fields
0053
0054
0055 def _update(self, args, kwargs):
0056 super(WRingtoneIndexEntry,self)._update(args,kwargs)
0057 keys=kwargs.keys()
0058 for key in keys:
0059 if key in self.__fields:
0060 setattr(self, key, kwargs[key])
0061 del kwargs[key]
0062 if __debug__:
0064 self._complainaboutunusedargs(WRingtoneIndexEntry,kwargs)
0065 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0066 try: self.__field_name
0068 except:
0069 self.__field_name=STRING()
0070
0071
0072 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0073 'Writes this packet to the supplied buffer'
0074 self._bufferstartoffset=buf.getcurrentoffset()
0075 try: self.__field_path_prefix
0076 except:
0077 self.__field_path_prefix=STRING(**{ 'terminator': None, 'default': '/ff/' })
0078 self.__field_path_prefix.writetobuffer(buf)
0079 self.__field_pathname.writetobuffer(buf)
0080 try: self.__field_eor
0081 except:
0082 self.__field_eor=STRING(**{ 'terminator': None, 'default': '|0|3\x0A' })
0083 self.__field_eor.writetobuffer(buf)
0084 self._bufferendoffset=buf.getcurrentoffset()
0085 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0086
0087
0088 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0089 'Reads this packet from the supplied buffer'
0090 self._bufferstartoffset=buf.getcurrentoffset()
0091 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0092 self.__field_path_prefix=STRING(**{ 'terminator': None, 'default': '/ff/' })
0093 self.__field_path_prefix.readfrombuffer(buf)
0094 self.__field_pathname=STRING(**{ 'terminator': None })
0095 self.__field_pathname.readfrombuffer(buf)
0096 self.__field_eor=STRING(**{ 'terminator': None, 'default': '|0|3\x0A' })
0097 self.__field_eor.readfrombuffer(buf)
0098 self._bufferendoffset=buf.getcurrentoffset()
0099
0100
0101 def __getfield_name(self):
0102 return self.__field_name.getvalue()
0103
0104 def __setfield_name(self, value):
0105 if isinstance(value,STRING):
0106 self.__field_name=value
0107 else:
0108 self.__field_name=STRING(value,)
0109
0110 def __delfield_name(self): del self.__field_name
0111
0112 name=property(__getfield_name, __setfield_name, __delfield_name, None)
0113
0114 def __getfield_path_prefix(self):
0115 try: self.__field_path_prefix
0116 except:
0117 self.__field_path_prefix=STRING(**{ 'terminator': None, 'default': '/ff/' })
0118 return self.__field_path_prefix.getvalue()
0119
0120 def __setfield_path_prefix(self, value):
0121 if isinstance(value,STRING):
0122 self.__field_path_prefix=value
0123 else:
0124 self.__field_path_prefix=STRING(value,**{ 'terminator': None, 'default': '/ff/' })
0125
0126 def __delfield_path_prefix(self): del self.__field_path_prefix
0127
0128 path_prefix=property(__getfield_path_prefix, __setfield_path_prefix, __delfield_path_prefix, None)
0129
0130 def __getfield_pathname(self):
0131 return self.__field_pathname.getvalue()
0132
0133 def __setfield_pathname(self, value):
0134 if isinstance(value,STRING):
0135 self.__field_pathname=value
0136 else:
0137 self.__field_pathname=STRING(value,**{ 'terminator': None })
0138
0139 def __delfield_pathname(self): del self.__field_pathname
0140
0141 pathname=property(__getfield_pathname, __setfield_pathname, __delfield_pathname, None)
0142
0143 def __getfield_eor(self):
0144 try: self.__field_eor
0145 except:
0146 self.__field_eor=STRING(**{ 'terminator': None, 'default': '|0|3\x0A' })
0147 return self.__field_eor.getvalue()
0148
0149 def __setfield_eor(self, value):
0150 if isinstance(value,STRING):
0151 self.__field_eor=value
0152 else:
0153 self.__field_eor=STRING(value,**{ 'terminator': None, 'default': '|0|3\x0A' })
0154
0155 def __delfield_eor(self): del self.__field_eor
0156
0157 eor=property(__getfield_eor, __setfield_eor, __delfield_eor, None)
0158
0159 def iscontainer(self):
0160 return True
0161
0162 def containerelements(self):
0163 yield ('name', self.__field_name, None)
0164 yield ('path_prefix', self.__field_path_prefix, None)
0165 yield ('pathname', self.__field_pathname, None)
0166 yield ('eor', self.__field_eor, None)
0167
0168
0169
0170
0171 class WRingtoneIndexFile(BaseProtogenClass):
0172 __fields=['items']
0173
0174 def __init__(self, *args, **kwargs):
0175 dict={}
0176 dict.update(kwargs)
0178 super(WRingtoneIndexFile,self).__init__(**dict)
0180 if self.__class__ is WRingtoneIndexFile:
0181 self._update(args,dict)
0182
0183
0184 def getfields(self):
0185 return self.__fields
0186
0187
0188 def _update(self, args, kwargs):
0189 super(WRingtoneIndexFile,self)._update(args,kwargs)
0190 keys=kwargs.keys()
0191 for key in keys:
0192 if key in self.__fields:
0193 setattr(self, key, kwargs[key])
0194 del kwargs[key]
0195 if __debug__:
0197 self._complainaboutunusedargs(WRingtoneIndexFile,kwargs)
0198 if len(args):
0199 dict2={ 'elementclass': WRingtoneIndexEntry }
0200 dict2.update(kwargs)
0201 kwargs=dict2
0202 self.__field_items=LIST(*args,**dict2)
0203
0205
0206 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0207 'Writes this packet to the supplied buffer'
0208 self._bufferstartoffset=buf.getcurrentoffset()
0209 try: self.__field_items
0210 except:
0211 self.__field_items=LIST(**{ 'elementclass': WRingtoneIndexEntry })
0212 self.__field_items.writetobuffer(buf)
0213 self._bufferendoffset=buf.getcurrentoffset()
0214 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0215
0216
0217 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0218 'Reads this packet from the supplied buffer'
0219 self._bufferstartoffset=buf.getcurrentoffset()
0220 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0221 self.__field_items=LIST(**{ 'elementclass': WRingtoneIndexEntry })
0222 self.__field_items.readfrombuffer(buf)
0223 self._bufferendoffset=buf.getcurrentoffset()
0224
0225
0226 def __getfield_items(self):
0227 try: self.__field_items
0228 except:
0229 self.__field_items=LIST(**{ 'elementclass': WRingtoneIndexEntry })
0230 return self.__field_items.getvalue()
0231
0232 def __setfield_items(self, value):
0233 if isinstance(value,LIST):
0234 self.__field_items=value
0235 else:
0236 self.__field_items=LIST(value,**{ 'elementclass': WRingtoneIndexEntry })
0237
0238 def __delfield_items(self): del self.__field_items
0239
0240 items=property(__getfield_items, __setfield_items, __delfield_items, None)
0241
0242 def iscontainer(self):
0243 return True
0244
0245 def containerelements(self):
0246 yield ('items', self.__field_items, None)
0247
0248
0249
0250
0251 class RRingtoneIndexEntry(BaseProtogenClass):
0252 __fields=['pathname', 'misc']
0253
0254 def __init__(self, *args, **kwargs):
0255 dict={}
0256 dict.update(kwargs)
0258 super(RRingtoneIndexEntry,self).__init__(**dict)
0260 if self.__class__ is RRingtoneIndexEntry:
0261 self._update(args,dict)
0262
0263
0264 def getfields(self):
0265 return self.__fields
0266
0267
0268 def _update(self, args, kwargs):
0269 super(RRingtoneIndexEntry,self)._update(args,kwargs)
0270 keys=kwargs.keys()
0271 for key in keys:
0272 if key in self.__fields:
0273 setattr(self, key, kwargs[key])
0274 del kwargs[key]
0275 if __debug__:
0277 self._complainaboutunusedargs(RRingtoneIndexEntry,kwargs)
0278 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0279
0281
0282 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0283 'Writes this packet to the supplied buffer'
0284 self._bufferstartoffset=buf.getcurrentoffset()
0285 self.__field_pathname.writetobuffer(buf)
0286 self.__field_misc.writetobuffer(buf)
0287 self._bufferendoffset=buf.getcurrentoffset()
0288 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0289
0290
0291 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0292 'Reads this packet from the supplied buffer'
0293 self._bufferstartoffset=buf.getcurrentoffset()
0294 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0295 self.__field_pathname=STRING(**{ 'terminator': 0x7C })
0296 self.__field_pathname.readfrombuffer(buf)
0297 self.__field_misc=STRING(**{ 'terminator': 0x0A })
0298 self.__field_misc.readfrombuffer(buf)
0299 self._bufferendoffset=buf.getcurrentoffset()
0300
0301
0302 def __getfield_pathname(self):
0303 return self.__field_pathname.getvalue()
0304
0305 def __setfield_pathname(self, value):
0306 if isinstance(value,STRING):
0307 self.__field_pathname=value
0308 else:
0309 self.__field_pathname=STRING(value,**{ 'terminator': 0x7C })
0310
0311 def __delfield_pathname(self): del self.__field_pathname
0312
0313 pathname=property(__getfield_pathname, __setfield_pathname, __delfield_pathname, None)
0314
0315 def __getfield_misc(self):
0316 return self.__field_misc.getvalue()
0317
0318 def __setfield_misc(self, value):
0319 if isinstance(value,STRING):
0320 self.__field_misc=value
0321 else:
0322 self.__field_misc=STRING(value,**{ 'terminator': 0x0A })
0323
0324 def __delfield_misc(self): del self.__field_misc
0325
0326 misc=property(__getfield_misc, __setfield_misc, __delfield_misc, None)
0327
0328 def iscontainer(self):
0329 return True
0330
0331 def containerelements(self):
0332 yield ('pathname', self.__field_pathname, None)
0333 yield ('misc', self.__field_misc, None)
0334
0335
0336
0337
0338 class RRingtoneIndexFile(BaseProtogenClass):
0339 __fields=['items']
0340
0341 def __init__(self, *args, **kwargs):
0342 dict={}
0343 dict.update(kwargs)
0345 super(RRingtoneIndexFile,self).__init__(**dict)
0347 if self.__class__ is RRingtoneIndexFile:
0348 self._update(args,dict)
0349
0350
0351 def getfields(self):
0352 return self.__fields
0353
0354
0355 def _update(self, args, kwargs):
0356 super(RRingtoneIndexFile,self)._update(args,kwargs)
0357 keys=kwargs.keys()
0358 for key in keys:
0359 if key in self.__fields:
0360 setattr(self, key, kwargs[key])
0361 del kwargs[key]
0362 if __debug__:
0364 self._complainaboutunusedargs(RRingtoneIndexFile,kwargs)
0365 if len(args):
0366 dict2={ 'elementclass': RRingtoneIndexEntry }
0367 dict2.update(kwargs)
0368 kwargs=dict2
0369 self.__field_items=LIST(*args,**dict2)
0370
0372
0373 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0374 'Writes this packet to the supplied buffer'
0375 self._bufferstartoffset=buf.getcurrentoffset()
0376 try: self.__field_items
0377 except:
0378 self.__field_items=LIST(**{ 'elementclass': RRingtoneIndexEntry })
0379 self.__field_items.writetobuffer(buf)
0380 self._bufferendoffset=buf.getcurrentoffset()
0381 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0382
0383
0384 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0385 'Reads this packet from the supplied buffer'
0386 self._bufferstartoffset=buf.getcurrentoffset()
0387 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0388 self.__field_items=LIST(**{ 'elementclass': RRingtoneIndexEntry })
0389 self.__field_items.readfrombuffer(buf)
0390 self._bufferendoffset=buf.getcurrentoffset()
0391
0392
0393 def __getfield_items(self):
0394 try: self.__field_items
0395 except:
0396 self.__field_items=LIST(**{ 'elementclass': RRingtoneIndexEntry })
0397 return self.__field_items.getvalue()
0398
0399 def __setfield_items(self, value):
0400 if isinstance(value,LIST):
0401 self.__field_items=value
0402 else:
0403 self.__field_items=LIST(value,**{ 'elementclass': RRingtoneIndexEntry })
0404
0405 def __delfield_items(self): del self.__field_items
0406
0407 items=property(__getfield_items, __setfield_items, __delfield_items, None)
0408
0409 def iscontainer(self):
0410 return True
0411
0412 def containerelements(self):
0413 yield ('items', self.__field_items, None)
0414
0415
0416
0417
0418 class WSoundsIndexEntry(BaseProtogenClass):
0419 __fields=['name', 'path_prefix', 'pathname', 'eor']
0420
0421 def __init__(self, *args, **kwargs):
0422 dict={}
0423 dict.update(kwargs)
0425 super(WSoundsIndexEntry,self).__init__(**dict)
0427 if self.__class__ is WSoundsIndexEntry:
0428 self._update(args,dict)
0429
0430
0431 def getfields(self):
0432 return self.__fields
0433
0434
0435 def _update(self, args, kwargs):
0436 super(WSoundsIndexEntry,self)._update(args,kwargs)
0437 keys=kwargs.keys()
0438 for key in keys:
0439 if key in self.__fields:
0440 setattr(self, key, kwargs[key])
0441 del kwargs[key]
0442 if __debug__:
0444 self._complainaboutunusedargs(WSoundsIndexEntry,kwargs)
0445 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0446 try: self.__field_name
0448 except:
0449 self.__field_name=STRING()
0450
0451
0452 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0453 'Writes this packet to the supplied buffer'
0454 self._bufferstartoffset=buf.getcurrentoffset()
0455 try: self.__field_path_prefix
0456 except:
0457 self.__field_path_prefix=STRING(**{ 'terminator': None, 'default': '/ff/' })
0458 self.__field_path_prefix.writetobuffer(buf)
0459 self.__field_pathname.writetobuffer(buf)
0460 try: self.__field_eor
0461 except:
0462 self.__field_eor=STRING(**{ 'terminator': None, 'default': '|0|7\x0A' })
0463 self.__field_eor.writetobuffer(buf)
0464 self._bufferendoffset=buf.getcurrentoffset()
0465 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0466
0467
0468 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0469 'Reads this packet from the supplied buffer'
0470 self._bufferstartoffset=buf.getcurrentoffset()
0471 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0472 self.__field_path_prefix=STRING(**{ 'terminator': None, 'default': '/ff/' })
0473 self.__field_path_prefix.readfrombuffer(buf)
0474 self.__field_pathname=STRING(**{ 'terminator': None })
0475 self.__field_pathname.readfrombuffer(buf)
0476 self.__field_eor=STRING(**{ 'terminator': None, 'default': '|0|7\x0A' })
0477 self.__field_eor.readfrombuffer(buf)
0478 self._bufferendoffset=buf.getcurrentoffset()
0479
0480
0481 def __getfield_name(self):
0482 return self.__field_name.getvalue()
0483
0484 def __setfield_name(self, value):
0485 if isinstance(value,STRING):
0486 self.__field_name=value
0487 else:
0488 self.__field_name=STRING(value,)
0489
0490 def __delfield_name(self): del self.__field_name
0491
0492 name=property(__getfield_name, __setfield_name, __delfield_name, None)
0493
0494 def __getfield_path_prefix(self):
0495 try: self.__field_path_prefix
0496 except:
0497 self.__field_path_prefix=STRING(**{ 'terminator': None, 'default': '/ff/' })
0498 return self.__field_path_prefix.getvalue()
0499
0500 def __setfield_path_prefix(self, value):
0501 if isinstance(value,STRING):
0502 self.__field_path_prefix=value
0503 else:
0504 self.__field_path_prefix=STRING(value,**{ 'terminator': None, 'default': '/ff/' })
0505
0506 def __delfield_path_prefix(self): del self.__field_path_prefix
0507
0508 path_prefix=property(__getfield_path_prefix, __setfield_path_prefix, __delfield_path_prefix, None)
0509
0510 def __getfield_pathname(self):
0511 return self.__field_pathname.getvalue()
0512
0513 def __setfield_pathname(self, value):
0514 if isinstance(value,STRING):
0515 self.__field_pathname=value
0516 else:
0517 self.__field_pathname=STRING(value,**{ 'terminator': None })
0518
0519 def __delfield_pathname(self): del self.__field_pathname
0520
0521 pathname=property(__getfield_pathname, __setfield_pathname, __delfield_pathname, None)
0522
0523 def __getfield_eor(self):
0524 try: self.__field_eor
0525 except:
0526 self.__field_eor=STRING(**{ 'terminator': None, 'default': '|0|7\x0A' })
0527 return self.__field_eor.getvalue()
0528
0529 def __setfield_eor(self, value):
0530 if isinstance(value,STRING):
0531 self.__field_eor=value
0532 else:
0533 self.__field_eor=STRING(value,**{ 'terminator': None, 'default': '|0|7\x0A' })
0534
0535 def __delfield_eor(self): del self.__field_eor
0536
0537 eor=property(__getfield_eor, __setfield_eor, __delfield_eor, None)
0538
0539 def iscontainer(self):
0540 return True
0541
0542 def containerelements(self):
0543 yield ('name', self.__field_name, None)
0544 yield ('path_prefix', self.__field_path_prefix, None)
0545 yield ('pathname', self.__field_pathname, None)
0546 yield ('eor', self.__field_eor, None)
0547
0548
0549
0550
0551 class WSoundsIndexFile(BaseProtogenClass):
0552 __fields=['items']
0553
0554 def __init__(self, *args, **kwargs):
0555 dict={}
0556 dict.update(kwargs)
0558 super(WSoundsIndexFile,self).__init__(**dict)
0560 if self.__class__ is WSoundsIndexFile:
0561 self._update(args,dict)
0562
0563
0564 def getfields(self):
0565 return self.__fields
0566
0567
0568 def _update(self, args, kwargs):
0569 super(WSoundsIndexFile,self)._update(args,kwargs)
0570 keys=kwargs.keys()
0571 for key in keys:
0572 if key in self.__fields:
0573 setattr(self, key, kwargs[key])
0574 del kwargs[key]
0575 if __debug__:
0577 self._complainaboutunusedargs(WSoundsIndexFile,kwargs)
0578 if len(args):
0579 dict2={ 'elementclass': WSoundsIndexEntry }
0580 dict2.update(kwargs)
0581 kwargs=dict2
0582 self.__field_items=LIST(*args,**dict2)
0583
0585
0586 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0587 'Writes this packet to the supplied buffer'
0588 self._bufferstartoffset=buf.getcurrentoffset()
0589 try: self.__field_items
0590 except:
0591 self.__field_items=LIST(**{ 'elementclass': WSoundsIndexEntry })
0592 self.__field_items.writetobuffer(buf)
0593 self._bufferendoffset=buf.getcurrentoffset()
0594 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0595
0596
0597 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0598 'Reads this packet from the supplied buffer'
0599 self._bufferstartoffset=buf.getcurrentoffset()
0600 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0601 self.__field_items=LIST(**{ 'elementclass': WSoundsIndexEntry })
0602 self.__field_items.readfrombuffer(buf)
0603 self._bufferendoffset=buf.getcurrentoffset()
0604
0605
0606 def __getfield_items(self):
0607 try: self.__field_items
0608 except:
0609 self.__field_items=LIST(**{ 'elementclass': WSoundsIndexEntry })
0610 return self.__field_items.getvalue()
0611
0612 def __setfield_items(self, value):
0613 if isinstance(value,LIST):
0614 self.__field_items=value
0615 else:
0616 self.__field_items=LIST(value,**{ 'elementclass': WSoundsIndexEntry })
0617
0618 def __delfield_items(self): del self.__field_items
0619
0620 items=property(__getfield_items, __setfield_items, __delfield_items, None)
0621
0622 def iscontainer(self):
0623 return True
0624
0625 def containerelements(self):
0626 yield ('items', self.__field_items, None)
0627
0628
0629
0630
0631 class RSoundIndexEntry(BaseProtogenClass):
0632 __fields=['pathname', 'misc']
0633
0634 def __init__(self, *args, **kwargs):
0635 dict={}
0636 dict.update(kwargs)
0638 super(RSoundIndexEntry,self).__init__(**dict)
0640 if self.__class__ is RSoundIndexEntry:
0641 self._update(args,dict)
0642
0643
0644 def getfields(self):
0645 return self.__fields
0646
0647
0648 def _update(self, args, kwargs):
0649 super(RSoundIndexEntry,self)._update(args,kwargs)
0650 keys=kwargs.keys()
0651 for key in keys:
0652 if key in self.__fields:
0653 setattr(self, key, kwargs[key])
0654 del kwargs[key]
0655 if __debug__:
0657 self._complainaboutunusedargs(RSoundIndexEntry,kwargs)
0658 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0659
0661
0662 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0663 'Writes this packet to the supplied buffer'
0664 self._bufferstartoffset=buf.getcurrentoffset()
0665 self.__field_pathname.writetobuffer(buf)
0666 self.__field_misc.writetobuffer(buf)
0667 self._bufferendoffset=buf.getcurrentoffset()
0668 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0669
0670
0671 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0672 'Reads this packet from the supplied buffer'
0673 self._bufferstartoffset=buf.getcurrentoffset()
0674 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0675 self.__field_pathname=STRING(**{ 'terminator': 0x7C })
0676 self.__field_pathname.readfrombuffer(buf)
0677 self.__field_misc=STRING(**{ 'terminator': 0x0A })
0678 self.__field_misc.readfrombuffer(buf)
0679 self._bufferendoffset=buf.getcurrentoffset()
0680
0681
0682 def __getfield_pathname(self):
0683 return self.__field_pathname.getvalue()
0684
0685 def __setfield_pathname(self, value):
0686 if isinstance(value,STRING):
0687 self.__field_pathname=value
0688 else:
0689 self.__field_pathname=STRING(value,**{ 'terminator': 0x7C })
0690
0691 def __delfield_pathname(self): del self.__field_pathname
0692
0693 pathname=property(__getfield_pathname, __setfield_pathname, __delfield_pathname, None)
0694
0695 def __getfield_misc(self):
0696 return self.__field_misc.getvalue()
0697
0698 def __setfield_misc(self, value):
0699 if isinstance(value,STRING):
0700 self.__field_misc=value
0701 else:
0702 self.__field_misc=STRING(value,**{ 'terminator': 0x0A })
0703
0704 def __delfield_misc(self): del self.__field_misc
0705
0706 misc=property(__getfield_misc, __setfield_misc, __delfield_misc, None)
0707
0708 def iscontainer(self):
0709 return True
0710
0711 def containerelements(self):
0712 yield ('pathname', self.__field_pathname, None)
0713 yield ('misc', self.__field_misc, None)
0714
0715
0716
0717
0718 class RSoundsIndexFile(BaseProtogenClass):
0719 __fields=['items']
0720
0721 def __init__(self, *args, **kwargs):
0722 dict={}
0723 dict.update(kwargs)
0725 super(RSoundsIndexFile,self).__init__(**dict)
0727 if self.__class__ is RSoundsIndexFile:
0728 self._update(args,dict)
0729
0730
0731 def getfields(self):
0732 return self.__fields
0733
0734
0735 def _update(self, args, kwargs):
0736 super(RSoundsIndexFile,self)._update(args,kwargs)
0737 keys=kwargs.keys()
0738 for key in keys:
0739 if key in self.__fields:
0740 setattr(self, key, kwargs[key])
0741 del kwargs[key]
0742 if __debug__:
0744 self._complainaboutunusedargs(RSoundsIndexFile,kwargs)
0745 if len(args):
0746 dict2={ 'elementclass': RSoundIndexEntry }
0747 dict2.update(kwargs)
0748 kwargs=dict2
0749 self.__field_items=LIST(*args,**dict2)
0750
0752
0753 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0754 'Writes this packet to the supplied buffer'
0755 self._bufferstartoffset=buf.getcurrentoffset()
0756 try: self.__field_items
0757 except:
0758 self.__field_items=LIST(**{ 'elementclass': RSoundIndexEntry })
0759 self.__field_items.writetobuffer(buf)
0760 self._bufferendoffset=buf.getcurrentoffset()
0761 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0762
0763
0764 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0765 'Reads this packet from the supplied buffer'
0766 self._bufferstartoffset=buf.getcurrentoffset()
0767 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0768 self.__field_items=LIST(**{ 'elementclass': RSoundIndexEntry })
0769 self.__field_items.readfrombuffer(buf)
0770 self._bufferendoffset=buf.getcurrentoffset()
0771
0772
0773 def __getfield_items(self):
0774 try: self.__field_items
0775 except:
0776 self.__field_items=LIST(**{ 'elementclass': RSoundIndexEntry })
0777 return self.__field_items.getvalue()
0778
0779 def __setfield_items(self, value):
0780 if isinstance(value,LIST):
0781 self.__field_items=value
0782 else:
0783 self.__field_items=LIST(value,**{ 'elementclass': RSoundIndexEntry })
0784
0785 def __delfield_items(self): del self.__field_items
0786
0787 items=property(__getfield_items, __setfield_items, __delfield_items, None)
0788
0789 def iscontainer(self):
0790 return True
0791
0792 def containerelements(self):
0793 yield ('items', self.__field_items, None)
0794
0795
0796
0797
0798 class WPictureIndexEntry(BaseProtogenClass):
0799 __fields=['path_prefix', 'pathname', 'path_name', 'pictype']
0800
0801 def __init__(self, *args, **kwargs):
0802 dict={}
0803 dict.update(kwargs)
0805 super(WPictureIndexEntry,self).__init__(**dict)
0807 if self.__class__ is WPictureIndexEntry:
0808 self._update(args,dict)
0809
0810
0811 def getfields(self):
0812 return self.__fields
0813
0814
0815 def _update(self, args, kwargs):
0816 super(WPictureIndexEntry,self)._update(args,kwargs)
0817 keys=kwargs.keys()
0818 for key in keys:
0819 if key in self.__fields:
0820 setattr(self, key, kwargs[key])
0821 del kwargs[key]
0822 if __debug__:
0824 self._complainaboutunusedargs(WPictureIndexEntry,kwargs)
0825 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0826 try: self.__field_path_prefix
0828 except:
0829 self.__field_path_prefix=STRING(**{ 'default': '/ff/' })
0830 try: self.__field_pathname
0831 except:
0832 self.__field_pathname=STRING(**{ 'terminator': None })
0833
0834
0835 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0836 'Writes this packet to the supplied buffer'
0837 self._bufferstartoffset=buf.getcurrentoffset()
0838 try: self.__field_path_name
0839 except:
0840 self.__field_path_name=STRING(**{'sizeinbytes': 258, 'terminator': 0, 'default': self.path_prefix+self.pathname })
0841 self.__field_path_name.writetobuffer(buf)
0842 try: self.__field_pictype
0843 except:
0844 self.__field_pictype=UINT(**{'sizeinbytes': 2, 'default': PIC_TYPE_USERS })
0845 self.__field_pictype.writetobuffer(buf)
0846 self._bufferendoffset=buf.getcurrentoffset()
0847 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0848
0849
0850 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0851 'Reads this packet from the supplied buffer'
0852 self._bufferstartoffset=buf.getcurrentoffset()
0853 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0854 self.__field_path_name=STRING(**{'sizeinbytes': 258, 'terminator': 0, 'default': self.path_prefix+self.pathname })
0855 self.__field_path_name.readfrombuffer(buf)
0856 self.__field_pictype=UINT(**{'sizeinbytes': 2, 'default': PIC_TYPE_USERS })
0857 self.__field_pictype.readfrombuffer(buf)
0858 self._bufferendoffset=buf.getcurrentoffset()
0859
0860
0861 def __getfield_path_prefix(self):
0862 try: self.__field_path_prefix
0863 except:
0864 self.__field_path_prefix=STRING(**{ 'default': '/ff/' })
0865 return self.__field_path_prefix.getvalue()
0866
0867 def __setfield_path_prefix(self, value):
0868 if isinstance(value,STRING):
0869 self.__field_path_prefix=value
0870 else:
0871 self.__field_path_prefix=STRING(value,**{ 'default': '/ff/' })
0872
0873 def __delfield_path_prefix(self): del self.__field_path_prefix
0874
0875 path_prefix=property(__getfield_path_prefix, __setfield_path_prefix, __delfield_path_prefix, None)
0876
0877 def __getfield_pathname(self):
0878 return self.__field_pathname.getvalue()
0879
0880 def __setfield_pathname(self, value):
0881 if isinstance(value,STRING):
0882 self.__field_pathname=value
0883 else:
0884 self.__field_pathname=STRING(value,**{ 'terminator': None })
0885
0886 def __delfield_pathname(self): del self.__field_pathname
0887
0888 pathname=property(__getfield_pathname, __setfield_pathname, __delfield_pathname, None)
0889
0890 def __getfield_path_name(self):
0891 try: self.__field_path_name
0892 except:
0893 self.__field_path_name=STRING(**{'sizeinbytes': 258, 'terminator': 0, 'default': self.path_prefix+self.pathname })
0894 return self.__field_path_name.getvalue()
0895
0896 def __setfield_path_name(self, value):
0897 if isinstance(value,STRING):
0898 self.__field_path_name=value
0899 else:
0900 self.__field_path_name=STRING(value,**{'sizeinbytes': 258, 'terminator': 0, 'default': self.path_prefix+self.pathname })
0901
0902 def __delfield_path_name(self): del self.__field_path_name
0903
0904 path_name=property(__getfield_path_name, __setfield_path_name, __delfield_path_name, None)
0905
0906 def __getfield_pictype(self):
0907 try: self.__field_pictype
0908 except:
0909 self.__field_pictype=UINT(**{'sizeinbytes': 2, 'default': PIC_TYPE_USERS })
0910 return self.__field_pictype.getvalue()
0911
0912 def __setfield_pictype(self, value):
0913 if isinstance(value,UINT):
0914 self.__field_pictype=value
0915 else:
0916 self.__field_pictype=UINT(value,**{'sizeinbytes': 2, 'default': PIC_TYPE_USERS })
0917
0918 def __delfield_pictype(self): del self.__field_pictype
0919
0920 pictype=property(__getfield_pictype, __setfield_pictype, __delfield_pictype, "0= invalid, 4=builtin, 3=users")
0921
0922 def iscontainer(self):
0923 return True
0924
0925 def containerelements(self):
0926 yield ('path_prefix', self.__field_path_prefix, None)
0927 yield ('pathname', self.__field_pathname, None)
0928 yield ('path_name', self.__field_path_name, None)
0929 yield ('pictype', self.__field_pictype, "0= invalid, 4=builtin, 3=users")
0930
0931
0932
0933
0934 class WPictureIndexFile(BaseProtogenClass):
0935 __fields=['header', 'preloaded1', 'preloaded2', 'preloaded3', 'preloaded4', 'preloaded5', 'preloaded6', 'preloaded7', 'preloaded8', 'items']
0936
0937 def __init__(self, *args, **kwargs):
0938 dict={}
0939 dict.update(kwargs)
0941 super(WPictureIndexFile,self).__init__(**dict)
0943 if self.__class__ is WPictureIndexFile:
0944 self._update(args,dict)
0945
0946
0947 def getfields(self):
0948 return self.__fields
0949
0950
0951 def _update(self, args, kwargs):
0952 super(WPictureIndexFile,self)._update(args,kwargs)
0953 keys=kwargs.keys()
0954 for key in keys:
0955 if key in self.__fields:
0956 setattr(self, key, kwargs[key])
0957 del kwargs[key]
0958 if __debug__:
0960 self._complainaboutunusedargs(WPictureIndexFile,kwargs)
0961 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0962
0964
0965 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0966 'Writes this packet to the supplied buffer'
0967 self._bufferstartoffset=buf.getcurrentoffset()
0968 try: self.__field_header
0969 except:
0970 self.__field_header=WPictureIndexEntry(**{ 'pathname': '0|/ff/brew/mod/10888/Default Album|\x0A', 'path_prefix': '', 'pictype': PIC_TYPE_HEADER })
0971 self.__field_header.writetobuffer(buf)
0972 try: self.__field_preloaded1
0973 except:
0974 self.__field_preloaded1=WPictureIndexEntry(**{ 'pathname': 'Preloaded1', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN })
0975 self.__field_preloaded1.writetobuffer(buf)
0976 try: self.__field_preloaded2
0977 except:
0978 self.__field_preloaded2=WPictureIndexEntry(**{ 'pathname': 'Preloaded2', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN })
0979 self.__field_preloaded2.writetobuffer(buf)
0980 try: self.__field_preloaded3
0981 except:
0982 self.__field_preloaded3=WPictureIndexEntry(**{ 'pathname': 'Preloaded3', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN })
0983 self.__field_preloaded3.writetobuffer(buf)
0984 try: self.__field_preloaded4
0985 except:
0986 self.__field_preloaded4=WPictureIndexEntry(**{ 'pathname': 'Preloaded4', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN })
0987 self.__field_preloaded4.writetobuffer(buf)
0988 try: self.__field_preloaded5
0989 except:
0990 self.__field_preloaded5=WPictureIndexEntry(**{ 'pathname': 'Preloaded5', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN })
0991 self.__field_preloaded5.writetobuffer(buf)
0992 try: self.__field_preloaded6
0993 except:
0994 self.__field_preloaded6=WPictureIndexEntry(**{ 'pathname': 'Preloaded6', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN })
0995 self.__field_preloaded6.writetobuffer(buf)
0996 try: self.__field_preloaded7
0997 except:
0998 self.__field_preloaded7=WPictureIndexEntry(**{ 'pathname': 'Preloaded7', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN })
0999 self.__field_preloaded7.writetobuffer(buf)
1000 try: self.__field_preloaded8
1001 except:
1002 self.__field_preloaded8=WPictureIndexEntry(**{ 'pathname': 'Preloaded8', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN })
1003 self.__field_preloaded8.writetobuffer(buf)
1004 try: self.__field_items
1005 except:
1006 self.__field_items=LIST(**{ 'elementclass': WPictureIndexEntry })
1007 self.__field_items.writetobuffer(buf)
1008 self._bufferendoffset=buf.getcurrentoffset()
1009 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1010
1011
1012 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1013 'Reads this packet from the supplied buffer'
1014 self._bufferstartoffset=buf.getcurrentoffset()
1015 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1016 self.__field_header=WPictureIndexEntry(**{ 'pathname': '0|/ff/brew/mod/10888/Default Album|\x0A', 'path_prefix': '', 'pictype': PIC_TYPE_HEADER })
1017 self.__field_header.readfrombuffer(buf)
1018 self.__field_preloaded1=WPictureIndexEntry(**{ 'pathname': 'Preloaded1', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN })
1019 self.__field_preloaded1.readfrombuffer(buf)
1020 self.__field_preloaded2=WPictureIndexEntry(**{ 'pathname': 'Preloaded2', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN })
1021 self.__field_preloaded2.readfrombuffer(buf)
1022 self.__field_preloaded3=WPictureIndexEntry(**{ 'pathname': 'Preloaded3', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN })
1023 self.__field_preloaded3.readfrombuffer(buf)
1024 self.__field_preloaded4=WPictureIndexEntry(**{ 'pathname': 'Preloaded4', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN })
1025 self.__field_preloaded4.readfrombuffer(buf)
1026 self.__field_preloaded5=WPictureIndexEntry(**{ 'pathname': 'Preloaded5', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN })
1027 self.__field_preloaded5.readfrombuffer(buf)
1028 self.__field_preloaded6=WPictureIndexEntry(**{ 'pathname': 'Preloaded6', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN })
1029 self.__field_preloaded6.readfrombuffer(buf)
1030 self.__field_preloaded7=WPictureIndexEntry(**{ 'pathname': 'Preloaded7', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN })
1031 self.__field_preloaded7.readfrombuffer(buf)
1032 self.__field_preloaded8=WPictureIndexEntry(**{ 'pathname': 'Preloaded8', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN })
1033 self.__field_preloaded8.readfrombuffer(buf)
1034 self.__field_items=LIST(**{ 'elementclass': WPictureIndexEntry })
1035 self.__field_items.readfrombuffer(buf)
1036 self._bufferendoffset=buf.getcurrentoffset()
1037
1038
1039 def __getfield_header(self):
1040 try: self.__field_header
1041 except:
1042 self.__field_header=WPictureIndexEntry(**{ 'pathname': '0|/ff/brew/mod/10888/Default Album|\x0A', 'path_prefix': '', 'pictype': PIC_TYPE_HEADER })
1043 return self.__field_header.getvalue()
1044
1045 def __setfield_header(self, value):
1046 if isinstance(value,WPictureIndexEntry):
1047 self.__field_header=value
1048 else:
1049 self.__field_header=WPictureIndexEntry(value,**{ 'pathname': '0|/ff/brew/mod/10888/Default Album|\x0A', 'path_prefix': '', 'pictype': PIC_TYPE_HEADER })
1050
1051 def __delfield_header(self): del self.__field_header
1052
1053 header=property(__getfield_header, __setfield_header, __delfield_header, None)
1054
1055 def __getfield_preloaded1(self):
1056 try: self.__field_preloaded1
1057 except:
1058 self.__field_preloaded1=WPictureIndexEntry(**{ 'pathname': 'Preloaded1', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN })
1059 return self.__field_preloaded1.getvalue()
1060
1061 def __setfield_preloaded1(self, value):
1062 if isinstance(value,WPictureIndexEntry):
1063 self.__field_preloaded1=value
1064 else:
1065 self.__field_preloaded1=WPictureIndexEntry(value,**{ 'pathname': 'Preloaded1', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN })
1066
1067 def __delfield_preloaded1(self): del self.__field_preloaded1
1068
1069 preloaded1=property(__getfield_preloaded1, __setfield_preloaded1, __delfield_preloaded1, None)
1070
1071 def __getfield_preloaded2(self):
1072 try: self.__field_preloaded2
1073 except:
1074 self.__field_preloaded2=WPictureIndexEntry(**{ 'pathname': 'Preloaded2', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN })
1075 return self.__field_preloaded2.getvalue()
1076
1077 def __setfield_preloaded2(self, value):
1078 if isinstance(value,WPictureIndexEntry):
1079 self.__field_preloaded2=value
1080 else:
1081 self.__field_preloaded2=WPictureIndexEntry(value,**{ 'pathname': 'Preloaded2', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN })
1082
1083 def __delfield_preloaded2(self): del self.__field_preloaded2
1084
1085 preloaded2=property(__getfield_preloaded2, __setfield_preloaded2, __delfield_preloaded2, None)
1086
1087 def __getfield_preloaded3(self):
1088 try: self.__field_preloaded3
1089 except:
1090 self.__field_preloaded3=WPictureIndexEntry(**{ 'pathname': 'Preloaded3', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN })
1091 return self.__field_preloaded3.getvalue()
1092
1093 def __setfield_preloaded3(self, value):
1094 if isinstance(value,WPictureIndexEntry):
1095 self.__field_preloaded3=value
1096 else:
1097 self.__field_preloaded3=WPictureIndexEntry(value,**{ 'pathname': 'Preloaded3', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN })
1098
1099 def __delfield_preloaded3(self): del self.__field_preloaded3
1100
1101 preloaded3=property(__getfield_preloaded3, __setfield_preloaded3, __delfield_preloaded3, None)
1102
1103 def __getfield_preloaded4(self):
1104 try: self.__field_preloaded4
1105 except:
1106 self.__field_preloaded4=WPictureIndexEntry(**{ 'pathname': 'Preloaded4', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN })
1107 return self.__field_preloaded4.getvalue()
1108
1109 def __setfield_preloaded4(self, value):
1110 if isinstance(value,WPictureIndexEntry):
1111 self.__field_preloaded4=value
1112 else:
1113 self.__field_preloaded4=WPictureIndexEntry(value,**{ 'pathname': 'Preloaded4', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN })
1114
1115 def __delfield_preloaded4(self): del self.__field_preloaded4
1116
1117 preloaded4=property(__getfield_preloaded4, __setfield_preloaded4, __delfield_preloaded4, None)
1118
1119 def __getfield_preloaded5(self):
1120 try: self.__field_preloaded5
1121 except:
1122 self.__field_preloaded5=WPictureIndexEntry(**{ 'pathname': 'Preloaded5', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN })
1123 return self.__field_preloaded5.getvalue()
1124
1125 def __setfield_preloaded5(self, value):
1126 if isinstance(value,WPictureIndexEntry):
1127 self.__field_preloaded5=value
1128 else:
1129 self.__field_preloaded5=WPictureIndexEntry(value,**{ 'pathname': 'Preloaded5', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN })
1130
1131 def __delfield_preloaded5(self): del self.__field_preloaded5
1132
1133 preloaded5=property(__getfield_preloaded5, __setfield_preloaded5, __delfield_preloaded5, None)
1134
1135 def __getfield_preloaded6(self):
1136 try: self.__field_preloaded6
1137 except:
1138 self.__field_preloaded6=WPictureIndexEntry(**{ 'pathname': 'Preloaded6', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN })
1139 return self.__field_preloaded6.getvalue()
1140
1141 def __setfield_preloaded6(self, value):
1142 if isinstance(value,WPictureIndexEntry):
1143 self.__field_preloaded6=value
1144 else:
1145 self.__field_preloaded6=WPictureIndexEntry(value,**{ 'pathname': 'Preloaded6', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN })
1146
1147 def __delfield_preloaded6(self): del self.__field_preloaded6
1148
1149 preloaded6=property(__getfield_preloaded6, __setfield_preloaded6, __delfield_preloaded6, None)
1150
1151 def __getfield_preloaded7(self):
1152 try: self.__field_preloaded7
1153 except:
1154 self.__field_preloaded7=WPictureIndexEntry(**{ 'pathname': 'Preloaded7', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN })
1155 return self.__field_preloaded7.getvalue()
1156
1157 def __setfield_preloaded7(self, value):
1158 if isinstance(value,WPictureIndexEntry):
1159 self.__field_preloaded7=value
1160 else:
1161 self.__field_preloaded7=WPictureIndexEntry(value,**{ 'pathname': 'Preloaded7', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN })
1162
1163 def __delfield_preloaded7(self): del self.__field_preloaded7
1164
1165 preloaded7=property(__getfield_preloaded7, __setfield_preloaded7, __delfield_preloaded7, None)
1166
1167 def __getfield_preloaded8(self):
1168 try: self.__field_preloaded8
1169 except:
1170 self.__field_preloaded8=WPictureIndexEntry(**{ 'pathname': 'Preloaded8', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN })
1171 return self.__field_preloaded8.getvalue()
1172
1173 def __setfield_preloaded8(self, value):
1174 if isinstance(value,WPictureIndexEntry):
1175 self.__field_preloaded8=value
1176 else:
1177 self.__field_preloaded8=WPictureIndexEntry(value,**{ 'pathname': 'Preloaded8', 'path_prefix': '', 'pictype': PIC_TYPE_BUILTIN })
1178
1179 def __delfield_preloaded8(self): del self.__field_preloaded8
1180
1181 preloaded8=property(__getfield_preloaded8, __setfield_preloaded8, __delfield_preloaded8, None)
1182
1183 def __getfield_items(self):
1184 try: self.__field_items
1185 except:
1186 self.__field_items=LIST(**{ 'elementclass': WPictureIndexEntry })
1187 return self.__field_items.getvalue()
1188
1189 def __setfield_items(self, value):
1190 if isinstance(value,LIST):
1191 self.__field_items=value
1192 else:
1193 self.__field_items=LIST(value,**{ 'elementclass': WPictureIndexEntry })
1194
1195 def __delfield_items(self): del self.__field_items
1196
1197 items=property(__getfield_items, __setfield_items, __delfield_items, None)
1198
1199 def iscontainer(self):
1200 return True
1201
1202 def containerelements(self):
1203 yield ('header', self.__field_header, None)
1204 yield ('preloaded1', self.__field_preloaded1, None)
1205 yield ('preloaded2', self.__field_preloaded2, None)
1206 yield ('preloaded3', self.__field_preloaded3, None)
1207 yield ('preloaded4', self.__field_preloaded4, None)
1208 yield ('preloaded5', self.__field_preloaded5, None)
1209 yield ('preloaded6', self.__field_preloaded6, None)
1210 yield ('preloaded7', self.__field_preloaded7, None)
1211 yield ('preloaded8', self.__field_preloaded8, None)
1212 yield ('items', self.__field_items, None)
1213
1214
1215
1216
1217 class RPictureIndexEntry(BaseProtogenClass):
1218 __fields=['pathname', 'pictype']
1219
1220 def __init__(self, *args, **kwargs):
1221 dict={}
1222 dict.update(kwargs)
1224 super(RPictureIndexEntry,self).__init__(**dict)
1226 if self.__class__ is RPictureIndexEntry:
1227 self._update(args,dict)
1228
1229
1230 def getfields(self):
1231 return self.__fields
1232
1233
1234 def _update(self, args, kwargs):
1235 super(RPictureIndexEntry,self)._update(args,kwargs)
1236 keys=kwargs.keys()
1237 for key in keys:
1238 if key in self.__fields:
1239 setattr(self, key, kwargs[key])
1240 del kwargs[key]
1241 if __debug__:
1243 self._complainaboutunusedargs(RPictureIndexEntry,kwargs)
1244 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1245
1247
1248 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1249 'Writes this packet to the supplied buffer'
1250 self._bufferstartoffset=buf.getcurrentoffset()
1251 self.__field_pathname.writetobuffer(buf)
1252 self.__field_pictype.writetobuffer(buf)
1253 self._bufferendoffset=buf.getcurrentoffset()
1254 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1255
1256
1257 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1258 'Reads this packet from the supplied buffer'
1259 self._bufferstartoffset=buf.getcurrentoffset()
1260 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1261 self.__field_pathname=STRING(**{'sizeinbytes': 258, 'terminator': 0, 'raiseonunterminatedread': False })
1262 self.__field_pathname.readfrombuffer(buf)
1263 self.__field_pictype=UINT(**{'sizeinbytes': 2})
1264 self.__field_pictype.readfrombuffer(buf)
1265 self._bufferendoffset=buf.getcurrentoffset()
1266
1267
1268 def __getfield_pathname(self):
1269 return self.__field_pathname.getvalue()
1270
1271 def __setfield_pathname(self, value):
1272 if isinstance(value,STRING):
1273 self.__field_pathname=value
1274 else:
1275 self.__field_pathname=STRING(value,**{'sizeinbytes': 258, 'terminator': 0, 'raiseonunterminatedread': False })
1276
1277 def __delfield_pathname(self): del self.__field_pathname
1278
1279 pathname=property(__getfield_pathname, __setfield_pathname, __delfield_pathname, None)
1280
1281 def __getfield_pictype(self):
1282 return self.__field_pictype.getvalue()
1283
1284 def __setfield_pictype(self, value):
1285 if isinstance(value,UINT):
1286 self.__field_pictype=value
1287 else:
1288 self.__field_pictype=UINT(value,**{'sizeinbytes': 2})
1289
1290 def __delfield_pictype(self): del self.__field_pictype
1291
1292 pictype=property(__getfield_pictype, __setfield_pictype, __delfield_pictype, "0= invalid, 4=builtin, 3=users")
1293
1294 def iscontainer(self):
1295 return True
1296
1297 def containerelements(self):
1298 yield ('pathname', self.__field_pathname, None)
1299 yield ('pictype', self.__field_pictype, "0= invalid, 4=builtin, 3=users")
1300
1301
1302
1303
1304 class RPictureIndexFile(BaseProtogenClass):
1305 __fields=['items']
1306
1307 def __init__(self, *args, **kwargs):
1308 dict={}
1309 dict.update(kwargs)
1311 super(RPictureIndexFile,self).__init__(**dict)
1313 if self.__class__ is RPictureIndexFile:
1314 self._update(args,dict)
1315
1316
1317 def getfields(self):
1318 return self.__fields
1319
1320
1321 def _update(self, args, kwargs):
1322 super(RPictureIndexFile,self)._update(args,kwargs)
1323 keys=kwargs.keys()
1324 for key in keys:
1325 if key in self.__fields:
1326 setattr(self, key, kwargs[key])
1327 del kwargs[key]
1328 if __debug__:
1330 self._complainaboutunusedargs(RPictureIndexFile,kwargs)
1331 if len(args):
1332 dict2={ 'elementclass': RPictureIndexEntry }
1333 dict2.update(kwargs)
1334 kwargs=dict2
1335 self.__field_items=LIST(*args,**dict2)
1336
1338
1339 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1340 'Writes this packet to the supplied buffer'
1341 self._bufferstartoffset=buf.getcurrentoffset()
1342 try: self.__field_items
1343 except:
1344 self.__field_items=LIST(**{ 'elementclass': RPictureIndexEntry })
1345 self.__field_items.writetobuffer(buf)
1346 self._bufferendoffset=buf.getcurrentoffset()
1347 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1348
1349
1350 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1351 'Reads this packet from the supplied buffer'
1352 self._bufferstartoffset=buf.getcurrentoffset()
1353 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1354 self.__field_items=LIST(**{ 'elementclass': RPictureIndexEntry })
1355 self.__field_items.readfrombuffer(buf)
1356 self._bufferendoffset=buf.getcurrentoffset()
1357
1358
1359 def __getfield_items(self):
1360 try: self.__field_items
1361 except:
1362 self.__field_items=LIST(**{ 'elementclass': RPictureIndexEntry })
1363 return self.__field_items.getvalue()
1364
1365 def __setfield_items(self, value):
1366 if isinstance(value,LIST):
1367 self.__field_items=value
1368 else:
1369 self.__field_items=LIST(value,**{ 'elementclass': RPictureIndexEntry })
1370
1371 def __delfield_items(self): del self.__field_items
1372
1373 items=property(__getfield_items, __setfield_items, __delfield_items, None)
1374
1375 def iscontainer(self):
1376 return True
1377
1378 def containerelements(self):
1379 yield ('items', self.__field_items, None)
1380
1381
1382
1383
1384 class NumberEntry(BaseProtogenClass):
1385 __fields=['number', 'option', 'speeddial', 'ringtone']
1386
1387 def __init__(self, *args, **kwargs):
1388 dict={}
1389 dict.update(kwargs)
1391 super(NumberEntry,self).__init__(**dict)
1393 if self.__class__ is NumberEntry:
1394 self._update(args,dict)
1395
1396
1397 def getfields(self):
1398 return self.__fields
1399
1400
1401 def _update(self, args, kwargs):
1402 super(NumberEntry,self)._update(args,kwargs)
1403 keys=kwargs.keys()
1404 for key in keys:
1405 if key in self.__fields:
1406 setattr(self, key, kwargs[key])
1407 del kwargs[key]
1408 if __debug__:
1410 self._complainaboutunusedargs(NumberEntry,kwargs)
1411 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1412
1414
1415 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1416 'Writes this packet to the supplied buffer'
1417 self._bufferstartoffset=buf.getcurrentoffset()
1418 self.__field_number.writetobuffer(buf)
1419 self.__field_option.writetobuffer(buf)
1420 if self.option & PB_FLG_SPEEDDIAL:
1421 self.__field_speeddial.writetobuffer(buf)
1422 if self.option & PB_FLG_RINGTONE:
1423 self.__field_ringtone.writetobuffer(buf)
1424 self._bufferendoffset=buf.getcurrentoffset()
1425 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1426
1427
1428 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1429 'Reads this packet from the supplied buffer'
1430 self._bufferstartoffset=buf.getcurrentoffset()
1431 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1432 self.__field_number=STRING(**{ 'terminator': None, 'pascal': True })
1433 self.__field_number.readfrombuffer(buf)
1434 self.__field_option=UINT(**{'sizeinbytes': 1})
1435 self.__field_option.readfrombuffer(buf)
1436 if self.option & PB_FLG_SPEEDDIAL:
1437 self.__field_speeddial=UINT(**{'sizeinbytes': 2})
1438 self.__field_speeddial.readfrombuffer(buf)
1439 if self.option & PB_FLG_RINGTONE:
1440 self.__field_ringtone=STRING(**{ 'terminator': None, 'pascal': True })
1441 self.__field_ringtone.readfrombuffer(buf)
1442 self._bufferendoffset=buf.getcurrentoffset()
1443
1444
1445 def __getfield_number(self):
1446 return self.__field_number.getvalue()
1447
1448 def __setfield_number(self, value):
1449 if isinstance(value,STRING):
1450 self.__field_number=value
1451 else:
1452 self.__field_number=STRING(value,**{ 'terminator': None, 'pascal': True })
1453
1454 def __delfield_number(self): del self.__field_number
1455
1456 number=property(__getfield_number, __setfield_number, __delfield_number, None)
1457
1458 def __getfield_option(self):
1459 return self.__field_option.getvalue()
1460
1461 def __setfield_option(self, value):
1462 if isinstance(value,UINT):
1463 self.__field_option=value
1464 else:
1465 self.__field_option=UINT(value,**{'sizeinbytes': 1})
1466
1467 def __delfield_option(self): del self.__field_option
1468
1469 option=property(__getfield_option, __setfield_option, __delfield_option, None)
1470
1471 def __getfield_speeddial(self):
1472 return self.__field_speeddial.getvalue()
1473
1474 def __setfield_speeddial(self, value):
1475 if isinstance(value,UINT):
1476 self.__field_speeddial=value
1477 else:
1478 self.__field_speeddial=UINT(value,**{'sizeinbytes': 2})
1479
1480 def __delfield_speeddial(self): del self.__field_speeddial
1481
1482 speeddial=property(__getfield_speeddial, __setfield_speeddial, __delfield_speeddial, None)
1483
1484 def __getfield_ringtone(self):
1485 return self.__field_ringtone.getvalue()
1486
1487 def __setfield_ringtone(self, value):
1488 if isinstance(value,STRING):
1489 self.__field_ringtone=value
1490 else:
1491 self.__field_ringtone=STRING(value,**{ 'terminator': None, 'pascal': True })
1492
1493 def __delfield_ringtone(self): del self.__field_ringtone
1494
1495 ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None)
1496
1497 def iscontainer(self):
1498 return True
1499
1500 def containerelements(self):
1501 yield ('number', self.__field_number, None)
1502 yield ('option', self.__field_option, None)
1503 if self.option & PB_FLG_SPEEDDIAL:
1504 yield ('speeddial', self.__field_speeddial, None)
1505 if self.option & PB_FLG_RINGTONE:
1506 yield ('ringtone', self.__field_ringtone, None)
1507
1508
1509
1510
1511 class PBEntry(BaseProtogenClass):
1512 __fields=['info', 'info2', 'name', 'email', 'email2', 'home', 'work', 'cell', 'fax', 'cell2', 'note', 'datetime', 'group', 'wallpaper', 'wallpaper_range']
1513
1514 def __init__(self, *args, **kwargs):
1515 dict={}
1516 dict.update(kwargs)
1518 super(PBEntry,self).__init__(**dict)
1520 if self.__class__ is PBEntry:
1521 self._update(args,dict)
1522
1523
1524 def getfields(self):
1525 return self.__fields
1526
1527
1528 def _update(self, args, kwargs):
1529 super(PBEntry,self)._update(args,kwargs)
1530 keys=kwargs.keys()
1531 for key in keys:
1532 if key in self.__fields:
1533 setattr(self, key, kwargs[key])
1534 del kwargs[key]
1535 if __debug__:
1537 self._complainaboutunusedargs(PBEntry,kwargs)
1538 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1539
1541
1542 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1543 'Writes this packet to the supplied buffer'
1544 self._bufferstartoffset=buf.getcurrentoffset()
1545 self.__field_info.writetobuffer(buf)
1546 self.__field_info2.writetobuffer(buf)
1547 if self.info & PB_FLG_NAME:
1548 self.__field_name.writetobuffer(buf)
1549 if self.info & PB_FLG_EMAIL:
1550 self.__field_email.writetobuffer(buf)
1551 if self.info & PB_FLG_EMAIL2:
1552 self.__field_email2.writetobuffer(buf)
1553 if self.info & PB_FLG_HOME:
1554 self.__field_home.writetobuffer(buf)
1555 if self.info & PB_FLG_WORK:
1556 self.__field_work.writetobuffer(buf)
1557 if self.info & PB_FLG_CELL:
1558 self.__field_cell.writetobuffer(buf)
1559 if self.info & PB_FLG_FAX:
1560 self.__field_fax.writetobuffer(buf)
1561 if self.info & PB_FLG_CELL2:
1562 self.__field_cell2.writetobuffer(buf)
1563 if self.info & PB_FLG_NOTE:
1564 self.__field_note.writetobuffer(buf)
1565 if self.info & PB_FLG_DATE:
1566 self.__field_datetime.writetobuffer(buf)
1567 if self.info & PB_FLG_GROUP:
1568 self.__field_group.writetobuffer(buf)
1569 if self.info & PB_FLG_WP:
1570 self.__field_wallpaper.writetobuffer(buf)
1571 self.__field_wallpaper_range.writetobuffer(buf)
1572 self._bufferendoffset=buf.getcurrentoffset()
1573 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1574
1575
1576 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1577 'Reads this packet from the supplied buffer'
1578 self._bufferstartoffset=buf.getcurrentoffset()
1579 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1580 self.__field_info=UINT(**{'sizeinbytes': 2})
1581 self.__field_info.readfrombuffer(buf)
1582 self.__field_info2=UINT(**{'sizeinbytes': 2})
1583 self.__field_info2.readfrombuffer(buf)
1584 if self.info & PB_FLG_NAME:
1585 self.__field_name=USTRING(**{ 'terminator': None, 'encoding': ENCODING, 'pascal': True })
1586 self.__field_name.readfrombuffer(buf)
1587 if self.info & PB_FLG_EMAIL:
1588 self.__field_email=USTRING(**{ 'terminator': None, 'encoding': ENCODING, 'pascal': True })
1589 self.__field_email.readfrombuffer(buf)
1590 if self.info & PB_FLG_EMAIL2:
1591 self.__field_email2=USTRING(**{ 'terminator': None, 'encoding': ENCODING, 'pascal': True })
1592 self.__field_email2.readfrombuffer(buf)
1593 if self.info & PB_FLG_HOME:
1594 self.__field_home=NumberEntry()
1595 self.__field_home.readfrombuffer(buf)
1596 if self.info & PB_FLG_WORK:
1597 self.__field_work=NumberEntry()
1598 self.__field_work.readfrombuffer(buf)
1599 if self.info & PB_FLG_CELL:
1600 self.__field_cell=NumberEntry()
1601 self.__field_cell.readfrombuffer(buf)
1602 if self.info & PB_FLG_FAX:
1603 self.__field_fax=NumberEntry()
1604 self.__field_fax.readfrombuffer(buf)
1605 if self.info & PB_FLG_CELL2:
1606 self.__field_cell2=NumberEntry()
1607 self.__field_cell2.readfrombuffer(buf)
1608 if self.info & PB_FLG_NOTE:
1609 self.__field_note=STRING(**{ 'terminator': None, 'pascal': True })
1610 self.__field_note.readfrombuffer(buf)
1611 if self.info & PB_FLG_DATE:
1612 self.__field_datetime=DateTime(**{'sizeinbytes': 4})
1613 self.__field_datetime.readfrombuffer(buf)
1614 if self.info & PB_FLG_GROUP:
1615 self.__field_group=UINT(**{'sizeinbytes': 1})
1616 self.__field_group.readfrombuffer(buf)
1617 if self.info & PB_FLG_WP:
1618 self.__field_wallpaper=STRING(**{ 'terminator': None, 'pascal': True })
1619 self.__field_wallpaper.readfrombuffer(buf)
1620 self.__field_wallpaper_range=UINT(**{'sizeinbytes': 4})
1621 self.__field_wallpaper_range.readfrombuffer(buf)
1622 self._bufferendoffset=buf.getcurrentoffset()
1623
1624
1625 def __getfield_info(self):
1626 return self.__field_info.getvalue()
1627
1628 def __setfield_info(self, value):
1629 if isinstance(value,UINT):
1630 self.__field_info=value
1631 else:
1632 self.__field_info=UINT(value,**{'sizeinbytes': 2})
1633
1634 def __delfield_info(self): del self.__field_info
1635
1636 info=property(__getfield_info, __setfield_info, __delfield_info, None)
1637
1638 def __getfield_info2(self):
1639 return self.__field_info2.getvalue()
1640
1641 def __setfield_info2(self, value):
1642 if isinstance(value,UINT):
1643 self.__field_info2=value
1644 else:
1645 self.__field_info2=UINT(value,**{'sizeinbytes': 2})
1646
1647 def __delfield_info2(self): del self.__field_info2
1648
1649 info2=property(__getfield_info2, __setfield_info2, __delfield_info2, None)
1650
1651 def __getfield_name(self):
1652 return self.__field_name.getvalue()
1653
1654 def __setfield_name(self, value):
1655 if isinstance(value,USTRING):
1656 self.__field_name=value
1657 else:
1658 self.__field_name=USTRING(value,**{ 'terminator': None, 'encoding': ENCODING, 'pascal': True })
1659
1660 def __delfield_name(self): del self.__field_name
1661
1662 name=property(__getfield_name, __setfield_name, __delfield_name, None)
1663
1664 def __getfield_email(self):
1665 return self.__field_email.getvalue()
1666
1667 def __setfield_email(self, value):
1668 if isinstance(value,USTRING):
1669 self.__field_email=value
1670 else:
1671 self.__field_email=USTRING(value,**{ 'terminator': None, 'encoding': ENCODING, 'pascal': True })
1672
1673 def __delfield_email(self): del self.__field_email
1674
1675 email=property(__getfield_email, __setfield_email, __delfield_email, None)
1676
1677 def __getfield_email2(self):
1678 return self.__field_email2.getvalue()
1679
1680 def __setfield_email2(self, value):
1681 if isinstance(value,USTRING):
1682 self.__field_email2=value
1683 else:
1684 self.__field_email2=USTRING(value,**{ 'terminator': None, 'encoding': ENCODING, 'pascal': True })
1685
1686 def __delfield_email2(self): del self.__field_email2
1687
1688 email2=property(__getfield_email2, __setfield_email2, __delfield_email2, None)
1689
1690 def __getfield_home(self):
1691 return self.__field_home.getvalue()
1692
1693 def __setfield_home(self, value):
1694 if isinstance(value,NumberEntry):
1695 self.__field_home=value
1696 else:
1697 self.__field_home=NumberEntry(value,)
1698
1699 def __delfield_home(self): del self.__field_home
1700
1701 home=property(__getfield_home, __setfield_home, __delfield_home, None)
1702
1703 def __getfield_work(self):
1704 return self.__field_work.getvalue()
1705
1706 def __setfield_work(self, value):
1707 if isinstance(value,NumberEntry):
1708 self.__field_work=value
1709 else:
1710 self.__field_work=NumberEntry(value,)
1711
1712 def __delfield_work(self): del self.__field_work
1713
1714 work=property(__getfield_work, __setfield_work, __delfield_work, None)
1715
1716 def __getfield_cell(self):
1717 return self.__field_cell.getvalue()
1718
1719 def __setfield_cell(self, value):
1720 if isinstance(value,NumberEntry):
1721 self.__field_cell=value
1722 else:
1723 self.__field_cell=NumberEntry(value,)
1724
1725 def __delfield_cell(self): del self.__field_cell
1726
1727 cell=property(__getfield_cell, __setfield_cell, __delfield_cell, None)
1728
1729 def __getfield_fax(self):
1730 return self.__field_fax.getvalue()
1731
1732 def __setfield_fax(self, value):
1733 if isinstance(value,NumberEntry):
1734 self.__field_fax=value
1735 else:
1736 self.__field_fax=NumberEntry(value,)
1737
1738 def __delfield_fax(self): del self.__field_fax
1739
1740 fax=property(__getfield_fax, __setfield_fax, __delfield_fax, None)
1741
1742 def __getfield_cell2(self):
1743 return self.__field_cell2.getvalue()
1744
1745 def __setfield_cell2(self, value):
1746 if isinstance(value,NumberEntry):
1747 self.__field_cell2=value
1748 else:
1749 self.__field_cell2=NumberEntry(value,)
1750
1751 def __delfield_cell2(self): del self.__field_cell2
1752
1753 cell2=property(__getfield_cell2, __setfield_cell2, __delfield_cell2, None)
1754
1755 def __getfield_note(self):
1756 return self.__field_note.getvalue()
1757
1758 def __setfield_note(self, value):
1759 if isinstance(value,STRING):
1760 self.__field_note=value
1761 else:
1762 self.__field_note=STRING(value,**{ 'terminator': None, 'pascal': True })
1763
1764 def __delfield_note(self): del self.__field_note
1765
1766 note=property(__getfield_note, __setfield_note, __delfield_note, None)
1767
1768 def __getfield_datetime(self):
1769 return self.__field_datetime.getvalue()
1770
1771 def __setfield_datetime(self, value):
1772 if isinstance(value,DateTime):
1773 self.__field_datetime=value
1774 else:
1775 self.__field_datetime=DateTime(value,**{'sizeinbytes': 4})
1776
1777 def __delfield_datetime(self): del self.__field_datetime
1778
1779 datetime=property(__getfield_datetime, __setfield_datetime, __delfield_datetime, None)
1780
1781 def __getfield_group(self):
1782 return self.__field_group.getvalue()
1783
1784 def __setfield_group(self, value):
1785 if isinstance(value,UINT):
1786 self.__field_group=value
1787 else:
1788 self.__field_group=UINT(value,**{'sizeinbytes': 1})
1789
1790 def __delfield_group(self): del self.__field_group
1791
1792 group=property(__getfield_group, __setfield_group, __delfield_group, None)
1793
1794 def __getfield_wallpaper(self):
1795 return self.__field_wallpaper.getvalue()
1796
1797 def __setfield_wallpaper(self, value):
1798 if isinstance(value,STRING):
1799 self.__field_wallpaper=value
1800 else:
1801 self.__field_wallpaper=STRING(value,**{ 'terminator': None, 'pascal': True })
1802
1803 def __delfield_wallpaper(self): del self.__field_wallpaper
1804
1805 wallpaper=property(__getfield_wallpaper, __setfield_wallpaper, __delfield_wallpaper, None)
1806
1807 def __getfield_wallpaper_range(self):
1808 return self.__field_wallpaper_range.getvalue()
1809
1810 def __setfield_wallpaper_range(self, value):
1811 if isinstance(value,UINT):
1812 self.__field_wallpaper_range=value
1813 else:
1814 self.__field_wallpaper_range=UINT(value,**{'sizeinbytes': 4})
1815
1816 def __delfield_wallpaper_range(self): del self.__field_wallpaper_range
1817
1818 wallpaper_range=property(__getfield_wallpaper_range, __setfield_wallpaper_range, __delfield_wallpaper_range, None)
1819
1820 def iscontainer(self):
1821 return True
1822
1823 def containerelements(self):
1824 yield ('info', self.__field_info, None)
1825 yield ('info2', self.__field_info2, None)
1826 if self.info & PB_FLG_NAME:
1827 yield ('name', self.__field_name, None)
1828 if self.info & PB_FLG_EMAIL:
1829 yield ('email', self.__field_email, None)
1830 if self.info & PB_FLG_EMAIL2:
1831 yield ('email2', self.__field_email2, None)
1832 if self.info & PB_FLG_HOME:
1833 yield ('home', self.__field_home, None)
1834 if self.info & PB_FLG_WORK:
1835 yield ('work', self.__field_work, None)
1836 if self.info & PB_FLG_CELL:
1837 yield ('cell', self.__field_cell, None)
1838 if self.info & PB_FLG_FAX:
1839 yield ('fax', self.__field_fax, None)
1840 if self.info & PB_FLG_CELL2:
1841 yield ('cell2', self.__field_cell2, None)
1842 if self.info & PB_FLG_NOTE:
1843 yield ('note', self.__field_note, None)
1844 if self.info & PB_FLG_DATE:
1845 yield ('datetime', self.__field_datetime, None)
1846 if self.info & PB_FLG_GROUP:
1847 yield ('group', self.__field_group, None)
1848 if self.info & PB_FLG_WP:
1849 yield ('wallpaper', self.__field_wallpaper, None)
1850 yield ('wallpaper_range', self.__field_wallpaper_range, None)
1851
1852
1853
1854
1855 class LenEntry(BaseProtogenClass):
1856 __fields=['itemlen']
1857
1858 def __init__(self, *args, **kwargs):
1859 dict={}
1860 dict.update(kwargs)
1862 super(LenEntry,self).__init__(**dict)
1864 if self.__class__ is LenEntry:
1865 self._update(args,dict)
1866
1867
1868 def getfields(self):
1869 return self.__fields
1870
1871
1872 def _update(self, args, kwargs):
1873 super(LenEntry,self)._update(args,kwargs)
1874 keys=kwargs.keys()
1875 for key in keys:
1876 if key in self.__fields:
1877 setattr(self, key, kwargs[key])
1878 del kwargs[key]
1879 if __debug__:
1881 self._complainaboutunusedargs(LenEntry,kwargs)
1882 if len(args):
1883 dict2={'sizeinbytes': 2, 'default': 0 }
1884 dict2.update(kwargs)
1885 kwargs=dict2
1886 self.__field_itemlen=UINT(*args,**dict2)
1887
1889
1890 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1891 'Writes this packet to the supplied buffer'
1892 self._bufferstartoffset=buf.getcurrentoffset()
1893 try: self.__field_itemlen
1894 except:
1895 self.__field_itemlen=UINT(**{'sizeinbytes': 2, 'default': 0 })
1896 self.__field_itemlen.writetobuffer(buf)
1897 self._bufferendoffset=buf.getcurrentoffset()
1898 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1899
1900
1901 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1902 'Reads this packet from the supplied buffer'
1903 self._bufferstartoffset=buf.getcurrentoffset()
1904 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1905 self.__field_itemlen=UINT(**{'sizeinbytes': 2, 'default': 0 })
1906 self.__field_itemlen.readfrombuffer(buf)
1907 self._bufferendoffset=buf.getcurrentoffset()
1908
1909
1910 def __getfield_itemlen(self):
1911 try: self.__field_itemlen
1912 except:
1913 self.__field_itemlen=UINT(**{'sizeinbytes': 2, 'default': 0 })
1914 return self.__field_itemlen.getvalue()
1915
1916 def __setfield_itemlen(self, value):
1917 if isinstance(value,UINT):
1918 self.__field_itemlen=value
1919 else:
1920 self.__field_itemlen=UINT(value,**{'sizeinbytes': 2, 'default': 0 })
1921
1922 def __delfield_itemlen(self): del self.__field_itemlen
1923
1924 itemlen=property(__getfield_itemlen, __setfield_itemlen, __delfield_itemlen, None)
1925
1926 def iscontainer(self):
1927 return True
1928
1929 def containerelements(self):
1930 yield ('itemlen', self.__field_itemlen, None)
1931
1932
1933
1934
1935 class PBFile(BaseProtogenClass):
1936 __fields=['lens', 'items']
1937
1938 def __init__(self, *args, **kwargs):
1939 dict={}
1940 dict.update(kwargs)
1942 super(PBFile,self).__init__(**dict)
1944 if self.__class__ is PBFile:
1945 self._update(args,dict)
1946
1947
1948 def getfields(self):
1949 return self.__fields
1950
1951
1952 def _update(self, args, kwargs):
1953 super(PBFile,self)._update(args,kwargs)
1954 keys=kwargs.keys()
1955 for key in keys:
1956 if key in self.__fields:
1957 setattr(self, key, kwargs[key])
1958 del kwargs[key]
1959 if __debug__:
1961 self._complainaboutunusedargs(PBFile,kwargs)
1962 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1963
1965
1966 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1967 'Writes this packet to the supplied buffer'
1968 self._bufferstartoffset=buf.getcurrentoffset()
1969 try: self.__field_lens
1970 except:
1971 self.__field_lens=LIST(**{ 'elementclass': LenEntry, 'length': 8, 'createdefault': True })
1972 self.__field_lens.writetobuffer(buf)
1973 try: self.__field_items
1974 except:
1975 self.__field_items=LIST(**{ 'elementclass': PBEntry })
1976 self.__field_items.writetobuffer(buf)
1977 self._bufferendoffset=buf.getcurrentoffset()
1978 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1979
1980
1981 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1982 'Reads this packet from the supplied buffer'
1983 self._bufferstartoffset=buf.getcurrentoffset()
1984 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1985 self.__field_lens=LIST(**{ 'elementclass': LenEntry, 'length': 8, 'createdefault': True })
1986 self.__field_lens.readfrombuffer(buf)
1987 self.__field_items=LIST(**{ 'elementclass': PBEntry })
1988 self.__field_items.readfrombuffer(buf)
1989 self._bufferendoffset=buf.getcurrentoffset()
1990
1991
1992 def __getfield_lens(self):
1993 try: self.__field_lens
1994 except:
1995 self.__field_lens=LIST(**{ 'elementclass': LenEntry, 'length': 8, 'createdefault': True })
1996 return self.__field_lens.getvalue()
1997
1998 def __setfield_lens(self, value):
1999 if isinstance(value,LIST):
2000 self.__field_lens=value
2001 else:
2002 self.__field_lens=LIST(value,**{ 'elementclass': LenEntry, 'length': 8, 'createdefault': True })
2003
2004 def __delfield_lens(self): del self.__field_lens
2005
2006 lens=property(__getfield_lens, __setfield_lens, __delfield_lens, None)
2007
2008 def __getfield_items(self):
2009 try: self.__field_items
2010 except:
2011 self.__field_items=LIST(**{ 'elementclass': PBEntry })
2012 return self.__field_items.getvalue()
2013
2014 def __setfield_items(self, value):
2015 if isinstance(value,LIST):
2016 self.__field_items=value
2017 else:
2018 self.__field_items=LIST(value,**{ 'elementclass': PBEntry })
2019
2020 def __delfield_items(self): del self.__field_items
2021
2022 items=property(__getfield_items, __setfield_items, __delfield_items, None)
2023
2024 def iscontainer(self):
2025 return True
2026
2027 def containerelements(self):
2028 yield ('lens', self.__field_lens, None)
2029 yield ('items', self.__field_items, None)
2030
2031
2032
2033
2034 class PBFileHeader(BaseProtogenClass):
2035 __fields=['lens']
2036
2037 def __init__(self, *args, **kwargs):
2038 dict={}
2039 dict.update(kwargs)
2041 super(PBFileHeader,self).__init__(**dict)
2043 if self.__class__ is PBFileHeader:
2044 self._update(args,dict)
2045
2046
2047 def getfields(self):
2048 return self.__fields
2049
2050
2051 def _update(self, args, kwargs):
2052 super(PBFileHeader,self)._update(args,kwargs)
2053 keys=kwargs.keys()
2054 for key in keys:
2055 if key in self.__fields:
2056 setattr(self, key, kwargs[key])
2057 del kwargs[key]
2058 if __debug__:
2060 self._complainaboutunusedargs(PBFileHeader,kwargs)
2061 if len(args):
2062 dict2={ 'elementclass': LenEntry, 'length': 8, 'createdefault': True }
2063 dict2.update(kwargs)
2064 kwargs=dict2
2065 self.__field_lens=LIST(*args,**dict2)
2066
2068
2069 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2070 'Writes this packet to the supplied buffer'
2071 self._bufferstartoffset=buf.getcurrentoffset()
2072 try: self.__field_lens
2073 except:
2074 self.__field_lens=LIST(**{ 'elementclass': LenEntry, 'length': 8, 'createdefault': True })
2075 self.__field_lens.writetobuffer(buf)
2076 self._bufferendoffset=buf.getcurrentoffset()
2077 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2078
2079
2080 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2081 'Reads this packet from the supplied buffer'
2082 self._bufferstartoffset=buf.getcurrentoffset()
2083 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2084 self.__field_lens=LIST(**{ 'elementclass': LenEntry, 'length': 8, 'createdefault': True })
2085 self.__field_lens.readfrombuffer(buf)
2086 self._bufferendoffset=buf.getcurrentoffset()
2087
2088
2089 def __getfield_lens(self):
2090 try: self.__field_lens
2091 except:
2092 self.__field_lens=LIST(**{ 'elementclass': LenEntry, 'length': 8, 'createdefault': True })
2093 return self.__field_lens.getvalue()
2094
2095 def __setfield_lens(self, value):
2096 if isinstance(value,LIST):
2097 self.__field_lens=value
2098 else:
2099 self.__field_lens=LIST(value,**{ 'elementclass': LenEntry, 'length': 8, 'createdefault': True })
2100
2101 def __delfield_lens(self): del self.__field_lens
2102
2103 lens=property(__getfield_lens, __setfield_lens, __delfield_lens, None)
2104
2105 def iscontainer(self):
2106 return True
2107
2108 def containerelements(self):
2109 yield ('lens', self.__field_lens, None)
2110
2111
2112
2113
2114 class ss_number_entry(BaseProtogenClass):
2115 __fields=['number', 'speeddial', 'primary', 'zero', 'ringtone']
2116
2117 def __init__(self, *args, **kwargs):
2118 dict={}
2119 dict.update(kwargs)
2121 super(ss_number_entry,self).__init__(**dict)
2123 if self.__class__ is ss_number_entry:
2124 self._update(args,dict)
2125
2126
2127 def getfields(self):
2128 return self.__fields
2129
2130
2131 def _update(self, args, kwargs):
2132 super(ss_number_entry,self)._update(args,kwargs)
2133 keys=kwargs.keys()
2134 for key in keys:
2135 if key in self.__fields:
2136 setattr(self, key, kwargs[key])
2137 del kwargs[key]
2138 if __debug__:
2140 self._complainaboutunusedargs(ss_number_entry,kwargs)
2141 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2142
2144
2145 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2146 'Writes this packet to the supplied buffer'
2147 self._bufferstartoffset=buf.getcurrentoffset()
2148 try: self.__field_number
2149 except:
2150 self.__field_number=STRING(**{ 'terminator': 0, 'default': '', 'maxsizeinbytes': PB_MAX_NUMBER_LEN, 'raiseontruncate': False })
2151 self.__field_number.writetobuffer(buf)
2152 try: self.__field_speeddial
2153 except:
2154 self.__field_speeddial=UINT(**{'sizeinbytes': 2, 'default': 0 })
2155 self.__field_speeddial.writetobuffer(buf)
2156 try: self.__field_primary
2157 except:
2158 self.__field_primary=UINT(**{'sizeinbytes': 1, 'default': 0 })
2159 self.__field_primary.writetobuffer(buf)
2160 try: self.__field_zero
2161 except:
2162 self.__field_zero=STRING(**{'sizeinbytes': 8, 'pad': 0, 'default': '' })
2163 self.__field_zero.writetobuffer(buf)
2164 try: self.__field_ringtone
2165 except:
2166 self.__field_ringtone=STRING(**{ 'terminator': 0, 'default': '' })
2167 self.__field_ringtone.writetobuffer(buf)
2168 self._bufferendoffset=buf.getcurrentoffset()
2169 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2170
2171
2172 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2173 'Reads this packet from the supplied buffer'
2174 self._bufferstartoffset=buf.getcurrentoffset()
2175 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2176 self.__field_number=STRING(**{ 'terminator': 0, 'default': '', 'maxsizeinbytes': PB_MAX_NUMBER_LEN, 'raiseontruncate': False })
2177 self.__field_number.readfrombuffer(buf)
2178 self.__field_speeddial=UINT(**{'sizeinbytes': 2, 'default': 0 })
2179 self.__field_speeddial.readfrombuffer(buf)
2180 self.__field_primary=UINT(**{'sizeinbytes': 1, 'default': 0 })
2181 self.__field_primary.readfrombuffer(buf)
2182 self.__field_zero=STRING(**{'sizeinbytes': 8, 'pad': 0, 'default': '' })
2183 self.__field_zero.readfrombuffer(buf)
2184 self.__field_ringtone=STRING(**{ 'terminator': 0, 'default': '' })
2185 self.__field_ringtone.readfrombuffer(buf)
2186 self._bufferendoffset=buf.getcurrentoffset()
2187
2188
2189 def __getfield_number(self):
2190 try: self.__field_number
2191 except:
2192 self.__field_number=STRING(**{ 'terminator': 0, 'default': '', 'maxsizeinbytes': PB_MAX_NUMBER_LEN, 'raiseontruncate': False })
2193 return self.__field_number.getvalue()
2194
2195 def __setfield_number(self, value):
2196 if isinstance(value,STRING):
2197 self.__field_number=value
2198 else:
2199 self.__field_number=STRING(value,**{ 'terminator': 0, 'default': '', 'maxsizeinbytes': PB_MAX_NUMBER_LEN, 'raiseontruncate': False })
2200
2201 def __delfield_number(self): del self.__field_number
2202
2203 number=property(__getfield_number, __setfield_number, __delfield_number, None)
2204
2205 def __getfield_speeddial(self):
2206 try: self.__field_speeddial
2207 except:
2208 self.__field_speeddial=UINT(**{'sizeinbytes': 2, 'default': 0 })
2209 return self.__field_speeddial.getvalue()
2210
2211 def __setfield_speeddial(self, value):
2212 if isinstance(value,UINT):
2213 self.__field_speeddial=value
2214 else:
2215 self.__field_speeddial=UINT(value,**{'sizeinbytes': 2, 'default': 0 })
2216
2217 def __delfield_speeddial(self): del self.__field_speeddial
2218
2219 speeddial=property(__getfield_speeddial, __setfield_speeddial, __delfield_speeddial, None)
2220
2221 def __getfield_primary(self):
2222 try: self.__field_primary
2223 except:
2224 self.__field_primary=UINT(**{'sizeinbytes': 1, 'default': 0 })
2225 return self.__field_primary.getvalue()
2226
2227 def __setfield_primary(self, value):
2228 if isinstance(value,UINT):
2229 self.__field_primary=value
2230 else:
2231 self.__field_primary=UINT(value,**{'sizeinbytes': 1, 'default': 0 })
2232
2233 def __delfield_primary(self): del self.__field_primary
2234
2235 primary=property(__getfield_primary, __setfield_primary, __delfield_primary, None)
2236
2237 def __getfield_zero(self):
2238 try: self.__field_zero
2239 except:
2240 self.__field_zero=STRING(**{'sizeinbytes': 8, 'pad': 0, 'default': '' })
2241 return self.__field_zero.getvalue()
2242
2243 def __setfield_zero(self, value):
2244 if isinstance(value,STRING):
2245 self.__field_zero=value
2246 else:
2247 self.__field_zero=STRING(value,**{'sizeinbytes': 8, 'pad': 0, 'default': '' })
2248
2249 def __delfield_zero(self): del self.__field_zero
2250
2251 zero=property(__getfield_zero, __setfield_zero, __delfield_zero, None)
2252
2253 def __getfield_ringtone(self):
2254 try: self.__field_ringtone
2255 except:
2256 self.__field_ringtone=STRING(**{ 'terminator': 0, 'default': '' })
2257 return self.__field_ringtone.getvalue()
2258
2259 def __setfield_ringtone(self, value):
2260 if isinstance(value,STRING):
2261 self.__field_ringtone=value
2262 else:
2263 self.__field_ringtone=STRING(value,**{ 'terminator': 0, 'default': '' })
2264
2265 def __delfield_ringtone(self): del self.__field_ringtone
2266
2267 ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None)
2268
2269 def iscontainer(self):
2270 return True
2271
2272 def containerelements(self):
2273 yield ('number', self.__field_number, None)
2274 yield ('speeddial', self.__field_speeddial, None)
2275 yield ('primary', self.__field_primary, None)
2276 yield ('zero', self.__field_zero, None)
2277 yield ('ringtone', self.__field_ringtone, None)
2278
2279
2280
2281
2282 class ss_pb_entry(BaseProtogenClass):
2283 __fields=['name', 'email', 'email2', 'zero1', 'note', 'zero5', 'wallpaper', 'wallpaper_range', 'zero2', 'home', 'work', 'cell', 'dummy', 'fax', 'cell2', 'zero3', 'group', 'zero4']
2284
2285 def __init__(self, *args, **kwargs):
2286 dict={}
2287 dict.update(kwargs)
2289 super(ss_pb_entry,self).__init__(**dict)
2291 if self.__class__ is ss_pb_entry:
2292 self._update(args,dict)
2293
2294
2295 def getfields(self):
2296 return self.__fields
2297
2298
2299 def _update(self, args, kwargs):
2300 super(ss_pb_entry,self)._update(args,kwargs)
2301 keys=kwargs.keys()
2302 for key in keys:
2303 if key in self.__fields:
2304 setattr(self, key, kwargs[key])
2305 del kwargs[key]
2306 if __debug__:
2308 self._complainaboutunusedargs(ss_pb_entry,kwargs)
2309 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2310
2312
2313 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2314 'Writes this packet to the supplied buffer'
2315 self._bufferstartoffset=buf.getcurrentoffset()
2316 self.__field_name.writetobuffer(buf)
2317 try: self.__field_email
2318 except:
2319 self.__field_email=USTRING(**{ 'terminator': 0, 'encoding': ENCODING, 'default': '', 'maxsizeinbytes': PB_MAX_EMAIL_LEN, 'raiseontruncate': False })
2320 self.__field_email.writetobuffer(buf)
2321 try: self.__field_email2
2322 except:
2323 self.__field_email2=USTRING(**{ 'terminator': 0, 'encoding': ENCODING, 'default': '', 'maxsizeinbytes': PB_MAX_EMAIL_LEN, 'raiseontruncate': False })
2324 self.__field_email2.writetobuffer(buf)
2325 try: self.__field_zero1
2326 except:
2327 self.__field_zero1=UINT(**{'sizeinbytes': 2, 'default': 0 })
2328 self.__field_zero1.writetobuffer(buf)
2329 try: self.__field_note
2330 except:
2331 self.__field_note=USTRING(**{ 'terminator': 0, 'encoding': ENCODING, 'maxsizeinbytes': PB_MAX_NOTE_LEN, 'raiseontruncate': False, 'default': '' })
2332 self.__field_note.writetobuffer(buf)
2333 try: self.__field_zero5
2334 except:
2335 self.__field_zero5=UINT(**{'sizeinbytes': 1, 'default': 0 })
2336 self.__field_zero5.writetobuffer(buf)
2337 try: self.__field_wallpaper
2338 except:
2339 self.__field_wallpaper=STRING(**{ 'terminator': 0, 'default': '' })
2340 self.__field_wallpaper.writetobuffer(buf)
2341 try: self.__field_wallpaper_range
2342 except:
2343 self.__field_wallpaper_range=UINT(**{'sizeinbytes': 4, 'default': 0 })
2344 self.__field_wallpaper_range.writetobuffer(buf)
2345 try: self.__field_zero2
2346 except:
2347 self.__field_zero2=UINT(**{'sizeinbytes': 1, 'default': 0 })
2348 self.__field_zero2.writetobuffer(buf)
2349 try: self.__field_home
2350 except:
2351 self.__field_home=ss_number_entry()
2352 self.__field_home.writetobuffer(buf)
2353 try: self.__field_work
2354 except:
2355 self.__field_work=ss_number_entry()
2356 self.__field_work.writetobuffer(buf)
2357 try: self.__field_cell
2358 except:
2359 self.__field_cell=ss_number_entry()
2360 self.__field_cell.writetobuffer(buf)
2361 try: self.__field_dummy
2362 except:
2363 self.__field_dummy=ss_number_entry()
2364 self.__field_dummy.writetobuffer(buf)
2365 try: self.__field_fax
2366 except:
2367 self.__field_fax=ss_number_entry()
2368 self.__field_fax.writetobuffer(buf)
2369 try: self.__field_cell2
2370 except:
2371 self.__field_cell2=ss_number_entry()
2372 self.__field_cell2.writetobuffer(buf)
2373 try: self.__field_zero3
2374 except:
2375 self.__field_zero3=UINT(**{'sizeinbytes': 4, 'default': 0 })
2376 self.__field_zero3.writetobuffer(buf)
2377 try: self.__field_group
2378 except:
2379 self.__field_group=UINT(**{'sizeinbytes': 1, 'default': 0 })
2380 self.__field_group.writetobuffer(buf)
2381 try: self.__field_zero4
2382 except:
2383 self.__field_zero4=UINT(**{'sizeinbytes': 2, 'default': 0 })
2384 self.__field_zero4.writetobuffer(buf)
2385 self._bufferendoffset=buf.getcurrentoffset()
2386 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2387
2388
2389 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2390 'Reads this packet from the supplied buffer'
2391 self._bufferstartoffset=buf.getcurrentoffset()
2392 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2393 self.__field_name=USTRING(**{ 'terminator': 0, 'maxsizeinbytes': PB_MAX_NAME_LEN, 'encoding': ENCODING, 'raiseontruncate': False })
2394 self.__field_name.readfrombuffer(buf)
2395 self.__field_email=USTRING(**{ 'terminator': 0, 'encoding': ENCODING, 'default': '', 'maxsizeinbytes': PB_MAX_EMAIL_LEN, 'raiseontruncate': False })
2396 self.__field_email.readfrombuffer(buf)
2397 self.__field_email2=USTRING(**{ 'terminator': 0, 'encoding': ENCODING, 'default': '', 'maxsizeinbytes': PB_MAX_EMAIL_LEN, 'raiseontruncate': False })
2398 self.__field_email2.readfrombuffer(buf)
2399 self.__field_zero1=UINT(**{'sizeinbytes': 2, 'default': 0 })
2400 self.__field_zero1.readfrombuffer(buf)
2401 self.__field_note=USTRING(**{ 'terminator': 0, 'encoding': ENCODING, 'maxsizeinbytes': PB_MAX_NOTE_LEN, 'raiseontruncate': False, 'default': '' })
2402 self.__field_note.readfrombuffer(buf)
2403 self.__field_zero5=UINT(**{'sizeinbytes': 1, 'default': 0 })
2404 self.__field_zero5.readfrombuffer(buf)
2405 self.__field_wallpaper=STRING(**{ 'terminator': 0, 'default': '' })
2406 self.__field_wallpaper.readfrombuffer(buf)
2407 self.__field_wallpaper_range=UINT(**{'sizeinbytes': 4, 'default': 0 })
2408 self.__field_wallpaper_range.readfrombuffer(buf)
2409 self.__field_zero2=UINT(**{'sizeinbytes': 1, 'default': 0 })
2410 self.__field_zero2.readfrombuffer(buf)
2411 self.__field_home=ss_number_entry()
2412 self.__field_home.readfrombuffer(buf)
2413 self.__field_work=ss_number_entry()
2414 self.__field_work.readfrombuffer(buf)
2415 self.__field_cell=ss_number_entry()
2416 self.__field_cell.readfrombuffer(buf)
2417 self.__field_dummy=ss_number_entry()
2418 self.__field_dummy.readfrombuffer(buf)
2419 self.__field_fax=ss_number_entry()
2420 self.__field_fax.readfrombuffer(buf)
2421 self.__field_cell2=ss_number_entry()
2422 self.__field_cell2.readfrombuffer(buf)
2423 self.__field_zero3=UINT(**{'sizeinbytes': 4, 'default': 0 })
2424 self.__field_zero3.readfrombuffer(buf)
2425 self.__field_group=UINT(**{'sizeinbytes': 1, 'default': 0 })
2426 self.__field_group.readfrombuffer(buf)
2427 self.__field_zero4=UINT(**{'sizeinbytes': 2, 'default': 0 })
2428 self.__field_zero4.readfrombuffer(buf)
2429 self._bufferendoffset=buf.getcurrentoffset()
2430
2431
2432 def __getfield_name(self):
2433 return self.__field_name.getvalue()
2434
2435 def __setfield_name(self, value):
2436 if isinstance(value,USTRING):
2437 self.__field_name=value
2438 else:
2439 self.__field_name=USTRING(value,**{ 'terminator': 0, 'maxsizeinbytes': PB_MAX_NAME_LEN, 'encoding': ENCODING, 'raiseontruncate': False })
2440
2441 def __delfield_name(self): del self.__field_name
2442
2443 name=property(__getfield_name, __setfield_name, __delfield_name, None)
2444
2445 def __getfield_email(self):
2446 try: self.__field_email
2447 except:
2448 self.__field_email=USTRING(**{ 'terminator': 0, 'encoding': ENCODING, 'default': '', 'maxsizeinbytes': PB_MAX_EMAIL_LEN, 'raiseontruncate': False })
2449 return self.__field_email.getvalue()
2450
2451 def __setfield_email(self, value):
2452 if isinstance(value,USTRING):
2453 self.__field_email=value
2454 else:
2455 self.__field_email=USTRING(value,**{ 'terminator': 0, 'encoding': ENCODING, 'default': '', 'maxsizeinbytes': PB_MAX_EMAIL_LEN, 'raiseontruncate': False })
2456
2457 def __delfield_email(self): del self.__field_email
2458
2459 email=property(__getfield_email, __setfield_email, __delfield_email, None)
2460
2461 def __getfield_email2(self):
2462 try: self.__field_email2
2463 except:
2464 self.__field_email2=USTRING(**{ 'terminator': 0, 'encoding': ENCODING, 'default': '', 'maxsizeinbytes': PB_MAX_EMAIL_LEN, 'raiseontruncate': False })
2465 return self.__field_email2.getvalue()
2466
2467 def __setfield_email2(self, value):
2468 if isinstance(value,USTRING):
2469 self.__field_email2=value
2470 else:
2471 self.__field_email2=USTRING(value,**{ 'terminator': 0, 'encoding': ENCODING, 'default': '', 'maxsizeinbytes': PB_MAX_EMAIL_LEN, 'raiseontruncate': False })
2472
2473 def __delfield_email2(self): del self.__field_email2
2474
2475 email2=property(__getfield_email2, __setfield_email2, __delfield_email2, None)
2476
2477 def __getfield_zero1(self):
2478 try: self.__field_zero1
2479 except:
2480 self.__field_zero1=UINT(**{'sizeinbytes': 2, 'default': 0 })
2481 return self.__field_zero1.getvalue()
2482
2483 def __setfield_zero1(self, value):
2484 if isinstance(value,UINT):
2485 self.__field_zero1=value
2486 else:
2487 self.__field_zero1=UINT(value,**{'sizeinbytes': 2, 'default': 0 })
2488
2489 def __delfield_zero1(self): del self.__field_zero1
2490
2491 zero1=property(__getfield_zero1, __setfield_zero1, __delfield_zero1, None)
2492
2493 def __getfield_note(self):
2494 try: self.__field_note
2495 except:
2496 self.__field_note=USTRING(**{ 'terminator': 0, 'encoding': ENCODING, 'maxsizeinbytes': PB_MAX_NOTE_LEN, 'raiseontruncate': False, 'default': '' })
2497 return self.__field_note.getvalue()
2498
2499 def __setfield_note(self, value):
2500 if isinstance(value,USTRING):
2501 self.__field_note=value
2502 else:
2503 self.__field_note=USTRING(value,**{ 'terminator': 0, 'encoding': ENCODING, 'maxsizeinbytes': PB_MAX_NOTE_LEN, 'raiseontruncate': False, 'default': '' })
2504
2505 def __delfield_note(self): del self.__field_note
2506
2507 note=property(__getfield_note, __setfield_note, __delfield_note, None)
2508
2509 def __getfield_zero5(self):
2510 try: self.__field_zero5
2511 except:
2512 self.__field_zero5=UINT(**{'sizeinbytes': 1, 'default': 0 })
2513 return self.__field_zero5.getvalue()
2514
2515 def __setfield_zero5(self, value):
2516 if isinstance(value,UINT):
2517 self.__field_zero5=value
2518 else:
2519 self.__field_zero5=UINT(value,**{'sizeinbytes': 1, 'default': 0 })
2520
2521 def __delfield_zero5(self): del self.__field_zero5
2522
2523 zero5=property(__getfield_zero5, __setfield_zero5, __delfield_zero5, None)
2524
2525 def __getfield_wallpaper(self):
2526 try: self.__field_wallpaper
2527 except:
2528 self.__field_wallpaper=STRING(**{ 'terminator': 0, 'default': '' })
2529 return self.__field_wallpaper.getvalue()
2530
2531 def __setfield_wallpaper(self, value):
2532 if isinstance(value,STRING):
2533 self.__field_wallpaper=value
2534 else:
2535 self.__field_wallpaper=STRING(value,**{ 'terminator': 0, 'default': '' })
2536
2537 def __delfield_wallpaper(self): del self.__field_wallpaper
2538
2539 wallpaper=property(__getfield_wallpaper, __setfield_wallpaper, __delfield_wallpaper, None)
2540
2541 def __getfield_wallpaper_range(self):
2542 try: self.__field_wallpaper_range
2543 except:
2544 self.__field_wallpaper_range=UINT(**{'sizeinbytes': 4, 'default': 0 })
2545 return self.__field_wallpaper_range.getvalue()
2546
2547 def __setfield_wallpaper_range(self, value):
2548 if isinstance(value,UINT):
2549 self.__field_wallpaper_range=value
2550 else:
2551 self.__field_wallpaper_range=UINT(value,**{'sizeinbytes': 4, 'default': 0 })
2552
2553 def __delfield_wallpaper_range(self): del self.__field_wallpaper_range
2554
2555 wallpaper_range=property(__getfield_wallpaper_range, __setfield_wallpaper_range, __delfield_wallpaper_range, None)
2556
2557 def __getfield_zero2(self):
2558 try: self.__field_zero2
2559 except:
2560 self.__field_zero2=UINT(**{'sizeinbytes': 1, 'default': 0 })
2561 return self.__field_zero2.getvalue()
2562
2563 def __setfield_zero2(self, value):
2564 if isinstance(value,UINT):
2565 self.__field_zero2=value
2566 else:
2567 self.__field_zero2=UINT(value,**{'sizeinbytes': 1, 'default': 0 })
2568
2569 def __delfield_zero2(self): del self.__field_zero2
2570
2571 zero2=property(__getfield_zero2, __setfield_zero2, __delfield_zero2, None)
2572
2573 def __getfield_home(self):
2574 try: self.__field_home
2575 except:
2576 self.__field_home=ss_number_entry()
2577 return self.__field_home.getvalue()
2578
2579 def __setfield_home(self, value):
2580 if isinstance(value,ss_number_entry):
2581 self.__field_home=value
2582 else:
2583 self.__field_home=ss_number_entry(value,)
2584
2585 def __delfield_home(self): del self.__field_home
2586
2587 home=property(__getfield_home, __setfield_home, __delfield_home, None)
2588
2589 def __getfield_work(self):
2590 try: self.__field_work
2591 except:
2592 self.__field_work=ss_number_entry()
2593 return self.__field_work.getvalue()
2594
2595 def __setfield_work(self, value):
2596 if isinstance(value,ss_number_entry):
2597 self.__field_work=value
2598 else:
2599 self.__field_work=ss_number_entry(value,)
2600
2601 def __delfield_work(self): del self.__field_work
2602
2603 work=property(__getfield_work, __setfield_work, __delfield_work, None)
2604
2605 def __getfield_cell(self):
2606 try: self.__field_cell
2607 except:
2608 self.__field_cell=ss_number_entry()
2609 return self.__field_cell.getvalue()
2610
2611 def __setfield_cell(self, value):
2612 if isinstance(value,ss_number_entry):
2613 self.__field_cell=value
2614 else:
2615 self.__field_cell=ss_number_entry(value,)
2616
2617 def __delfield_cell(self): del self.__field_cell
2618
2619 cell=property(__getfield_cell, __setfield_cell, __delfield_cell, None)
2620
2621 def __getfield_dummy(self):
2622 try: self.__field_dummy
2623 except:
2624 self.__field_dummy=ss_number_entry()
2625 return self.__field_dummy.getvalue()
2626
2627 def __setfield_dummy(self, value):
2628 if isinstance(value,ss_number_entry):
2629 self.__field_dummy=value
2630 else:
2631 self.__field_dummy=ss_number_entry(value,)
2632
2633 def __delfield_dummy(self): del self.__field_dummy
2634
2635 dummy=property(__getfield_dummy, __setfield_dummy, __delfield_dummy, None)
2636
2637 def __getfield_fax(self):
2638 try: self.__field_fax
2639 except:
2640 self.__field_fax=ss_number_entry()
2641 return self.__field_fax.getvalue()
2642
2643 def __setfield_fax(self, value):
2644 if isinstance(value,ss_number_entry):
2645 self.__field_fax=value
2646 else:
2647 self.__field_fax=ss_number_entry(value,)
2648
2649 def __delfield_fax(self): del self.__field_fax
2650
2651 fax=property(__getfield_fax, __setfield_fax, __delfield_fax, None)
2652
2653 def __getfield_cell2(self):
2654 try: self.__field_cell2
2655 except:
2656 self.__field_cell2=ss_number_entry()
2657 return self.__field_cell2.getvalue()
2658
2659 def __setfield_cell2(self, value):
2660 if isinstance(value,ss_number_entry):
2661 self.__field_cell2=value
2662 else:
2663 self.__field_cell2=ss_number_entry(value,)
2664
2665 def __delfield_cell2(self): del self.__field_cell2
2666
2667 cell2=property(__getfield_cell2, __setfield_cell2, __delfield_cell2, None)
2668
2669 def __getfield_zero3(self):
2670 try: self.__field_zero3
2671 except:
2672 self.__field_zero3=UINT(**{'sizeinbytes': 4, 'default': 0 })
2673 return self.__field_zero3.getvalue()
2674
2675 def __setfield_zero3(self, value):
2676 if isinstance(value,UINT):
2677 self.__field_zero3=value
2678 else:
2679 self.__field_zero3=UINT(value,**{'sizeinbytes': 4, 'default': 0 })
2680
2681 def __delfield_zero3(self): del self.__field_zero3
2682
2683 zero3=property(__getfield_zero3, __setfield_zero3, __delfield_zero3, None)
2684
2685 def __getfield_group(self):
2686 try: self.__field_group
2687 except:
2688 self.__field_group=UINT(**{'sizeinbytes': 1, 'default': 0 })
2689 return self.__field_group.getvalue()
2690
2691 def __setfield_group(self, value):
2692 if isinstance(value,UINT):
2693 self.__field_group=value
2694 else:
2695 self.__field_group=UINT(value,**{'sizeinbytes': 1, 'default': 0 })
2696
2697 def __delfield_group(self): del self.__field_group
2698
2699 group=property(__getfield_group, __setfield_group, __delfield_group, None)
2700
2701 def __getfield_zero4(self):
2702 try: self.__field_zero4
2703 except:
2704 self.__field_zero4=UINT(**{'sizeinbytes': 2, 'default': 0 })
2705 return self.__field_zero4.getvalue()
2706
2707 def __setfield_zero4(self, value):
2708 if isinstance(value,UINT):
2709 self.__field_zero4=value
2710 else:
2711 self.__field_zero4=UINT(value,**{'sizeinbytes': 2, 'default': 0 })
2712
2713 def __delfield_zero4(self): del self.__field_zero4
2714
2715 zero4=property(__getfield_zero4, __setfield_zero4, __delfield_zero4, None)
2716
2717 def iscontainer(self):
2718 return True
2719
2720 def containerelements(self):
2721 yield ('name', self.__field_name, None)
2722 yield ('email', self.__field_email, None)
2723 yield ('email2', self.__field_email2, None)
2724 yield ('zero1', self.__field_zero1, None)
2725 yield ('note', self.__field_note, None)
2726 yield ('zero5', self.__field_zero5, None)
2727 yield ('wallpaper', self.__field_wallpaper, None)
2728 yield ('wallpaper_range', self.__field_wallpaper_range, None)
2729 yield ('zero2', self.__field_zero2, None)
2730 yield ('home', self.__field_home, None)
2731 yield ('work', self.__field_work, None)
2732 yield ('cell', self.__field_cell, None)
2733 yield ('dummy', self.__field_dummy, None)
2734 yield ('fax', self.__field_fax, None)
2735 yield ('cell2', self.__field_cell2, None)
2736 yield ('zero3', self.__field_zero3, None)
2737 yield ('group', self.__field_group, None)
2738 yield ('zero4', self.__field_zero4, None)
2739
2740
2741
2742
2743 class ss_pb_write_req(BaseProtogenClass):
2744 __fields=['hdr', 'zero', 'entry']
2745
2746 def __init__(self, *args, **kwargs):
2747 dict={}
2748 dict.update(kwargs)
2750 super(ss_pb_write_req,self).__init__(**dict)
2752 if self.__class__ is ss_pb_write_req:
2753 self._update(args,dict)
2754
2755
2756 def getfields(self):
2757 return self.__fields
2758
2759
2760 def _update(self, args, kwargs):
2761 super(ss_pb_write_req,self)._update(args,kwargs)
2762 keys=kwargs.keys()
2763 for key in keys:
2764 if key in self.__fields:
2765 setattr(self, key, kwargs[key])
2766 del kwargs[key]
2767 if __debug__:
2769 self._complainaboutunusedargs(ss_pb_write_req,kwargs)
2770 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2771
2773
2774 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2775 'Writes this packet to the supplied buffer'
2776 self._bufferstartoffset=buf.getcurrentoffset()
2777 try: self.__field_hdr
2778 except:
2779 self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_WRITE })
2780 self.__field_hdr.writetobuffer(buf)
2781 try: self.__field_zero
2782 except:
2783 self.__field_zero=UINT(**{'sizeinbytes': 1, 'default': 0 })
2784 self.__field_zero.writetobuffer(buf)
2785 self.__field_entry.writetobuffer(buf)
2786 self._bufferendoffset=buf.getcurrentoffset()
2787 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2788
2789
2790 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2791 'Reads this packet from the supplied buffer'
2792 self._bufferstartoffset=buf.getcurrentoffset()
2793 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2794 self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_WRITE })
2795 self.__field_hdr.readfrombuffer(buf)
2796 self.__field_zero=UINT(**{'sizeinbytes': 1, 'default': 0 })
2797 self.__field_zero.readfrombuffer(buf)
2798 self.__field_entry=ss_pb_entry()
2799 self.__field_entry.readfrombuffer(buf)
2800 self._bufferendoffset=buf.getcurrentoffset()
2801
2802
2803 def __getfield_hdr(self):
2804 try: self.__field_hdr
2805 except:
2806 self.__field_hdr=ss_cmd_hdr(**{ 'command': SS_CMD_PB_WRITE })
2807 return self.__field_hdr.getvalue()
2808
2809 def __setfield_hdr(self, value):
2810 if isinstance(value,ss_cmd_hdr):
2811 self.__field_hdr=value
2812 else:
2813 self.__field_hdr=ss_cmd_hdr(value,**{ 'command': SS_CMD_PB_WRITE })
2814
2815 def __delfield_hdr(self): del self.__field_hdr
2816
2817 hdr=property(__getfield_hdr, __setfield_hdr, __delfield_hdr, None)
2818
2819 def __getfield_zero(self):
2820 try: self.__field_zero
2821 except:
2822 self.__field_zero=UINT(**{'sizeinbytes': 1, 'default': 0 })
2823 return self.__field_zero.getvalue()
2824
2825 def __setfield_zero(self, value):
2826 if isinstance(value,UINT):
2827 self.__field_zero=value
2828 else:
2829 self.__field_zero=UINT(value,**{'sizeinbytes': 1, 'default': 0 })
2830
2831 def __delfield_zero(self): del self.__field_zero
2832
2833 zero=property(__getfield_zero, __setfield_zero, __delfield_zero, None)
2834
2835 def __getfield_entry(self):
2836 return self.__field_entry.getvalue()
2837
2838 def __setfield_entry(self, value):
2839 if isinstance(value,ss_pb_entry):
2840 self.__field_entry=value
2841 else:
2842 self.__field_entry=ss_pb_entry(value,)
2843
2844 def __delfield_entry(self): del self.__field_entry
2845
2846 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
2847
2848 def iscontainer(self):
2849 return True
2850
2851 def containerelements(self):
2852 yield ('hdr', self.__field_hdr, None)
2853 yield ('zero', self.__field_zero, None)
2854 yield ('entry', self.__field_entry, None)
2855
2856
2857
2858
2859 class ss_pb_write_resp(BaseProtogenClass):
2860 __fields=['hdr', 'zero', 'index']
2861
2862 def __init__(self, *args, **kwargs):
2863 dict={}
2864 dict.update(kwargs)
2866 super(ss_pb_write_resp,self).__init__(**dict)
2868 if self.__class__ is ss_pb_write_resp:
2869 self._update(args,dict)
2870
2871
2872 def getfields(self):
2873 return self.__fields
2874
2875
2876 def _update(self, args, kwargs):
2877 super(ss_pb_write_resp,self)._update(args,kwargs)
2878 keys=kwargs.keys()
2879 for key in keys:
2880 if key in self.__fields:
2881 setattr(self, key, kwargs[key])
2882 del kwargs[key]
2883 if __debug__:
2885 self._complainaboutunusedargs(ss_pb_write_resp,kwargs)
2886 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2887
2889
2890 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2891 'Writes this packet to the supplied buffer'
2892 self._bufferstartoffset=buf.getcurrentoffset()
2893 self.__field_hdr.writetobuffer(buf)
2894 self.__field_zero.writetobuffer(buf)
2895 self.__field_index.writetobuffer(buf)
2896 self._bufferendoffset=buf.getcurrentoffset()
2897 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2898
2899
2900 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2901 'Reads this packet from the supplied buffer'
2902 self._bufferstartoffset=buf.getcurrentoffset()
2903 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2904 self.__field_hdr=ss_cmd_hdr()
2905 self.__field_hdr.readfrombuffer(buf)
2906 self.__field_zero=UINT(**{'sizeinbytes': 1})
2907 self.__field_zero.readfrombuffer(buf)
2908 self.__field_index=UINT(**{'sizeinbytes': 2})
2909