def manage_upload(self, file=None, REQUEST=None) :
    """ Zope calls this when the content of the enclosed file changes.
    The 'cells' attribute is updated, but already defined cells are not
    erased, they are saved in the 'all_cells' attribute so if the pdf
    file is reverted, you do not loose the cells definitions.
    """
    if not file or not hasattr(file, "read") :
      raise ValueError ("The pdf form file should not be empty")

    file.seek(0) # file is always valid here
    values = PDFTk().dumpDataFields(file)
    self.cells = {}
    for v in values :
      if v["FieldType"] not in ("Button", "Choice")\
                    or not int(v["FieldFlags"]) & 65536:
        k = v["FieldName"]
        if not self.all_cells.has_key(k) :
          self.cells[k] = ""
        else :
          self.cells[k] = self.all_cells[k]
    self.all_cells.update(self.cells)
    file.seek(0)
    File.manage_upload(self, file, REQUEST)
    if REQUEST:
      message = "Saved changes."
      return self.manage_main(self, REQUEST, manage_tabs_message=message)

 def __setstate__(self, dict):
     mimetype = dict.get('mimetype', None)
     if IMimetype.isImplementedBy(mimetype):
         dict['mimetype'] = str(mimetype)
         dict['binary'] = not not mimetype.binary
     assert(dict.has_key('mimetype'), 'no mimetype in setstate dict')
     File.__setstate__(self, dict)

 def manage_afterAdd( self, item, container ):
     """ For cleaning up as we are removed.
     
     """
     File.manage_afterAdd( self, item, container )
     if IXWFFileReader.isImplementedBy( self.storage_plugin ):
         self.storage_plugin.set_physicalPath( self.getPhysicalPath() )
     XWFCatalogAware.manage_afterAdd( self, item, container )

 def manage_beforeDelete( self, item, container ):
     """ For cleaning up as we are removed.
     
     """
     if IXWFFileReader.isImplementedBy( self.storage_plugin ):
         self.storage_plugin.set_physicalPath( None )
     XWFCatalogAware.manage_beforeDelete( self, item, container )
     File.manage_beforeDelete( self, item, container )

  def __init__ (self, id, title='', pdf_file=''):
    # holds all the cell informations, even those not related to this form
    self.all_cells = PersistentMapping()
    # holds the cells related to this pdf form
    self.cells = PersistentMapping()

    # File constructor will set the file content
    File.__init__(self, id, title, pdf_file)

    def __init__(self, id):
        """ Initialise a new instance of XWFFile.

        """
        self.id = id
        self.initProperties()
        File.__init__(self, id, id, '', '', '')
        self.update_data('', '', 0)

 def manage_afterClone( self, item ):
     """ For configuring the object post copy.
     
     """
     File.manage_afterClone( self, item )
     if IXWFFileReader.isImplementedBy( self.storage_plugin ):
         self.storage_plugin.set_physicalPath( self.getPhysicalPath() )
     XWFCatalogAware.manage_afterClone( self, item )

 def testBlobbableOFSFile(self):
     obj = File('foo', 'Foo', getFile('plone.pdf'), 'application/pdf')
     obj.filename = 'foo.pdf'
     blobbable = IBlobbable(obj)
     target = Blob()
     blobbable.feed(target)
     self.assertEqual(target.open('r').read(),
         getFile('plone.pdf').read())
     self.assertEqual(blobbable.filename(), 'foo.pdf')
     self.assertEqual(blobbable.mimetype(), 'application/pdf')

 def __init__( self, id, storage_plugin ):
     """ Initialise a new instance of XWFPluggableFile.
         
     """
     self.storage_plugin = storage_plugin()
     # we do a quick, fake, init here, and do the actual file
     # later
     File.__init__( self, id, id, '' )
     
     security = getSecurityManager()
     self.manage_addProperty( 'dc_creator', security.getUser().getId(), 'ustring' )
     self.manage_addProperty( 'original_filename', '', 'ustring' )

