phones.p_lgvx8700

1 # THIS FILE IS AUTOMATICALLY GENERATED. EDIT THE SOURCE FILE NOT THIS ONE 2 3 from prototypes import * 4 5 # Make all lg stuff available in this module as well 6 from p_lg import * 7 8 # we are the same as lgvx9900 except as noted below 9 from p_lgvx9900 import * 10 from p_lgvx8500 import t9udbfile 11 12 # We use LSB for all integer like fields 13 UINT=UINTlsb 14 BOOL=BOOLlsb 15 16 BREW_FILE_SYSTEM = 2 17 BREW_READ_SIZE = 0x400 18 BREW_WRITE_SIZE = 0x1A00 19 20 MAX_PHONEBOOK_GROUPS=30 21 22 # Phonebook stuff 23 RTPathIndexFile='pim/pbRingIdSetAsPath.dat' 24 WPPathIndexFile='pim/pbPictureIdSetAsPath.dat' 25 26 pb_file_name='pim/pbentry.dat' 27 pb_group_filename='pim/pbgroup.dat' 28 29 T9USERDBFILENAME='t9udb/t9udb_eng.dat' 30

31 -class pbgroup(BaseProtogenClass):

32 __fields=['name', 'groupid', 'user_added'] 33

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

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

42 43

44 - def getfields(self):

45 return self.__fields

46 47

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

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

59 # Make all P fields that haven't already been constructed 60 61

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

63 'Writes this packet to the supplied buffer' 64 self._bufferstartoffset=buf.getcurrentoffset() 65 try: self.__field_name 66 except: 67 self.__field_name=USTRING(**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '' }) 68 self.__field_name.writetobuffer(buf) 69 try: self.__field_groupid 70 except: 71 self.__field_groupid=UINT(**{'sizeinbytes': 2, 'default': 0 }) 72 self.__field_groupid.writetobuffer(buf) 73 try: self.__field_user_added 74 except: 75 self.__field_user_added=UINT(**{'sizeinbytes': 1, 'default': 0}) 76 self.__field_user_added.writetobuffer(buf) 77 self._bufferendoffset=buf.getcurrentoffset() 78 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

79 80

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

82 'Reads this packet from the supplied buffer' 83 self._bufferstartoffset=buf.getcurrentoffset() 84 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 85 self.__field_name=USTRING(**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '' }) 86 self.__field_name.readfrombuffer(buf) 87 self.__field_groupid=UINT(**{'sizeinbytes': 2, 'default': 0 }) 88 self.__field_groupid.readfrombuffer(buf) 89 self.__field_user_added=UINT(**{'sizeinbytes': 1, 'default': 0}) 90 self.__field_user_added.readfrombuffer(buf) 91 self._bufferendoffset=buf.getcurrentoffset()

92 93

94 - def __getfield_name(self):

95 try: self.__field_name 96 except: 97 self.__field_name=USTRING(**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '' }) 98 return self.__field_name.getvalue()

99

100 - def __setfield_name(self, value):

101 if isinstance(value,USTRING): 102 self.__field_name=value 103 else: 104 self.__field_name=USTRING(value,**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '' })

105

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

107 108 name=property(__getfield_name, __setfield_name, __delfield_name, None) 109

110 - def __getfield_groupid(self):

111 try: self.__field_groupid 112 except: 113 self.__field_groupid=UINT(**{'sizeinbytes': 2, 'default': 0 }) 114 return self.__field_groupid.getvalue()

115

116 - def __setfield_groupid(self, value):

117 if isinstance(value,UINT): 118 self.__field_groupid=value 119 else: 120 self.__field_groupid=UINT(value,**{'sizeinbytes': 2, 'default': 0 })

121

122 - def __delfield_groupid(self): del self.__field_groupid

123 124 groupid=property(__getfield_groupid, __setfield_groupid, __delfield_groupid, None) 125

126 - def __getfield_user_added(self):

127 try: self.__field_user_added 128 except: 129 self.__field_user_added=UINT(**{'sizeinbytes': 1, 'default': 0}) 130 return self.__field_user_added.getvalue()

131

132 - def __setfield_user_added(self, value):

133 if isinstance(value,UINT): 134 self.__field_user_added=value 135 else: 136 self.__field_user_added=UINT(value,**{'sizeinbytes': 1, 'default': 0})

137

138 - def __delfield_user_added(self): del self.__field_user_added

139 140 user_added=property(__getfield_user_added, __setfield_user_added, __delfield_user_added, "=1 when was added by user") 141

142 - def iscontainer(self):

143 return True

144

145 - def containerelements(self):

146 yield ('name', self.__field_name, None) 147 yield ('groupid', self.__field_groupid, None) 148 yield ('user_added', self.__field_user_added, "=1 when was added by user")

149 150 151 152

153 -class pbgroups(BaseProtogenClass):

154 "Phonebook groups" 155 __fields=['groups'] 156

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

158 dict={} 159 # What was supplied to this function 160 dict.update(kwargs) 161 # Parent constructor 162 super(pbgroups,self).__init__(**dict) 163 if self.__class__ is pbgroups: 164 self._update(args,dict)

165 166

167 - def getfields(self):

168 return self.__fields

169 170

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

172 super(pbgroups,self)._update(args,kwargs) 173 keys=kwargs.keys() 174 for key in keys: 175 if key in self.__fields: 176 setattr(self, key, kwargs[key]) 177 del kwargs[key] 178 # Were any unrecognized kwargs passed in? 179 if __debug__: 180 self._complainaboutunusedargs(pbgroups,kwargs) 181 if len(args): 182 dict2={'elementclass': pbgroup, 'raiseonincompleteread': False, 'length': MAX_PHONEBOOK_GROUPS, 'createdefault': True} 183 dict2.update(kwargs) 184 kwargs=dict2 185 self.__field_groups=LIST(*args,**dict2)

