PyXR

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

0001 # THIS FILE IS AUTOMATICALLY GENERATED.  EDIT THE SOURCE FILE NOT THIS ONE
0002 
0003 """Various descriptions of data specific to Sanyo MM-7400"""
0004 
0005 from prototypes import *
0006 
0007 # Make all sanyo stuff available in this module as well
0008 from p_sanyo import *
0009 from p_sanyomedia import *
0010 from p_sanyonewer import *
0011 
0012 # We use LSB for all integer like fields
0013 UINT=UINTlsb
0014 BOOL=BOOLlsb
0015 _NUMPBSLOTS=300
0016 _NUMSPEEDDIALS=8
0017 _NUMLONGNUMBERS=5
0018 _LONGPHONENUMBERLEN=30
0019 _NUMEVENTSLOTS=100
0020 _NUMCALLALARMSLOTS=15
0021  # Need to check.  Is max phone will hold 32/96 or 33/97
0022 _MAXNUMBERLEN=32
0023 _MAXEMAILLEN=96
0024 HASRINGPICBUF=0
0025 
0026 class qcpheader(BaseProtogenClass):
0027     __fields=['readwrite', 'command', 'packettype']
0028 
0029     def __init__(self, *args, **kwargs):
0030         dict={}
0031         # User specified arguments in the packet description
0032         dict.update({'readwrite': 0x26})
0033         # What was supplied to this function
0034         dict.update(kwargs)
0035         # Parent constructor
0036         super(qcpheader,self).__init__(**dict)
0037         if self.__class__ is qcpheader:
0038             self._update(args,dict)
0039 
0040 
0041     def getfields(self):
0042         return self.__fields
0043 
0044 
0045     def _update(self, args, kwargs):
0046         super(qcpheader,self)._update(args,kwargs)
0047         keys=kwargs.keys()
0048         for key in keys:
0049             if key in self.__fields:
0050                 setattr(self, key, kwargs[key])
0051                 del kwargs[key]
0052         # Were any unrecognized kwargs passed in?
0053         if __debug__:
0054             self._complainaboutunusedargs(qcpheader,kwargs)
0055         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0056         # Make all P fields that haven't already been constructed
0057 
0058 
0059     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0060         'Writes this packet to the supplied buffer'
0061         self._bufferstartoffset=buf.getcurrentoffset()
0062         self.__field_readwrite.writetobuffer(buf)
0063         self.__field_command.writetobuffer(buf)
0064         self.__field_packettype.writetobuffer(buf)
0065         self._bufferendoffset=buf.getcurrentoffset()
0066         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0067 
0068 
0069     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0070         'Reads this packet from the supplied buffer'
0071         self._bufferstartoffset=buf.getcurrentoffset()
0072         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0073         self.__field_readwrite=UINT(**{'sizeinbytes': 1})
0074         self.__field_readwrite.readfrombuffer(buf)
0075         self.__field_command=UINT(**{'sizeinbytes': 1})
0076         self.__field_command.readfrombuffer(buf)
0077         self.__field_packettype=UINT(**{'sizeinbytes': 1})
0078         self.__field_packettype.readfrombuffer(buf)
0079         self._bufferendoffset=buf.getcurrentoffset()
0080 
0081 
0082     def __getfield_readwrite(self):
0083         return self.__field_readwrite.getvalue()
0084 
0085     def __setfield_readwrite(self, value):
0086         if isinstance(value,UINT):
0087             self.__field_readwrite=value
0088         else:
0089             self.__field_readwrite=UINT(value,**{'sizeinbytes': 1})
0090 
0091     def __delfield_readwrite(self): del self.__field_readwrite
0092 
0093     readwrite=property(__getfield_readwrite, __setfield_readwrite, __delfield_readwrite, None)
0094 
0095     def __getfield_command(self):
0096         return self.__field_command.getvalue()
0097 
0098     def __setfield_command(self, value):
0099         if isinstance(value,UINT):
0100             self.__field_command=value
0101         else:
0102             self.__field_command=UINT(value,**{'sizeinbytes': 1})
0103 
0104     def __delfield_command(self): del self.__field_command
0105 
0106     command=property(__getfield_command, __setfield_command, __delfield_command, None)
0107 
0108     def __getfield_packettype(self):
0109         return self.__field_packettype.getvalue()
0110 
0111     def __setfield_packettype(self, value):
0112         if isinstance(value,UINT):
0113             self.__field_packettype=value
0114         else:
0115             self.__field_packettype=UINT(value,**{'sizeinbytes': 1})
0116 
0117     def __delfield_packettype(self): del self.__field_packettype
0118 
0119     packettype=property(__getfield_packettype, __setfield_packettype, __delfield_packettype, None)
0120 
0121     def iscontainer(self):
0122         return True
0123 
0124     def containerelements(self):
0125         yield ('readwrite', self.__field_readwrite, None)
0126         yield ('command', self.__field_command, None)
0127         yield ('packettype', self.__field_packettype, None)
0128 
0129 
0130 
0131 
0132 class qcpwriteheader(BaseProtogenClass):
0133     __fields=['readwrite', 'command', 'packettype']
0134 
0135     def __init__(self, *args, **kwargs):
0136         dict={}
0137         # User specified arguments in the packet description
0138         dict.update({'readwrite': 0x27})
0139         # What was supplied to this function
0140         dict.update(kwargs)
0141         # Parent constructor
0142         super(qcpwriteheader,self).__init__(**dict)
0143         if self.__class__ is qcpwriteheader:
0144             self._update(args,dict)
0145 
0146 
0147     def getfields(self):
0148         return self.__fields
0149 
0150 
0151     def _update(self, args, kwargs):
0152         super(qcpwriteheader,self)._update(args,kwargs)
0153         keys=kwargs.keys()
0154         for key in keys:
0155             if key in self.__fields:
0156                 setattr(self, key, kwargs[key])
0157                 del kwargs[key]
0158         # Were any unrecognized kwargs passed in?
0159         if __debug__:
0160             self._complainaboutunusedargs(qcpwriteheader,kwargs)
0161         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0162         # Make all P fields that haven't already been constructed
0163 
0164 
0165     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0166         'Writes this packet to the supplied buffer'
0167         self._bufferstartoffset=buf.getcurrentoffset()
0168         self.__field_readwrite.writetobuffer(buf)
0169         self.__field_command.writetobuffer(buf)
0170         self.__field_packettype.writetobuffer(buf)
0171         self._bufferendoffset=buf.getcurrentoffset()
0172         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0173 
0174 
0175     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0176         'Reads this packet from the supplied buffer'
0177         self._bufferstartoffset=buf.getcurrentoffset()
0178         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0179         self.__field_readwrite=UINT(**{'sizeinbytes': 1})
0180         self.__field_readwrite.readfrombuffer(buf)
0181         self.__field_command=UINT(**{'sizeinbytes': 1})
0182         self.__field_command.readfrombuffer(buf)
0183         self.__field_packettype=UINT(**{'sizeinbytes': 1})
0184         self.__field_packettype.readfrombuffer(buf)
0185         self._bufferendoffset=buf.getcurrentoffset()
0186 
0187 
0188     def __getfield_readwrite(self):
0189         return self.__field_readwrite.getvalue()
0190 
0191     def __setfield_readwrite(self, value):
0192         if isinstance(value,UINT):
0193             self.__field_readwrite=value
0194         else:
0195             self.__field_readwrite=UINT(value,**{'sizeinbytes': 1})
0196 
0197     def __delfield_readwrite(self): del self.__field_readwrite
0198 
0199     readwrite=property(__getfield_readwrite, __setfield_readwrite, __delfield_readwrite, None)
0200 
0201     def __getfield_command(self):
0202         return self.__field_command.getvalue()
0203 
0204     def __setfield_command(self, value):
0205         if isinstance(value,UINT):
0206             self.__field_command=value
0207         else:
0208             self.__field_command=UINT(value,**{'sizeinbytes': 1})
0209 
0210     def __delfield_command(self): del self.__field_command
0211 
0212     command=property(__getfield_command, __setfield_command, __delfield_command, None)
0213 
0214     def __getfield_packettype(self):
0215         return self.__field_packettype.getvalue()
0216 
0217     def __setfield_packettype(self, value):
0218         if isinstance(value,UINT):
0219             self.__field_packettype=value
0220         else:
0221             self.__field_packettype=UINT(value,**{'sizeinbytes': 1})
0222 
0223     def __delfield_packettype(self): del self.__field_packettype
0224 
0225     packettype=property(__getfield_packettype, __setfield_packettype, __delfield_packettype, None)
0226 
0227     def iscontainer(self):
0228         return True
0229 
0230     def containerelements(self):
0231         yield ('readwrite', self.__field_readwrite, None)
0232         yield ('command', self.__field_command, None)
0233         yield ('packettype', self.__field_packettype, None)
0234 
0235 
0236 
0237 
0238 class eventrequest(BaseProtogenClass):
0239     __fields=['header', 'slot', 'pad']
0240 
0241     def __init__(self, *args, **kwargs):
0242         dict={}
0243         # What was supplied to this function
0244         dict.update(kwargs)
0245         # Parent constructor
0246         super(eventrequest,self).__init__(**dict)
0247         if self.__class__ is eventrequest:
0248             self._update(args,dict)
0249 
0250 
0251     def getfields(self):
0252         return self.__fields
0253 
0254 
0255     def _update(self, args, kwargs):
0256         super(eventrequest,self)._update(args,kwargs)
0257         keys=kwargs.keys()
0258         for key in keys:
0259             if key in self.__fields:
0260                 setattr(self, key, kwargs[key])
0261                 del kwargs[key]
0262         # Were any unrecognized kwargs passed in?
0263         if __debug__:
0264             self._complainaboutunusedargs(eventrequest,kwargs)
0265         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0266         # Make all P fields that haven't already been constructed
0267 
0268 
0269     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0270         'Writes this packet to the supplied buffer'
0271         self._bufferstartoffset=buf.getcurrentoffset()
0272         try: self.__field_header
0273         except:
0274             self.__field_header=qcpheader(**{'packettype': 0x0c, 'command': 0x23})
0275         self.__field_header.writetobuffer(buf)
0276         self.__field_slot.writetobuffer(buf)
0277         try: self.__field_pad
0278         except:
0279             self.__field_pad=UNKNOWN(**{'sizeinbytes': 129})
0280         self.__field_pad.writetobuffer(buf)
0281         self._bufferendoffset=buf.getcurrentoffset()
0282         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0283 
0284 
0285     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0286         'Reads this packet from the supplied buffer'
0287         self._bufferstartoffset=buf.getcurrentoffset()
0288         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0289         self.__field_header=qcpheader(**{'packettype': 0x0c, 'command': 0x23})
0290         self.__field_header.readfrombuffer(buf)
0291         self.__field_slot=UINT(**{'sizeinbytes': 1})
0292         self.__field_slot.readfrombuffer(buf)
0293         self.__field_pad=UNKNOWN(**{'sizeinbytes': 129})
0294         self.__field_pad.readfrombuffer(buf)
0295         self._bufferendoffset=buf.getcurrentoffset()
0296 
0297 
0298     def __getfield_header(self):
0299         try: self.__field_header
0300         except:
0301             self.__field_header=qcpheader(**{'packettype': 0x0c, 'command': 0x23})
0302         return self.__field_header.getvalue()
0303 
0304     def __setfield_header(self, value):
0305         if isinstance(value,qcpheader):
0306             self.__field_header=value
0307         else:
0308             self.__field_header=qcpheader(value,**{'packettype': 0x0c, 'command': 0x23})
0309 
0310     def __delfield_header(self): del self.__field_header
0311 
0312     header=property(__getfield_header, __setfield_header, __delfield_header, None)
0313 
0314     def __getfield_slot(self):
0315         return self.__field_slot.getvalue()
0316 
0317     def __setfield_slot(self, value):
0318         if isinstance(value,UINT):
0319             self.__field_slot=value
0320         else:
0321             self.__field_slot=UINT(value,**{'sizeinbytes': 1})
0322 
0323     def __delfield_slot(self): del self.__field_slot
0324 
0325     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
0326 
0327     def __getfield_pad(self):
0328         try: self.__field_pad
0329         except:
0330             self.__field_pad=UNKNOWN(**{'sizeinbytes': 129})
0331         return self.__field_pad.getvalue()
0332 
0333     def __setfield_pad(self, value):
0334         if isinstance(value,UNKNOWN):
0335             self.__field_pad=value
0336         else:
0337             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 129})
0338 
0339     def __delfield_pad(self): del self.__field_pad
0340 
0341     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
0342 
0343     def iscontainer(self):
0344         return True
0345 
0346     def containerelements(self):
0347         yield ('header', self.__field_header, None)
0348         yield ('slot', self.__field_slot, None)
0349         yield ('pad', self.__field_pad, None)
0350 
0351 
0352 
0353 
0354 class eventslotinuserequest(BaseProtogenClass):
0355     __fields=['header', 'slot', 'pad']
0356 
0357     def __init__(self, *args, **kwargs):
0358         dict={}
0359         # What was supplied to this function
0360         dict.update(kwargs)
0361         # Parent constructor
0362         super(eventslotinuserequest,self).__init__(**dict)
0363         if self.__class__ is eventslotinuserequest:
0364             self._update(args,dict)
0365 
0366 
0367     def getfields(self):
0368         return self.__fields
0369 
0370 
0371     def _update(self, args, kwargs):
0372         super(eventslotinuserequest,self)._update(args,kwargs)
0373         keys=kwargs.keys()
0374         for key in keys:
0375             if key in self.__fields:
0376                 setattr(self, key, kwargs[key])
0377                 del kwargs[key]
0378         # Were any unrecognized kwargs passed in?
0379         if __debug__:
0380             self._complainaboutunusedargs(eventslotinuserequest,kwargs)
0381         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0382         # Make all P fields that haven't already been constructed
0383 
0384 
0385     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0386         'Writes this packet to the supplied buffer'
0387         self._bufferstartoffset=buf.getcurrentoffset()
0388         try: self.__field_header
0389         except:
0390             self.__field_header=qcpheader(**{'readwrite': 0x26, 'packettype': 0x0d, 'command': 0x74})
0391         self.__field_header.writetobuffer(buf)
0392         self.__field_slot.writetobuffer(buf)
0393         try: self.__field_pad
0394         except:
0395             self.__field_pad=UNKNOWN(**{'sizeinbytes': 129})
0396         self.__field_pad.writetobuffer(buf)
0397         self._bufferendoffset=buf.getcurrentoffset()
0398         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0399 
0400 
0401     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0402         'Reads this packet from the supplied buffer'
0403         self._bufferstartoffset=buf.getcurrentoffset()
0404         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0405         self.__field_header=qcpheader(**{'readwrite': 0x26, 'packettype': 0x0d, 'command': 0x74})
0406         self.__field_header.readfrombuffer(buf)
0407         self.__field_slot=UINT(**{'sizeinbytes': 1})
0408         self.__field_slot.readfrombuffer(buf)
0409         self.__field_pad=UNKNOWN(**{'sizeinbytes': 129})
0410         self.__field_pad.readfrombuffer(buf)
0411         self._bufferendoffset=buf.getcurrentoffset()
0412 
0413 
0414     def __getfield_header(self):
0415         try: self.__field_header
0416         except:
0417             self.__field_header=qcpheader(**{'readwrite': 0x26, 'packettype': 0x0d, 'command': 0x74})
0418         return self.__field_header.getvalue()
0419 
0420     def __setfield_header(self, value):
0421         if isinstance(value,qcpheader):
0422             self.__field_header=value
0423         else:
0424             self.__field_header=qcpheader(value,**{'readwrite': 0x26, 'packettype': 0x0d, 'command': 0x74})
0425 
0426     def __delfield_header(self): del self.__field_header
0427 
0428     header=property(__getfield_header, __setfield_header, __delfield_header, None)
0429 
0430     def __getfield_slot(self):
0431         return self.__field_slot.getvalue()
0432 
0433     def __setfield_slot(self, value):
0434         if isinstance(value,UINT):
0435             self.__field_slot=value
0436         else:
0437             self.__field_slot=UINT(value,**{'sizeinbytes': 1})
0438 
0439     def __delfield_slot(self): del self.__field_slot
0440 
0441     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
0442 
0443     def __getfield_pad(self):
0444         try: self.__field_pad
0445         except:
0446             self.__field_pad=UNKNOWN(**{'sizeinbytes': 129})
0447         return self.__field_pad.getvalue()
0448 
0449     def __setfield_pad(self, value):
0450         if isinstance(value,UNKNOWN):
0451             self.__field_pad=value
0452         else:
0453             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 129})
0454 
0455     def __delfield_pad(self): del self.__field_pad
0456 
0457     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
0458 
0459     def iscontainer(self):
0460         return True
0461 
0462     def containerelements(self):
0463         yield ('header', self.__field_header, None)
0464         yield ('slot', self.__field_slot, None)
0465         yield ('pad', self.__field_pad, None)
0466 
0467 
0468 
0469 
0470 class evententry(BaseProtogenClass):
0471     __fields=['slot', 'eventname', 'pad1', 'eventname_len', 'start', 'end', 'location', 'pad2', 'location_len', 'alarmdiff', 'period', 'dom', 'alarm', 'pad3', 'serial', 'pad4', 'ringtone']
0472 
0473     def __init__(self, *args, **kwargs):
0474         dict={}
0475         # What was supplied to this function
0476         dict.update(kwargs)
0477         # Parent constructor
0478         super(evententry,self).__init__(**dict)
0479         if self.__class__ is evententry:
0480             self._update(args,dict)
0481 
0482 
0483     def getfields(self):
0484         return self.__fields
0485 
0486 
0487     def _update(self, args, kwargs):
0488         super(evententry,self)._update(args,kwargs)
0489         keys=kwargs.keys()
0490         for key in keys:
0491             if key in self.__fields:
0492                 setattr(self, key, kwargs[key])
0493                 del kwargs[key]
0494         # Were any unrecognized kwargs passed in?
0495         if __debug__:
0496             self._complainaboutunusedargs(evententry,kwargs)
0497         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0498         # Make all P fields that haven't already been constructed
0499 
0500 
0501     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0502         'Writes this packet to the supplied buffer'
0503         self._bufferstartoffset=buf.getcurrentoffset()
0504         self.__field_slot.writetobuffer(buf)
0505         self.__field_eventname.writetobuffer(buf)
0506         try: self.__field_pad1
0507         except:
0508             self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7})
0509         self.__field_pad1.writetobuffer(buf)
0510         self.__field_eventname_len.writetobuffer(buf)
0511         self.__field_start.writetobuffer(buf)
0512         self.__field_end.writetobuffer(buf)
0513         self.__field_location.writetobuffer(buf)
0514         try: self.__field_pad2
0515         except:
0516             self.__field_pad2=UNKNOWN(**{'sizeinbytes': 7})
0517         self.__field_pad2.writetobuffer(buf)
0518         self.__field_location_len.writetobuffer(buf)
0519         self.__field_alarmdiff.writetobuffer(buf)
0520         self.__field_period.writetobuffer(buf)
0521         self.__field_dom.writetobuffer(buf)
0522         self.__field_alarm.writetobuffer(buf)
0523         try: self.__field_pad3
0524         except:
0525             self.__field_pad3=UNKNOWN(**{'sizeinbytes': 1})
0526         self.__field_pad3.writetobuffer(buf)
0527         try: self.__field_serial
0528         except:
0529             self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0})
0530         self.__field_serial.writetobuffer(buf)
0531         try: self.__field_pad4
0532         except:
0533             self.__field_pad4=UNKNOWN(**{'sizeinbytes': 3})
0534         self.__field_pad4.writetobuffer(buf)
0535         self.__field_ringtone.writetobuffer(buf)
0536         self._bufferendoffset=buf.getcurrentoffset()
0537         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0538 
0539 
0540     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0541         'Reads this packet from the supplied buffer'
0542         self._bufferstartoffset=buf.getcurrentoffset()
0543         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0544         self.__field_slot=UINT(**{'sizeinbytes': 1})
0545         self.__field_slot.readfrombuffer(buf)
0546         self.__field_eventname=USTRING(**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None})
0547         self.__field_eventname.readfrombuffer(buf)
0548         self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7})
0549         self.__field_pad1.readfrombuffer(buf)
0550         self.__field_eventname_len=UINT(**{'sizeinbytes': 1})
0551         self.__field_eventname_len.readfrombuffer(buf)
0552         self.__field_start=UINT(**{'sizeinbytes': 4})
0553         self.__field_start.readfrombuffer(buf)
0554         self.__field_end=UINT(**{'sizeinbytes': 4})
0555         self.__field_end.readfrombuffer(buf)
0556         self.__field_location=USTRING(**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None})
0557         self.__field_location.readfrombuffer(buf)
0558         self.__field_pad2=UNKNOWN(**{'sizeinbytes': 7})
0559         self.__field_pad2.readfrombuffer(buf)
0560         self.__field_location_len=UINT(**{'sizeinbytes': 1})
0561         self.__field_location_len.readfrombuffer(buf)
0562         self.__field_alarmdiff=UINT(**{'sizeinbytes': 4})
0563         self.__field_alarmdiff.readfrombuffer(buf)
0564         self.__field_period=UINT(**{'sizeinbytes': 1})
0565         self.__field_period.readfrombuffer(buf)
0566         self.__field_dom=UINT(**{'sizeinbytes': 1})
0567         self.__field_dom.readfrombuffer(buf)
0568         self.__field_alarm=UINT(**{'sizeinbytes': 4})
0569         self.__field_alarm.readfrombuffer(buf)
0570         self.__field_pad3=UNKNOWN(**{'sizeinbytes': 1})
0571         self.__field_pad3.readfrombuffer(buf)
0572         self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0})
0573         self.__field_serial.readfrombuffer(buf)
0574         self.__field_pad4=UNKNOWN(**{'sizeinbytes': 3})
0575         self.__field_pad4.readfrombuffer(buf)
0576         self.__field_ringtone=UINT(**{'sizeinbytes': 2})
0577         self.__field_ringtone.readfrombuffer(buf)
0578         self._bufferendoffset=buf.getcurrentoffset()
0579 
0580 
0581     def __getfield_slot(self):
0582         return self.__field_slot.getvalue()
0583 
0584     def __setfield_slot(self, value):
0585         if isinstance(value,UINT):
0586             self.__field_slot=value
0587         else:
0588             self.__field_slot=UINT(value,**{'sizeinbytes': 1})
0589 
0590     def __delfield_slot(self): del self.__field_slot
0591 
0592     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
0593 
0594     def __getfield_eventname(self):
0595         return self.__field_eventname.getvalue()
0596 
0597     def __setfield_eventname(self, value):
0598         if isinstance(value,USTRING):
0599             self.__field_eventname=value
0600         else:
0601             self.__field_eventname=USTRING(value,**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None})
0602 
0603     def __delfield_eventname(self): del self.__field_eventname
0604 
0605     eventname=property(__getfield_eventname, __setfield_eventname, __delfield_eventname, None)
0606 
0607     def __getfield_pad1(self):
0608         try: self.__field_pad1
0609         except:
0610             self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7})
0611         return self.__field_pad1.getvalue()
0612 
0613     def __setfield_pad1(self, value):
0614         if isinstance(value,UNKNOWN):
0615             self.__field_pad1=value
0616         else:
0617             self.__field_pad1=UNKNOWN(value,**{'sizeinbytes': 7})
0618 
0619     def __delfield_pad1(self): del self.__field_pad1
0620 
0621     pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None)
0622 
0623     def __getfield_eventname_len(self):
0624         return self.__field_eventname_len.getvalue()
0625 
0626     def __setfield_eventname_len(self, value):
0627         if isinstance(value,UINT):
0628             self.__field_eventname_len=value
0629         else:
0630             self.__field_eventname_len=UINT(value,**{'sizeinbytes': 1})
0631 
0632     def __delfield_eventname_len(self): del self.__field_eventname_len
0633 
0634     eventname_len=property(__getfield_eventname_len, __setfield_eventname_len, __delfield_eventname_len, None)
0635 
0636     def __getfield_start(self):
0637         return self.__field_start.getvalue()
0638 
0639     def __setfield_start(self, value):
0640         if isinstance(value,UINT):
0641             self.__field_start=value
0642         else:
0643             self.__field_start=UINT(value,**{'sizeinbytes': 4})
0644 
0645     def __delfield_start(self): del self.__field_start
0646 
0647     start=property(__getfield_start, __setfield_start, __delfield_start, "# seconds since Jan 1, 1980 approximately")
0648 
0649     def __getfield_end(self):
0650         return self.__field_end.getvalue()
0651 
0652     def __setfield_end(self, value):
0653         if isinstance(value,UINT):
0654             self.__field_end=value
0655         else:
0656             self.__field_end=UINT(value,**{'sizeinbytes': 4})
0657 
0658     def __delfield_end(self): del self.__field_end
0659 
0660     end=property(__getfield_end, __setfield_end, __delfield_end, None)
0661 
0662     def __getfield_location(self):
0663         return self.__field_location.getvalue()
0664 
0665     def __setfield_location(self, value):
0666         if isinstance(value,USTRING):
0667             self.__field_location=value
0668         else:
0669             self.__field_location=USTRING(value,**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None})
0670 
0671     def __delfield_location(self): del self.__field_location
0672 
0673     location=property(__getfield_location, __setfield_location, __delfield_location, None)
0674 
0675     def __getfield_pad2(self):
0676         try: self.__field_pad2
0677         except:
0678             self.__field_pad2=UNKNOWN(**{'sizeinbytes': 7})
0679         return self.__field_pad2.getvalue()
0680 
0681     def __setfield_pad2(self, value):
0682         if isinstance(value,UNKNOWN):
0683             self.__field_pad2=value
0684         else:
0685             self.__field_pad2=UNKNOWN(value,**{'sizeinbytes': 7})
0686 
0687     def __delfield_pad2(self): del self.__field_pad2
0688 
0689     pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None)
0690 
0691     def __getfield_location_len(self):
0692         return self.__field_location_len.getvalue()
0693 
0694     def __setfield_location_len(self, value):
0695         if isinstance(value,UINT):
0696             self.__field_location_len=value
0697         else:
0698             self.__field_location_len=UINT(value,**{'sizeinbytes': 1})
0699 
0700     def __delfield_location_len(self): del self.__field_location_len
0701 
0702     location_len=property(__getfield_location_len, __setfield_location_len, __delfield_location_len, None)
0703 
0704     def __getfield_alarmdiff(self):
0705         return self.__field_alarmdiff.getvalue()
0706 
0707     def __setfield_alarmdiff(self, value):
0708         if isinstance(value,UINT):
0709             self.__field_alarmdiff=value
0710         else:
0711             self.__field_alarmdiff=UINT(value,**{'sizeinbytes': 4})
0712 
0713     def __delfield_alarmdiff(self): del self.__field_alarmdiff
0714 
0715     alarmdiff=property(__getfield_alarmdiff, __setfield_alarmdiff, __delfield_alarmdiff, "Displayed alarm time")
0716 
0717     def __getfield_period(self):
0718         return self.__field_period.getvalue()
0719 
0720     def __setfield_period(self, value):
0721         if isinstance(value,UINT):
0722             self.__field_period=value
0723         else:
0724             self.__field_period=UINT(value,**{'sizeinbytes': 1})
0725 
0726     def __delfield_period(self): del self.__field_period
0727 
0728     period=property(__getfield_period, __setfield_period, __delfield_period, "No, Daily, Weekly, Monthly, Yearly")
0729 
0730     def __getfield_dom(self):
0731         return self.__field_dom.getvalue()
0732 
0733     def __setfield_dom(self, value):
0734         if isinstance(value,UINT):
0735             self.__field_dom=value
0736         else:
0737             self.__field_dom=UINT(value,**{'sizeinbytes': 1})
0738 
0739     def __delfield_dom(self): del self.__field_dom
0740 
0741     dom=property(__getfield_dom, __setfield_dom, __delfield_dom, "Day of month for the event")
0742 
0743     def __getfield_alarm(self):
0744         return self.__field_alarm.getvalue()
0745 
0746     def __setfield_alarm(self, value):
0747         if isinstance(value,UINT):
0748             self.__field_alarm=value
0749         else:
0750             self.__field_alarm=UINT(value,**{'sizeinbytes': 4})
0751 
0752     def __delfield_alarm(self): del self.__field_alarm
0753 
0754     alarm=property(__getfield_alarm, __setfield_alarm, __delfield_alarm, None)
0755 
0756     def __getfield_pad3(self):
0757         try: self.__field_pad3
0758         except:
0759             self.__field_pad3=UNKNOWN(**{'sizeinbytes': 1})
0760         return self.__field_pad3.getvalue()
0761 
0762     def __setfield_pad3(self, value):
0763         if isinstance(value,UNKNOWN):
0764             self.__field_pad3=value
0765         else:
0766             self.__field_pad3=UNKNOWN(value,**{'sizeinbytes': 1})
0767 
0768     def __delfield_pad3(self): del self.__field_pad3
0769 
0770     pad3=property(__getfield_pad3, __setfield_pad3, __delfield_pad3, None)
0771 
0772     def __getfield_serial(self):
0773         try: self.__field_serial
0774         except:
0775             self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0})
0776         return self.__field_serial.getvalue()
0777 
0778     def __setfield_serial(self, value):
0779         if isinstance(value,UINT):
0780             self.__field_serial=value
0781         else:
0782             self.__field_serial=UINT(value,**{'sizeinbytes': 1, 'default': 0})
0783 
0784     def __delfield_serial(self): del self.__field_serial
0785 
0786     serial=property(__getfield_serial, __setfield_serial, __delfield_serial, "Some kind of serial number")
0787 
0788     def __getfield_pad4(self):
0789         try: self.__field_pad4
0790         except:
0791             self.__field_pad4=UNKNOWN(**{'sizeinbytes': 3})
0792         return self.__field_pad4.getvalue()
0793 
0794     def __setfield_pad4(self, value):
0795         if isinstance(value,UNKNOWN):
0796             self.__field_pad4=value
0797         else:
0798             self.__field_pad4=UNKNOWN(value,**{'sizeinbytes': 3})
0799 
0800     def __delfield_pad4(self): del self.__field_pad4
0801 
0802     pad4=property(__getfield_pad4, __setfield_pad4, __delfield_pad4, None)
0803 
0804     def __getfield_ringtone(self):
0805         return self.__field_ringtone.getvalue()
0806 
0807     def __setfield_ringtone(self, value):
0808         if isinstance(value,UINT):
0809             self.__field_ringtone=value
0810         else:
0811             self.__field_ringtone=UINT(value,**{'sizeinbytes': 2})
0812 
0813     def __delfield_ringtone(self): del self.__field_ringtone
0814 
0815     ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None)
0816 
0817     def iscontainer(self):
0818         return True
0819 
0820     def containerelements(self):
0821         yield ('slot', self.__field_slot, None)
0822         yield ('eventname', self.__field_eventname, None)
0823         yield ('pad1', self.__field_pad1, None)
0824         yield ('eventname_len', self.__field_eventname_len, None)
0825         yield ('start', self.__field_start, "# seconds since Jan 1, 1980 approximately")
0826         yield ('end', self.__field_end, None)
0827         yield ('location', self.__field_location, None)
0828         yield ('pad2', self.__field_pad2, None)
0829         yield ('location_len', self.__field_location_len, None)
0830         yield ('alarmdiff', self.__field_alarmdiff, "Displayed alarm time")
0831         yield ('period', self.__field_period, "No, Daily, Weekly, Monthly, Yearly")
0832         yield ('dom', self.__field_dom, "Day of month for the event")
0833         yield ('alarm', self.__field_alarm, None)
0834         yield ('pad3', self.__field_pad3, None)
0835         yield ('serial', self.__field_serial, "Some kind of serial number")
0836         yield ('pad4', self.__field_pad4, None)
0837         yield ('ringtone', self.__field_ringtone, None)
0838 
0839 
0840 
0841 
0842 class eventresponse(BaseProtogenClass):
0843     __fields=['header', 'entry', 'pad']
0844 
0845     def __init__(self, *args, **kwargs):
0846         dict={}
0847         # What was supplied to this function
0848         dict.update(kwargs)
0849         # Parent constructor
0850         super(eventresponse,self).__init__(**dict)
0851         if self.__class__ is eventresponse:
0852             self._update(args,dict)
0853 
0854 
0855     def getfields(self):
0856         return self.__fields
0857 
0858 
0859     def _update(self, args, kwargs):
0860         super(eventresponse,self)._update(args,kwargs)
0861         keys=kwargs.keys()
0862         for key in keys:
0863             if key in self.__fields:
0864                 setattr(self, key, kwargs[key])
0865                 del kwargs[key]
0866         # Were any unrecognized kwargs passed in?
0867         if __debug__:
0868             self._complainaboutunusedargs(eventresponse,kwargs)
0869         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0870         # Make all P fields that haven't already been constructed
0871 
0872 
0873     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0874         'Writes this packet to the supplied buffer'
0875         self._bufferstartoffset=buf.getcurrentoffset()
0876         self.__field_header.writetobuffer(buf)
0877         self.__field_entry.writetobuffer(buf)
0878         self.__field_pad.writetobuffer(buf)
0879         self._bufferendoffset=buf.getcurrentoffset()
0880         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0881 
0882 
0883     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0884         'Reads this packet from the supplied buffer'
0885         self._bufferstartoffset=buf.getcurrentoffset()
0886         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0887         self.__field_header=qcpheader()
0888         self.__field_header.readfrombuffer(buf)
0889         self.__field_entry=evententry()
0890         self.__field_entry.readfrombuffer(buf)
0891         self.__field_pad=UNKNOWN()
0892         self.__field_pad.readfrombuffer(buf)
0893         self._bufferendoffset=buf.getcurrentoffset()
0894 
0895 
0896     def __getfield_header(self):
0897         return self.__field_header.getvalue()
0898 
0899     def __setfield_header(self, value):
0900         if isinstance(value,qcpheader):
0901             self.__field_header=value
0902         else:
0903             self.__field_header=qcpheader(value,)
0904 
0905     def __delfield_header(self): del self.__field_header
0906 
0907     header=property(__getfield_header, __setfield_header, __delfield_header, None)
0908 
0909     def __getfield_entry(self):
0910         return self.__field_entry.getvalue()
0911 
0912     def __setfield_entry(self, value):
0913         if isinstance(value,evententry):
0914             self.__field_entry=value
0915         else:
0916             self.__field_entry=evententry(value,)
0917 
0918     def __delfield_entry(self): del self.__field_entry
0919 
0920     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
0921 
0922     def __getfield_pad(self):
0923         return self.__field_pad.getvalue()
0924 
0925     def __setfield_pad(self, value):
0926         if isinstance(value,UNKNOWN):
0927             self.__field_pad=value
0928         else:
0929             self.__field_pad=UNKNOWN(value,)
0930 
0931     def __delfield_pad(self): del self.__field_pad
0932 
0933     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
0934 
0935     def iscontainer(self):
0936         return True
0937 
0938     def containerelements(self):
0939         yield ('header', self.__field_header, None)
0940         yield ('entry', self.__field_entry, None)
0941         yield ('pad', self.__field_pad, None)
0942 
0943 
0944 
0945 
0946 class eventslotinuseresponse(BaseProtogenClass):
0947     __fields=['header', 'slot', 'flag', 'pad']
0948 
0949     def __init__(self, *args, **kwargs):
0950         dict={}
0951         # What was supplied to this function
0952         dict.update(kwargs)
0953         # Parent constructor
0954         super(eventslotinuseresponse,self).__init__(**dict)
0955         if self.__class__ is eventslotinuseresponse:
0956             self._update(args,dict)
0957 
0958 
0959     def getfields(self):
0960         return self.__fields
0961 
0962 
0963     def _update(self, args, kwargs):
0964         super(eventslotinuseresponse,self)._update(args,kwargs)
0965         keys=kwargs.keys()
0966         for key in keys:
0967             if key in self.__fields:
0968                 setattr(self, key, kwargs[key])
0969                 del kwargs[key]
0970         # Were any unrecognized kwargs passed in?
0971         if __debug__:
0972             self._complainaboutunusedargs(eventslotinuseresponse,kwargs)
0973         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0974         # Make all P fields that haven't already been constructed
0975 
0976 
0977     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0978         'Writes this packet to the supplied buffer'
0979         self._bufferstartoffset=buf.getcurrentoffset()
0980         self.__field_header.writetobuffer(buf)
0981         self.__field_slot.writetobuffer(buf)
0982         self.__field_flag.writetobuffer(buf)
0983         self.__field_pad.writetobuffer(buf)
0984         self._bufferendoffset=buf.getcurrentoffset()
0985         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0986 
0987 
0988     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0989         'Reads this packet from the supplied buffer'
0990         self._bufferstartoffset=buf.getcurrentoffset()
0991         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0992         self.__field_header=qcpheader()
0993         self.__field_header.readfrombuffer(buf)
0994         self.__field_slot=UINT(**{'sizeinbytes': 1})
0995         self.__field_slot.readfrombuffer(buf)
0996         self.__field_flag=UINT(**{'sizeinbytes': 1})
0997         self.__field_flag.readfrombuffer(buf)
0998         self.__field_pad=UNKNOWN()
0999         self.__field_pad.readfrombuffer(buf)
1000         self._bufferendoffset=buf.getcurrentoffset()
1001 
1002 
1003     def __getfield_header(self):
1004         return self.__field_header.getvalue()
1005 
1006     def __setfield_header(self, value):
1007         if isinstance(value,qcpheader):
1008             self.__field_header=value
1009         else:
1010             self.__field_header=qcpheader(value,)
1011 
1012     def __delfield_header(self): del self.__field_header
1013 
1014     header=property(__getfield_header, __setfield_header, __delfield_header, None)
1015 
1016     def __getfield_slot(self):
1017         return self.__field_slot.getvalue()
1018 
1019     def __setfield_slot(self, value):
1020         if isinstance(value,UINT):
1021             self.__field_slot=value
1022         else:
1023             self.__field_slot=UINT(value,**{'sizeinbytes': 1})
1024 
1025     def __delfield_slot(self): del self.__field_slot
1026 
1027     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
1028 
1029     def __getfield_flag(self):
1030         return self.__field_flag.getvalue()
1031 
1032     def __setfield_flag(self, value):
1033         if isinstance(value,UINT):
1034             self.__field_flag=value
1035         else:
1036             self.__field_flag=UINT(value,**{'sizeinbytes': 1})
1037 
1038     def __delfield_flag(self): del self.__field_flag
1039 
1040     flag=property(__getfield_flag, __setfield_flag, __delfield_flag, None)
1041 
1042     def __getfield_pad(self):
1043         return self.__field_pad.getvalue()
1044 
1045     def __setfield_pad(self, value):
1046         if isinstance(value,UNKNOWN):
1047             self.__field_pad=value
1048         else:
1049             self.__field_pad=UNKNOWN(value,)
1050 
1051     def __delfield_pad(self): del self.__field_pad
1052 
1053     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
1054 
1055     def iscontainer(self):
1056         return True
1057 
1058     def containerelements(self):
1059         yield ('header', self.__field_header, None)
1060         yield ('slot', self.__field_slot, None)
1061         yield ('flag', self.__field_flag, None)
1062         yield ('pad', self.__field_pad, None)
1063 
1064 
1065 
1066 
1067 class eventslotinuseupdaterequest(BaseProtogenClass):
1068     __fields=['header', 'slot', 'flag', 'pad']
1069 
1070     def __init__(self, *args, **kwargs):
1071         dict={}
1072         # What was supplied to this function
1073         dict.update(kwargs)
1074         # Parent constructor
1075         super(eventslotinuseupdaterequest,self).__init__(**dict)
1076         if self.__class__ is eventslotinuseupdaterequest:
1077             self._update(args,dict)
1078 
1079 
1080     def getfields(self):
1081         return self.__fields
1082 
1083 
1084     def _update(self, args, kwargs):
1085         super(eventslotinuseupdaterequest,self)._update(args,kwargs)
1086         keys=kwargs.keys()
1087         for key in keys:
1088             if key in self.__fields:
1089                 setattr(self, key, kwargs[key])
1090                 del kwargs[key]
1091         # Were any unrecognized kwargs passed in?
1092         if __debug__:
1093             self._complainaboutunusedargs(eventslotinuseupdaterequest,kwargs)
1094         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1095         # Make all P fields that haven't already been constructed
1096 
1097 
1098     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1099         'Writes this packet to the supplied buffer'
1100         self._bufferstartoffset=buf.getcurrentoffset()
1101         try: self.__field_header
1102         except:
1103             self.__field_header=qcpwriteheader(**{'packettype': 0x0d, 'command': 0x74})
1104         self.__field_header.writetobuffer(buf)
1105         self.__field_slot.writetobuffer(buf)
1106         self.__field_flag.writetobuffer(buf)
1107         try: self.__field_pad
1108         except:
1109             self.__field_pad=UNKNOWN(**{'sizeinbytes': 124})
1110         self.__field_pad.writetobuffer(buf)
1111         self._bufferendoffset=buf.getcurrentoffset()
1112         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1113 
1114 
1115     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1116         'Reads this packet from the supplied buffer'
1117         self._bufferstartoffset=buf.getcurrentoffset()
1118         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1119         self.__field_header=qcpwriteheader(**{'packettype': 0x0d, 'command': 0x74})
1120         self.__field_header.readfrombuffer(buf)
1121         self.__field_slot=UINT(**{'sizeinbytes': 1})
1122         self.__field_slot.readfrombuffer(buf)
1123         self.__field_flag=UINT(**{'sizeinbytes': 1})
1124         self.__field_flag.readfrombuffer(buf)
1125         self.__field_pad=UNKNOWN(**{'sizeinbytes': 124})
1126         self.__field_pad.readfrombuffer(buf)
1127         self._bufferendoffset=buf.getcurrentoffset()
1128 
1129 
1130     def __getfield_header(self):
1131         try: self.__field_header
1132         except:
1133             self.__field_header=qcpwriteheader(**{'packettype': 0x0d, 'command': 0x74})
1134         return self.__field_header.getvalue()
1135 
1136     def __setfield_header(self, value):
1137         if isinstance(value,qcpwriteheader):
1138             self.__field_header=value
1139         else:
1140             self.__field_header=qcpwriteheader(value,**{'packettype': 0x0d, 'command': 0x74})
1141 
1142     def __delfield_header(self): del self.__field_header
1143 
1144     header=property(__getfield_header, __setfield_header, __delfield_header, None)
1145 
1146     def __getfield_slot(self):
1147         return self.__field_slot.getvalue()
1148 
1149     def __setfield_slot(self, value):
1150         if isinstance(value,UINT):
1151             self.__field_slot=value
1152         else:
1153             self.__field_slot=UINT(value,**{'sizeinbytes': 1})
1154 
1155     def __delfield_slot(self): del self.__field_slot
1156 
1157     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
1158 
1159     def __getfield_flag(self):
1160         return self.__field_flag.getvalue()
1161 
1162     def __setfield_flag(self, value):
1163         if isinstance(value,UINT):
1164             self.__field_flag=value
1165         else:
1166             self.__field_flag=UINT(value,**{'sizeinbytes': 1})
1167 
1168     def __delfield_flag(self): del self.__field_flag
1169 
1170     flag=property(__getfield_flag, __setfield_flag, __delfield_flag, None)
1171 
1172     def __getfield_pad(self):
1173         try: self.__field_pad
1174         except:
1175             self.__field_pad=UNKNOWN(**{'sizeinbytes': 124})
1176         return self.__field_pad.getvalue()
1177 
1178     def __setfield_pad(self, value):
1179         if isinstance(value,UNKNOWN):
1180             self.__field_pad=value
1181         else:
1182             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 124})
1183 
1184     def __delfield_pad(self): del self.__field_pad
1185 
1186     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
1187 
1188     def iscontainer(self):
1189         return True
1190 
1191     def containerelements(self):
1192         yield ('header', self.__field_header, None)
1193         yield ('slot', self.__field_slot, None)
1194         yield ('flag', self.__field_flag, None)
1195         yield ('pad', self.__field_pad, None)
1196 
1197 
1198 
1199 
1200 class eventupdaterequest(BaseProtogenClass):
1201     __fields=['header', 'entry', 'pad']
1202 
1203     def __init__(self, *args, **kwargs):
1204         dict={}
1205         # What was supplied to this function
1206         dict.update(kwargs)
1207         # Parent constructor
1208         super(eventupdaterequest,self).__init__(**dict)
1209         if self.__class__ is eventupdaterequest:
1210             self._update(args,dict)
1211 
1212 
1213     def getfields(self):
1214         return self.__fields
1215 
1216 
1217     def _update(self, args, kwargs):
1218         super(eventupdaterequest,self)._update(args,kwargs)
1219         keys=kwargs.keys()
1220         for key in keys:
1221             if key in self.__fields:
1222                 setattr(self, key, kwargs[key])
1223                 del kwargs[key]
1224         # Were any unrecognized kwargs passed in?
1225         if __debug__:
1226             self._complainaboutunusedargs(eventupdaterequest,kwargs)
1227         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1228         # Make all P fields that haven't already been constructed
1229 
1230 
1231     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1232         'Writes this packet to the supplied buffer'
1233         self._bufferstartoffset=buf.getcurrentoffset()
1234         try: self.__field_header
1235         except:
1236             self.__field_header=qcpwriteheader(**{'packettype': 0x0c, 'command':0x23})
1237         self.__field_header.writetobuffer(buf)
1238         self.__field_entry.writetobuffer(buf)
1239         try: self.__field_pad
1240         except:
1241             self.__field_pad=UNKNOWN(**{'sizeinbytes': 56})
1242         self.__field_pad.writetobuffer(buf)
1243         self._bufferendoffset=buf.getcurrentoffset()
1244         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1245 
1246 
1247     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1248         'Reads this packet from the supplied buffer'
1249         self._bufferstartoffset=buf.getcurrentoffset()
1250         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1251         self.__field_header=qcpwriteheader(**{'packettype': 0x0c, 'command':0x23})
1252         self.__field_header.readfrombuffer(buf)
1253         self.__field_entry=evententry()
1254         self.__field_entry.readfrombuffer(buf)
1255         self.__field_pad=UNKNOWN(**{'sizeinbytes': 56})
1256         self.__field_pad.readfrombuffer(buf)
1257         self._bufferendoffset=buf.getcurrentoffset()
1258 
1259 
1260     def __getfield_header(self):
1261         try: self.__field_header
1262         except:
1263             self.__field_header=qcpwriteheader(**{'packettype': 0x0c, 'command':0x23})
1264         return self.__field_header.getvalue()
1265 
1266     def __setfield_header(self, value):
1267         if isinstance(value,qcpwriteheader):
1268             self.__field_header=value
1269         else:
1270             self.__field_header=qcpwriteheader(value,**{'packettype': 0x0c, 'command':0x23})
1271 
1272     def __delfield_header(self): del self.__field_header
1273 
1274     header=property(__getfield_header, __setfield_header, __delfield_header, None)
1275 
1276     def __getfield_entry(self):
1277         return self.__field_entry.getvalue()
1278 
1279     def __setfield_entry(self, value):
1280         if isinstance(value,evententry):
1281             self.__field_entry=value
1282         else:
1283             self.__field_entry=evententry(value,)
1284 
1285     def __delfield_entry(self): del self.__field_entry
1286 
1287     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
1288 
1289     def __getfield_pad(self):
1290         try: self.__field_pad
1291         except:
1292             self.__field_pad=UNKNOWN(**{'sizeinbytes': 56})
1293         return self.__field_pad.getvalue()
1294 
1295     def __setfield_pad(self, value):
1296         if isinstance(value,UNKNOWN):
1297             self.__field_pad=value
1298         else:
1299             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 56})
1300 
1301     def __delfield_pad(self): del self.__field_pad
1302 
1303     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
1304 
1305     def iscontainer(self):
1306         return True
1307 
1308     def containerelements(self):
1309         yield ('header', self.__field_header, None)
1310         yield ('entry', self.__field_entry, None)
1311         yield ('pad', self.__field_pad, None)
1312 
1313 
1314 
1315 
1316 class callalarmrequest(BaseProtogenClass):
1317     __fields=['header', 'slot', 'pad']
1318 
1319     def __init__(self, *args, **kwargs):
1320         dict={}
1321         # What was supplied to this function
1322         dict.update(kwargs)
1323         # Parent constructor
1324         super(callalarmrequest,self).__init__(**dict)
1325         if self.__class__ is callalarmrequest:
1326             self._update(args,dict)
1327 
1328 
1329     def getfields(self):
1330         return self.__fields
1331 
1332 
1333     def _update(self, args, kwargs):
1334         super(callalarmrequest,self)._update(args,kwargs)
1335         keys=kwargs.keys()
1336         for key in keys:
1337             if key in self.__fields:
1338                 setattr(self, key, kwargs[key])
1339                 del kwargs[key]
1340         # Were any unrecognized kwargs passed in?
1341         if __debug__:
1342             self._complainaboutunusedargs(callalarmrequest,kwargs)
1343         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1344         # Make all P fields that haven't already been constructed
1345 
1346 
1347     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1348         'Writes this packet to the supplied buffer'
1349         self._bufferstartoffset=buf.getcurrentoffset()
1350         try: self.__field_header
1351         except:
1352             self.__field_header=qcpheader(**{'packettype': 0x0c, 'command': 0x24})
1353         self.__field_header.writetobuffer(buf)
1354         self.__field_slot.writetobuffer(buf)
1355         try: self.__field_pad
1356         except:
1357             self.__field_pad=UNKNOWN(**{'sizeinbytes': 129})
1358         self.__field_pad.writetobuffer(buf)
1359         self._bufferendoffset=buf.getcurrentoffset()
1360         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1361 
1362 
1363     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1364         'Reads this packet from the supplied buffer'
1365         self._bufferstartoffset=buf.getcurrentoffset()
1366         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1367         self.__field_header=qcpheader(**{'packettype': 0x0c, 'command': 0x24})
1368         self.__field_header.readfrombuffer(buf)
1369         self.__field_slot=UINT(**{'sizeinbytes': 1})
1370         self.__field_slot.readfrombuffer(buf)
1371         self.__field_pad=UNKNOWN(**{'sizeinbytes': 129})
1372         self.__field_pad.readfrombuffer(buf)
1373         self._bufferendoffset=buf.getcurrentoffset()
1374 
1375 
1376     def __getfield_header(self):
1377         try: self.__field_header
1378         except:
1379             self.__field_header=qcpheader(**{'packettype': 0x0c, 'command': 0x24})
1380         return self.__field_header.getvalue()
1381 
1382     def __setfield_header(self, value):
1383         if isinstance(value,qcpheader):
1384             self.__field_header=value
1385         else:
1386             self.__field_header=qcpheader(value,**{'packettype': 0x0c, 'command': 0x24})
1387 
1388     def __delfield_header(self): del self.__field_header
1389 
1390     header=property(__getfield_header, __setfield_header, __delfield_header, None)
1391 
1392     def __getfield_slot(self):
1393         return self.__field_slot.getvalue()
1394 
1395     def __setfield_slot(self, value):
1396         if isinstance(value,UINT):
1397             self.__field_slot=value
1398         else:
1399             self.__field_slot=UINT(value,**{'sizeinbytes': 1})
1400 
1401     def __delfield_slot(self): del self.__field_slot
1402 
1403     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
1404 
1405     def __getfield_pad(self):
1406         try: self.__field_pad
1407         except:
1408             self.__field_pad=UNKNOWN(**{'sizeinbytes': 129})
1409         return self.__field_pad.getvalue()
1410 
1411     def __setfield_pad(self, value):
1412         if isinstance(value,UNKNOWN):
1413             self.__field_pad=value
1414         else:
1415             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 129})
1416 
1417     def __delfield_pad(self): del self.__field_pad
1418 
1419     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
1420 
1421     def iscontainer(self):
1422         return True
1423 
1424     def containerelements(self):
1425         yield ('header', self.__field_header, None)
1426         yield ('slot', self.__field_slot, None)
1427         yield ('pad', self.__field_pad, None)
1428 
1429 
1430 
1431 
1432 class callalarmresponse(BaseProtogenClass):
1433     __fields=['header', 'entry', 'pad']
1434 
1435     def __init__(self, *args, **kwargs):
1436         dict={}
1437         # What was supplied to this function
1438         dict.update(kwargs)
1439         # Parent constructor
1440         super(callalarmresponse,self).__init__(**dict)
1441         if self.__class__ is callalarmresponse:
1442             self._update(args,dict)
1443 
1444 
1445     def getfields(self):
1446         return self.__fields
1447 
1448 
1449     def _update(self, args, kwargs):
1450         super(callalarmresponse,self)._update(args,kwargs)
1451         keys=kwargs.keys()
1452         for key in keys:
1453             if key in self.__fields:
1454                 setattr(self, key, kwargs[key])
1455                 del kwargs[key]
1456         # Were any unrecognized kwargs passed in?
1457         if __debug__:
1458             self._complainaboutunusedargs(callalarmresponse,kwargs)
1459         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1460         # Make all P fields that haven't already been constructed
1461 
1462 
1463     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1464         'Writes this packet to the supplied buffer'
1465         self._bufferstartoffset=buf.getcurrentoffset()
1466         self.__field_header.writetobuffer(buf)
1467         self.__field_entry.writetobuffer(buf)
1468         self.__field_pad.writetobuffer(buf)
1469         self._bufferendoffset=buf.getcurrentoffset()
1470         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1471 
1472 
1473     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1474         'Reads this packet from the supplied buffer'
1475         self._bufferstartoffset=buf.getcurrentoffset()
1476         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1477         self.__field_header=qcpheader()
1478         self.__field_header.readfrombuffer(buf)
1479         self.__field_entry=callalarmentry()
1480         self.__field_entry.readfrombuffer(buf)
1481         self.__field_pad=UNKNOWN()
1482         self.__field_pad.readfrombuffer(buf)
1483         self._bufferendoffset=buf.getcurrentoffset()
1484 
1485 
1486     def __getfield_header(self):
1487         return self.__field_header.getvalue()
1488 
1489     def __setfield_header(self, value):
1490         if isinstance(value,qcpheader):
1491             self.__field_header=value
1492         else:
1493             self.__field_header=qcpheader(value,)
1494 
1495     def __delfield_header(self): del self.__field_header
1496 
1497     header=property(__getfield_header, __setfield_header, __delfield_header, None)
1498 
1499     def __getfield_entry(self):
1500         return self.__field_entry.getvalue()
1501 
1502     def __setfield_entry(self, value):
1503         if isinstance(value,callalarmentry):
1504             self.__field_entry=value
1505         else:
1506             self.__field_entry=callalarmentry(value,)
1507 
1508     def __delfield_entry(self): del self.__field_entry
1509 
1510     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
1511 
1512     def __getfield_pad(self):
1513         return self.__field_pad.getvalue()
1514 
1515     def __setfield_pad(self, value):
1516         if isinstance(value,UNKNOWN):
1517             self.__field_pad=value
1518         else:
1519             self.__field_pad=UNKNOWN(value,)
1520 
1521     def __delfield_pad(self): del self.__field_pad
1522 
1523     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
1524 
1525     def iscontainer(self):
1526         return True
1527 
1528     def containerelements(self):
1529         yield ('header', self.__field_header, None)
1530         yield ('entry', self.__field_entry, None)
1531         yield ('pad', self.__field_pad, None)
1532 
1533 
1534 
1535 
1536 class callalarmupdaterequest(BaseProtogenClass):
1537     __fields=['header', 'entry', 'pad']
1538 
1539     def __init__(self, *args, **kwargs):
1540         dict={}
1541         # What was supplied to this function
1542         dict.update(kwargs)
1543         # Parent constructor
1544         super(callalarmupdaterequest,self).__init__(**dict)
1545         if self.__class__ is callalarmupdaterequest:
1546             self._update(args,dict)
1547 
1548 
1549     def getfields(self):
1550         return self.__fields
1551 
1552 
1553     def _update(self, args, kwargs):
1554         super(callalarmupdaterequest,self)._update(args,kwargs)
1555         keys=kwargs.keys()
1556         for key in keys:
1557             if key in self.__fields:
1558                 setattr(self, key, kwargs[key])
1559                 del kwargs[key]
1560         # Were any unrecognized kwargs passed in?
1561         if __debug__:
1562             self._complainaboutunusedargs(callalarmupdaterequest,kwargs)
1563         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1564         # Make all P fields that haven't already been constructed
1565 
1566 
1567     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1568         'Writes this packet to the supplied buffer'
1569         self._bufferstartoffset=buf.getcurrentoffset()
1570         try: self.__field_header
1571         except:
1572             self.__field_header=qcpwriteheader(**{'packettype': 0x0c, 'command':0x24})
1573         self.__field_header.writetobuffer(buf)
1574         self.__field_entry.writetobuffer(buf)
1575         try: self.__field_pad
1576         except:
1577             self.__field_pad=UNKNOWN(**{'sizeinbytes': 40})
1578         self.__field_pad.writetobuffer(buf)
1579         self._bufferendoffset=buf.getcurrentoffset()
1580         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1581 
1582 
1583     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1584         'Reads this packet from the supplied buffer'
1585         self._bufferstartoffset=buf.getcurrentoffset()
1586         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1587         self.__field_header=qcpwriteheader(**{'packettype': 0x0c, 'command':0x24})
1588         self.__field_header.readfrombuffer(buf)
1589         self.__field_entry=callalarmentry()
1590         self.__field_entry.readfrombuffer(buf)
1591         self.__field_pad=UNKNOWN(**{'sizeinbytes': 40})
1592         self.__field_pad.readfrombuffer(buf)
1593         self._bufferendoffset=buf.getcurrentoffset()
1594 
1595 
1596     def __getfield_header(self):
1597         try: self.__field_header
1598         except:
1599             self.__field_header=qcpwriteheader(**{'packettype': 0x0c, 'command':0x24})
1600         return self.__field_header.getvalue()
1601 
1602     def __setfield_header(self, value):
1603         if isinstance(value,qcpwriteheader):
1604             self.__field_header=value
1605         else:
1606             self.__field_header=qcpwriteheader(value,**{'packettype': 0x0c, 'command':0x24})
1607 
1608     def __delfield_header(self): del self.__field_header
1609 
1610     header=property(__getfield_header, __setfield_header, __delfield_header, None)
1611 
1612     def __getfield_entry(self):
1613         return self.__field_entry.getvalue()
1614 
1615     def __setfield_entry(self, value):
1616         if isinstance(value,callalarmentry):
1617             self.__field_entry=value
1618         else:
1619             self.__field_entry=callalarmentry(value,)
1620 
1621     def __delfield_entry(self): del self.__field_entry
1622 
1623     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
1624 
1625     def __getfield_pad(self):
1626         try: self.__field_pad
1627         except:
1628             self.__field_pad=UNKNOWN(**{'sizeinbytes': 40})
1629         return self.__field_pad.getvalue()
1630 
1631     def __setfield_pad(self, value):
1632         if isinstance(value,UNKNOWN):
1633             self.__field_pad=value
1634         else:
1635             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 40})
1636 
1637     def __delfield_pad(self): del self.__field_pad
1638 
1639     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
1640 
1641     def iscontainer(self):
1642         return True
1643 
1644     def containerelements(self):
1645         yield ('header', self.__field_header, None)
1646         yield ('entry', self.__field_entry, None)
1647         yield ('pad', self.__field_pad, None)
1648 
1649 
1650 
1651 
1652 class callalarmslotinuserequest(BaseProtogenClass):
1653     __fields=['header', 'slot', 'pad']
1654 
1655     def __init__(self, *args, **kwargs):
1656         dict={}
1657         # What was supplied to this function
1658         dict.update(kwargs)
1659         # Parent constructor
1660         super(callalarmslotinuserequest,self).__init__(**dict)
1661         if self.__class__ is callalarmslotinuserequest:
1662             self._update(args,dict)
1663 
1664 
1665     def getfields(self):
1666         return self.__fields
1667 
1668 
1669     def _update(self, args, kwargs):
1670         super(callalarmslotinuserequest,self)._update(args,kwargs)
1671         keys=kwargs.keys()
1672         for key in keys:
1673             if key in self.__fields:
1674                 setattr(self, key, kwargs[key])
1675                 del kwargs[key]
1676         # Were any unrecognized kwargs passed in?
1677         if __debug__:
1678             self._complainaboutunusedargs(callalarmslotinuserequest,kwargs)
1679         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1680         # Make all P fields that haven't already been constructed
1681 
1682 
1683     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1684         'Writes this packet to the supplied buffer'
1685         self._bufferstartoffset=buf.getcurrentoffset()
1686         try: self.__field_header
1687         except:
1688             self.__field_header=qcpheader(**{'packettype': 0x0d, 'command': 0x76})
1689         self.__field_header.writetobuffer(buf)
1690         self.__field_slot.writetobuffer(buf)
1691         try: self.__field_pad
1692         except:
1693             self.__field_pad=UNKNOWN(**{'sizeinbytes': 129})
1694         self.__field_pad.writetobuffer(buf)
1695         self._bufferendoffset=buf.getcurrentoffset()
1696         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1697 
1698 
1699     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1700         'Reads this packet from the supplied buffer'
1701         self._bufferstartoffset=buf.getcurrentoffset()
1702         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1703         self.__field_header=qcpheader(**{'packettype': 0x0d, 'command': 0x76})
1704         self.__field_header.readfrombuffer(buf)
1705         self.__field_slot=UINT(**{'sizeinbytes': 1})
1706         self.__field_slot.readfrombuffer(buf)
1707         self.__field_pad=UNKNOWN(**{'sizeinbytes': 129})
1708         self.__field_pad.readfrombuffer(buf)
1709         self._bufferendoffset=buf.getcurrentoffset()
1710 
1711 
1712     def __getfield_header(self):
1713         try: self.__field_header
1714         except:
1715             self.__field_header=qcpheader(**{'packettype': 0x0d, 'command': 0x76})
1716         return self.__field_header.getvalue()
1717 
1718     def __setfield_header(self, value):
1719         if isinstance(value,qcpheader):
1720             self.__field_header=value
1721         else:
1722             self.__field_header=qcpheader(value,**{'packettype': 0x0d, 'command': 0x76})
1723 
1724     def __delfield_header(self): del self.__field_header
1725 
1726     header=property(__getfield_header, __setfield_header, __delfield_header, None)
1727 
1728     def __getfield_slot(self):
1729         return self.__field_slot.getvalue()
1730 
1731     def __setfield_slot(self, value):
1732         if isinstance(value,UINT):
1733             self.__field_slot=value
1734         else:
1735             self.__field_slot=UINT(value,**{'sizeinbytes': 1})
1736 
1737     def __delfield_slot(self): del self.__field_slot
1738 
1739     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
1740 
1741     def __getfield_pad(self):
1742         try: self.__field_pad
1743         except:
1744             self.__field_pad=UNKNOWN(**{'sizeinbytes': 129})
1745         return self.__field_pad.getvalue()
1746 
1747     def __setfield_pad(self, value):
1748         if isinstance(value,UNKNOWN):
1749             self.__field_pad=value
1750         else:
1751             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 129})
1752 
1753     def __delfield_pad(self): del self.__field_pad
1754 
1755     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
1756 
1757     def iscontainer(self):
1758         return True
1759 
1760     def containerelements(self):
1761         yield ('header', self.__field_header, None)
1762         yield ('slot', self.__field_slot, None)
1763         yield ('pad', self.__field_pad, None)
1764 
1765 
1766 
1767 
1768 class callalarmslotinuseresponse(BaseProtogenClass):
1769     __fields=['header', 'slot', 'flag', 'pad']
1770 
1771     def __init__(self, *args, **kwargs):
1772         dict={}
1773         # What was supplied to this function
1774         dict.update(kwargs)
1775         # Parent constructor
1776         super(callalarmslotinuseresponse,self).__init__(**dict)
1777         if self.__class__ is callalarmslotinuseresponse:
1778             self._update(args,dict)
1779 
1780 
1781     def getfields(self):
1782         return self.__fields
1783 
1784 
1785     def _update(self, args, kwargs):
1786         super(callalarmslotinuseresponse,self)._update(args,kwargs)
1787         keys=kwargs.keys()
1788         for key in keys:
1789             if key in self.__fields:
1790                 setattr(self, key, kwargs[key])
1791                 del kwargs[key]
1792         # Were any unrecognized kwargs passed in?
1793         if __debug__:
1794             self._complainaboutunusedargs(callalarmslotinuseresponse,kwargs)
1795         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1796         # Make all P fields that haven't already been constructed
1797 
1798 
1799     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1800         'Writes this packet to the supplied buffer'
1801         self._bufferstartoffset=buf.getcurrentoffset()
1802         self.__field_header.writetobuffer(buf)
1803         self.__field_slot.writetobuffer(buf)
1804         self.__field_flag.writetobuffer(buf)
1805         self.__field_pad.writetobuffer(buf)
1806         self._bufferendoffset=buf.getcurrentoffset()
1807         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1808 
1809 
1810     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1811         'Reads this packet from the supplied buffer'
1812         self._bufferstartoffset=buf.getcurrentoffset()
1813         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1814         self.__field_header=qcpheader()
1815         self.__field_header.readfrombuffer(buf)
1816         self.__field_slot=UINT(**{'sizeinbytes': 1})
1817         self.__field_slot.readfrombuffer(buf)
1818         self.__field_flag=UINT(**{'sizeinbytes': 1})
1819         self.__field_flag.readfrombuffer(buf)
1820         self.__field_pad=UNKNOWN()
1821         self.__field_pad.readfrombuffer(buf)
1822         self._bufferendoffset=buf.getcurrentoffset()
1823 
1824 
1825     def __getfield_header(self):
1826         return self.__field_header.getvalue()
1827 
1828     def __setfield_header(self, value):
1829         if isinstance(value,qcpheader):
1830             self.__field_header=value
1831         else:
1832             self.__field_header=qcpheader(value,)
1833 
1834     def __delfield_header(self): del self.__field_header
1835 
1836     header=property(__getfield_header, __setfield_header, __delfield_header, None)
1837 
1838     def __getfield_slot(self):
1839         return self.__field_slot.getvalue()
1840 
1841     def __setfield_slot(self, value):
1842         if isinstance(value,UINT):
1843             self.__field_slot=value
1844         else:
1845             self.__field_slot=UINT(value,**{'sizeinbytes': 1})
1846 
1847     def __delfield_slot(self): del self.__field_slot
1848 
1849     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
1850 
1851     def __getfield_flag(self):
1852         return self.__field_flag.getvalue()
1853 
1854     def __setfield_flag(self, value):
1855         if isinstance(value,UINT):
1856             self.__field_flag=value
1857         else:
1858             self.__field_flag=UINT(value,**{'sizeinbytes': 1})
1859 
1860     def __delfield_flag(self): del self.__field_flag
1861 
1862     flag=property(__getfield_flag, __setfield_flag, __delfield_flag, None)
1863 
1864     def __getfield_pad(self):
1865         return self.__field_pad.getvalue()
1866 
1867     def __setfield_pad(self, value):
1868         if isinstance(value,UNKNOWN):
1869             self.__field_pad=value
1870         else:
1871             self.__field_pad=UNKNOWN(value,)
1872 
1873     def __delfield_pad(self): del self.__field_pad
1874 
1875     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
1876 
1877     def iscontainer(self):
1878         return True
1879 
1880     def containerelements(self):
1881         yield ('header', self.__field_header, None)
1882         yield ('slot', self.__field_slot, None)
1883         yield ('flag', self.__field_flag, None)
1884         yield ('pad', self.__field_pad, None)
1885 
1886 
1887 
1888 
1889 class callalarmentry(BaseProtogenClass):
1890     __fields=['slot', 'pad0', 'phonenum', 'phonenum_len', 'date', 'period', 'dom', 'datedup', 'name', 'pad1', 'name_len', 'phonenumbertype', 'phonenumberslot', 'pad2', 'serial', 'pad3', 'ringtone', 'pad4', 'flag']
1891 
1892     def __init__(self, *args, **kwargs):
1893         dict={}
1894         # What was supplied to this function
1895         dict.update(kwargs)
1896         # Parent constructor
1897         super(callalarmentry,self).__init__(**dict)
1898         if self.__class__ is callalarmentry:
1899             self._update(args,dict)
1900 
1901 
1902     def getfields(self):
1903         return self.__fields
1904 
1905 
1906     def _update(self, args, kwargs):
1907         super(callalarmentry,self)._update(args,kwargs)
1908         keys=kwargs.keys()
1909         for key in keys:
1910             if key in self.__fields:
1911                 setattr(self, key, kwargs[key])
1912                 del kwargs[key]
1913         # Were any unrecognized kwargs passed in?
1914         if __debug__:
1915             self._complainaboutunusedargs(callalarmentry,kwargs)
1916         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1917         # Make all P fields that haven't already been constructed
1918 
1919 
1920     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1921         'Writes this packet to the supplied buffer'
1922         self._bufferstartoffset=buf.getcurrentoffset()
1923         self.__field_slot.writetobuffer(buf)
1924         try: self.__field_pad0
1925         except:
1926             self.__field_pad0=UNKNOWN(**{'sizeinbytes': 1})
1927         self.__field_pad0.writetobuffer(buf)
1928         self.__field_phonenum.writetobuffer(buf)
1929         self.__field_phonenum_len.writetobuffer(buf)
1930         self.__field_date.writetobuffer(buf)
1931         self.__field_period.writetobuffer(buf)
1932         self.__field_dom.writetobuffer(buf)
1933         self.__field_datedup.writetobuffer(buf)
1934         self.__field_name.writetobuffer(buf)
1935         try: self.__field_pad1
1936         except:
1937             self.__field_pad1=UNKNOWN(**{'sizeinbytes': 1})
1938         self.__field_pad1.writetobuffer(buf)
1939         self.__field_name_len.writetobuffer(buf)
1940         self.__field_phonenumbertype.writetobuffer(buf)
1941         self.__field_phonenumberslot.writetobuffer(buf)
1942         try: self.__field_pad2
1943         except:
1944             self.__field_pad2=UNKNOWN(**{'sizeinbytes': 1})
1945         self.__field_pad2.writetobuffer(buf)
1946         try: self.__field_serial
1947         except:
1948             self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0})
1949         self.__field_serial.writetobuffer(buf)
1950         try: self.__field_pad3
1951         except:
1952             self.__field_pad3=UNKNOWN(**{'sizeinbytes': 2})
1953         self.__field_pad3.writetobuffer(buf)
1954         try: self.__field_ringtone
1955         except:
1956             self.__field_ringtone=UINT(**{'sizeinbytes': 1, 'default': 0xfc})
1957         self.__field_ringtone.writetobuffer(buf)
1958         try: self.__field_pad4
1959         except:
1960             self.__field_pad4=UNKNOWN(**{'sizeinbytes': 1})
1961         self.__field_pad4.writetobuffer(buf)
1962         try: self.__field_flag
1963         except:
1964             self.__field_flag=UINT(**{'sizeinbytes': 1})
1965         self.__field_flag.writetobuffer(buf)
1966         self._bufferendoffset=buf.getcurrentoffset()
1967         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1968 
1969 
1970     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1971         'Reads this packet from the supplied buffer'
1972         self._bufferstartoffset=buf.getcurrentoffset()
1973         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1974         self.__field_slot=UINT(**{'sizeinbytes': 1})
1975         self.__field_slot.readfrombuffer(buf)
1976         self.__field_pad0=UNKNOWN(**{'sizeinbytes': 1})
1977         self.__field_pad0.readfrombuffer(buf)
1978         self.__field_phonenum=USTRING(**{'sizeinbytes': 49, 'raiseonunterminatedread': False})
1979         self.__field_phonenum.readfrombuffer(buf)
1980         self.__field_phonenum_len=UINT(**{'sizeinbytes': 1})
1981         self.__field_phonenum_len.readfrombuffer(buf)
1982         self.__field_date=UINT(**{'sizeinbytes': 4})
1983         self.__field_date.readfrombuffer(buf)
1984         self.__field_period=UINT(**{'sizeinbytes': 1})
1985         self.__field_period.readfrombuffer(buf)
1986         self.__field_dom=UINT(**{'sizeinbytes': 1})
1987         self.__field_dom.readfrombuffer(buf)
1988         self.__field_datedup=UINT(**{'sizeinbytes': 4})
1989         self.__field_datedup.readfrombuffer(buf)
1990         self.__field_name=USTRING(**{'sizeinbytes': 16, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None})
1991         self.__field_name.readfrombuffer(buf)
1992         self.__field_pad1=UNKNOWN(**{'sizeinbytes': 1})
1993         self.__field_pad1.readfrombuffer(buf)
1994         self.__field_name_len=UINT(**{'sizeinbytes': 1})
1995         self.__field_name_len.readfrombuffer(buf)
1996         self.__field_phonenumbertype=UINT(**{'sizeinbytes': 1})
1997         self.__field_phonenumbertype.readfrombuffer(buf)
1998         self.__field_phonenumberslot=UINT(**{'sizeinbytes': 2})
1999         self.__field_phonenumberslot.readfrombuffer(buf)
2000         self.__field_pad2=UNKNOWN(**{'sizeinbytes': 1})
2001         self.__field_pad2.readfrombuffer(buf)
2002         self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0})
2003         self.__field_serial.readfrombuffer(buf)
2004         self.__field_pad3=UNKNOWN(**{'sizeinbytes': 2})
2005         self.__field_pad3.readfrombuffer(buf)
2006         self.__field_ringtone=UINT(**{'sizeinbytes': 1, 'default': 0xfc})
2007         self.__field_ringtone.readfrombuffer(buf)
2008         self.__field_pad4=UNKNOWN(**{'sizeinbytes': 1})
2009         self.__field_pad4.readfrombuffer(buf)
2010         self.__field_flag=UINT(**{'sizeinbytes': 1})
2011         self.__field_flag.readfrombuffer(buf)
2012         self._bufferendoffset=buf.getcurrentoffset()
2013 
2014 
2015     def __getfield_slot(self):
2016         return self.__field_slot.getvalue()
2017 
2018     def __setfield_slot(self, value):
2019         if isinstance(value,UINT):
2020             self.__field_slot=value
2021         else:
2022             self.__field_slot=UINT(value,**{'sizeinbytes': 1})
2023 
2024     def __delfield_slot(self): del self.__field_slot
2025 
2026     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
2027 
2028     def __getfield_pad0(self):
2029         try: self.__field_pad0
2030         except:
2031             self.__field_pad0=UNKNOWN(**{'sizeinbytes': 1})
2032         return self.__field_pad0.getvalue()
2033 
2034     def __setfield_pad0(self, value):
2035         if isinstance(value,UNKNOWN):
2036             self.__field_pad0=value
2037         else:
2038             self.__field_pad0=UNKNOWN(value,**{'sizeinbytes': 1})
2039 
2040     def __delfield_pad0(self): del self.__field_pad0
2041 
2042     pad0=property(__getfield_pad0, __setfield_pad0, __delfield_pad0, "Not the flag?")
2043 
2044     def __getfield_phonenum(self):
2045         return self.__field_phonenum.getvalue()
2046 
2047     def __setfield_phonenum(self, value):
2048         if isinstance(value,USTRING):
2049             self.__field_phonenum=value
2050         else:
2051             self.__field_phonenum=USTRING(value,**{'sizeinbytes': 49, 'raiseonunterminatedread': False})
2052 
2053     def __delfield_phonenum(self): del self.__field_phonenum
2054 
2055     phonenum=property(__getfield_phonenum, __setfield_phonenum, __delfield_phonenum, None)
2056 
2057     def __getfield_phonenum_len(self):
2058         return self.__field_phonenum_len.getvalue()
2059 
2060     def __setfield_phonenum_len(self, value):
2061         if isinstance(value,UINT):
2062             self.__field_phonenum_len=value
2063         else:
2064             self.__field_phonenum_len=UINT(value,**{'sizeinbytes': 1})
2065 
2066     def __delfield_phonenum_len(self): del self.__field_phonenum_len
2067 
2068     phonenum_len=property(__getfield_phonenum_len, __setfield_phonenum_len, __delfield_phonenum_len, None)
2069 
2070     def __getfield_date(self):
2071         return self.__field_date.getvalue()
2072 
2073     def __setfield_date(self, value):
2074         if isinstance(value,UINT):
2075             self.__field_date=value
2076         else:
2077             self.__field_date=UINT(value,**{'sizeinbytes': 4})
2078 
2079     def __delfield_date(self): del self.__field_date
2080 
2081     date=property(__getfield_date, __setfield_date, __delfield_date, "# seconds since Jan 1, 1980 approximately")
2082 
2083     def __getfield_period(self):
2084         return self.__field_period.getvalue()
2085 
2086     def __setfield_period(self, value):
2087         if isinstance(value,UINT):
2088             self.__field_period=value
2089         else:
2090             self.__field_period=UINT(value,**{'sizeinbytes': 1})
2091 
2092     def __delfield_period(self): del self.__field_period
2093 
2094     period=property(__getfield_period, __setfield_period, __delfield_period, "No, Daily, Weekly, Monthly, Yearly")
2095 
2096     def __getfield_dom(self):
2097         return self.__field_dom.getvalue()
2098 
2099     def __setfield_dom(self, value):
2100         if isinstance(value,UINT):
2101             self.__field_dom=value
2102         else:
2103             self.__field_dom=UINT(value,**{'sizeinbytes': 1})
2104 
2105     def __delfield_dom(self): del self.__field_dom
2106 
2107     dom=property(__getfield_dom, __setfield_dom, __delfield_dom, "Day of month for the event")
2108 
2109     def __getfield_datedup(self):
2110         return self.__field_datedup.getvalue()
2111 
2112     def __setfield_datedup(self, value):
2113         if isinstance(value,UINT):
2114             self.__field_datedup=value
2115         else:
2116             self.__field_datedup=UINT(value,**{'sizeinbytes': 4})
2117 
2118     def __delfield_datedup(self): del self.__field_datedup
2119 
2120     datedup=property(__getfield_datedup, __setfield_datedup, __delfield_datedup, "Copy of the date.  Always the same???")
2121 
2122     def __getfield_name(self):
2123         return self.__field_name.getvalue()
2124 
2125     def __setfield_name(self, value):
2126         if isinstance(value,USTRING):
2127             self.__field_name=value
2128         else:
2129             self.__field_name=USTRING(value,**{'sizeinbytes': 16, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None})
2130 
2131     def __delfield_name(self): del self.__field_name
2132 
2133     name=property(__getfield_name, __setfield_name, __delfield_name, None)
2134 
2135     def __getfield_pad1(self):
2136         try: self.__field_pad1
2137         except:
2138             self.__field_pad1=UNKNOWN(**{'sizeinbytes': 1})
2139         return self.__field_pad1.getvalue()
2140 
2141     def __setfield_pad1(self, value):
2142         if isinstance(value,UNKNOWN):
2143             self.__field_pad1=value
2144         else:
2145             self.__field_pad1=UNKNOWN(value,**{'sizeinbytes': 1})
2146 
2147     def __delfield_pad1(self): del self.__field_pad1
2148 
2149     pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None)
2150 
2151     def __getfield_name_len(self):
2152         return self.__field_name_len.getvalue()
2153 
2154     def __setfield_name_len(self, value):
2155         if isinstance(value,UINT):
2156             self.__field_name_len=value
2157         else:
2158             self.__field_name_len=UINT(value,**{'sizeinbytes': 1})
2159 
2160     def __delfield_name_len(self): del self.__field_name_len
2161 
2162     name_len=property(__getfield_name_len, __setfield_name_len, __delfield_name_len, None)
2163 
2164     def __getfield_phonenumbertype(self):
2165         return self.__field_phonenumbertype.getvalue()
2166 
2167     def __setfield_phonenumbertype(self, value):
2168         if isinstance(value,UINT):
2169             self.__field_phonenumbertype=value
2170         else:
2171             self.__field_phonenumbertype=UINT(value,**{'sizeinbytes': 1})
2172 
2173     def __delfield_phonenumbertype(self): del self.__field_phonenumbertype
2174 
2175     phonenumbertype=property(__getfield_phonenumbertype, __setfield_phonenumbertype, __delfield_phonenumbertype, "1: Home, 2: Work, ...")
2176 
2177     def __getfield_phonenumberslot(self):
2178         return self.__field_phonenumberslot.getvalue()
2179 
2180     def __setfield_phonenumberslot(self, value):
2181         if isinstance(value,UINT):
2182             self.__field_phonenumberslot=value
2183         else:
2184             self.__field_phonenumberslot=UINT(value,**{'sizeinbytes': 2})
2185 
2186     def __delfield_phonenumberslot(self): del self.__field_phonenumberslot
2187 
2188     phonenumberslot=property(__getfield_phonenumberslot, __setfield_phonenumberslot, __delfield_phonenumberslot, None)
2189 
2190     def __getfield_pad2(self):
2191         try: self.__field_pad2
2192         except:
2193             self.__field_pad2=UNKNOWN(**{'sizeinbytes': 1})
2194         return self.__field_pad2.getvalue()
2195 
2196     def __setfield_pad2(self, value):
2197         if isinstance(value,UNKNOWN):
2198             self.__field_pad2=value
2199         else:
2200             self.__field_pad2=UNKNOWN(value,**{'sizeinbytes': 1})
2201 
2202     def __delfield_pad2(self): del self.__field_pad2
2203 
2204     pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None)
2205 
2206     def __getfield_serial(self):
2207         try: self.__field_serial
2208         except:
2209             self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0})
2210         return self.__field_serial.getvalue()
2211 
2212     def __setfield_serial(self, value):
2213         if isinstance(value,UINT):
2214             self.__field_serial=value
2215         else:
2216             self.__field_serial=UINT(value,**{'sizeinbytes': 1, 'default': 0})
2217 
2218     def __delfield_serial(self): del self.__field_serial
2219 
2220     serial=property(__getfield_serial, __setfield_serial, __delfield_serial, None)
2221 
2222     def __getfield_pad3(self):
2223         try: self.__field_pad3
2224         except:
2225             self.__field_pad3=UNKNOWN(**{'sizeinbytes': 2})
2226         return self.__field_pad3.getvalue()
2227 
2228     def __setfield_pad3(self, value):
2229         if isinstance(value,UNKNOWN):
2230             self.__field_pad3=value
2231         else:
2232             self.__field_pad3=UNKNOWN(value,**{'sizeinbytes': 2})
2233 
2234     def __delfield_pad3(self): del self.__field_pad3
2235 
2236     pad3=property(__getfield_pad3, __setfield_pad3, __delfield_pad3, None)
2237 
2238     def __getfield_ringtone(self):
2239         try: self.__field_ringtone
2240         except:
2241             self.__field_ringtone=UINT(**{'sizeinbytes': 1, 'default': 0xfc})
2242         return self.__field_ringtone.getvalue()
2243 
2244     def __setfield_ringtone(self, value):
2245         if isinstance(value,UINT):
2246             self.__field_ringtone=value
2247         else:
2248             self.__field_ringtone=UINT(value,**{'sizeinbytes': 1, 'default': 0xfc})
2249 
2250     def __delfield_ringtone(self): del self.__field_ringtone
2251 
2252     ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None)
2253 
2254     def __getfield_pad4(self):
2255         try: self.__field_pad4
2256         except:
2257             self.__field_pad4=UNKNOWN(**{'sizeinbytes': 1})
2258         return self.__field_pad4.getvalue()
2259 
2260     def __setfield_pad4(self, value):
2261         if isinstance(value,UNKNOWN):
2262             self.__field_pad4=value
2263         else:
2264             self.__field_pad4=UNKNOWN(value,**{'sizeinbytes': 1})
2265 
2266     def __delfield_pad4(self): del self.__field_pad4
2267 
2268     pad4=property(__getfield_pad4, __setfield_pad4, __delfield_pad4, " This may be the ringtone.  Need to understand ")
2269 
2270     def __getfield_flag(self):
2271         try: self.__field_flag
2272         except:
2273             self.__field_flag=UINT(**{'sizeinbytes': 1})
2274         return self.__field_flag.getvalue()
2275 
2276     def __setfield_flag(self, value):
2277         if isinstance(value,UINT):
2278             self.__field_flag=value
2279         else:
2280             self.__field_flag=UINT(value,**{'sizeinbytes': 1})
2281 
2282     def __delfield_flag(self): del self.__field_flag
2283 
2284     flag=property(__getfield_flag, __setfield_flag, __delfield_flag, None)
2285 
2286     def iscontainer(self):
2287         return True
2288 
2289     def containerelements(self):
2290         yield ('slot', self.__field_slot, None)
2291         yield ('pad0', self.__field_pad0, "Not the flag?")
2292         yield ('phonenum', self.__field_phonenum, None)
2293         yield ('phonenum_len', self.__field_phonenum_len, None)
2294         yield ('date', self.__field_date, "# seconds since Jan 1, 1980 approximately")
2295         yield ('period', self.__field_period, "No, Daily, Weekly, Monthly, Yearly")
2296         yield ('dom', self.__field_dom, "Day of month for the event")
2297         yield ('datedup', self.__field_datedup, "Copy of the date.  Always the same???")
2298         yield ('name', self.__field_name, None)
2299         yield ('pad1', self.__field_pad1, None)
2300         yield ('name_len', self.__field_name_len, None)
2301         yield ('phonenumbertype', self.__field_phonenumbertype, "1: Home, 2: Work, ...")
2302         yield ('phonenumberslot', self.__field_phonenumberslot, None)
2303         yield ('pad2', self.__field_pad2, None)
2304         yield ('serial', self.__field_serial, None)
2305         yield ('pad3', self.__field_pad3, None)
2306         yield ('ringtone', self.__field_ringtone, None)
2307         yield ('pad4', self.__field_pad4, " This may be the ringtone.  Need to understand ")
2308         yield ('flag', self.__field_flag, None)
2309 
2310 
2311 
2312 
2313 class todorequest(BaseProtogenClass):
2314     __fields=['header', 'slot', 'pad']
2315 
2316     def __init__(self, *args, **kwargs):
2317         dict={}
2318         # What was supplied to this function
2319         dict.update(kwargs)
2320         # Parent constructor
2321         super(todorequest,self).__init__(**dict)
2322         if self.__class__ is todorequest:
2323             self._update(args,dict)
2324 
2325 
2326     def getfields(self):
2327         return self.__fields
2328 
2329 
2330     def _update(self, args, kwargs):
2331         super(todorequest,self)._update(args,kwargs)
2332         keys=kwargs.keys()
2333         for key in keys:
2334             if key in self.__fields:
2335                 setattr(self, key, kwargs[key])
2336                 del kwargs[key]
2337         # Were any unrecognized kwargs passed in?
2338         if __debug__:
2339             self._complainaboutunusedargs(todorequest,kwargs)
2340         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2341         # Make all P fields that haven't already been constructed
2342 
2343 
2344     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2345         'Writes this packet to the supplied buffer'
2346         self._bufferstartoffset=buf.getcurrentoffset()
2347         try: self.__field_header
2348         except:
2349             self.__field_header=qcpheader(**{'packettype': 0x0c, 'command': 0x25})
2350         self.__field_header.writetobuffer(buf)
2351         self.__field_slot.writetobuffer(buf)
2352         try: self.__field_pad
2353         except:
2354             self.__field_pad=UNKNOWN(**{'sizeinbytes': 129})
2355         self.__field_pad.writetobuffer(buf)
2356         self._bufferendoffset=buf.getcurrentoffset()
2357         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2358 
2359 
2360     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2361         'Reads this packet from the supplied buffer'
2362         self._bufferstartoffset=buf.getcurrentoffset()
2363         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2364         self.__field_header=qcpheader(**{'packettype': 0x0c, 'command': 0x25})
2365         self.__field_header.readfrombuffer(buf)
2366         self.__field_slot=UINT(**{'sizeinbytes': 1})
2367         self.__field_slot.readfrombuffer(buf)
2368         self.__field_pad=UNKNOWN(**{'sizeinbytes': 129})
2369         self.__field_pad.readfrombuffer(buf)
2370         self._bufferendoffset=buf.getcurrentoffset()
2371 
2372 
2373     def __getfield_header(self):
2374         try: self.__field_header
2375         except:
2376             self.__field_header=qcpheader(**{'packettype': 0x0c, 'command': 0x25})
2377         return self.__field_header.getvalue()
2378 
2379     def __setfield_header(self, value):
2380         if isinstance(value,qcpheader):
2381             self.__field_header=value
2382         else:
2383             self.__field_header=qcpheader(value,**{'packettype': 0x0c, 'command': 0x25})
2384 
2385     def __delfield_header(self): del self.__field_header
2386 
2387     header=property(__getfield_header, __setfield_header, __delfield_header, None)
2388 
2389     def __getfield_slot(self):
2390         return self.__field_slot.getvalue()
2391 
2392     def __setfield_slot(self, value):
2393         if isinstance(value,UINT):
2394             self.__field_slot=value
2395         else:
2396             self.__field_slot=UINT(value,**{'sizeinbytes': 1})
2397 
2398     def __delfield_slot(self): del self.__field_slot
2399 
2400     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
2401 
2402     def __getfield_pad(self):
2403         try: self.__field_pad
2404         except:
2405             self.__field_pad=UNKNOWN(**{'sizeinbytes': 129})
2406         return self.__field_pad.getvalue()
2407 
2408     def __setfield_pad(self, value):
2409         if isinstance(value,UNKNOWN):
2410             self.__field_pad=value
2411         else:
2412             self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 129})
2413 
2414     def __delfield_pad(self): del self.__field_pad
2415 
2416     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
2417 
2418     def iscontainer(self):
2419         return True
2420 
2421     def containerelements(self):
2422         yield ('header', self.__field_header, None)
2423         yield ('slot', self.__field_slot, None)
2424         yield ('pad', self.__field_pad, None)
2425 
2426 
2427 
2428 
2429 class todoentry(BaseProtogenClass):
2430     __fields=['slot', 'flag', 'todo', 'pad1', 'todo_len', 'priority', 'dunno', 'order']
2431 
2432     def __init__(self, *args, **kwargs):
2433         dict={}
2434         # What was supplied to this function
2435         dict.update(kwargs)
2436         # Parent constructor
2437         super(todoentry,self).__init__(**dict)
2438         if self.__class__ is todoentry:
2439             self._update(args,dict)
2440 
2441 
2442     def getfields(self):
2443         return self.__fields
2444 
2445 
2446     def _update(self, args, kwargs):
2447         super(todoentry,self)._update(args,kwargs)
2448         keys=kwargs.keys()
2449         for key in keys:
2450             if key in self.__fields:
2451                 setattr(self, key, kwargs[key])
2452                 del kwargs[key]
2453         # Were any unrecognized kwargs passed in?
2454         if __debug__:
2455             self._complainaboutunusedargs(todoentry,kwargs)
2456         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2457         # Make all P fields that haven't already been constructed
2458 
2459 
2460     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2461         'Writes this packet to the supplied buffer'
2462         self._bufferstartoffset=buf.getcurrentoffset()
2463         self.__field_slot.writetobuffer(buf)
2464         self.__field_flag.writetobuffer(buf)
2465         self.__field_todo.writetobuffer(buf)
2466         try: self.__field_pad1
2467         except:
2468             self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7})
2469         self.__field_pad1.writetobuffer(buf)
2470         self.__field_todo_len.writetobuffer(buf)
2471         self.__field_priority.writetobuffer(buf)
2472         try: self.__field_dunno
2473         except:
2474             self.__field_dunno=UINT(**{'sizeinbytes': 1})
2475         self.__field_dunno.writetobuffer(buf)
2476         self.__field_order.writetobuffer(buf)
2477         self._bufferendoffset=buf.getcurrentoffset()
2478         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2479 
2480 
2481     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2482         'Reads this packet from the supplied buffer'
2483         self._bufferstartoffset=buf.getcurrentoffset()
2484         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2485         self.__field_slot=UINT(**{'sizeinbytes': 1})
2486         self.__field_slot.readfrombuffer(buf)
2487         self.__field_flag=UINT(**{'sizeinbytes': 1})
2488         self.__field_flag.readfrombuffer(buf)
2489         self.__field_todo=USTRING(**{'sizeinbytes': 14, 'raiseonunterminatedread': False})
2490         self.__field_todo.readfrombuffer(buf)
2491         self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7})
2492         self.__field_pad1.readfrombuffer(buf)
2493         self.__field_todo_len=UINT(**{'sizeinbytes': 1})
2494         self.__field_todo_len.readfrombuffer(buf)
2495         self.__field_priority=UINT(**{'sizeinbytes': 1})
2496         self.__field_priority.readfrombuffer(buf)
2497         self.__field_dunno=UINT(**{'sizeinbytes': 1})
2498         self.__field_dunno.readfrombuffer(buf)
2499         self.__field_order=UINT(**{'sizeinbytes': 1})
2500         self.__field_order.readfrombuffer(buf)
2501         self._bufferendoffset=buf.getcurrentoffset()
2502 
2503 
2504     def __getfield_slot(self):
2505         return self.__field_slot.getvalue()
2506 
2507     def __setfield_slot(self, value):
2508         if isinstance(value,UINT):
2509             self.__field_slot=value
2510         else:
2511             self.__field_slot=UINT(value,**{'sizeinbytes': 1})
2512 
2513     def __delfield_slot(self): del self.__field_slot
2514 
2515     slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
2516 
2517     def __getfield_flag(self):
2518         return self.__field_flag.getvalue()
2519 
2520     def __setfield_flag(self, value):
2521         if isinstance(value,UINT):
2522             self.__field_flag=value
2523         else:
2524             self.__field_flag=UINT(value,**{'sizeinbytes': 1})
2525 
2526     def __delfield_flag(self): del self.__field_flag
2527 
2528     flag=property(__getfield_flag, __setfield_flag, __delfield_flag, "0: Not used, 1: Used")
2529 
2530     def __getfield_todo(self):
2531         return self.__field_todo.getvalue()
2532 
2533     def __setfield_todo(self, value):
2534         if isinstance(value,USTRING):
2535             self.__field_todo=value
2536         else:
2537             self.__field_todo=USTRING(value,**{'sizeinbytes': 14, 'raiseonunterminatedread': False})
2538 
2539     def __delfield_todo(self): del self.__field_todo
2540 
2541     todo=property(__getfield_todo, __setfield_todo, __delfield_todo, None)
2542 
2543     def __getfield_pad1(self):
2544         try: self.__field_pad1
2545         except:
2546             self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7})
2547         return self.__field_pad1.getvalue()
2548 
2549     def __setfield_pad1(self, value):
2550         if isinstance(value,UNKNOWN):
2551             self.__field_pad1=value
2552         else:
2553             self.__field_pad1=UNKNOWN(value,**{'sizeinbytes': 7})
2554 
2555     def __delfield_pad1(self): del self.__field_pad1
2556 
2557     pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None)
2558 
2559     def __getfield_todo_len(self):
2560         return self.__field_todo_len.getvalue()
2561 
2562     def __setfield_todo_len(self, value):
2563         if isinstance(value,UINT):
2564             self.__field_todo_len=value
2565         else:
2566             self.__field_todo_len=UINT(value,**{'sizeinbytes': 1})
2567 
2568     def __delfield_todo_len(self): del self.__field_todo_len
2569 
2570     todo_len=property(__getfield_todo_len, __setfield_todo_len, __delfield_todo_len, None)
2571 
2572     def __getfield_priority(self):
2573         return self.__field_priority.getvalue()
2574 
2575     def __setfield_priority(self, value):
2576         if isinstance(value,UINT):
2577             self.__field_priority=value
2578         else:
2579             self.__field_priority=UINT(value,**{'sizeinbytes': 1})
2580 
2581     def __delfield_priority(self): del self.__field_priority
2582 
2583     priority=property(__getfield_priority, __setfield_priority, __delfield_priority, "0: Normal, 1: Urgent, 2: Done")
2584 
2585     def __getfield_dunno(self):
2586         try: self.__field_dunno
2587         except:
2588             self.__field_dunno=UINT(**{'sizeinbytes': 1})
2589         return self.__field_dunno.getvalue()
2590 
2591     def __setfield_dunno(self, value):
2592         if isinstance(value,UINT):
2593             self.__field_dunno=value
2594         else:
2595             self.__field_dunno=UINT(value,**{'sizeinbytes': 1})
2596 
2597     def __delfield_dunno(self): del self.__field_dunno
2598 
2599     dunno=property(__getfield_dunno, __setfield_dunno, __delfield_dunno, "Maybe always zero")
2600 
2601     def __getfield_order(self):
2602         return self.__field_order.getvalue()
2603 
2604     def __setfield_order(self, value):
2605         if isinstance(value,UINT):
2606             self.__field_order=value
2607         else:
2608             self.__field_order=UINT(value,**{'sizeinbytes': 1})
2609 
2610     def __delfield_order(self): del self.__field_order
2611 
2612     order=property(__getfield_order, __setfield_order, __delfield_order, "Gets sorted on screen in this order")
2613 
2614     def iscontainer(self):
2615         return True
2616 
2617     def containerelements(self):
2618         yield ('slot', self.__field_slot, None)
2619         yield ('flag', self.__field_flag, "0: Not used, 1: Used")
2620         yield ('todo', self.__field_todo, None)
2621         yield ('pad1', self.__field_pad1, None)
2622         yield ('todo_len', self.__field_todo_len, None)
2623         yield ('priority', self.__field_priority, "0: Normal, 1: Urgent, 2: Done")
2624         yield ('dunno', self.__field_dunno, "Maybe always zero")
2625         yield ('order', self.__field_order, "Gets sorted on screen in this order")
2626 
2627 
2628 
2629 
2630 class todoresponse(BaseProtogenClass):
2631     __fields=['header', 'entry', 'pad']
2632 
2633     def __init__(self, *args, **kwargs):
2634         dict={}
2635         # What was supplied to this function
2636         dict.update(kwargs)
2637         # Parent constructor
2638         super(todoresponse,self).__init__(**dict)
2639         if self.__class__ is todoresponse:
2640             self._update(args,dict)
2641 
2642 
2643     def getfields(self):
2644         return self.__fields
2645 
2646 
2647     def _update(self, args, kwargs):
2648         super(todoresponse,self)._update(args,kwargs)
2649         keys=kwargs.keys()
2650         for key in keys:
2651             if key in self.__fields:
2652                 setattr(self, key, kwargs[key])
2653                 del kwargs[key]
2654         # Were any unrecognized kwargs passed in?
2655         if __debug__:
2656             self._complainaboutunusedargs(todoresponse,kwargs)
2657         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2658         # Make all P fields that haven't already been constructed
2659 
2660 
2661     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2662         'Writes this packet to the supplied buffer'
2663         self._bufferstartoffset=buf.getcurrentoffset()
2664         self.__field_header.writetobuffer(buf)
2665         self.__field_entry.writetobuffer(buf)
2666         self.__field_pad.writetobuffer(buf)
2667         self._bufferendoffset=buf.getcurrentoffset()
2668         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2669 
2670 
2671     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2672         'Reads this packet from the supplied buffer'
2673         self._bufferstartoffset=buf.getcurrentoffset()
2674         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2675         self.__field_header=qcpheader()
2676         self.__field_header.readfrombuffer(buf)
2677         self.__field_entry=todoentry()
2678         self.__field_entry.readfrombuffer(buf)
2679         self.__field_pad=UNKNOWN()
2680         self.__field_pad.readfrombuffer(buf)
2681         self._bufferendoffset=buf.getcurrentoffset()
2682 
2683 
2684     def __getfield_header(self):
2685         return self.__field_header.getvalue()
2686 
2687     def __setfield_header(self, value):
2688         if isinstance(value,qcpheader):
2689             self.__field_header=value
2690         else:
2691             self.__field_header=qcpheader(value,)
2692 
2693     def __delfield_header(self): del self.__field_header
2694 
2695     header=property(__getfield_header, __setfield_header, __delfield_header, None)
2696 
2697     def __getfield_entry(self):
2698         return self.__field_entry.getvalue()
2699 
2700     def __setfield_entry(self, value):
2701         if isinstance(value,todoentry):
2702             self.__field_entry=value
2703         else:
2704             self.__field_entry=todoentry(value,)
2705 
2706     def __delfield_entry(self): del self.__field_entry
2707 
2708     entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
2709 
2710     def __getfield_pad(self):
2711         return self.__field_pad.getvalue()
2712 
2713     def __setfield_pad(self, value):
2714         if isinstance(value,UNKNOWN):
2715             self.__field_pad=value
2716         else:
2717             self.__field_pad=UNKNOWN(value,)
2718 
2719     def __delfield_pad(self): del self.__field_pad
2720 
2721     pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
2722 
2723     def iscontainer(self):
2724         return True
2725 
2726     def containerelements(self):
2727         yield ('header', self.__field_header, None)
2728         yield ('entry', self.__field_entry, None)
2729         yield ('pad', self.__field_pad, None)
2730 
2731 
2732 
2733 
2734 class sanyomediafilenameresponse(BaseProtogenClass):
2735     __fields=['header', 'pad1', 'filename', 'num1', 'pad2', 'num2', 'pad3', 'num5', 'pad4', 'num4', 'pad5', 'num3', 'pad5']
2736 
2737     def __init__(self, *args, **kwargs):
2738         dict={}
2739         # What was supplied to this function
2740         dict.update(kwargs)
2741         # Parent constructor
2742         super(sanyomediafilenameresponse,self).__init__(**dict)
2743         if self.__class__ is sanyomediafilenameresponse:
2744             self._update(args,dict)
2745 
2746 
2747     def getfields(self):
2748         return self.__fields
2749 
2750 
2751     def _update(self, args, kwargs):
2752         super(sanyomediafilenameresponse,self)._update(args,kwargs)
2753         keys=kwargs.keys()
2754         for key in keys:
2755             if key in self.__fields:
2756                 setattr(self, key, kwargs[key])
2757                 del kwargs[key]
2758         # Were any unrecognized kwargs passed in?
2759         if __debug__:
2760             self._complainaboutunusedargs(sanyomediafilenameresponse,kwargs)
2761         if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2762         # Make all P fields that haven't already been constructed
2763 
2764 
2765     def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2766         'Writes this packet to the supplied buffer'
2767         self._bufferstartoffset=buf.getcurrentoffset()
2768         self.__field_header.writetobuffer(buf)
2769         self.__field_pad1.writetobuffer(buf)
2770         self.__field_filename.writetobuffer(buf)
2771         self.__field_num1.writetobuffer(buf)
2772         self.__field_pad2.writetobuffer(buf)
2773         self.__field_num2.writetobuffer(buf)
2774         self.__field_pad3.writetobuffer(buf)
2775         self.__field_num5.writetobuffer(buf)
2776         self.__field_pad4.writetobuffer(buf)
2777         self.__field_num4.writetobuffer(buf)
2778         self.__field_pad5.writetobuffer(buf)
2779         self.__field_num3.writetobuffer(buf)
2780         self.__field_pad5.writetobuffer(buf)
2781         self._bufferendoffset=buf.getcurrentoffset()
2782         if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2783 
2784 
2785     def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2786         'Reads this packet from the supplied buffer'
2787         self._bufferstartoffset=buf.getcurrentoffset()
2788         if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2789         self.__field_header=sanyomediaheader()
2790         self.__field_header.readfrombuffer(buf)
2791         self.__field_pad1=UINT(**{'sizeinbytes': 1})
2792         self.__field_pad1.readfrombuffer(buf)
2793         self.__field_filename=USTRING(**{'sizeinbytes': 154})
2794         self.__field_filename.readfrombuffer(buf)
2795         self.__field_num1=UINT(**{'sizeinbytes': 1})
2796         self.__field_num1.readfrombuffer(buf)
2797         self.__field_pad2=UNKNOWN(**{'sizeinbytes': 1})
2798         self.__field_pad2.readfrombuffer(buf)
2799         self.__field_num2=UINT(**{'sizeinbytes': 1})
2800         self.__field_num2.readfrombuffer(buf)
2801         self.__field_pad3=UNKNOWN(**{'sizeinbytes': 1})
2802         self.__field_pad3.readfrombuffer(buf)
2803         self.__field_num5=UINT(**{'sizeinbytes': 1})
2804         self.__field_num5.readfrombuffer(buf)
2805         self.__field_pad4=UNKNOWN(**{'sizeinbytes': 1})
2806         self.__field_pad4.readfrombuffer(buf)
2807         self.__field_num4=UINT(**{'sizeinbytes': 1})
2808         self.__field_num4.readfrombuffer(buf)
2809         self.__field_pad5=UNKNOWN(**{'sizeinbytes': 1})
2810         self.__field_pad5.readfrombuffer(buf)
2811         self.__field_num3=UINT(**{'sizeinbytes': 1})
2812         self.__field_num3.readfrombuffer(buf)
2813         self.__field_pad5=UNKNOWN(**{'sizeinbytes': 8})
2814         self.__field_pad5.readfrombuffer(buf)
2815         self._bufferendoffset=buf.getcurrentoffset()
2816 
2817 
2818     def __getfield_header(self):
2819         return self.__field_header.getvalue()
2820 
2821     def __setfield_header(self, value):
2822         if isinstance(value,sanyomediaheader):
2823             self.__field_header=value
2824         else:
2825             self.__field_header=sanyomediaheader(value,)
2826 
2827     def __delfield_header(self): del self.__field_header
2828 
2829     header=property(__getfield_header, __setfield_header, __delfield_header, None)
2830 
2831     def __getfield_pad1(self):
2832         return self.__field_pad1.getvalue()
2833 
2834     def __setfield_pad1(self, value):
2835         if isinstance(value,UINT):
2836             self.__field_pad1=value
2837         else:
2838             self.__field_pad1=UINT(value,**{'sizeinbytes': 1})
2839 
2840     def __delfield_pad1(self): del self.__field_pad1
2841 
2842     pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None)
2843 
2844     def __getfield_filename(self):
2845         return self.__field_filename.getvalue()
2846 
2847     def __setfield_filename(self, value):
2848         if isinstance(value,USTRING):
2849             self.__field_filename=value
2850         else:
2851             self.__field_filename=USTRING(value,**{'sizeinbytes': 154})
2852 
2853     def __delfield_filename(self): del self.__field_filename
2854 
2855     filename=property(__getfield_filename, __setfield_filename, __delfield_filename, None)
2856 
2857     def __getfield_num1(self):
2858         return self.__field_num1.getvalue()
2859 
2860     def __setfield_num1(self, value):
2861         if isinstance(value,UINT):
2862             self.__field_num1=value
2863         else:
2864             self.__field_num1=UINT(value,**{'sizeinbytes': 1})
2865 
2866     def __delfield_num1(self): del self.__field_num1
2867 
2868     num1=property(__getfield_num1, __setfield_num1, __delfield_num1, None)
2869 
2870     def __getfield_pad2(self):
2871         return self.__field_pad2.getvalue()
2872 
2873     def __setfield_pad2(self, value):
2874         if isinstance(value,UNKNOWN):
2875             self.__field_pad2=value
2876         else:
2877             self.__field_pad2=UNKNOWN(value,**{'sizeinbytes': 1})
2878 
2879     def __delfield_pad2(self): del self.__field_pad2
2880 
2881     pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None)
2882 
2883     def __getfield_num2(self):
2884         return self.__field_num2.getvalue()
2885 
2886     def __setfield_num2(self, value):
2887         if isinstance(value,UINT):
2888             self.__field_num2=value
2889         else:
2890             self.__field_num2=UINT(value,**{'sizeinbytes': 1})
2891 
2892     def __delfield_num2(self): del self.__field_num2
2893 
2894     num2=property(__getfield_num2, __setfield_num2, __delfield_num2, None)
2895 
2896     def __getfield_pad3(self):
2897         return self.__field_pad3.getvalue()
2898 
2899     def __setfield_pad3(self, value):
2900         if isinstance(value,UNKNOWN):
2901             self.__field_pad3=value
2902         else:
2903             self.__field_pad3=UNKNOWN(value,**{'sizeinbytes': 1})
2904 
2905     def __delfield_pad3(self): del self.__field_pad3
2906 
2907     pad3=property(__getfield_pad3, __setfield_pad3, __delfield_pad3, None)
2908 
2909     def __getfield_num5(self):
2910         return self.__field_num5.getvalue()
2911 
2912     def __setfield_num5(self, value):
2913         if isinstance(value,UINT):
2914             self.__field_num5=value
2915         else:
2916             self.__field_num5=UINT(value,**{'sizeinbytes': 1})
2917 
2918     def __delfield_num5(self): del self.__field_num5
2919 
2920     num5=property(__getfield_num5, __setfield_num5, __delfield_num5, None)
2921 
2922     def __getfield_pad4(self):
2923         return self.__field_pad4.getvalue()
2924 
2925     def __setfield_pad4(self, value):
2926         if isinstance(value,UNKNOWN):
2927             self.__field_pad4=value
2928         else:
2929             self.__field_pad4=UNKNOWN(value,**{'sizeinbytes': 1})
2930 
2931     def __delfield_pad4(self): del self.__field_pad4
2932 
2933     pad4=property(__getfield_pad4, __setfield_pad4, __delfield_pad4, None)
2934 
2935     def __getfield_num4(self):
2936         return self.__field_num4.getvalue()
2937 
2938     def __setfield_num4(self, value):
2939         if isinstance(value,UINT):
2940             self.__field_num4=value
2941         else:
2942             self.__field_num4=UINT(value,**{'sizeinbytes': 1})
2943 
2944     def __delfield_num4(self): del self.__field_num4
2945 
2946     num4=property(__getfield_num4, __setfield_num4, __delfield_num4, None)
2947 
2948     def __getfield_pad5(self):
2949         return self.__field_pad5.getvalue()
2950 
2951     def __setfield_pad5(self, value):
2952         if isinstance(value,UNKNOWN):
2953             self.__field_pad5=value
2954         else:
2955             self.__field_pad5=UNKNOWN(value,**{'sizeinbytes': 1})
2956 
2957     def __delfield_pad5(self): del self.__field_pad5
2958 
2959     pad5=property(__getfield_pad5, __setfield_pad5, __delfield_pad5, None)
2960 
2961     def __getfield_num3(self):
2962         return self.__field_num3.getvalue()
2963 
2964     def __setfield_num3(self, value):
2965         if isinstance(value,UINT):
2966             self.__field_num3=value
2967         else:
2968             self.__field_num3=UINT(value,**{'sizeinbytes': 1})
2969 
2970     def __delfield_num3(self): del self.__field_num3
2971 
2972     num3=property(__getfield_num3, __setfield_num3, __delfield_num3, None)
2973 
2974     def __getfield_pad5(self):
2975         return self.__field_pad5.getvalue()
2976 
2977     def __setfield_pad5(self, value):
2978         if isinstance(value,UNKNOWN):
2979             self.__field_pad5=value
2980         else:
2981             self.__field_pad5=UNKNOWN(value,**{'sizeinbytes': 8})
2982 
2983     def __delfield_pad5(self): del self.__field_pad5
2984 
2985     pad5=property(__getfield_pad5, __setfield_pad5, __delfield_pad5, None)
2986 
2987     def iscontainer(self):
2988         return True
2989 
2990     def containerelements(self):
2991         yield ('header', self.__field_header, None)
2992         yield ('pad1', self.__field_pad1, None)
2993         yield ('filename', self.__field_filename, None)
2994         yield ('num1', self.__field_num1, None)
2995         yield ('pad2', self.__field_pad2, None)
2996         yield ('num2', self.__field_num2, None)
2997         yield ('pad3', self.__field_pad3, None)
2998         yield ('num5', self.__field_num5, None)
2999         yield ('pad4', self.__field_pad4, None)
3000         yield ('num4', self.__field_num4, None)
3001         yield ('pad5', self.__field_pad5, None)
3002         yield ('num3', self.__field_num3, None)
3003         yield ('pad5', self.__field_pad5, None)
3004 
3005 
3006 
3007 
3008