phones.p_samsungscha930

1 # THIS FILE IS AUTOMATICALLY GENERATED. EDIT THE SOURCE FILE NOT THIS ONE 2 3 """Various descriptions of data specific to the Samsung SCH-A950 Phone""" 4 5 from prototypes import * 6 from prototypes_samsung import * 7 from p_brew import * 8 from p_samsungscha950 import * 9 10 # We use LSB for all integer like fields 11 UINT=UINTlsb 12 BOOL=BOOLlsb 13 14 # Calendar stuff 15 CAL_PATH='sch_event' 16 CAL_INDEX_FILE_NAME=CAL_PATH+'/usr_tsk' 17 CAL_FILE_NAME_PREFIX=CAL_PATH+'/usr_tsk_' 18 CAL_MAX_EVENTS=100 19 20 CAL_REMINDER_OFF=3 21 CAL_REMINDER_ONCE=0 22 CAL_REMINDER_2MIN=1 23 CAL_REMINDER_15MIN=2 24 25 # vide stuff 26 FLIX_PATH='brew/16452/mf' 27 28 # Call log/history 29 CL_MAX_ENTRIES=90 30

31 -class WRingtoneIndexEntry(BaseProtogenClass):

32 __fields=['path_prefix', 'pathname', 'eor'] 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(WRingtoneIndexEntry,self).__init__(**dict) 40 if self.__class__ is WRingtoneIndexEntry: 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(WRingtoneIndexEntry,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(WRingtoneIndexEntry,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_path_prefix 66 except: 67 self.__field_path_prefix=STRING(**{ 'terminator': None, 'default': '/ff/' }) 68 self.__field_path_prefix.writetobuffer(buf) 69 self.__field_pathname.writetobuffer(buf) 70 try: self.__field_eor 71 except: 72 self.__field_eor=STRING(**{ 'terminator': None, 'default': '|0|2\x0A' }) 73 self.__field_eor.writetobuffer(buf) 74 self._bufferendoffset=buf.getcurrentoffset() 75 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

76 77

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

79 'Reads this packet from the supplied buffer' 80 self._bufferstartoffset=buf.getcurrentoffset() 81 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 82 self.__field_path_prefix=STRING(**{ 'terminator': None, 'default': '/ff/' }) 83 self.__field_path_prefix.readfrombuffer(buf) 84 self.__field_pathname=STRING(**{ 'terminator': None }) 85 self.__field_pathname.readfrombuffer(buf) 86 self.__field_eor=STRING(**{ 'terminator': None, 'default': '|0|2\x0A' }) 87 self.__field_eor.readfrombuffer(buf) 88 self._bufferendoffset=buf.getcurrentoffset()

89 90

91 - def __getfield_path_prefix(self):

92 try: self.__field_path_prefix 93 except: 94 self.__field_path_prefix=STRING(**{ 'terminator': None, 'default': '/ff/' }) 95 return self.__field_path_prefix.getvalue()

96

97 - def __setfield_path_prefix(self, value):

98 if isinstance(value,STRING): 99 self.__field_path_prefix=value 100 else: 101 self.__field_path_prefix=STRING(value,**{ 'terminator': None, 'default': '/ff/' })

102

103 - def __delfield_path_prefix(self): del self.__field_path_prefix

104 105 path_prefix=property(__getfield_path_prefix, __setfield_path_prefix, __delfield_path_prefix, None) 106

107 - def __getfield_pathname(self):

108 return self.__field_pathname.getvalue()

109

110 - def __setfield_pathname(self, value):

111 if isinstance(value,STRING): 112 self.__field_pathname=value 113 else: 114 self.__field_pathname=STRING(value,**{ 'terminator': None })

115

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

117 118 pathname=property(__getfield_pathname, __setfield_pathname, __delfield_pathname, None) 119

120 - def __getfield_eor(self):

121 try: self.__field_eor 122 except: 123 self.__field_eor=STRING(**{ 'terminator': None, 'default': '|0|2\x0A' }) 124 return self.__field_eor.getvalue()

125

126 - def __setfield_eor(self, value):

127 if isinstance(value,STRING): 128 self.__field_eor=value 129 else: 130 self.__field_eor=STRING(value,**{ 'terminator': None, 'default': '|0|2\x0A' })

131

132 - def __delfield_eor(self): del self.__field_eor

133 134 eor=property(__getfield_eor, __setfield_eor, __delfield_eor, None) 135

136 - def iscontainer(self):

137 return True

138

139 - def containerelements(self):

140 yield ('path_prefix', self.__field_path_prefix, None) 141 yield ('pathname', self.__field_pathname, None) 142 yield ('eor', self.__field_eor, None)

143 144 145 146

147 -class WRingtoneIndexFile(BaseProtogenClass):

148 __fields=['items'] 149

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

151 dict={} 152 # What was supplied to this function 153 dict.update(kwargs) 154 # Parent constructor 155 super(WRingtoneIndexFile,self).__init__(**dict) 156 if self.__class__ is WRingtoneIndexFile: 157 self._update(args,dict)

158 159

160 - def getfields(self):

161 return self.__fields

162 163

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

165 super(WRingtoneIndexFile,self)._update(args,kwargs) 166 keys=kwargs.keys() 167 for key in keys: 168 if key in self.__fields: 169 setattr(self, key, kwargs[key]) 170 del kwargs[key] 171 # Were any unrecognized kwargs passed in? 172 if __debug__: 173 self._complainaboutunusedargs(WRingtoneIndexFile,kwargs) 174 if len(args): 175 dict2={ 'elementclass': WRingtoneIndexEntry } 176 dict2.update(kwargs) 177 kwargs=dict2 178 self.__field_items=LIST(*args,**dict2)

179 # Make all P fields that haven't already been constructed 180 181

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

183 'Writes this packet to the supplied buffer' 184 self._bufferstartoffset=buf.getcurrentoffset() 185 try: self.__field_items 186 except: 187 self.__field_items=LIST(**{ 'elementclass': WRingtoneIndexEntry }) 188 self.__field_items.writetobuffer(buf) 189 self._bufferendoffset=buf.getcurrentoffset() 190 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

191 192

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

194 'Reads this packet from the supplied buffer' 195 self._bufferstartoffset=buf.getcurrentoffset() 196 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 197 self.__field_items=LIST(**{ 'elementclass': WRingtoneIndexEntry }) 198 self.__field_items.readfrombuffer(buf) 199 self._bufferendoffset=buf.getcurrentoffset()

200 201

202 - def __getfield_items(self):

203 try: self.__field_items 204 except: 205 self.__field_items=LIST(**{ 'elementclass': WRingtoneIndexEntry }) 206 return self.__field_items.getvalue()

207

208 - def __setfield_items(self, value):

209 if isinstance(value,LIST): 210 self.__field_items=value 211 else: 212 self.__field_items=LIST(value,**{ 'elementclass': WRingtoneIndexEntry })

213

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

215 216 items=property(__getfield_items, __setfield_items, __delfield_items, None) 217

218 - def iscontainer(self):

219 return True

220

221 - def containerelements(self):

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

223 224 225 226

227 -class RRingtoneIndexEntry(BaseProtogenClass):

228 __fields=['pathname', 'misc'] 229

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

231 dict={} 232 # What was supplied to this function 233 dict.update(kwargs) 234 # Parent constructor 235 super(RRingtoneIndexEntry,self).__init__(**dict) 236 if self.__class__ is RRingtoneIndexEntry: 237 self._update(args,dict)

238 239

240 - def getfields(self):

241 return self.__fields

242 243

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

245 super(RRingtoneIndexEntry,self)._update(args,kwargs) 246 keys=kwargs.keys() 247 for key in keys: 248 if key in self.__fields: 249 setattr(self, key, kwargs[key]) 250 del kwargs[key] 251 # Were any unrecognized kwargs passed in? 252 if __debug__: 253 self._complainaboutunusedargs(RRingtoneIndexEntry,kwargs) 254 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

255 # Make all P fields that haven't already been constructed 256 257

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

259 'Writes this packet to the supplied buffer' 260 self._bufferstartoffset=buf.getcurrentoffset() 261 self.__field_pathname.writetobuffer(buf) 262 self.__field_misc.writetobuffer(buf) 263 self._bufferendoffset=buf.getcurrentoffset() 264 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

265 266

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

268 'Reads this packet from the supplied buffer' 269 self._bufferstartoffset=buf.getcurrentoffset() 270 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 271 self.__field_pathname=STRING(**{ 'terminator': 0x7C }) 272 self.__field_pathname.readfrombuffer(buf) 273 self.__field_misc=STRING(**{ 'terminator': 0x0A }) 274 self.__field_misc.readfrombuffer(buf) 275 self._bufferendoffset=buf.getcurrentoffset()

276 277

278 - def __getfield_pathname(self):

279 return self.__field_pathname.getvalue()

280

281 - def __setfield_pathname(self, value):

282 if isinstance(value,STRING): 283 self.__field_pathname=value 284 else: 285 self.__field_pathname=STRING(value,**{ 'terminator': 0x7C })

286

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

288 289 pathname=property(__getfield_pathname, __setfield_pathname, __delfield_pathname, None) 290

291 - def __getfield_misc(self):

292 return self.__field_misc.getvalue()

293

294 - def __setfield_misc(self, value):

295 if isinstance(value,STRING): 296 self.__field_misc=value 297 else: 298 self.__field_misc=STRING(value,**{ 'terminator': 0x0A })

299

300 - def __delfield_misc(self): del self.__field_misc

301 302 misc=property(__getfield_misc, __setfield_misc, __delfield_misc, None) 303

304 - def iscontainer(self):

305 return True

306

307 - def containerelements(self):

308 yield ('pathname', self.__field_pathname, None) 309 yield ('misc', self.__field_misc, None)

310 311 312 313

314 -class RRingtoneIndexFile(BaseProtogenClass):

315 __fields=['items'] 316

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

318 dict={} 319 # What was supplied to this function 320 dict.update(kwargs) 321 # Parent constructor 322 super(RRingtoneIndexFile,self).__init__(**dict) 323 if self.__class__ is RRingtoneIndexFile: 324 self._update(args,dict)

325 326

327 - def getfields(self):

328 return self.__fields

329 330

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

332 super(RRingtoneIndexFile,self)._update(args,kwargs) 333 keys=kwargs.keys() 334 for key in keys: 335 if key in self.__fields: 336 setattr(self, key, kwargs[key]) 337 del kwargs[key] 338 # Were any unrecognized kwargs passed in? 339 if __debug__: 340 self._complainaboutunusedargs(RRingtoneIndexFile,kwargs) 341 if len(args): 342 dict2={ 'elementclass': RRingtoneIndexEntry } 343 dict2.update(kwargs) 344 kwargs=dict2 345 self.__field_items=LIST(*args,**dict2)

346 # Make all P fields that haven't already been constructed 347 348

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

350 'Writes this packet to the supplied buffer' 351 self._bufferstartoffset=buf.getcurrentoffset() 352 try: self.__field_items 353 except: 354 self.__field_items=LIST(**{ 'elementclass': RRingtoneIndexEntry }) 355 self.__field_items.writetobuffer(buf) 356 self._bufferendoffset=buf.getcurrentoffset() 357 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

358 359

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

361 'Reads this packet from the supplied buffer' 362 self._bufferstartoffset=buf.getcurrentoffset() 363 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 364 self.__field_items=LIST(**{ 'elementclass': RRingtoneIndexEntry }) 365 self.__field_items.readfrombuffer(buf) 366 self._bufferendoffset=buf.getcurrentoffset()

367 368

369 - def __getfield_items(self):

370 try: self.__field_items 371 except: 372 self.__field_items=LIST(**{ 'elementclass': RRingtoneIndexEntry }) 373 return self.__field_items.getvalue()

374

375 - def __setfield_items(self, value):

376 if isinstance(value,LIST): 377 self.__field_items=value 378 else: 379 self.__field_items=LIST(value,**{ 'elementclass': RRingtoneIndexEntry })

380

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

382 383 items=property(__getfield_items, __setfield_items, __delfield_items, None) 384

385 - def iscontainer(self):

386 return True

387

388 - def containerelements(self):

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

390 391 392 393

394 -class CalIndexEntry(BaseProtogenClass):

395 __fields=['index'] 396

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

398 dict={} 399 # What was supplied to this function 400 dict.update(kwargs) 401 # Parent constructor 402 super(CalIndexEntry,self).__init__(**dict) 403 if self.__class__ is CalIndexEntry: 404 self._update(args,dict)

405 406

407 - def getfields(self):

408 return self.__fields

409 410

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

412 super(CalIndexEntry,self)._update(args,kwargs) 413 keys=kwargs.keys() 414 for key in keys: 415 if key in self.__fields: 416 setattr(self, key, kwargs[key]) 417 del kwargs[key] 418 # Were any unrecognized kwargs passed in? 419 if __debug__: 420 self._complainaboutunusedargs(CalIndexEntry,kwargs) 421 if len(args): 422 dict2={'sizeinbytes': 2, 'default': 0 } 423 dict2.update(kwargs) 424 kwargs=dict2 425 self.__field_index=UINT(*args,**dict2)

426 # Make all P fields that haven't already been constructed 427 428

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

430 'Writes this packet to the supplied buffer' 431 self._bufferstartoffset=buf.getcurrentoffset() 432 try: self.__field_index 433 except: 434 self.__field_index=UINT(**{'sizeinbytes': 2, 'default': 0 }) 435 self.__field_index.writetobuffer(buf) 436 self._bufferendoffset=buf.getcurrentoffset() 437 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

438 439

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

441 'Reads this packet from the supplied buffer' 442 self._bufferstartoffset=buf.getcurrentoffset() 443 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 444 self.__field_index=UINT(**{'sizeinbytes': 2, 'default': 0 }) 445 self.__field_index.readfrombuffer(buf) 446 self._bufferendoffset=buf.getcurrentoffset()

447 448

449 - def __getfield_index(self):

450 try: self.__field_index 451 except: 452 self.__field_index=UINT(**{'sizeinbytes': 2, 'default': 0 }) 453 return self.__field_index.getvalue()

454

455 - def __setfield_index(self, value):

456 if isinstance(value,UINT): 457 self.__field_index=value 458 else: 459 self.__field_index=UINT(value,**{'sizeinbytes': 2, 'default': 0 })

460

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

462 463 index=property(__getfield_index, __setfield_index, __delfield_index, None) 464

465 - def iscontainer(self):

466 return True

467

468 - def containerelements(self):

469 yield ('index', self.__field_index, None)

470 471 472 473

474 -class CalIndexFile(BaseProtogenClass):

475 __fields=['next_index', 'zero1', 'numofevents', 'zero2', 'numofnotes', 'zero3', 'numofactiveevents', 'zero4', 'events', 'notes', 'activeevents'] 476

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

478 dict={} 479 # What was supplied to this function 480 dict.update(kwargs) 481 # Parent constructor 482 super(CalIndexFile,self).__init__(**dict) 483 if self.__class__ is CalIndexFile: 484 self._update(args,dict)

485 486

487 - def getfields(self):

488 return self.__fields

489 490

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

492 super(CalIndexFile,self)._update(args,kwargs) 493 keys=kwargs.keys() 494 for key in keys: 495 if key in self.__fields: 496 setattr(self, key, kwargs[key]) 497 del kwargs[key] 498 # Were any unrecognized kwargs passed in? 499 if __debug__: 500 self._complainaboutunusedargs(CalIndexFile,kwargs) 501 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

502 # Make all P fields that haven't already been constructed 503 504

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

506 'Writes this packet to the supplied buffer' 507 self._bufferstartoffset=buf.getcurrentoffset() 508 self.__field_next_index.writetobuffer(buf) 509 try: self.__field_zero1 510 except: 511 self.__field_zero1=UNKNOWN(**{'sizeinbytes': 12, 'pad': 0 }) 512 self.__field_zero1.writetobuffer(buf) 513 self.__field_numofevents.writetobuffer(buf) 514 try: self.__field_zero2 515 except: 516 self.__field_zero2=UNKNOWN(**{'sizeinbytes': 6, 'pad': 0 }) 517 self.__field_zero2.writetobuffer(buf) 518 self.__field_numofnotes.writetobuffer(buf) 519 try: self.__field_zero3 520 except: 521 self.__field_zero3=UNKNOWN(**{'sizeinbytes': 2, 'pad': 0 }) 522 self.__field_zero3.writetobuffer(buf) 523 self.__field_numofactiveevents.writetobuffer(buf) 524 try: self.__field_zero4 525 except: 526 self.__field_zero4=UNKNOWN(**{'sizeinbytes': 112, 'pad': 0 }) 527 self.__field_zero4.writetobuffer(buf) 528 try: self.__field_events 529 except: 530 self.__field_events=LIST(**{ 'elementclass': CalIndexEntry, 'length': 103, 'createdefault': True }) 531 self.__field_events.writetobuffer(buf) 532 try: self.__field_notes 533 except: 534 self.__field_notes=LIST(**{ 'elementclass': CalIndexEntry, 'length': 30, 'createdefault': True }) 535 self.__field_notes.writetobuffer(buf) 536 try: self.__field_activeevents 537 except: 538 self.__field_activeevents=LIST(**{ 'elementclass': CalIndexEntry, 'length': 324, 'createdefault': True }) 539 self.__field_activeevents.writetobuffer(buf) 540 self._bufferendoffset=buf.getcurrentoffset() 541 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

542 543

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

545 'Reads this packet from the supplied buffer' 546 self._bufferstartoffset=buf.getcurrentoffset() 547 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 548 self.__field_next_index=UINT(**{'sizeinbytes': 2}) 549 self.__field_next_index.readfrombuffer(buf) 550 self.__field_zero1=UNKNOWN(**{'sizeinbytes': 12, 'pad': 0 }) 551 self.__field_zero1.readfrombuffer(buf) 552 self.__field_numofevents=UINT(**{'sizeinbytes': 2}) 553 self.__field_numofevents.readfrombuffer(buf) 554 self.__field_zero2=UNKNOWN(**{'sizeinbytes': 6, 'pad': 0 }) 555 self.__field_zero2.readfrombuffer(buf) 556 self.__field_numofnotes=UINT(**{'sizeinbytes': 2}) 557 self.__field_numofnotes.readfrombuffer(buf) 558 self.__field_zero3=UNKNOWN(**{'sizeinbytes': 2, 'pad': 0 }) 559 self.__field_zero3.readfrombuffer(buf) 560 self.__field_numofactiveevents=UINT(**{'sizeinbytes': 2}) 561 self.__field_numofactiveevents.readfrombuffer(buf) 562 self.__field_zero4=UNKNOWN(**{'sizeinbytes': 112, 'pad': 0 }) 563 self.__field_zero4.readfrombuffer(buf) 564 self.__field_events=LIST(**{ 'elementclass': CalIndexEntry, 'length': 103, 'createdefault': True }) 565 self.__field_events.readfrombuffer(buf) 566 self.__field_notes=LIST(**{ 'elementclass': CalIndexEntry, 'length': 30, 'createdefault': True }) 567 self.__field_notes.readfrombuffer(buf) 568 self.__field_activeevents=LIST(**{ 'elementclass': CalIndexEntry, 'length': 324, 'createdefault': True }) 569 self.__field_activeevents.readfrombuffer(buf) 570 self._bufferendoffset=buf.getcurrentoffset()

571 572

573 - def __getfield_next_index(self):

574 return self.__field_next_index.getvalue()

575

576 - def __setfield_next_index(self, value):

577 if isinstance(value,UINT): 578 self.__field_next_index=value 579 else: 580 self.__field_next_index=UINT(value,**{'sizeinbytes': 2})

581

582 - def __delfield_next_index(self): del self.__field_next_index

583 584 next_index=property(__getfield_next_index, __setfield_next_index, __delfield_next_index, None) 585

586 - def __getfield_zero1(self):

587 try: self.__field_zero1 588 except: 589 self.__field_zero1=UNKNOWN(**{'sizeinbytes': 12, 'pad': 0 }) 590 return self.__field_zero1.getvalue()

591

592 - def __setfield_zero1(self, value):

593 if isinstance(value,UNKNOWN): 594 self.__field_zero1=value 595 else: 596 self.__field_zero1=UNKNOWN(value,**{'sizeinbytes': 12, 'pad': 0 })

597

598 - def __delfield_zero1(self): del self.__field_zero1

599 600 zero1=property(__getfield_zero1, __setfield_zero1, __delfield_zero1, None) 601

602 - def __getfield_numofevents(self):

603 return self.__field_numofevents.getvalue()

604

605 - def __setfield_numofevents(self, value):

606 if isinstance(value,UINT): 607 self.__field_numofevents=value 608 else: 609 self.__field_numofevents=UINT(value,**{'sizeinbytes': 2})

610

611 - def __delfield_numofevents(self): del self.__field_numofevents

612 613 numofevents=property(__getfield_numofevents, __setfield_numofevents, __delfield_numofevents, None) 614

615 - def __getfield_zero2(self):

616 try: self.__field_zero2 617 except: 618 self.__field_zero2=UNKNOWN(**{'sizeinbytes': 6, 'pad': 0 }) 619 return self.__field_zero2.getvalue()

620

621 - def __setfield_zero2(self, value):

622 if isinstance(value,UNKNOWN): 623 self.__field_zero2=value 624 else: 625 self.__field_zero2=UNKNOWN(value,**{'sizeinbytes': 6, 'pad': 0 })

626

627 - def __delfield_zero2(self): del self.__field_zero2

628 629 zero2=property(__getfield_zero2, __setfield_zero2, __delfield_zero2, None) 630

631 - def __getfield_numofnotes(self):

632 return self.__field_numofnotes.getvalue()

633

634 - def __setfield_numofnotes(self, value):

635 if isinstance(value,UINT): 636 self.__field_numofnotes=value 637 else: 638 self.__field_numofnotes=UINT(value,**{'sizeinbytes': 2})

639

640 - def __delfield_numofnotes(self): del self.__field_numofnotes

641 642 numofnotes=property(__getfield_numofnotes, __setfield_numofnotes, __delfield_numofnotes, None) 643

644 - def __getfield_zero3(self):

645 try: self.__field_zero3 646 except: 647 self.__field_zero3=UNKNOWN(**{'sizeinbytes': 2, 'pad': 0 }) 648 return self.__field_zero3.getvalue()

649

650 - def __setfield_zero3(self, value):

651 if isinstance(value,UNKNOWN): 652 self.__field_zero3=value 653 else: 654 self.__field_zero3=UNKNOWN(value,**{'sizeinbytes': 2, 'pad': 0 })

655

656 - def __delfield_zero3(self): del self.__field_zero3

657 658 zero3=property(__getfield_zero3, __setfield_zero3, __delfield_zero3, None) 659

660 - def __getfield_numofactiveevents(self):

661 return self.__field_numofactiveevents.getvalue()

662

663 - def __setfield_numofactiveevents(self, value):

664 if isinstance(value,UINT): 665 self.__field_numofactiveevents=value 666 else: 667 self.__field_numofactiveevents=UINT(value,**{'sizeinbytes': 2})

668

669 - def __delfield_numofactiveevents(self): del self.__field_numofactiveevents

670 671 numofactiveevents=property(__getfield_numofactiveevents, __setfield_numofactiveevents, __delfield_numofactiveevents, None) 672

673 - def __getfield_zero4(self):

674 try: self.__field_zero4 675 except: 676 self.__field_zero4=UNKNOWN(**{'sizeinbytes': 112, 'pad': 0 }) 677 return self.__field_zero4.getvalue()

678

679 - def __setfield_zero4(self, value):

680 if isinstance(value,UNKNOWN): 681 self.__field_zero4=value 682 else: 683 self.__field_zero4=UNKNOWN(value,**{'sizeinbytes': 112, 'pad': 0 })

684

685 - def __delfield_zero4(self): del self.__field_zero4

686 687 zero4=property(__getfield_zero4, __setfield_zero4, __delfield_zero4, None) 688

689 - def __getfield_events(self):

690 try: self.__field_events 691 except: 692 self.__field_events=LIST(**{ 'elementclass': CalIndexEntry, 'length': 103, 'createdefault': True }) 693 return self.__field_events.getvalue()

694

695 - def __setfield_events(self, value):

696 if isinstance(value,LIST): 697 self.__field_events=value 698 else: 699 self.__field_events=LIST(value,**{ 'elementclass': CalIndexEntry, 'length': 103, 'createdefault': True })

700

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

702 703 events=property(__getfield_events, __setfield_events, __delfield_events, None) 704

705 - def __getfield_notes(self):

706 try: self.__field_notes 707 except: 708 self.__field_notes=LIST(**{ 'elementclass': CalIndexEntry, 'length': 30, 'createdefault': True }) 709 return self.__field_notes.getvalue()

710

711 - def __setfield_notes(self, value):

712 if isinstance(value,LIST): 713 self.__field_notes=value 714 else: 715 self.__field_notes=LIST(value,**{ 'elementclass': CalIndexEntry, 'length': 30, 'createdefault': True })

716

717 - def __delfield_notes(self): del self.__field_notes

718 719 notes=property(__getfield_notes, __setfield_notes, __delfield_notes, None) 720

721 - def __getfield_activeevents(self):

722 try: self.__field_activeevents 723 except: 724 self.__field_activeevents=LIST(**{ 'elementclass': CalIndexEntry, 'length': 324, 'createdefault': True }) 725 return self.__field_activeevents.getvalue()

726

727 - def __setfield_activeevents(self, value):

728 if isinstance(value,LIST): 729 self.__field_activeevents=value 730 else: 731 self.__field_activeevents=LIST(value,**{ 'elementclass': CalIndexEntry, 'length': 324, 'createdefault': True })

732

733 - def __delfield_activeevents(self): del self.__field_activeevents

734 735 activeevents=property(__getfield_activeevents, __setfield_activeevents, __delfield_activeevents, None) 736

737 - def iscontainer(self):

738 return True

739

740 - def containerelements(self):

741 yield ('next_index', self.__field_next_index, None) 742 yield ('zero1', self.__field_zero1, None) 743 yield ('numofevents', self.__field_numofevents, None) 744 yield ('zero2', self.__field_zero2, None) 745 yield ('numofnotes', self.__field_numofnotes, None) 746 yield ('zero3', self.__field_zero3, None) 747 yield ('numofactiveevents', self.__field_numofactiveevents, None) 748 yield ('zero4', self.__field_zero4, None) 749 yield ('events', self.__field_events, None) 750 yield ('notes', self.__field_notes, None) 751 yield ('activeevents', self.__field_activeevents, None)

752 753 754 755

756 -class CalEntry(BaseProtogenClass):

757 __fields=['titlelen', 'title', 'start', 'zero1', 'start2', 'zero2', 'exptime', 'zero3', 'one', 'repeat', 'three', 'alarm', 'alert', 'reminder', 'zero4', 'duration', 'timezone', 'creationtime', 'zero5', 'modifiedtime', 'zero6', 'ringtonelen', 'ringtone', 'zero7'] 758

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

760 dict={} 761 # What was supplied to this function 762 dict.update(kwargs) 763 # Parent constructor 764 super(CalEntry,self).__init__(**dict) 765 if self.__class__ is CalEntry: 766 self._update(args,dict)

767 768

769 - def getfields(self):

770 return self.__fields

771 772

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

774 super(CalEntry,self)._update(args,kwargs) 775 keys=kwargs.keys() 776 for key in keys: 777 if key in self.__fields: 778 setattr(self, key, kwargs[key]) 779 del kwargs[key] 780 # Were any unrecognized kwargs passed in? 781 if __debug__: 782 self._complainaboutunusedargs(CalEntry,kwargs) 783 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

784 # Make all P fields that haven't already been constructed 785 786

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

788 'Writes this packet to the supplied buffer' 789 self._bufferstartoffset=buf.getcurrentoffset() 790 self.__field_titlelen.writetobuffer(buf) 791 self.__field_title.writetobuffer(buf) 792 self.__field_start.writetobuffer(buf) 793 try: self.__field_zero1 794 except: 795 self.__field_zero1=UNKNOWN(**{'sizeinbytes': 4, 'pad': 0 }) 796 self.__field_zero1.writetobuffer(buf) 797 try: self.__field_start2 798 except: 799 self.__field_start2=DateTime(**{'sizeinbytes': 4, 'default': self.start }) 800 self.__field_start2.writetobuffer(buf) 801 try: self.__field_zero2 802 except: 803 self.__field_zero2=UNKNOWN(**{'sizeinbytes': 4, 'pad': 0 }) 804 self.__field_zero2.writetobuffer(buf) 805 self.__field_exptime.writetobuffer(buf) 806 try: self.__field_zero3 807 except: 808 self.__field_zero3=UNKNOWN(**{'sizeinbytes': 4, 'pad': 0 }) 809 self.__field_zero3.writetobuffer(buf) 810 try: self.__field_one 811 except: 812 self.__field_one=UINT(**{'sizeinbytes': 1, 'default': 1 }) 813 self.__field_one.writetobuffer(buf) 814 self.__field_repeat.writetobuffer(buf) 815 try: self.__field_three 816 except: 817 self.__field_three=UINT(**{'sizeinbytes': 1, 'default': 3 }) 818 self.__field_three.writetobuffer(buf) 819 self.__field_alarm.writetobuffer(buf) 820 self.__field_alert.writetobuffer(buf) 821 try: self.__field_reminder 822 except: 823 self.__field_reminder=UINT(**{'sizeinbytes': 1, 'default': CAL_REMINDER_ONCE }) 824 self.__field_reminder.writetobuffer(buf) 825 try: self.__field_zero4 826 except: 827 self.__field_zero4=UNKNOWN(**{'sizeinbytes': 5, 'pad': 0 }) 828 self.__field_zero4.writetobuffer(buf) 829 self.__field_duration.writetobuffer(buf) 830 self.__field_timezone.writetobuffer(buf) 831 self.__field_creationtime.writetobuffer(buf) 832 try: self.__field_zero5 833 except: 834 self.__field_zero5=UNKNOWN(**{'sizeinbytes': 4, 'pad': 0 }) 835 self.__field_zero5.writetobuffer(buf) 836 self.__field_modifiedtime.writetobuffer(buf) 837 try: self.__field_zero6 838 except: 839 self.__field_zero6=UNKNOWN(**{'sizeinbytes': 4, 'pad': 0 }) 840 self.__field_zero6.writetobuffer(buf) 841 self.__field_ringtonelen.writetobuffer(buf) 842 self.__field_ringtone.writetobuffer(buf) 843 try: self.__field_zero7 844 except: 845 self.__field_zero7=UNKNOWN(**{'sizeinbytes': 2, 'pad': 0 }) 846 self.__field_zero7.writetobuffer(buf) 847 self._bufferendoffset=buf.getcurrentoffset() 848 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

849 850

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

852 'Reads this packet from the supplied buffer' 853 self._bufferstartoffset=buf.getcurrentoffset() 854 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 855 self.__field_titlelen=UINT(**{'sizeinbytes': 2}) 856 self.__field_titlelen.readfrombuffer(buf) 857 self.__field_title=USTRING(**{ 'sizeinbytes': self.titlelen, 'encoding': ENCODING, 'terminator': None }) 858 self.__field_title.readfrombuffer(buf) 859 self.__field_start=DateTime(**{'sizeinbytes': 4}) 860 self.__field_start.readfrombuffer(buf) 861 self.__field_zero1=UNKNOWN(**{'sizeinbytes': 4, 'pad': 0 }) 862 self.__field_zero1.readfrombuffer(buf) 863 self.__field_start2=DateTime(**{'sizeinbytes': 4, 'default': self.start }) 864 self.__field_start2.readfrombuffer(buf) 865 self.__field_zero2=UNKNOWN(**{'sizeinbytes': 4, 'pad': 0 }) 866 self.__field_zero2.readfrombuffer(buf) 867 self.__field_exptime=ExpiringTime(**{'sizeinbytes': 4}) 868 self.__field_exptime.readfrombuffer(buf) 869 self.__field_zero3=UNKNOWN(**{'sizeinbytes': 4, 'pad': 0 }) 870 self.__field_zero3.readfrombuffer(buf) 871 self.__field_one=UINT(**{'sizeinbytes': 1, 'default': 1 }) 872 self.__field_one.readfrombuffer(buf) 873 self.__field_repeat=UINT(**{'sizeinbytes': 1}) 874 self.__field_repeat.readfrombuffer(buf) 875 self.__field_three=UINT(**{'sizeinbytes': 1, 'default': 3 }) 876 self.__field_three.readfrombuffer(buf) 877 self.__field_alarm=UINT(**{'sizeinbytes': 1}) 878 self.__field_alarm.readfrombuffer(buf) 879 self.__field_alert=UINT(**{'sizeinbytes': 1}) 880 self.__field_alert.readfrombuffer(buf) 881 self.__field_reminder=UINT(**{'sizeinbytes': 1, 'default': CAL_REMINDER_ONCE }) 882 self.__field_reminder.readfrombuffer(buf) 883 self.__field_zero4=UNKNOWN(**{'sizeinbytes': 5, 'pad': 0 }) 884 self.__field_zero4.readfrombuffer(buf) 885 self.__field_duration=UINT(**{'sizeinbytes': 4}) 886 self.__field_duration.readfrombuffer(buf) 887 self.__field_timezone=UINT(**{'sizeinbytes': 1}) 888 self.__field_timezone.readfrombuffer(buf) 889 self.__field_creationtime=DateTime(**{'sizeinbytes': 4}) 890 self.__field_creationtime.readfrombuffer(buf) 891 self.__field_zero5=UNKNOWN(**{'sizeinbytes': 4, 'pad': 0 }) 892 self.__field_zero5.readfrombuffer(buf) 893 self.__field_modifiedtime=DateTime(**{'sizeinbytes': 4}) 894 self.__field_modifiedtime.readfrombuffer(buf) 895 self.__field_zero6=UNKNOWN(**{'sizeinbytes': 4, 'pad': 0 }) 896 self.__field_zero6.readfrombuffer(buf) 897 self.__field_ringtonelen=UINT(**{'sizeinbytes': 2}) 898 self.__field_ringtonelen.readfrombuffer(buf) 899 self.__field_ringtone=STRING(**{ 'sizeinbytes': self.ringtonelen, 'terminator': None }) 900 self.__field_ringtone.readfrombuffer(buf) 901 self.__field_zero7=UNKNOWN(**{'sizeinbytes': 2, 'pad': 0 }) 902 self.__field_zero7.readfrombuffer(buf) 903 self._bufferendoffset=buf.getcurrentoffset()

904 905

906 - def __getfield_titlelen(self):

907 return self.__field_titlelen.getvalue()

908

909 - def __setfield_titlelen(self, value):

910 if isinstance(value,UINT): 911 self.__field_titlelen=value 912 else: 913 self.__field_titlelen=UINT(value,**{'sizeinbytes': 2})

914

915 - def __delfield_titlelen(self): del self.__field_titlelen

916 917 titlelen=property(__getfield_titlelen, __setfield_titlelen, __delfield_titlelen, None) 918

919 - def __getfield_title(self):

920 return self.__field_title.getvalue()

921

922 - def __setfield_title(self, value):

923 if isinstance(value,USTRING): 924 self.__field_title=value 925 else: 926 self.__field_title=USTRING(value,**{ 'sizeinbytes': self.titlelen, 'encoding': ENCODING, 'terminator': None })

927

928 - def __delfield_title(self): del self.__field_title

929 930 title=property(__getfield_title, __setfield_title, __delfield_title, None) 931

932 - def __getfield_start(self):

933 return self.__field_start.getvalue()

934

935 - def __setfield_start(self, value):

936 if isinstance(value,DateTime): 937 self.__field_start=value 938 else: 939 self.__field_start=DateTime(value,**{'sizeinbytes': 4})

940

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

942 943 start=property(__getfield_start, __setfield_start, __delfield_start, None) 944

945 - def __getfield_zero1(self):

946 try: self.__field_zero1 947 except: 948 self.__field_zero1=UNKNOWN(**{'sizeinbytes': 4, 'pad': 0 }) 949 return self.__field_zero1.getvalue()

950

951 - def __setfield_zero1(self, value):

952 if isinstance(value,UNKNOWN): 953 self.__field_zero1=value 954 else: 955 self.__field_zero1=UNKNOWN(value,**{'sizeinbytes': 4, 'pad': 0 })

956

957 - def __delfield_zero1(self): del self.__field_zero1

958 959 zero1=property(__getfield_zero1, __setfield_zero1, __delfield_zero1, None) 960

961 - def __getfield_start2(self):

962 try: self.__field_start2 963 except: 964 self.__field_start2=DateTime(**{'sizeinbytes': 4, 'default': self.start }) 965 return self.__field_start2.getvalue()

966

967 - def __setfield_start2(self, value):

968 if isinstance(value,DateTime): 969 self.__field_start2=value 970 else: 971 self.__field_start2=DateTime(value,**{'sizeinbytes': 4, 'default': self.start })

972

973 - def __delfield_start2(self): del self.__field_start2

974 975 start2=property(__getfield_start2, __setfield_start2, __delfield_start2, None) 976

977 - def __getfield_zero2(self):

978 try: self.__field_zero2 979 except: 980 self.__field_zero2=UNKNOWN(**{'sizeinbytes': 4, 'pad': 0 }) 981 return self.__field_zero2.getvalue()

982

983 - def __setfield_zero2(self, value):

984 if isinstance(value,UNKNOWN): 985 self.__field_zero2=value 986 else: 987 self.__field_zero2=UNKNOWN(value,**{'sizeinbytes': 4, 'pad': 0 })

988

989 - def __delfield_zero2(self): del self.__field_zero2

990 991 zero2=property(__getfield_zero2, __setfield_zero2, __delfield_zero2, None) 992

993 - def __getfield_exptime(self):

994 return self.__field_exptime.getvalue()

995

996 - def __setfield_exptime(self, value):

997 if isinstance(value,ExpiringTime): 998 self.__field_exptime=value 999 else: 1000 self.__field_exptime=ExpiringTime(value,**{'sizeinbytes': 4})

1001

1002 - def __delfield_exptime(self): del self.__field_exptime

1003 1004 exptime=property(__getfield_exptime, __setfield_exptime, __delfield_exptime, None) 1005

1006 - def __getfield_zero3(self):

1007 try: self.__field_zero3 1008 except: 1009 self.__field_zero3=UNKNOWN(**{'sizeinbytes': 4, 'pad': 0 }) 1010 return self.__field_zero3.getvalue()

1011

1012 - def __setfield_zero3(self, value):

1013 if isinstance(value,UNKNOWN): 1014 self.__field_zero3=value 1015 else: 1016 self.__field_zero3=UNKNOWN(value,**{'sizeinbytes': 4, 'pad': 0 })

1017

1018 - def __delfield_zero3(self): del self.__field_zero3

1019 1020 zero3=property(__getfield_zero3, __setfield_zero3, __delfield_zero3, None) 1021

1022 - def __getfield_one(self):

1023 try: self.__field_one 1024 except: 1025 self.__field_one=UINT(**{'sizeinbytes': 1, 'default': 1 }) 1026 return self.__field_one.getvalue()

1027

1028 - def __setfield_one(self, value):

1029 if isinstance(value,UINT): 1030 self.__field_one=value 1031 else: 1032 self.__field_one=UINT(value,**{'sizeinbytes': 1, 'default': 1 })

1033

1034 - def __delfield_one(self): del self.__field_one

1035 1036 one=property(__getfield_one, __setfield_one, __delfield_one, None) 1037

1038 - def __getfield_repeat(self):

1039 return self.__field_repeat.getvalue()

1040

1041 - def __setfield_repeat(self, value):

1042 if isinstance(value,UINT): 1043 self.__field_repeat=value 1044 else: 1045 self.__field_repeat=UINT(value,**{'sizeinbytes': 1})

1046

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

1048 1049 repeat=property(__getfield_repeat, __setfield_repeat, __delfield_repeat, None) 1050

1051 - def __getfield_three(self):

1052 try: self.__field_three 1053 except: 1054 self.__field_three=UINT(**{'sizeinbytes': 1, 'default': 3 }) 1055 return self.__field_three.getvalue()

1056

1057 - def __setfield_three(self, value):

1058 if isinstance(value,UINT): 1059 self.__field_three=value 1060 else: 1061 self.__field_three=UINT(value,**{'sizeinbytes': 1, 'default': 3 })

1062

1063 - def __delfield_three(self): del self.__field_three

1064 1065 three=property(__getfield_three, __setfield_three, __delfield_three, None) 1066

1067 - def __getfield_alarm(self):

1068 return self.__field_alarm.getvalue()

1069

1070 - def __setfield_alarm(self, value):

1071 if isinstance(value,UINT): 1072 self.__field_alarm=value 1073 else: 1074 self.__field_alarm=UINT(value,**{'sizeinbytes': 1})

1075

1076 - def __delfield_alarm(self): del self.__field_alarm

1077 1078 alarm=property(__getfield_alarm, __setfield_alarm, __delfield_alarm, None) 1079

1080 - def __getfield_alert(self):

1081 return self.__field_alert.getvalue()

1082

1083 - def __setfield_alert(self, value):

1084 if isinstance(value,UINT): 1085 self.__field_alert=value 1086 else: 1087 self.__field_alert=UINT(value,**{'sizeinbytes': 1})

1088

1089 - def __delfield_alert(self): del self.__field_alert

1090 1091 alert=property(__getfield_alert, __setfield_alert, __delfield_alert, None) 1092

1093 - def __getfield_reminder(self):

1094 try: self.__field_reminder 1095 except: 1096 self.__field_reminder=UINT(**{'sizeinbytes': 1, 'default': CAL_REMINDER_ONCE }) 1097 return self.__field_reminder.getvalue()

1098

1099 - def __setfield_reminder(self, value):

1100 if isinstance(value,UINT): 1101 self.__field_reminder=value 1102 else: 1103 self.__field_reminder=UINT(value,**{'sizeinbytes': 1, 'default': CAL_REMINDER_ONCE })

1104

1105 - def __delfield_reminder(self): del self.__field_reminder

1106 1107 reminder=property(__getfield_reminder, __setfield_reminder, __delfield_reminder, None) 1108

1109 - def __getfield_zero4(self):

1110 try: self.__field_zero4 1111 except: 1112 self.__field_zero4=UNKNOWN(**{'sizeinbytes': 5, 'pad': 0 }) 1113 return self.__field_zero4.getvalue()

1114

1115 - def __setfield_zero4(self, value):

1116 if isinstance(value,UNKNOWN): 1117 self.__field_zero4=value 1118 else: 1119 self.__field_zero4=UNKNOWN(value,**{'sizeinbytes': 5, 'pad': 0 })

1120

1121 - def __delfield_zero4(self): del self.__field_zero4

1122 1123 zero4=property(__getfield_zero4, __setfield_zero4, __delfield_zero4, None) 1124

1125 - def __getfield_duration(self):

1126 return self.__field_duration.getvalue()

1127

1128 - def __setfield_duration(self, value):

1129 if isinstance(value,UINT): 1130 self.__field_duration=value 1131 else: 1132 self.__field_duration=UINT(value,**{'sizeinbytes': 4})

1133

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

1135 1136 duration=property(__getfield_duration, __setfield_duration, __delfield_duration, None) 1137

1138 - def __getfield_timezone(self):

1139 return self.__field_timezone.getvalue()

1140

1141 - def __setfield_timezone(self, value):

1142 if isinstance(value,UINT): 1143 self.__field_timezone=value 1144 else: 1145 self.__field_timezone=UINT(value,**{'sizeinbytes': 1})

1146

1147 - def __delfield_timezone(self): del self.__field_timezone

1148 1149 timezone=property(__getfield_timezone, __setfield_timezone, __delfield_timezone, None) 1150

1151 - def __getfield_creationtime(self):

1152 return self.__field_creationtime.getvalue()

1153

1154 - def __setfield_creationtime(self, value):

1155 if isinstance(value,DateTime): 1156 self.__field_creationtime=value 1157 else: 1158 self.__field_creationtime=DateTime(value,**{'sizeinbytes': 4})

1159

1160 - def __delfield_creationtime(self): del self.__field_creationtime

1161 1162 creationtime=property(__getfield_creationtime, __setfield_creationtime, __delfield_creationtime, None) 1163

1164 - def __getfield_zero5(self):

1165 try: self.__field_zero5 1166 except: 1167 self.__field_zero5=UNKNOWN(**{'sizeinbytes': 4, 'pad': 0 }) 1168 return self.__field_zero5.getvalue()

1169

1170 - def __setfield_zero5(self, value):

1171 if isinstance(value,UNKNOWN): 1172 self.__field_zero5=value 1173 else: 1174 self.__field_zero5=UNKNOWN(value,**{'sizeinbytes': 4, 'pad': 0 })

1175

1176 - def __delfield_zero5(self): del self.__field_zero5

1177 1178 zero5=property(__getfield_zero5, __setfield_zero5, __delfield_zero5, None) 1179

1180 - def __getfield_modifiedtime(self):

1181 return self.__field_modifiedtime.getvalue()

1182

1183 - def __setfield_modifiedtime(self, value):

1184 if isinstance(value,DateTime): 1185 self.__field_modifiedtime=value 1186 else: 1187 self.__field_modifiedtime=DateTime(value,**{'sizeinbytes': 4})

1188

1189 - def __delfield_modifiedtime(self): del self.__field_modifiedtime

1190 1191 modifiedtime=property(__getfield_modifiedtime, __setfield_modifiedtime, __delfield_modifiedtime, None) 1192

1193 - def __getfield_zero6(self):

1194 try: self.__field_zero6 1195 except: 1196 self.__field_zero6=UNKNOWN(**{'sizeinbytes': 4, 'pad': 0 }) 1197 return self.__field_zero6.getvalue()

1198

1199 - def __setfield_zero6(self, value):

1200 if isinstance(value,UNKNOWN): 1201 self.__field_zero6=value 1202 else: 1203 self.__field_zero6=UNKNOWN(value,**{'sizeinbytes': 4, 'pad': 0 })

1204

1205 - def __delfield_zero6(self): del self.__field_zero6

1206 1207 zero6=property(__getfield_zero6, __setfield_zero6, __delfield_zero6, None) 1208

1209 - def __getfield_ringtonelen(self):

1210 return self.__field_ringtonelen.getvalue()

1211

1212 - def __setfield_ringtonelen(self, value):

1213 if isinstance(value,UINT): 1214 self.__field_ringtonelen=value 1215 else: 1216 self.__field_ringtonelen=UINT(value,**{'sizeinbytes': 2})

1217

1218 - def __delfield_ringtonelen(self): del self.__field_ringtonelen

1219 1220 ringtonelen=property(__getfield_ringtonelen, __setfield_ringtonelen, __delfield_ringtonelen, None) 1221

1222 - def __getfield_ringtone(self):

1223 return self.__field_ringtone.getvalue()

1224

1225 - def __setfield_ringtone(self, value):

1226 if isinstance(value,STRING): 1227 self.__field_ringtone=value 1228 else: 1229 self.__field_ringtone=STRING(value,**{ 'sizeinbytes': self.ringtonelen, 'terminator': None })

1230

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

1232 1233 ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None) 1234

1235 - def __getfield_zero7(self):

1236 try: self.__field_zero7 1237 except: 1238 self.__field_zero7=UNKNOWN(**{'sizeinbytes': 2, 'pad': 0 }) 1239 return self.__field_zero7.getvalue()

1240

1241 - def __setfield_zero7(self, value):

1242 if isinstance(value,UNKNOWN): 1243 self.__field_zero7=value 1244 else: 1245 self.__field_zero7=UNKNOWN(value,**{'sizeinbytes': 2, 'pad': 0 })

1246

1247 - def __delfield_zero7(self): del self.__field_zero7

1248 1249 zero7=property(__getfield_zero7, __setfield_zero7, __delfield_zero7, None) 1250

1251 - def iscontainer(self):

1252 return True

1253

1254 - def containerelements(self):

1255 yield ('titlelen', self.__field_titlelen, None) 1256 yield ('title', self.__field_title, None) 1257 yield ('start', self.__field_start, None) 1258 yield ('zero1', self.__field_zero1, None) 1259 yield ('start2', self.__field_start2, None) 1260 yield ('zero2', self.__field_zero2, None) 1261 yield ('exptime', self.__field_exptime, None) 1262 yield ('zero3', self.__field_zero3, None) 1263 yield ('one', self.__field_one, None) 1264 yield ('repeat', self.__field_repeat, None) 1265 yield ('three', self.__field_three, None) 1266 yield ('alarm', self.__field_alarm, None) 1267 yield ('alert', self.__field_alert, None) 1268 yield ('reminder', self.__field_reminder, None) 1269 yield ('zero4', self.__field_zero4, None) 1270 yield ('duration', self.__field_duration, None) 1271 yield ('timezone', self.__field_timezone, None) 1272 yield ('creationtime', self.__field_creationtime, None) 1273 yield ('zero5', self.__field_zero5, None) 1274 yield ('modifiedtime', self.__field_modifiedtime, None) 1275 yield ('zero6', self.__field_zero6, None) 1276 yield ('ringtonelen', self.__field_ringtonelen, None) 1277 yield ('ringtone', self.__field_ringtone, None) 1278 yield ('zero7', self.__field_zero7, None)

1279 1280 1281 1282

1283 -class cl_list(BaseProtogenClass):

1284 __fields=['index'] 1285

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

1287 dict={} 1288 # What was supplied to this function 1289 dict.update(kwargs) 1290 # Parent constructor 1291 super(cl_list,self).__init__(**dict) 1292 if self.__class__ is cl_list: 1293 self._update(args,dict)

1294 1295

1296 - def getfields(self):

1297 return self.__fields

1298 1299

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

1301 super(cl_list,self)._update(args,kwargs) 1302 keys=kwargs.keys() 1303 for key in keys: 1304 if key in self.__fields: 1305 setattr(self, key, kwargs[key]) 1306 del kwargs[key] 1307 # Were any unrecognized kwargs passed in? 1308 if __debug__: 1309 self._complainaboutunusedargs(cl_list,kwargs) 1310 if len(args): 1311 dict2={'sizeinbytes': 2} 1312 dict2.update(kwargs) 1313 kwargs=dict2 1314 self.__field_index=UINT(*args,**dict2)

1315 # Make all P fields that haven't already been constructed 1316 1317

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

1319 'Writes this packet to the supplied buffer' 1320 self._bufferstartoffset=buf.getcurrentoffset() 1321 self.__field_index.writetobuffer(buf) 1322 self._bufferendoffset=buf.getcurrentoffset() 1323 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

1324 1325

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

1327 'Reads this packet from the supplied buffer' 1328 self._bufferstartoffset=buf.getcurrentoffset() 1329 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1330 self.__field_index=UINT(**{'sizeinbytes': 2}) 1331 self.__field_index.readfrombuffer(buf) 1332 self._bufferendoffset=buf.getcurrentoffset()

1333 1334

1335 - def __getfield_index(self):

1336 return self.__field_index.getvalue()

1337

1338 - def __setfield_index(self, value):

1339 if isinstance(value,UINT): 1340 self.__field_index=value 1341 else: 1342 self.__field_index=UINT(value,**{'sizeinbytes': 2})

1343

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

1345 1346 index=property(__getfield_index, __setfield_index, __delfield_index, None) 1347

1348 - def iscontainer(self):

1349 return True

1350

1351 - def containerelements(self):

1352 yield ('index', self.__field_index, None)

1353 1354 1355 1356

1357 -class cl_index_file(BaseProtogenClass):

1358 __fields=['incoming', 'outgoing', 'missed', 'dunno1', 'incoming_count', 'outgoing_count', 'missed_count'] 1359

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

1361 dict={} 1362 # What was supplied to this function 1363 dict.update(kwargs) 1364 # Parent constructor 1365 super(cl_index_file,self).__init__(**dict) 1366 if self.__class__ is cl_index_file: 1367 self._update(args,dict)

1368 1369

1370 - def getfields(self):

1371 return self.__fields

1372 1373

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

1375 super(cl_index_file,self)._update(args,kwargs) 1376 keys=kwargs.keys() 1377 for key in keys: 1378 if key in self.__fields: 1379 setattr(self, key, kwargs[key]) 1380 del kwargs[key] 1381 # Were any unrecognized kwargs passed in? 1382 if __debug__: 1383 self._complainaboutunusedargs(cl_index_file,kwargs) 1384 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

1385 # Make all P fields that haven't already been constructed 1386 1387

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

1389 'Writes this packet to the supplied buffer' 1390 self._bufferstartoffset=buf.getcurrentoffset() 1391 self.__field_incoming.writetobuffer(buf) 1392 self.__field_outgoing.writetobuffer(buf) 1393 self.__field_missed.writetobuffer(buf) 1394 self.__field_dunno1.writetobuffer(buf) 1395 self.__field_incoming_count.writetobuffer(buf) 1396 self.__field_outgoing_count.writetobuffer(buf) 1397 self.__field_missed_count.writetobuffer(buf) 1398 self._bufferendoffset=buf.getcurrentoffset() 1399 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

1400 1401

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

1403 'Reads this packet from the supplied buffer' 1404 self._bufferstartoffset=buf.getcurrentoffset() 1405 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1406 self.__field_incoming=LIST(**{ 'length': CL_MAX_ENTRIES, 'elementclass': cl_list }) 1407 self.__field_incoming.readfrombuffer(buf) 1408 self.__field_outgoing=LIST(**{ 'length': CL_MAX_ENTRIES, 'elementclass': cl_list }) 1409 self.__field_outgoing.readfrombuffer(buf) 1410 self.__field_missed=LIST(**{ 'length': CL_MAX_ENTRIES, 'elementclass': cl_list }) 1411 self.__field_missed.readfrombuffer(buf) 1412 self.__field_dunno1=UNKNOWN(**{'sizeinbytes': 992}) 1413 self.__field_dunno1.readfrombuffer(buf) 1414 self.__field_incoming_count=UINT(**{'sizeinbytes': 4}) 1415 self.__field_incoming_count.readfrombuffer(buf) 1416 self.__field_outgoing_count=UINT(**{'sizeinbytes': 4}) 1417 self.__field_outgoing_count.readfrombuffer(buf) 1418 self.__field_missed_count=UINT(**{'sizeinbytes': 4}) 1419 self.__field_missed_count.readfrombuffer(buf) 1420 self._bufferendoffset=buf.getcurrentoffset()

1421 1422

1423 - def __getfield_incoming(self):

1424 return self.__field_incoming.getvalue()

1425

1426 - def __setfield_incoming(self, value):

1427 if isinstance(value,LIST): 1428 self.__field_incoming=value 1429 else: 1430 self.__field_incoming=LIST(value,**{ 'length': CL_MAX_ENTRIES, 'elementclass': cl_list })

1431

1432 - def __delfield_incoming(self): del self.__field_incoming

1433 1434 incoming=property(__getfield_incoming, __setfield_incoming, __delfield_incoming, None) 1435

1436 - def __getfield_outgoing(self):

1437 return self.__field_outgoing.getvalue()

1438

1439 - def __setfield_outgoing(self, value):

1440 if isinstance(value,LIST): 1441 self.__field_outgoing=value 1442 else: 1443 self.__field_outgoing=LIST(value,**{ 'length': CL_MAX_ENTRIES, 'elementclass': cl_list })

1444

1445 - def __delfield_outgoing(self): del self.__field_outgoing

1446 1447 outgoing=property(__getfield_outgoing, __setfield_outgoing, __delfield_outgoing, None) 1448

1449 - def __getfield_missed(self):

1450 return self.__field_missed.getvalue()

1451

1452 - def __setfield_missed(self, value):

1453 if isinstance(value,LIST): 1454 self.__field_missed=value 1455 else: 1456 self.__field_missed=LIST(value,**{ 'length': CL_MAX_ENTRIES, 'elementclass': cl_list })

1457

1458 - def __delfield_missed(self): del self.__field_missed

1459 1460 missed=property(__getfield_missed, __setfield_missed, __delfield_missed, None) 1461

1462 - def __getfield_dunno1(self):

1463 return self.__field_dunno1.getvalue()

1464

1465 - def __setfield_dunno1(self, value):

1466 if isinstance(value,UNKNOWN): 1467 self.__field_dunno1=value 1468 else: 1469 self.__field_dunno1=UNKNOWN(value,**{'sizeinbytes': 992})

1470

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

1472 1473 dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None) 1474