186 # Make all P fields that haven't already been constructed 187 188

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

190 'Writes this packet to the supplied buffer' 191 self._bufferstartoffset=buf.getcurrentoffset() 192 try: self.__field_groups 193 except: 194 self.__field_groups=LIST(**{'elementclass': pbgroup, 'raiseonincompleteread': False, 'length': MAX_PHONEBOOK_GROUPS, 'createdefault': True}) 195 self.__field_groups.writetobuffer(buf) 196 self._bufferendoffset=buf.getcurrentoffset() 197 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

198 199

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

201 'Reads this packet from the supplied buffer' 202 self._bufferstartoffset=buf.getcurrentoffset() 203 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 204 self.__field_groups=LIST(**{'elementclass': pbgroup, 'raiseonincompleteread': False, 'length': MAX_PHONEBOOK_GROUPS, 'createdefault': True}) 205 self.__field_groups.readfrombuffer(buf) 206 self._bufferendoffset=buf.getcurrentoffset()

207 208

209 - def __getfield_groups(self):

210 try: self.__field_groups 211 except: 212 self.__field_groups=LIST(**{'elementclass': pbgroup, 'raiseonincompleteread': False, 'length': MAX_PHONEBOOK_GROUPS, 'createdefault': True}) 213 return self.__field_groups.getvalue()

214

215 - def __setfield_groups(self, value):

216 if isinstance(value,LIST): 217 self.__field_groups=value 218 else: 219 self.__field_groups=LIST(value,**{'elementclass': pbgroup, 'raiseonincompleteread': False, 'length': MAX_PHONEBOOK_GROUPS, 'createdefault': True})

220

221 - def __delfield_groups(self): del self.__field_groups

222 223 groups=property(__getfield_groups, __setfield_groups, __delfield_groups, None) 224

225 - def iscontainer(self):

226 return True

227

228 - def containerelements(self):

229 yield ('groups', self.__field_groups, None)

230 231 232 233

234 -class pbfileentry(BaseProtogenClass):

235 __fields=['serial1', 'entrynumber', 'data1', 'ringtone', 'wallpaper', 'data2'] 236

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

238 dict={} 239 # What was supplied to this function 240 dict.update(kwargs) 241 # Parent constructor 242 super(pbfileentry,self).__init__(**dict) 243 if self.__class__ is pbfileentry: 244 self._update(args,dict)

245 246

247 - def getfields(self):

248 return self.__fields

249 250

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

252 super(pbfileentry,self)._update(args,kwargs) 253 keys=kwargs.keys() 254 for key in keys: 255 if key in self.__fields: 256 setattr(self, key, kwargs[key]) 257 del kwargs[key] 258 # Were any unrecognized kwargs passed in? 259 if __debug__: 260 self._complainaboutunusedargs(pbfileentry,kwargs) 261 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

262 # Make all P fields that haven't already been constructed 263 264

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

266 'Writes this packet to the supplied buffer' 267 self._bufferstartoffset=buf.getcurrentoffset() 268 self.__field_serial1.writetobuffer(buf) 269 self.__field_entrynumber.writetobuffer(buf) 270 self.__field_data1.writetobuffer(buf) 271 self.__field_ringtone.writetobuffer(buf) 272 self.__field_wallpaper.writetobuffer(buf) 273 self.__field_data2.writetobuffer(buf) 274 self._bufferendoffset=buf.getcurrentoffset() 275 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

276 277

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

279 'Reads this packet from the supplied buffer' 280 self._bufferstartoffset=buf.getcurrentoffset() 281 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 282 self.__field_serial1=UINT(**{'sizeinbytes': 4}) 283 self.__field_serial1.readfrombuffer(buf) 284 self.__field_entrynumber=UINT(**{'sizeinbytes': 2}) 285 self.__field_entrynumber.readfrombuffer(buf) 286 self.__field_data1=DATA(**{'sizeinbytes': 133}) 287 self.__field_data1.readfrombuffer(buf) 288 self.__field_ringtone=UINT(**{'sizeinbytes': 2}) 289 self.__field_ringtone.readfrombuffer(buf) 290 self.__field_wallpaper=UINT(**{'sizeinbytes': 2}) 291 self.__field_wallpaper.readfrombuffer(buf) 292 self.__field_data2=DATA(**{'sizeinbytes': 15}) 293 self.__field_data2.readfrombuffer(buf) 294 self._bufferendoffset=buf.getcurrentoffset()

295 296

297 - def __getfield_serial1(self):

298 return self.__field_serial1.getvalue()

299

300 - def __setfield_serial1(self, value):

301 if isinstance(value,UINT): 302 self.__field_serial1=value 303 else: 304 self.__field_serial1=UINT(value,**{'sizeinbytes': 4})

305

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

307 308 serial1=property(__getfield_serial1, __setfield_serial1, __delfield_serial1, None) 309

310 - def __getfield_entrynumber(self):

311 return self.__field_entrynumber.getvalue()

312

313 - def __setfield_entrynumber(self, value):

314 if isinstance(value,UINT): 315 self.__field_entrynumber=value 316 else: 317 self.__field_entrynumber=UINT(value,**{'sizeinbytes': 2})

318

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

320 321 entrynumber=property(__getfield_entrynumber, __setfield_entrynumber, __delfield_entrynumber, None) 322

323 - def __getfield_data1(self):

324 return self.__field_data1.getvalue()

325

326 - def __setfield_data1(self, value):

