phones.p_lgvx9700

1 # THIS FILE IS AUTOMATICALLY GENERATED. EDIT THE SOURCE FILE NOT THIS ONE 2 3 """Various descriptions of data specific to LG VX9700""" 4 5 # groups - same as VX-8700 6 # phonebook - LG Phonebook v1.0 (same as VX-8550) 7 # schedule - same as VX-8550 8 from p_lgvx8550 import * 9 10 # sms - same as VX-9100 11 from p_lgvx9100 import msg_record,recipient_record,sms_saved,sms_out,SMSINBOXMSGFRAGMENT,sms_in 12 13 # SMS index files 14 inbox_index = "dload/inbox.dat" 15 outbox_index = "dload/outbox.dat" 16 drafts_index = "dload/drafts.dat" 17

18 -class indexentry(BaseProtogenClass):

19 __fields=['filename', 'size', 'date', 'type', 'unk0', 'unk1', 'unk2'] 20

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

22 dict={} 23 # What was supplied to this function 24 dict.update(kwargs) 25 # Parent constructor 26 super(indexentry,self).__init__(**dict) 27 if self.__class__ is indexentry: 28 self._update(args,dict)

29 30

31 - def getfields(self):

32 return self.__fields

33 34

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

36 super(indexentry,self)._update(args,kwargs) 37 keys=kwargs.keys() 38 for key in keys: 39 if key in self.__fields: 40 setattr(self, key, kwargs[key]) 41 del kwargs[key] 42 # Were any unrecognized kwargs passed in? 43 if __debug__: 44 self._complainaboutunusedargs(indexentry,kwargs) 45 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

46 # Make all P fields that haven't already been constructed 47 48

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

50 'Writes this packet to the supplied buffer' 51 self._bufferstartoffset=buf.getcurrentoffset() 52 self.__field_filename.writetobuffer(buf) 53 self.__field_size.writetobuffer(buf) 54 try: self.__field_date 55 except: 56 self.__field_date=UINT(**{'sizeinbytes': 4, 'default': 0}) 57 self.__field_date.writetobuffer(buf) 58 self.__field_type.writetobuffer(buf) 59 try: self.__field_unk0 60 except: 61 self.__field_unk0=UINT(**{'sizeinbytes': 4, 'default': 0}) 62 self.__field_unk0.writetobuffer(buf) 63 try: self.__field_unk1 64 except: 65 self.__field_unk1=UINT(**{'sizeinbytes': 4, 'default': 0}) 66 self.__field_unk1.writetobuffer(buf) 67 try: self.__field_unk2 68 except: 69 self.__field_unk2=UINT(**{'sizeinbytes': 4, 'default': 0}) 70 self.__field_unk2.writetobuffer(buf) 71 self._bufferendoffset=buf.getcurrentoffset() 72 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

73 74

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

76 'Reads this packet from the supplied buffer' 77 self._bufferstartoffset=buf.getcurrentoffset() 78 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 79 self.__field_filename=USTRING(**{'sizeinbytes': 256, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False }) 80 self.__field_filename.readfrombuffer(buf) 81 self.__field_size=UINT(**{'sizeinbytes': 4}) 82 self.__field_size.readfrombuffer(buf) 83 self.__field_date=UINT(**{'sizeinbytes': 4, 'default': 0}) 84 self.__field_date.readfrombuffer(buf) 85 self.__field_type=UINT(**{'sizeinbytes': 4}) 86 self.__field_type.readfrombuffer(buf) 87 self.__field_unk0=UINT(**{'sizeinbytes': 4, 'default': 0}) 88 self.__field_unk0.readfrombuffer(buf) 89 self.__field_unk1=UINT(**{'sizeinbytes': 4, 'default': 0}) 90 self.__field_unk1.readfrombuffer(buf) 91 self.__field_unk2=UINT(**{'sizeinbytes': 4, 'default': 0}) 92 self.__field_unk2.readfrombuffer(buf) 93 self._bufferendoffset=buf.getcurrentoffset()

