0001 # THIS FILE IS AUTOMATICALLY GENERATED. EDIT THE SOURCE FILE NOT THIS ONE 0002 0003 from prototypes import * 0004 0005 # Make all lg stuff available in this module as well 0006 from p_lg import * 0007 0008 # we are the same as lgvx8500 except as noted below 0009 from p_lgvx8500 import * 0010 0011 # We use LSB for all integer like fields 0012 UINT=UINTlsb 0013 BOOL=BOOLlsb 0014 0015 #Play List stuff 0016 PLIndexFileName='dload/pl_mgr.dat' 0017 PLFilePath='my_music' 0018 PLExt='.vpl' 0019 PLMaxSize=50 # Max number of items per playlist 0020 0021 class call(BaseProtogenClass): 0022 __fields=['GPStime', 'dunno1', 'duration', 'dunno2', 'pbentrynum', 'numberlength', 'dunno3', 'pbnumbertype', 'dunno4', 'name', 'number'] 0023 0024 def __init__(self, *args, **kwargs): 0025 dict={} 0026 # What was supplied to this function 0027 dict.update(kwargs) 0028 # Parent constructor 0029 super(call,self).__init__(**dict) 0030 if self.__class__ is call: 0031 self._update(args,dict) 0032 0033 0034 def getfields(self): 0035 return self.__fields 0036 0037 0038 def _update(self, args, kwargs): 0039 super(call,self)._update(args,kwargs) 0040 keys=kwargs.keys() 0041 for key in keys: 0042 if key in self.__fields: 0043 setattr(self, key, kwargs[key]) 0044 del kwargs[key] 0045 # Were any unrecognized kwargs passed in? 0046 if __debug__: 0047 self._complainaboutunusedargs(call,kwargs) 0048 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 0049 # Make all P fields that haven't already been constructed 0050 0051 0052 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0053 'Writes this packet to the supplied buffer' 0054 self._bufferstartoffset=buf.getcurrentoffset() 0055 self.__field_GPStime.writetobuffer(buf) 0056 self.__field_dunno1.writetobuffer(buf) 0057 self.__field_duration.writetobuffer(buf) 0058 self.__field_dunno2.writetobuffer(buf) 0059 self.__field_pbentrynum.writetobuffer(buf) 0060 self.__field_numberlength.writetobuffer(buf) 0061 self.__field_dunno3.writetobuffer(buf) 0062 self.__field_pbnumbertype.writetobuffer(buf) 0063 self.__field_dunno4.writetobuffer(buf) 0064 self.__field_name.writetobuffer(buf) 0065 self.__field_number.writetobuffer(buf) 0066 self._bufferendoffset=buf.getcurrentoffset() 0067 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0068 0069 0070 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0071 'Reads this packet from the supplied buffer' 0072 self._bufferstartoffset=buf.getcurrentoffset() 0073 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0074 self.__field_GPStime=GPSDATE(**{'sizeinbytes': 4}) 0075 self.__field_GPStime.readfrombuffer(buf) 0076 self.__field_dunno1=UINT(**{'sizeinbytes': 4}) 0077 self.__field_dunno1.readfrombuffer(buf) 0078 self.__field_duration=UINT(**{'sizeinbytes': 4}) 0079 self.__field_duration.readfrombuffer(buf) 0080 self.__field_dunno2=UINT(**{'sizeinbytes': 2}) 0081 self.__field_dunno2.readfrombuffer(buf) 0082 self.__field_pbentrynum=UINT(**{'sizeinbytes': 2}) 0083 self.__field_pbentrynum.readfrombuffer(buf) 0084 self.__field_numberlength=UINT(**{'sizeinbytes': 1}) 0085 self.__field_numberlength.readfrombuffer(buf) 0086 self.__field_dunno3=UINT(**{'sizeinbytes': 1}) 0087 self.__field_dunno3.readfrombuffer(buf) 0088 self.__field_pbnumbertype=UINT(**{'sizeinbytes': 1}) 0089 self.__field_pbnumbertype.readfrombuffer(buf) 0090 self.__field_dunno4=UINT(**{'sizeinbytes': 2}) 0091 self.__field_dunno4.readfrombuffer(buf) 0092 self.__field_name=USTRING(**{'sizeinbytes': 36, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 0093 self.__field_name.readfrombuffer(buf) 0094 self.__field_number=USTRING(**{'sizeinbytes': 49, 'raiseonunterminatedread': False}) 0095 self.__field_number.readfrombuffer(buf) 0096 self._bufferendoffset=buf.getcurrentoffset() 0097 0098 0099 def __getfield_GPStime(self): 0100 return self.__field_GPStime.getvalue() 0101 0102 def __setfield_GPStime(self, value): 0103 if isinstance(value,GPSDATE): 0104 self.__field_GPStime=value 0105 else: 0106 self.__field_GPStime=GPSDATE(value,**{'sizeinbytes': 4}) 0107 0108 def __delfield_GPStime(self): del self.__field_GPStime 0109 0110 GPStime=property(__getfield_GPStime, __setfield_GPStime, __delfield_GPStime, None) 0111 0112 def __getfield_dunno1(self): 0113 return self.__field_dunno1.getvalue() 0114 0115 def __setfield_dunno1(self, value): 0116 if isinstance(value,UINT): 0117 self.__field_dunno1=value 0118 else: 0119 self.__field_dunno1=UINT(value,**{'sizeinbytes': 4}) 0120 0121 def __delfield_dunno1(self): del self.__field_dunno1 0122 0123 dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None) 0124 0125 def __getfield_duration(self): 0126 return self.__field_duration.getvalue() 0127 0128 def __setfield_duration(self, value): 0129 if isinstance(value,UINT): 0130 self.__field_duration=value 0131 else: 0132 self.__field_duration=UINT(value,**{'sizeinbytes': 4}) 0133 0134 def __delfield_duration(self): del self.__field_duration 0135 0136 duration=property(__getfield_duration, __setfield_duration, __delfield_duration, None) 0137 0138 def __getfield_dunno2(self): 0139 return self.__field_dunno2.getvalue() 0140 0141 def __setfield_dunno2(self, value): 0142 if isinstance(value,UINT): 0143 self.__field_dunno2=value 0144 else: 0145 self.__field_dunno2=UINT(value,**{'sizeinbytes': 2}) 0146 0147 def __delfield_dunno2(self): del self.__field_dunno2 0148 0149 dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None) 0150 0151 def __getfield_pbentrynum(self): 0152 return self.__field_pbentrynum.getvalue() 0153 0154 def __setfield_pbentrynum(self, value): 0155 if isinstance(value,UINT): 0156 self.__field_pbentrynum=value 0157 else: 0158 self.__field_pbentrynum=UINT(value,**{'sizeinbytes': 2}) 0159 0160 def __delfield_pbentrynum(self): del self.__field_pbentrynum 0161 0162 pbentrynum=property(__getfield_pbentrynum, __setfield_pbentrynum, __delfield_pbentrynum, None) 0163 0164 def __getfield_numberlength(self): 0165 return self.__field_numberlength.getvalue() 0166 0167 def __setfield_numberlength(self, value): 0168 if isinstance(value,UINT): 0169 self.__field_numberlength=value 0170 else: 0171 self.__field_numberlength=UINT(value,**{'sizeinbytes': 1}) 0172 0173 def __delfield_numberlength(self): del self.__field_numberlength 0174 0175 numberlength=property(__getfield_numberlength, __setfield_numberlength, __delfield_numberlength, None) 0176 0177 def __getfield_dunno3(self): 0178 return self.__field_dunno3.getvalue() 0179 0180 def __setfield_dunno3(self, value): 0181 if isinstance(value,UINT): 0182 self.__field_dunno3=value 0183 else: 0184 self.__field_dunno3=UINT(value,**{'sizeinbytes': 1}) 0185 0186 def __delfield_dunno3(self): del self.__field_dunno3 0187 0188 dunno3=property(__getfield_dunno3, __setfield_dunno3, __delfield_dunno3, None) 0189 0190 def __getfield_pbnumbertype(self): 0191 return self.__field_pbnumbertype.getvalue() 0192 0193 def __setfield_pbnumbertype(self, value): 0194 if isinstance(value,UINT): 0195 self.__field_pbnumbertype=value 0196 else: 0197 self.__field_pbnumbertype=UINT(value,**{'sizeinbytes': 1}) 0198 0199 def __delfield_pbnumbertype(self): del self.__field_pbnumbertype 0200 0201 pbnumbertype=property(__getfield_pbnumbertype, __setfield_pbnumbertype, __delfield_pbnumbertype, None) 0202 0203 def __getfield_dunno4(self): 0204 return self.__field_dunno4.getvalue() 0205 0206 def __setfield_dunno4(self, value): 0207 if isinstance(value,UINT): 0208 self.__field_dunno4=value 0209 else: 0210 self.__field_dunno4=UINT(value,**{'sizeinbytes': 2}) 0211 0212 def __delfield_dunno4(self): del self.__field_dunno4 0213 0214 dunno4=property(__getfield_dunno4, __setfield_dunno4, __delfield_dunno4, None) 0215 0216 def __getfield_name(self): 0217 return self.__field_name.getvalue() 0218 0219 def __setfield_name(self, value): 0220 if isinstance(value,USTRING): 0221 self.__field_name=value 0222 else: 0223 self.__field_name=USTRING(value,**{'sizeinbytes': 36, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 0224 0225 def __delfield_name(self): del self.__field_name 0226 0227 name=property(__getfield_name, __setfield_name, __delfield_name, None) 0228 0229 def __getfield_number(self): 0230 return self.__field_number.getvalue() 0231 0232 def __setfield_number(self, value): 0233 if isinstance(value,USTRING): 0234 self.__field_number=value 0235 else: 0236 self.__field_number=USTRING(value,**{'sizeinbytes': 49, 'raiseonunterminatedread': False}) 0237 0238 def __delfield_number(self): del self.__field_number 0239 0240 number=property(__getfield_number, __setfield_number, __delfield_number, None) 0241 0242 def iscontainer(self): 0243 return True 0244 0245 def containerelements(self): 0246 yield ('GPStime', self.__field_GPStime, None) 0247 yield ('dunno1', self.__field_dunno1, None) 0248 yield ('duration', self.__field_duration, None) 0249 yield ('dunno2', self.__field_dunno2, None) 0250 yield ('pbentrynum', self.__field_pbentrynum, None) 0251 yield ('numberlength', self.__field_numberlength, None) 0252 yield ('dunno3', self.__field_dunno3, None) 0253 yield ('pbnumbertype', self.__field_pbnumbertype, None) 0254 yield ('dunno4', self.__field_dunno4, None) 0255 yield ('name', self.__field_name, None) 0256 yield ('number', self.__field_number, None) 0257 0258 0259 0260 0261 class callhistory(BaseProtogenClass): 0262 __fields=['numcalls', 'unknown1', 'calls'] 0263 0264 def __init__(self, *args, **kwargs): 0265 dict={} 0266 # What was supplied to this function 0267 dict.update(kwargs) 0268 # Parent constructor 0269 super(callhistory,self).__init__(**dict) 0270 if self.__class__ is callhistory: 0271 self._update(args,dict) 0272 0273 0274 def getfields(self): 0275 return self.__fields 0276 0277 0278 def _update(self, args, kwargs): 0279 super(callhistory,self)._update(args,kwargs) 0280 keys=kwargs.keys() 0281 for key in keys: 0282 if key in self.__fields: 0283 setattr(self, key, kwargs[key]) 0284 del kwargs[key] 0285 # Were any unrecognized kwargs passed in? 0286 if __debug__: 0287 self._complainaboutunusedargs(callhistory,kwargs) 0288 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 0289 # Make all P fields that haven't already been constructed 0290 0291 0292 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0293 'Writes this packet to the supplied buffer' 0294 self._bufferstartoffset=buf.getcurrentoffset() 0295 self.__field_numcalls.writetobuffer(buf) 0296 self.__field_unknown1.writetobuffer(buf) 0297 try: self.__field_calls 0298 except: 0299 self.__field_calls=LIST(**{'elementclass': call}) 0300 self.__field_calls.writetobuffer(buf) 0301 self._bufferendoffset=buf.getcurrentoffset() 0302 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0303 0304 0305 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0306 'Reads this packet from the supplied buffer' 0307 self._bufferstartoffset=buf.getcurrentoffset() 0308 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0309 self.__field_numcalls=UINT(**{'sizeinbytes': 4}) 0310 self.__field_numcalls.readfrombuffer(buf) 0311 self.__field_unknown1=UINT(**{'sizeinbytes': 1}) 0312 self.__field_unknown1.readfrombuffer(buf) 0313 self.__field_calls=LIST(**{'elementclass': call}) 0314 self.__field_calls.readfrombuffer(buf) 0315 self._bufferendoffset=buf.getcurrentoffset() 0316 0317 0318 def __getfield_numcalls(self): 0319 return self.__field_numcalls.getvalue() 0320 0321 def __setfield_numcalls(self, value): 0322 if isinstance(value,UINT): 0323 self.__field_numcalls=value 0324 else: 0325 self.__field_numcalls=UINT(value,**{'sizeinbytes': 4}) 0326 0327 def __delfield_numcalls(self): del self.__field_numcalls 0328 0329 numcalls=property(__getfield_numcalls, __setfield_numcalls, __delfield_numcalls, None) 0330 0331 def __getfield_unknown1(self): 0332 return self.__field_unknown1.getvalue() 0333 0334 def __setfield_unknown1(self, value): 0335 if isinstance(value,UINT): 0336 self.__field_unknown1=value 0337 else: 0338 self.__field_unknown1=UINT(value,**{'sizeinbytes': 1}) 0339 0340 def __delfield_unknown1(self): del self.__field_unknown1 0341 0342 unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None) 0343 0344 def __getfield_calls(self): 0345 try: self.__field_calls 0346 except: 0347 self.__field_calls=LIST(**{'elementclass': call}) 0348 return self.__field_calls.getvalue() 0349 0350 def __setfield_calls(self, value): 0351 if isinstance(value,LIST): 0352 self.__field_calls=value 0353 else: 0354 self.__field_calls=LIST(value,**{'elementclass': call}) 0355 0356 def __delfield_calls(self): del self.__field_calls 0357 0358 calls=property(__getfield_calls, __setfield_calls, __delfield_calls, None) 0359 0360 def iscontainer(self): 0361 return True 0362 0363 def containerelements(self): 0364 yield ('numcalls', self.__field_numcalls, None) 0365 yield ('unknown1', self.__field_unknown1, None) 0366 yield ('calls', self.__field_calls, None) 0367 0368 0369 0370 0371 class PLIndexEntry(BaseProtogenClass): 0372 __fields=['pathname', 'dunno'] 0373 0374 def __init__(self, *args, **kwargs): 0375 dict={} 0376 # What was supplied to this function 0377 dict.update(kwargs) 0378 # Parent constructor 0379 super(PLIndexEntry,self).__init__(**dict) 0380 if self.__class__ is PLIndexEntry: 0381 self._update(args,dict) 0382 0383 0384 def getfields(self): 0385 return self.__fields 0386 0387 0388 def _update(self, args, kwargs): 0389 super(PLIndexEntry,self)._update(args,kwargs) 0390 keys=kwargs.keys() 0391 for key in keys: 0392 if key in self.__fields: 0393 setattr(self, key, kwargs[key]) 0394 del kwargs[key] 0395 # Were any unrecognized kwargs passed in? 0396 if __debug__: 0397 self._complainaboutunusedargs(PLIndexEntry,kwargs) 0398 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 0399 # Make all P fields that haven't already been constructed 0400 0401 0402 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0403 'Writes this packet to the supplied buffer' 0404 self._bufferstartoffset=buf.getcurrentoffset() 0405 self.__field_pathname.writetobuffer(buf) 0406 try: self.__field_dunno 0407 except: 0408 self.__field_dunno=UINT(**{'sizeinbytes': 4, 'default': 0x105 }) 0409 self.__field_dunno.writetobuffer(buf) 0410 self._bufferendoffset=buf.getcurrentoffset() 0411 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0412 0413 0414 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0415 'Reads this packet from the supplied buffer' 0416 self._bufferstartoffset=buf.getcurrentoffset() 0417 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0418 self.__field_pathname=USTRING(**{'sizeinbytes': 264, 'encoding': PHONE_ENCODING }) 0419 self.__field_pathname.readfrombuffer(buf) 0420 self.__field_dunno=UINT(**{'sizeinbytes': 4, 'default': 0x105 }) 0421 self.__field_dunno.readfrombuffer(buf) 0422 self._bufferendoffset=buf.getcurrentoffset() 0423 0424 0425 def __getfield_pathname(self): 0426 return self.__field_pathname.getvalue() 0427 0428 def __setfield_pathname(self, value): 0429 if isinstance(value,USTRING): 0430 self.__field_pathname=value 0431 else: 0432 self.__field_pathname=USTRING(value,**{'sizeinbytes': 264, 'encoding': PHONE_ENCODING }) 0433 0434 def __delfield_pathname(self): del self.__field_pathname 0435 0436 pathname=property(__getfield_pathname, __setfield_pathname, __delfield_pathname, None) 0437 0438 def __getfield_dunno(self): 0439 try: self.__field_dunno 0440 except: 0441 self.__field_dunno=UINT(**{'sizeinbytes': 4, 'default': 0x105 }) 0442 return self.__field_dunno.getvalue() 0443 0444 def __setfield_dunno(self, value): 0445 if isinstance(value,UINT): 0446 self.__field_dunno=value 0447 else: 0448 self.__field_dunno=UINT(value,**{'sizeinbytes': 4, 'default': 0x105 }) 0449 0450 def __delfield_dunno(self): del self.__field_dunno 0451 0452 dunno=property(__getfield_dunno, __setfield_dunno, __delfield_dunno, None) 0453 0454 def iscontainer(self): 0455 return True 0456 0457 def containerelements(self): 0458 yield ('pathname', self.__field_pathname, None) 0459 yield ('dunno', self.__field_dunno, None) 0460 0461 0462 0463 0464 class PLIndexFile(BaseProtogenClass): 0465 __fields=['items'] 0466 0467 def __init__(self, *args, **kwargs): 0468 dict={} 0469 # What was supplied to this function 0470 dict.update(kwargs) 0471 # Parent constructor 0472 super(PLIndexFile,self).__init__(**dict) 0473 if self.__class__ is PLIndexFile: 0474 self._update(args,dict) 0475 0476 0477 def getfields(self): 0478 return self.__fields 0479 0480 0481 def _update(self, args, kwargs): 0482 super(PLIndexFile,self)._update(args,kwargs) 0483 keys=kwargs.keys() 0484 for key in keys: 0485 if key in self.__fields: 0486 setattr(self, key, kwargs[key]) 0487 del kwargs[key] 0488 # Were any unrecognized kwargs passed in? 0489 if __debug__: 0490 self._complainaboutunusedargs(PLIndexFile,kwargs) 0491 if len(args): 0492 dict2={ 'elementclass': PLIndexEntry, 'createdefault': True } 0493 dict2.update(kwargs) 0494 kwargs=dict2 0495 self.__field_items=LIST(*args,**dict2) 0496 # Make all P fields that haven't already been constructed 0497 0498 0499 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0500 'Writes this packet to the supplied buffer' 0501 self._bufferstartoffset=buf.getcurrentoffset() 0502 try: self.__field_items 0503 except: 0504 self.__field_items=LIST(**{ 'elementclass': PLIndexEntry, 'createdefault': True }) 0505 self.__field_items.writetobuffer(buf) 0506 self._bufferendoffset=buf.getcurrentoffset() 0507 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0508 0509 0510 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0511 'Reads this packet from the supplied buffer' 0512 self._bufferstartoffset=buf.getcurrentoffset() 0513 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0514 self.__field_items=LIST(**{ 'elementclass': PLIndexEntry, 'createdefault': True }) 0515 self.__field_items.readfrombuffer(buf) 0516 self._bufferendoffset=buf.getcurrentoffset() 0517 0518 0519 def __getfield_items(self): 0520 try: self.__field_items 0521 except: 0522 self.__field_items=LIST(**{ 'elementclass': PLIndexEntry, 'createdefault': True }) 0523 return self.__field_items.getvalue() 0524 0525 def __setfield_items(self, value): 0526 if isinstance(value,LIST): 0527 self.__field_items=value 0528 else: 0529 self.__field_items=LIST(value,**{ 'elementclass': PLIndexEntry, 'createdefault': True }) 0530 0531 def __delfield_items(self): del self.__field_items 0532 0533 items=property(__getfield_items, __setfield_items, __delfield_items, None) 0534 0535 def iscontainer(self): 0536 return True 0537 0538 def containerelements(self): 0539 yield ('items', self.__field_items, None) 0540 0541 0542 0543 0544 class PLSongEntry(BaseProtogenClass): 0545 __fields=['pathname', 'tunename', 'artistname', 'albumname', 'genre', 'dunno1', 'date', 'size', 'zero'] 0546 0547 def __init__(self, *args, **kwargs): 0548 dict={} 0549 # What was supplied to this function 0550 dict.update(kwargs) 0551 # Parent constructor 0552 super(PLSongEntry,self).__init__(**dict) 0553 if self.__class__ is PLSongEntry: 0554 self._update(args,dict) 0555 0556 0557 def getfields(self): 0558 return self.__fields 0559 0560 0561 def _update(self, args, kwargs): 0562 super(PLSongEntry,self)._update(args,kwargs) 0563 keys=kwargs.keys() 0564 for key in keys: 0565 if key in self.__fields: 0566 setattr(self, key, kwargs[key]) 0567 del kwargs[key] 0568 # Were any unrecognized kwargs passed in? 0569 if __debug__: 0570 self._complainaboutunusedargs(PLSongEntry,kwargs) 0571 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 0572 # Make all P fields that haven't already been constructed 0573 0574 0575 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0576 'Writes this packet to the supplied buffer' 0577 self._bufferstartoffset=buf.getcurrentoffset() 0578 self.__field_pathname.writetobuffer(buf) 0579 try: self.__field_tunename 0580 except: 0581 self.__field_tunename=USTRING(**{'sizeinbytes': 255, 'encoding': PHONE_ENCODING, 'default': self.pathname }) 0582 self.__field_tunename.writetobuffer(buf) 0583 try: self.__field_artistname 0584 except: 0585 self.__field_artistname=USTRING(**{'sizeinbytes': 100, 'encoding': PHONE_ENCODING, 'default': 'Unknown' }) 0586 self.__field_artistname.writetobuffer(buf) 0587 try: self.__field_albumname 0588 except: 0589 self.__field_albumname=USTRING(**{'sizeinbytes': 100, 'encoding': PHONE_ENCODING, 'default': 'Unknown' }) 0590 self.__field_albumname.writetobuffer(buf) 0591 try: self.__field_genre 0592 except: 0593 self.__field_genre=USTRING(**{'sizeinbytes': 102, 'encoding': PHONE_ENCODING, 'default': 'Unknown' }) 0594 self.__field_genre.writetobuffer(buf) 0595 try: self.__field_dunno1 0596 except: 0597 self.__field_dunno1=UINT(**{'sizeinbytes': 4, 'default': 2 }) 0598 self.__field_dunno1.writetobuffer(buf) 0599 try: self.__field_date 0600 except: 0601 self.__field_date=GPSDATE(**{'sizeinbytes': 4, 'default': GPSDATE.now() }) 0602 self.__field_date.writetobuffer(buf) 0603 self.__field_size.writetobuffer(buf) 0604 try: self.__field_zero 0605 except: 0606 self.__field_zero=UINT(**{'sizeinbytes': 4, 'default': 0 }) 0607 self.__field_zero.writetobuffer(buf) 0608 self._bufferendoffset=buf.getcurrentoffset() 0609 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0610 0611 0612 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0613 'Reads this packet from the supplied buffer' 0614 self._bufferstartoffset=buf.getcurrentoffset() 0615 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0616 self.__field_pathname=USTRING(**{'sizeinbytes': 255, 'encoding': PHONE_ENCODING }) 0617 self.__field_pathname.readfrombuffer(buf) 0618 self.__field_tunename=USTRING(**{'sizeinbytes': 255, 'encoding': PHONE_ENCODING, 'default': self.pathname }) 0619 self.__field_tunename.readfrombuffer(buf) 0620 self.__field_artistname=USTRING(**{'sizeinbytes': 100, 'encoding': PHONE_ENCODING, 'default': 'Unknown' }) 0621 self.__field_artistname.readfrombuffer(buf) 0622 self.__field_albumname=USTRING(**{'sizeinbytes': 100, 'encoding': PHONE_ENCODING, 'default': 'Unknown' }) 0623 self.__field_albumname.readfrombuffer(buf) 0624 self.__field_genre=USTRING(**{'sizeinbytes': 102, 'encoding': PHONE_ENCODING, 'default': 'Unknown' }) 0625 self.__field_genre.readfrombuffer(buf) 0626 self.__field_dunno1=UINT(**{'sizeinbytes': 4, 'default': 2 }) 0627 self.__field_dunno1.readfrombuffer(buf) 0628 self.__field_date=GPSDATE(**{'sizeinbytes': 4, 'default': GPSDATE.now() }) 0629 self.__field_date.readfrombuffer(buf) 0630 self.__field_size=UINT(**{'sizeinbytes': 4}) 0631 self.__field_size.readfrombuffer(buf) 0632 self.__field_zero=UINT(**{'sizeinbytes': 4, 'default': 0 }) 0633 self.__field_zero.readfrombuffer(buf) 0634 self._bufferendoffset=buf.getcurrentoffset() 0635 0636 0637 def __getfield_pathname(self): 0638 return self.__field_pathname.getvalue() 0639 0640 def __setfield_pathname(self, value): 0641 if isinstance(value,USTRING): 0642 self.__field_pathname=value 0643 else: 0644 self.__field_pathname=USTRING(value,**{'sizeinbytes': 255, 'encoding': PHONE_ENCODING }) 0645 0646 def __delfield_pathname(self): del self.__field_pathname 0647 0648 pathname=property(__getfield_pathname, __setfield_pathname, __delfield_pathname, None) 0649 0650 def __getfield_tunename(self): 0651 try: self.__field_tunename 0652 except: 0653 self.__field_tunename=USTRING(**{'sizeinbytes': 255, 'encoding': PHONE_ENCODING, 'default': self.pathname }) 0654 return self.__field_tunename.getvalue() 0655 0656 def __setfield_tunename(self, value): 0657 if isinstance(value,USTRING): 0658 self.__field_tunename=value 0659 else: 0660 self.__field_tunename=USTRING(value,**{'sizeinbytes': 255, 'encoding': PHONE_ENCODING, 'default': self.pathname }) 0661 0662 def __delfield_tunename(self): del self.__field_tunename 0663 0664 tunename=property(__getfield_tunename, __setfield_tunename, __delfield_tunename, None) 0665 0666 def __getfield_artistname(self): 0667 try: self.__field_artistname 0668 except: 0669 self.__field_artistname=USTRING(**{'sizeinbytes': 100, 'encoding': PHONE_ENCODING, 'default': 'Unknown' }) 0670 return self.__field_artistname.getvalue() 0671 0672 def __setfield_artistname(self, value): 0673 if isinstance(value,USTRING): 0674 self.__field_artistname=value 0675 else: 0676 self.__field_artistname=USTRING(value,**{'sizeinbytes': 100, 'encoding': PHONE_ENCODING, 'default': 'Unknown' }) 0677 0678 def __delfield_artistname(self): del self.__field_artistname 0679 0680 artistname=property(__getfield_artistname, __setfield_artistname, __delfield_artistname, None) 0681 0682 def __getfield_albumname(self): 0683 try: self.__field_albumname 0684 except: 0685 self.__field_albumname=USTRING(**{'sizeinbytes': 100, 'encoding': PHONE_ENCODING, 'default': 'Unknown' }) 0686 return self.__field_albumname.getvalue() 0687 0688 def __setfield_albumname(self, value): 0689 if isinstance(value,USTRING): 0690 self.__field_albumname=value 0691 else: 0692 self.__field_albumname=USTRING(value,**{'sizeinbytes': 100, 'encoding': PHONE_ENCODING, 'default': 'Unknown' }) 0693 0694 def __delfield_albumname(self): del self.__field_albumname 0695 0696 albumname=property(__getfield_albumname, __setfield_albumname, __delfield_albumname, None) 0697 0698 def __getfield_genre(self): 0699 try: self.__field_genre 0700 except: 0701 self.__field_genre=USTRING(**{'sizeinbytes': 102, 'encoding': PHONE_ENCODING, 'default': 'Unknown' }) 0702 return self.__field_genre.getvalue() 0703 0704 def __setfield_genre(self, value): 0705 if isinstance(value,USTRING): 0706 self.__field_genre=value 0707 else: 0708 self.__field_genre=USTRING(value,**{'sizeinbytes': 102, 'encoding': PHONE_ENCODING, 'default': 'Unknown' }) 0709 0710 def __delfield_genre(self): del self.__field_genre 0711 0712 genre=property(__getfield_genre, __setfield_genre, __delfield_genre, None) 0713 0714 def __getfield_dunno1(self): 0715 try: self.__field_dunno1 0716 except: 0717 self.__field_dunno1=UINT(**{'sizeinbytes': 4, 'default': 2 }) 0718 return self.__field_dunno1.getvalue() 0719 0720 def __setfield_dunno1(self, value): 0721 if isinstance(value,UINT): 0722 self.__field_dunno1=value 0723 else: 0724 self.__field_dunno1=UINT(value,**{'sizeinbytes': 4, 'default': 2 }) 0725 0726 def __delfield_dunno1(self): del self.__field_dunno1 0727 0728 dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None) 0729 0730 def __getfield_date(self): 0731 try: self.__field_date 0732 except: 0733 self.__field_date=GPSDATE(**{'sizeinbytes': 4, 'default': GPSDATE.now() }) 0734 return self.__field_date.getvalue() 0735 0736 def __setfield_date(self, value): 0737 if isinstance(value,GPSDATE): 0738 self.__field_date=value 0739 else: 0740 self.__field_date=GPSDATE(value,**{'sizeinbytes': 4, 'default': GPSDATE.now() }) 0741 0742 def __delfield_date(self): del self.__field_date 0743 0744 date=property(__getfield_date, __setfield_date, __delfield_date, None) 0745 0746 def __getfield_size(self): 0747 return self.__field_size.getvalue() 0748 0749 def __setfield_size(self, value): 0750 if isinstance(value,UINT): 0751 self.__field_size=value 0752 else: 0753 self.__field_size=UINT(value,**{'sizeinbytes': 4}) 0754 0755 def __delfield_size(self): del self.__field_size 0756 0757 size=property(__getfield_size, __setfield_size, __delfield_size, None) 0758 0759 def __getfield_zero(self): 0760 try: self.__field_zero 0761 except: 0762 self.__field_zero=UINT(**{'sizeinbytes': 4, 'default': 0 }) 0763 return self.__field_zero.getvalue() 0764 0765 def __setfield_zero(self, value): 0766 if isinstance(value,UINT): 0767 self.__field_zero=value 0768 else: 0769 self.__field_zero=UINT(value,**{'sizeinbytes': 4, 'default': 0 }) 0770 0771 def __delfield_zero(self): del self.__field_zero 0772 0773 zero=property(__getfield_zero, __setfield_zero, __delfield_zero, None) 0774 0775 def iscontainer(self): 0776 return True 0777 0778 def containerelements(self): 0779 yield ('pathname', self.__field_pathname, None) 0780 yield ('tunename', self.__field_tunename, None) 0781 yield ('artistname', self.__field_artistname, None) 0782 yield ('albumname', self.__field_albumname, None) 0783 yield ('genre', self.__field_genre, None) 0784 yield ('dunno1', self.__field_dunno1, None) 0785 yield ('date', self.__field_date, None) 0786 yield ('size', self.__field_size, None) 0787 yield ('zero', self.__field_zero, None) 0788 0789 0790 0791 0792 class PLPlayListFile(BaseProtogenClass): 0793 __fields=['items'] 0794 0795 def __init__(self, *args, **kwargs): 0796 dict={} 0797 # What was supplied to this function 0798 dict.update(kwargs) 0799 # Parent constructor 0800 super(PLPlayListFile,self).__init__(**dict) 0801 if self.__class__ is PLPlayListFile: 0802 self._update(args,dict) 0803 0804 0805 def getfields(self): 0806 return self.__fields 0807 0808 0809 def _update(self, args, kwargs): 0810 super(PLPlayListFile,self)._update(args,kwargs) 0811 keys=kwargs.keys() 0812 for key in keys: 0813 if key in self.__fields: 0814 setattr(self, key, kwargs[key]) 0815 del kwargs[key] 0816 # Were any unrecognized kwargs passed in? 0817 if __debug__: 0818 self._complainaboutunusedargs(PLPlayListFile,kwargs) 0819 if len(args): 0820 dict2={ 'elementclass': PLSongEntry, 'createdefault': True } 0821 dict2.update(kwargs) 0822 kwargs=dict2 0823 self.__field_items=LIST(*args,**dict2) 0824 # Make all P fields that haven't already been constructed 0825 0826 0827 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0828 'Writes this packet to the supplied buffer' 0829 self._bufferstartoffset=buf.getcurrentoffset() 0830 try: self.__field_items 0831 except: 0832 self.__field_items=LIST(**{ 'elementclass': PLSongEntry, 'createdefault': True }) 0833 self.__field_items.writetobuffer(buf) 0834 self._bufferendoffset=buf.getcurrentoffset() 0835 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0836 0837 0838 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0839 'Reads this packet from the supplied buffer' 0840 self._bufferstartoffset=buf.getcurrentoffset() 0841 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0842 self.__field_items=LIST(**{ 'elementclass': PLSongEntry, 'createdefault': True }) 0843 self.__field_items.readfrombuffer(buf) 0844 self._bufferendoffset=buf.getcurrentoffset() 0845 0846 0847 def __getfield_items(self): 0848 try: self.__field_items 0849 except: 0850 self.__field_items=LIST(**{ 'elementclass': PLSongEntry, 'createdefault': True }) 0851 return self.__field_items.getvalue() 0852 0853 def __setfield_items(self, value): 0854 if isinstance(value,LIST): 0855 self.__field_items=value 0856 else: 0857 self.__field_items=LIST(value,**{ 'elementclass': PLSongEntry, 'createdefault': True }) 0858 0859 def __delfield_items(self): del self.__field_items 0860 0861 items=property(__getfield_items, __setfield_items, __delfield_items, None) 0862 0863 def iscontainer(self): 0864 return True 0865 0866 def containerelements(self): 0867 yield ('items', self.__field_items, None) 0868 0869 0870 0871 0872
Generated by PyXR 0.9.4