327 if isinstance(value,DATA): 328 self.__field_data1=value 329 else: 330 self.__field_data1=DATA(value,**{'sizeinbytes': 133})

331

332 - def __delfield_data1(self): del self.__field_data1

333 334 data1=property(__getfield_data1, __setfield_data1, __delfield_data1, None) 335

336 - def __getfield_ringtone(self):

337 return self.__field_ringtone.getvalue()

338

339 - def __setfield_ringtone(self, value):

340 if isinstance(value,UINT): 341 self.__field_ringtone=value 342 else: 343 self.__field_ringtone=UINT(value,**{'sizeinbytes': 2})

344

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

346 347 ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None) 348

349 - def __getfield_wallpaper(self):

350 return self.__field_wallpaper.getvalue()

351

352 - def __setfield_wallpaper(self, value):

353 if isinstance(value,UINT): 354 self.__field_wallpaper=value 355 else: 356 self.__field_wallpaper=UINT(value,**{'sizeinbytes': 2})

357

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

359 360 wallpaper=property(__getfield_wallpaper, __setfield_wallpaper, __delfield_wallpaper, None) 361

362 - def __getfield_data2(self):

363 return self.__field_data2.getvalue()

364

365 - def __setfield_data2(self, value):

366 if isinstance(value,DATA): 367 self.__field_data2=value 368 else: 369 self.__field_data2=DATA(value,**{'sizeinbytes': 15})

370

371 - def __delfield_data2(self): del self.__field_data2

372 373 data2=property(__getfield_data2, __setfield_data2, __delfield_data2, None) 374

375 - def iscontainer(self):

376 return True

377

378 - def containerelements(self):

379 yield ('serial1', self.__field_serial1, None) 380 yield ('entrynumber', self.__field_entrynumber, None) 381 yield ('data1', self.__field_data1, None) 382 yield ('ringtone', self.__field_ringtone, None) 383 yield ('wallpaper', self.__field_wallpaper, None) 384 yield ('data2', self.__field_data2, None)

385 386 387 388

389 -class pbfile(BaseProtogenClass):

390 __fields=['items'] 391

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

393 dict={} 394 # What was supplied to this function 395 dict.update(kwargs) 396 # Parent constructor 397 super(pbfile,self).__init__(**dict) 398 if self.__class__ is pbfile: 399 self._update(args,dict)

400 401

402 - def getfields(self):

403 return self.__fields

404 405

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

407 super(pbfile,self)._update(args,kwargs) 408 keys=kwargs.keys() 409 for key in keys: 410 if key in self.__fields: 411 setattr(self, key, kwargs[key]) 412 del kwargs[key] 413 # Were any unrecognized kwargs passed in? 414 if __debug__: 415 self._complainaboutunusedargs(pbfile,kwargs) 416 if len(args): 417 dict2={ 'elementclass': pbfileentry } 418 dict2.update(kwargs) 419 kwargs=dict2 420 self.__field_items=LIST(*args,**dict2)

421 # Make all P fields that haven't already been constructed 422 423

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

425 'Writes this packet to the supplied buffer' 426 self._bufferstartoffset=buf.getcurrentoffset() 427 self.__field_items.writetobuffer(buf) 428 self._bufferendoffset=buf.getcurrentoffset() 429 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

430 431

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

433 'Reads this packet from the supplied buffer' 434 self._bufferstartoffset=buf.getcurrentoffset() 435 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 436 self.__field_items=LIST(**{ 'elementclass': pbfileentry }) 437 self.__field_items.readfrombuffer(buf) 438 self._bufferendoffset=buf.getcurrentoffset()

439 440

441 - def __getfield_items(self):

442 return self.__field_items.getvalue()

443

444 - def __setfield_items(self, value):

445 if isinstance(value,LIST): 446 self.__field_items=value 447 else: 448 self.__field_items=LIST(value,**{ 'elementclass': pbfileentry })

449

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

451 452 items=property(__getfield_items, __setfield_items, __delfield_items, None) 453

454 - def iscontainer(self):

455 return True

456

457 - def containerelements(self):

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

459 460 461 462

463 -class PathIndexEntry(BaseProtogenClass):

464 __fields=['pathname'] 465

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

467 dict={} 468 # What was supplied to this function 469 dict.update(kwargs) 470 # Parent constructor 471 super(PathIndexEntry,self).__init__(**dict) 472 if self.__class__ is PathIndexEntry: 473 self._update(args,dict)

474 475

476 - def getfields(self):

477 return self.__fields

478 479

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

481 super(PathIndexEntry,self)._update(args,kwargs) 482 keys=kwargs.keys() 483 for key in keys: 484 if key in self.__fields: 485 setattr(self, key, kwargs[key]) 486 del kwargs[key] 487 # Were any unrecognized kwargs passed in? 488 if __debug__: 489 self._complainaboutunusedargs(PathIndexEntry,kwargs) 490 if len(args): 491 dict2={'sizeinbytes': 255, 'encoding': PHONE_ENCODING, 'default': '' } 492 dict2.update(kwargs) 493 kwargs=dict2 494 self.__field_pathname=USTRING(*args,**dict2)

495 # Make all P fields that haven't already been constructed 496 497

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

499 'Writes this packet to the supplied buffer' 500 self._bufferstartoffset=buf.getcurrentoffset() 501 try: self.__field_pathname 502 except: 503 self.__field_pathname=USTRING(**{'sizeinbytes': 255, 'encoding': PHONE_ENCODING, 'default': '' }) 504 self.__field_pathname.writetobuffer(buf) 505 self._bufferendoffset=buf.getcurrentoffset() 506 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

507 508

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