1475 - def __getfield_incoming_count(self):

1476 return self.__field_incoming_count.getvalue()

1477

1478 - def __setfield_incoming_count(self, value):

1479 if isinstance(value,UINT): 1480 self.__field_incoming_count=value 1481 else: 1482 self.__field_incoming_count=UINT(value,**{'sizeinbytes': 4})

1483

1484 - def __delfield_incoming_count(self): del self.__field_incoming_count

1485 1486 incoming_count=property(__getfield_incoming_count, __setfield_incoming_count, __delfield_incoming_count, None) 1487

1488 - def __getfield_outgoing_count(self):

1489 return self.__field_outgoing_count.getvalue()

1490

1491 - def __setfield_outgoing_count(self, value):

1492 if isinstance(value,UINT): 1493 self.__field_outgoing_count=value 1494 else: 1495 self.__field_outgoing_count=UINT(value,**{'sizeinbytes': 4})

1496

1497 - def __delfield_outgoing_count(self): del self.__field_outgoing_count

1498 1499 outgoing_count=property(__getfield_outgoing_count, __setfield_outgoing_count, __delfield_outgoing_count, None) 1500

1501 - def __getfield_missed_count(self):

1502 return self.__field_missed_count.getvalue()

1503

1504 - def __setfield_missed_count(self, value):

