phones.p_lgvx4600

1 # THIS FILE IS AUTOMATICALLY GENERATED. EDIT THE SOURCE FILE NOT THIS ONE 2 3 """Various descriptions of data specific to LG VX4600""" 4 5 from prototypes import * 6 7 # Make all lg stuff available in this module as well 8 from p_lg import * 9 10 # we are the same as lgvx4400 except as noted 11 # below 12 from p_lgvx4400 import * 13 14 # We use LSB for all integer like fields 15 UINT=UINTlsb 16 BOOL=BOOLlsb 17 18 NUMSPEEDDIALS=100 19 FIRSTSPEEDDIAL=1 20 LASTSPEEDDIAL=99 21 NUMPHONEBOOKENTRIES=500 22 MAXCALENDARDESCRIPTION=38 23 24 NUMEMAILS=1 25 NUMPHONENUMBERS=5 26 27 MEMOLENGTH=49

28 -class mediadesc(BaseProtogenClass):

29 __fields=['totalsize', 'dunno1', 'index', 'magic1', 'magic2', 'magic3', 'dunno2', 'filename', 'whoknows', 'mimetype', 'whoknows2'] 30

31 - def __init__(self, *args, **kwargs):

32 dict={} 33 # What was supplied to this function 34 dict.update(kwargs) 35 # Parent constructor 36 super(mediadesc,self).__init__(**dict) 37 if self.__class__ is mediadesc: 38 self._update(args,dict)

39 40

41 - def getfields(self):

42 return self.__fields

43 44

45 - def _update(self, args, kwargs):

46 super(mediadesc,self)._update(args,kwargs) 47 keys=kwargs.keys() 48 for key in keys: 49 if key in self.__fields: 50 setattr(self, key, kwargs[key]) 51 del kwargs[key] 52 # Were any unrecognized kwargs passed in? 53 if __debug__: 54 self._complainaboutunusedargs(mediadesc,kwargs) 55 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

56 # Make all P fields that haven't already been constructed 57 58

59 - def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):

60 'Writes this packet to the supplied buffer' 61 self._bufferstartoffset=buf.getcurrentoffset() 62 self.__field_totalsize.writetobuffer(buf) 63 try: self.__field_dunno1 64 except: 65 self.__field_dunno1=UINT(**{'sizeinbytes': 4, 'constant': 0}) 66 self.__field_dunno1.writetobuffer(buf) 67 self.__field_index.writetobuffer(buf) 68 try: self.__field_magic1 69 except: 70 self.__field_magic1=UINT(**{'sizeinbytes': 4, 'default': 0x7824c97a}) 71 self.__field_magic1.writetobuffer(buf) 72 try: self.__field_magic2 73 except: 74 self.__field_magic2=UINT(**{'sizeinbytes': 4, 'default': 0x7824c97a}) 75 self.__field_magic2.writetobuffer(buf) 76 try: self.__field_magic3 77 except: 78 self.__field_magic3=UINT(**{'sizeinbytes': 4, 'default': 0x7824c97a}) 79 self.__field_magic3.writetobuffer(buf) 80 try: self.__field_dunno2 81 except: 82 self.__field_dunno2=UINT(**{'sizeinbytes': 4, 'constant': 0}) 83 self.__field_dunno2.writetobuffer(buf) 84 self.__field_filename.writetobuffer(buf) 85 try: self.__field_whoknows 86 except: 87 self.__field_whoknows=USTRING(**{'sizeinbytes': 32, 'default': 'identity'}) 88 self.__field_whoknows.writetobuffer(buf) 89 self.__field_mimetype.writetobuffer(buf) 90 try: self.__field_whoknows2 91 except: 92 self.__field_whoknows2=USTRING(**{'sizeinbytes': 32, 'default': ""}) 93 self.__field_whoknows2.writetobuffer(buf) 94 self._bufferendoffset=buf.getcurrentoffset() 95 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

96 97

98 - def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):

99 'Reads this packet from the supplied buffer' 100 self._bufferstartoffset=buf.getcurrentoffset() 101 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 102 self.__field_totalsize=UINT(**{'sizeinbytes': 4}) 103 self.__field_totalsize.readfrombuffer(buf) 104 self.__field_dunno1=UINT(**{'sizeinbytes': 4, 'constant': 0}) 105 self.__field_dunno1.readfrombuffer(buf) 106 self.__field_index=UINT(**{'sizeinbytes': 4}) 107 self.__field_index.readfrombuffer(buf) 108 self.__field_magic1=UINT(**{'sizeinbytes': 4, 'default': 0x7824c97a}) 109 self.__field_magic1.readfrombuffer(buf) 110 self.__field_magic2=UINT(**{'sizeinbytes': 4, 'default': 0x7824c97a}) 111 self.__field_magic2.readfrombuffer(buf) 112 self.__field_magic3=UINT(**{'sizeinbytes': 4, 'default': 0x7824c97a}) 113 self.__field_magic3.readfrombuffer(buf) 114 self.__field_dunno2=UINT(**{'sizeinbytes': 4, 'constant': 0}) 115 self.__field_dunno2.readfrombuffer(buf) 116 self.__field_filename=USTRING(**{'sizeinbytes': 32, 'default': 'body'}) 117 self.__field_filename.readfrombuffer(buf) 118 self.__field_whoknows=USTRING(**{'sizeinbytes': 32, 'default': 'identity'}) 119 self.__field_whoknows.readfrombuffer(buf) 120 self.__field_mimetype=USTRING(**{'sizeinbytes': 32}) 121 self.__field_mimetype.readfrombuffer(buf) 122 self.__field_whoknows2=USTRING(**{'sizeinbytes': 32, 'default': ""}) 123 self.__field_whoknows2.readfrombuffer(buf) 124 self._bufferendoffset=buf.getcurrentoffset()