510 'Reads this packet from the supplied buffer' 511 self._bufferstartoffset=buf.getcurrentoffset() 512 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 513 self.__field_pathname=USTRING(**{'sizeinbytes': 255, 'encoding': PHONE_ENCODING, 'default': '' }) 514 self.__field_pathname.readfrombuffer(buf) 515 self._bufferendoffset=buf.getcurrentoffset()

516 517

518 - def __getfield_pathname(self):

519 try: self.__field_pathname 520 except: 521 self.__field_pathname=USTRING(**{'sizeinbytes': 255, 'encoding': PHONE_ENCODING, 'default': '' }) 522 return self.__field_pathname.getvalue()

523

524 - def __setfield_pathname(self, value):

525 if isinstance(value,USTRING): 526 self.__field_pathname=value 527 else: 528 self.__field_pathname=USTRING(value,**{'sizeinbytes': 255, 'encoding': PHONE_ENCODING, 'default': '' })

529

530 - def __delfield_pathname(self): del self.__field_pathname

531 532 pathname=property(__getfield_pathname, __setfield_pathname, __delfield_pathname, None) 533

534 - def iscontainer(self):

535 return True

536

537 - def containerelements(self):

538 yield ('pathname', self.__field_pathname, None)

539 540 541 542

543 -class PathIndexFile(BaseProtogenClass):

544 __fields=['items'] 545

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

547 dict={} 548 # What was supplied to this function 549 dict.update(kwargs) 550 # Parent constructor 551 super(PathIndexFile,self).__init__(**dict) 552 if self.__class__ is PathIndexFile: 553 self._update(args,dict)

554 555

556 - def getfields(self):

557 return self.__fields

558 559

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

561 super(PathIndexFile,self)._update(args,kwargs) 562 keys=kwargs.keys() 563 for key in keys: 564 if key in self.__fields: 565 setattr(self, key, kwargs[key]) 566 del kwargs[key] 567 # Were any unrecognized kwargs passed in? 568 if __debug__: 569 self._complainaboutunusedargs(PathIndexFile,kwargs) 570 if len(args): 571 dict2={ 'elementclass': PathIndexEntry, 'createdefault': True, 'length': NUMPHONEBOOKENTRIES } 572 dict2.update(kwargs) 573 kwargs=dict2 574 self.__field_items=LIST(*args,**dict2)

575 # Make all P fields that haven't already been constructed 576 577

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

579 'Writes this packet to the supplied buffer' 580 self._bufferstartoffset=buf.getcurrentoffset() 581 try: self.__field_items 582 except: 583 self.__field_items=LIST(**{ 'elementclass': PathIndexEntry, 'createdefault': True, 'length': NUMPHONEBOOKENTRIES }) 584 self.__field_items.writetobuffer(buf) 585 self._bufferendoffset=buf.getcurrentoffset() 586 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

587 588

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

590 'Reads this packet from the supplied buffer' 591 self._bufferstartoffset=buf.getcurrentoffset() 592 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 593 self.__field_items=LIST(**{ 'elementclass': PathIndexEntry, 'createdefault': True, 'length': NUMPHONEBOOKENTRIES }) 594 self.__field_items.readfrombuffer(buf) 595 self._bufferendoffset=buf.getcurrentoffset()

596 597

598 - def __getfield_items(self):

599 try: self.__field_items 600 except: 601 self.__field_items=LIST(**{ 'elementclass': PathIndexEntry, 'createdefault': True, 'length': NUMPHONEBOOKENTRIES }) 602 return self.__field_items.getvalue()

603

604 - def __setfield_items(self, value):

605 if isinstance(value,LIST): 606 self.__field_items=value 607 else: 608 self.__field_items=LIST(value,**{ 'elementclass': PathIndexEntry, 'createdefault': True, 'length': NUMPHONEBOOKENTRIES })

609

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

611 612 items=property(__getfield_items, __setfield_items, __delfield_items, None) 613

614 - def iscontainer(self):

615 return True

616

617 - def containerelements(self):

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

619 620 621 622

623 -class scheduleevent(BaseProtogenClass):

624 __fields=['pos', 'description', 'cdate', 'mdate', 'start', 'end_time', 'end_date', 'repeat', 'alarmindex_vibrate', 'ringtone', 'unknown1', 'alarmminutes', 'alarmhours', 'unknown2', 'unknown3', 'unknown4'] 625

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

627 dict={} 628 # What was supplied to this function 629 dict.update(kwargs) 630 # Parent constructor 631 super(scheduleevent,self).__init__(**dict) 632 if self.__class__ is scheduleevent: 633 self._update(args,dict)

634 635

636 - def getfields(self):

637 return self.__fields

638 639

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

641 super(scheduleevent,self)._update(args,kwargs) 642 keys=kwargs.keys() 643 for key in keys: 644 if key in self.__fields: 645 setattr(self, key, kwargs[key]) 646 del kwargs[key] 647 # Were any unrecognized kwargs passed in? 648 if __debug__: 649 self._complainaboutunusedargs(scheduleevent,kwargs) 650 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

651 # Make all P fields that haven't already been constructed 652 653

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