1505 if isinstance(value,UINT): 1506 self.__field_missed_count=value 1507 else: 1508 self.__field_missed_count=UINT(value,**{'sizeinbytes': 4})

1509

1510 - def __delfield_missed_count(self): del self.__field_missed_count

1511 1512 missed_count=property(__getfield_missed_count, __setfield_missed_count, __delfield_missed_count, None) 1513

1514 - def iscontainer(self):

1515 return True

1516

1517 - def containerelements(self):

1518 yield ('incoming', self.__field_incoming, None) 1519 yield ('outgoing', self.__field_outgoing, None) 1520 yield ('missed', self.__field_missed, None) 1521 yield ('dunno1', self.__field_dunno1, None) 1522 yield ('incoming_count', self.__field_incoming_count, None) 1523 yield ('outgoing_count', self.__field_outgoing_count, None) 1524 yield ('missed_count', self.__field_missed_count, None)

1525 1526 1527 1528

1529 -class cl_file(BaseProtogenClass):

1530 __fields=['cl_type', 'number', 'datetime', 'dunno1', 'duration'] 1531

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

1533 dict={} 1534 # What was supplied to this function 1535 dict.update(kwargs) 1536 # Parent constructor 1537 super(cl_file,self).__init__(**dict) 1538 if self.__class__ is cl_file: 1539 self._update(args,dict)

