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