125 126

127 - def __getfield_totalsize(self):

128 return self.__field_totalsize.getvalue()

129

130 - def __setfield_totalsize(self, value):

131 if isinstance(value,UINT): 132 self.__field_totalsize=value 133 else: 134 self.__field_totalsize=UINT(value,**{'sizeinbytes': 4})

135

136 - def __delfield_totalsize(self): del self.__field_totalsize

137 138 totalsize=property(__getfield_totalsize, __setfield_totalsize, __delfield_totalsize, "media file size with size of this file (156 bytes) added") 139

140 - def __getfield_dunno1(self):

141 try: self.__field_dunno1 142 except: 143 self.__field_dunno1=UINT(**{'sizeinbytes': 4, 'constant': 0}) 144 return self.__field_dunno1.getvalue()

145

146 - def __setfield_dunno1(self, value):

147 if isinstance(value,UINT): 148 self.__field_dunno1=value 149 else: 150 self.__field_dunno1=UINT(value,**{'sizeinbytes': 4, 'constant': 0})

151

152 - def __delfield_dunno1(self): del self.__field_dunno1

153 154 dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None) 155

156 - def __getfield_index(self):

157 return self.__field_index.getvalue()

158

159 - def __setfield_index(self, value):

160 if isinstance(value,UINT): 161 self.__field_index=value 162 else: 163 self.__field_index=UINT(value,**{'sizeinbytes': 4})

164

165 - def __delfield_index(self): del self.__field_index

166 167 index=property(__getfield_index, __setfield_index, __delfield_index, "index number") 168

169 - def __getfield_magic1(self):

170 try: self.__field_magic1 171 except: 172 self.__field_magic1=UINT(**{'sizeinbytes': 4, 'default': 0x7824c97a}) 173 return self.__field_magic1.getvalue()

174

175 - def __setfield_magic1(self, value):

176 if isinstance(value,UINT): 177 self.__field_magic1=value 178 else: 179 self.__field_magic1=UINT(value,**{'sizeinbytes': 4, 'default': 0x7824c97a})

180

181 - def __delfield_magic1(self): del self.__field_magic1

182 183 magic1=property(__getfield_magic1, __setfield_magic1, __delfield_magic1, "probably a date") 184

185 - def __getfield_magic2(self):

186 try: self.__field_magic2 187 except: 188 self.__field_magic2=UINT(**{'sizeinbytes': 4, 'default': 0x7824c97a}) 189 return self.__field_magic2.getvalue()

190

191 - def __setfield_magic2(self, value):

192 if isinstance(value,UINT): 193 self.__field_magic2=value 194 else: 195 self.__field_magic2=UINT(value,**{'sizeinbytes': 4, 'default': 0x7824c97a})

196

197 - def __delfield_magic2(self): del self.__field_magic2

198 199 magic2=property(__getfield_magic2, __setfield_magic2, __delfield_magic2, "probably a date") 200

201 - def __getfield_magic3(self):

202 try: self.__field_magic3 203 except: 204 self.__field_magic3=UINT(**{'sizeinbytes': 4, 'default': 0x7824c97a}) 205 return self.__field_magic3.getvalue()

206

207 - def __setfield_magic3(self, value):

208 if isinstance(value,UINT): 209 self.__field_magic3=value 210 else: 211 self.__field_magic3=UINT(value,**{'sizeinbytes': 4, 'default': 0x7824c97a})

212

213 - def __delfield_magic3(self): del self.__field_magic3

214 215 magic3=property(__getfield_magic3, __setfield_magic3, __delfield_magic3, "probably a date") 216

217 - def __getfield_dunno2(self):

218 try: self.__field_dunno2 219 except: 220 self.__field_dunno2=UINT(**{'sizeinbytes': 4, 'constant': 0}) 221 return self.__field_dunno2.getvalue()

222

223 - def __setfield_dunno2(self, value):

224 if isinstance(value,UINT): 225 self.__field_dunno2=value 226 else: 227 self.__field_dunno2=UINT(value,**{'sizeinbytes': 4, 'constant': 0})

228

229 - def __delfield_dunno2(self): del self.__field_dunno2

230 231 dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None) 232

233 - def __getfield_filename(self):

234 return self.__field_filename.getvalue()

235

236 - def __setfield_filename(self, value):

237 if isinstance(value,USTRING): 238 self.__field_filename=value 239 else: 240 self.__field_filename=USTRING(value,**{'sizeinbytes': 32, 'default': 'body'})

241

242 - def __delfield_filename(self): del self.__field_filename

243 244 filename=property(__getfield_filename, __setfield_filename, __delfield_filename, None) 245

246 - def __getfield_whoknows(self):

247 try: self.__field_whoknows 248 except: 249 self.__field_whoknows=USTRING(**{'sizeinbytes': 32, 'default': 'identity'}) 250 return self.__field_whoknows.getvalue()

251

252 - def __setfield_whoknows(self, value):

253 if isinstance(value,USTRING): 254 self.__field_whoknows=value 255 else: 256 self.__field_whoknows=USTRING(value,**{'sizeinbytes': 32, 'default': 'identity'})

257