1540 1541

1542 - def getfields(self):

1543 return self.__fields

1544 1545

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

1547 super(cl_file,self)._update(args,kwargs) 1548 keys=kwargs.keys() 1549 for key in keys: 1550 if key in self.__fields: 1551 setattr(self, key, kwargs[key]) 1552 del kwargs[key] 1553 # Were any unrecognized kwargs passed in? 1554 if __debug__: 1555 self._complainaboutunusedargs(cl_file,kwargs) 1556 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)

1557 # Make all P fields that haven't already been constructed 1558 1559

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

1561 'Writes this packet to the supplied buffer' 1562 self._bufferstartoffset=buf.getcurrentoffset() 1563 self.__field_cl_type.writetobuffer(buf) 1564 self.__field_number.writetobuffer(buf) 1565 self.__field_datetime.writetobuffer(buf) 1566 self.__field_dunno1.writetobuffer(buf) 1567 self.__field_duration.writetobuffer(buf) 1568 self._bufferendoffset=buf.getcurrentoffset() 1569 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)

1570 1571

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

1573 'Reads this packet from the supplied buffer' 1574 self._bufferstartoffset=buf.getcurrentoffset() 1575 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1576 self.__field_cl_type=UINT(**{'sizeinbytes': 1}) 1577 self.__field_cl_type.readfrombuffer(buf) 1578 self.__field_number=STRING(**{'sizeinbytes': 51, 'terminator': 0 }) 1579 self.__field_number.readfrombuffer(buf) 1580 self.__field_datetime=DateTime1(**{'sizeinbytes': 4}) 1581 self.__field_datetime.readfrombuffer(buf) 1582 self.__field_dunno1=UNKNOWN(**{'sizeinbytes': 4}) 1583 self.__field_dunno1.readfrombuffer(buf) 1584 self.__field_duration=UINT(**{'sizeinbytes': 4}) 1585 self.__field_duration.readfrombuffer(buf) 1586 self._bufferendoffset=buf.getcurrentoffset()