94 95

96 - def __getfield_filename(self):

97 return self.__field_filename.getvalue()

98

99 - def __setfield_filename(self, value):

100 if isinstance(value,USTRING): 101 self.__field_filename=value 102 else: 103 self.__field_filename=USTRING(value,**{'sizeinbytes': 256, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False })

104

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

106 107 filename=property(__getfield_filename, __setfield_filename, __delfield_filename, "full pathname") 108

109 - def __getfield_size(self):

110 return self.__field_size.getvalue()

111

112 - def __setfield_size(self, value):

113 if isinstance(value,UINT): 114 self.__field_size=value 115 else: 116 self.__field_size=UINT(value,**{'sizeinbytes': 4})

117

118 - def __delfield_size(self): del self.__field_size

119 120 size=property(__getfield_size, __setfield_size, __delfield_size, None) 121

122 - def __getfield_date(self):

123 try: self.__field_date 124 except: 125 self.__field_date=UINT(**{'sizeinbytes': 4, 'default': 0}) 126 return self.__field_date.getvalue()

127

128 - def __setfield_date(self, value):

129 if isinstance(value,UINT): 130 self.__field_date=value 131 else: 132 self.__field_date=UINT(value,**{'sizeinbytes': 4, 'default': 0})

133

134 - def __delfield_date(self): del self.__field_date

135 136 date=property(__getfield_date, __setfield_date, __delfield_date, None) 137

138 - def __getfield_type(self):

139 return self.__field_type.getvalue()

140

141 - def __setfield_type(self, value):

142 if isinstance(value,UINT): 143 self.__field_type=value 144 else: 145 self.__field_type=UINT(value,**{'sizeinbytes': 4})

146

147 - def __delfield_type(self): del self.__field_type

148 149 type=property(__getfield_type, __setfield_type, __delfield_type, None) 150

151 - def __getfield_unk0(self):

152 try: self.__field_unk0 153 except: 154 self.__field_unk0=UINT(**{'sizeinbytes': 4, 'default': 0}) 155 return self.__field_unk0.getvalue()

156

157 - def __setfield_unk0(self, value):

158 if isinstance(value,UINT): 159 self.__field_unk0=value 160 else: 161 self.__field_unk0=UINT(value,**{'sizeinbytes': 4, 'default': 0})

162

163 - def __delfield_unk0(self): del self.__field_unk0

164 165 unk0=property(__getfield_unk0, __setfield_unk0, __delfield_unk0, None) 166

167 - def __getfield_unk1(self):

168 try: self.__field_unk1 169 except: 170 self.__field_unk1=UINT(**{'sizeinbytes': 4, 'default': 0}) 171 return self.__field_unk1.getvalue()

172

173 - def __setfield_unk1(self, value):

174 if isinstance(value,UINT): 175 self.__field_unk1=value 176 else: 177 self.__field_unk1=UINT(value,**{'sizeinbytes': 4, 'default': 0})

178

179 - def __delfield_unk1(self): del self.__field_unk1

180 181 unk1=property(__getfield_unk1, __setfield_unk1, __delfield_unk1, None) 182

183 - def __getfield_unk2(self):

184 try: self.__field_unk2 185 except: 186 self.__field_unk2=UINT(**{'sizeinbytes': 4, 'default': 0}) 187 return self.__field_unk2.getvalue()

188

189 - def __setfield_unk2(self, value):

190 if isinstance(value,UINT): 191 self.__field_unk2=value 192 else: 193 self.__field_unk2=UINT(value,**{'sizeinbytes': 4, 'default': 0})

194

195 - def __delfield_unk2(self): del self.__field_unk2

196 197 unk2=property(__getfield_unk2, __setfield_unk2, __delfield_unk2, None) 198

199 - def iscontainer(self):

200 return True

201

202 - def containerelements(self):