655 'Writes this packet to the supplied buffer' 656 self._bufferstartoffset=buf.getcurrentoffset() 657 self.__field_pos.writetobuffer(buf) 658 self.__field_description.writetobuffer(buf) 659 try: self.__field_cdate 660 except: 661 self.__field_cdate=GPSDATE(**{'sizeinbytes': 4, 'default': GPSDATE.now() }) 662 self.__field_cdate.writetobuffer(buf) 663 try: self.__field_mdate 664 except: 665 self.__field_mdate=GPSDATE(**{'sizeinbytes': 4, 'default': GPSDATE.now() }) 666 self.__field_mdate.writetobuffer(buf) 667 self.__field_start.writetobuffer(buf) 668 self.__field_end_time.writetobuffer(buf) 669 self.__field_end_date.writetobuffer(buf) 670 self.__field_repeat.writetobuffer(buf) 671 self.__field_alarmindex_vibrate.writetobuffer(buf) 672 self.__field_ringtone.writetobuffer(buf) 673 self.__field_unknown1.writetobuffer(buf) 674 self.__field_alarmminutes.writetobuffer(buf) 675 self.__field_alarmhours.writetobuffer(buf) 676 try: self.__field_unknown2 677 except: 678 self.__field_unknown2=UINT(**{'sizeinbytes': 1, 'default': 0 }) 679 self.__field_unknown2.writetobuffer(buf) 680 try: self.__field_unknown3 681 except: 682 self.__field_unknown3=UINT(**{'sizeinbytes': 2, 'default': 0x01FA }) 683 self.__field_unknown3.writetobuffer(buf) 684 try: self.__field_unknown4 685 except: 686 self.__field_unknown4=USTRING(**{'sizeinbytes': 69, 'default': '', 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False }) 687 self.__field_unknown4.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_pos=UINT(**{'sizeinbytes': 4}) 697 self.__field_pos.readfrombuffer(buf) 698 self.__field_description=USTRING(**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False }) 699 self.__field_description.readfrombuffer(buf) 700 self.__field_cdate=GPSDATE(**{'sizeinbytes': 4, 'default': GPSDATE.now() }) 701 self.__field_cdate.readfrombuffer(buf) 702 self.__field_mdate=GPSDATE(**{'sizeinbytes': 4, 'default': GPSDATE.now() }) 703 self.__field_mdate.readfrombuffer(buf) 704 self.__field_start=LGCALDATE(**{'sizeinbytes': 4}) 705 self.__field_start.readfrombuffer(buf) 706 self.__field_end_time=LGCALDATE(**{'sizeinbytes': 4}) 707 self.__field_end_time.readfrombuffer(buf) 708 self.__field_end_date=LGCALDATE(**{'sizeinbytes': 4}) 709 self.__field_end_date.readfrombuffer(buf) 710 self.__field_repeat=LGCALREPEAT(**{'sizeinbytes': 4}) 711 self.__field_repeat.readfrombuffer(buf) 712 self.__field_alarmindex_vibrate=UINT(**{'sizeinbytes': 1}) 713 self.__field_alarmindex_vibrate.readfrombuffer(buf) 714 self.__field_ringtone=UINT(**{'sizeinbytes': 1}) 715 self.__field_ringtone.readfrombuffer(buf) 716 self.__field_unknown1=UINT(**{'sizeinbytes': 1}) 717 self.__field_unknown1.readfrombuffer(buf) 718 self.__field_alarmminutes=UINT(**{'sizeinbytes': 1}) 719 self.__field_alarmminutes.readfrombuffer(buf) 720 self.__field_alarmhours=UINT(**{'sizeinbytes': 1}) 721 self.__field_alarmhours.readfrombuffer(buf) 722 self.__field_unknown2=UINT(**{'sizeinbytes': 1, 'default': 0 }) 723 self.__field_unknown2.readfrombuffer(buf) 724 self.__field_unknown3=UINT(**{'sizeinbytes': 2, 'default': 0x01FA }) 725 self.__field_unknown3.readfrombuffer(buf) 726 self.__field_unknown4=USTRING(**{'sizeinbytes': 69, 'default': '', 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False }) 727 self.__field_unknown4.readfrombuffer(buf) 728 self._bufferendoffset=buf.getcurrentoffset()

729 730

731 - def __getfield_pos(self):

732 return self.__field_pos.getvalue()

733

734 - def __setfield_pos(self, value):

735 if isinstance(value,UINT): 736 self.__field_pos=value 737 else: 738 self.__field_pos=UINT(value,**{'sizeinbytes': 4})

739

740 - def __delfield_pos(self): del self.__field_pos

741 742 pos=property(__getfield_pos, __setfield_pos, __delfield_pos, "position within file, used as an event id") 743

744 - def __getfield_description(self):

745 return self.__field_description.getvalue()

746

747 - def __setfield_description(self, value):

748 if isinstance(value,USTRING): 749 self.__field_description=value 750 else: 751 self.__field_description=USTRING(value,**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False })

752

753 - def __delfield_description(self): del self.__field_description

754 755 description=property(__getfield_description, __setfield_description, __delfield_description, None) 756

757 - def __getfield_cdate(self):

758 try: self.__field_cdate 759 except: 760 self.__field_cdate=GPSDATE(**{'sizeinbytes': 4, 'default': GPSDATE.now() }) 761 return self.__field_cdate.getvalue()

762

763 - def __setfield_cdate(self, value):

764 if isinstance(value,GPSDATE): 765 self.__field_cdate=value 766 else: 767 self.__field_cdate=GPSDATE(value,**{'sizeinbytes': 4, 'default': GPSDATE.now() })

768

769 - def __delfield_cdate(self): del self.__field_cdate

770 771 cdate=property(__getfield_cdate, __setfield_cdate, __delfield_cdate, None) 772

773 - def __getfield_mdate(self):

774 try: self.__field_mdate 775 except: 776 self.__field_mdate=GPSDATE(**{'sizeinbytes': 4, 'default': GPSDATE.now() }) 777 return self.__field_mdate.getvalue()

778

779 - def __setfield_mdate(self, value):

780 if isinstance(value,GPSDATE): 781 self.__field_mdate=value 782 else: 783 self.__field_mdate=GPSDATE(value,**{'sizeinbytes': 4, 'default': GPSDATE.now() })

784

785 - def __delfield_mdate(self): del self.__field_mdate