1587 1588

1589 - def __getfield_cl_type(self):

1590 return self.__field_cl_type.getvalue()

1591

1592 - def __setfield_cl_type(self, value):

1593 if isinstance(value,UINT): 1594 self.__field_cl_type=value 1595 else: 1596 self.__field_cl_type=UINT(value,**{'sizeinbytes': 1})

1597

1598 - def __delfield_cl_type(self): del self.__field_cl_type

1599 1600 cl_type=property(__getfield_cl_type, __setfield_cl_type, __delfield_cl_type, None) 1601

1602 - def __getfield_number(self):

1603 return self.__field_number.getvalue()

1604

1605 - def __setfield_number(self, value):

1606 if isinstance(value,STRING): 1607 self.__field_number=value 1608 else: 1609 self.__field_number=STRING(value,**{'sizeinbytes': 51, 'terminator': 0 })

1610

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

1612 1613 number=property(__getfield_number, __setfield_number, __delfield_number, None) 1614

1615 - def __getfield_datetime(self):

1616 return self.__field_datetime.getvalue()

1617

1618 - def __setfield_datetime(self, value):

1619 if isinstance(value,DateTime1): 1620 self.__field_datetime=value 1621 else: 1622 self.__field_datetime=DateTime1(value,**{'sizeinbytes': 4})