203 yield ('filename', self.__field_filename, "full pathname") 204 yield ('size', self.__field_size, None) 205 yield ('date', self.__field_date, None) 206 yield ('type', self.__field_type, None) 207 yield ('unk0', self.__field_unk0, None) 208 yield ('unk1', self.__field_unk1, None) 209 yield ('unk2', self.__field_unk2, None)

210 211 212 213

214 -class indexfile(BaseProtogenClass):

215 "Used for tracking wallpaper and ringtones" 216 __fields=['items'] 217

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

219 dict={} 220 # What was supplied to this function 221 dict.update(kwargs) 222 # Parent constructor 223 super(indexfile,self).__init__(**dict) 224 if self.__class__ is indexfile: 225 self._update(args,dict)

226 227

228 - def getfields(self):

229 return self.__fields

230 231

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

233 super(indexfile,self)._update(args,kwargs) 234 keys=kwargs.keys() 235 for key in keys: 236 if key in self.__fields: 237 setattr(self, key, kwargs[key]) 238 del kwargs[key] 239 # Were any unrecognized kwargs passed in? 240 if __debug__: 241 self._complainaboutunusedargs(indexfile,kwargs) 242 if len(args): 243 dict2={'elementclass': indexentry, 'createdefault': True} 244 dict2.update(kwargs) 245 kwargs=dict2 246 self.__field_items=LIST(*args,**dict2)

247 # Make all P fields that haven't already been constructed 248 249

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

251 'Writes this packet to the supplied buffer' 252 self._bufferstartoffset=buf.getcurrentoffset() 253 try: self.__field_items 254 except: 255 self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True}) 256 self.__field_items.writetobuffer(buf) 257 self._bufferendoffset=buf.getcurrentoffset() 258 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

259 260

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

262 'Reads this packet from the supplied buffer' 263 self._bufferstartoffset=buf.getcurrentoffset() 264 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 265 self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True}) 266 self.__field_items.readfrombuffer(buf) 267 self._bufferendoffset=buf.getcurrentoffset()

268 269

270 - def __getfield_items(self):

271 try: self.__field_items 272 except: 273 self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True}) 274 return self.__field_items.getvalue()

275

276 - def __setfield_items(self, value):

277 if isinstance(value,LIST): 278 self.__field_items=value 279 else: 280 self.__field_items=LIST(value,**{'elementclass': indexentry, 'createdefault': True})

281

282 - def __delfield_items(self): del self.__field_items

283 284 items=property(__getfield_items, __setfield_items, __delfield_items, None) 285

286 - def iscontainer(self):

287 return True

288

289 - def containerelements(self):

290 yield ('items', self.__field_items, None)

291 292 293 294

295 -class call(BaseProtogenClass):

296 __fields=['GPStime', 'unk0', 'duration', 'number', 'name', 'numberlength', 'status', 'pbnumbertype', 'unk1', 'pbentrynum', 'unk2'] 297

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

299 dict={} 300 # What was supplied to this function 301 dict.update(kwargs) 302 # Parent constructor 303 super(call,self).__init__(**dict) 304 if self.__class__ is call: 305 self._update(args,dict)

306 307

308 - def getfields(self):

309 return self.__fields

310 311

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

313 super(call,self)._update(args,kwargs) 314 keys=kwargs.keys() 315 for key in keys: 316 if key in self.__fields: 317 setattr(self, key, kwargs[key]) 318 del kwargs[key] 319 # Were any unrecognized kwargs passed in? 320 if __debug__: 321 self._complainaboutunusedargs(call,kwargs) 322 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

323 # Make all P fields that haven't already been constructed 324 325

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

327 'Writes this packet to the supplied buffer' 328 self._bufferstartoffset=buf.getcurrentoffset() 329 self.__field_GPStime.writetobuffer(buf) 330 self.__field_unk0.writetobuffer(buf) 331 self.__field_duration.writetobuffer(buf) 332 self.__field_number.writetobuffer(buf) 333 self.__field_name.writetobuffer(buf) 334 self.__field_numberlength.writetobuffer(buf) 335 self.__field_status.writetobuffer(buf) 336 self.__field_pbnumbertype.writetobuffer(buf) 337 self.__field_unk1.writetobuffer(buf) 338 self.__field_pbentrynum.writetobuffer(buf) 339 self.__field_unk2.writetobuffer(buf) 340 self._bufferendoffset=buf.getcurrentoffset() 341 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