258 - def __delfield_whoknows(self): del self.__field_whoknows

259 260 whoknows=property(__getfield_whoknows, __setfield_whoknows, __delfield_whoknows, None) 261

262 - def __getfield_mimetype(self):

263 return self.__field_mimetype.getvalue()

264

265 - def __setfield_mimetype(self, value):

266 if isinstance(value,USTRING): 267 self.__field_mimetype=value 268 else: 269 self.__field_mimetype=USTRING(value,**{'sizeinbytes': 32})

270

271 - def __delfield_mimetype(self): del self.__field_mimetype

272 273 mimetype=property(__getfield_mimetype, __setfield_mimetype, __delfield_mimetype, None) 274

275 - def __getfield_whoknows2(self):

276 try: self.__field_whoknows2 277 except: 278 self.__field_whoknows2=USTRING(**{'sizeinbytes': 32, 'default': ""}) 279 return self.__field_whoknows2.getvalue()

280

281 - def __setfield_whoknows2(self, value):

282 if isinstance(value,USTRING): 283 self.__field_whoknows2=value 284 else: 285 self.__field_whoknows2=USTRING(value,**{'sizeinbytes': 32, 'default': ""})

286

287 - def __delfield_whoknows2(self): del self.__field_whoknows2

288 289 whoknows2=property(__getfield_whoknows2, __setfield_whoknows2, __delfield_whoknows2, None) 290

291 - def iscontainer(self):

292 return True

293

294 - def containerelements(self):

295 yield ('totalsize', self.__field_totalsize, "media file size with size of this file (156 bytes) added") 296 yield ('dunno1', self.__field_dunno1, None) 297 yield ('index', self.__field_index, "index number") 298 yield ('magic1', self.__field_magic1, "probably a date") 299 yield ('magic2', self.__field_magic2, "probably a date") 300 yield ('magic3', self.__field_magic3, "probably a date") 301 yield ('dunno2', self.__field_dunno2, None) 302 yield ('filename', self.__field_filename, None) 303 yield ('whoknows', self.__field_whoknows, None) 304 yield ('mimetype', self.__field_mimetype, None) 305 yield ('whoknows2', self.__field_whoknows2, None)

306 307 308 309

310 -class pbentry(BaseProtogenClass):

311 __fields=['serial1', 'entrysize', 'serial2', 'entrynumber', 'name', 'group', 'emails', 'url', 'ringtone', 'secret', 'memo', 'wallpaper', 'numbertypes', 'numbers', 'unknown20c'] 312

313 - def __init__(self, *args, **kwargs):

314 dict={} 315 # What was supplied to this function 316 dict.update(kwargs) 317 # Parent constructor 318 super(pbentry,self).__init__(**dict) 319 if self.__class__ is pbentry: 320 self._update(args,dict)

321 322

323 - def getfields(self):

324 return self.__fields

325 326

327 - def _update(self, args, kwargs):

328 super(pbentry,self)._update(args,kwargs) 329 keys=kwargs.keys() 330 for key in keys: 331 if key in self.__fields: 332 setattr(self, key, kwargs[key]) 333 del kwargs[key] 334 # Were any unrecognized kwargs passed in? 335 if __debug__: 336 self._complainaboutunusedargs(pbentry,kwargs) 337 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

338 # Make all P fields that haven't already been constructed 339 340

341 - def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):

342 'Writes this packet to the supplied buffer' 343 self._bufferstartoffset=buf.getcurrentoffset() 344 self.__field_serial1.writetobuffer(buf) 345 try: self.__field_entrysize 346 except: 347 self.__field_entrysize=UINT(**{'sizeinbytes': 2, 'constant': 0x0190}) 348 self.__field_entrysize.writetobuffer(buf) 349 self.__field_serial2.writetobuffer(buf) 350 self.__field_entrynumber.writetobuffer(buf) 351 self.__field_name.writetobuffer(buf) 352 self.__field_group.writetobuffer(buf) 353 try: self.__field_emails 354 except: 355 self.__field_emails=LIST(**{'elementclass': _gen_p_lgvx4600_66, 'length': NUMEMAILS}) 356 self.__field_emails.writetobuffer(buf) 357 self.__field_url.writetobuffer(buf) 358 self.__field_ringtone.writetobuffer(buf) 359 self.__field_secret.writetobuffer(buf) 360 self.__field_memo.writetobuffer(buf) 361 self.__field_wallpaper.writetobuffer(buf) 362 try: self.__field_numbertypes 363 except: 364 self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lgvx4600_73, 'length': NUMPHONENUMBERS}) 365 self.__field_numbertypes.writetobuffer(buf) 366 try: self.__field_numbers 367 except: 368 self.__field_numbers=LIST(**{'elementclass': _gen_p_lgvx4600_75, 'length': NUMPHONENUMBERS}) 369 self.__field_numbers.writetobuffer(buf) 370 try: self.__field_unknown20c 371 except: 372 self.__field_unknown20c=UNKNOWN() 373 self.__field_unknown20c.writetobuffer(buf) 374 self._bufferendoffset=buf.getcurrentoffset() 375 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

376 377

378 - def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):

