PyXR

c:\projects\bitpim\src \ phones \ p_lglg6190.py

0001 # THIS FILE IS AUTOMATICALLY GENERATED.  EDIT THE SOURCE FILE NOT THIS ONE
0002 
0003 """Various descriptions of data specific to LG 6190 (Sprint)"""
0004 
0005 import re
0006 
0007 from prototypes import *
0008 from prototypeslg import *
0009 
0010 # Make all lg stuff available in this module as well
0011 from p_lg import *
0012 
0013 # we are the same as lgvx4400 except as noted
0014 # below
0015 from p_lgvx4400 import *
0016 
0017 
0018 # We use LSB for all integer like fields
0019 UINT=UINTlsb
0020 BOOL=BOOLlsb
0021 
0022 NUMSPEEDDIALS=100
0023 FIRSTSPEEDDIAL=1
0024 LASTSPEEDDIAL=99
0025 NUMPHONEBOOKENTRIES=500
0026 MEMOLENGTH=65
0027 
0028 NORINGTONE=0
0029 NOMSGRINGTONE=0
0030 NOWALLPAPER=0
0031 
0032 NUMEMAILS=3
0033 NUMPHONENUMBERS=5
0034 
0035 SMS_CANNED_MAX_ITEMS=18
0036 SMS_CANNED_MAX_LENGTH=101
0037 SMS_CANNED_FILENAME="sms/mediacan000.dat"
0038 SMS_PATTERNS={'Inbox': re.compile(r"^.*/inbox[0-9][0-9][0-9]\.dat$"),
0039              'Sent': re.compile(r"^.*/outbox[0-9][0-9][0-9]\.dat$"),
0040              'Saved': re.compile(r"^.*/sf[0-9][0-9]\.dat$"),
0041              }
0042 
0043 # Text Memo const
0044 text_memo_file='sch/memo.dat'
0045 content_file_name='ams/contentInfo'
0046 content_count_file_name='ams/realContent'
0047 
0048 media_directory='ams'
0049 ringerindex='setas/amsRingerIndex.map'
0050 imageindex='setas/amsImageIndex.map'
0051 ringerconst=2
0052 imageconst=3
0053 max_ringers=100
0054 max_images=100
0055 
0056 phonebook_media='pim/pbookcontact.dat'
0057 
0058 # Calendar parameters
0059 NUMCALENDARENTRIES=300  # ?? for VX4400
0060 CAL_REP_NONE=0x10
0061 CAL_REP_DAILY=0x11
0062 CAL_REP_MONFRI=0x12
0063 CAL_REP_WEEKLY=0x13
0064 CAL_REP_MONTHLY=0x14
0065 CAL_REP_YEARLY=0x15
0066 CAL_DOW_SUN=0x0800
0067 CAL_DOW_MON=0x0400
0068 CAL_DOW_TUE=0x0200
0069 CAL_DOW_WED=0x0100
0070 CAL_DOW_THU=0x0080
0071 CAL_DOW_FRI=0x0040
0072 CAL_DOW_SAT=0x0020
0073 CAL_DOW_EXCEPTIONS=0x0010
0074 CAL_REMINDER_NONE=0
0075 CAL_REMINDER_ONTIME=1
0076 CAL_REMINDER_5MIN=2
0077 CAL_REMINDER_10MIN=3
0078 CAL_REMINDER_1HOUR=4
0079 CAL_REMINDER_1DAY=5
0080 CAL_REMINDER_2DAYS=6
0081 CAL_NO_VOICE=0xffff
0082 CAL_REPEAT_DATE=(2999, 12, 31)
0083 
0084 cal_has_voice_id=True
0085 cal_voice_id_ofs=0x11
0086 cal_voice_ext='.qcp'      # full name='sche000.qcp'
0087 
0088 cal_dir='sch'
0089 cal_data_file_name='sch/schedule.dat'
0090 cal_exception_file_name='sch/schexception.dat'
0091 
0092 PHONE_ENCODING='iso8859_1'
0093 
0094 class pbreadentryresponse(BaseProtogenClass):
0095     "Results of reading one entry"
0096     __fields=['header', 'entry']
0097 
0098     def __init__(self, *args, **kwargs):
0099         dict={}
0100         # What was supplied to this function
0101         dict.update(kwargs)
0102         # Parent constructor
0103         super(pbreadentryresponse,self).__init__(**dict)
0104         if self.__class__ is pbreadentryresponse:
0105             self._update(args,dict)
0106 
0107 
0108     def getfields(self):
0109         return self.__fields
0110 
0111 
0112     def _update(self, args, kwargs):
0113         super(pbreadentryresponse,self)._update(args,kwargs)
0114         keys=kwargs.keys()
0115         for key in keys:
0116             if key in self.__fields:
0117                 setattr(self, key, kwargs[key])
0118                 del kwargs[key]
0119         # Were any unrecognized kwargs passed in?
0120         if __debug__:
0121             self._complainaboutunusedargs(pbreadentryresponse,kwargs)
0122         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0123         # Make all P fields that haven't already been constructed
0124 
0125 
0126     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0127         'Writes this packet to the supplied buffer'
0128         self._bufferstartoffset=buf.getcurrentoffset()
0129         self.__field_header.writetobuffer(buf)
0130         self.__field_entry.writetobuffer(buf)
0131         self._bufferendoffset=buf.getcurrentoffset()
0132         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0133 
0134 
0135     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0136         'Reads this packet from the supplied buffer'
0137         self._bufferstartoffset=buf.getcurrentoffset()
0138         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0139         self.__field_header=pbheader()
0140         self.__field_header.readfrombuffer(buf)
0141         self.__field_entry=pbentry()
0142         self.__field_entry.readfrombuffer(buf)
0143         self._bufferendoffset=buf.getcurrentoffset()
0144 
0145 
0146     def __getfield_header(self):
0147         return self.__field_header.getvalue()
0148 
0149     def __setfield_header(self, value):
0150         if isinstance(value,pbheader):
0151             self.__field_header=value
0152         else:
0153             self.__field_header=pbheader(value,)
0154 
0155     def __delfield_header(self): del self.__field_header
0156 
0157     header=property(__getfield_header, __setfield_header, __delfield_header, None)
0158 
0159     def __getfield_entry(self):
0160         return self.__field_entry.getvalue()
0161 
0162     def __setfield_entry(self, value):
0163         if isinstance(value,pbentry):
0164             self.__field_entry=value
0165         else:
0166             self.__field_entry=pbentry(value,)
0167 
0168     def __delfield_entry(self): del self.__field_entry
0169 
0170     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
0171 
0172     def iscontainer(self):
0173         return True
0174 
0175     def containerelements(self):
0176         yield ('header', self.__field_header, None)
0177         yield ('entry', self.__field_entry, None)
0178 
0179 
0180 
0181 
0182 class pbupdateentryrequest(BaseProtogenClass):
0183     __fields=['header', 'entry']
0184 
0185     def __init__(self, *args, **kwargs):
0186         dict={}
0187         # What was supplied to this function
0188         dict.update(kwargs)
0189         # Parent constructor
0190         super(pbupdateentryrequest,self).__init__(**dict)
0191         if self.__class__ is pbupdateentryrequest:
0192             self._update(args,dict)
0193 
0194 
0195     def getfields(self):
0196         return self.__fields
0197 
0198 
0199     def _update(self, args, kwargs):
0200         super(pbupdateentryrequest,self)._update(args,kwargs)
0201         keys=kwargs.keys()
0202         for key in keys:
0203             if key in self.__fields:
0204                 setattr(self, key, kwargs[key])
0205                 del kwargs[key]
0206         # Were any unrecognized kwargs passed in?
0207         if __debug__:
0208             self._complainaboutunusedargs(pbupdateentryrequest,kwargs)
0209         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0210         # Make all P fields that haven't already been constructed
0211 
0212 
0213     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0214         'Writes this packet to the supplied buffer'
0215         self._bufferstartoffset=buf.getcurrentoffset()
0216         try: self.__field_header
0217         except:
0218             self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01})
0219         self.__field_header.writetobuffer(buf)
0220         self.__field_entry.writetobuffer(buf)
0221         self._bufferendoffset=buf.getcurrentoffset()
0222         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0223 
0224 
0225     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0226         'Reads this packet from the supplied buffer'
0227         self._bufferstartoffset=buf.getcurrentoffset()
0228         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0229         self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01})
0230         self.__field_header.readfrombuffer(buf)
0231         self.__field_entry=pbentry()
0232         self.__field_entry.readfrombuffer(buf)
0233         self._bufferendoffset=buf.getcurrentoffset()
0234 
0235 
0236     def __getfield_header(self):
0237         try: self.__field_header
0238         except:
0239             self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01})
0240         return self.__field_header.getvalue()
0241 
0242     def __setfield_header(self, value):
0243         if isinstance(value,pbheader):
0244             self.__field_header=value
0245         else:
0246             self.__field_header=pbheader(value,**{'command': 0x04, 'flag': 0x01})
0247 
0248     def __delfield_header(self): del self.__field_header
0249 
0250     header=property(__getfield_header, __setfield_header, __delfield_header, None)
0251 
0252     def __getfield_entry(self):
0253         return self.__field_entry.getvalue()
0254 
0255     def __setfield_entry(self, value):
0256         if isinstance(value,pbentry):
0257             self.__field_entry=value
0258         else:
0259             self.__field_entry=pbentry(value,)
0260 
0261     def __delfield_entry(self): del self.__field_entry
0262 
0263     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
0264 
0265     def iscontainer(self):
0266         return True
0267 
0268     def containerelements(self):
0269         yield ('header', self.__field_header, None)
0270         yield ('entry', self.__field_entry, None)
0271 
0272 
0273 
0274 
0275 class pbappendentryrequest(BaseProtogenClass):
0276     __fields=['header', 'entry']
0277 
0278     def __init__(self, *args, **kwargs):
0279         dict={}
0280         # What was supplied to this function
0281         dict.update(kwargs)
0282         # Parent constructor
0283         super(pbappendentryrequest,self).__init__(**dict)
0284         if self.__class__ is pbappendentryrequest:
0285             self._update(args,dict)
0286 
0287 
0288     def getfields(self):
0289         return self.__fields
0290 
0291 
0292     def _update(self, args, kwargs):
0293         super(pbappendentryrequest,self)._update(args,kwargs)
0294         keys=kwargs.keys()
0295         for key in keys:
0296             if key in self.__fields:
0297                 setattr(self, key, kwargs[key])
0298                 del kwargs[key]
0299         # Were any unrecognized kwargs passed in?
0300         if __debug__:
0301             self._complainaboutunusedargs(pbappendentryrequest,kwargs)
0302         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0303         # Make all P fields that haven't already been constructed
0304 
0305 
0306     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0307         'Writes this packet to the supplied buffer'
0308         self._bufferstartoffset=buf.getcurrentoffset()
0309         try: self.__field_header
0310         except:
0311             self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01})
0312         self.__field_header.writetobuffer(buf)
0313         self.__field_entry.writetobuffer(buf)
0314         self._bufferendoffset=buf.getcurrentoffset()
0315         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0316 
0317 
0318     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0319         'Reads this packet from the supplied buffer'
0320         self._bufferstartoffset=buf.getcurrentoffset()
0321         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0322         self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01})
0323         self.__field_header.readfrombuffer(buf)
0324         self.__field_entry=pbentry()
0325         self.__field_entry.readfrombuffer(buf)
0326         self._bufferendoffset=buf.getcurrentoffset()
0327 
0328 
0329     def __getfield_header(self):
0330         try: self.__field_header
0331         except:
0332             self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01})
0333         return self.__field_header.getvalue()
0334 
0335     def __setfield_header(self, value):
0336         if isinstance(value,pbheader):
0337             self.__field_header=value
0338         else:
0339             self.__field_header=pbheader(value,**{'command': 0x03, 'flag': 0x01})
0340 
0341     def __delfield_header(self): del self.__field_header
0342 
0343     header=property(__getfield_header, __setfield_header, __delfield_header, None)
0344 
0345     def __getfield_entry(self):
0346         return self.__field_entry.getvalue()
0347 
0348     def __setfield_entry(self, value):
0349         if isinstance(value,pbentry):
0350             self.__field_entry=value
0351         else:
0352             self.__field_entry=pbentry(value,)
0353 
0354     def __delfield_entry(self): del self.__field_entry
0355 
0356     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
0357 
0358     def iscontainer(self):
0359         return True
0360 
0361     def containerelements(self):
0362         yield ('header', self.__field_header, None)
0363         yield ('entry', self.__field_entry, None)
0364 
0365 
0366 
0367 
0368 class speeddial(BaseProtogenClass):
0369     __fields=['entry', 'number']
0370 
0371     def __init__(self, *args, **kwargs):
0372         dict={}
0373         # What was supplied to this function
0374         dict.update(kwargs)
0375         # Parent constructor
0376         super(speeddial,self).__init__(**dict)
0377         if self.__class__ is speeddial:
0378             self._update(args,dict)
0379 
0380 
0381     def getfields(self):
0382         return self.__fields
0383 
0384 
0385     def _update(self, args, kwargs):
0386         super(speeddial,self)._update(args,kwargs)
0387         keys=kwargs.keys()
0388         for key in keys:
0389             if key in self.__fields:
0390                 setattr(self, key, kwargs[key])
0391                 del kwargs[key]
0392         # Were any unrecognized kwargs passed in?
0393         if __debug__:
0394             self._complainaboutunusedargs(speeddial,kwargs)
0395         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0396         # Make all P fields that haven't already been constructed
0397 
0398 
0399     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0400         'Writes this packet to the supplied buffer'
0401         self._bufferstartoffset=buf.getcurrentoffset()
0402         try: self.__field_entry
0403         except:
0404             self.__field_entry=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
0405         self.__field_entry.writetobuffer(buf)
0406         try: self.__field_number
0407         except:
0408             self.__field_number=UINT(**{'sizeinbytes': 1, 'default': 0xff})
0409         self.__field_number.writetobuffer(buf)
0410         self._bufferendoffset=buf.getcurrentoffset()
0411         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0412 
0413 
0414     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0415         'Reads this packet from the supplied buffer'
0416         self._bufferstartoffset=buf.getcurrentoffset()
0417         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0418         self.__field_entry=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
0419         self.__field_entry.readfrombuffer(buf)
0420         self.__field_number=UINT(**{'sizeinbytes': 1, 'default': 0xff})
0421         self.__field_number.readfrombuffer(buf)
0422         self._bufferendoffset=buf.getcurrentoffset()
0423 
0424 
0425     def __getfield_entry(self):
0426         try: self.__field_entry
0427         except:
0428             self.__field_entry=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
0429         return self.__field_entry.getvalue()
0430 
0431     def __setfield_entry(self, value):
0432         if isinstance(value,UINT):
0433             self.__field_entry=value
0434         else:
0435             self.__field_entry=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff})
0436 
0437     def __delfield_entry(self): del self.__field_entry
0438 
0439     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
0440 
0441     def __getfield_number(self):
0442         try: self.__field_number
0443         except:
0444             self.__field_number=UINT(**{'sizeinbytes': 1, 'default': 0xff})
0445         return self.__field_number.getvalue()
0446 
0447     def __setfield_number(self, value):
0448         if isinstance(value,UINT):
0449             self.__field_number=value
0450         else:
0451             self.__field_number=UINT(value,**{'sizeinbytes': 1, 'default': 0xff})
0452 
0453     def __delfield_number(self): del self.__field_number
0454 
0455     number=property(__getfield_number, __setfield_number, __delfield_number, None)
0456 
0457     def iscontainer(self):
0458         return True
0459 
0460     def containerelements(self):
0461         yield ('entry', self.__field_entry, None)
0462         yield ('number', self.__field_number, None)
0463 
0464 
0465 
0466 
0467 class speeddials(BaseProtogenClass):
0468     __fields=['speeddials']
0469 
0470     def __init__(self, *args, **kwargs):
0471         dict={}
0472         # What was supplied to this function
0473         dict.update(kwargs)
0474         # Parent constructor
0475         super(speeddials,self).__init__(**dict)
0476         if self.__class__ is speeddials:
0477             self._update(args,dict)
0478 
0479 
0480     def getfields(self):
0481         return self.__fields
0482 
0483 
0484     def _update(self, args, kwargs):
0485         super(speeddials,self)._update(args,kwargs)
0486         keys=kwargs.keys()
0487         for key in keys:
0488             if key in self.__fields:
0489                 setattr(self, key, kwargs[key])
0490                 del kwargs[key]
0491         # Were any unrecognized kwargs passed in?
0492         if __debug__:
0493             self._complainaboutunusedargs(speeddials,kwargs)
0494         if len(args):
0495             dict2={'length': NUMSPEEDDIALS, 'elementclass': speeddial}
0496             dict2.update(kwargs)
0497             kwargs=dict2
0498             self.__field_speeddials=LIST(*args,**dict2)
0499         # Make all P fields that haven't already been constructed
0500 
0501 
0502     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0503         'Writes this packet to the supplied buffer'
0504         self._bufferstartoffset=buf.getcurrentoffset()
0505         try: self.__field_speeddials
0506         except:
0507             self.__field_speeddials=LIST(**{'length': NUMSPEEDDIALS, 'elementclass': speeddial})
0508         self.__field_speeddials.writetobuffer(buf)
0509         self._bufferendoffset=buf.getcurrentoffset()
0510         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0511 
0512 
0513     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0514         'Reads this packet from the supplied buffer'
0515         self._bufferstartoffset=buf.getcurrentoffset()
0516         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0517         self.__field_speeddials=LIST(**{'length': NUMSPEEDDIALS, 'elementclass': speeddial})
0518         self.__field_speeddials.readfrombuffer(buf)
0519         self._bufferendoffset=buf.getcurrentoffset()
0520 
0521 
0522     def __getfield_speeddials(self):
0523         try: self.__field_speeddials
0524         except:
0525             self.__field_speeddials=LIST(**{'length': NUMSPEEDDIALS, 'elementclass': speeddial})
0526         return self.__field_speeddials.getvalue()
0527 
0528     def __setfield_speeddials(self, value):
0529         if isinstance(value,LIST):
0530             self.__field_speeddials=value
0531         else:
0532             self.__field_speeddials=LIST(value,**{'length': NUMSPEEDDIALS, 'elementclass': speeddial})
0533 
0534     def __delfield_speeddials(self): del self.__field_speeddials
0535 
0536     speeddials=property(__getfield_speeddials, __setfield_speeddials, __delfield_speeddials, None)
0537 
0538     def iscontainer(self):
0539         return True
0540 
0541     def containerelements(self):
0542         yield ('speeddials', self.__field_speeddials, None)
0543 
0544 
0545 
0546 
0547 class pbentry(BaseProtogenClass):
0548     __fields=['serial1', 'entrysize', 'serial2', 'entrynumber', 'name', 'group', 'emails', 'url', 'ringtone', 'msgringtone', 'secret', 'memo', 'wallpaper', 'numbertypes', 'numbers', 'unknown20c']
0549 
0550     def __init__(self, *args, **kwargs):
0551         dict={}
0552         # What was supplied to this function
0553         dict.update(kwargs)
0554         # Parent constructor
0555         super(pbentry,self).__init__(**dict)
0556         if self.__class__ is pbentry:
0557             self._update(args,dict)
0558 
0559 
0560     def getfields(self):
0561         return self.__fields
0562 
0563 
0564     def _update(self, args, kwargs):
0565         super(pbentry,self)._update(args,kwargs)
0566         keys=kwargs.keys()
0567         for key in keys:
0568             if key in self.__fields:
0569                 setattr(self, key, kwargs[key])
0570                 del kwargs[key]
0571         # Were any unrecognized kwargs passed in?
0572         if __debug__:
0573             self._complainaboutunusedargs(pbentry,kwargs)
0574         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0575         # Make all P fields that haven't already been constructed
0576 
0577 
0578     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0579         'Writes this packet to the supplied buffer'
0580         self._bufferstartoffset=buf.getcurrentoffset()
0581         self.__field_serial1.writetobuffer(buf)
0582         try: self.__field_entrysize
0583         except:
0584             self.__field_entrysize=UINT(**{'sizeinbytes': 2, 'constant': 0x0222})
0585         self.__field_entrysize.writetobuffer(buf)
0586         self.__field_serial2.writetobuffer(buf)
0587         self.__field_entrynumber.writetobuffer(buf)
0588         self.__field_name.writetobuffer(buf)
0589         self.__field_group.writetobuffer(buf)
0590         try: self.__field_emails
0591         except:
0592             self.__field_emails=LIST(**{'elementclass': _gen_p_lglg6190_137, 'length': NUMEMAILS})
0593         self.__field_emails.writetobuffer(buf)
0594         self.__field_url.writetobuffer(buf)
0595         self.__field_ringtone.writetobuffer(buf)
0596         self.__field_msgringtone.writetobuffer(buf)
0597         self.__field_secret.writetobuffer(buf)
0598         self.__field_memo.writetobuffer(buf)
0599         self.__field_wallpaper.writetobuffer(buf)
0600         try: self.__field_numbertypes
0601         except:
0602             self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lglg6190_145, 'length': NUMPHONENUMBERS})
0603         self.__field_numbertypes.writetobuffer(buf)
0604         try: self.__field_numbers
0605         except:
0606             self.__field_numbers=LIST(**{'elementclass': _gen_p_lglg6190_147, 'length': NUMPHONENUMBERS})
0607         self.__field_numbers.writetobuffer(buf)
0608         try: self.__field_unknown20c
0609         except:
0610             self.__field_unknown20c=UNKNOWN()
0611         self.__field_unknown20c.writetobuffer(buf)
0612         self._bufferendoffset=buf.getcurrentoffset()
0613         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0614 
0615 
0616     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0617         'Reads this packet from the supplied buffer'
0618         self._bufferstartoffset=buf.getcurrentoffset()
0619         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0620         self.__field_serial1=UINT(**{'sizeinbytes': 4})
0621         self.__field_serial1.readfrombuffer(buf)
0622         self.__field_entrysize=UINT(**{'sizeinbytes': 2, 'constant': 0x0222})
0623         self.__field_entrysize.readfrombuffer(buf)
0624         self.__field_serial2=UINT(**{'sizeinbytes': 4})
0625         self.__field_serial2.readfrombuffer(buf)
0626         self.__field_entrynumber=UINT(**{'sizeinbytes': 2})
0627         self.__field_entrynumber.readfrombuffer(buf)
0628         self.__field_name=USTRING(**{'sizeinbytes': 23, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})
0629         self.__field_name.readfrombuffer(buf)
0630         self.__field_group=UINT(**{'sizeinbytes': 2})
0631         self.__field_group.readfrombuffer(buf)
0632         self.__field_emails=LIST(**{'elementclass': _gen_p_lglg6190_137, 'length': NUMEMAILS})
0633         self.__field_emails.readfrombuffer(buf)
0634         self.__field_url=USTRING(**{'sizeinbytes': 49, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})
0635         self.__field_url.readfrombuffer(buf)
0636         self.__field_ringtone=UINT(**{'sizeinbytes': 1})
0637         self.__field_ringtone.readfrombuffer(buf)
0638         self.__field_msgringtone=UINT(**{'sizeinbytes': 1})
0639         self.__field_msgringtone.readfrombuffer(buf)
0640         self.__field_secret=BOOL(**{'sizeinbytes': 1})
0641         self.__field_secret.readfrombuffer(buf)
0642         self.__field_memo=USTRING(**{'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'sizeinbytes': MEMOLENGTH})
0643         self.__field_memo.readfrombuffer(buf)
0644         self.__field_wallpaper=UINT(**{'sizeinbytes': 1})
0645         self.__field_wallpaper.readfrombuffer(buf)
0646         self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lglg6190_145, 'length': NUMPHONENUMBERS})
0647         self.__field_numbertypes.readfrombuffer(buf)
0648         self.__field_numbers=LIST(**{'elementclass': _gen_p_lglg6190_147, 'length': NUMPHONENUMBERS})
0649         self.__field_numbers.readfrombuffer(buf)
0650         self.__field_unknown20c=UNKNOWN()
0651         self.__field_unknown20c.readfrombuffer(buf)
0652         self._bufferendoffset=buf.getcurrentoffset()
0653 
0654 
0655     def __getfield_serial1(self):
0656         return self.__field_serial1.getvalue()
0657 
0658     def __setfield_serial1(self, value):
0659         if isinstance(value,UINT):
0660             self.__field_serial1=value
0661         else:
0662             self.__field_serial1=UINT(value,**{'sizeinbytes': 4})
0663 
0664     def __delfield_serial1(self): del self.__field_serial1
0665 
0666     serial1=property(__getfield_serial1, __setfield_serial1, __delfield_serial1, None)
0667 
0668     def __getfield_entrysize(self):
0669         try: self.__field_entrysize
0670         except:
0671             self.__field_entrysize=UINT(**{'sizeinbytes': 2, 'constant': 0x0222})
0672         return self.__field_entrysize.getvalue()
0673 
0674     def __setfield_entrysize(self, value):
0675         if isinstance(value,UINT):
0676             self.__field_entrysize=value
0677         else:
0678             self.__field_entrysize=UINT(value,**{'sizeinbytes': 2, 'constant': 0x0222})
0679 
0680     def __delfield_entrysize(self): del self.__field_entrysize
0681 
0682     entrysize=property(__getfield_entrysize, __setfield_entrysize, __delfield_entrysize, None)
0683 
0684     def __getfield_serial2(self):
0685         return self.__field_serial2.getvalue()
0686 
0687     def __setfield_serial2(self, value):
0688         if isinstance(value,UINT):
0689             self.__field_serial2=value
0690         else:
0691             self.__field_serial2=UINT(value,**{'sizeinbytes': 4})
0692 
0693     def __delfield_serial2(self): del self.__field_serial2
0694 
0695     serial2=property(__getfield_serial2, __setfield_serial2, __delfield_serial2, None)
0696 
0697     def __getfield_entrynumber(self):
0698         return self.__field_entrynumber.getvalue()
0699 
0700     def __setfield_entrynumber(self, value):
0701         if isinstance(value,UINT):
0702             self.__field_entrynumber=value
0703         else:
0704             self.__field_entrynumber=UINT(value,**{'sizeinbytes': 2})
0705 
0706     def __delfield_entrynumber(self): del self.__field_entrynumber
0707 
0708     entrynumber=property(__getfield_entrynumber, __setfield_entrynumber, __delfield_entrynumber, None)
0709 
0710     def __getfield_name(self):
0711         return self.__field_name.getvalue()
0712 
0713     def __setfield_name(self, value):
0714         if isinstance(value,USTRING):
0715             self.__field_name=value
0716         else:
0717             self.__field_name=USTRING(value,**{'sizeinbytes': 23, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})
0718 
0719     def __delfield_name(self): del self.__field_name
0720 
0721     name=property(__getfield_name, __setfield_name, __delfield_name, None)
0722 
0723     def __getfield_group(self):
0724         return self.__field_group.getvalue()
0725 
0726     def __setfield_group(self, value):
0727         if isinstance(value,UINT):
0728             self.__field_group=value
0729         else:
0730             self.__field_group=UINT(value,**{'sizeinbytes': 2})
0731 
0732     def __delfield_group(self): del self.__field_group
0733 
0734     group=property(__getfield_group, __setfield_group, __delfield_group, None)
0735 
0736     def __getfield_emails(self):
0737         try: self.__field_emails
0738         except:
0739             self.__field_emails=LIST(**{'elementclass': _gen_p_lglg6190_137, 'length': NUMEMAILS})
0740         return self.__field_emails.getvalue()
0741 
0742     def __setfield_emails(self, value):
0743         if isinstance(value,LIST):
0744             self.__field_emails=value
0745         else:
0746             self.__field_emails=LIST(value,**{'elementclass': _gen_p_lglg6190_137, 'length': NUMEMAILS})
0747 
0748     def __delfield_emails(self): del self.__field_emails
0749 
0750     emails=property(__getfield_emails, __setfield_emails, __delfield_emails, None)
0751 
0752     def __getfield_url(self):
0753         return self.__field_url.getvalue()
0754 
0755     def __setfield_url(self, value):
0756         if isinstance(value,USTRING):
0757             self.__field_url=value
0758         else:
0759             self.__field_url=USTRING(value,**{'sizeinbytes': 49, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})
0760 
0761     def __delfield_url(self): del self.__field_url
0762 
0763     url=property(__getfield_url, __setfield_url, __delfield_url, None)
0764 
0765     def __getfield_ringtone(self):
0766         return self.__field_ringtone.getvalue()
0767 
0768     def __setfield_ringtone(self, value):
0769         if isinstance(value,UINT):
0770             self.__field_ringtone=value
0771         else:
0772             self.__field_ringtone=UINT(value,**{'sizeinbytes': 1})
0773 
0774     def __delfield_ringtone(self): del self.__field_ringtone
0775 
0776     ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, "ringtone index for a call")
0777 
0778     def __getfield_msgringtone(self):
0779         return self.__field_msgringtone.getvalue()
0780 
0781     def __setfield_msgringtone(self, value):
0782         if isinstance(value,UINT):
0783             self.__field_msgringtone=value
0784         else:
0785             self.__field_msgringtone=UINT(value,**{'sizeinbytes': 1})
0786 
0787     def __delfield_msgringtone(self): del self.__field_msgringtone
0788 
0789     msgringtone=property(__getfield_msgringtone, __setfield_msgringtone, __delfield_msgringtone, "ringtone index for a text message")
0790 
0791     def __getfield_secret(self):
0792         return self.__field_secret.getvalue()
0793 
0794     def __setfield_secret(self, value):
0795         if isinstance(value,BOOL):
0796             self.__field_secret=value
0797         else:
0798             self.__field_secret=BOOL(value,**{'sizeinbytes': 1})
0799 
0800     def __delfield_secret(self): del self.__field_secret
0801 
0802     secret=property(__getfield_secret, __setfield_secret, __delfield_secret, None)
0803 
0804     def __getfield_memo(self):
0805         return self.__field_memo.getvalue()
0806 
0807     def __setfield_memo(self, value):
0808         if isinstance(value,USTRING):
0809             self.__field_memo=value
0810         else:
0811             self.__field_memo=USTRING(value,**{'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'sizeinbytes': MEMOLENGTH})
0812 
0813     def __delfield_memo(self): del self.__field_memo
0814 
0815     memo=property(__getfield_memo, __setfield_memo, __delfield_memo, None)
0816 
0817     def __getfield_wallpaper(self):
0818         return self.__field_wallpaper.getvalue()
0819 
0820     def __setfield_wallpaper(self, value):
0821         if isinstance(value,UINT):
0822             self.__field_wallpaper=value
0823         else:
0824             self.__field_wallpaper=UINT(value,**{'sizeinbytes': 1})
0825 
0826     def __delfield_wallpaper(self): del self.__field_wallpaper
0827 
0828     wallpaper=property(__getfield_wallpaper, __setfield_wallpaper, __delfield_wallpaper, None)
0829 
0830     def __getfield_numbertypes(self):
0831         try: self.__field_numbertypes
0832         except:
0833             self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lglg6190_145, 'length': NUMPHONENUMBERS})
0834         return self.__field_numbertypes.getvalue()
0835 
0836     def __setfield_numbertypes(self, value):
0837         if isinstance(value,LIST):
0838             self.__field_numbertypes=value
0839         else:
0840             self.__field_numbertypes=LIST(value,**{'elementclass': _gen_p_lglg6190_145, 'length': NUMPHONENUMBERS})
0841 
0842     def __delfield_numbertypes(self): del self.__field_numbertypes
0843 
0844     numbertypes=property(__getfield_numbertypes, __setfield_numbertypes, __delfield_numbertypes, None)
0845 
0846     def __getfield_numbers(self):
0847         try: self.__field_numbers
0848         except:
0849             self.__field_numbers=LIST(**{'elementclass': _gen_p_lglg6190_147, 'length': NUMPHONENUMBERS})
0850         return self.__field_numbers.getvalue()
0851 
0852     def __setfield_numbers(self, value):
0853         if isinstance(value,LIST):
0854             self.__field_numbers=value
0855         else:
0856             self.__field_numbers=LIST(value,**{'elementclass': _gen_p_lglg6190_147, 'length': NUMPHONENUMBERS})
0857 
0858     def __delfield_numbers(self): del self.__field_numbers
0859 
0860     numbers=property(__getfield_numbers, __setfield_numbers, __delfield_numbers, None)
0861 
0862     def __getfield_unknown20c(self):
0863         try: self.__field_unknown20c
0864         except:
0865             self.__field_unknown20c=UNKNOWN()
0866         return self.__field_unknown20c.getvalue()
0867 
0868     def __setfield_unknown20c(self, value):
0869         if isinstance(value,UNKNOWN):
0870             self.__field_unknown20c=value
0871         else:
0872             self.__field_unknown20c=UNKNOWN(value,)
0873 
0874     def __delfield_unknown20c(self): del self.__field_unknown20c
0875 
0876     unknown20c=property(__getfield_unknown20c, __setfield_unknown20c, __delfield_unknown20c, None)
0877 
0878     def iscontainer(self):
0879         return True
0880 
0881     def containerelements(self):
0882         yield ('serial1', self.__field_serial1, None)
0883         yield ('entrysize', self.__field_entrysize, None)
0884         yield ('serial2', self.__field_serial2, None)
0885         yield ('entrynumber', self.__field_entrynumber, None)
0886         yield ('name', self.__field_name, None)
0887         yield ('group', self.__field_group, None)
0888         yield ('emails', self.__field_emails, None)
0889         yield ('url', self.__field_url, None)
0890         yield ('ringtone', self.__field_ringtone, "ringtone index for a call")
0891         yield ('msgringtone', self.__field_msgringtone, "ringtone index for a text message")
0892         yield ('secret', self.__field_secret, None)
0893         yield ('memo', self.__field_memo, None)
0894         yield ('wallpaper', self.__field_wallpaper, None)
0895         yield ('numbertypes', self.__field_numbertypes, None)
0896         yield ('numbers', self.__field_numbers, None)
0897         yield ('unknown20c', self.__field_unknown20c, None)
0898 
0899 
0900 
0901 
0902 class _gen_p_lglg6190_137(BaseProtogenClass):
0903     'Anonymous inner class'
0904     __fields=['email']
0905 
0906     def __init__(self, *args, **kwargs):
0907         dict={}
0908         # What was supplied to this function
0909         dict.update(kwargs)
0910         # Parent constructor
0911         super(_gen_p_lglg6190_137,self).__init__(**dict)
0912         if self.__class__ is _gen_p_lglg6190_137:
0913             self._update(args,dict)
0914 
0915 
0916     def getfields(self):
0917         return self.__fields
0918 
0919 
0920     def _update(self, args, kwargs):
0921         super(_gen_p_lglg6190_137,self)._update(args,kwargs)
0922         keys=kwargs.keys()
0923         for key in keys:
0924             if key in self.__fields:
0925                 setattr(self, key, kwargs[key])
0926                 del kwargs[key]
0927         # Were any unrecognized kwargs passed in?
0928         if __debug__:
0929             self._complainaboutunusedargs(_gen_p_lglg6190_137,kwargs)
0930         if len(args):
0931             dict2={'sizeinbytes': 49, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}
0932             dict2.update(kwargs)
0933             kwargs=dict2
0934             self.__field_email=USTRING(*args,**dict2)
0935         # Make all P fields that haven't already been constructed
0936 
0937 
0938     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0939         'Writes this packet to the supplied buffer'
0940         self._bufferstartoffset=buf.getcurrentoffset()
0941         self.__field_email.writetobuffer(buf)
0942         self._bufferendoffset=buf.getcurrentoffset()
0943         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0944 
0945 
0946     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0947         'Reads this packet from the supplied buffer'
0948         self._bufferstartoffset=buf.getcurrentoffset()
0949         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0950         self.__field_email=USTRING(**{'sizeinbytes': 49, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})
0951         self.__field_email.readfrombuffer(buf)
0952         self._bufferendoffset=buf.getcurrentoffset()
0953 
0954 
0955     def __getfield_email(self):
0956         return self.__field_email.getvalue()
0957 
0958     def __setfield_email(self, value):
0959         if isinstance(value,USTRING):
0960             self.__field_email=value
0961         else:
0962             self.__field_email=USTRING(value,**{'sizeinbytes': 49, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})
0963 
0964     def __delfield_email(self): del self.__field_email
0965 
0966     email=property(__getfield_email, __setfield_email, __delfield_email, None)
0967 
0968     def iscontainer(self):
0969         return True
0970 
0971     def containerelements(self):
0972         yield ('email', self.__field_email, None)
0973 
0974 
0975 
0976 
0977 class _gen_p_lglg6190_145(BaseProtogenClass):
0978     'Anonymous inner class'
0979     __fields=['numbertype']
0980 
0981     def __init__(self, *args, **kwargs):
0982         dict={}
0983         # What was supplied to this function
0984         dict.update(kwargs)
0985         # Parent constructor
0986         super(_gen_p_lglg6190_145,self).__init__(**dict)
0987         if self.__class__ is _gen_p_lglg6190_145:
0988             self._update(args,dict)
0989 
0990 
0991     def getfields(self):
0992         return self.__fields
0993 
0994 
0995     def _update(self, args, kwargs):
0996         super(_gen_p_lglg6190_145,self)._update(args,kwargs)
0997         keys=kwargs.keys()
0998         for key in keys:
0999             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(_gen_p_lglg6190_145,kwargs)
1005         if len(args):
1006             dict2={'sizeinbytes': 1}
1007             dict2.update(kwargs)
1008             kwargs=dict2
1009             self.__field_numbertype=UINT(*args,**dict2)
1010         # Make all P fields that haven't already been constructed
1011 
1012 
1013     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1014         'Writes this packet to the supplied buffer'
1015         self._bufferstartoffset=buf.getcurrentoffset()
1016         self.__field_numbertype.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_numbertype=UINT(**{'sizeinbytes': 1})
1026         self.__field_numbertype.readfrombuffer(buf)
1027         self._bufferendoffset=buf.getcurrentoffset()
1028 
1029 
1030     def __getfield_numbertype(self):
1031         return self.__field_numbertype.getvalue()
1032 
1033     def __setfield_numbertype(self, value):
1034         if isinstance(value,UINT):
1035             self.__field_numbertype=value
1036         else:
1037             self.__field_numbertype=UINT(value,**{'sizeinbytes': 1})
1038 
1039     def __delfield_numbertype(self): del self.__field_numbertype
1040 
1041     numbertype=property(__getfield_numbertype, __setfield_numbertype, __delfield_numbertype, None)
1042 
1043     def iscontainer(self):
1044         return True
1045 
1046     def containerelements(self):
1047         yield ('numbertype', self.__field_numbertype, None)
1048 
1049 
1050 
1051 
1052 class _gen_p_lglg6190_147(BaseProtogenClass):
1053     'Anonymous inner class'
1054     __fields=['number']
1055 
1056     def __init__(self, *args, **kwargs):
1057         dict={}
1058         # What was supplied to this function
1059         dict.update(kwargs)
1060         # Parent constructor
1061         super(_gen_p_lglg6190_147,self).__init__(**dict)
1062         if self.__class__ is _gen_p_lglg6190_147:
1063             self._update(args,dict)
1064 
1065 
1066     def getfields(self):
1067         return self.__fields
1068 
1069 
1070     def _update(self, args, kwargs):
1071         super(_gen_p_lglg6190_147,self)._update(args,kwargs)
1072         keys=kwargs.keys()
1073         for key in keys:
1074             if key in self.__fields:
1075                 setattr(self, key, kwargs[key])
1076                 del kwargs[key]
1077         # Were any unrecognized kwargs passed in?
1078         if __debug__:
1079             self._complainaboutunusedargs(_gen_p_lglg6190_147,kwargs)
1080         if len(args):
1081             dict2={'sizeinbytes': 49, 'raiseonunterminatedread': False}
1082             dict2.update(kwargs)
1083             kwargs=dict2
1084             self.__field_number=USTRING(*args,**dict2)
1085         # Make all P fields that haven't already been constructed
1086 
1087 
1088     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1089         'Writes this packet to the supplied buffer'
1090         self._bufferstartoffset=buf.getcurrentoffset()
1091         self.__field_number.writetobuffer(buf)
1092         self._bufferendoffset=buf.getcurrentoffset()
1093         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1094 
1095 
1096     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1097         'Reads this packet from the supplied buffer'
1098         self._bufferstartoffset=buf.getcurrentoffset()
1099         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1100         self.__field_number=USTRING(**{'sizeinbytes': 49, 'raiseonunterminatedread': False})
1101         self.__field_number.readfrombuffer(buf)
1102         self._bufferendoffset=buf.getcurrentoffset()
1103 
1104 
1105     def __getfield_number(self):
1106         return self.__field_number.getvalue()
1107 
1108     def __setfield_number(self, value):
1109         if isinstance(value,USTRING):
1110             self.__field_number=value
1111         else:
1112             self.__field_number=USTRING(value,**{'sizeinbytes': 49, 'raiseonunterminatedread': False})
1113 
1114     def __delfield_number(self): del self.__field_number
1115 
1116     number=property(__getfield_number, __setfield_number, __delfield_number, None)
1117 
1118     def iscontainer(self):
1119         return True
1120 
1121     def containerelements(self):
1122         yield ('number', self.__field_number, None)
1123 
1124 
1125 
1126 
1127 class pbgroup(BaseProtogenClass):
1128     "A single group"
1129     __fields=['icon', 'name']
1130 
1131     def __init__(self, *args, **kwargs):
1132         dict={}
1133         # What was supplied to this function
1134         dict.update(kwargs)
1135         # Parent constructor
1136         super(pbgroup,self).__init__(**dict)
1137         if self.__class__ is pbgroup:
1138             self._update(args,dict)
1139 
1140 
1141     def getfields(self):
1142         return self.__fields
1143 
1144 
1145     def _update(self, args, kwargs):
1146         super(pbgroup,self)._update(args,kwargs)
1147         keys=kwargs.keys()
1148         for key in keys:
1149             if key in self.__fields:
1150                 setattr(self, key, kwargs[key])
1151                 del kwargs[key]
1152         # Were any unrecognized kwargs passed in?
1153         if __debug__:
1154             self._complainaboutunusedargs(pbgroup,kwargs)
1155         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1156         # Make all P fields that haven't already been constructed
1157 
1158 
1159     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1160         'Writes this packet to the supplied buffer'
1161         self._bufferstartoffset=buf.getcurrentoffset()
1162         self.__field_icon.writetobuffer(buf)
1163         self.__field_name.writetobuffer(buf)
1164         self._bufferendoffset=buf.getcurrentoffset()
1165         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1166 
1167 
1168     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1169         'Reads this packet from the supplied buffer'
1170         self._bufferstartoffset=buf.getcurrentoffset()
1171         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1172         self.__field_icon=UINT(**{'sizeinbytes': 1})
1173         self.__field_icon.readfrombuffer(buf)
1174         self.__field_name=USTRING(**{'sizeinbytes': 23, 'encoding': PHONE_ENCODING})
1175         self.__field_name.readfrombuffer(buf)
1176         self._bufferendoffset=buf.getcurrentoffset()
1177 
1178 
1179     def __getfield_icon(self):
1180         return self.__field_icon.getvalue()
1181 
1182     def __setfield_icon(self, value):
1183         if isinstance(value,UINT):
1184             self.__field_icon=value
1185         else:
1186             self.__field_icon=UINT(value,**{'sizeinbytes': 1})
1187 
1188     def __delfield_icon(self): del self.__field_icon
1189 
1190     icon=property(__getfield_icon, __setfield_icon, __delfield_icon, None)
1191 
1192     def __getfield_name(self):
1193         return self.__field_name.getvalue()
1194 
1195     def __setfield_name(self, value):
1196         if isinstance(value,USTRING):
1197             self.__field_name=value
1198         else:
1199             self.__field_name=USTRING(value,**{'sizeinbytes': 23, 'encoding': PHONE_ENCODING})
1200 
1201     def __delfield_name(self): del self.__field_name
1202 
1203     name=property(__getfield_name, __setfield_name, __delfield_name, None)
1204 
1205     def iscontainer(self):
1206         return True
1207 
1208     def containerelements(self):
1209         yield ('icon', self.__field_icon, None)
1210         yield ('name', self.__field_name, None)
1211 
1212 
1213 
1214 
1215 class pbgroups(BaseProtogenClass):
1216     "Phonebook groups"
1217     __fields=['groups']
1218 
1219     def __init__(self, *args, **kwargs):
1220         dict={}
1221         # What was supplied to this function
1222         dict.update(kwargs)
1223         # Parent constructor
1224         super(pbgroups,self).__init__(**dict)
1225         if self.__class__ is pbgroups:
1226             self._update(args,dict)
1227 
1228 
1229     def getfields(self):
1230         return self.__fields
1231 
1232 
1233     def _update(self, args, kwargs):
1234         super(pbgroups,self)._update(args,kwargs)
1235         keys=kwargs.keys()
1236         for key in keys:
1237             if key in self.__fields:
1238                 setattr(self, key, kwargs[key])
1239                 del kwargs[key]
1240         # Were any unrecognized kwargs passed in?
1241         if __debug__:
1242             self._complainaboutunusedargs(pbgroups,kwargs)
1243         if len(args):
1244             dict2={'elementclass': pbgroup}
1245             dict2.update(kwargs)
1246             kwargs=dict2
1247             self.__field_groups=LIST(*args,**dict2)
1248         # Make all P fields that haven't already been constructed
1249 
1250 
1251     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1252         'Writes this packet to the supplied buffer'
1253         self._bufferstartoffset=buf.getcurrentoffset()
1254         try: self.__field_groups
1255         except:
1256             self.__field_groups=LIST(**{'elementclass': pbgroup})
1257         self.__field_groups.writetobuffer(buf)
1258         self._bufferendoffset=buf.getcurrentoffset()
1259         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1260 
1261 
1262     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1263         'Reads this packet from the supplied buffer'
1264         self._bufferstartoffset=buf.getcurrentoffset()
1265         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1266         self.__field_groups=LIST(**{'elementclass': pbgroup})
1267         self.__field_groups.readfrombuffer(buf)
1268         self._bufferendoffset=buf.getcurrentoffset()
1269 
1270 
1271     def __getfield_groups(self):
1272         try: self.__field_groups
1273         except:
1274             self.__field_groups=LIST(**{'elementclass': pbgroup})
1275         return self.__field_groups.getvalue()
1276 
1277     def __setfield_groups(self, value):
1278         if isinstance(value,LIST):
1279             self.__field_groups=value
1280         else:
1281             self.__field_groups=LIST(value,**{'elementclass': pbgroup})
1282 
1283     def __delfield_groups(self): del self.__field_groups
1284 
1285     groups=property(__getfield_groups, __setfield_groups, __delfield_groups, None)
1286 
1287     def iscontainer(self):
1288         return True
1289 
1290     def containerelements(self):
1291         yield ('groups', self.__field_groups, None)
1292 
1293 
1294 
1295 
1296 class call(BaseProtogenClass):
1297     __fields=['GPStime', 'unknown1', 'duration', 'number', 'name', 'numberlength', 'unknown2', 'pbnumbertype', 'unknown3', 'pbentrynum']
1298 
1299     def __init__(self, *args, **kwargs):
1300         dict={}
1301         # What was supplied to this function
1302         dict.update(kwargs)
1303         # Parent constructor
1304         super(call,self).__init__(**dict)
1305         if self.__class__ is call:
1306             self._update(args,dict)
1307 
1308 
1309     def getfields(self):
1310         return self.__fields
1311 
1312 
1313     def _update(self, args, kwargs):
1314         super(call,self)._update(args,kwargs)
1315         keys=kwargs.keys()
1316         for key in keys:
1317             if key in self.__fields:
1318                 setattr(self, key, kwargs[key])
1319                 del kwargs[key]
1320         # Were any unrecognized kwargs passed in?
1321         if __debug__:
1322             self._complainaboutunusedargs(call,kwargs)
1323         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1324         # Make all P fields that haven't already been constructed
1325 
1326 
1327     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1328         'Writes this packet to the supplied buffer'
1329         self._bufferstartoffset=buf.getcurrentoffset()
1330         self.__field_GPStime.writetobuffer(buf)
1331         self.__field_unknown1.writetobuffer(buf)
1332         self.__field_duration.writetobuffer(buf)
1333         self.__field_number.writetobuffer(buf)
1334         self.__field_name.writetobuffer(buf)
1335         self.__field_numberlength.writetobuffer(buf)
1336         self.__field_unknown2.writetobuffer(buf)
1337         self.__field_pbnumbertype.writetobuffer(buf)
1338         self.__field_unknown3.writetobuffer(buf)
1339         self.__field_pbentrynum.writetobuffer(buf)
1340         self._bufferendoffset=buf.getcurrentoffset()
1341         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1342 
1343 
1344     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1345         'Reads this packet from the supplied buffer'
1346         self._bufferstartoffset=buf.getcurrentoffset()
1347         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1348         self.__field_GPStime=GPSDATE(**{'sizeinbytes': 4})
1349         self.__field_GPStime.readfrombuffer(buf)
1350         self.__field_unknown1=UINT(**{'sizeinbytes': 4})
1351         self.__field_unknown1.readfrombuffer(buf)
1352         self.__field_duration=UINT(**{'sizeinbytes': 4})
1353         self.__field_duration.readfrombuffer(buf)
1354         self.__field_number=USTRING(**{'sizeinbytes': 49, 'raiseonunterminatedread': False})
1355         self.__field_number.readfrombuffer(buf)
1356         self.__field_name=USTRING(**{'sizeinbytes': 36, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})
1357         self.__field_name.readfrombuffer(buf)
1358         self.__field_numberlength=UINT(**{'sizeinbytes': 1})
1359         self.__field_numberlength.readfrombuffer(buf)
1360         self.__field_unknown2=UINT(**{'sizeinbytes': 1})
1361         self.__field_unknown2.readfrombuffer(buf)
1362         self.__field_pbnumbertype=UINT(**{'sizeinbytes': 1})
1363         self.__field_pbnumbertype.readfrombuffer(buf)
1364         self.__field_unknown3=UINT(**{'sizeinbytes': 2})
1365         self.__field_unknown3.readfrombuffer(buf)
1366         self.__field_pbentrynum=UINT(**{'sizeinbytes': 2})
1367         self.__field_pbentrynum.readfrombuffer(buf)
1368         self._bufferendoffset=buf.getcurrentoffset()
1369 
1370 
1371     def __getfield_GPStime(self):
1372         return self.__field_GPStime.getvalue()
1373 
1374     def __setfield_GPStime(self, value):
1375         if isinstance(value,GPSDATE):
1376             self.__field_GPStime=value
1377         else:
1378             self.__field_GPStime=GPSDATE(value,**{'sizeinbytes': 4})
1379 
1380     def __delfield_GPStime(self): del self.__field_GPStime
1381 
1382     GPStime=property(__getfield_GPStime, __setfield_GPStime, __delfield_GPStime, None)
1383 
1384     def __getfield_unknown1(self):
1385         return self.__field_unknown1.getvalue()
1386 
1387     def __setfield_unknown1(self, value):
1388         if isinstance(value,UINT):
1389             self.__field_unknown1=value
1390         else:
1391             self.__field_unknown1=UINT(value,**{'sizeinbytes': 4})
1392 
1393     def __delfield_unknown1(self): del self.__field_unknown1
1394 
1395     unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None)
1396 
1397     def __getfield_duration(self):
1398         return self.__field_duration.getvalue()
1399 
1400     def __setfield_duration(self, value):
1401         if isinstance(value,UINT):
1402             self.__field_duration=value
1403         else:
1404             self.__field_duration=UINT(value,**{'sizeinbytes': 4})
1405 
1406     def __delfield_duration(self): del self.__field_duration
1407 
1408     duration=property(__getfield_duration, __setfield_duration, __delfield_duration, None)
1409 
1410     def __getfield_number(self):
1411         return self.__field_number.getvalue()
1412 
1413     def __setfield_number(self, value):
1414         if isinstance(value,USTRING):
1415             self.__field_number=value
1416         else:
1417             self.__field_number=USTRING(value,**{'sizeinbytes': 49, 'raiseonunterminatedread': False})
1418 
1419     def __delfield_number(self): del self.__field_number
1420 
1421     number=property(__getfield_number, __setfield_number, __delfield_number, None)
1422 
1423     def __getfield_name(self):
1424         return self.__field_name.getvalue()
1425 
1426     def __setfield_name(self, value):
1427         if isinstance(value,USTRING):
1428             self.__field_name=value
1429         else:
1430             self.__field_name=USTRING(value,**{'sizeinbytes': 36, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})
1431 
1432     def __delfield_name(self): del self.__field_name
1433 
1434     name=property(__getfield_name, __setfield_name, __delfield_name, None)
1435 
1436     def __getfield_numberlength(self):
1437         return self.__field_numberlength.getvalue()
1438 
1439     def __setfield_numberlength(self, value):
1440         if isinstance(value,UINT):
1441             self.__field_numberlength=value
1442         else:
1443             self.__field_numberlength=UINT(value,**{'sizeinbytes': 1})
1444 
1445     def __delfield_numberlength(self): del self.__field_numberlength
1446 
1447     numberlength=property(__getfield_numberlength, __setfield_numberlength, __delfield_numberlength, None)
1448 
1449     def __getfield_unknown2(self):
1450         return self.__field_unknown2.getvalue()
1451 
1452     def __setfield_unknown2(self, value):
1453         if isinstance(value,UINT):
1454             self.__field_unknown2=value
1455         else:
1456             self.__field_unknown2=UINT(value,**{'sizeinbytes': 1})
1457 
1458     def __delfield_unknown2(self): del self.__field_unknown2
1459 
1460     unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None)
1461 
1462     def __getfield_pbnumbertype(self):
1463         return self.__field_pbnumbertype.getvalue()
1464 
1465     def __setfield_pbnumbertype(self, value):
1466         if isinstance(value,UINT):
1467             self.__field_pbnumbertype=value
1468         else:
1469             self.__field_pbnumbertype=UINT(value,**{'sizeinbytes': 1})
1470 
1471     def __delfield_pbnumbertype(self): del self.__field_pbnumbertype
1472 
1473     pbnumbertype=property(__getfield_pbnumbertype, __setfield_pbnumbertype, __delfield_pbnumbertype, None)
1474 
1475     def __getfield_unknown3(self):
1476         return self.__field_unknown3.getvalue()
1477 
1478     def __setfield_unknown3(self, value):
1479         if isinstance(value,UINT):
1480             self.__field_unknown3=value
1481         else:
1482             self.__field_unknown3=UINT(value,**{'sizeinbytes': 2})
1483 
1484     def __delfield_unknown3(self): del self.__field_unknown3
1485 
1486     unknown3=property(__getfield_unknown3, __setfield_unknown3, __delfield_unknown3, None)
1487 
1488     def __getfield_pbentrynum(self):
1489         return self.__field_pbentrynum.getvalue()
1490 
1491     def __setfield_pbentrynum(self, value):
1492         if isinstance(value,UINT):
1493             self.__field_pbentrynum=value
1494         else:
1495             self.__field_pbentrynum=UINT(value,**{'sizeinbytes': 2})
1496 
1497     def __delfield_pbentrynum(self): del self.__field_pbentrynum
1498 
1499     pbentrynum=property(__getfield_pbentrynum, __setfield_pbentrynum, __delfield_pbentrynum, None)
1500 
1501     def iscontainer(self):
1502         return True
1503 
1504     def containerelements(self):
1505         yield ('GPStime', self.__field_GPStime, None)
1506         yield ('unknown1', self.__field_unknown1, None)
1507         yield ('duration', self.__field_duration, None)
1508         yield ('number', self.__field_number, None)
1509         yield ('name', self.__field_name, None)
1510         yield ('numberlength', self.__field_numberlength, None)
1511         yield ('unknown2', self.__field_unknown2, None)
1512         yield ('pbnumbertype', self.__field_pbnumbertype, None)
1513         yield ('unknown3', self.__field_unknown3, None)
1514         yield ('pbentrynum', self.__field_pbentrynum, None)
1515 
1516 
1517 
1518 
1519 class callhistory(BaseProtogenClass):
1520     __fields=['numcalls', 'unknown1', 'calls']
1521 
1522     def __init__(self, *args, **kwargs):
1523         dict={}
1524         # What was supplied to this function
1525         dict.update(kwargs)
1526         # Parent constructor
1527         super(callhistory,self).__init__(**dict)
1528         if self.__class__ is callhistory:
1529             self._update(args,dict)
1530 
1531 
1532     def getfields(self):
1533         return self.__fields
1534 
1535 
1536     def _update(self, args, kwargs):
1537         super(callhistory,self)._update(args,kwargs)
1538         keys=kwargs.keys()
1539         for key in keys:
1540             if key in self.__fields:
1541                 setattr(self, key, kwargs[key])
1542                 del kwargs[key]
1543         # Were any unrecognized kwargs passed in?
1544         if __debug__:
1545             self._complainaboutunusedargs(callhistory,kwargs)
1546         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1547         # Make all P fields that haven't already been constructed
1548 
1549 
1550     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1551         'Writes this packet to the supplied buffer'
1552         self._bufferstartoffset=buf.getcurrentoffset()
1553         self.__field_numcalls.writetobuffer(buf)
1554         self.__field_unknown1.writetobuffer(buf)
1555         try: self.__field_calls
1556         except:
1557             self.__field_calls=LIST(**{'elementclass': call})
1558         self.__field_calls.writetobuffer(buf)
1559         self._bufferendoffset=buf.getcurrentoffset()
1560         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1561 
1562 
1563     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1564         'Reads this packet from the supplied buffer'
1565         self._bufferstartoffset=buf.getcurrentoffset()
1566         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1567         self.__field_numcalls=UINT(**{'sizeinbytes': 4})
1568         self.__field_numcalls.readfrombuffer(buf)
1569         self.__field_unknown1=UINT(**{'sizeinbytes': 1})
1570         self.__field_unknown1.readfrombuffer(buf)
1571         self.__field_calls=LIST(**{'elementclass': call})
1572         self.__field_calls.readfrombuffer(buf)
1573         self._bufferendoffset=buf.getcurrentoffset()
1574 
1575 
1576     def __getfield_numcalls(self):
1577         return self.__field_numcalls.getvalue()
1578 
1579     def __setfield_numcalls(self, value):
1580         if isinstance(value,UINT):
1581             self.__field_numcalls=value
1582         else:
1583             self.__field_numcalls=UINT(value,**{'sizeinbytes': 4})
1584 
1585     def __delfield_numcalls(self): del self.__field_numcalls
1586 
1587     numcalls=property(__getfield_numcalls, __setfield_numcalls, __delfield_numcalls, None)
1588 
1589     def __getfield_unknown1(self):
1590         return self.__field_unknown1.getvalue()
1591 
1592     def __setfield_unknown1(self, value):
1593         if isinstance(value,UINT):
1594             self.__field_unknown1=value
1595         else:
1596             self.__field_unknown1=UINT(value,**{'sizeinbytes': 1})
1597 
1598     def __delfield_unknown1(self): del self.__field_unknown1
1599 
1600     unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None)
1601 
1602     def __getfield_calls(self):
1603         try: self.__field_calls
1604         except:
1605             self.__field_calls=LIST(**{'elementclass': call})
1606         return self.__field_calls.getvalue()
1607 
1608     def __setfield_calls(self, value):
1609         if isinstance(value,LIST):
1610             self.__field_calls=value
1611         else:
1612             self.__field_calls=LIST(value,**{'elementclass': call})
1613 
1614     def __delfield_calls(self): del self.__field_calls
1615 
1616     calls=property(__getfield_calls, __setfield_calls, __delfield_calls, None)
1617 
1618     def iscontainer(self):
1619         return True
1620 
1621     def containerelements(self):
1622         yield ('numcalls', self.__field_numcalls, None)
1623         yield ('unknown1', self.__field_unknown1, None)
1624         yield ('calls', self.__field_calls, None)
1625 
1626 
1627 
1628 
1629 class indexentry(BaseProtogenClass):
1630     __fields=['index', 'name']
1631 
1632     def __init__(self, *args, **kwargs):
1633         dict={}
1634         # What was supplied to this function
1635         dict.update(kwargs)
1636         # Parent constructor
1637         super(indexentry,self).__init__(**dict)
1638         if self.__class__ is indexentry:
1639             self._update(args,dict)
1640 
1641 
1642     def getfields(self):
1643         return self.__fields
1644 
1645 
1646     def _update(self, args, kwargs):
1647         super(indexentry,self)._update(args,kwargs)
1648         keys=kwargs.keys()
1649         for key in keys:
1650             if key in self.__fields:
1651                 setattr(self, key, kwargs[key])
1652                 del kwargs[key]
1653         # Were any unrecognized kwargs passed in?
1654         if __debug__:
1655             self._complainaboutunusedargs(indexentry,kwargs)
1656         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1657         # Make all P fields that haven't already been constructed
1658 
1659 
1660     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1661         'Writes this packet to the supplied buffer'
1662         self._bufferstartoffset=buf.getcurrentoffset()
1663         try: self.__field_index
1664         except:
1665             self.__field_index=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
1666         self.__field_index.writetobuffer(buf)
1667         try: self.__field_name
1668         except:
1669             self.__field_name=USTRING(**{'sizeinbytes': 50, 'default': ""})
1670         self.__field_name.writetobuffer(buf)
1671         self._bufferendoffset=buf.getcurrentoffset()
1672         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1673 
1674 
1675     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1676         'Reads this packet from the supplied buffer'
1677         self._bufferstartoffset=buf.getcurrentoffset()
1678         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1679         self.__field_index=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
1680         self.__field_index.readfrombuffer(buf)
1681         self.__field_name=USTRING(**{'sizeinbytes': 50, 'default': ""})
1682         self.__field_name.readfrombuffer(buf)
1683         self._bufferendoffset=buf.getcurrentoffset()
1684 
1685 
1686     def __getfield_index(self):
1687         try: self.__field_index
1688         except:
1689             self.__field_index=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
1690         return self.__field_index.getvalue()
1691 
1692     def __setfield_index(self, value):
1693         if isinstance(value,UINT):
1694             self.__field_index=value
1695         else:
1696             self.__field_index=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff})
1697 
1698     def __delfield_index(self): del self.__field_index
1699 
1700     index=property(__getfield_index, __setfield_index, __delfield_index, None)
1701 
1702     def __getfield_name(self):
1703         try: self.__field_name
1704         except:
1705             self.__field_name=USTRING(**{'sizeinbytes': 50, 'default': ""})
1706         return self.__field_name.getvalue()
1707 
1708     def __setfield_name(self, value):
1709         if isinstance(value,USTRING):
1710             self.__field_name=value
1711         else:
1712             self.__field_name=USTRING(value,**{'sizeinbytes': 50, 'default': ""})
1713 
1714     def __delfield_name(self): del self.__field_name
1715 
1716     name=property(__getfield_name, __setfield_name, __delfield_name, None)
1717 
1718     def iscontainer(self):
1719         return True
1720 
1721     def containerelements(self):
1722         yield ('index', self.__field_index, None)
1723         yield ('name', self.__field_name, None)
1724 
1725 
1726 
1727 
1728 class indexfile(BaseProtogenClass):
1729     "Used for tracking wallpaper and ringtones"
1730     __fields=['maxitems', 'numactiveitems', 'items']
1731 
1732     def __init__(self, *args, **kwargs):
1733         dict={}
1734         # What was supplied to this function
1735         dict.update(kwargs)
1736         # Parent constructor
1737         super(indexfile,self).__init__(**dict)
1738         if self.__class__ is indexfile:
1739             self._update(args,dict)
1740 
1741 
1742     def getfields(self):
1743         return self.__fields
1744 
1745 
1746     def _update(self, args, kwargs):
1747         super(indexfile,self)._update(args,kwargs)
1748         keys=kwargs.keys()
1749         for key in keys:
1750             if key in self.__fields:
1751                 setattr(self, key, kwargs[key])
1752                 del kwargs[key]
1753         # Were any unrecognized kwargs passed in?
1754         if __debug__:
1755             self._complainaboutunusedargs(indexfile,kwargs)
1756         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1757         # Make all P fields that haven't already been constructed
1758         try: self.__field_maxitems
1759         except:
1760             self.__field_maxitems=UINT(**{'constant': 30})
1761 
1762 
1763     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1764         'Writes this packet to the supplied buffer'
1765         self._bufferstartoffset=buf.getcurrentoffset()
1766         self.__field_numactiveitems.writetobuffer(buf)
1767         try: self.__field_items
1768         except:
1769             self.__field_items=LIST(**{'length': self.maxitems, 'elementclass': indexentry, 'createdefault': True})
1770         self.__field_items.writetobuffer(buf)
1771         self._bufferendoffset=buf.getcurrentoffset()
1772         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1773 
1774 
1775     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1776         'Reads this packet from the supplied buffer'
1777         self._bufferstartoffset=buf.getcurrentoffset()
1778         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1779         self.__field_numactiveitems=UINT(**{'sizeinbytes': 2})
1780         self.__field_numactiveitems.readfrombuffer(buf)
1781         self.__field_items=LIST(**{'length': self.maxitems, 'elementclass': indexentry, 'createdefault': True})
1782         self.__field_items.readfrombuffer(buf)
1783         self._bufferendoffset=buf.getcurrentoffset()
1784 
1785 
1786     def __getfield_maxitems(self):
1787         return self.__field_maxitems.getvalue()
1788 
1789     def __setfield_maxitems(self, value):
1790         if isinstance(value,UINT):
1791             self.__field_maxitems=value
1792         else:
1793             self.__field_maxitems=UINT(value,**{'constant': 30})
1794 
1795     def __delfield_maxitems(self): del self.__field_maxitems
1796 
1797     maxitems=property(__getfield_maxitems, __setfield_maxitems, __delfield_maxitems, None)
1798 
1799     def __getfield_numactiveitems(self):
1800         return self.__field_numactiveitems.getvalue()
1801 
1802     def __setfield_numactiveitems(self, value):
1803         if isinstance(value,UINT):
1804             self.__field_numactiveitems=value
1805         else:
1806             self.__field_numactiveitems=UINT(value,**{'sizeinbytes': 2})
1807 
1808     def __delfield_numactiveitems(self): del self.__field_numactiveitems
1809 
1810     numactiveitems=property(__getfield_numactiveitems, __setfield_numactiveitems, __delfield_numactiveitems, None)
1811 
1812     def __getfield_items(self):
1813         try: self.__field_items
1814         except:
1815             self.__field_items=LIST(**{'length': self.maxitems, 'elementclass': indexentry, 'createdefault': True})
1816         return self.__field_items.getvalue()
1817 
1818     def __setfield_items(self, value):
1819         if isinstance(value,LIST):
1820             self.__field_items=value
1821         else:
1822             self.__field_items=LIST(value,**{'length': self.maxitems, 'elementclass': indexentry, 'createdefault': True})
1823 
1824     def __delfield_items(self): del self.__field_items
1825 
1826     items=property(__getfield_items, __setfield_items, __delfield_items, None)
1827 
1828     def iscontainer(self):
1829         return True
1830 
1831     def containerelements(self):
1832         yield ('maxitems', self.__field_maxitems, None)
1833         yield ('numactiveitems', self.__field_numactiveitems, None)
1834         yield ('items', self.__field_items, None)
1835 
1836 
1837 
1838 
1839 class camindexentry(BaseProtogenClass):
1840     __fields=['index', 'unknown1', 'name', 'taken', 'unkown2']
1841 
1842     def __init__(self, *args, **kwargs):
1843         dict={}
1844         # What was supplied to this function
1845         dict.update(kwargs)
1846         # Parent constructor
1847         super(camindexentry,self).__init__(**dict)
1848         if self.__class__ is camindexentry:
1849             self._update(args,dict)
1850 
1851 
1852     def getfields(self):
1853         return self.__fields
1854 
1855 
1856     def _update(self, args, kwargs):
1857         super(camindexentry,self)._update(args,kwargs)
1858         keys=kwargs.keys()
1859         for key in keys:
1860             if key in self.__fields:
1861                 setattr(self, key, kwargs[key])
1862                 del kwargs[key]
1863         # Were any unrecognized kwargs passed in?
1864         if __debug__:
1865             self._complainaboutunusedargs(camindexentry,kwargs)
1866         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1867         # Make all P fields that haven't already been constructed
1868 
1869 
1870     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1871         'Writes this packet to the supplied buffer'
1872         self._bufferstartoffset=buf.getcurrentoffset()
1873         self.__field_index.writetobuffer(buf)
1874         try: self.__field_unknown1
1875         except:
1876             self.__field_unknown1=UINT(**{'sizeinbytes': 1, 'default' : 80})
1877         self.__field_unknown1.writetobuffer(buf)
1878         try: self.__field_name
1879         except:
1880             self.__field_name=USTRING(**{'sizeinbytes': 10, 'default': ""})
1881         self.__field_name.writetobuffer(buf)
1882         self.__field_taken.writetobuffer(buf)
1883         self.__field_unkown2.writetobuffer(buf)
1884         self._bufferendoffset=buf.getcurrentoffset()
1885         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1886 
1887 
1888     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1889         'Reads this packet from the supplied buffer'
1890         self._bufferstartoffset=buf.getcurrentoffset()
1891         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1892         self.__field_index=UINT(**{'sizeinbytes': 1})
1893         self.__field_index.readfrombuffer(buf)
1894         self.__field_unknown1=UINT(**{'sizeinbytes': 1, 'default' : 80})
1895         self.__field_unknown1.readfrombuffer(buf)
1896         self.__field_name=USTRING(**{'sizeinbytes': 10, 'default': ""})
1897         self.__field_name.readfrombuffer(buf)
1898         self.__field_taken=LGCALDATE(**{'sizeinbytes': 4})
1899         self.__field_taken.readfrombuffer(buf)
1900         self.__field_unkown2=UINT(**{'sizeinbytes': 4})
1901         self.__field_unkown2.readfrombuffer(buf)
1902         self._bufferendoffset=buf.getcurrentoffset()
1903 
1904 
1905     def __getfield_index(self):
1906         return self.__field_index.getvalue()
1907 
1908     def __setfield_index(self, value):
1909         if isinstance(value,UINT):
1910             self.__field_index=value
1911         else:
1912             self.__field_index=UINT(value,**{'sizeinbytes': 1})
1913 
1914     def __delfield_index(self): del self.__field_index
1915 
1916     index=property(__getfield_index, __setfield_index, __delfield_index, None)
1917 
1918     def __getfield_unknown1(self):
1919         try: self.__field_unknown1
1920         except:
1921             self.__field_unknown1=UINT(**{'sizeinbytes': 1, 'default' : 80})
1922         return self.__field_unknown1.getvalue()
1923 
1924     def __setfield_unknown1(self, value):
1925         if isinstance(value,UINT):
1926             self.__field_unknown1=value
1927         else:
1928             self.__field_unknown1=UINT(value,**{'sizeinbytes': 1, 'default' : 80})
1929 
1930     def __delfield_unknown1(self): del self.__field_unknown1
1931 
1932     unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None)
1933 
1934     def __getfield_name(self):
1935         try: self.__field_name
1936         except:
1937             self.__field_name=USTRING(**{'sizeinbytes': 10, 'default': ""})
1938         return self.__field_name.getvalue()
1939 
1940     def __setfield_name(self, value):
1941         if isinstance(value,USTRING):
1942             self.__field_name=value
1943         else:
1944             self.__field_name=USTRING(value,**{'sizeinbytes': 10, 'default': ""})
1945 
1946     def __delfield_name(self): del self.__field_name
1947 
1948     name=property(__getfield_name, __setfield_name, __delfield_name, None)
1949 
1950     def __getfield_taken(self):
1951         return self.__field_taken.getvalue()
1952 
1953     def __setfield_taken(self, value):
1954         if isinstance(value,LGCALDATE):
1955             self.__field_taken=value
1956         else:
1957             self.__field_taken=LGCALDATE(value,**{'sizeinbytes': 4})
1958 
1959     def __delfield_taken(self): del self.__field_taken
1960 
1961     taken=property(__getfield_taken, __setfield_taken, __delfield_taken, None)
1962 
1963     def __getfield_unkown2(self):
1964         return self.__field_unkown2.getvalue()
1965 
1966     def __setfield_unkown2(self, value):
1967         if isinstance(value,UINT):
1968             self.__field_unkown2=value
1969         else:
1970             self.__field_unkown2=UINT(value,**{'sizeinbytes': 4})
1971 
1972     def __delfield_unkown2(self): del self.__field_unkown2
1973 
1974     unkown2=property(__getfield_unkown2, __setfield_unkown2, __delfield_unkown2, None)
1975 
1976     def iscontainer(self):
1977         return True
1978 
1979     def containerelements(self):
1980         yield ('index', self.__field_index, None)
1981         yield ('unknown1', self.__field_unknown1, None)
1982         yield ('name', self.__field_name, None)
1983         yield ('taken', self.__field_taken, None)
1984         yield ('unkown2', self.__field_unkown2, None)
1985 
1986 
1987 
1988 
1989 class camindexfile(BaseProtogenClass):
1990     "Used for tracking wallpaper and ringtones"
1991     __fields=['maxitems', 'items']
1992 
1993     def __init__(self, *args, **kwargs):
1994         dict={}
1995         # What was supplied to this function
1996         dict.update(kwargs)
1997         # Parent constructor
1998         super(camindexfile,self).__init__(**dict)
1999         if self.__class__ is camindexfile:
2000             self._update(args,dict)
2001 
2002 
2003     def getfields(self):
2004         return self.__fields
2005 
2006 
2007     def _update(self, args, kwargs):
2008         super(camindexfile,self)._update(args,kwargs)
2009         keys=kwargs.keys()
2010         for key in keys:
2011             if key in self.__fields:
2012                 setattr(self, key, kwargs[key])
2013                 del kwargs[key]
2014         # Were any unrecognized kwargs passed in?
2015         if __debug__:
2016             self._complainaboutunusedargs(camindexfile,kwargs)
2017         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2018         # Make all P fields that haven't already been constructed
2019         try: self.__field_maxitems
2020         except:
2021             self.__field_maxitems=UINT(**{'constant': 60})
2022 
2023 
2024     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2025         'Writes this packet to the supplied buffer'
2026         self._bufferstartoffset=buf.getcurrentoffset()
2027         try: self.__field_items
2028         except:
2029             self.__field_items=LIST(**{'length': self.maxitems, 'elementclass': camindexentry, 'createdefault': True})
2030         self.__field_items.writetobuffer(buf)
2031         self._bufferendoffset=buf.getcurrentoffset()
2032         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2033 
2034 
2035     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2036         'Reads this packet from the supplied buffer'
2037         self._bufferstartoffset=buf.getcurrentoffset()
2038         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2039         self.__field_items=LIST(**{'length': self.maxitems, 'elementclass': camindexentry, 'createdefault': True})
2040         self.__field_items.readfrombuffer(buf)
2041         self._bufferendoffset=buf.getcurrentoffset()
2042 
2043 
2044     def __getfield_maxitems(self):
2045         return self.__field_maxitems.getvalue()
2046 
2047     def __setfield_maxitems(self, value):
2048         if isinstance(value,UINT):
2049             self.__field_maxitems=value
2050         else:
2051             self.__field_maxitems=UINT(value,**{'constant': 60})
2052 
2053     def __delfield_maxitems(self): del self.__field_maxitems
2054 
2055     maxitems=property(__getfield_maxitems, __setfield_maxitems, __delfield_maxitems, None)
2056 
2057     def __getfield_items(self):
2058         try: self.__field_items
2059         except:
2060             self.__field_items=LIST(**{'length': self.maxitems, 'elementclass': camindexentry, 'createdefault': True})
2061         return self.__field_items.getvalue()
2062 
2063     def __setfield_items(self, value):
2064         if isinstance(value,LIST):
2065             self.__field_items=value
2066         else:
2067             self.__field_items=LIST(value,**{'length': self.maxitems, 'elementclass': camindexentry, 'createdefault': True})
2068 
2069     def __delfield_items(self): del self.__field_items
2070 
2071     items=property(__getfield_items, __setfield_items, __delfield_items, None)
2072 
2073     def iscontainer(self):
2074         return True
2075 
2076     def containerelements(self):
2077         yield ('maxitems', self.__field_maxitems, None)
2078         yield ('items', self.__field_items, None)
2079 
2080 
2081 
2082 
2083 class mediadesc(BaseProtogenClass):
2084     __fields=['totalsize', 'dunno1', 'magic1', 'magic2', 'magic3', 'dunno2', 'filename', 'whoknows', 'mimetype', 'whoknows2']
2085 
2086     def __init__(self, *args, **kwargs):
2087         dict={}
2088         # What was supplied to this function
2089         dict.update(kwargs)
2090         # Parent constructor
2091         super(mediadesc,self).__init__(**dict)
2092         if self.__class__ is mediadesc:
2093             self._update(args,dict)
2094 
2095 
2096     def getfields(self):
2097         return self.__fields
2098 
2099 
2100     def _update(self, args, kwargs):
2101         super(mediadesc,self)._update(args,kwargs)
2102         keys=kwargs.keys()
2103         for key in keys:
2104             if key in self.__fields:
2105                 setattr(self, key, kwargs[key])
2106                 del kwargs[key]
2107         # Were any unrecognized kwargs passed in?
2108         if __debug__:
2109             self._complainaboutunusedargs(mediadesc,kwargs)
2110         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2111         # Make all P fields that haven't already been constructed
2112 
2113 
2114     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2115         'Writes this packet to the supplied buffer'
2116         self._bufferstartoffset=buf.getcurrentoffset()
2117         self.__field_totalsize.writetobuffer(buf)
2118         try: self.__field_dunno1
2119         except:
2120             self.__field_dunno1=UINT(**{'sizeinbytes': 4, 'constant': 0})
2121         self.__field_dunno1.writetobuffer(buf)
2122         try: self.__field_magic1
2123         except:
2124             self.__field_magic1=UINT(**{'sizeinbytes': 4, 'default': 0x7824c97a})
2125         self.__field_magic1.writetobuffer(buf)
2126         try: self.__field_magic2
2127         except:
2128             self.__field_magic2=UINT(**{'sizeinbytes': 4, 'default': 0x7824c97a})
2129         self.__field_magic2.writetobuffer(buf)
2130         try: self.__field_magic3
2131         except:
2132             self.__field_magic3=UINT(**{'sizeinbytes': 4, 'default': 0x7824c97a})
2133         self.__field_magic3.writetobuffer(buf)
2134         try: self.__field_dunno2
2135         except:
2136             self.__field_dunno2=UINT(**{'sizeinbytes': 4, 'constant': 0})
2137         self.__field_dunno2.writetobuffer(buf)
2138         try: self.__field_filename
2139         except:
2140             self.__field_filename=USTRING(**{'sizeinbytes': 32, 'default': 'body'})
2141         self.__field_filename.writetobuffer(buf)
2142         try: self.__field_whoknows
2143         except:
2144             self.__field_whoknows=USTRING(**{'sizeinbytes': 32, 'default': 'identity'})
2145         self.__field_whoknows.writetobuffer(buf)
2146         self.__field_mimetype.writetobuffer(buf)
2147         try: self.__field_whoknows2
2148         except:
2149             self.__field_whoknows2=USTRING(**{'sizeinbytes': 32, 'default': ""})
2150         self.__field_whoknows2.writetobuffer(buf)
2151         self._bufferendoffset=buf.getcurrentoffset()
2152         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2153 
2154 
2155     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2156         'Reads this packet from the supplied buffer'
2157         self._bufferstartoffset=buf.getcurrentoffset()
2158         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2159         self.__field_totalsize=UINT(**{'sizeinbytes': 4})
2160         self.__field_totalsize.readfrombuffer(buf)
2161         self.__field_dunno1=UINT(**{'sizeinbytes': 4, 'constant': 0})
2162         self.__field_dunno1.readfrombuffer(buf)
2163         self.__field_magic1=UINT(**{'sizeinbytes': 4, 'default': 0x7824c97a})
2164         self.__field_magic1.readfrombuffer(buf)
2165         self.__field_magic2=UINT(**{'sizeinbytes': 4, 'default': 0x7824c97a})
2166         self.__field_magic2.readfrombuffer(buf)
2167         self.__field_magic3=UINT(**{'sizeinbytes': 4, 'default': 0x7824c97a})
2168         self.__field_magic3.readfrombuffer(buf)
2169         self.__field_dunno2=UINT(**{'sizeinbytes': 4, 'constant': 0})
2170         self.__field_dunno2.readfrombuffer(buf)
2171         self.__field_filename=USTRING(**{'sizeinbytes': 32, 'default': 'body'})
2172         self.__field_filename.readfrombuffer(buf)
2173         self.__field_whoknows=USTRING(**{'sizeinbytes': 32, 'default': 'identity'})
2174         self.__field_whoknows.readfrombuffer(buf)
2175         self.__field_mimetype=USTRING(**{'sizeinbytes': 32})
2176         self.__field_mimetype.readfrombuffer(buf)
2177         self.__field_whoknows2=USTRING(**{'sizeinbytes': 32, 'default': ""})
2178         self.__field_whoknows2.readfrombuffer(buf)
2179         self._bufferendoffset=buf.getcurrentoffset()
2180 
2181 
2182     def __getfield_totalsize(self):
2183         return self.__field_totalsize.getvalue()
2184 
2185     def __setfield_totalsize(self, value):
2186         if isinstance(value,UINT):
2187             self.__field_totalsize=value
2188         else:
2189             self.__field_totalsize=UINT(value,**{'sizeinbytes': 4})
2190 
2191     def __delfield_totalsize(self): del self.__field_totalsize
2192 
2193     totalsize=property(__getfield_totalsize, __setfield_totalsize, __delfield_totalsize, "media file size with size of this file (152 bytes) added")
2194 
2195     def __getfield_dunno1(self):
2196         try: self.__field_dunno1
2197         except:
2198             self.__field_dunno1=UINT(**{'sizeinbytes': 4, 'constant': 0})
2199         return self.__field_dunno1.getvalue()
2200 
2201     def __setfield_dunno1(self, value):
2202         if isinstance(value,UINT):
2203             self.__field_dunno1=value
2204         else:
2205             self.__field_dunno1=UINT(value,**{'sizeinbytes': 4, 'constant': 0})
2206 
2207     def __delfield_dunno1(self): del self.__field_dunno1
2208 
2209     dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None)
2210 
2211     def __getfield_magic1(self):
2212         try: self.__field_magic1
2213         except:
2214             self.__field_magic1=UINT(**{'sizeinbytes': 4, 'default': 0x7824c97a})
2215         return self.__field_magic1.getvalue()
2216 
2217     def __setfield_magic1(self, value):
2218         if isinstance(value,UINT):
2219             self.__field_magic1=value
2220         else:
2221             self.__field_magic1=UINT(value,**{'sizeinbytes': 4, 'default': 0x7824c97a})
2222 
2223     def __delfield_magic1(self): del self.__field_magic1
2224 
2225     magic1=property(__getfield_magic1, __setfield_magic1, __delfield_magic1, "probably the file date (created)")
2226 
2227     def __getfield_magic2(self):
2228         try: self.__field_magic2
2229         except:
2230             self.__field_magic2=UINT(**{'sizeinbytes': 4, 'default': 0x7824c97a})
2231         return self.__field_magic2.getvalue()
2232 
2233     def __setfield_magic2(self, value):
2234         if isinstance(value,UINT):
2235             self.__field_magic2=value
2236         else:
2237             self.__field_magic2=UINT(value,**{'sizeinbytes': 4, 'default': 0x7824c97a})
2238 
2239     def __delfield_magic2(self): del self.__field_magic2
2240 
2241     magic2=property(__getfield_magic2, __setfield_magic2, __delfield_magic2, "probably the file date (accessed)")
2242 
2243     def __getfield_magic3(self):
2244         try: self.__field_magic3
2245         except:
2246             self.__field_magic3=UINT(**{'sizeinbytes': 4, 'default': 0x7824c97a})
2247         return self.__field_magic3.getvalue()
2248 
2249     def __setfield_magic3(self, value):
2250         if isinstance(value,UINT):
2251             self.__field_magic3=value
2252         else:
2253             self.__field_magic3=UINT(value,**{'sizeinbytes': 4, 'default': 0x7824c97a})
2254 
2255     def __delfield_magic3(self): del self.__field_magic3
2256 
2257     magic3=property(__getfield_magic3, __setfield_magic3, __delfield_magic3, "probably the file date (modified)")
2258 
2259     def __getfield_dunno2(self):
2260         try: self.__field_dunno2
2261         except:
2262             self.__field_dunno2=UINT(**{'sizeinbytes': 4, 'constant': 0})
2263         return self.__field_dunno2.getvalue()
2264 
2265     def __setfield_dunno2(self, value):
2266         if isinstance(value,UINT):
2267             self.__field_dunno2=value
2268         else:
2269             self.__field_dunno2=UINT(value,**{'sizeinbytes': 4, 'constant': 0})
2270 
2271     def __delfield_dunno2(self): del self.__field_dunno2
2272 
2273     dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None)
2274 
2275     def __getfield_filename(self):
2276         try: self.__field_filename
2277         except:
2278             self.__field_filename=USTRING(**{'sizeinbytes': 32, 'default': 'body'})
2279         return self.__field_filename.getvalue()
2280 
2281     def __setfield_filename(self, value):
2282         if isinstance(value,USTRING):
2283             self.__field_filename=value
2284         else:
2285             self.__field_filename=USTRING(value,**{'sizeinbytes': 32, 'default': 'body'})
2286 
2287     def __delfield_filename(self): del self.__field_filename
2288 
2289     filename=property(__getfield_filename, __setfield_filename, __delfield_filename, None)
2290 
2291     def __getfield_whoknows(self):
2292         try: self.__field_whoknows
2293         except:
2294             self.__field_whoknows=USTRING(**{'sizeinbytes': 32, 'default': 'identity'})
2295         return self.__field_whoknows.getvalue()
2296 
2297     def __setfield_whoknows(self, value):
2298         if isinstance(value,USTRING):
2299             self.__field_whoknows=value
2300         else:
2301             self.__field_whoknows=USTRING(value,**{'sizeinbytes': 32, 'default': 'identity'})
2302 
2303     def __delfield_whoknows(self): del self.__field_whoknows
2304 
2305     whoknows=property(__getfield_whoknows, __setfield_whoknows, __delfield_whoknows, "set to iso8859_1 in some cases??")
2306 
2307     def __getfield_mimetype(self):
2308         return self.__field_mimetype.getvalue()
2309 
2310     def __setfield_mimetype(self, value):
2311         if isinstance(value,USTRING):
2312             self.__field_mimetype=value
2313         else:
2314             self.__field_mimetype=USTRING(value,**{'sizeinbytes': 32})
2315 
2316     def __delfield_mimetype(self): del self.__field_mimetype
2317 
2318     mimetype=property(__getfield_mimetype, __setfield_mimetype, __delfield_mimetype, None)
2319 
2320     def __getfield_whoknows2(self):
2321         try: self.__field_whoknows2
2322         except:
2323             self.__field_whoknows2=USTRING(**{'sizeinbytes': 32, 'default': ""})
2324         return self.__field_whoknows2.getvalue()
2325 
2326     def __setfield_whoknows2(self, value):
2327         if isinstance(value,USTRING):
2328             self.__field_whoknows2=value
2329         else:
2330             self.__field_whoknows2=USTRING(value,**{'sizeinbytes': 32, 'default': ""})
2331 
2332     def __delfield_whoknows2(self): del self.__field_whoknows2
2333 
2334     whoknows2=property(__getfield_whoknows2, __setfield_whoknows2, __delfield_whoknows2, None)
2335 
2336     def iscontainer(self):
2337         return True
2338 
2339     def containerelements(self):
2340         yield ('totalsize', self.__field_totalsize, "media file size with size of this file (152 bytes) added")
2341         yield ('dunno1', self.__field_dunno1, None)
2342         yield ('magic1', self.__field_magic1, "probably the file date (created)")
2343         yield ('magic2', self.__field_magic2, "probably the file date (accessed)")
2344         yield ('magic3', self.__field_magic3, "probably the file date (modified)")
2345         yield ('dunno2', self.__field_dunno2, None)
2346         yield ('filename', self.__field_filename, None)
2347         yield ('whoknows', self.__field_whoknows, "set to iso8859_1 in some cases??")
2348         yield ('mimetype', self.__field_mimetype, None)
2349         yield ('whoknows2', self.__field_whoknows2, None)
2350 
2351 
2352 
2353 
2354 class textmemo(BaseProtogenClass):
2355     __fields=['text']
2356 
2357     def __init__(self, *args, **kwargs):
2358         dict={}
2359         # What was supplied to this function
2360         dict.update(kwargs)
2361         # Parent constructor
2362         super(textmemo,self).__init__(**dict)
2363         if self.__class__ is textmemo:
2364             self._update(args,dict)
2365 
2366 
2367     def getfields(self):
2368         return self.__fields
2369 
2370 
2371     def _update(self, args, kwargs):
2372         super(textmemo,self)._update(args,kwargs)
2373         keys=kwargs.keys()
2374         for key in keys:
2375             if key in self.__fields:
2376                 setattr(self, key, kwargs[key])
2377                 del kwargs[key]
2378         # Were any unrecognized kwargs passed in?
2379         if __debug__:
2380             self._complainaboutunusedargs(textmemo,kwargs)
2381         if len(args):
2382             dict2={'sizeinbytes': 151,  'raiseonunterminatedread': False, 'raiseontruncate': False }
2383             dict2.update(kwargs)
2384             kwargs=dict2
2385             self.__field_text=USTRING(*args,**dict2)
2386         # Make all P fields that haven't already been constructed
2387 
2388 
2389     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2390         'Writes this packet to the supplied buffer'
2391         self._bufferstartoffset=buf.getcurrentoffset()
2392         self.__field_text.writetobuffer(buf)
2393         self._bufferendoffset=buf.getcurrentoffset()
2394         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2395 
2396 
2397     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2398         'Reads this packet from the supplied buffer'
2399         self._bufferstartoffset=buf.getcurrentoffset()
2400         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2401         self.__field_text=USTRING(**{'sizeinbytes': 151,  'raiseonunterminatedread': False, 'raiseontruncate': False })
2402         self.__field_text.readfrombuffer(buf)
2403         self._bufferendoffset=buf.getcurrentoffset()
2404 
2405 
2406     def __getfield_text(self):
2407         return self.__field_text.getvalue()
2408 
2409     def __setfield_text(self, value):
2410         if isinstance(value,USTRING):
2411             self.__field_text=value
2412         else:
2413             self.__field_text=USTRING(value,**{'sizeinbytes': 151,  'raiseonunterminatedread': False, 'raiseontruncate': False })
2414 
2415     def __delfield_text(self): del self.__field_text
2416 
2417     text=property(__getfield_text, __setfield_text, __delfield_text, None)
2418 
2419     def iscontainer(self):
2420         return True
2421 
2422     def containerelements(self):
2423         yield ('text', self.__field_text, None)
2424 
2425 
2426 
2427 
2428 class textmemofile(BaseProtogenClass):
2429     __fields=['itemcount', 'items']
2430 
2431     def __init__(self, *args, **kwargs):
2432         dict={}
2433         # What was supplied to this function
2434         dict.update(kwargs)
2435         # Parent constructor
2436         super(textmemofile,self).__init__(**dict)
2437         if self.__class__ is textmemofile:
2438             self._update(args,dict)
2439 
2440 
2441     def getfields(self):
2442         return self.__fields
2443 
2444 
2445     def _update(self, args, kwargs):
2446         super(textmemofile,self)._update(args,kwargs)
2447         keys=kwargs.keys()
2448         for key in keys:
2449             if key in self.__fields:
2450                 setattr(self, key, kwargs[key])
2451                 del kwargs[key]
2452         # Were any unrecognized kwargs passed in?
2453         if __debug__:
2454             self._complainaboutunusedargs(textmemofile,kwargs)
2455         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2456         # Make all P fields that haven't already been constructed
2457 
2458 
2459     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2460         'Writes this packet to the supplied buffer'
2461         self._bufferstartoffset=buf.getcurrentoffset()
2462         self.__field_itemcount.writetobuffer(buf)
2463         try: self.__field_items
2464         except:
2465             self.__field_items=LIST(**{'elementclass': textmemo })
2466         self.__field_items.writetobuffer(buf)
2467         self._bufferendoffset=buf.getcurrentoffset()
2468         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2469 
2470 
2471     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2472         'Reads this packet from the supplied buffer'
2473         self._bufferstartoffset=buf.getcurrentoffset()
2474         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2475         self.__field_itemcount=UINT(**{'sizeinbytes': 4})
2476         self.__field_itemcount.readfrombuffer(buf)
2477         self.__field_items=LIST(**{'elementclass': textmemo })
2478         self.__field_items.readfrombuffer(buf)
2479         self._bufferendoffset=buf.getcurrentoffset()
2480 
2481 
2482     def __getfield_itemcount(self):
2483         return self.__field_itemcount.getvalue()
2484 
2485     def __setfield_itemcount(self, value):
2486         if isinstance(value,UINT):
2487             self.__field_itemcount=value
2488         else:
2489             self.__field_itemcount=UINT(value,**{'sizeinbytes': 4})
2490 
2491     def __delfield_itemcount(self): del self.__field_itemcount
2492 
2493     itemcount=property(__getfield_itemcount, __setfield_itemcount, __delfield_itemcount, None)
2494 
2495     def __getfield_items(self):
2496         try: self.__field_items
2497         except:
2498             self.__field_items=LIST(**{'elementclass': textmemo })
2499         return self.__field_items.getvalue()
2500 
2501     def __setfield_items(self, value):
2502         if isinstance(value,LIST):
2503             self.__field_items=value
2504         else:
2505             self.__field_items=LIST(value,**{'elementclass': textmemo })
2506 
2507     def __delfield_items(self): del self.__field_items
2508 
2509     items=property(__getfield_items, __setfield_items, __delfield_items, None)
2510 
2511     def iscontainer(self):
2512         return True
2513 
2514     def containerelements(self):
2515         yield ('itemcount', self.__field_itemcount, None)
2516         yield ('items', self.__field_items, None)
2517 
2518 
2519 
2520 
2521 class scheduleexception(BaseProtogenClass):
2522     __fields=['pos', 'day', 'month', 'year']
2523 
2524     def __init__(self, *args, **kwargs):
2525         dict={}
2526         # What was supplied to this function
2527         dict.update(kwargs)
2528         # Parent constructor
2529         super(scheduleexception,self).__init__(**dict)
2530         if self.__class__ is scheduleexception:
2531             self._update(args,dict)
2532 
2533 
2534     def getfields(self):
2535         return self.__fields
2536 
2537 
2538     def _update(self, args, kwargs):
2539         super(scheduleexception,self)._update(args,kwargs)
2540         keys=kwargs.keys()
2541         for key in keys:
2542             if key in self.__fields:
2543                 setattr(self, key, kwargs[key])
2544                 del kwargs[key]
2545         # Were any unrecognized kwargs passed in?
2546         if __debug__:
2547             self._complainaboutunusedargs(scheduleexception,kwargs)
2548         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2549         # Make all P fields that haven't already been constructed
2550 
2551 
2552     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2553         'Writes this packet to the supplied buffer'
2554         self._bufferstartoffset=buf.getcurrentoffset()
2555         self.__field_pos.writetobuffer(buf)
2556         self.__field_day.writetobuffer(buf)
2557         self.__field_month.writetobuffer(buf)
2558         self.__field_year.writetobuffer(buf)
2559         self._bufferendoffset=buf.getcurrentoffset()
2560         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2561 
2562 
2563     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2564         'Reads this packet from the supplied buffer'
2565         self._bufferstartoffset=buf.getcurrentoffset()
2566         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2567         self.__field_pos=UINT(**{'sizeinbytes': 4})
2568         self.__field_pos.readfrombuffer(buf)
2569         self.__field_day=UINT(**{'sizeinbytes': 1})
2570         self.__field_day.readfrombuffer(buf)
2571         self.__field_month=UINT(**{'sizeinbytes': 1})
2572         self.__field_month.readfrombuffer(buf)
2573         self.__field_year=UINT(**{'sizeinbytes': 2})
2574         self.__field_year.readfrombuffer(buf)
2575         self._bufferendoffset=buf.getcurrentoffset()
2576 
2577 
2578     def __getfield_pos(self):
2579         return self.__field_pos.getvalue()
2580 
2581     def __setfield_pos(self, value):
2582         if isinstance(value,UINT):
2583             self.__field_pos=value
2584         else:
2585             self.__field_pos=UINT(value,**{'sizeinbytes': 4})
2586 
2587     def __delfield_pos(self): del self.__field_pos
2588 
2589     pos=property(__getfield_pos, __setfield_pos, __delfield_pos, "Refers to event id (position in schedule file) that this suppresses")
2590 
2591     def __getfield_day(self):
2592         return self.__field_day.getvalue()
2593 
2594     def __setfield_day(self, value):
2595         if isinstance(value,UINT):
2596             self.__field_day=value
2597         else:
2598             self.__field_day=UINT(value,**{'sizeinbytes': 1})
2599 
2600     def __delfield_day(self): del self.__field_day
2601 
2602     day=property(__getfield_day, __setfield_day, __delfield_day, None)
2603 
2604     def __getfield_month(self):
2605         return self.__field_month.getvalue()
2606 
2607     def __setfield_month(self, value):
2608         if isinstance(value,UINT):
2609             self.__field_month=value
2610         else:
2611             self.__field_month=UINT(value,**{'sizeinbytes': 1})
2612 
2613     def __delfield_month(self): del self.__field_month
2614 
2615     month=property(__getfield_month, __setfield_month, __delfield_month, None)
2616 
2617     def __getfield_year(self):
2618         return self.__field_year.getvalue()
2619 
2620     def __setfield_year(self, value):
2621         if isinstance(value,UINT):
2622             self.__field_year=value
2623         else:
2624             self.__field_year=UINT(value,**{'sizeinbytes': 2})
2625 
2626     def __delfield_year(self): del self.__field_year
2627 
2628     year=property(__getfield_year, __setfield_year, __delfield_year, None)
2629 
2630     def iscontainer(self):
2631         return True
2632 
2633     def containerelements(self):
2634         yield ('pos', self.__field_pos, "Refers to event id (position in schedule file) that this suppresses")
2635         yield ('day', self.__field_day, None)
2636         yield ('month', self.__field_month, None)
2637         yield ('year', self.__field_year, None)
2638 
2639 
2640 
2641 
2642 class scheduleexceptionfile(BaseProtogenClass):
2643     __fields=['items']
2644 
2645     def __init__(self, *args, **kwargs):
2646         dict={}
2647         # What was supplied to this function
2648         dict.update(kwargs)
2649         # Parent constructor
2650         super(scheduleexceptionfile,self).__init__(**dict)
2651         if self.__class__ is scheduleexceptionfile:
2652             self._update(args,dict)
2653 
2654 
2655     def getfields(self):
2656         return self.__fields
2657 
2658 
2659     def _update(self, args, kwargs):
2660         super(scheduleexceptionfile,self)._update(args,kwargs)
2661         keys=kwargs.keys()
2662         for key in keys:
2663             if key in self.__fields:
2664                 setattr(self, key, kwargs[key])
2665                 del kwargs[key]
2666         # Were any unrecognized kwargs passed in?
2667         if __debug__:
2668             self._complainaboutunusedargs(scheduleexceptionfile,kwargs)
2669         if len(args):
2670             dict2={'elementclass': scheduleexception}
2671             dict2.update(kwargs)
2672             kwargs=dict2
2673             self.__field_items=LIST(*args,**dict2)
2674         # Make all P fields that haven't already been constructed
2675 
2676 
2677     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2678         'Writes this packet to the supplied buffer'
2679         self._bufferstartoffset=buf.getcurrentoffset()
2680         try: self.__field_items
2681         except:
2682             self.__field_items=LIST(**{'elementclass': scheduleexception})
2683         self.__field_items.writetobuffer(buf)
2684         self._bufferendoffset=buf.getcurrentoffset()
2685         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2686 
2687 
2688     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2689         'Reads this packet from the supplied buffer'
2690         self._bufferstartoffset=buf.getcurrentoffset()
2691         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2692         self.__field_items=LIST(**{'elementclass': scheduleexception})
2693         self.__field_items.readfrombuffer(buf)
2694         self._bufferendoffset=buf.getcurrentoffset()
2695 
2696 
2697     def __getfield_items(self):
2698         try: self.__field_items
2699         except:
2700             self.__field_items=LIST(**{'elementclass': scheduleexception})
2701         return self.__field_items.getvalue()
2702 
2703     def __setfield_items(self, value):
2704         if isinstance(value,LIST):
2705             self.__field_items=value
2706         else:
2707             self.__field_items=LIST(value,**{'elementclass': scheduleexception})
2708 
2709     def __delfield_items(self): del self.__field_items
2710 
2711     items=property(__getfield_items, __setfield_items, __delfield_items, None)
2712 
2713     def iscontainer(self):
2714         return True
2715 
2716     def containerelements(self):
2717         yield ('items', self.__field_items, None)
2718 
2719 
2720 
2721 
2722 class scheduleevent(BaseProtogenClass):
2723     __fields=['packet_size', 'pos', 'start', 'end', 'repeat', 'daybitmap', 'pad2', 'alarmminutes', 'alarmhours', 'alarmtype', 'snoozedelay', 'ringtone', 'description', 'unknown1', 'hasvoice', 'voiceid', 'unknown2']
2724 
2725     def __init__(self, *args, **kwargs):
2726         dict={}
2727         # What was supplied to this function
2728         dict.update(kwargs)
2729         # Parent constructor
2730         super(scheduleevent,self).__init__(**dict)
2731         if self.__class__ is scheduleevent:
2732             self._update(args,dict)
2733 
2734 
2735     def getfields(self):
2736         return self.__fields
2737 
2738 
2739     def _update(self, args, kwargs):
2740         super(scheduleevent,self)._update(args,kwargs)
2741         keys=kwargs.keys()
2742         for key in keys:
2743             if key in self.__fields:
2744                 setattr(self, key, kwargs[key])
2745                 del kwargs[key]
2746         # Were any unrecognized kwargs passed in?
2747         if __debug__:
2748             self._complainaboutunusedargs(scheduleevent,kwargs)
2749         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2750         # Make all P fields that haven't already been constructed
2751         try: self.__field_packet_size
2752         except:
2753             self.__field_packet_size=UINT(**{ 'constant': 64 })
2754 
2755 
2756     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2757         'Writes this packet to the supplied buffer'
2758         self._bufferstartoffset=buf.getcurrentoffset()
2759         self.__field_pos.writetobuffer(buf)
2760         self.__field_start.writetobuffer(buf)
2761         self.__field_end.writetobuffer(buf)
2762         self.__field_repeat.writetobuffer(buf)
2763         self.__field_daybitmap.writetobuffer(buf)
2764         try: self.__field_pad2
2765         except:
2766             self.__field_pad2=UINT(**{'sizeinbytes': 1,  'default': 0 })
2767         self.__field_pad2.writetobuffer(buf)
2768         self.__field_alarmminutes.writetobuffer(buf)
2769         self.__field_alarmhours.writetobuffer(buf)
2770         self.__field_alarmtype.writetobuffer(buf)
2771         try: self.__field_snoozedelay
2772         except:
2773             self.__field_snoozedelay=UINT(**{'sizeinbytes': 1,  'default': 0 })
2774         self.__field_snoozedelay.writetobuffer(buf)
2775         self.__field_ringtone.writetobuffer(buf)
2776         self.__field_description.writetobuffer(buf)
2777         try: self.__field_unknown1
2778         except:
2779             self.__field_unknown1=UINT(**{'sizeinbytes': 2,  'default': 0 })
2780         self.__field_unknown1.writetobuffer(buf)
2781         self.__field_hasvoice.writetobuffer(buf)
2782         self.__field_voiceid.writetobuffer(buf)
2783         try: self.__field_unknown2
2784         except:
2785             self.__field_unknown2=UINT(**{'sizeinbytes': 2,  'default': 0 })
2786         self.__field_unknown2.writetobuffer(buf)
2787         self._bufferendoffset=buf.getcurrentoffset()
2788         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2789 
2790 
2791     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2792         'Reads this packet from the supplied buffer'
2793         self._bufferstartoffset=buf.getcurrentoffset()
2794         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2795         self.__field_pos=UINT(**{'sizeinbytes': 4})
2796         self.__field_pos.readfrombuffer(buf)
2797         self.__field_start=LGCALDATE(**{'sizeinbytes': 4})
2798         self.__field_start.readfrombuffer(buf)
2799         self.__field_end=LGCALDATE(**{'sizeinbytes': 4})
2800         self.__field_end.readfrombuffer(buf)
2801         self.__field_repeat=UINT(**{'sizeinbytes': 1})
2802         self.__field_repeat.readfrombuffer(buf)
2803         self.__field_daybitmap=UINT(**{'sizeinbytes': 2})
2804         self.__field_daybitmap.readfrombuffer(buf)
2805         self.__field_pad2=UINT(**{'sizeinbytes': 1,  'default': 0 })
2806         self.__field_pad2.readfrombuffer(buf)
2807         self.__field_alarmminutes=UINT(**{'sizeinbytes': 1})
2808         self.__field_alarmminutes.readfrombuffer(buf)
2809         self.__field_alarmhours=UINT(**{'sizeinbytes': 1})
2810         self.__field_alarmhours.readfrombuffer(buf)
2811         self.__field_alarmtype=UINT(**{'sizeinbytes': 1})
2812         self.__field_alarmtype.readfrombuffer(buf)
2813         self.__field_snoozedelay=UINT(**{'sizeinbytes': 1,  'default': 0 })
2814         self.__field_snoozedelay.readfrombuffer(buf)
2815         self.__field_ringtone=UINT(**{'sizeinbytes': 1})
2816         self.__field_ringtone.readfrombuffer(buf)
2817         self.__field_description=USTRING(**{'sizeinbytes': 35, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False })
2818         self.__field_description.readfrombuffer(buf)
2819         self.__field_unknown1=UINT(**{'sizeinbytes': 2,  'default': 0 })
2820         self.__field_unknown1.readfrombuffer(buf)
2821         self.__field_hasvoice=UINT(**{'sizeinbytes': 2})
2822         self.__field_hasvoice.readfrombuffer(buf)
2823         self.__field_voiceid=UINT(**{'sizeinbytes': 2})
2824         self.__field_voiceid.readfrombuffer(buf)
2825         self.__field_unknown2=UINT(**{'sizeinbytes': 2,  'default': 0 })
2826         self.__field_unknown2.readfrombuffer(buf)
2827         self._bufferendoffset=buf.getcurrentoffset()
2828 
2829 
2830     def __getfield_packet_size(self):
2831         return self.__field_packet_size.getvalue()
2832 
2833     def __setfield_packet_size(self, value):
2834         if isinstance(value,UINT):
2835             self.__field_packet_size=value
2836         else:
2837             self.__field_packet_size=UINT(value,**{ 'constant': 64 })
2838 
2839     def __delfield_packet_size(self): del self.__field_packet_size
2840 
2841     packet_size=property(__getfield_packet_size, __setfield_packet_size, __delfield_packet_size, "Faster than packetsize()")
2842 
2843     def __getfield_pos(self):
2844         return self.__field_pos.getvalue()
2845 
2846     def __setfield_pos(self, value):
2847         if isinstance(value,UINT):
2848             self.__field_pos=value
2849         else:
2850             self.__field_pos=UINT(value,**{'sizeinbytes': 4})
2851 
2852     def __delfield_pos(self): del self.__field_pos
2853 
2854     pos=property(__getfield_pos, __setfield_pos, __delfield_pos, "position within file, used as an event id")
2855 
2856     def __getfield_start(self):
2857         return self.__field_start.getvalue()
2858 
2859     def __setfield_start(self, value):
2860         if isinstance(value,LGCALDATE):
2861             self.__field_start=value
2862         else:
2863             self.__field_start=LGCALDATE(value,**{'sizeinbytes': 4})
2864 
2865     def __delfield_start(self): del self.__field_start
2866 
2867     start=property(__getfield_start, __setfield_start, __delfield_start, None)
2868 
2869     def __getfield_end(self):
2870         return self.__field_end.getvalue()
2871 
2872     def __setfield_end(self, value):
2873         if isinstance(value,LGCALDATE):
2874             self.__field_end=value
2875         else:
2876             self.__field_end=LGCALDATE(value,**{'sizeinbytes': 4})
2877 
2878     def __delfield_end(self): del self.__field_end
2879 
2880     end=property(__getfield_end, __setfield_end, __delfield_end, None)
2881 
2882     def __getfield_repeat(self):
2883         return self.__field_repeat.getvalue()
2884 
2885     def __setfield_repeat(self, value):
2886         if isinstance(value,UINT):
2887             self.__field_repeat=value
2888         else:
2889             self.__field_repeat=UINT(value,**{'sizeinbytes': 1})
2890 
2891     def __delfield_repeat(self): del self.__field_repeat
2892 
2893     repeat=property(__getfield_repeat, __setfield_repeat, __delfield_repeat, None)
2894 
2895     def __getfield_daybitmap(self):
2896         return self.__field_daybitmap.getvalue()
2897 
2898     def __setfield_daybitmap(self, value):
2899         if isinstance(value,UINT):
2900             self.__field_daybitmap=value
2901         else:
2902             self.__field_daybitmap=UINT(value,**{'sizeinbytes': 2})
2903 
2904     def __delfield_daybitmap(self): del self.__field_daybitmap
2905 
2906     daybitmap=property(__getfield_daybitmap, __setfield_daybitmap, __delfield_daybitmap, "which days a weekly repeat event happens on")
2907 
2908     def __getfield_pad2(self):
2909         try: self.__field_pad2
2910         except:
2911             self.__field_pad2=UINT(**{'sizeinbytes': 1,  'default': 0 })
2912         return self.__field_pad2.getvalue()
2913 
2914     def __setfield_pad2(self, value):
2915         if isinstance(value,UINT):
2916             self.__field_pad2=value
2917         else:
2918             self.__field_pad2=UINT(value,**{'sizeinbytes': 1,  'default': 0 })
2919 
2920     def __delfield_pad2(self): del self.__field_pad2
2921 
2922     pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None)
2923 
2924     def __getfield_alarmminutes(self):
2925         return self.__field_alarmminutes.getvalue()
2926 
2927     def __setfield_alarmminutes(self, value):
2928         if isinstance(value,UINT):
2929             self.__field_alarmminutes=value
2930         else:
2931             self.__field_alarmminutes=UINT(value,**{'sizeinbytes': 1})
2932 
2933     def __delfield_alarmminutes(self): del self.__field_alarmminutes
2934 
2935     alarmminutes=property(__getfield_alarmminutes, __setfield_alarmminutes, __delfield_alarmminutes, "a value of 100 indicates not set")
2936 
2937     def __getfield_alarmhours(self):
2938         return self.__field_alarmhours.getvalue()
2939 
2940     def __setfield_alarmhours(self, value):
2941         if isinstance(value,UINT):
2942             self.__field_alarmhours=value
2943         else:
2944             self.__field_alarmhours=UINT(value,**{'sizeinbytes': 1})
2945 
2946     def __delfield_alarmhours(self): del self.__field_alarmhours
2947 
2948     alarmhours=property(__getfield_alarmhours, __setfield_alarmhours, __delfield_alarmhours, "a value of 100 indicates not set")
2949 
2950     def __getfield_alarmtype(self):
2951         return self.__field_alarmtype.getvalue()
2952 
2953     def __setfield_alarmtype(self, value):
2954         if isinstance(value,UINT):
2955             self.__field_alarmtype=value
2956         else:
2957             self.__field_alarmtype=UINT(value,**{'sizeinbytes': 1})
2958 
2959     def __delfield_alarmtype(self): del self.__field_alarmtype
2960 
2961     alarmtype=property(__getfield_alarmtype, __setfield_alarmtype, __delfield_alarmtype, "preset alarm reminder type")
2962 
2963     def __getfield_snoozedelay(self):
2964         try: self.__field_snoozedelay
2965         except:
2966             self.__field_snoozedelay=UINT(**{'sizeinbytes': 1,  'default': 0 })
2967         return self.__field_snoozedelay.getvalue()
2968 
2969     def __setfield_snoozedelay(self, value):
2970         if isinstance(value,UINT):
2971             self.__field_snoozedelay=value
2972         else:
2973             self.__field_snoozedelay=UINT(value,**{'sizeinbytes': 1,  'default': 0 })
2974 
2975     def __delfield_snoozedelay(self): del self.__field_snoozedelay
2976 
2977     snoozedelay=property(__getfield_snoozedelay, __setfield_snoozedelay, __delfield_snoozedelay, "in minutes, not for this phone")
2978 
2979     def __getfield_ringtone(self):
2980         return self.__field_ringtone.getvalue()
2981 
2982     def __setfield_ringtone(self, value):
2983         if isinstance(value,UINT):
2984             self.__field_ringtone=value
2985         else:
2986             self.__field_ringtone=UINT(value,**{'sizeinbytes': 1})
2987 
2988     def __delfield_ringtone(self): del self.__field_ringtone
2989 
2990     ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None)
2991 
2992     def __getfield_description(self):
2993         return self.__field_description.getvalue()
2994 
2995     def __setfield_description(self, value):
2996         if isinstance(value,USTRING):
2997             self.__field_description=value
2998         else:
2999             self.__field_description=USTRING(value,**{'sizeinbytes': 35, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False })
3000 
3001     def __delfield_description(self): del self.__field_description
3002 
3003     description=property(__getfield_description, __setfield_description, __delfield_description, None)
3004 
3005     def __getfield_unknown1(self):
3006         try: self.__field_unknown1
3007         except:
3008             self.__field_unknown1=UINT(**{'sizeinbytes': 2,  'default': 0 })
3009         return self.__field_unknown1.getvalue()
3010 
3011     def __setfield_unknown1(self, value):
3012         if isinstance(value,UINT):
3013             self.__field_unknown1=value
3014         else:
3015             self.__field_unknown1=UINT(value,**{'sizeinbytes': 2,  'default': 0 })
3016 
3017     def __delfield_unknown1(self): del self.__field_unknown1
3018 
3019     unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, "This seems to always be two zeros")
3020 
3021     def __getfield_hasvoice(self):
3022         return self.__field_hasvoice.getvalue()
3023 
3024     def __setfield_hasvoice(self, value):
3025         if isinstance(value,UINT):
3026             self.__field_hasvoice=value
3027         else:
3028             self.__field_hasvoice=UINT(value,**{'sizeinbytes': 2})
3029 
3030     def __delfield_hasvoice(self): del self.__field_hasvoice
3031 
3032     hasvoice=property(__getfield_hasvoice, __setfield_hasvoice, __delfield_hasvoice, "This event has an associated voice memo if 1")
3033 
3034     def __getfield_voiceid(self):
3035         return self.__field_voiceid.getvalue()
3036 
3037     def __setfield_voiceid(self, value):
3038         if isinstance(value,UINT):
3039             self.__field_voiceid=value
3040         else:
3041             self.__field_voiceid=UINT(value,**{'sizeinbytes': 2})
3042 
3043     def __delfield_voiceid(self): del self.__field_voiceid
3044 
3045     voiceid=property(__getfield_voiceid, __setfield_voiceid, __delfield_voiceid, "sch/schexxx.qcp is the voice memo (xxx = voiceid - 0x0f)")
3046 
3047     def __getfield_unknown2(self):
3048         try: self.__field_unknown2
3049         except:
3050             self.__field_unknown2=UINT(**{'sizeinbytes': 2,  'default': 0 })
3051         return self.__field_unknown2.getvalue()
3052 
3053     def __setfield_unknown2(self, value):
3054         if isinstance(value,UINT):
3055             self.__field_unknown2=value
3056         else:
3057             self.__field_unknown2=UINT(value,**{'sizeinbytes': 2,  'default': 0 })
3058 
3059     def __delfield_unknown2(self): del self.__field_unknown2
3060 
3061     unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, "This seems to always be yet two more zeros")
3062 
3063     def iscontainer(self):
3064         return True
3065 
3066     def containerelements(self):
3067         yield ('packet_size', self.__field_packet_size, "Faster than packetsize()")
3068         yield ('pos', self.__field_pos, "position within file, used as an event id")
3069         yield ('start', self.__field_start, None)
3070         yield ('end', self.__field_end, None)
3071         yield ('repeat', self.__field_repeat, None)
3072         yield ('daybitmap', self.__field_daybitmap, "which days a weekly repeat event happens on")
3073         yield ('pad2', self.__field_pad2, None)
3074         yield ('alarmminutes', self.__field_alarmminutes, "a value of 100 indicates not set")
3075         yield ('alarmhours', self.__field_alarmhours, "a value of 100 indicates not set")
3076         yield ('alarmtype', self.__field_alarmtype, "preset alarm reminder type")
3077         yield ('snoozedelay', self.__field_snoozedelay, "in minutes, not for this phone")
3078         yield ('ringtone', self.__field_ringtone, None)
3079         yield ('description', self.__field_description, None)
3080         yield ('unknown1', self.__field_unknown1, "This seems to always be two zeros")
3081         yield ('hasvoice', self.__field_hasvoice, "This event has an associated voice memo if 1")
3082         yield ('voiceid', self.__field_voiceid, "sch/schexxx.qcp is the voice memo (xxx = voiceid - 0x0f)")
3083         yield ('unknown2', self.__field_unknown2, "This seems to always be yet two more zeros")
3084 
3085 
3086 
3087 
3088 class schedulefile(BaseProtogenClass):
3089     __fields=['numactiveitems', 'events']
3090 
3091     def __init__(self, *args, **kwargs):
3092         dict={}
3093         # What was supplied to this function
3094         dict.update(kwargs)
3095         # Parent constructor
3096         super(schedulefile,self).__init__(**dict)
3097         if self.__class__ is schedulefile:
3098             self._update(args,dict)
3099 
3100 
3101     def getfields(self):
3102         return self.__fields
3103 
3104 
3105     def _update(self, args, kwargs):
3106         super(schedulefile,self)._update(args,kwargs)
3107         keys=kwargs.keys()
3108         for key in keys:
3109             if key in self.__fields:
3110                 setattr(self, key, kwargs[key])
3111                 del kwargs[key]
3112         # Were any unrecognized kwargs passed in?
3113         if __debug__:
3114             self._complainaboutunusedargs(schedulefile,kwargs)
3115         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
3116         # Make all P fields that haven't already been constructed
3117 
3118 
3119     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3120         'Writes this packet to the supplied buffer'
3121         self._bufferstartoffset=buf.getcurrentoffset()
3122         self.__field_numactiveitems.writetobuffer(buf)
3123         try: self.__field_events
3124         except:
3125             self.__field_events=LIST(**{'elementclass': scheduleevent})
3126         self.__field_events.writetobuffer(buf)
3127         self._bufferendoffset=buf.getcurrentoffset()
3128         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3129 
3130 
3131     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3132         'Reads this packet from the supplied buffer'
3133         self._bufferstartoffset=buf.getcurrentoffset()
3134         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3135         self.__field_numactiveitems=UINT(**{'sizeinbytes': 2})
3136         self.__field_numactiveitems.readfrombuffer(buf)
3137         self.__field_events=LIST(**{'elementclass': scheduleevent})
3138         self.__field_events.readfrombuffer(buf)
3139         self._bufferendoffset=buf.getcurrentoffset()
3140 
3141 
3142     def __getfield_numactiveitems(self):
3143         return self.__field_numactiveitems.getvalue()
3144 
3145     def __setfield_numactiveitems(self, value):
3146         if isinstance(value,UINT):
3147             self.__field_numactiveitems=value
3148         else:
3149             self.__field_numactiveitems=UINT(value,**{'sizeinbytes': 2})
3150 
3151     def __delfield_numactiveitems(self): del self.__field_numactiveitems
3152 
3153     numactiveitems=property(__getfield_numactiveitems, __setfield_numactiveitems, __delfield_numactiveitems, None)
3154 
3155     def __getfield_events(self):
3156         try: self.__field_events
3157         except:
3158             self.__field_events=LIST(**{'elementclass': scheduleevent})
3159         return self.__field_events.getvalue()
3160 
3161     def __setfield_events(self, value):
3162         if isinstance(value,LIST):
3163             self.__field_events=value
3164         else:
3165             self.__field_events=LIST(value,**{'elementclass': scheduleevent})
3166 
3167     def __delfield_events(self): del self.__field_events
3168 
3169     events=property(__getfield_events, __setfield_events, __delfield_events, None)
3170 
3171     def iscontainer(self):
3172         return True
3173 
3174     def containerelements(self):
3175         yield ('numactiveitems', self.__field_numactiveitems, None)
3176         yield ('events', self.__field_events, None)
3177 
3178 
3179 
3180 
3181 class recipient_record(BaseProtogenClass):
3182     __fields=['unknown1', 'name', 'number', 'unknown2', 'status', 'time']
3183 
3184     def __init__(self, *args, **kwargs):
3185         dict={}
3186         # What was supplied to this function
3187         dict.update(kwargs)
3188         # Parent constructor
3189         super(recipient_record,self).__init__(**dict)
3190         if self.__class__ is recipient_record:
3191             self._update(args,dict)
3192 
3193 
3194     def getfields(self):
3195         return self.__fields
3196 
3197 
3198     def _update(self, args, kwargs):
3199         super(recipient_record,self)._update(args,kwargs)
3200         keys=kwargs.keys()
3201         for key in keys:
3202             if key in self.__fields:
3203                 setattr(self, key, kwargs[key])
3204                 del kwargs[key]
3205         # Were any unrecognized kwargs passed in?
3206         if __debug__:
3207             self._complainaboutunusedargs(recipient_record,kwargs)
3208         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
3209         # Make all P fields that haven't already been constructed
3210         try: self.__field_name
3211         except:
3212             self.__field_name=USTRING(**{'encoding': PHONE_ENCODING, 'default':'', 'raiseonunterminatedread': False})
3213 
3214 
3215     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3216         'Writes this packet to the supplied buffer'
3217         self._bufferstartoffset=buf.getcurrentoffset()
3218         self.__field_unknown1.writetobuffer(buf)
3219         self.__field_number.writetobuffer(buf)
3220         self.__field_unknown2.writetobuffer(buf)
3221         self.__field_status.writetobuffer(buf)
3222         self.__field_time.writetobuffer(buf)
3223         self._bufferendoffset=buf.getcurrentoffset()
3224         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3225 
3226 
3227     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3228         'Reads this packet from the supplied buffer'
3229         self._bufferstartoffset=buf.getcurrentoffset()
3230         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3231         self.__field_unknown1=UINT(**{'sizeinbytes': 20})
3232         self.__field_unknown1.readfrombuffer(buf)
3233         self.__field_number=USTRING(**{'sizeinbytes': 49})
3234         self.__field_number.readfrombuffer(buf)
3235         self.__field_unknown2=UINT(**{'sizeinbytes': 24})
3236         self.__field_unknown2.readfrombuffer(buf)
3237         self.__field_status=UINT(**{'sizeinbytes': 1})
3238         self.__field_status.readfrombuffer(buf)
3239         self.__field_time=LGCALDATE(**{'sizeinbytes': 4})
3240         self.__field_time.readfrombuffer(buf)
3241         self._bufferendoffset=buf.getcurrentoffset()
3242 
3243 
3244     def __getfield_unknown1(self):
3245         return self.__field_unknown1.getvalue()
3246 
3247     def __setfield_unknown1(self, value):
3248         if isinstance(value,UINT):
3249             self.__field_unknown1=value
3250         else:
3251             self.__field_unknown1=UINT(value,**{'sizeinbytes': 20})
3252 
3253     def __delfield_unknown1(self): del self.__field_unknown1
3254 
3255     unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None)
3256 
3257     def __getfield_name(self):
3258         return self.__field_name.getvalue()
3259 
3260     def __setfield_name(self, value):
3261         if isinstance(value,USTRING):
3262             self.__field_name=value
3263         else:
3264             self.__field_name=USTRING(value,**{'encoding': PHONE_ENCODING, 'default':'', 'raiseonunterminatedread': False})
3265 
3266     def __delfield_name(self): del self.__field_name
3267 
3268     name=property(__getfield_name, __setfield_name, __delfield_name, None)
3269 
3270     def __getfield_number(self):
3271         return self.__field_number.getvalue()
3272 
3273     def __setfield_number(self, value):
3274         if isinstance(value,USTRING):
3275             self.__field_number=value
3276         else:
3277             self.__field_number=USTRING(value,**{'sizeinbytes': 49})
3278 
3279     def __delfield_number(self): del self.__field_number
3280 
3281     number=property(__getfield_number, __setfield_number, __delfield_number, None)
3282 
3283     def __getfield_unknown2(self):
3284         return self.__field_unknown2.getvalue()
3285 
3286     def __setfield_unknown2(self, value):
3287         if isinstance(value,UINT):
3288             self.__field_unknown2=value
3289         else:
3290             self.__field_unknown2=UINT(value,**{'sizeinbytes': 24})
3291 
3292     def __delfield_unknown2(self): del self.__field_unknown2
3293 
3294     unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None)
3295 
3296     def __getfield_status(self):
3297         return self.__field_status.getvalue()
3298 
3299     def __setfield_status(self, value):
3300         if isinstance(value,UINT):
3301             self.__field_status=value
3302         else:
3303             self.__field_status=UINT(value,**{'sizeinbytes': 1})
3304 
3305     def __delfield_status(self): del self.__field_status
3306 
3307     status=property(__getfield_status, __setfield_status, __delfield_status, None)
3308 
3309     def __getfield_time(self):
3310         return self.__field_time.getvalue()
3311 
3312     def __setfield_time(self, value):
3313         if isinstance(value,LGCALDATE):
3314             self.__field_time=value
3315         else:
3316             self.__field_time=LGCALDATE(value,**{'sizeinbytes': 4})
3317 
3318     def __delfield_time(self): del self.__field_time
3319 
3320     time=property(__getfield_time, __setfield_time, __delfield_time, None)
3321 
3322     def iscontainer(self):
3323         return True
3324 
3325     def containerelements(self):
3326         yield ('unknown1', self.__field_unknown1, None)
3327         yield ('name', self.__field_name, None)
3328         yield ('number', self.__field_number, None)
3329         yield ('unknown2', self.__field_unknown2, None)
3330         yield ('status', self.__field_status, None)
3331         yield ('time', self.__field_time, None)
3332 
3333 
3334 
3335 
3336 class sms_saved(BaseProtogenClass):
3337     __fields=['outboxmsg', 'GPStime', 'outbox', 'inbox']
3338 
3339     def __init__(self, *args, **kwargs):
3340         dict={}
3341         # What was supplied to this function
3342         dict.update(kwargs)
3343         # Parent constructor
3344         super(sms_saved,self).__init__(**dict)
3345         if self.__class__ is sms_saved:
3346             self._update(args,dict)
3347 
3348 
3349     def getfields(self):
3350         return self.__fields
3351 
3352 
3353     def _update(self, args, kwargs):
3354         super(sms_saved,self)._update(args,kwargs)
3355         keys=kwargs.keys()
3356         for key in keys:
3357             if key in self.__fields:
3358                 setattr(self, key, kwargs[key])
3359                 del kwargs[key]
3360         # Were any unrecognized kwargs passed in?
3361         if __debug__:
3362             self._complainaboutunusedargs(sms_saved,kwargs)
3363         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
3364         # Make all P fields that haven't already been constructed
3365 
3366 
3367     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3368         'Writes this packet to the supplied buffer'
3369         self._bufferstartoffset=buf.getcurrentoffset()
3370         self.__field_outboxmsg.writetobuffer(buf)
3371         self.__field_GPStime.writetobuffer(buf)
3372         if self.outboxmsg:
3373             self.__field_outbox.writetobuffer(buf)
3374         if not self.outboxmsg:
3375             self.__field_inbox.writetobuffer(buf)
3376         self._bufferendoffset=buf.getcurrentoffset()
3377         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3378 
3379 
3380     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3381         'Reads this packet from the supplied buffer'
3382         self._bufferstartoffset=buf.getcurrentoffset()
3383         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3384         self.__field_outboxmsg=UINT(**{'sizeinbytes': 4})
3385         self.__field_outboxmsg.readfrombuffer(buf)
3386         self.__field_GPStime=GPSDATE(**{'sizeinbytes': 4})
3387         self.__field_GPStime.readfrombuffer(buf)
3388         if self.outboxmsg:
3389             self.__field_outbox=sms_out()
3390             self.__field_outbox.readfrombuffer(buf)
3391         if not self.outboxmsg:
3392             self.__field_inbox=sms_in()
3393             self.__field_inbox.readfrombuffer(buf)
3394         self._bufferendoffset=buf.getcurrentoffset()
3395 
3396 
3397     def __getfield_outboxmsg(self):
3398         return self.__field_outboxmsg.getvalue()
3399 
3400     def __setfield_outboxmsg(self, value):
3401         if isinstance(value,UINT):
3402             self.__field_outboxmsg=value
3403         else:
3404             self.__field_outboxmsg=UINT(value,**{'sizeinbytes': 4})
3405 
3406     def __delfield_outboxmsg(self): del self.__field_outboxmsg
3407 
3408     outboxmsg=property(__getfield_outboxmsg, __setfield_outboxmsg, __delfield_outboxmsg, None)
3409 
3410     def __getfield_GPStime(self):
3411         return self.__field_GPStime.getvalue()
3412 
3413     def __setfield_GPStime(self, value):
3414         if isinstance(value,GPSDATE):
3415             self.__field_GPStime=value
3416         else:
3417             self.__field_GPStime=GPSDATE(value,**{'sizeinbytes': 4})
3418 
3419     def __delfield_GPStime(self): del self.__field_GPStime
3420 
3421     GPStime=property(__getfield_GPStime, __setfield_GPStime, __delfield_GPStime, None)
3422 
3423     def __getfield_outbox(self):
3424         return self.__field_outbox.getvalue()
3425 
3426     def __setfield_outbox(self, value):
3427         if isinstance(value,sms_out):
3428             self.__field_outbox=value
3429         else:
3430             self.__field_outbox=sms_out(value,)
3431 
3432     def __delfield_outbox(self): del self.__field_outbox
3433 
3434     outbox=property(__getfield_outbox, __setfield_outbox, __delfield_outbox, None)
3435 
3436     def __getfield_inbox(self):
3437         return self.__field_inbox.getvalue()
3438 
3439     def __setfield_inbox(self, value):
3440         if isinstance(value,sms_in):
3441             self.__field_inbox=value
3442         else:
3443             self.__field_inbox=sms_in(value,)
3444 
3445     def __delfield_inbox(self): del self.__field_inbox
3446 
3447     inbox=property(__getfield_inbox, __setfield_inbox, __delfield_inbox, None)
3448 
3449     def iscontainer(self):
3450         return True
3451 
3452     def containerelements(self):
3453         yield ('outboxmsg', self.__field_outboxmsg, None)
3454         yield ('GPStime', self.__field_GPStime, None)
3455         if self.outboxmsg:
3456             yield ('outbox', self.__field_outbox, None)
3457         if not self.outboxmsg:
3458             yield ('inbox', self.__field_inbox, None)
3459 
3460 
3461 
3462 
3463 class sms_out(BaseProtogenClass):
3464     __fields=['index', 'locked', 'unknown1', 'timesent', 'msg', 'unknown2', 'callback', 'recipients']
3465 
3466     def __init__(self, *args, **kwargs):
3467         dict={}
3468         # What was supplied to this function
3469         dict.update(kwargs)
3470         # Parent constructor
3471         super(sms_out,self).__init__(**dict)
3472         if self.__class__ is sms_out:
3473             self._update(args,dict)
3474 
3475 
3476     def getfields(self):
3477         return self.__fields
3478 
3479 
3480     def _update(self, args, kwargs):
3481         super(sms_out,self)._update(args,kwargs)
3482         keys=kwargs.keys()
3483         for key in keys:
3484             if key in self.__fields:
3485                 setattr(self, key, kwargs[key])
3486                 del kwargs[key]
3487         # Were any unrecognized kwargs passed in?
3488         if __debug__:
3489             self._complainaboutunusedargs(sms_out,kwargs)
3490         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
3491         # Make all P fields that haven't already been constructed
3492 
3493 
3494     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3495         'Writes this packet to the supplied buffer'
3496         self._bufferstartoffset=buf.getcurrentoffset()
3497         self.__field_index.writetobuffer(buf)
3498         self.__field_locked.writetobuffer(buf)
3499         self.__field_unknown1.writetobuffer(buf)
3500         self.__field_timesent.writetobuffer(buf)
3501         self.__field_msg.writetobuffer(buf)
3502         self.__field_unknown2.writetobuffer(buf)
3503         self.__field_callback.writetobuffer(buf)
3504         try: self.__field_recipients
3505         except:
3506             self.__field_recipients=LIST(**{'elementclass': recipient_record, 'length': 10})
3507         self.__field_recipients.writetobuffer(buf)
3508         self._bufferendoffset=buf.getcurrentoffset()
3509         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3510 
3511 
3512     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3513         'Reads this packet from the supplied buffer'
3514         self._bufferstartoffset=buf.getcurrentoffset()
3515         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3516         self.__field_index=UINT(**{'sizeinbytes': 4})
3517         self.__field_index.readfrombuffer(buf)
3518         self.__field_locked=UINT(**{'sizeinbytes': 1})
3519         self.__field_locked.readfrombuffer(buf)
3520         self.__field_unknown1=UINT(**{'sizeinbytes': 3})
3521         self.__field_unknown1.readfrombuffer(buf)
3522         self.__field_timesent=LGCALDATE(**{'sizeinbytes': 4})
3523         self.__field_timesent.readfrombuffer(buf)
3524         self.__field_msg=USTRING(**{'sizeinbytes': 500, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})
3525         self.__field_msg.readfrombuffer(buf)
3526         self.__field_unknown2=DATA(**{'sizeinbytes': 1250})
3527         self.__field_unknown2.readfrombuffer(buf)
3528         self.__field_callback=USTRING(**{'sizeinbytes': 16})
3529         self.__field_callback.readfrombuffer(buf)
3530         self.__field_recipients=LIST(**{'elementclass': recipient_record, 'length': 10})
3531         self.__field_recipients.readfrombuffer(buf)
3532         self._bufferendoffset=buf.getcurrentoffset()
3533 
3534 
3535     def __getfield_index(self):
3536         return self.__field_index.getvalue()
3537 
3538     def __setfield_index(self, value):
3539         if isinstance(value,UINT):
3540             self.__field_index=value
3541         else:
3542             self.__field_index=UINT(value,**{'sizeinbytes': 4})
3543 
3544     def __delfield_index(self): del self.__field_index
3545 
3546     index=property(__getfield_index, __setfield_index, __delfield_index, None)
3547 
3548     def __getfield_locked(self):
3549         return self.__field_locked.getvalue()
3550 
3551     def __setfield_locked(self, value):
3552         if isinstance(value,UINT):
3553             self.__field_locked=value
3554         else:
3555             self.__field_locked=UINT(value,**{'sizeinbytes': 1})
3556 
3557     def __delfield_locked(self): del self.__field_locked
3558 
3559     locked=property(__getfield_locked, __setfield_locked, __delfield_locked, None)
3560 
3561     def __getfield_unknown1(self):
3562         return self.__field_unknown1.getvalue()
3563 
3564     def __setfield_unknown1(self, value):
3565         if isinstance(value,UINT):
3566             self.__field_unknown1=value
3567         else:
3568             self.__field_unknown1=UINT(value,**{'sizeinbytes': 3})
3569 
3570     def __delfield_unknown1(self): del self.__field_unknown1
3571 
3572     unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None)
3573 
3574     def __getfield_timesent(self):
3575         return self.__field_timesent.getvalue()
3576 
3577     def __setfield_timesent(self, value):
3578         if isinstance(value,LGCALDATE):
3579             self.__field_timesent=value
3580         else:
3581             self.__field_timesent=LGCALDATE(value,**{'sizeinbytes': 4})
3582 
3583     def __delfield_timesent(self): del self.__field_timesent
3584 
3585     timesent=property(__getfield_timesent, __setfield_timesent, __delfield_timesent, None)
3586 
3587     def __getfield_msg(self):
3588         return self.__field_msg.getvalue()
3589 
3590     def __setfield_msg(self, value):
3591         if isinstance(value,USTRING):
3592             self.__field_msg=value
3593         else:
3594             self.__field_msg=USTRING(value,**{'sizeinbytes': 500, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})
3595 
3596     def __delfield_msg(self): del self.__field_msg
3597 
3598     msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None)
3599 
3600     def __getfield_unknown2(self):
3601         return self.__field_unknown2.getvalue()
3602 
3603     def __setfield_unknown2(self, value):
3604         if isinstance(value,DATA):
3605             self.__field_unknown2=value
3606         else:
3607             self.__field_unknown2=DATA(value,**{'sizeinbytes': 1250})
3608 
3609     def __delfield_unknown2(self): del self.__field_unknown2
3610 
3611     unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None)
3612 
3613     def __getfield_callback(self):
3614         return self.__field_callback.getvalue()
3615 
3616     def __setfield_callback(self, value):
3617         if isinstance(value,USTRING):
3618             self.__field_callback=value
3619         else:
3620             self.__field_callback=USTRING(value,**{'sizeinbytes': 16})
3621 
3622     def __delfield_callback(self): del self.__field_callback
3623 
3624     callback=property(__getfield_callback, __setfield_callback, __delfield_callback, None)
3625 
3626     def __getfield_recipients(self):
3627         try: self.__field_recipients
3628         except:
3629             self.__field_recipients=LIST(**{'elementclass': recipient_record, 'length': 10})
3630         return self.__field_recipients.getvalue()
3631 
3632     def __setfield_recipients(self, value):
3633         if isinstance(value,LIST):
3634             self.__field_recipients=value
3635         else:
3636             self.__field_recipients=LIST(value,**{'elementclass': recipient_record, 'length': 10})
3637 
3638     def __delfield_recipients(self): del self.__field_recipients
3639 
3640     recipients=property(__getfield_recipients, __setfield_recipients, __delfield_recipients, None)
3641 
3642     def iscontainer(self):
3643         return True
3644 
3645     def containerelements(self):
3646         yield ('index', self.__field_index, None)
3647         yield ('locked', self.__field_locked, None)
3648         yield ('unknown1', self.__field_unknown1, None)
3649         yield ('timesent', self.__field_timesent, None)
3650         yield ('msg', self.__field_msg, None)
3651         yield ('unknown2', self.__field_unknown2, None)
3652         yield ('callback', self.__field_callback, None)
3653         yield ('recipients', self.__field_recipients, None)
3654 
3655 
3656 
3657 
3658 class SMSINBOXMSGFRAGMENT(BaseProtogenClass):
3659     __fields=['msg']
3660 
3661     def __init__(self, *args, **kwargs):
3662         dict={}
3663         # What was supplied to this function
3664         dict.update(kwargs)
3665         # Parent constructor
3666         super(SMSINBOXMSGFRAGMENT,self).__init__(**dict)
3667         if self.__class__ is SMSINBOXMSGFRAGMENT:
3668             self._update(args,dict)
3669 
3670 
3671     def getfields(self):
3672         return self.__fields
3673 
3674 
3675     def _update(self, args, kwargs):
3676         super(SMSINBOXMSGFRAGMENT,self)._update(args,kwargs)
3677         keys=kwargs.keys()
3678         for key in keys:
3679             if key in self.__fields:
3680                 setattr(self, key, kwargs[key])
3681                 del kwargs[key]
3682         # Were any unrecognized kwargs passed in?
3683         if __debug__:
3684             self._complainaboutunusedargs(SMSINBOXMSGFRAGMENT,kwargs)
3685         if len(args):
3686             dict2={'elementclass': _gen_p_lglg6190_321, 'length': 181}
3687             dict2.update(kwargs)
3688             kwargs=dict2
3689             self.__field_msg=LIST(*args,**dict2)
3690         # Make all P fields that haven't already been constructed
3691 
3692 
3693     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3694         'Writes this packet to the supplied buffer'
3695         self._bufferstartoffset=buf.getcurrentoffset()
3696         try: self.__field_msg
3697         except:
3698             self.__field_msg=LIST(**{'elementclass': _gen_p_lglg6190_321, 'length': 181})
3699         self.__field_msg.writetobuffer(buf)
3700         self._bufferendoffset=buf.getcurrentoffset()
3701         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3702 
3703 
3704     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3705         'Reads this packet from the supplied buffer'
3706         self._bufferstartoffset=buf.getcurrentoffset()
3707         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3708         self.__field_msg=LIST(**{'elementclass': _gen_p_lglg6190_321, 'length': 181})
3709         self.__field_msg.readfrombuffer(buf)
3710         self._bufferendoffset=buf.getcurrentoffset()
3711 
3712 
3713     def __getfield_msg(self):
3714         try: self.__field_msg
3715         except:
3716             self.__field_msg=LIST(**{'elementclass': _gen_p_lglg6190_321, 'length': 181})
3717         return self.__field_msg.getvalue()
3718 
3719     def __setfield_msg(self, value):
3720         if isinstance(value,LIST):
3721             self.__field_msg=value
3722         else:
3723             self.__field_msg=LIST(value,**{'elementclass': _gen_p_lglg6190_321, 'length': 181})
3724 
3725     def __delfield_msg(self): del self.__field_msg
3726 
3727     msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None)
3728 
3729     def iscontainer(self):
3730         return True
3731 
3732     def containerelements(self):
3733         yield ('msg', self.__field_msg, None)
3734 
3735 
3736 
3737 
3738 class _gen_p_lglg6190_321(BaseProtogenClass):
3739     'Anonymous inner class'
3740     __fields=['byte']
3741 
3742     def __init__(self, *args, **kwargs):
3743         dict={}
3744         # What was supplied to this function
3745         dict.update(kwargs)
3746         # Parent constructor
3747         super(_gen_p_lglg6190_321,self).__init__(**dict)
3748         if self.__class__ is _gen_p_lglg6190_321:
3749             self._update(args,dict)
3750 
3751 
3752     def getfields(self):
3753         return self.__fields
3754 
3755 
3756     def _update(self, args, kwargs):
3757         super(_gen_p_lglg6190_321,self)._update(args,kwargs)
3758         keys=kwargs.keys()
3759         for key in keys:
3760             if key in self.__fields:
3761                 setattr(self, key, kwargs[key])
3762                 del kwargs[key]
3763         # Were any unrecognized kwargs passed in?
3764         if __debug__:
3765             self._complainaboutunusedargs(_gen_p_lglg6190_321,kwargs)
3766         if len(args):
3767             dict2={'sizeinbytes': 1}
3768             dict2.update(kwargs)
3769             kwargs=dict2
3770             self.__field_byte=UINT(*args,**dict2)
3771         # Make all P fields that haven't already been constructed
3772 
3773 
3774     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3775         'Writes this packet to the supplied buffer'
3776         self._bufferstartoffset=buf.getcurrentoffset()
3777         self.__field_byte.writetobuffer(buf)
3778         self._bufferendoffset=buf.getcurrentoffset()
3779         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3780 
3781 
3782     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3783         'Reads this packet from the supplied buffer'
3784         self._bufferstartoffset=buf.getcurrentoffset()
3785         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3786         self.__field_byte=UINT(**{'sizeinbytes': 1})
3787         self.__field_byte.readfrombuffer(buf)
3788         self._bufferendoffset=buf.getcurrentoffset()
3789 
3790 
3791     def __getfield_byte(self):
3792         return self.__field_byte.getvalue()
3793 
3794     def __setfield_byte(self, value):
3795         if isinstance(value,UINT):
3796             self.__field_byte=value
3797         else:
3798             self.__field_byte=UINT(value,**{'sizeinbytes': 1})
3799 
3800     def __delfield_byte(self): del self.__field_byte
3801 
3802     byte=property(__getfield_byte, __setfield_byte, __delfield_byte, "individual byte of message")
3803 
3804     def iscontainer(self):
3805         return True
3806 
3807     def containerelements(self):
3808         yield ('byte', self.__field_byte, "individual byte of message")
3809 
3810 
3811 
3812 
3813 class sms_in(BaseProtogenClass):
3814     __fields=['unknown1', 'msg_index2', 'unknown2', 'timesent', 'unknown', 'callback_length', 'callback', 'sender_length', 'sender', 'unknown4', 'lg_time', 'GPStime', 'unknown41', 'read', 'unknown5', 'subject', 'unknown6', 'msglength', 'unknown7', 'msg', 'unknown8']
3815 
3816     def __init__(self, *args, **kwargs):
3817         dict={}
3818         # What was supplied to this function
3819         dict.update(kwargs)
3820         # Parent constructor
3821         super(sms_in,self).__init__(**dict)
3822         if self.__class__ is sms_in:
3823             self._update(args,dict)
3824 
3825 
3826     def getfields(self):
3827         return self.__fields
3828 
3829 
3830     def _update(self, args, kwargs):
3831         super(sms_in,self)._update(args,kwargs)
3832         keys=kwargs.keys()
3833         for key in keys:
3834             if key in self.__fields:
3835                 setattr(self, key, kwargs[key])
3836                 del kwargs[key]
3837         # Were any unrecognized kwargs passed in?
3838         if __debug__:
3839             self._complainaboutunusedargs(sms_in,kwargs)
3840         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
3841         # Make all P fields that haven't already been constructed
3842 
3843 
3844     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
3845         'Writes this packet to the supplied buffer'
3846         self._bufferstartoffset=buf.getcurrentoffset()
3847         self.__field_unknown1.writetobuffer(buf)
3848         self.__field_msg_index2.writetobuffer(buf)
3849         self.__field_unknown2.writetobuffer(buf)
3850         self.__field_timesent.writetobuffer(buf)
3851         self.__field_unknown.writetobuffer(buf)
3852         self.__field_callback_length.writetobuffer(buf)
3853         self.__field_callback.writetobuffer(buf)
3854         self.__field_sender_length.writetobuffer(buf)
3855         try: self.__field_sender
3856         except:
3857             self.__field_sender=LIST(**{'elementclass': _gen_p_lglg6190_333, 'length': 38})
3858         self.__field_sender.writetobuffer(buf)
3859         self.__field_unknown4.writetobuffer(buf)
3860         self.__field_lg_time.writetobuffer(buf)
3861         self.__field_GPStime.writetobuffer(buf)
3862         self.__field_unknown41.writetobuffer(buf)
3863         self.__field_read.writetobuffer(buf)
3864         self.__field_unknown5.writetobuffer(buf)
3865         self.__field_subject.writetobuffer(buf)
3866         self.__field_unknown6.writetobuffer(buf)
3867         self.__field_msglength.writetobuffer(buf)
3868         self.__field_unknown7.writetobuffer(buf)
3869         self.__field_msg.writetobuffer(buf)
3870         self.__field_unknown8.writetobuffer(buf)
3871         self._bufferendoffset=buf.getcurrentoffset()
3872         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
3873 
3874 
3875     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
3876         'Reads this packet from the supplied buffer'
3877         self._bufferstartoffset=buf.getcurrentoffset()
3878         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
3879         self.__field_unknown1=UINT(**{'sizeinbytes': 4})
3880         self.__field_unknown1.readfrombuffer(buf)
3881         self.__field_msg_index2=UINT(**{'sizeinbytes': 4})
3882         self.__field_msg_index2.readfrombuffer(buf)
3883         self.__field_unknown2=UINT(**{'sizeinbytes': 6})
3884         self.__field_unknown2.readfrombuffer(buf)
3885         self.__field_timesent=SMSDATE(**{'sizeinbytes': 6})
3886         self.__field_timesent.readfrombuffer(buf)
3887         self.__field_unknown=UINT(**{'sizeinbytes': 3})
3888         self.__field_unknown.readfrombuffer(buf)
3889         self.__field_callback_length=UINT(**{'sizeinbytes': 1})
3890         self.__field_callback_length.readfrombuffer(buf)
3891         self.__field_callback=USTRING(**{'sizeinbytes': 38})
3892         self.__field_callback.readfrombuffer(buf)
3893         self.__field_sender_length=UINT(**{'sizeinbytes': 1})
3894         self.__field_sender_length.readfrombuffer(buf)
3895         self.__field_sender=LIST(**{'elementclass': _gen_p_lglg6190_333, 'length': 38})
3896         self.__field_sender.readfrombuffer(buf)
3897         self.__field_unknown4=DATA(**{'sizeinbytes': 15})
3898         self.__field_unknown4.readfrombuffer(buf)
3899         self.__field_lg_time=LGCALDATE(**{'sizeinbytes': 4})
3900         self.__field_lg_time.readfrombuffer(buf)
3901         self.__field_GPStime=GPSDATE(**{'sizeinbytes': 4})
3902         self.__field_GPStime.readfrombuffer(buf)
3903         self.__field_unknown41=UINT(**{'sizeinbytes': 2})
3904         self.__field_unknown41.readfrombuffer(buf)
3905         self.__field_read=UINT(**{'sizeinbytes': 2})
3906         self.__field_read.readfrombuffer(buf)
3907         self.__field_unknown5=UINT(**{'sizeinbytes': 9})
3908         self.__field_unknown5.readfrombuffer(buf)
3909         self.__field_subject=USTRING(**{'sizeinbytes': 21, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})
3910         self.__field_subject.readfrombuffer(buf)
3911         self.__field_unknown6=UINT(**{'sizeinbytes': 8})
3912         self.__field_unknown6.readfrombuffer(buf)
3913         self.__field_msglength=UINT(**{'sizeinbytes': 2})
3914         self.__field_msglength.readfrombuffer(buf)
3915         self.__field_unknown7=UINT(**{'sizeinbytes': 18})
3916         self.__field_unknown7.readfrombuffer(buf)
3917         self.__field_msg=USTRING(**{'sizeinbytes': 200, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})
3918         self.__field_msg.readfrombuffer(buf)
3919         self.__field_unknown8=DATA()
3920         self.__field_unknown8.readfrombuffer(buf)
3921         self._bufferendoffset=buf.getcurrentoffset()
3922 
3923 
3924     def __getfield_unknown1(self):
3925         return self.__field_unknown1.getvalue()
3926 
3927     def __setfield_unknown1(self, value):
3928         if isinstance(value,UINT):
3929             self.__field_unknown1=value
3930         else:
3931             self.__field_unknown1=UINT(value,**{'sizeinbytes': 4})
3932 
3933     def __delfield_unknown1(self): del self.__field_unknown1
3934 
3935     unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None)
3936 
3937     def __getfield_msg_index2(self):
3938         return self.__field_msg_index2.getvalue()
3939 
3940     def __setfield_msg_index2(self, value):
3941         if isinstance(value,UINT):
3942             self.__field_msg_index2=value
3943         else:
3944             self.__field_msg_index2=UINT(value,**{'sizeinbytes': 4})
3945 
3946     def __delfield_msg_index2(self): del self.__field_msg_index2
3947 
3948     msg_index2=property(__getfield_msg_index2, __setfield_msg_index2, __delfield_msg_index2, None)
3949 
3950     def __getfield_unknown2(self):
3951         return self.__field_unknown2.getvalue()
3952 
3953     def __setfield_unknown2(self, value):
3954         if isinstance(value,UINT):
3955             self.__field_unknown2=value
3956         else:
3957             self.__field_unknown2=UINT(value,**{'sizeinbytes': 6})
3958 
3959     def __delfield_unknown2(self): del self.__field_unknown2
3960 
3961     unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None)
3962 
3963     def __getfield_timesent(self):
3964         return self.__field_timesent.getvalue()
3965 
3966     def __setfield_timesent(self, value):
3967         if isinstance(value,SMSDATE):
3968             self.__field_timesent=value
3969         else:
3970             self.__field_timesent=SMSDATE(value,**{'sizeinbytes': 6})
3971 
3972     def __delfield_timesent(self): del self.__field_timesent
3973 
3974     timesent=property(__getfield_timesent, __setfield_timesent, __delfield_timesent, None)
3975 
3976     def __getfield_unknown(self):
3977         return self.__field_unknown.getvalue()
3978 
3979     def __setfield_unknown(self, value):
3980         if isinstance(value,UINT):
3981             self.__field_unknown=value
3982         else:
3983             self.__field_unknown=UINT(value,**{'sizeinbytes': 3})
3984 
3985     def __delfield_unknown(self): del self.__field_unknown
3986 
3987     unknown=property(__getfield_unknown, __setfield_unknown, __delfield_unknown, None)
3988 
3989     def __getfield_callback_length(self):
3990         return self.__field_callback_length.getvalue()
3991 
3992     def __setfield_callback_length(self, value):
3993         if isinstance(value,UINT):
3994             self.__field_callback_length=value
3995         else:
3996             self.__field_callback_length=UINT(value,**{'sizeinbytes': 1})
3997 
3998     def __delfield_callback_length(self): del self.__field_callback_length
3999 
4000     callback_length=property(__getfield_callback_length, __setfield_callback_length, __delfield_callback_length, None)
4001 
4002     def __getfield_callback(self):
4003         return self.__field_callback.getvalue()
4004 
4005     def __setfield_callback(self, value):
4006         if isinstance(value,USTRING):
4007             self.__field_callback=value
4008         else:
4009             self.__field_callback=USTRING(value,**{'sizeinbytes': 38})
4010 
4011     def __delfield_callback(self): del self.__field_callback
4012 
4013     callback=property(__getfield_callback, __setfield_callback, __delfield_callback, None)
4014 
4015     def __getfield_sender_length(self):
4016         return self.__field_sender_length.getvalue()
4017 
4018     def __setfield_sender_length(self, value):
4019         if isinstance(value,UINT):
4020             self.__field_sender_length=value
4021         else:
4022             self.__field_sender_length=UINT(value,**{'sizeinbytes': 1})
4023 
4024     def __delfield_sender_length(self): del self.__field_sender_length
4025 
4026     sender_length=property(__getfield_sender_length, __setfield_sender_length, __delfield_sender_length, None)
4027 
4028     def __getfield_sender(self):
4029         try: self.__field_sender
4030         except:
4031             self.__field_sender=LIST(**{'elementclass': _gen_p_lglg6190_333, 'length': 38})
4032         return self.__field_sender.getvalue()
4033 
4034     def __setfield_sender(self, value):
4035         if isinstance(value,LIST):
4036             self.__field_sender=value
4037         else:
4038             self.__field_sender=LIST(value,**{'elementclass': _gen_p_lglg6190_333, 'length': 38})
4039 
4040     def __delfield_sender(self): del self.__field_sender
4041 
4042     sender=property(__getfield_sender, __setfield_sender, __delfield_sender, None)
4043 
4044     def __getfield_unknown4(self):
4045         return self.__field_unknown4.getvalue()
4046 
4047     def __setfield_unknown4(self, value):
4048         if isinstance(value,DATA):
4049             self.__field_unknown4=value
4050         else:
4051             self.__field_unknown4=DATA(value,**{'sizeinbytes': 15})
4052 
4053     def __delfield_unknown4(self): del self.__field_unknown4
4054 
4055     unknown4=property(__getfield_unknown4, __setfield_unknown4, __delfield_unknown4, None)
4056 
4057     def __getfield_lg_time(self):
4058         return self.__field_lg_time.getvalue()
4059 
4060     def __setfield_lg_time(self, value):
4061         if isinstance(value,LGCALDATE):
4062             self.__field_lg_time=value
4063         else:
4064             self.__field_lg_time=LGCALDATE(value,**{'sizeinbytes': 4})
4065 
4066     def __delfield_lg_time(self): del self.__field_lg_time
4067 
4068     lg_time=property(__getfield_lg_time, __setfield_lg_time, __delfield_lg_time, None)
4069 
4070     def __getfield_GPStime(self):
4071         return self.__field_GPStime.getvalue()
4072 
4073     def __setfield_GPStime(self, value):
4074         if isinstance(value,GPSDATE):
4075             self.__field_GPStime=value
4076         else:
4077             self.__field_GPStime=GPSDATE(value,**{'sizeinbytes': 4})
4078 
4079     def __delfield_GPStime(self): del self.__field_GPStime
4080 
4081     GPStime=property(__getfield_GPStime, __setfield_GPStime, __delfield_GPStime, None)
4082 
4083     def __getfield_unknown41(self):
4084         return self.__field_unknown41.getvalue()
4085 
4086     def __setfield_unknown41(self, value):
4087         if isinstance(value,UINT):
4088             self.__field_unknown41=value
4089         else:
4090             self.__field_unknown41=UINT(value,**{'sizeinbytes': 2})
4091 
4092     def __delfield_unknown41(self): del self.__field_unknown41
4093 
4094     unknown41=property(__getfield_unknown41, __setfield_unknown41, __delfield_unknown41, None)
4095 
4096     def __getfield_read(self):
4097         return self.__field_read.getvalue()
4098 
4099     def __setfield_read(self, value):
4100         if isinstance(value,UINT):
4101             self.__field_read=value
4102         else:
4103             self.__field_read=UINT(value,**{'sizeinbytes': 2})
4104 
4105     def __delfield_read(self): del self.__field_read
4106 
4107     read=property(__getfield_read, __setfield_read, __delfield_read, None)
4108 
4109     def __getfield_unknown5(self):
4110         return self.__field_unknown5.getvalue()
4111 
4112     def __setfield_unknown5(self, value):
4113         if isinstance(value,UINT):
4114             self.__field_unknown5=value
4115         else:
4116             self.__field_unknown5=UINT(value,**{'sizeinbytes': 9})
4117 
4118     def __delfield_unknown5(self): del self.__field_unknown5
4119 
4120     unknown5=property(__getfield_unknown5, __setfield_unknown5, __delfield_unknown5, None)
4121 
4122     def __getfield_subject(self):
4123         return self.__field_subject.getvalue()
4124 
4125     def __setfield_subject(self, value):
4126         if isinstance(value,USTRING):
4127             self.__field_subject=value
4128         else:
4129             self.__field_subject=USTRING(value,**{'sizeinbytes': 21, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})
4130 
4131     def __delfield_subject(self): del self.__field_subject
4132 
4133     subject=property(__getfield_subject, __setfield_subject, __delfield_subject, None)
4134 
4135     def __getfield_unknown6(self):
4136         return self.__field_unknown6.getvalue()
4137 
4138     def __setfield_unknown6(self, value):
4139         if isinstance(value,UINT):
4140             self.__field_unknown6=value
4141         else:
4142             self.__field_unknown6=UINT(value,**{'sizeinbytes': 8})
4143 
4144     def __delfield_unknown6(self): del self.__field_unknown6
4145 
4146     unknown6=property(__getfield_unknown6, __setfield_unknown6, __delfield_unknown6, None)
4147 
4148     def __getfield_msglength(self):
4149         return self.__field_msglength.getvalue()
4150 
4151     def __setfield_msglength(self, value):
4152         if isinstance(value,UINT):
4153             self.__field_msglength=value
4154         else:
4155             self.__field_msglength=UINT(value,**{'sizeinbytes': 2})
4156 
4157     def __delfield_msglength(self): del self.__field_msglength
4158 
4159     msglength=property(__getfield_msglength, __setfield_msglength, __delfield_msglength, None)
4160 
4161     def __getfield_unknown7(self):
4162         return self.__field_unknown7.getvalue()
4163 
4164     def __setfield_unknown7(self, value):
4165         if isinstance(value,UINT):
4166             self.__field_unknown7=value
4167         else:
4168             self.__field_unknown7=UINT(value,**{'sizeinbytes': 18})
4169 
4170     def __delfield_unknown7(self): del self.__field_unknown7
4171 
4172     unknown7=property(__getfield_unknown7, __setfield_unknown7, __delfield_unknown7, None)
4173 
4174     def __getfield_msg(self):
4175         return self.__field_msg.getvalue()
4176 
4177     def __setfield_msg(self, value):
4178         if isinstance(value,USTRING):
4179             self.__field_msg=value
4180         else:
4181             self.__field_msg=USTRING(value,**{'sizeinbytes': 200, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})
4182 
4183     def __delfield_msg(self): del self.__field_msg
4184 
4185     msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None)
4186 
4187     def __getfield_unknown8(self):
4188         return self.__field_unknown8.getvalue()
4189 
4190     def __setfield_unknown8(self, value):
4191         if isinstance(value,DATA):
4192             self.__field_unknown8=value
4193         else:
4194             self.__field_unknown8=DATA(value,)
4195 
4196     def __delfield_unknown8(self): del self.__field_unknown8
4197 
4198     unknown8=property(__getfield_unknown8, __setfield_unknown8, __delfield_unknown8, None)
4199 
4200     def iscontainer(self):
4201         return True
4202 
4203     def containerelements(self):
4204         yield ('unknown1', self.__field_unknown1, None)
4205         yield ('msg_index2', self.__field_msg_index2, None)
4206         yield ('unknown2', self.__field_unknown2, None)
4207         yield ('timesent', self.__field_timesent, None)
4208         yield ('unknown', self.__field_unknown, None)
4209         yield ('callback_length', self.__field_callback_length, None)
4210         yield ('callback', self.__field_callback, None)
4211         yield ('sender_length', self.__field_sender_length, None)
4212         yield ('sender', self.__field_sender, None)
4213         yield ('unknown4', self.__field_unknown4, None)
4214         yield ('lg_time', self.__field_lg_time, None)
4215         yield ('GPStime', self.__field_GPStime, None)
4216         yield ('unknown41', self.__field_unknown41, None)
4217         yield ('read', self.__field_read, None)
4218         yield ('unknown5', self.__field_unknown5, None)
4219         yield ('subject', self.__field_subject, None)
4220         yield ('unknown6', self.__field_unknown6, None)
4221         yield ('msglength', self.__field_msglength, None)
4222         yield ('unknown7', self.__field_unknown7, None)
4223         yield ('msg', self.__field_msg, None)
4224         yield ('unknown8', self.__field_unknown8, None)
4225 
4226 
4227 
4228 
4229 class _gen_p_lglg6190_333(BaseProtogenClass):
4230     'Anonymous inner class'
4231     __fields=['byte']
4232 
4233     def __init__(self, *args, **kwargs):
4234         dict={}
4235         # What was supplied to this function
4236         dict.update(kwargs)
4237         # Parent constructor
4238         super(_gen_p_lglg6190_333,self).__init__(**dict)
4239         if self.__class__ is _gen_p_lglg6190_333:
4240             self._update(args,dict)
4241 
4242 
4243     def getfields(self):
4244         return self.__fields
4245 
4246 
4247     def _update(self, args, kwargs):
4248         super(_gen_p_lglg6190_333,self)._update(args,kwargs)
4249         keys=kwargs.keys()
4250         for key in keys:
4251             if key in self.__fields:
4252                 setattr(self, key, kwargs[key])
4253                 del kwargs[key]
4254         # Were any unrecognized kwargs passed in?
4255         if __debug__:
4256             self._complainaboutunusedargs(_gen_p_lglg6190_333,kwargs)
4257         if len(args):
4258             dict2={'sizeinbytes': 1}
4259             dict2.update(kwargs)
4260             kwargs=dict2
4261             self.__field_byte=UINT(*args,**dict2)
4262         # Make all P fields that haven't already been constructed
4263 
4264 
4265     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
4266         'Writes this packet to the supplied buffer'
4267         self._bufferstartoffset=buf.getcurrentoffset()
4268         self.__field_byte.writetobuffer(buf)
4269         self._bufferendoffset=buf.getcurrentoffset()
4270         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
4271 
4272 
4273     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
4274         'Reads this packet from the supplied buffer'
4275         self._bufferstartoffset=buf.getcurrentoffset()
4276         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
4277         self.__field_byte=UINT(**{'sizeinbytes': 1})
4278         self.__field_byte.readfrombuffer(buf)
4279         self._bufferendoffset=buf.getcurrentoffset()
4280 
4281 
4282     def __getfield_byte(self):
4283         return self.__field_byte.getvalue()
4284 
4285     def __setfield_byte(self, value):
4286         if isinstance(value,UINT):
4287             self.__field_byte=value
4288         else:
4289             self.__field_byte=UINT(value,**{'sizeinbytes': 1})
4290 
4291     def __delfield_byte(self): del self.__field_byte
4292 
4293     byte=property(__getfield_byte, __setfield_byte, __delfield_byte, "individual byte of senders phone number")
4294 
4295     def iscontainer(self):
4296         return True
4297 
4298     def containerelements(self):
4299         yield ('byte', self.__field_byte, "individual byte of senders phone number")
4300 
4301 
4302 
4303 
4304 class sms_quick_text(BaseProtogenClass):
4305     __fields=['msgs']
4306 
4307     def __init__(self, *args, **kwargs):
4308         dict={}
4309         # What was supplied to this function
4310         dict.update(kwargs)
4311         # Parent constructor
4312         super(sms_quick_text,self).__init__(**dict)
4313         if self.__class__ is sms_quick_text:
4314             self._update(args,dict)
4315 
4316 
4317     def getfields(self):
4318         return self.__fields
4319 
4320 
4321     def _update(self, args, kwargs):
4322         super(sms_quick_text,self)._update(args,kwargs)
4323         keys=kwargs.keys()
4324         for key in keys:
4325             if key in self.__fields:
4326                 setattr(self, key, kwargs[key])
4327                 del kwargs[key]
4328         # Were any unrecognized kwargs passed in?
4329         if __debug__:
4330             self._complainaboutunusedargs(sms_quick_text,kwargs)
4331         if len(args):
4332             dict2={'elementclass': _gen_p_lglg6190_354, }
4333             dict2.update(kwargs)
4334             kwargs=dict2
4335             self.__field_msgs=LIST(*args,**dict2)
4336         # Make all P fields that haven't already been constructed
4337 
4338 
4339     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
4340         'Writes this packet to the supplied buffer'
4341         self._bufferstartoffset=buf.getcurrentoffset()
4342         try: self.__field_msgs
4343         except:
4344             self.__field_msgs=LIST(**{'elementclass': _gen_p_lglg6190_354, })
4345         self.__field_msgs.writetobuffer(buf)
4346         self._bufferendoffset=buf.getcurrentoffset()
4347         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
4348 
4349 
4350     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
4351         'Reads this packet from the supplied buffer'
4352         self._bufferstartoffset=buf.getcurrentoffset()
4353         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
4354         self.__field_msgs=LIST(**{'elementclass': _gen_p_lglg6190_354, })
4355         self.__field_msgs.readfrombuffer(buf)
4356         self._bufferendoffset=buf.getcurrentoffset()
4357 
4358 
4359     def __getfield_msgs(self):
4360         try: self.__field_msgs
4361         except:
4362             self.__field_msgs=LIST(**{'elementclass': _gen_p_lglg6190_354, })
4363         return self.__field_msgs.getvalue()
4364 
4365     def __setfield_msgs(self, value):
4366         if isinstance(value,LIST):
4367             self.__field_msgs=value
4368         else:
4369             self.__field_msgs=LIST(value,**{'elementclass': _gen_p_lglg6190_354, })
4370 
4371     def __delfield_msgs(self): del self.__field_msgs
4372 
4373     msgs=property(__getfield_msgs, __setfield_msgs, __delfield_msgs, None)
4374 
4375     def iscontainer(self):
4376         return True
4377 
4378     def containerelements(self):
4379         yield ('msgs', self.__field_msgs, None)
4380 
4381 
4382 
4383 
4384 class _gen_p_lglg6190_354(BaseProtogenClass):
4385     'Anonymous inner class'
4386     __fields=['msg']
4387 
4388     def __init__(self, *args, **kwargs):
4389         dict={}
4390         # What was supplied to this function
4391         dict.update(kwargs)
4392         # Parent constructor
4393         super(_gen_p_lglg6190_354,self).__init__(**dict)
4394         if self.__class__ is _gen_p_lglg6190_354:
4395             self._update(args,dict)
4396 
4397 
4398     def getfields(self):
4399         return self.__fields
4400 
4401 
4402     def _update(self, args, kwargs):
4403         super(_gen_p_lglg6190_354,self)._update(args,kwargs)
4404         keys=kwargs.keys()
4405         for key in keys:
4406             if key in self.__fields:
4407                 setattr(self, key, kwargs[key])
4408                 del kwargs[key]
4409         # Were any unrecognized kwargs passed in?
4410         if __debug__:
4411             self._complainaboutunusedargs(_gen_p_lglg6190_354,kwargs)
4412         if len(args):
4413             dict2={'encoding': PHONE_ENCODING}
4414             dict2.update(kwargs)
4415             kwargs=dict2
4416             self.__field_msg=USTRING(*args,**dict2)
4417         # Make all P fields that haven't already been constructed
4418 
4419 
4420     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
4421         'Writes this packet to the supplied buffer'
4422         self._bufferstartoffset=buf.getcurrentoffset()
4423         self.__field_msg.writetobuffer(buf)
4424         self._bufferendoffset=buf.getcurrentoffset()
4425         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
4426 
4427 
4428     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
4429         'Reads this packet from the supplied buffer'
4430         self._bufferstartoffset=buf.getcurrentoffset()
4431         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
4432         self.__field_msg=USTRING(**{'encoding': PHONE_ENCODING})
4433         self.__field_msg.readfrombuffer(buf)
4434         self._bufferendoffset=buf.getcurrentoffset()
4435 
4436 
4437     def __getfield_msg(self):
4438         return self.__field_msg.getvalue()
4439 
4440     def __setfield_msg(self, value):
4441         if isinstance(value,USTRING):
4442             self.__field_msg=value
4443         else:
4444             self.__field_msg=USTRING(value,**{'encoding': PHONE_ENCODING})
4445 
4446     def __delfield_msg(self): del self.__field_msg
4447 
4448     msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None)
4449 
4450     def iscontainer(self):
4451         return True
4452 
4453     def containerelements(self):
4454         yield ('msg', self.__field_msg, None)
4455 
4456 
4457 
4458 
4459