342 343

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

345 'Reads this packet from the supplied buffer' 346 self._bufferstartoffset=buf.getcurrentoffset() 347 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 348 self.__field_GPStime=GPSDATE(**{'sizeinbytes': 4}) 349 self.__field_GPStime.readfrombuffer(buf) 350 self.__field_unk0=UINT(**{'sizeinbytes': 4}) 351 self.__field_unk0.readfrombuffer(buf) 352 self.__field_duration=UINT(**{'sizeinbytes': 4}) 353 self.__field_duration.readfrombuffer(buf) 354 self.__field_number=USTRING(**{'sizeinbytes': 49, 'raiseonunterminatedread': False}) 355 self.__field_number.readfrombuffer(buf) 356 self.__field_name=USTRING(**{'sizeinbytes': 36, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}) 357 self.__field_name.readfrombuffer(buf) 358 self.__field_numberlength=UINT(**{'sizeinbytes': 1}) 359 self.__field_numberlength.readfrombuffer(buf) 360 self.__field_status=UINT(**{'sizeinbytes': 1}) 361 self.__field_status.readfrombuffer(buf) 362 self.__field_pbnumbertype=UINT(**{'sizeinbytes': 1}) 363 self.__field_pbnumbertype.readfrombuffer(buf) 364 self.__field_unk1=UINT(**{'sizeinbytes': 4}) 365 self.__field_unk1.readfrombuffer(buf) 366 self.__field_pbentrynum=UINT(**{'sizeinbytes': 4}) 367 self.__field_pbentrynum.readfrombuffer(buf) 368 self.__field_unk2=DATA(**{'sizeinbytes': 24}) 369 self.__field_unk2.readfrombuffer(buf) 370 self._bufferendoffset=buf.getcurrentoffset()

371 372

373 - def __getfield_GPStime(self):

374 return self.__field_GPStime.getvalue()

375

376 - def __setfield_GPStime(self, value):

377 if isinstance(value,GPSDATE): 378 self.__field_GPStime=value 379 else: 380 self.__field_GPStime=GPSDATE(value,**{'sizeinbytes': 4})

381

382 - def __delfield_GPStime(self): del self.__field_GPStime

383 384 GPStime=property(__getfield_GPStime, __setfield_GPStime, __delfield_GPStime, None) 385

386 - def __getfield_unk0(self):

387 return self.__field_unk0.getvalue()

388

389 - def __setfield_unk0(self, value):

390 if isinstance(value,UINT): 391 self.__field_unk0=value 392 else: 393 self.__field_unk0=UINT(value,**{'sizeinbytes': 4})

394

395 - def __delfield_unk0(self): del self.__field_unk0

396 397 unk0=property(__getfield_unk0, __setfield_unk0, __delfield_unk0, None) 398

399 - def __getfield_duration(self):

400 return self.__field_duration.getvalue()

401

402 - def __setfield_duration(self, value):

403 if isinstance(value,UINT): 404 self.__field_duration=value 405 else: 406 self.__field_duration=UINT(value,**{'sizeinbytes': 4})

407

408 - def __delfield_duration(self): del self.__field_duration

409 410 duration=property(__getfield_duration, __setfield_duration, __delfield_duration, None) 411

412 - def __getfield_number(self):

413 return self.__field_number.getvalue()

414

415 - def __setfield_number(self, value):

416 if isinstance(value,USTRING): 417 self.__field_number=value 418 else: 419 self.__field_number=USTRING(value,**{'sizeinbytes': 49, 'raiseonunterminatedread': False})

420

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

422 423 number=property(__getfield_number, __setfield_number, __delfield_number, None) 424

425 - def __getfield_name(self):