379 'Reads this packet from the supplied buffer' 380 self._bufferstartoffset=buf.getcurrentoffset() 381 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 382 self.__field_serial1=UINT(**{'sizeinbytes': 4}) 383 self.__field_serial1.readfrombuffer(buf) 384 self.__field_entrysize=UINT(**{'sizeinbytes': 2, 'constant': 0x0190}) 385 self.__field_entrysize.readfrombuffer(buf) 386 self.__field_serial2=UINT(**{'sizeinbytes': 4}) 387 self.__field_serial2.readfrombuffer(buf) 388 self.__field_entrynumber=UINT(**{'sizeinbytes': 2}) 389 self.__field_entrynumber.readfrombuffer(buf) 390 self.__field_name=USTRING(**{'sizeinbytes': 23, 'raiseonunterminatedread': False}) 391 self.__field_name.readfrombuffer(buf) 392 self.__field_group=UINT(**{'sizeinbytes': 2}) 393 self.__field_group.readfrombuffer(buf) 394 self.__field_emails=LIST(**{'elementclass': _gen_p_lgvx4600_66, 'length': NUMEMAILS}) 395 self.__field_emails.readfrombuffer(buf) 396 self.__field_url=USTRING(**{'sizeinbytes': 72, 'raiseonunterminatedread': False}) 397 self.__field_url.readfrombuffer(buf) 398 self.__field_ringtone=UINT(**{'sizeinbytes': 2}) 399 self.__field_ringtone.readfrombuffer(buf) 400 self.__field_secret=BOOL(**{'sizeinbytes': 1}) 401 self.__field_secret.readfrombuffer(buf) 402 self.__field_memo=USTRING(**{'raiseonunterminatedread': False, 'sizeinbytes': MEMOLENGTH}) 403 self.__field_memo.readfrombuffer(buf) 404 self.__field_wallpaper=UINT(**{'sizeinbytes': 2}) 405 self.__field_wallpaper.readfrombuffer(buf) 406 self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lgvx4600_73, 'length': NUMPHONENUMBERS}) 407 self.__field_numbertypes.readfrombuffer(buf) 408 self.__field_numbers=LIST(**{'elementclass': _gen_p_lgvx4600_75, 'length': NUMPHONENUMBERS}) 409 self.__field_numbers.readfrombuffer(buf) 410 self.__field_unknown20c=UNKNOWN() 411 self.__field_unknown20c.readfrombuffer(buf) 412 self._bufferendoffset=buf.getcurrentoffset()

413 414

415 - def __getfield_serial1(self):

416 return self.__field_serial1.getvalue()

417

418 - def __setfield_serial1(self, value):

419 if isinstance(value,UINT): 420 self.__field_serial1=value 421 else: 422 self.__field_serial1=UINT(value,**{'sizeinbytes': 4})

423

424 - def __delfield_serial1(self): del self.__field_serial1

425 426 serial1=property(__getfield_serial1, __setfield_serial1, __delfield_serial1, None) 427

428 - def __getfield_entrysize(self):

429 try: self.__field_entrysize 430 except: 431 self.__field_entrysize=UINT(**{'sizeinbytes': 2, 'constant': 0x0190}) 432 return self.__field_entrysize.getvalue()

433

434 - def __setfield_entrysize(self, value):

435 if isinstance(value,UINT): 436 self.__field_entrysize=value 437 else: 438 self.__field_entrysize=UINT(value,**{'sizeinbytes': 2, 'constant': 0x0190})

439

440 - def __delfield_entrysize(self): del self.__field_entrysize

441 442 entrysize=property(__getfield_entrysize, __setfield_entrysize, __delfield_entrysize, None) 443

444 - def __getfield_serial2(self):

445 return self.__field_serial2.getvalue()

446

447 - def __setfield_serial2(self, value):

448 if isinstance(value,UINT): 449 self.__field_serial2=value 450 else: 451 self.__field_serial2=UINT(value,**{'sizeinbytes': 4})

452

453 - def __delfield_serial2(self): del self.__field_serial2

454 455 serial2=property(__getfield_serial2, __setfield_serial2, __delfield_serial2, None) 456

457 - def __getfield_entrynumber(self):

458 return self.__field_entrynumber.getvalue()

459

460 - def __setfield_entrynumber(self, value):

461 if isinstance(value,UINT): 462 self.__field_entrynumber=value 463 else: 464 self.__field_entrynumber=UINT(value,**{'sizeinbytes': 2})

465

466 - def __delfield_entrynumber(self): del self.__field_entrynumber

467 468 entrynumber=property(__getfield_entrynumber, __setfield_entrynumber, __delfield_entrynumber, None) 469

470 - def __getfield_name(self):

471 return self.__field_name.getvalue()

472

473 - def __setfield_name(self, value):

474 if isinstance(value,USTRING): 475 self.__field_name=value 476 else: 477 self.__field_name=USTRING(value,**{'sizeinbytes': 23, 'raiseonunterminatedread': False})

478

479 - def __delfield_name(self): del self.__field_name

480 481 name=property(__getfield_name, __setfield_name, __delfield_name, None) 482

483 - def __getfield_group(self):

484 return self.__field_group.getvalue()

485

486 - def __setfield_group(self, value):

487 if isinstance(value,UINT): 488 self.__field_group=value 489 else: 490 self.__field_group=UINT(value,**{'sizeinbytes': 2})

491

492 - def __delfield_group(self): del self.__field_group

493 494 group=property(__getfield_group, __setfield_group, __delfield_group, None) 495

496 - def __getfield_emails(self):

497 try: self.__field_emails 498 except: 499 self.__field_emails=LIST(**{'elementclass': _gen_p_lgvx4600_66, 'length': NUMEMAILS}) 500 return self.__field_emails.getvalue()

501

502 - def __setfield_emails(self, value):