1623

1624 - def __delfield_datetime(self): del self.__field_datetime

1625 1626 datetime=property(__getfield_datetime, __setfield_datetime, __delfield_datetime, None) 1627

1628 - def __getfield_dunno1(self):

1629 return self.__field_dunno1.getvalue()

1630

1631 - def __setfield_dunno1(self, value):

1632 if isinstance(value,UNKNOWN): 1633 self.__field_dunno1=value 1634 else: 1635 self.__field_dunno1=UNKNOWN(value,**{'sizeinbytes': 4})

1636

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

1638 1639 dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None) 1640

1641 - def __getfield_duration(self):

1642 return self.__field_duration.getvalue()

1643

1644 - def __setfield_duration(self, value):

1645 if isinstance(value,UINT): 1646 self.__field_duration=value 1647 else: 1648 self.__field_duration=UINT(value,**{'sizeinbytes': 4})

1649

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

1651 1652 duration=property(__getfield_duration, __setfield_duration, __delfield_duration, None) 1653

1654 - def iscontainer(self):

1655 return True

1656

1657 - def containerelements(self):

1658 yield ('cl_type', self.__field_cl_type, None) 1659 yield ('number', self.__field_number, None) 1660 yield ('datetime', self.__field_datetime, None) 1661 yield ('dunno1', self.__field_dunno1, None) 1662 yield ('duration', self.__field_duration, None)

1663

Source Code for Module phones.p_samsungscha930