blobbases.py

   1 # -*- coding: utf-8 -*-
   2 ##############################################################################
   3 # This module is based on OFS.Image originaly copyrighted as:
   4 #
   5 # Copyright (c) 2002 Zope Corporation and Contributors. All Rights Reserved.
   6 #
   7 # This software is subject to the provisions of the Zope Public License,
   8 # Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
   9 # THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
  10 # WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  11 # WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
  12 # FOR A PARTICULAR PURPOSE
  13 #
  14 ##############################################################################
  15 """Image object
  16
  17 """
  18
  19 from cgi import escape
  20 from cStringIO import StringIO
  21 from mimetools import choose_boundary
  22 import struct
  23
  24 from AccessControl.Permissions import change_images_and_files
  25 from AccessControl.Permissions import view_management_screens
  26 from AccessControl.Permissions import view as View
  27 from AccessControl.Permissions import ftp_access
  28 from AccessControl.Permissions import delete_objects
  29 from AccessControl.Role import RoleManager
  30 from AccessControl.SecurityInfo import ClassSecurityInfo
  31 from Acquisition import Implicit
  32 from App.class_init import InitializeClass
  33 from App.special_dtml import DTMLFile
  34 from DateTime.DateTime import DateTime
  35 from Persistence import Persistent
  36 from webdav.common import rfc1123_date
  37 from webdav.interfaces import IWriteLock
  38 from webdav.Lockable import ResourceLockedError
  39 from ZPublisher import HTTPRangeSupport
  40 from ZPublisher.HTTPRequest import FileUpload
  41 from ZPublisher.Iterators import filestream_iterator
  42 from zExceptions import Redirect
  43 from zope.contenttype import guess_content_type
  44 from zope.interface import implementedBy
  45 from zope.interface import implements
  46
  47 from OFS.Cache import Cacheable
  48 from OFS.PropertyManager import PropertyManager
  49 from OFS.SimpleItem import Item_w__name__
  50
  51 from zope.event import notify
  52 from zope.lifecycleevent import ObjectModifiedEvent
  53 from zope.lifecycleevent import ObjectCreatedEvent
  54
  55 from ZODB.blob import Blob
  56
  57 CHUNK_SIZE = 1 << 16
  58
  59
  60 manage_addFileForm = DTMLFile('dtml/imageAdd',
  61                               globals(),
  62                               Kind='File',
  63                               kind='file',
  64                              )
  65 def manage_addFile(self, id, file='', title='', precondition='',
  66                    content_type='', REQUEST=None):
  67     """Add a new File object.
  68
  69     Creates a new File object 'id' with the contents of 'file'"""
  70
  71     id = str(id)
  72     title = str(title)
  73     content_type = str(content_type)
  74     precondition = str(precondition)
  75
  76     id, title = cookId(id, title, file)
  77
  78     self=self.this()
  79     self._setObject(id, File(id,title,file,content_type, precondition))
  80
  81     newFile = self._getOb(id)
  82     notify(ObjectCreatedEvent(newFile))
  83
  84     if REQUEST is not None:
  85         REQUEST['RESPONSE'].redirect(self.absolute_url()+'/manage_main')
  86
  87
  88 class File(Persistent, Implicit, PropertyManager,
  89            RoleManager, Item_w__name__, Cacheable):
  90     """A File object is a content object for arbitrary files."""
  91
  92     implements(implementedBy(Persistent),
  93                implementedBy(Implicit),
  94                implementedBy(PropertyManager),
  95                implementedBy(RoleManager),
  96                implementedBy(Item_w__name__),
  97                implementedBy(Cacheable),
  98                IWriteLock,
  99                HTTPRangeSupport.HTTPRangeInterface,
 100               )
 101     meta_type='Blob File'
 102
 103     security = ClassSecurityInfo()
 104     security.declareObjectProtected(View)
 105
 106     precondition=''
 107     size=None
 108
 109     manage_editForm  =DTMLFile('dtml/fileEdit',globals(),
 110                                Kind='File',kind='file')
 111     manage_editForm._setName('manage_editForm')
 112
 113     security.declareProtected(view_management_screens, 'manage')
 114     security.declareProtected(view_management_screens, 'manage_main')
 115     manage=manage_main=manage_editForm
 116     manage_uploadForm=manage_editForm
 117
 118     manage_options=(
 119         (
 120         {'label':'Edit', 'action':'manage_main',
 121          'help':('OFSP','File_Edit.stx')},
 122         {'label':'View', 'action':'',
 123          'help':('OFSP','File_View.stx')},
 124         )
 125         + PropertyManager.manage_options
 126         + RoleManager.manage_options
 127         + Item_w__name__.manage_options
 128         + Cacheable.manage_options
 129         )
 130
 131     _properties=({'id':'title', 'type': 'string'},
 132                  {'id':'content_type', 'type':'string'},
 133                  )
 134
 135     def __init__(self, id, title, file, content_type='', precondition=''):
 136         self.__name__=id
 137         self.title=title
 138         self.precondition=precondition
 139         self.uploaded_filename = cookId('', '', file)[0]
 140         self.bdata = Blob()
 141
 142         content_type=self._get_content_type(file, id, content_type)
 143         self.update_data(file, content_type)
 144
 145     security.declarePrivate('save')
 146     def save(self, file):
 147         bf = self.bdata.open('w')
 148         bf.write(file.read())
 149         self.size = bf.tell()
 150         bf.close()
 151
 152     security.declarePrivate('open')
 153     def open(self, mode='r'):
 154         bf = self.bdata.open(mode)
 155         return bf
 156
 157     security.declarePrivate('updateSize')
 158     def updateSize(self, size=None):
 159         if size is None :
 160             bf = self.open('r')
 161             bf.seek(0,2)
 162             self.size = bf.tell()
 163             bf.close()
 164         else :
 165             self.size = size
 166
 167     def _getLegacyData(self) :
 168         warn("Accessing 'data' attribute may be inefficient with "
 169              "this blob based file. You should refactor your product "
 170              "by accessing data like: "
 171              "f = self.open('r') "
 172              "data = f.read()",
 173             DeprecationWarning, stacklevel=2)
 174         f = self.open()
 175         data = f.read()
 176         f.close()
 177         return data
 178
 179     def _setLegacyData(self, data) :
 180         warn("Accessing 'data' attribute may be inefficient with "
 181              "this blob based file. You should refactor your product "
 182              "by accessing data like: "
 183              "f = self.save(data)",
 184             DeprecationWarning, stacklevel=2)
 185         if isinstance(data, str) :
 186             sio = StringIO()
 187             sio.write(data)
 188             sio.seek(0)
 189             data = sio
 190         self.save(data)
 191
 192     data = property(_getLegacyData, _setLegacyData,
 193                     "Data Legacy attribute to ensure compatibility "
 194                     "with derived classes that access data by this way.")
 195
 196     def id(self):
 197         return self.__name__
 198
 199     def _if_modified_since_request_handler(self, REQUEST, RESPONSE):
 200         # HTTP If-Modified-Since header handling: return True if
 201         # we can handle this request by returning a 304 response
 202         header=REQUEST.get_header('If-Modified-Since', None)
 203         if header is not None:
 204             header=header.split( ';')[0]
 205             # Some proxies seem to send invalid date strings for this
 206             # header. If the date string is not valid, we ignore it
 207             # rather than raise an error to be generally consistent
 208             # with common servers such as Apache (which can usually
 209             # understand the screwy date string as a lucky side effect
 210             # of the way they parse it).
 211             # This happens to be what RFC2616 tells us to do in the face of an
 212             # invalid date.
 213             try:    mod_since=long(DateTime(header).timeTime())
 214             except: mod_since=None
 215             if mod_since is not None:
 216                 if self._p_mtime:
 217                     last_mod = long(self._p_mtime)
 218                 else:
 219                     last_mod = long(0)
 220                 if last_mod > 0 and last_mod <= mod_since:
 221                     RESPONSE.setHeader('Last-Modified',
 222                                        rfc1123_date(self._p_mtime))
 223                     RESPONSE.setHeader('Content-Type', self.content_type)
 224                     RESPONSE.setHeader('Accept-Ranges', 'bytes')
 225                     RESPONSE.setStatus(304)
 226                     return True
 227
 228     def _range_request_handler(self, REQUEST, RESPONSE):
 229         # HTTP Range header handling: return True if we've served a range
 230         # chunk out of our data.
 231         range = REQUEST.get_header('Range', None)
 232         request_range = REQUEST.get_header('Request-Range', None)
 233         if request_range is not None:
 234             # Netscape 2 through 4 and MSIE 3 implement a draft version
 235             # Later on, we need to serve a different mime-type as well.
 236             range = request_range
 237         if_range = REQUEST.get_header('If-Range', None)
 238         if range is not None:
 239             ranges = HTTPRangeSupport.parseRange(range)
 240
 241             if if_range is not None:
 242                 # Only send ranges if the data isn't modified, otherwise send
 243                 # the whole object. Support both ETags and Last-Modified dates!
 244                 if len(if_range) > 1 and if_range[:2] == 'ts':
 245                     # ETag:
 246                     if if_range != self.http__etag():
 247                         # Modified, so send a normal response. We delete
 248                         # the ranges, which causes us to skip to the 200
 249                         # response.
 250                         ranges = None
 251                 else:
 252                     # Date
 253                     date = if_range.split( ';')[0]
 254                     try: mod_since=long(DateTime(date).timeTime())
 255                     except: mod_since=None
 256                     if mod_since is not None:
 257                         if self._p_mtime:
 258                             last_mod = long(self._p_mtime)
 259                         else:
 260                             last_mod = long(0)
 261                         if last_mod > mod_since:
 262                             # Modified, so send a normal response. We delete
 263                             # the ranges, which causes us to skip to the 200
 264                             # response.
 265                             ranges = None
 266
 267             if ranges:
 268                 # Search for satisfiable ranges.
 269                 satisfiable = 0
 270                 for start, end in ranges:
 271                     if start < self.size:
 272                         satisfiable = 1
 273                         break
 274
 275                 if not satisfiable:
 276                     RESPONSE.setHeader('Content-Range',
 277                         'bytes */%d' % self.size)
 278                     RESPONSE.setHeader('Accept-Ranges', 'bytes')
 279                     RESPONSE.setHeader('Last-Modified',
 280                         rfc1123_date(self._p_mtime))
 281                     RESPONSE.setHeader('Content-Type', self.content_type)
 282                     RESPONSE.setHeader('Content-Length', self.size)
 283                     RESPONSE.setStatus(416)
 284                     return True
 285
 286                 ranges = HTTPRangeSupport.expandRanges(ranges, self.size)
 287
 288                 if len(ranges) == 1:
 289                     # Easy case, set extra header and return partial set.
 290                     start, end = ranges[0]
 291                     size = end - start
 292
 293                     RESPONSE.setHeader('Last-Modified',
 294                         rfc1123_date(self._p_mtime))
 295                     RESPONSE.setHeader('Content-Type', self.content_type)
 296                     RESPONSE.setHeader('Content-Length', size)
 297                     RESPONSE.setHeader('Accept-Ranges', 'bytes')
 298                     RESPONSE.setHeader('Content-Range',
 299                         'bytes %d-%d/%d' % (start, end - 1, self.size))
 300                     RESPONSE.setStatus(206) # Partial content
 301
 302                     bf = self.open('r')
 303                     bf.seek(start)
 304                     RESPONSE.write(bf.read(size))
 305                     bf.close()
 306                     return True
 307
 308                 else:
 309                     boundary = choose_boundary()
 310
 311                     # Calculate the content length
 312                     size = (8 + len(boundary) + # End marker length
 313                         len(ranges) * (         # Constant lenght per set
 314                             49 + len(boundary) + len(self.content_type) +
 315                             len('%d' % self.size)))
 316                     for start, end in ranges:
 317                         # Variable length per set
 318                         size = (size + len('%d%d' % (start, end - 1)) +
 319                             end - start)
 320
 321
 322                     # Some clients implement an earlier draft of the spec, they
 323                     # will only accept x-byteranges.
 324                     draftprefix = (request_range is not None) and 'x-' or ''
 325
 326                     RESPONSE.setHeader('Content-Length', size)
 327                     RESPONSE.setHeader('Accept-Ranges', 'bytes')
 328                     RESPONSE.setHeader('Last-Modified',
 329                         rfc1123_date(self._p_mtime))
 330                     RESPONSE.setHeader('Content-Type',
 331                         'multipart/%sbyteranges; boundary=%s' % (
 332                             draftprefix, boundary))
 333                     RESPONSE.setStatus(206) # Partial content
 334
 335
 336                     bf = self.open('r')
 337 #                    data = self.data
 338 #                    # The Pdata map allows us to jump into the Pdata chain
 339 #                    # arbitrarily during out-of-order range searching.
 340 #                    pdata_map = {}
 341 #                    pdata_map[0] = data
 342
 343                     for start, end in ranges:
 344                         RESPONSE.write('\r\n--%s\r\n' % boundary)
 345                         RESPONSE.write('Content-Type: %s\r\n' %
 346                             self.content_type)
 347                         RESPONSE.write(
 348                             'Content-Range: bytes %d-%d/%d\r\n\r\n' % (
 349                                 start, end - 1, self.size))
 350
 351
 352                         size = end - start
 353                         bf.seek(start)
 354                         RESPONSE.write(bf.read(size))
 355
 356                     bf.close()
 357
 358                     RESPONSE.write('\r\n--%s--\r\n' % boundary)
 359                     return True
 360
 361     security.declareProtected(View, 'index_html')
 362     def index_html(self, REQUEST, RESPONSE):
 363         """
 364         The default view of the contents of a File or Image.
 365
 366         Returns the contents of the file or image.  Also, sets the
 367         Content-Type HTTP header to the objects content type.
 368         """
 369
 370         if self._if_modified_since_request_handler(REQUEST, RESPONSE):
 371             # we were able to handle this by returning a 304
 372             # unfortunately, because the HTTP cache manager uses the cache
 373             # API, and because 304 responses are required to carry the Expires
 374             # header for HTTP/1.1, we need to call ZCacheable_set here.
 375             # This is nonsensical for caches other than the HTTP cache manager
 376             # unfortunately.
 377             self.ZCacheable_set(None)
 378             return ''
 379
 380         if self.precondition and hasattr(self, str(self.precondition)):
 381             # Grab whatever precondition was defined and then
 382             # execute it.  The precondition will raise an exception
 383             # if something violates its terms.
 384             c=getattr(self, str(self.precondition))
 385             if hasattr(c,'isDocTemp') and c.isDocTemp:
 386                 c(REQUEST['PARENTS'][1],REQUEST)
 387             else:
 388                 c()
 389
 390         if self._range_request_handler(REQUEST, RESPONSE):
 391             # we served a chunk of content in response to a range request.
 392             return ''
 393
 394         RESPONSE.setHeader('Last-Modified', rfc1123_date(self._p_mtime))
 395         RESPONSE.setHeader('Content-Type', self.content_type)
 396         RESPONSE.setHeader('Content-Length', self.size)
 397         RESPONSE.setHeader('Accept-Ranges', 'bytes')
 398
 399         if self.ZCacheable_isCachingEnabled():
 400             result = self.ZCacheable_get(default=None)
 401             if result is not None:
 402                 # We will always get None from RAMCacheManager and HTTP
 403                 # Accelerated Cache Manager but we will get
 404                 # something implementing the IStreamIterator interface
 405                 # from a "FileCacheManager"
 406                 return result
 407
 408         self.ZCacheable_set(None)
 409
 410         bf = self.open('r')
 411         chunk = bf.read(CHUNK_SIZE)
 412         while chunk :
 413             RESPONSE.write(chunk)
 414             chunk = bf.read(CHUNK_SIZE)
 415         bf.close()
 416         return ''
 417
 418     security.declareProtected(View, 'view_image_or_file')
 419     def view_image_or_file(self, URL1):
 420         """
 421         The default view of the contents of the File or Image.
 422         """
 423         raise Redirect, URL1
 424
 425     security.declareProtected(View, 'PrincipiaSearchSource')
 426     def PrincipiaSearchSource(self):
 427         """ Allow file objects to be searched.
 428         """
 429         if self.content_type.startswith('text/'):
 430             bf = self.open('r')
 431             data = bf.read()
 432             bf.close()
 433             return data
 434         return ''
 435
 436     security.declarePrivate('update_data')
 437     def update_data(self, file, content_type=None):
 438         if isinstance(file, unicode):
 439             raise TypeError('Data can only be str or file-like.  '
 440                             'Unicode objects are expressly forbidden.')
 441         elif isinstance(file, str) :
 442             sio = StringIO()
 443             sio.write(file)
 444             sio.seek(0)
 445             file = sio
 446
 447         if content_type is not None: self.content_type=content_type
 448         self.save(file)
 449         self.ZCacheable_invalidate()
 450         self.ZCacheable_set(None)
 451         self.http__refreshEtag()
 452
 453     security.declareProtected(change_images_and_files, 'manage_edit')
 454     def manage_edit(self, title, content_type, precondition='',
 455                     filedata=None, REQUEST=None):
 456         """
 457         Changes the title and content type attributes of the File or Image.
 458         """
 459         if self.wl_isLocked():
 460             raise ResourceLockedError, "File is locked via WebDAV"
 461
 462         self.title=str(title)
 463         self.content_type=str(content_type)
 464         if precondition: self.precondition=str(precondition)
 465         elif self.precondition: del self.precondition
 466         if filedata is not None:
 467             self.update_data(filedata, content_type)
 468         else:
 469             self.ZCacheable_invalidate()
 470
 471         notify(ObjectModifiedEvent(self))
 472
 473         if REQUEST:
 474             message="Saved changes."
 475             return self.manage_main(self,REQUEST,manage_tabs_message=message)
 476
 477     security.declareProtected(change_images_and_files, 'manage_upload')
 478     def manage_upload(self,file='',REQUEST=None):
 479         """
 480         Replaces the current contents of the File or Image object with file.
 481
 482         The file or images contents are replaced with the contents of 'file'.
 483         """
 484         if self.wl_isLocked():
 485             raise ResourceLockedError, "File is locked via WebDAV"
 486
 487         content_type=self._get_content_type(file, self.__name__,
 488                                             'application/octet-stream')
 489         self.update_data(file, content_type)
 490         notify(ObjectModifiedEvent(self))
 491
 492         if REQUEST:
 493             message="Saved changes."
 494             return self.manage_main(self,REQUEST,manage_tabs_message=message)
 495
 496     def _get_content_type(self, file, id, content_type=None):
 497         headers=getattr(file, 'headers', None)
 498         if headers and headers.has_key('content-type'):
 499             content_type=headers['content-type']
 500         else:
 501             name = getattr(file, 'filename', self.uploaded_filename) or id
 502             content_type, enc=guess_content_type(name, '', content_type)
 503         return content_type
 504
 505     security.declareProtected(delete_objects, 'DELETE')
 506
 507     security.declareProtected(change_images_and_files, 'PUT')
 508     def PUT(self, REQUEST, RESPONSE):
 509         """Handle HTTP PUT requests"""
 510         self.dav__init(REQUEST, RESPONSE)
 511         self.dav__simpleifhandler(REQUEST, RESPONSE, refresh=1)
 512         type=REQUEST.get_header('content-type', None)
 513
 514         file=REQUEST['BODYFILE']
 515
 516         content_type = self._get_content_type(file, self.__name__,
 517                                               type or self.content_type)
 518         self.update_data(file, content_type)
 519
 520         RESPONSE.setStatus(204)
 521         return RESPONSE
 522
 523     security.declareProtected(View, 'get_size')
 524     def get_size(self):
 525         """Get the size of a file or image.
 526
 527         Returns the size of the file or image.
 528         """
 529         size=self.size
 530         if size is None :
 531             bf = self.open('r')
 532             bf.seek(0,2)
 533             self.size = size = bf.tell()
 534             bf.close()
 535         return size
 536
 537     # deprecated; use get_size!
 538     getSize=get_size
 539
 540     security.declareProtected(View, 'getContentType')
 541     def getContentType(self):
 542         """Get the content type of a file or image.
 543
 544         Returns the content type (MIME type) of a file or image.
 545         """
 546         return self.content_type
 547
 548
 549     def __str__(self): return str(self.data)
 550     def __len__(self): return 1
 551
 552     security.declareProtected(ftp_access, 'manage_FTPstat')
 553     security.declareProtected(ftp_access, 'manage_FTPlist')
 554
 555     security.declareProtected(ftp_access, 'manage_FTPget')
 556     def manage_FTPget(self):
 557         """Return body for ftp."""
 558         RESPONSE = self.REQUEST.RESPONSE
 559
 560         if self.ZCacheable_isCachingEnabled():
 561             result = self.ZCacheable_get(default=None)
 562             if result is not None:
 563                 # We will always get None from RAMCacheManager but we will get
 564                 # something implementing the IStreamIterator interface
 565                 # from FileCacheManager.
 566                 # the content-length is required here by HTTPResponse, even
 567                 # though FTP doesn't use it.
 568                 RESPONSE.setHeader('Content-Length', self.size)
 569                 return result
 570
 571         bf = self.open('r')
 572         data = bf.read()
 573         bf.close()
 574         RESPONSE.setBase(None)
 575         return data
 576
 577 manage_addImageForm=DTMLFile('dtml/imageAdd',globals(),
 578                              Kind='Image',kind='image')
 579 def manage_addImage(self, id, file, title='', precondition='', content_type='',
 580                     REQUEST=None):
 581     """
 582     Add a new Image object.
 583
 584     Creates a new Image object 'id' with the contents of 'file'.
 585     """
 586
 587     id=str(id)
 588     title=str(title)
 589     content_type=str(content_type)
 590     precondition=str(precondition)
 591
 592     id, title = cookId(id, title, file)
 593
 594     self=self.this()
 595     self._setObject(id, Image(id,title,file,content_type, precondition))
 596
 597     newFile = self._getOb(id)
 598     notify(ObjectCreatedEvent(newFile))
 599
 600     if REQUEST is not None:
 601         try:    url=self.DestinationURL()
 602         except: url=REQUEST['URL1']
 603         REQUEST.RESPONSE.redirect('%s/manage_main' % url)
 604     return id
 605
 606
 607 def getImageInfo(file):
 608     height = -1
 609     width = -1
 610     content_type = ''
 611
 612     # handle GIFs
 613     data = file.read(24)
 614     size = len(data)
 615     if (size >= 10) and data[:6] in ('GIF87a', 'GIF89a'):
 616         # Check to see if content_type is correct
 617         content_type = 'image/gif'
 618         w, h = struct.unpack("<HH", data[6:10])
 619         width = int(w)
 620         height = int(h)
 621
 622     # See PNG v1.2 spec (http://www.cdrom.com/pub/png/spec/)
 623     # Bytes 0-7 are below, 4-byte chunk length, then 'IHDR'
 624     # and finally the 4-byte width, height
 625     elif ((size >= 24) and (data[:8] == '\211PNG\r\n\032\n')
 626           and (data[12:16] == 'IHDR')):
 627         content_type = 'image/png'
 628         w, h = struct.unpack(">LL", data[16:24])
 629         width = int(w)
 630         height = int(h)
 631
 632     # Maybe this is for an older PNG version.
 633     elif (size >= 16) and (data[:8] == '\211PNG\r\n\032\n'):
 634         # Check to see if we have the right content type
 635         content_type = 'image/png'
 636         w, h = struct.unpack(">LL", data[8:16])
 637         width = int(w)
 638         height = int(h)
 639
 640     # handle JPEGs
 641     elif (size >= 2) and (data[:2] == '\377\330'):
 642         content_type = 'image/jpeg'
 643         jpeg = file
 644         jpeg.seek(0)
 645         jpeg.read(2)
 646         b = jpeg.read(1)
 647         try:
 648             while (b and ord(b) != 0xDA):
 649                 while (ord(b) != 0xFF): b = jpeg.read(1)
 650                 while (ord(b) == 0xFF): b = jpeg.read(1)
 651                 if (ord(b) >= 0xC0 and ord(b) <= 0xC3):
 652                     jpeg.read(3)
 653                     h, w = struct.unpack(">HH", jpeg.read(4))
 654                     break
 655                 else:
 656                     jpeg.read(int(struct.unpack(">H", jpeg.read(2))[0])-2)
 657                 b = jpeg.read(1)
 658             width = int(w)
 659             height = int(h)
 660         except: pass
 661
 662     return content_type, width, height
 663
 664
 665 class Image(File):
 666     """Image objects can be GIF, PNG or JPEG and have the same methods
 667     as File objects.  Images also have a string representation that
 668     renders an HTML 'IMG' tag.
 669     """
 670     meta_type='Blob Image'
 671
 672     security = ClassSecurityInfo()
 673     security.declareObjectProtected(View)
 674
 675     alt=''
 676     height=''
 677     width=''
 678
 679     # FIXME: Redundant, already in base class
 680     security.declareProtected(change_images_and_files, 'manage_edit')
 681     security.declareProtected(change_images_and_files, 'manage_upload')
 682     security.declareProtected(change_images_and_files, 'PUT')
 683     security.declareProtected(View, 'index_html')
 684     security.declareProtected(View, 'get_size')
 685     security.declareProtected(View, 'getContentType')
 686     security.declareProtected(ftp_access, 'manage_FTPstat')
 687     security.declareProtected(ftp_access, 'manage_FTPlist')
 688     security.declareProtected(ftp_access, 'manage_FTPget')
 689     security.declareProtected(delete_objects, 'DELETE')
 690
 691     _properties=({'id':'title', 'type': 'string'},
 692                  {'id':'alt', 'type':'string'},
 693                  {'id':'content_type', 'type':'string','mode':'w'},
 694                  {'id':'height', 'type':'string'},
 695                  {'id':'width', 'type':'string'},
 696                  )
 697
 698     manage_options=(
 699         ({'label':'Edit', 'action':'manage_main',
 700          'help':('OFSP','Image_Edit.stx')},
 701          {'label':'View', 'action':'view_image_or_file',
 702          'help':('OFSP','Image_View.stx')},)
 703         + PropertyManager.manage_options
 704         + RoleManager.manage_options
 705         + Item_w__name__.manage_options
 706         + Cacheable.manage_options
 707         )
 708
 709     manage_editForm  =DTMLFile('dtml/imageEdit',globals(),
 710                                Kind='Image',kind='image')
 711     manage_editForm._setName('manage_editForm')
 712
 713     security.declareProtected(View, 'view_image_or_file')
 714     view_image_or_file =DTMLFile('dtml/imageView',globals())
 715
 716     security.declareProtected(view_management_screens, 'manage')
 717     security.declareProtected(view_management_screens, 'manage_main')
 718     manage=manage_main=manage_editForm
 719     manage_uploadForm=manage_editForm
 720
 721     security.declarePrivate('update_data')
 722     def update_data(self, file, content_type=None):
 723         super(Image, self).update_data(file, content_type)
 724         self.updateFormat(size=self.size, content_type=content_type)
 725
 726     security.declarePrivate('updateFormat')
 727     def updateFormat(self, size=None, dimensions=None, content_type=None):
 728         self.updateSize(size=size)
 729
 730         if dimensions is None or content_type is None :
 731             bf = self.open('r')
 732             ct, width, height = getImageInfo(bf)
 733             bf.close()
 734             if ct:
 735                 content_type = ct
 736             if width >= 0 and height >= 0:
 737                 self.width = width
 738                 self.height = height
 739
 740             # Now we should have the correct content type, or still None
 741             if content_type is not None: self.content_type = content_type
 742         else :
 743             self.width, self.height = dimensions
 744             self.content_type = content_type
 745
 746     def __str__(self):
 747         return self.tag()
 748
 749     security.declareProtected(View, 'tag')
 750     def tag(self, height=None, width=None, alt=None,
 751             scale=0, xscale=0, yscale=0, css_class=None, title=None, **args):
 752         """
 753         Generate an HTML IMG tag for this image, with customization.
 754         Arguments to self.tag() can be any valid attributes of an IMG tag.
 755         'src' will always be an absolute pathname, to prevent redundant
 756         downloading of images. Defaults are applied intelligently for
 757         'height', 'width', and 'alt'. If specified, the 'scale', 'xscale',
 758         and 'yscale' keyword arguments will be used to automatically adjust
 759         the output height and width values of the image tag.
 760
 761         Since 'class' is a Python reserved word, it cannot be passed in
 762         directly in keyword arguments which is a problem if you are
 763         trying to use 'tag()' to include a CSS class. The tag() method
 764         will accept a 'css_class' argument that will be converted to
 765         'class' in the output tag to work around this.
 766         """
 767         if height is None: height=self.height
 768         if width is None:  width=self.width
 769
 770         # Auto-scaling support
 771         xdelta = xscale or scale
 772         ydelta = yscale or scale
 773
 774         if xdelta and width:
 775             width =  str(int(round(int(width) * xdelta)))
 776         if ydelta and height:
 777             height = str(int(round(int(height) * ydelta)))
 778
 779         result='<img src="%s"' % (self.absolute_url())
 780
 781         if alt is None:
 782             alt=getattr(self, 'alt', '')
 783         result = '%s alt="%s"' % (result, escape(alt, 1))
 784
 785         if title is None:
 786             title=getattr(self, 'title', '')
 787         result = '%s title="%s"' % (result, escape(title, 1))
 788
 789         if height:
 790             result = '%s height="%s"' % (result, height)
 791
 792         if width:
 793             result = '%s width="%s"' % (result, width)
 794
 795         # Omitting 'border' attribute (Collector #1557)
 796 #        if not 'border' in [ x.lower() for x in  args.keys()]:
 797 #            result = '%s border="0"' % result
 798
 799         if css_class is not None:
 800             result = '%s class="%s"' % (result, css_class)
 801
 802         for key in args.keys():
 803             value = args.get(key)
 804             if value:
 805                 result = '%s %s="%s"' % (result, key, value)
 806
 807         return '%s />' % result
 808
 809
 810 def cookId(id, title, file):
 811     if not id and hasattr(file,'filename'):
 812         filename=file.filename
 813         title=title or filename
 814         id=filename[max(filename.rfind('/'),
 815                         filename.rfind('\\'),
 816                         filename.rfind(':'),
 817                         )+1:]
 818     return id, title