503 if isinstance(value,LIST): 504 self.__field_emails=value 505 else: 506 self.__field_emails=LIST(value,**{'elementclass': _gen_p_lgvx4600_66, 'length': NUMEMAILS})

507

508 - def __delfield_emails(self): del self.__field_emails

509 510 emails=property(__getfield_emails, __setfield_emails, __delfield_emails, None) 511

512 - def __getfield_url(self):

513 return self.__field_url.getvalue()

514

515 - def __setfield_url(self, value):

516 if isinstance(value,USTRING): 517 self.__field_url=value 518 else: 519 self.__field_url=USTRING(value,**{'sizeinbytes': 72, 'raiseonunterminatedread': False})

520

521 - def __delfield_url(self): del self.__field_url

522 523 url=property(__getfield_url, __setfield_url, __delfield_url, None) 524

525 - def __getfield_ringtone(self):

526 return self.__field_ringtone.getvalue()

527

528 - def __setfield_ringtone(self, value):

529 if isinstance(value,UINT): 530 self.__field_ringtone=value 531 else: 532 self.__field_ringtone=UINT(value,**{'sizeinbytes': 2})

533

534 - def __delfield_ringtone(self): del self.__field_ringtone

535 536 ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, "ringtone index for a call") 537

538 - def __getfield_secret(self):

539 return self.__field_secret.getvalue()

540

541 - def __setfield_secret(self, value):

542 if isinstance(value,BOOL): 543 self.__field_secret=value 544 else: 545 self.__field_secret=BOOL(value,**{'sizeinbytes': 1})

546

547 - def __delfield_secret(self): del self.__field_secret

548 549 secret=property(__getfield_secret, __setfield_secret, __delfield_secret, None) 550

551 - def __getfield_memo(self):

552 return self.__field_memo.getvalue()

553

554 - def __setfield_memo(self, value):

555 if isinstance(value,USTRING): 556 self.__field_memo=value 557 else: 558 self.__field_memo=USTRING(value,**{'raiseonunterminatedread': False, 'sizeinbytes': MEMOLENGTH})

559

560 - def __delfield_memo(self): del self.__field_memo

561 562 memo=property(__getfield_memo, __setfield_memo, __delfield_memo, None) 563

564 - def __getfield_wallpaper(self):

565 return self.__field_wallpaper.getvalue()

566

567 - def __setfield_wallpaper(self, value):

568 if isinstance(value,UINT): 569 self.__field_wallpaper=value 570 else: 571 self.__field_wallpaper=UINT(value,**{'sizeinbytes': 2})

572

573 - def __delfield_wallpaper(self): del self.__field_wallpaper

574 575 wallpaper=property(__getfield_wallpaper, __setfield_wallpaper, __delfield_wallpaper, None) 576

577 - def __getfield_numbertypes(self):

578 try: self.__field_numbertypes 579 except: 580 self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lgvx4600_73, 'length': NUMPHONENUMBERS}) 581 return self.__field_numbertypes.getvalue()

582

583 - def __setfield_numbertypes(self, value):

584 if isinstance(value,LIST): 585 self.__field_numbertypes=value 586 else: 587 self.__field_numbertypes=LIST(value,**{'elementclass': _gen_p_lgvx4600_73, 'length': NUMPHONENUMBERS})

588

589 - def __delfield_numbertypes(self): del self.__field_numbertypes

590 591 numbertypes=property(__getfield_numbertypes, __setfield_numbertypes, __delfield_numbertypes, None) 592

593 - def __getfield_numbers(self):

594 try: self.__field_numbers 595 except: 596 self.__field_numbers=LIST(**{'elementclass': _gen_p_lgvx4600_75, 'length': NUMPHONENUMBERS}) 597 return self.__field_numbers.getvalue()

598

599 - def __setfield_numbers(self, value):

600 if isinstance(value,LIST): 601 self.__field_numbers=value 602 else: 603 self.__field_numbers=LIST(value,**{'elementclass': _gen_p_lgvx4600_75, 'length': NUMPHONENUMBERS})

604

605 - def __delfield_numbers(self): del self.__field_numbers

606 607 numbers=property(__getfield_numbers, __setfield_numbers, __delfield_numbers, None) 608

609 - def __getfield_unknown20c(self):

610 try: self.__field_unknown20c 611 except: 612 self.__field_unknown20c=UNKNOWN() 613 return self.__field_unknown20c.getvalue()

614

615 - def __setfield_unknown20c(self, value):

616 if isinstance(value,UNKNOWN): 617 self.__field_unknown20c=value 618 else: 619 self.__field_unknown20c=UNKNOWN(value,)

620

621 - def __delfield_unknown20c(self): del self.__field_unknown20c

622 623 unknown20c=property(__getfield_unknown20c, __setfield_unknown20c, __delfield_unknown20c, None) 624

625 - def iscontainer(self):

626 return True

627

628 - def containerelements(self):

629 yield ('serial1', self.__field_serial1, None) 630 yield ('entrysize', self.__field_entrysize, None) 631 yield ('serial2', self.__field_serial2, None) 632 yield ('entrynumber', self.__field_entrynumber, None) 633 yield ('name', self.__field_name, None) 634 yield ('group', self.__field_group, None) 635 yield ('emails', self.__field_emails, None) 636 yield ('url', self.__field_url, None) 637 yield ('ringtone', self.__field_ringtone, "ringtone index for a call") 638 yield ('secret', self.__field_secret, None) 639 yield ('memo', self.__field_memo, None) 640 yield ('wallpaper', self.__field_wallpaper, None) 641 yield ('numbertypes', self.__field_numbertypes, None) 642 yield ('numbers', self.__field_numbers, None) 643 yield ('unknown20c', self.__field_unknown20c, None)