426 return self.__field_name.getvalue()

427

428 - def __setfield_name(self, value):

429 if isinstance(value,USTRING): 430 self.__field_name=value 431 else: 432 self.__field_name=USTRING(value,**{'sizeinbytes': 36, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})

433

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

435 436 name=property(__getfield_name, __setfield_name, __delfield_name, None) 437

438 - def __getfield_numberlength(self):

439 return self.__field_numberlength.getvalue()

440

441 - def __setfield_numberlength(self, value):

442 if isinstance(value,UINT): 443 self.__field_numberlength=value 444 else: 445 self.__field_numberlength=UINT(value,**{'sizeinbytes': 1})

446

447 - def __delfield_numberlength(self): del self.__field_numberlength

448 449 numberlength=property(__getfield_numberlength, __setfield_numberlength, __delfield_numberlength, None) 450

451 - def __getfield_status(self):

452 return self.__field_status.getvalue()

453

454 - def __setfield_status(self, value):

455 if isinstance(value,UINT): 456 self.__field_status=value 457 else: 458 self.__field_status=UINT(value,**{'sizeinbytes': 1})

459

460 - def __delfield_status(self): del self.__field_status

461 462 status=property(__getfield_status, __setfield_status, __delfield_status, None) 463

464 - def __getfield_pbnumbertype(self):

465 return self.__field_pbnumbertype.getvalue()

466

467 - def __setfield_pbnumbertype(self, value):

468 if isinstance(value,UINT): 469 self.__field_pbnumbertype=value 470 else: 471 self.__field_pbnumbertype=UINT(value,**{'sizeinbytes': 1})

472

473 - def __delfield_pbnumbertype(self): del self.__field_pbnumbertype

474 475 pbnumbertype=property(__getfield_pbnumbertype, __setfield_pbnumbertype, __delfield_pbnumbertype, None) 476

477 - def __getfield_unk1(self):

478 return self.__field_unk1.getvalue()

479

480 - def __setfield_unk1(self, value):

481 if isinstance(value,UINT): 482 self.__field_unk1=value 483 else: 484 self.__field_unk1=UINT(value,**{'sizeinbytes': 4})

485

486 - def __delfield_unk1(self): del self.__field_unk1

487 488 unk1=property(__getfield_unk1, __setfield_unk1, __delfield_unk1, None) 489

490 - def __getfield_pbentrynum(self):

491 return self.__field_pbentrynum.getvalue()

492

493 - def __setfield_pbentrynum(self, value):

494 if isinstance(value,UINT): 495 self.__field_pbentrynum=value 496 else: 497 self.__field_pbentrynum=UINT(value,**{'sizeinbytes': 4})

498

499 - def __delfield_pbentrynum(self): del self.__field_pbentrynum

500 501 pbentrynum=property(__getfield_pbentrynum, __setfield_pbentrynum, __delfield_pbentrynum, None) 502

503 - def __getfield_unk2(self):

504 return self.__field_unk2.getvalue()

505

506 - def __setfield_unk2(self, value):

507 if isinstance(value,DATA): 508 self.__field_unk2=value 509 else: 510 self.__field_unk2=DATA(value,**{'sizeinbytes': 24})

511

512 - def __delfield_unk2(self): del self.__field_unk2

513 514 unk2=property(__getfield_unk2, __setfield_unk2, __delfield_unk2, None) 515

516 - def iscontainer(self):

517 return True

518

519 - def containerelements(self):

520 yield ('GPStime', self.__field_GPStime, None) 521 yield ('unk0', self.__field_unk0, None) 522 yield ('duration', self.__field_duration, None) 523 yield ('number', self.__field_number, None) 524 yield ('name', self.__field_name, None) 525 yield ('numberlength', self.__field_numberlength, None) 526 yield ('status', self.__field_status, None) 527 yield ('pbnumbertype', self.__field_pbnumbertype, None) 528 yield ('unk1', self.__field_unk1, None) 529 yield ('pbentrynum', self.__field_pbentrynum, None) 530 yield ('unk2', self.__field_unk2, None)

