"""ExtImage product module."""
###############################################################################
#
# Copyright (c) 2001 Gregor Heine <mac.gregor@gmx.de>. All rights reserved.
# ExtFile Home: http://www.zope.org/Members/MacGregor/ExtFile/index_html
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# 1. Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# 2. Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
# 3. The name of the author may not be used to endorse or promote products
# derived from this software without specific prior written permission
#
# Disclaimer
#
# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
# In accordance with the license provided for by the software upon
# which some of the source code has been derived or used, the following
# acknowledgement is hereby provided :
#
# "This product includes software developed by Digital Creations
# for use in the Z Object Publishing Environment
# (http://www.zope.org/)."
#
###############################################################################
__doc__ = """ExtImage product module.
The ExtImage-Product works like the Zope Image-product, but stores the
uploaded image externally in a repository-direcory. It creates a preview
of the image (requires PIL)."""
__version__='1.5.4'
import Globals
from Products.ExtFile.ExtFile import *
from Globals import HTMLFile, MessageDialog, InitializeClass
from AccessControl import ClassSecurityInfo
from webdav.Lockable import ResourceLockedError
import urllib, os, string, types
from os.path import join, isfile
from tempfile import TemporaryFile
from webdav.WriteLockInterface import WriteLockInterface
from IExtFile import IExtImage
from zLOG import *
_SUBSYS = 'ExtImage'
_debug = 0
try: from zExceptions import Redirect
except ImportError: Redirect = 'Redirect'
from Config import REPOSITORY_UMASK
NO_PREVIEW = 0
GENERATE = 1
UPLOAD_NORESIZE = 2
UPLOAD_RESIZE = 3
manage_addExtImageForm = HTMLFile('dtml/extImageAdd', globals())
def manage_addExtImage(self, id='', title='', descr='', file='', preview='',
content_type='', create_prev=0, maxx='', maxy='',
ratio=0, permission_check=0, redirect_default_view=0, REQUEST=None):
""" Add an ExtImage to a folder. """
if not id and getattr(file, 'filename', None) is not None:
# generate id from filename and make sure, it has no 'bad' chars
id = file.filename
id = id[max(string.rfind(id,'/'),
string.rfind(id,'\\'),
string.rfind(id,':'))+1:]
title = title or id
id = normalize_id(id)
tempExtImage = ExtImage(id, title, descr, permission_check, redirect_default_view)
self._setObject(id, tempExtImage)
if file != '':
self._getOb(id).manage_file_upload(file, content_type, 0, create_prev, maxx, maxy, ratio)
if create_prev==UPLOAD_NORESIZE or create_prev==UPLOAD_RESIZE:
self._getOb(id).manage_file_upload(preview, content_type, 1, create_prev, maxx, maxy, ratio)
if REQUEST is not None:
return self.manage_main(self, REQUEST, update_menu=0)
return id
class ExtImage(ExtFile):
""" The ExtImage-Product works like the Zope Image-product, but stores the
uploaded image externally in a repository-direcory. It can create a
preview of the image (requires PIL)."""
__implements__ = (IExtImage, WriteLockInterface)
security = ClassSecurityInfo()
# what do people think they're adding?
meta_type = 'ExtImage'
# default,min,max-sizes for the preview image
_image_size={'default':256,'min':1,'max':999}
# store maxx and maxy
prev_maxx = _image_size['default']
prev_maxy = _image_size['default']
################################
# Init method #
################################
def __init__(self, id, title='', descr='', permission_check=0, redirect_default_view=0):
""" Initialize a new instance of ExtImage """
ExtImage.inheritedAttribute("__init__")(self, id, title, descr, permission_check, redirect_default_view)
self.prev_filename = []
self.prev_content_type = ''
self.prev_ratio = 1
self.has_preview = 0
################################
# Public methods #
################################
def __str__(self):
return self.tag()
security.declareProtected(ViewPermission, 'tag')
def tag(self, preview=0, icon=0, height=None, width=None, alt=None,
scale=0, xscale=0, yscale=0, border='0', REQUEST=None, **args):
""" Generate an HTML IMG tag for this image, with customization.
Arguments to self.tag() can be any valid attributes of an IMG tag.
'src' will always be an absolute pathname, to prevent redundant
downloading of images. Defaults are applied intelligently for
'height', 'width', and 'alt'. If specified, the 'scale', 'xscale',
and 'yscale' keyword arguments will be used to automatically adjust
the output height and width values of the image tag.
Adopted and adapted from OFS/Image.py
"""
if not self.is_webviewable():
preview = 1
if not self._access_permitted():
preview = 1
if preview and not self.has_preview:
icon = 1
if icon:
url = self._static_url(icon=1)
img_width, img_height = (32, 32)
elif preview:
url = self._static_url(preview=1)
img_width, img_height = self._getImageSize(self.prev_filename)
else:
url = self._static_url()
img_width, img_height = self._getImageSize(self.filename)
height = height or img_height
width = width or img_width
# Auto-scaling support
xdelta = xscale or scale
ydelta = yscale or scale
if xdelta and width != None:
width = str(int(width) * xdelta)
if ydelta and height != None:
height = str(int(height) * ydelta)
if alt is None: alt = self.title or ''
strg = '<img src="%s" border="%s" alt="%s"' % \
(url, border, alt)
if height: strg = '%s height="%s"' % (strg, height)
if width: strg = '%s width="%s"' % (strg, width)
for key in args.keys():
value = args.get(key)
strg = '%s %s="%s"' % (strg, key, value)
strg="%s />" % (strg)
return strg
security.declareProtected(ViewPermission, 'preview')
def preview(self):
""" Return a preview of the image """
raise Redirect, self._static_url(preview=1)
security.declareProtected(ViewPermission, 'preview_tag')
def preview_tag(self):
""" Generates the HTML IMG tag for the preview image """
return self.tag(preview=1)
security.declareProtected(ViewPermission, 'preview_html')
def preview_html(self):
""" Same as preview_tag """
return self.preview_tag()
security.declareProtected(ViewPermission, 'is_broken')
def is_broken(self):
""" Check if external file exists and return true (1) or false (0) """
if self.has_preview and self.filename != self.prev_filename:
if not self._get_fsname(self.prev_filename):
return 1
return ExtImage.inheritedAttribute("is_broken")(self)
security.declareProtected(ViewPermission, 'is_webviewable')
def is_webviewable(self):
""" Return 1 for GIF, JPEG, and PNG images, otherwise return 0 """
format = self.format()
if format=='JPEG' or format=='GIF' or format=='PNG':
return 1
else:
return 0
security.declareProtected(ViewPermission, 'get_prev_size')
def get_prev_size(self):
""" Returns the size of the preview file """
fn = self._get_fsname(self.prev_filename)
if fn:
return os.stat(fn)[6]
return 0
security.declareProtected(ViewPermission, 'prev_rawsize')
def prev_rawsize(self):
""" Same as get_prev_size """
return self.get_prev_size()
security.declareProtected(ViewPermission, 'prev_size')
def prev_size(self):
""" Returns a formatted stringified version of the preview size """
return self._bytetostring(self.get_prev_size())
security.declareProtected(ViewPermission, 'width')
def width(self):
""" Pixel width of the image """
return self._getImageSize(self.filename)[0]
security.declareProtected(ViewPermission, 'height')
def height(self):
""" Pixel height of the image """
return self._getImageSize(self.filename)[1]
security.declareProtected(ViewPermission, 'prev_width')
def prev_width(self):
""" Pixel width of the preview """
return self._getImageSize(self.prev_filename)[0]
security.declareProtected(ViewPermission, 'prev_height')
def prev_height(self):
""" Pixel height of the preview """
return self._getImageSize(self.prev_filename)[1]
security.declareProtected(ViewPermission, 'format')
def format(self):
""" Get the PIL file format of the image """
filename = self._get_fsname(self.filename)
try:
from PIL import Image
im = Image.open(filename)
return im.format
except:
return 'unknown'
security.declareProtected(AccessPermission, 'get_prev_filename')
def get_prev_filename(self):
""" Returns the preview file name for display """
return self._fsname(self.prev_filename)
################################
# Protected management methods #
################################
# Management Interface
security.declareProtected(AccessPermission, 'manage_main')
manage_main = HTMLFile('dtml/extImageEdit', globals())
security.declareProtected(ChangePermission, 'manage_del_prev')
def manage_del_prev(self, REQUEST=None):
""" Delete the Preview Image """
if self.has_preview and self.filename != self.prev_filename:
tmp_fn = self._temp_fsname(self.prev_filename)
fn = self._fsname(self.prev_filename)
if isfile(tmp_fn):
try: os.rename(tmp_fn, fn+'.undo')
except OSError: pass
else:
try: os.remove(fn)
except OSError: pass
elif isfile(fn):
try: os.rename(fn, fn+'.undo')
except OSError: pass
self.prev_content_type = ''
self.has_preview = 0
self.ZCacheable_invalidate()
if REQUEST is not None:
return self.manage_main(self, REQUEST, manage_tabs_message='Preview deleted.')
security.declareProtected(ChangePermission, 'manage_create_prev')
def manage_create_prev(self, maxx=0, maxy=0, ratio=0, REQUEST=None):
""" Create a preview Image """
maxx, maxy = self._formatDimensions(maxx, maxy)
if maxx!=0 and maxy!=0:
self._register() # Register with TM
try:
new_fn = self._get_ufn(self.prev_filename, content_type='image/jpeg')
self._createPreview(self.filename, new_fn, maxx, maxy, ratio)
finally:
self._dir__unlock()
if REQUEST is None:
return self.has_preview
else:
if self.has_preview:
return self.manage_main(self, REQUEST, manage_tabs_message='Preview created.')
elif maxx=='0' and maxy=='0':
return MessageDialog(
title = 'Attention',
message = "You must enter a value > 0",
action = './manage_main',)
else:
return MessageDialog(
title = 'Warning',
message = "An error occurred while generating the preview.",
action = './manage_main',)
# File upload Interface
security.declareProtected(AccessPermission, 'manage_uploadForm')
manage_uploadForm = HTMLFile('dtml/extImageUpload', globals())
security.declareProtected(ChangePermission, 'manage_upload')
def manage_upload(self, file='', content_type='', is_preview=0,
create_prev=NO_PREVIEW, maxx='', maxy='', ratio=0,
REQUEST=None):
""" Upload image from file handle or string buffer """
if self.wl_isLocked():
raise ResourceLockedError, "File is locked via WebDAV"
if type(file) == types.StringType:
temp_file = TemporaryFile()
temp_file.write(file)
temp_file.seek(0)
else:
temp_file = file
return self.manage_file_upload(temp_file, content_type, is_preview,
create_prev, maxx, maxy, ratio, REQUEST)
security.declareProtected(ChangePermission, 'manage_file_upload')
def manage_file_upload(self, file='', content_type='', is_preview=0,
create_prev=NO_PREVIEW, maxx='', maxy='', ratio=0,
REQUEST=None):
""" Upload image from file handle or local directory """
if self.wl_isLocked():
raise ResourceLockedError, "File is locked via WebDAV"
if is_preview:
if type(file) == types.StringType:
cant_read_exc = "Can't open: "
try: file = open(file, 'rb')
except: raise cant_read_exc, file
maxx, maxy = self._formatDimensions(maxx, maxy)
if create_prev==UPLOAD_RESIZE and maxx!=0 and maxy!=0:
self._register() # Register with TM
try:
new_fn = self._get_ufn(self.prev_filename, content_type='image/jpeg')
self._update_data(file, self._temp_fsname(new_fn))
finally:
self._dir__unlock()
self._createPreview(new_fn, new_fn, maxx, maxy, ratio)
else:
if content_type:
file = HTTPUpload(file, content_type)
self.prev_content_type = self._get_content_type(file, file.read(100),
self.id, self.prev_content_type)
file.seek(0)
self._register() # Register with TM
try:
new_fn = self._get_ufn(self.prev_filename, content_type=self.prev_content_type)
self._update_data(file, self._temp_fsname(new_fn))
finally:
self._dir__unlock()
self.prev_filename = new_fn
self._initPreview()
else:
ExtImage.inheritedAttribute("manage_file_upload")(self, file, content_type)
if create_prev==GENERATE:
maxx, maxy = self._formatDimensions(maxx, maxy)
if maxx!=0 and maxy!=0:
self._register() # Register with TM
try:
new_fn = self._get_ufn(self.prev_filename, content_type='image/jpeg')
self._createPreview(self.filename, new_fn, maxx, maxy, ratio)
finally:
self._dir__unlock()
if REQUEST is not None:
return self.manage_main(self, REQUEST, manage_tabs_message='Upload complete.')
security.declareProtected(ChangePermission, 'manage_http_upload')
def manage_http_upload(self, url, is_preview=0, REQUEST=None):
""" Upload image from http-server """
if self.wl_isLocked():
raise ResourceLockedError, "File is locked via WebDAV"
if is_preview:
url = urllib.quote(url,'/:')
cant_read_exc = "Can't open: "
try: file = urllib.urlopen(url)
except: raise cant_read_exc, url
file = HTTPUpload(file)
self.prev_content_type = self._get_content_type(file, file.read(100),
self.id, self.prev_content_type)
file.seek(0)
self._register() # Register with TM
try:
new_fn = self._get_ufn(self.prev_filename, content_type=self.prev_content_type)
self._update_data(file, self._temp_fsname(new_fn))
finally:
self._dir__unlock()
self.prev_filename = new_fn
self._initPreview()
else:
ExtImage.inheritedAttribute("manage_http_upload")(self, url)
#if self.has_preview:
# maxx, maxy = self._formatDimensions(self.prev_maxx, self.prev_maxy)
# self._register() # Register with TM
# try:
# new_fn = self._get_ufn(self.prev_filename, content_type='image/jpeg')
# self._createPreview(self.filename, new_fn, maxx, maxy, self.prev_ratio)
# finally:
# self._dir__unlock()
if REQUEST is not None:
return self.manage_main(self, REQUEST, manage_tabs_message='Upload complete.')
security.declareProtected(ChangePermission, 'PUT')
def PUT(self, REQUEST, RESPONSE):
""" Handle HTTP PUT requests """
RESPONSE = ExtImage.inheritedAttribute("PUT")(self, REQUEST, RESPONSE)
if self.has_preview:
maxx, maxy = self._formatDimensions(self.prev_maxx, self.prev_maxy)
self._register() # Register with TM
try:
# Need to pass in the path as webdav.NullResource calls PUT
# on an unwrapped object.
try:
self.aq_parent # This raises AttributeError if no context
except AttributError:
path = self._get_zodb_path(REQUEST.PARENTS[0])
else:
path = None
new_fn = self._get_ufn(self.prev_filename, content_type='image/jpeg', path=path)
self._createPreview(self.filename, new_fn, maxx, maxy, self.prev_ratio)
finally:
self._dir__unlock()
return RESPONSE
################################
# Private methods #
################################
def _getImageSize(self, filename):
""" Return width, height tuple using PIL """
filename = self._get_fsname(filename)
try:
from PIL import Image
im = Image.open(filename)
return im.size[0], im.size[1]
except:
return 0, 0
def _createPreview(self, from_filename, to_filename, maxx, maxy, ratio):
""" Generate a preview using PIL """
try:
from PIL import Image
except ImportError:
pass
else:
imfile = self._get_fsname(from_filename)
if imfile:
im = Image.open(imfile)
if im.mode!='RGB':
im = im.convert('RGB')
filter = Image.BICUBIC
if hasattr(Image, 'ANTIALIAS'): # PIL 1.1.3
filter = Image.ANTIALIAS
if ratio: # keep aspect-ratio
im.thumbnail((maxx,maxy), filter)
else: # distort to fixed size
im = im.resize((maxx,maxy), filter)
umask = os.umask(REPOSITORY_UMASK)
outfile = self._temp_fsname(to_filename)
try:
im.save(outfile, 'JPEG', quality=85)
except:
os.umask(umask)
if isfile(outfile):
try: os.remove(outfile)
except OSError: pass
raise
else:
os.umask(umask)
self.prev_content_type = 'image/jpeg'
self.prev_filename = to_filename
self.prev_maxx = maxx
self.prev_maxy = maxy
self.prev_ratio = ratio
self._initPreview()
def _initPreview(self):
""" Verify the preview """
self.ZCacheable_invalidate()
prev_width, prev_height = self._getImageSize(self.prev_filename)
if prev_width<=0 or prev_height<=0:
self.has_preview = 0
else:
self.has_preview = 1
def _formatDimensions(self, maxx, maxy):
""" Make sure, the dimensions are valid int's """
if type(maxx) is types.StringType:
try: maxx = int(maxx)
except ValueError: maxx = self._image_size['default']
if type(maxy) is types.StringType:
try: maxy = int(maxy)
except ValueError: maxy = self._image_size['default']
if maxx!=0 and maxy!=0:
if maxx<self._image_size['min']: maxx = self._image_size['min']
elif maxx>self._image_size['max']: maxx = self._image_size['max']
if maxy<self._image_size['min']: maxy = self._image_size['min']
elif maxy>self._image_size['max']: maxy = self._image_size['max']
return maxx, maxy
def _undo(self):
""" Restore filename after delete or copy-paste """
if self.has_preview and self.filename != self.prev_filename:
fn = self._fsname(self.prev_filename)
if not isfile(fn) and isfile(fn+'.undo'):
self._register() # Register with TM
os.rename(fn+'.undo', self._temp_fsname(self.prev_filename))
return ExtImage.inheritedAttribute("_undo")(self)
def _get_content_type(self, file, body, id, content_type=None):
""" Determine the mime-type """
from OFS.Image import getImageInfo
ct, w, h = getImageInfo(body)
if ct:
content_type = ct
else:
content_type = ExtImage.inheritedAttribute('_get_content_type')(self,
file, body, id, content_type)
return content_type
################################
# Special management methods #
################################
security.declarePrivate('manage_afterClone')
def manage_afterClone(self, item):
""" When a copy of the object is created (zope copy-paste-operation),
this function is called by CopySupport.py. A copy of the external
file is created and self.filename is changed.
"""
try:
self.aq_parent # This raises AttributeError if no context
except AttributeError:
pass
else:
result = ExtImage.inheritedAttribute("manage_afterClone")(self, item)
self._register() # Register with TM
try:
new_prev_fn = self._get_new_ufn(content_type=self.prev_content_type)
if self.has_preview and self.filename != self.prev_filename:
old_prev_fn = self._get_fsname(self.prev_filename)
if old_prev_fn:
self._update_data(old_prev_fn, self._temp_fsname(new_prev_fn))
self.prev_filename = new_prev_fn
else:
self.prev_filename = []
self.has_preview = 0
elif self.has_preview:
# XXX: This seems to be an impossible state?
old_fn = self._get_fsname(self.filename)
if not old_fn:
self.prev_filename = []
self.has_preview = 0
else:
self.prev_filename = []
finally:
self._dir__unlock()
return result
return ExtImage.inheritedAttribute("manage_afterClone")(self, item)
security.declarePrivate('manage_afterAdd')
def manage_afterAdd(self, item, container):
""" When a copy of the object is created (zope copy-paste-operation),
this function is called by CopySupport.py. A copy of the external
file is created and self.filename is changed.
"""
return ExtImage.inheritedAttribute("manage_afterAdd")(self, item, container)
security.declarePrivate('manage_beforeDelete')
def manage_beforeDelete(self, item, container):
""" This method is called, when the object is deleted. To support
undo-functionality and because this happens too, when the object
is moved (cut-paste) or renamed, the external file is not deleted.
It is just renamed to filename.undo and remains in the
repository, until it is deleted manually.
"""
if self.has_preview and self.filename != self.prev_filename:
tmp_fn = self._temp_fsname(self.prev_filename)
fn = self._fsname(self.prev_filename)
if isfile(tmp_fn):
try: os.rename(tmp_fn, fn+'.undo')
except OSError: pass
else:
try: os.remove(fn)
except OSError: pass
elif isfile(fn):
try: os.rename(fn, fn+'.undo')
except OSError: pass
return ExtImage.inheritedAttribute("manage_beforeDelete")(self, item, container)
################################
# Transaction manager methods #
################################
def _finish(self):
""" Commits the temporary file """
if self.prev_filename and self.filename != self.prev_filename:
tmp_fn = self._temp_fsname(self.prev_filename)
if _debug: LOG(_SUBSYS, INFO, 'finishing %s' % tmp_fn)
if isfile(tmp_fn):
if _debug: LOG(_SUBSYS, INFO, 'isfile %s' % tmp_fn)
fn = self._fsname(self.prev_filename)
try: os.remove(fn)
except OSError: pass
os.rename(tmp_fn, fn)
ExtImage.inheritedAttribute('_finish')(self)
def _abort(self):
""" Deletes the temporary file """
if self.prev_filename and self.filename != self.prev_filename:
tmp_fn = self._temp_fsname(self.prev_filename)
if _debug: LOG(_SUBSYS, INFO, 'aborting %s' % tmp_fn)
if isfile(tmp_fn):
if _debug: LOG(_SUBSYS, INFO, 'isfile %s' % tmp_fn)
try: os.remove(tmp_fn)
except OSError: pass
ExtImage.inheritedAttribute('_abort')(self)
InitializeClass(ExtImage)
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvs/cvsweb/icons/back.gif){kind=icon}
Return to ExtImage.py CVS log ![[TXT]](/cvs/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvs/cvsweb/icons/dir.gif){kind=icon}
Up to [Repository] / ExtFile