644 645 646 647

648 -class _gen_p_lgvx4600_66(BaseProtogenClass):

649 'Anonymous inner class' 650 __fields=['email'] 651

652 - def __init__(self, *args, **kwargs):

653 dict={} 654 # What was supplied to this function 655 dict.update(kwargs) 656 # Parent constructor 657 super(_gen_p_lgvx4600_66,self).__init__(**dict) 658 if self.__class__ is _gen_p_lgvx4600_66: 659 self._update(args,dict)

660 661

662 - def getfields(self):

663 return self.__fields

664 665

666 - def _update(self, args, kwargs):

667 super(_gen_p_lgvx4600_66,self)._update(args,kwargs) 668 keys=kwargs.keys() 669 for key in keys: 670 if key in self.__fields: 671 setattr(self, key, kwargs[key]) 672 del kwargs[key] 673 # Were any unrecognized kwargs passed in? 674 if __debug__: 675 self._complainaboutunusedargs(_gen_p_lgvx4600_66,kwargs) 676 if len(args): 677 dict2={'sizeinbytes': 73, 'raiseonunterminatedread': False} 678 dict2.update(kwargs) 679 kwargs=dict2 680 self.__field_email=USTRING(*args,**dict2)

681 # Make all P fields that haven't already been constructed 682 683

684 - def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):

685 'Writes this packet to the supplied buffer' 686 self._bufferstartoffset=buf.getcurrentoffset() 687 self.__field_email.writetobuffer(buf) 688 self._bufferendoffset=buf.getcurrentoffset() 689 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

690 691

692 - def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):

693 'Reads this packet from the supplied buffer' 694 self._bufferstartoffset=buf.getcurrentoffset() 695 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 696 self.__field_email=USTRING(**{'sizeinbytes': 73, 'raiseonunterminatedread': False}) 697 self.__field_email.readfrombuffer(buf) 698 self._bufferendoffset=buf.getcurrentoffset()

699 700

701 - def __getfield_email(self):

702 return self.__field_email.getvalue()

703

704 - def __setfield_email(self, value):

705 if isinstance(value,USTRING): 706 self.__field_email=value 707 else: 708 self.__field_email=USTRING(value,**{'sizeinbytes': 73, 'raiseonunterminatedread': False})

709

710 - def __delfield_email(self): del self.__field_email

711 712 email=property(__getfield_email, __setfield_email, __delfield_email, None) 713

714 - def iscontainer(self):

715 return True

716

717 - def containerelements(self):

718 yield ('email', self.__field_email, None)

719 720 721 722

723 -class _gen_p_lgvx4600_73(BaseProtogenClass):

724 'Anonymous inner class' 725 __fields=['numbertype'] 726

727 - def __init__(self, *args, **kwargs):

728 dict={} 729 # What was supplied to this function 730 dict.update(kwargs) 731 # Parent constructor 732 super(_gen_p_lgvx4600_73,self).__init__(**dict) 733 if self.__class__ is _gen_p_lgvx4600_73: 734 self._update(args,dict)

735 736

737 - def getfields(self):

738 return self.__fields

739 740

741 - def _update(self, args, kwargs):

742 super(_gen_p_lgvx4600_73,self)._update(args,kwargs) 743 keys=kwargs.keys() 744 for key in keys: 745 if key in self.__fields: 746 setattr(self, key, kwargs[key]) 747 del kwargs[key] 748 # Were any unrecognized kwargs passed in? 749 if __debug__: 750 self._complainaboutunusedargs(_gen_p_lgvx4600_73,kwargs) 751 if len(args): 752 dict2={'sizeinbytes': 1} 753 dict2.update(kwargs) 754 kwargs=dict2 755 self.__field_numbertype=UINT(*args,**dict2)

756 # Make all P fields that haven't already been constructed 757 758

759 - def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):

760 'Writes this packet to the supplied buffer' 761 self._bufferstartoffset=buf.getcurrentoffset() 762 self.__field_numbertype.writetobuffer(buf) 763 self._bufferendoffset=buf.getcurrentoffset() 764 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

765 766

767 - def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):

768 'Reads this packet from the supplied buffer' 769 self._bufferstartoffset=buf.getcurrentoffset() 770 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 771 self.__field_numbertype=UINT(**{'sizeinbytes': 1}) 772 self.__field_numbertype.readfrombuffer(buf) 773 self._bufferendoffset=buf.getcurrentoffset()

774 775

776 - def __getfield_numbertype(self):

777 return self.__field_numbertype.getvalue()

778

779 - def __setfield_numbertype(self, value):

780 if isinstance(value,UINT): 781 self.__field_numbertype=value 782 else: 783 self.__field_numbertype=UINT(value,**{'sizeinbytes': 1})

784

785 - def __delfield_numbertype(self): del self.__field_numbertype

786 787 numbertype=property(__getfield_numbertype, __setfield_numbertype, __delfield_numbertype, None) 788

789 - def iscontainer(self):

790 return True

791

792 - def containerelements(self):

793 yield ('numbertype', self.__field_numbertype, None)

794 795 796 797

798 -class _gen_p_lgvx4600_75(BaseProtogenClass):

799 'Anonymous inner class' 800 __fields=['number'] 801