531 532 533 534

535 -class callhistory(BaseProtogenClass):

536 __fields=['numcalls', 'unk1', 'calls'] 537

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

539 dict={} 540 # What was supplied to this function 541 dict.update(kwargs) 542 # Parent constructor 543 super(callhistory,self).__init__(**dict) 544 if self.__class__ is callhistory: 545 self._update(args,dict)

546 547

548 - def getfields(self):

549 return self.__fields

550 551

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

553 super(callhistory,self)._update(args,kwargs) 554 keys=kwargs.keys() 555 for key in keys: 556 if key in self.__fields: 557 setattr(self, key, kwargs[key]) 558 del kwargs[key] 559 # Were any unrecognized kwargs passed in? 560 if __debug__: 561 self._complainaboutunusedargs(callhistory,kwargs) 562 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

563 # Make all P fields that haven't already been constructed 564 565

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

567 'Writes this packet to the supplied buffer' 568 self._bufferstartoffset=buf.getcurrentoffset() 569 self.__field_numcalls.writetobuffer(buf) 570 self.__field_unk1.writetobuffer(buf) 571 try: self.__field_calls 572 except: 573 self.__field_calls=LIST(**{'elementclass': call, 'length': self.numcalls}) 574 self.__field_calls.writetobuffer(buf) 575 self._bufferendoffset=buf.getcurrentoffset() 576 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

577 578

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

580 'Reads this packet from the supplied buffer' 581 self._bufferstartoffset=buf.getcurrentoffset() 582 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 583 self.__field_numcalls=UINT(**{'sizeinbytes': 4}) 584 self.__field_numcalls.readfrombuffer(buf) 585 self.__field_unk1=UINT(**{'sizeinbytes': 1}) 586 self.__field_unk1.readfrombuffer(buf) 587 self.__field_calls=LIST(**{'elementclass': call, 'length': self.numcalls}) 588 self.__field_calls.readfrombuffer(buf) 589 self._bufferendoffset=buf.getcurrentoffset()

590 591

592 - def __getfield_numcalls(self):

593 return self.__field_numcalls.getvalue()

594

595 - def __setfield_numcalls(self, value):

596 if isinstance(value,UINT): 597 self.__field_numcalls=value 598 else: 599 self.__field_numcalls=UINT(value,**{'sizeinbytes': 4})

600

601 - def __delfield_numcalls(self): del self.__field_numcalls

602 603 numcalls=property(__getfield_numcalls, __setfield_numcalls, __delfield_numcalls, None) 604

605 - def __getfield_unk1(self):

606 return self.__field_unk1.getvalue()

607

608 - def __setfield_unk1(self, value):

609 if isinstance(value,UINT): 610 self.__field_unk1=value 611 else: 612 self.__field_unk1=UINT(value,**{'sizeinbytes': 1})

613

614 - def __delfield_unk1(self): del self.__field_unk1

615 616 unk1=property(__getfield_unk1, __setfield_unk1, __delfield_unk1, None) 617

618 - def __getfield_calls(self):

619 try: self.__field_calls 620 except: 621 self.__field_calls=LIST(**{'elementclass': call, 'length': self.numcalls}) 622 return self.__field_calls.getvalue()

623

624 - def __setfield_calls(self, value):

625 if isinstance(value,LIST): 626 self.__field_calls=value 627 else: 628 self.__field_calls=LIST(value,**{'elementclass': call, 'length': self.numcalls})

629

630 - def __delfield_calls(self): del self.__field_calls

631 632 calls=property(__getfield_calls, __setfield_calls, __delfield_calls, None) 633

634 - def iscontainer(self):

635 return True

636

637 - def containerelements(self):

638 yield ('numcalls', self.__field_numcalls, None) 639 yield ('unk1', self.__field_unk1, None) 640 yield ('calls', self.__field_calls, None)

641

Source Code for Module phones.p_lgvx9700