786 787 mdate=property(__getfield_mdate, __setfield_mdate, __delfield_mdate, None) 788

789 - def __getfield_start(self):

790 return self.__field_start.getvalue()

791

792 - def __setfield_start(self, value):

793 if isinstance(value,LGCALDATE): 794 self.__field_start=value 795 else: 796 self.__field_start=LGCALDATE(value,**{'sizeinbytes': 4})

797

798 - def __delfield_start(self): del self.__field_start

799 800 start=property(__getfield_start, __setfield_start, __delfield_start, None) 801

802 - def __getfield_end_time(self):

803 return self.__field_end_time.getvalue()

804

805 - def __setfield_end_time(self, value):

806 if isinstance(value,LGCALDATE): 807 self.__field_end_time=value 808 else: 809 self.__field_end_time=LGCALDATE(value,**{'sizeinbytes': 4})

810

811 - def __delfield_end_time(self): del self.__field_end_time

812 813 end_time=property(__getfield_end_time, __setfield_end_time, __delfield_end_time, None) 814

815 - def __getfield_end_date(self):

816 return self.__field_end_date.getvalue()

817

818 - def __setfield_end_date(self, value):

819 if isinstance(value,LGCALDATE): 820 self.__field_end_date=value 821 else: 822 self.__field_end_date=LGCALDATE(value,**{'sizeinbytes': 4})

823

824 - def __delfield_end_date(self): del self.__field_end_date

825 826 end_date=property(__getfield_end_date, __setfield_end_date, __delfield_end_date, None) 827

828 - def __getfield_repeat(self):

829 return self.__field_repeat.getvalue()

830

831 - def __setfield_repeat(self, value):

832 if isinstance(value,LGCALREPEAT): 833 self.__field_repeat=value 834 else: 835 self.__field_repeat=LGCALREPEAT(value,**{'sizeinbytes': 4})

836

837 - def __delfield_repeat(self): del self.__field_repeat

838 839 repeat=property(__getfield_repeat, __setfield_repeat, __delfield_repeat, None) 840

841 - def __getfield_alarmindex_vibrate(self):

842 return self.__field_alarmindex_vibrate.getvalue()

843

844 - def __setfield_alarmindex_vibrate(self, value):

845 if isinstance(value,UINT): 846 self.__field_alarmindex_vibrate=value 847 else: 848 self.__field_alarmindex_vibrate=UINT(value,**{'sizeinbytes': 1})

849

850 - def __delfield_alarmindex_vibrate(self): del self.__field_alarmindex_vibrate

851 852 alarmindex_vibrate=property(__getfield_alarmindex_vibrate, __setfield_alarmindex_vibrate, __delfield_alarmindex_vibrate, None) 853

854 - def __getfield_ringtone(self):

855 return self.__field_ringtone.getvalue()

856

857 - def __setfield_ringtone(self, value):

858 if isinstance(value,UINT): 859 self.__field_ringtone=value 860 else: 861 self.__field_ringtone=UINT(value,**{'sizeinbytes': 1})

862

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

864 865 ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None) 866

867 - def __getfield_unknown1(self):

868 return self.__field_unknown1.getvalue()

869

870 - def __setfield_unknown1(self, value):

871 if isinstance(value,UINT): 872 self.__field_unknown1=value 873 else: 874 self.__field_unknown1=UINT(value,**{'sizeinbytes': 1})

875

876 - def __delfield_unknown1(self): del self.__field_unknown1

877 878 unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None) 879

880 - def __getfield_alarmminutes(self):

881 return self.__field_alarmminutes.getvalue()

882

883 - def __setfield_alarmminutes(self, value):

884 if isinstance(value,UINT): 885 self.__field_alarmminutes=value 886 else: 887 self.__field_alarmminutes=UINT(value,**{'sizeinbytes': 1})

888

889 - def __delfield_alarmminutes(self): del self.__field_alarmminutes

890 891 alarmminutes=property(__getfield_alarmminutes, __setfield_alarmminutes, __delfield_alarmminutes, "a value of 0xFF indicates not set") 892

893 - def __getfield_alarmhours(self):

894 return self.__field_alarmhours.getvalue()

895

896 - def __setfield_alarmhours(self, value):

897 if isinstance(value,UINT): 898 self.__field_alarmhours=value 899 else: 900 self.__field_alarmhours=UINT(value,**{'sizeinbytes': 1})

901

902 - def __delfield_alarmhours(self): del self.__field_alarmhours

903 904 alarmhours=property(__getfield_alarmhours, __setfield_alarmhours, __delfield_alarmhours, "a value of 0xFF indicates not set") 905

906 - def __getfield_unknown2(self):

907 try: self.__field_unknown2 908 except: 909 self.__field_unknown2=UINT(**{'sizeinbytes': 1, 'default': 0 }) 910 return self.__field_unknown2.getvalue()

911

912 - def __setfield_unknown2(self, value):

913 if isinstance(value,UINT): 914 self.__field_unknown2=value 915 else: 916 self.__field_unknown2=UINT(value,**{'sizeinbytes': 1, 'default': 0 })

917

918 - def __delfield_unknown2(self): del self.__field_unknown2

919 920 unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None) 921

922 - def __getfield_unknown3(self):

923 try: self.__field_unknown3 924 except: 925 self.__field_unknown3=UINT(**{'sizeinbytes': 2, 'default': 0x01FA }) 926 return self.__field_unknown3.getvalue()

927

928 - def __setfield_unknown3(self, value):

929 if isinstance(value,UINT): 930 self.__field_unknown3=value 931 else: 932 self.__field_unknown3=UINT(value,**{'sizeinbytes': 2, 'default': 0x01FA })