802 - def __init__(self, *args, **kwargs):

803 dict={} 804 # What was supplied to this function 805 dict.update(kwargs) 806 # Parent constructor 807 super(_gen_p_lgvx4600_75,self).__init__(**dict) 808 if self.__class__ is _gen_p_lgvx4600_75: 809 self._update(args,dict)

810 811

812 - def getfields(self):

813 return self.__fields

814 815

816 - def _update(self, args, kwargs):

817 super(_gen_p_lgvx4600_75,self)._update(args,kwargs) 818 keys=kwargs.keys() 819 for key in keys: 820 if key in self.__fields: 821 setattr(self, key, kwargs[key]) 822 del kwargs[key] 823 # Were any unrecognized kwargs passed in? 824 if __debug__: 825 self._complainaboutunusedargs(_gen_p_lgvx4600_75,kwargs) 826 if len(args): 827 dict2={'sizeinbytes': 33, 'raiseonunterminatedread': False} 828 dict2.update(kwargs) 829 kwargs=dict2 830 self.__field_number=USTRING(*args,**dict2)

831 # Make all P fields that haven't already been constructed 832 833

834 - def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):

835 'Writes this packet to the supplied buffer' 836 self._bufferstartoffset=buf.getcurrentoffset() 837 self.__field_number.writetobuffer(buf) 838 self._bufferendoffset=buf.getcurrentoffset() 839 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

840 841

842 - def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):

843 'Reads this packet from the supplied buffer' 844 self._bufferstartoffset=buf.getcurrentoffset() 845 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 846 self.__field_number=USTRING(**{'sizeinbytes': 33, 'raiseonunterminatedread': False}) 847 self.__field_number.readfrombuffer(buf) 848 self._bufferendoffset=buf.getcurrentoffset()

849 850

851 - def __getfield_number(self):

852 return self.__field_number.getvalue()

853

854 - def __setfield_number(self, value):

855 if isinstance(value,USTRING): 856 self.__field_number=value 857 else: 858 self.__field_number=USTRING(value,**{'sizeinbytes': 33, 'raiseonunterminatedread': False})

859

860 - def __delfield_number(self): del self.__field_number

861 862 number=property(__getfield_number, __setfield_number, __delfield_number, None) 863

864 - def iscontainer(self):

865 return True

866

867 - def containerelements(self):

868 yield ('number', self.__field_number, None)

869 870 871 872

873 -class pbreadentryresponse(BaseProtogenClass):

874 "Results of reading one entry" 875 __fields=['header', 'entry'] 876

877 - def __init__(self, *args, **kwargs):

878 dict={} 879 # What was supplied to this function 880 dict.update(kwargs) 881 # Parent constructor 882 super(pbreadentryresponse,self).__init__(**dict) 883 if self.__class__ is pbreadentryresponse: 884 self._update(args,dict)

885 886

887 - def getfields(self):

888 return self.__fields

889 890

891 - def _update(self, args, kwargs):

892 super(pbreadentryresponse,self)._update(args,kwargs) 893 keys=kwargs.keys() 894 for key in keys: 895 if key in self.__fields: 896 setattr(self, key, kwargs[key]) 897 del kwargs[key] 898 # Were any unrecognized kwargs passed in? 899 if __debug__: 900 self._complainaboutunusedargs(pbreadentryresponse,kwargs) 901 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

902 # Make all P fields that haven't already been constructed 903 904

905 - def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):

906 'Writes this packet to the supplied buffer' 907 self._bufferstartoffset=buf.getcurrentoffset() 908 self.__field_header.writetobuffer(buf) 909 self.__field_entry.writetobuffer(buf) 910 self._bufferendoffset=buf.getcurrentoffset() 911 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

912 913

914 - def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):

915 'Reads this packet from the supplied buffer' 916 self._bufferstartoffset=buf.getcurrentoffset() 917 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 918 self.__field_header=pbheader() 919 self.__field_header.readfrombuffer(buf) 920 self.__field_entry=pbentry() 921 self.__field_entry.readfrombuffer(buf) 922 self._bufferendoffset=buf.getcurrentoffset()

923 924

925 - def __getfield_header(self):

926 return self.__field_header.getvalue()

927

928 - def __setfield_header(self, value):

929 if isinstance(value,pbheader): 930 self.__field_header=value 931 else: 932 self.__field_header=pbheader(value,)

933

934 - def __delfield_header(self): del self.__field_header

935 936 header=property(__getfield_header, __setfield_header, __delfield_header, None) 937

938 - def __getfield_entry(self):

939 return self.__field_entry.getvalue()

940

941 - def __setfield_entry(self, value):

942 if isinstance(value,pbentry): 943 self.__field_entry=value 944 else: 945 self.__field_entry=pbentry(value,)

946

947 - def __delfield_entry(self): del self.__field_entry

948 949 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 950

951 - def iscontainer(self):

952 return True

953

954 - def containerelements(self):

955 yield ('header', self.__field_header, None) 956 yield ('entry', self.__field_entry, None)

957 958 959 960

961 -class pbupdateentryrequest(BaseProtogenClass):

962 __fields=['header', 'entry'] 963

964 - def __init__(self, *args, **kwargs):

965 dict={} 966 # What was supplied to this function 967 dict.update(kwargs) 968 # Parent constructor 969 super(pbupdateentryrequest,self).__init__(**dict) 970 if self.__class__ is pbupdateentryrequest: 971 self._update(args,dict)

972 973

974 - def getfields(self):