def _copyFile(f_from, f_to, id, keep_new=False):
  obj_id = id
  if hasattr(f_to,id):
    if keep_new:
      obj_id = 'old_' + id
    else:
      _renameObj (f_to, id, 'new_' + id)
  oldobj = f_from._getOb(id)
  newobj = File(obj_id,oldobj.title,'',oldobj.content_type)
  newobj.size = oldobj.size
  newobj.data = oldobj.data[:]
  f_to._setObject(obj_id, newobj)

 def writeFile(self, path, data):
     basepath = '/'.join(path.split('/')[:-1])
     if basepath:
         self.makeDirectory(basepath)
     filename = path.split('/')[-1]
     if isinstance(filename, unicode):
         filename = filename.encode('utf-8')
     f = File(filename, filename, data)
     if f.getContentType() == 'text/html':
         # otherwise HTTPResponse.setBody assumes latin1 and mangles things
         f.content_type = 'text/html; charset=utf-8'
     container = self.context.unrestrictedTraverse(basepath)
     if filename in container:
         container._delOb(filename)
     container._setOb(filename, f)

 def viewOriginal(self, REQUEST=None, RESPONSE=None, *args, **kwargs) :
   """ publish original pdf """
   pdf = File.index_html(self, REQUEST, RESPONSE, *args, **kwargs)
   RESPONSE.setHeader('Content-Type', 'application/pdf')
   RESPONSE.setHeader('Content-Disposition', 'inline;filename="%s.pdf"'
       % (self.title_or_id()))
   return pdf

 def test_OFSFileLastModified_File(self):
     from OFS.Image import File
     
     dummy = File('dummy', 'Dummy', 'data')
     self.assertEquals(None, ILastModified(dummy)())
     
     timestamp = 987654321.0 # time stamp (in UTC)
     ts = TimeStamp(*time.gmtime(timestamp)[:6]) # corresponding TimeStamp
     
     # equivalent in local time, which is what the last-modified adapter
     # should return
     mod = datetime.datetime.fromtimestamp(timestamp, tzlocal())
     
     dummy._p_jar = FauxDataManager()
     dummy._p_serial = repr(ts)
     self.assertEquals(mod, ILastModified(dummy)())

 def manage_upload( self, file='', REQUEST=None ):
     """ This overrided the manage_upload provided by the File class
     to add a hook for setting the original filename.
     
     """
     LOG('XWFPluggableFile1.1',INFO,str(dir(file)))
     File.manage_upload( self, file )
     
     filename = getattr( file, 'filename', '' )
     filename = convertTextToAscii( removePathsFromFilenames( filename ) )
     
     self.filename = filename
     self.manage_changeProperties(original_filename=filename)\
     
     if REQUEST:
         message="Saved changes."
         return self.manage_main( self, REQUEST, manage_tabs_message=message )

 def index_html( self, REQUEST, RESPONSE ):
     """ Extends the file index_html to set the download filename.
     
     """
     filename = self.get_filename()
     REQUEST.RESPONSE.setHeader( 'Content-Disposition', 
                                'inline; filename="%s"' % filename )
     
     return File.index_html( self, REQUEST, RESPONSE )

    def index_html(self, REQUEST, RESPONSE):
        """ Override for File.index_html
        """
        # this is to deal with an acquisition issue, where
        # the context gets lost when .data is called
        bfd = self.get_baseFilesDir()
        if self._base_files_dir != bfd:
            self._base_files_dir = bfd

        return File.index_html(self, REQUEST, RESPONSE)

 def writeFile(self, path, data):
     basepath = '/'.join(path.split('/')[:-1])
     if basepath:
         self.makeDirectory(basepath)
     filename = path.split('/')[-1]
     if isinstance(filename, unicode):
         filename = filename.encode('utf-8')
     f = File(filename, filename, data)
     ct = f.getContentType()
     if ct.startswith('text/') or ct == 'application/javascript':
         # otherwise HTTPResponse.setBody assumes latin1 and mangles things
         f.content_type = ct + '; charset=utf-8'
     container = self.context.unrestrictedTraverse(basepath)
     if filename in container:
         container._delOb(filename)
         event = PloneResourceModifiedEvent
     else:
         event = PloneResourceCreatedEvent
     container._setOb(filename, f)
     obj = container._getOb(filename)
     notify(event(obj))

def loadFile(name,dir='skins/zwiki'):
    """
    Load and return a File from the filesystem, or None.
    """
    filepath = os.path.join(abszwikipath(dir),name)
    if os.path.exists(filepath):
        f = None
        try:
            try:
                f = open(filepath,'rb')
                data = f.read()
                mtime = os.path.getmtime(filepath)
                file = File(name,'',data)
                # bug workaround: bobobase_modification_time will otherwise be current time
                file.bobobase_modification_time = lambda:mtime
                return file
            except IOError:
                return None
        finally:
            if f: f.close()
    else:
        return None

    def test_uploadFile(self):
        file = File('foo', 'Foo', getFile('plone.pdf'), 'application/pdf')
        file.filename = 'foo.pdf'

        myUpload = makeFileUpload(file, 'test.gif')
        myUpload.method = 'GET'
        view = VNCCollabUtilView(self.portal, myUpload)
        self.assertRaises(Exception, lambda:  view.uploadFile(myUpload))

        myUpload = makeFileUpload(file, 'test.gif')
        myUpload.method = 'POST'
        myUpload.form = {}
        headers, output, request = makeResponse(myUpload)
        view = VNCCollabUtilView(self.portal, request)
        result = view.uploadFile(file)
        self.assertEqual(result, 'http://nohost/plone/foo.pdf/edit')

        myUpload = makeFileUpload(file, 'test.gif')
        myUpload.method = 'POST'
        myUpload.form = {'ajax_call': True}
        headers, output, request = makeResponse(myUpload)
        view = VNCCollabUtilView(self.portal, request)
        result = view.uploadFile(file)
        self.assertEqual(result, 'http://nohost/plone/foo.pdf-1/edit')

    def __init__(self, id, title, properties={}):
        """ZAnnotation constructor"""

        # Initialize properties
        if properties:
            self._doUpdate(properties)
        else:
            self.type = None
            self.annotates = None
            self.context = None
            self.language = None
            self.creator = None
            self.created = None
            self.date = None
            self.body = None
            self.root = None
            self.inreplyto = None
            self.encoding = ''

        return File.__init__(self, id, title,'','text/html')