933

934 - def __delfield_unknown3(self): del self.__field_unknown3

935 936 unknown3=property(__getfield_unknown3, __setfield_unknown3, __delfield_unknown3, None) 937

938 - def __getfield_unknown4(self):

939 try: self.__field_unknown4 940 except: 941 self.__field_unknown4=USTRING(**{'sizeinbytes': 69, 'default': '', 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False }) 942 return self.__field_unknown4.getvalue()

943

944 - def __setfield_unknown4(self, value):

945 if isinstance(value,USTRING): 946 self.__field_unknown4=value 947 else: 948 self.__field_unknown4=USTRING(value,**{'sizeinbytes': 69, 'default': '', 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False })

949

950 - def __delfield_unknown4(self): del self.__field_unknown4

951 952 unknown4=property(__getfield_unknown4, __setfield_unknown4, __delfield_unknown4, None) 953

954 - def iscontainer(self):

955 return True

956

957 - def containerelements(self):

958 yield ('pos', self.__field_pos, "position within file, used as an event id") 959 yield ('description', self.__field_description, None) 960 yield ('cdate', self.__field_cdate, None) 961 yield ('mdate', self.__field_mdate, None) 962 yield ('start', self.__field_start, None) 963 yield ('end_time', self.__field_end_time, None) 964 yield ('end_date', self.__field_end_date, None) 965 yield ('repeat', self.__field_repeat, None) 966 yield ('alarmindex_vibrate', self.__field_alarmindex_vibrate, None) 967 yield ('ringtone', self.__field_ringtone, None) 968 yield ('unknown1', self.__field_unknown1, None) 969 yield ('alarmminutes', self.__field_alarmminutes, "a value of 0xFF indicates not set") 970 yield ('alarmhours', self.__field_alarmhours, "a value of 0xFF indicates not set") 971 yield ('unknown2', self.__field_unknown2, None) 972 yield ('unknown3', self.__field_unknown3, None) 973 yield ('unknown4', self.__field_unknown4, None)

974 975 976 977

978 -class schedulefile(BaseProtogenClass):

979 __fields=['numactiveitems', 'events'] 980

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

982 dict={} 983 # What was supplied to this function 984 dict.update(kwargs) 985 # Parent constructor 986 super(schedulefile,self).__init__(**dict) 987 if self.__class__ is schedulefile: 988 self._update(args,dict)

989 990

991 - def getfields(self):

992 return self.__fields

993 994

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

996 super(schedulefile,self)._update(args,kwargs) 997 keys=kwargs.keys() 998 for key in keys: 999 if key in self.__fields: 1000 setattr(self, key, kwargs[key]) 1001 del kwargs[key] 1002 # Were any unrecognized kwargs passed in? 1003 if __debug__: 1004 self._complainaboutunusedargs(schedulefile,kwargs) 1005 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

1006 # Make all P fields that haven't already been constructed 1007 1008

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

1010 'Writes this packet to the supplied buffer' 1011 self._bufferstartoffset=buf.getcurrentoffset() 1012 self.__field_numactiveitems.writetobuffer(buf) 1013 try: self.__field_events 1014 except: 1015 self.__field_events=LIST(**{'elementclass': scheduleevent}) 1016 self.__field_events.writetobuffer(buf) 1017 self._bufferendoffset=buf.getcurrentoffset() 1018 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

1019 1020

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

1022 'Reads this packet from the supplied buffer' 1023 self._bufferstartoffset=buf.getcurrentoffset() 1024 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1025 self.__field_numactiveitems=UINT(**{'sizeinbytes': 2}) 1026 self.__field_numactiveitems.readfrombuffer(buf) 1027 self.__field_events=LIST(**{'elementclass': scheduleevent}) 1028 self.__field_events.readfrombuffer(buf) 1029 self._bufferendoffset=buf.getcurrentoffset()

1030 1031

1032 - def __getfield_numactiveitems(self):

1033 return self.__field_numactiveitems.getvalue()

1034

1035 - def __setfield_numactiveitems(self, value):

1036 if isinstance(value,UINT): 1037 self.__field_numactiveitems=value 1038 else: 1039 self.__field_numactiveitems=UINT(value,**{'sizeinbytes': 2})

1040

1041 - def __delfield_numactiveitems(self): del self.__field_numactiveitems

1042 1043 numactiveitems=property(__getfield_numactiveitems, __setfield_numactiveitems, __delfield_numactiveitems, None) 1044

1045 - def __getfield_events(self):

1046 try: self.__field_events 1047 except: 1048 self.__field_events=LIST(**{'elementclass': scheduleevent}) 1049 return self.__field_events.getvalue()

1050

1051 - def __setfield_events(self, value):

1052 if isinstance(value,LIST): 1053 self.__field_events=value 1054 else: 1055 self.__field_events=LIST(value,**{'elementclass': scheduleevent})

1056

1057 - def __delfield_events(self): del self.__field_events

1058 1059 events=property(__getfield_events, __setfield_events, __delfield_events, None) 1060

1061 - def iscontainer(self):

1062 return True

1063

1064 - def containerelements(self):

1065 yield ('numactiveitems', self.__field_numactiveitems, None) 1066 yield ('events', self.__field_events, None)

1067 1068 1069 1070

1071 -class textmemo(BaseProtogenClass):

1072 __fields=['text', 'memotime'] 1073

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

1075 dict={} 1076 # What was supplied to this function 1077 dict.update(kwargs) 1078 # Parent constructor 1079 super(textmemo,self).__init__(**dict) 1080 if self.__class__ is textmemo: 1081 self._update(args,dict)

1082 1083

1084 - def getfields(self):

1085 return self.__fields