975 return self.__fields

976 977

978 - def _update(self, args, kwargs):

979 super(pbupdateentryrequest,self)._update(args,kwargs) 980 keys=kwargs.keys() 981 for key in keys: 982 if key in self.__fields: 983 setattr(self, key, kwargs[key]) 984 del kwargs[key] 985 # Were any unrecognized kwargs passed in? 986 if __debug__: 987 self._complainaboutunusedargs(pbupdateentryrequest,kwargs) 988 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

989 # Make all P fields that haven't already been constructed 990 991

992 - def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):

993 'Writes this packet to the supplied buffer' 994 self._bufferstartoffset=buf.getcurrentoffset() 995 try: self.__field_header 996 except: 997 self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01}) 998 self.__field_header.writetobuffer(buf) 999 self.__field_entry.writetobuffer(buf) 1000 self._bufferendoffset=buf.getcurrentoffset() 1001 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

1002 1003

1004 - def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):

1005 'Reads this packet from the supplied buffer' 1006 self._bufferstartoffset=buf.getcurrentoffset() 1007 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1008 self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01}) 1009 self.__field_header.readfrombuffer(buf) 1010 self.__field_entry=pbentry() 1011 self.__field_entry.readfrombuffer(buf) 1012 self._bufferendoffset=buf.getcurrentoffset()

1013 1014

1015 - def __getfield_header(self):

1016 try: self.__field_header 1017 except: 1018 self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01}) 1019 return self.__field_header.getvalue()

1020

1021 - def __setfield_header(self, value):

1022 if isinstance(value,pbheader): 1023 self.__field_header=value 1024 else: 1025 self.__field_header=pbheader(value,**{'command': 0x04, 'flag': 0x01})

1026

1027 - def __delfield_header(self): del self.__field_header

1028 1029 header=property(__getfield_header, __setfield_header, __delfield_header, None) 1030

1031 - def __getfield_entry(self):

1032 return self.__field_entry.getvalue()

1033

1034 - def __setfield_entry(self, value):

1035 if isinstance(value,pbentry): 1036 self.__field_entry=value 1037 else: 1038 self.__field_entry=pbentry(value,)

1039

1040 - def __delfield_entry(self): del self.__field_entry

1041 1042 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 1043

1044 - def iscontainer(self):

1045 return True

1046

1047 - def containerelements(self):

1048 yield ('header', self.__field_header, None) 1049 yield ('entry', self.__field_entry, None)

1050 1051 1052 1053

1054 -class pbappendentryrequest(BaseProtogenClass):

1055 __fields=['header', 'entry'] 1056

1057 - def __init__(self, *args, **kwargs):

1058 dict={} 1059 # What was supplied to this function 1060 dict.update(kwargs) 1061 # Parent constructor 1062 super(pbappendentryrequest,self).__init__(**dict) 1063 if self.__class__ is pbappendentryrequest: 1064 self._update(args,dict)

1065 1066

1067 - def getfields(self):

1068 return self.__fields

1069 1070

1071 - def _update(self, args, kwargs):

1072 super(pbappendentryrequest,self)._update(args,kwargs) 1073 keys=kwargs.keys() 1074 for key in keys: 1075 if key in self.__fields: 1076 setattr(self, key, kwargs[key]) 1077 del kwargs[key] 1078 # Were any unrecognized kwargs passed in? 1079 if __debug__: 1080 self._complainaboutunusedargs(pbappendentryrequest,kwargs) 1081 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

1082 # Make all P fields that haven't already been constructed 1083 1084

1085 - def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):

1086 'Writes this packet to the supplied buffer' 1087 self._bufferstartoffset=buf.getcurrentoffset() 1088 try: self.__field_header 1089 except: 1090 self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01}) 1091 self.__field_header.writetobuffer(buf) 1092 self.__field_entry.writetobuffer(buf) 1093 self._bufferendoffset=buf.getcurrentoffset() 1094 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

1095 1096

1097 - def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):

1098 'Reads this packet from the supplied buffer' 1099 self._bufferstartoffset=buf.getcurrentoffset() 1100 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1101 self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01}) 1102 self.__field_header.readfrombuffer(buf) 1103 self.__field_entry=pbentry() 1104 self.__field_entry.readfrombuffer(buf) 1105 self._bufferendoffset=buf.getcurrentoffset()

1106 1107

1108 - def __getfield_header(self):

1109 try: self.__field_header 1110 except: 1111 self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01}) 1112 return self.__field_header.getvalue()

1113

1114 - def __setfield_header(self, value):

1115 if isinstance(value,pbheader): 1116 self.__field_header=value 1117 else: 1118 self.__field_header=pbheader(value,**{'command': 0x03, 'flag': 0x01})

1119

1120 - def __delfield_header(self): del self.__field_header

1121 1122 header=property(__getfield_header, __setfield_header, __delfield_header, None) 1123

1124 - def __getfield_entry(self):

1125 return self.__field_entry.getvalue()

1126

1127 - def __setfield_entry(self, value):

1128 if isinstance(value,pbentry): 1129 self.__field_entry=value 1130 else: 1131 self.__field_entry=pbentry(value,)

1132

1133 - def __delfield_entry(self): del self.__field_entry

1134 1135 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 1136

1137 - def iscontainer(self):

1138 return True

1139

1140 - def containerelements(self):

1141 yield ('header', self.__field_header, None) 1142 yield ('entry', self.__field_entry, None)

1143

Source Code for Module phones.p_lgvx4600