1086 1087

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

1089 super(textmemo,self)._update(args,kwargs) 1090 keys=kwargs.keys() 1091 for key in keys: 1092 if key in self.__fields: 1093 setattr(self, key, kwargs[key]) 1094 del kwargs[key] 1095 # Were any unrecognized kwargs passed in? 1096 if __debug__: 1097 self._complainaboutunusedargs(textmemo,kwargs) 1098 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

1099 # Make all P fields that haven't already been constructed 1100 1101

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

1103 'Writes this packet to the supplied buffer' 1104 self._bufferstartoffset=buf.getcurrentoffset() 1105 self.__field_text.writetobuffer(buf) 1106 self.__field_memotime.writetobuffer(buf) 1107 self._bufferendoffset=buf.getcurrentoffset() 1108 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

1109 1110

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

1112 'Reads this packet from the supplied buffer' 1113 self._bufferstartoffset=buf.getcurrentoffset() 1114 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1115 self.__field_text=USTRING(**{'sizeinbytes': 301, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False }) 1116 self.__field_text.readfrombuffer(buf) 1117 self.__field_memotime=LGCALDATE(**{'sizeinbytes': 4}) 1118 self.__field_memotime.readfrombuffer(buf) 1119 self._bufferendoffset=buf.getcurrentoffset()

1120 1121

1122 - def __getfield_text(self):

1123 return self.__field_text.getvalue()

1124

1125 - def __setfield_text(self, value):

1126 if isinstance(value,USTRING): 1127 self.__field_text=value 1128 else: 1129 self.__field_text=USTRING(value,**{'sizeinbytes': 301, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False })

1130

1131 - def __delfield_text(self): del self.__field_text

1132 1133 text=property(__getfield_text, __setfield_text, __delfield_text, None) 1134

1135 - def __getfield_memotime(self):

1136 return self.__field_memotime.getvalue()

1137

1138 - def __setfield_memotime(self, value):

1139 if isinstance(value,LGCALDATE): 1140 self.__field_memotime=value 1141 else: 1142 self.__field_memotime=LGCALDATE(value,**{'sizeinbytes': 4})

1143

1144 - def __delfield_memotime(self): del self.__field_memotime

1145 1146 memotime=property(__getfield_memotime, __setfield_memotime, __delfield_memotime, None) 1147

1148 - def iscontainer(self):

1149 return True

1150

1151 - def containerelements(self):

1152 yield ('text', self.__field_text, None) 1153 yield ('memotime', self.__field_memotime, None)

1154 1155 1156 1157

1158 -class textmemofile(BaseProtogenClass):

1159 __fields=['itemcount', 'items'] 1160

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

1162 dict={} 1163 # What was supplied to this function 1164 dict.update(kwargs) 1165 # Parent constructor 1166 super(textmemofile,self).__init__(**dict) 1167 if self.__class__ is textmemofile: 1168 self._update(args,dict)

1169 1170

1171 - def getfields(self):

1172 return self.__fields

1173 1174

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

1176 super(textmemofile,self)._update(args,kwargs) 1177 keys=kwargs.keys() 1178 for key in keys: 1179 if key in self.__fields: 1180 setattr(self, key, kwargs[key]) 1181 del kwargs[key] 1182 # Were any unrecognized kwargs passed in? 1183 if __debug__: 1184 self._complainaboutunusedargs(textmemofile,kwargs) 1185 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

1186 # Make all P fields that haven't already been constructed 1187 1188

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

1190 'Writes this packet to the supplied buffer' 1191 self._bufferstartoffset=buf.getcurrentoffset() 1192 self.__field_itemcount.writetobuffer(buf) 1193 try: self.__field_items 1194 except: 1195 self.__field_items=LIST(**{ 'elementclass': textmemo }) 1196 self.__field_items.writetobuffer(buf) 1197 self._bufferendoffset=buf.getcurrentoffset() 1198 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

1199 1200

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

1202 'Reads this packet from the supplied buffer' 1203 self._bufferstartoffset=buf.getcurrentoffset() 1204 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1205 self.__field_itemcount=UINT(**{'sizeinbytes': 4}) 1206 self.__field_itemcount.readfrombuffer(buf) 1207 self.__field_items=LIST(**{ 'elementclass': textmemo }) 1208 self.__field_items.readfrombuffer(buf) 1209 self._bufferendoffset=buf.getcurrentoffset()

1210 1211

1212 - def __getfield_itemcount(self):

1213 return self.__field_itemcount.getvalue()

1214

1215 - def __setfield_itemcount(self, value):

1216 if isinstance(value,UINT): 1217 self.__field_itemcount=value 1218 else: 1219 self.__field_itemcount=UINT(value,**{'sizeinbytes': 4})

1220

1221 - def __delfield_itemcount(self): del self.__field_itemcount

1222 1223 itemcount=property(__getfield_itemcount, __setfield_itemcount, __delfield_itemcount, None) 1224

1225 - def __getfield_items(self):

1226 try: self.__field_items 1227 except: 1228 self.__field_items=LIST(**{ 'elementclass': textmemo }) 1229 return self.__field_items.getvalue()

1230

1231 - def __setfield_items(self, value):

1232 if isinstance(value,LIST): 1233 self.__field_items=value 1234 else: 1235 self.__field_items=LIST(value,**{ 'elementclass': textmemo })

1236

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

1238 1239 items=property(__getfield_items, __setfield_items, __delfield_items, None) 1240

1241 - def iscontainer(self):

1242 return True

1243

1244 - def containerelements(self):

1245 yield ('itemcount', self.__field_itemcount, None) 1246 yield ('items', self.__field_items, None)

1247

Source Code for Module phones.p_lgvx8700