./0000775000076400007640000000000011156453112006144 5ustar ./LICENSE.txt0000664000076400007640000004313110057365036007777 0ustar GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Library General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. , 1 April 1989 Ty Coon, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Library General Public License instead of this License. ./EXIF.py0000644000000000000000000017262511156343260011034 0ustar rootroot#!/usr/bin/env python # -*- coding: utf-8 -*- # # Library to extract EXIF information from digital camera image files # http://sourceforge.net/projects/exif-py/ # # VERSION 1.1.1 # # To use this library call with: # f = open(path_name, 'rb') # tags = EXIF.process_file(f) # # To ignore MakerNote tags, pass the -q or --quick # command line arguments, or as # tags = EXIF.process_file(f, details=False) # # To stop processing after a certain tag is retrieved, # pass the -t TAG or --stop-tag TAG argument, or as # tags = EXIF.process_file(f, stop_tag='TAG') # # where TAG is a valid tag name, ex 'DateTimeOriginal' # # These 2 are useful when you are retrieving a large list of images # # # To return an error on invalid tags, # pass the -s or --strict argument, or as # tags = EXIF.process_file(f, strict=True) # # Otherwise these tags will be ignored # # Returned tags will be a dictionary mapping names of EXIF tags to their # values in the file named by path_name. You can process the tags # as you wish. In particular, you can iterate through all the tags with: # for tag in tags.keys(): # if tag not in ('JPEGThumbnail', 'TIFFThumbnail', 'Filename', # 'EXIF MakerNote'): # print "Key: %s, value %s" % (tag, tags[tag]) # (This code uses the if statement to avoid printing out a few of the # tags that tend to be long or boring.) # # The tags dictionary will include keys for all of the usual EXIF # tags, and will also include keys for Makernotes used by some # cameras, for which we have a good specification. # # Note that the dictionary keys are the IFD name followed by the # tag name. For example: # 'EXIF DateTimeOriginal', 'Image Orientation', 'MakerNote FocusMode' # # Copyright (c) 2002-2007 Gene Cash All rights reserved # Copyright (c) 2007-2008 Ianaré Sévi All rights reserved # # 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. Neither the name of the authors nor the names of its contributors # may be used to endorse or promote products derived from this # software without specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS # "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 COPYRIGHT # OWNER OR CONTRIBUTORS 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. # # # ----- See 'changes.txt' file for all contributors and changes ----- # # # Don't throw an exception when given an out of range character. def make_string(seq): str = '' for c in seq: # Screen out non-printing characters if 32 <= c and c < 256: str += chr(c) # If no printing chars if not str: return seq return str # Special version to deal with the code in the first 8 bytes of a user comment. # First 8 bytes gives coding system e.g. ASCII vs. JIS vs Unicode def make_string_uc(seq): code = seq[0:8] seq = seq[8:] # Of course, this is only correct if ASCII, and the standard explicitly # allows JIS and Unicode. return make_string( make_string(seq) ) # field type descriptions as (length, abbreviation, full name) tuples FIELD_TYPES = ( (0, 'X', 'Proprietary'), # no such type (1, 'B', 'Byte'), (1, 'A', 'ASCII'), (2, 'S', 'Short'), (4, 'L', 'Long'), (8, 'R', 'Ratio'), (1, 'SB', 'Signed Byte'), (1, 'U', 'Undefined'), (2, 'SS', 'Signed Short'), (4, 'SL', 'Signed Long'), (8, 'SR', 'Signed Ratio'), ) # dictionary of main EXIF tag names # first element of tuple is tag name, optional second element is # another dictionary giving names to values EXIF_TAGS = { 0x0100: ('ImageWidth', ), 0x0101: ('ImageLength', ), 0x0102: ('BitsPerSample', ), 0x0103: ('Compression', {1: 'Uncompressed', 2: 'CCITT 1D', 3: 'T4/Group 3 Fax', 4: 'T6/Group 4 Fax', 5: 'LZW', 6: 'JPEG (old-style)', 7: 'JPEG', 8: 'Adobe Deflate', 9: 'JBIG B&W', 10: 'JBIG Color', 32766: 'Next', 32769: 'Epson ERF Compressed', 32771: 'CCIRLEW', 32773: 'PackBits', 32809: 'Thunderscan', 32895: 'IT8CTPAD', 32896: 'IT8LW', 32897: 'IT8MP', 32898: 'IT8BL', 32908: 'PixarFilm', 32909: 'PixarLog', 32946: 'Deflate', 32947: 'DCS', 34661: 'JBIG', 34676: 'SGILog', 34677: 'SGILog24', 34712: 'JPEG 2000', 34713: 'Nikon NEF Compressed', 65000: 'Kodak DCR Compressed', 65535: 'Pentax PEF Compressed'}), 0x0106: ('PhotometricInterpretation', ), 0x0107: ('Thresholding', ), 0x010A: ('FillOrder', ), 0x010D: ('DocumentName', ), 0x010E: ('ImageDescription', ), 0x010F: ('Make', ), 0x0110: ('Model', ), 0x0111: ('StripOffsets', ), 0x0112: ('Orientation', {1: 'Horizontal (normal)', 2: 'Mirrored horizontal', 3: 'Rotated 180', 4: 'Mirrored vertical', 5: 'Mirrored horizontal then rotated 90 CCW', 6: 'Rotated 90 CW', 7: 'Mirrored horizontal then rotated 90 CW', 8: 'Rotated 90 CCW'}), 0x0115: ('SamplesPerPixel', ), 0x0116: ('RowsPerStrip', ), 0x0117: ('StripByteCounts', ), 0x011A: ('XResolution', ), 0x011B: ('YResolution', ), 0x011C: ('PlanarConfiguration', ), 0x011D: ('PageName', make_string), 0x0128: ('ResolutionUnit', {1: 'Not Absolute', 2: 'Pixels/Inch', 3: 'Pixels/Centimeter'}), 0x012D: ('TransferFunction', ), 0x0131: ('Software', ), 0x0132: ('DateTime', ), 0x013B: ('Artist', ), 0x013E: ('WhitePoint', ), 0x013F: ('PrimaryChromaticities', ), 0x0156: ('TransferRange', ), 0x0200: ('JPEGProc', ), 0x0201: ('JPEGInterchangeFormat', ), 0x0202: ('JPEGInterchangeFormatLength', ), 0x0211: ('YCbCrCoefficients', ), 0x0212: ('YCbCrSubSampling', ), 0x0213: ('YCbCrPositioning', {1: 'Centered', 2: 'Co-sited'}), 0x0214: ('ReferenceBlackWhite', ), 0x4746: ('Rating', ), 0x828D: ('CFARepeatPatternDim', ), 0x828E: ('CFAPattern', ), 0x828F: ('BatteryLevel', ), 0x8298: ('Copyright', ), 0x829A: ('ExposureTime', ), 0x829D: ('FNumber', ), 0x83BB: ('IPTC/NAA', ), 0x8769: ('ExifOffset', ), 0x8773: ('InterColorProfile', ), 0x8822: ('ExposureProgram', {0: 'Unidentified', 1: 'Manual', 2: 'Program Normal', 3: 'Aperture Priority', 4: 'Shutter Priority', 5: 'Program Creative', 6: 'Program Action', 7: 'Portrait Mode', 8: 'Landscape Mode'}), 0x8824: ('SpectralSensitivity', ), 0x8825: ('GPSInfo', ), 0x8827: ('ISOSpeedRatings', ), 0x8828: ('OECF', ), 0x9000: ('ExifVersion', make_string), 0x9003: ('DateTimeOriginal', ), 0x9004: ('DateTimeDigitized', ), 0x9101: ('ComponentsConfiguration', {0: '', 1: 'Y', 2: 'Cb', 3: 'Cr', 4: 'Red', 5: 'Green', 6: 'Blue'}), 0x9102: ('CompressedBitsPerPixel', ), 0x9201: ('ShutterSpeedValue', ), 0x9202: ('ApertureValue', ), 0x9203: ('BrightnessValue', ), 0x9204: ('ExposureBiasValue', ), 0x9205: ('MaxApertureValue', ), 0x9206: ('SubjectDistance', ), 0x9207: ('MeteringMode', {0: 'Unidentified', 1: 'Average', 2: 'CenterWeightedAverage', 3: 'Spot', 4: 'MultiSpot', 5: 'Pattern'}), 0x9208: ('LightSource', {0: 'Unknown', 1: 'Daylight', 2: 'Fluorescent', 3: 'Tungsten', 9: 'Fine Weather', 10: 'Flash', 11: 'Shade', 12: 'Daylight Fluorescent', 13: 'Day White Fluorescent', 14: 'Cool White Fluorescent', 15: 'White Fluorescent', 17: 'Standard Light A', 18: 'Standard Light B', 19: 'Standard Light C', 20: 'D55', 21: 'D65', 22: 'D75', 255: 'Other'}), 0x9209: ('Flash', {0: 'No', 1: 'Fired', 5: 'Fired (?)', # no return sensed 7: 'Fired (!)', # return sensed 9: 'Fill Fired', 13: 'Fill Fired (?)', 15: 'Fill Fired (!)', 16: 'Off', 24: 'Auto Off', 25: 'Auto Fired', 29: 'Auto Fired (?)', 31: 'Auto Fired (!)', 32: 'Not Available'}), 0x920A: ('FocalLength', ), 0x9214: ('SubjectArea', ), 0x927C: ('MakerNote', ), 0x9286: ('UserComment', make_string_uc), 0x9290: ('SubSecTime', ), 0x9291: ('SubSecTimeOriginal', ), 0x9292: ('SubSecTimeDigitized', ), # used by Windows Explorer 0x9C9B: ('XPTitle', ), 0x9C9C: ('XPComment', ), 0x9C9D: ('XPAuthor', ), #(ignored by Windows Explorer if Artist exists) 0x9C9E: ('XPKeywords', ), 0x9C9F: ('XPSubject', ), 0xA000: ('FlashPixVersion', make_string), 0xA001: ('ColorSpace', {1: 'sRGB', 2: 'Adobe RGB', 65535: 'Uncalibrated'}), 0xA002: ('ExifImageWidth', ), 0xA003: ('ExifImageLength', ), 0xA005: ('InteroperabilityOffset', ), 0xA20B: ('FlashEnergy', ), # 0x920B in TIFF/EP 0xA20C: ('SpatialFrequencyResponse', ), # 0x920C 0xA20E: ('FocalPlaneXResolution', ), # 0x920E 0xA20F: ('FocalPlaneYResolution', ), # 0x920F 0xA210: ('FocalPlaneResolutionUnit', ), # 0x9210 0xA214: ('SubjectLocation', ), # 0x9214 0xA215: ('ExposureIndex', ), # 0x9215 0xA217: ('SensingMethod', # 0x9217 {1: 'Not defined', 2: 'One-chip color area', 3: 'Two-chip color area', 4: 'Three-chip color area', 5: 'Color sequential area', 7: 'Trilinear', 8: 'Color sequential linear'}), 0xA300: ('FileSource', {1: 'Film Scanner', 2: 'Reflection Print Scanner', 3: 'Digital Camera'}), 0xA301: ('SceneType', {1: 'Directly Photographed'}), 0xA302: ('CVAPattern', ), 0xA401: ('CustomRendered', {0: 'Normal', 1: 'Custom'}), 0xA402: ('ExposureMode', {0: 'Auto Exposure', 1: 'Manual Exposure', 2: 'Auto Bracket'}), 0xA403: ('WhiteBalance', {0: 'Auto', 1: 'Manual'}), 0xA404: ('DigitalZoomRatio', ), 0xA405: ('FocalLengthIn35mmFilm', ), 0xA406: ('SceneCaptureType', {0: 'Standard', 1: 'Landscape', 2: 'Portrait', 3: 'Night)'}), 0xA407: ('GainControl', {0: 'None', 1: 'Low gain up', 2: 'High gain up', 3: 'Low gain down', 4: 'High gain down'}), 0xA408: ('Contrast', {0: 'Normal', 1: 'Soft', 2: 'Hard'}), 0xA409: ('Saturation', {0: 'Normal', 1: 'Soft', 2: 'Hard'}), 0xA40A: ('Sharpness', {0: 'Normal', 1: 'Soft', 2: 'Hard'}), 0xA40B: ('DeviceSettingDescription', ), 0xA40C: ('SubjectDistanceRange', ), 0xA500: ('Gamma', ), 0xC4A5: ('PrintIM', ), 0xEA1C: ('Padding', ), } # interoperability tags INTR_TAGS = { 0x0001: ('InteroperabilityIndex', ), 0x0002: ('InteroperabilityVersion', ), 0x1000: ('RelatedImageFileFormat', ), 0x1001: ('RelatedImageWidth', ), 0x1002: ('RelatedImageLength', ), } # GPS tags (not used yet, haven't seen camera with GPS) GPS_TAGS = { 0x0000: ('GPSVersionID', ), 0x0001: ('GPSLatitudeRef', ), 0x0002: ('GPSLatitude', ), 0x0003: ('GPSLongitudeRef', ), 0x0004: ('GPSLongitude', ), 0x0005: ('GPSAltitudeRef', ), 0x0006: ('GPSAltitude', ), 0x0007: ('GPSTimeStamp', ), 0x0008: ('GPSSatellites', ), 0x0009: ('GPSStatus', ), 0x000A: ('GPSMeasureMode', ), 0x000B: ('GPSDOP', ), 0x000C: ('GPSSpeedRef', ), 0x000D: ('GPSSpeed', ), 0x000E: ('GPSTrackRef', ), 0x000F: ('GPSTrack', ), 0x0010: ('GPSImgDirectionRef', ), 0x0011: ('GPSImgDirection', ), 0x0012: ('GPSMapDatum', ), 0x0013: ('GPSDestLatitudeRef', ), 0x0014: ('GPSDestLatitude', ), 0x0015: ('GPSDestLongitudeRef', ), 0x0016: ('GPSDestLongitude', ), 0x0017: ('GPSDestBearingRef', ), 0x0018: ('GPSDestBearing', ), 0x0019: ('GPSDestDistanceRef', ), 0x001A: ('GPSDestDistance', ), 0x001D: ('GPSDate', ), } # Ignore these tags when quick processing # 0x927C is MakerNote Tags # 0x9286 is user comment IGNORE_TAGS=(0x9286, 0x927C) # http://tomtia.plala.jp/DigitalCamera/MakerNote/index.asp def nikon_ev_bias(seq): # First digit seems to be in steps of 1/6 EV. # Does the third value mean the step size? It is usually 6, # but it is 12 for the ExposureDifference. # # Check for an error condition that could cause a crash. # This only happens if something has gone really wrong in # reading the Nikon MakerNote. if len( seq ) < 4 : return "" # if seq == [252, 1, 6, 0]: return "-2/3 EV" if seq == [253, 1, 6, 0]: return "-1/2 EV" if seq == [254, 1, 6, 0]: return "-1/3 EV" if seq == [0, 1, 6, 0]: return "0 EV" if seq == [2, 1, 6, 0]: return "+1/3 EV" if seq == [3, 1, 6, 0]: return "+1/2 EV" if seq == [4, 1, 6, 0]: return "+2/3 EV" # Handle combinations not in the table. a = seq[0] # Causes headaches for the +/- logic, so special case it. if a == 0: return "0 EV" if a > 127: a = 256 - a ret_str = "-" else: ret_str = "+" b = seq[2] # Assume third value means the step size whole = a / b a = a % b if whole != 0: ret_str = ret_str + str(whole) + " " if a == 0: ret_str = ret_str + "EV" else: r = Ratio(a, b) ret_str = ret_str + r.__repr__() + " EV" return ret_str # Nikon E99x MakerNote Tags MAKERNOTE_NIKON_NEWER_TAGS={ 0x0001: ('MakernoteVersion', make_string), # Sometimes binary 0x0002: ('ISOSetting', make_string), 0x0003: ('ColorMode', ), 0x0004: ('Quality', ), 0x0005: ('Whitebalance', ), 0x0006: ('ImageSharpening', ), 0x0007: ('FocusMode', ), 0x0008: ('FlashSetting', ), 0x0009: ('AutoFlashMode', ), 0x000B: ('WhiteBalanceBias', ), 0x000C: ('WhiteBalanceRBCoeff', ), 0x000D: ('ProgramShift', nikon_ev_bias), # Nearly the same as the other EV vals, but step size is 1/12 EV (?) 0x000E: ('ExposureDifference', nikon_ev_bias), 0x000F: ('ISOSelection', ), 0x0011: ('NikonPreview', ), 0x0012: ('FlashCompensation', nikon_ev_bias), 0x0013: ('ISOSpeedRequested', ), 0x0016: ('PhotoCornerCoordinates', ), # 0x0017: Unknown, but most likely an EV value 0x0018: ('FlashBracketCompensationApplied', nikon_ev_bias), 0x0019: ('AEBracketCompensationApplied', ), 0x001A: ('ImageProcessing', ), 0x001B: ('CropHiSpeed', ), 0x001D: ('SerialNumber', ), # Conflict with 0x00A0 ? 0x001E: ('ColorSpace', ), 0x001F: ('VRInfo', ), 0x0020: ('ImageAuthentication', ), 0x0022: ('ActiveDLighting', ), 0x0023: ('PictureControl', ), 0x0024: ('WorldTime', ), 0x0025: ('ISOInfo', ), 0x0080: ('ImageAdjustment', ), 0x0081: ('ToneCompensation', ), 0x0082: ('AuxiliaryLens', ), 0x0083: ('LensType', ), 0x0084: ('LensMinMaxFocalMaxAperture', ), 0x0085: ('ManualFocusDistance', ), 0x0086: ('DigitalZoomFactor', ), 0x0087: ('FlashMode', {0x00: 'Did Not Fire', 0x01: 'Fired, Manual', 0x07: 'Fired, External', 0x08: 'Fired, Commander Mode ', 0x09: 'Fired, TTL Mode'}), 0x0088: ('AFFocusPosition', {0x0000: 'Center', 0x0100: 'Top', 0x0200: 'Bottom', 0x0300: 'Left', 0x0400: 'Right'}), 0x0089: ('BracketingMode', {0x00: 'Single frame, no bracketing', 0x01: 'Continuous, no bracketing', 0x02: 'Timer, no bracketing', 0x10: 'Single frame, exposure bracketing', 0x11: 'Continuous, exposure bracketing', 0x12: 'Timer, exposure bracketing', 0x40: 'Single frame, white balance bracketing', 0x41: 'Continuous, white balance bracketing', 0x42: 'Timer, white balance bracketing'}), 0x008A: ('AutoBracketRelease', ), 0x008B: ('LensFStops', ), 0x008C: ('NEFCurve1', ), # ExifTool calls this 'ContrastCurve' 0x008D: ('ColorMode', ), 0x008F: ('SceneMode', ), 0x0090: ('LightingType', ), 0x0091: ('ShotInfo', ), # First 4 bytes are a version number in ASCII 0x0092: ('HueAdjustment', ), # ExifTool calls this 'NEFCompression', should be 1-4 0x0093: ('Compression', ), 0x0094: ('Saturation', {-3: 'B&W', -2: '-2', -1: '-1', 0: '0', 1: '1', 2: '2'}), 0x0095: ('NoiseReduction', ), 0x0096: ('NEFCurve2', ), # ExifTool calls this 'LinearizationTable' 0x0097: ('ColorBalance', ), # First 4 bytes are a version number in ASCII 0x0098: ('LensData', ), # First 4 bytes are a version number in ASCII 0x0099: ('RawImageCenter', ), 0x009A: ('SensorPixelSize', ), 0x009C: ('Scene Assist', ), 0x009E: ('RetouchHistory', ), 0x00A0: ('SerialNumber', ), 0x00A2: ('ImageDataSize', ), # 00A3: unknown - a single byte 0 # 00A4: In NEF, looks like a 4 byte ASCII version number ('0200') 0x00A5: ('ImageCount', ), 0x00A6: ('DeletedImageCount', ), 0x00A7: ('TotalShutterReleases', ), # First 4 bytes are a version number in ASCII, with version specific # info to follow. Its hard to treat it as a string due to embedded nulls. 0x00A8: ('FlashInfo', ), 0x00A9: ('ImageOptimization', ), 0x00AA: ('Saturation', ), 0x00AB: ('DigitalVariProgram', ), 0x00AC: ('ImageStabilization', ), 0x00AD: ('Responsive AF', ), # 'AFResponse' 0x00B0: ('MultiExposure', ), 0x00B1: ('HighISONoiseReduction', ), 0x00B7: ('AFInfo', ), 0x00B8: ('FileInfo', ), # 00B9: unknown 0x0100: ('DigitalICE', ), 0x0103: ('PreviewCompression', {1: 'Uncompressed', 2: 'CCITT 1D', 3: 'T4/Group 3 Fax', 4: 'T6/Group 4 Fax', 5: 'LZW', 6: 'JPEG (old-style)', 7: 'JPEG', 8: 'Adobe Deflate', 9: 'JBIG B&W', 10: 'JBIG Color', 32766: 'Next', 32769: 'Epson ERF Compressed', 32771: 'CCIRLEW', 32773: 'PackBits', 32809: 'Thunderscan', 32895: 'IT8CTPAD', 32896: 'IT8LW', 32897: 'IT8MP', 32898: 'IT8BL', 32908: 'PixarFilm', 32909: 'PixarLog', 32946: 'Deflate', 32947: 'DCS', 34661: 'JBIG', 34676: 'SGILog', 34677: 'SGILog24', 34712: 'JPEG 2000', 34713: 'Nikon NEF Compressed', 65000: 'Kodak DCR Compressed', 65535: 'Pentax PEF Compressed',}), 0x0201: ('PreviewImageStart', ), 0x0202: ('PreviewImageLength', ), 0x0213: ('PreviewYCbCrPositioning', {1: 'Centered', 2: 'Co-sited'}), 0x0010: ('DataDump', ), } MAKERNOTE_NIKON_OLDER_TAGS = { 0x0003: ('Quality', {1: 'VGA Basic', 2: 'VGA Normal', 3: 'VGA Fine', 4: 'SXGA Basic', 5: 'SXGA Normal', 6: 'SXGA Fine'}), 0x0004: ('ColorMode', {1: 'Color', 2: 'Monochrome'}), 0x0005: ('ImageAdjustment', {0: 'Normal', 1: 'Bright+', 2: 'Bright-', 3: 'Contrast+', 4: 'Contrast-'}), 0x0006: ('CCDSpeed', {0: 'ISO 80', 2: 'ISO 160', 4: 'ISO 320', 5: 'ISO 100'}), 0x0007: ('WhiteBalance', {0: 'Auto', 1: 'Preset', 2: 'Daylight', 3: 'Incandescent', 4: 'Fluorescent', 5: 'Cloudy', 6: 'Speed Light'}), } # decode Olympus SpecialMode tag in MakerNote def olympus_special_mode(v): a={ 0: 'Normal', 1: 'Unknown', 2: 'Fast', 3: 'Panorama'} b={ 0: 'Non-panoramic', 1: 'Left to right', 2: 'Right to left', 3: 'Bottom to top', 4: 'Top to bottom'} if v[0] not in a or v[2] not in b: return v return '%s - sequence %d - %s' % (a[v[0]], v[1], b[v[2]]) MAKERNOTE_OLYMPUS_TAGS={ # ah HAH! those sneeeeeaky bastids! this is how they get past the fact # that a JPEG thumbnail is not allowed in an uncompressed TIFF file 0x0100: ('JPEGThumbnail', ), 0x0200: ('SpecialMode', olympus_special_mode), 0x0201: ('JPEGQual', {1: 'SQ', 2: 'HQ', 3: 'SHQ'}), 0x0202: ('Macro', {0: 'Normal', 1: 'Macro', 2: 'SuperMacro'}), 0x0203: ('BWMode', {0: 'Off', 1: 'On'}), 0x0204: ('DigitalZoom', ), 0x0205: ('FocalPlaneDiagonal', ), 0x0206: ('LensDistortionParams', ), 0x0207: ('SoftwareRelease', ), 0x0208: ('PictureInfo', ), 0x0209: ('CameraID', make_string), # print as string 0x0F00: ('DataDump', ), 0x0300: ('PreCaptureFrames', ), 0x0404: ('SerialNumber', ), 0x1000: ('ShutterSpeedValue', ), 0x1001: ('ISOValue', ), 0x1002: ('ApertureValue', ), 0x1003: ('BrightnessValue', ), 0x1004: ('FlashMode', ), 0x1004: ('FlashMode', {2: 'On', 3: 'Off'}), 0x1005: ('FlashDevice', {0: 'None', 1: 'Internal', 4: 'External', 5: 'Internal + External'}), 0x1006: ('ExposureCompensation', ), 0x1007: ('SensorTemperature', ), 0x1008: ('LensTemperature', ), 0x100b: ('FocusMode', {0: 'Auto', 1: 'Manual'}), 0x1017: ('RedBalance', ), 0x1018: ('BlueBalance', ), 0x101a: ('SerialNumber', ), 0x1023: ('FlashExposureComp', ), 0x1026: ('ExternalFlashBounce', {0: 'No', 1: 'Yes'}), 0x1027: ('ExternalFlashZoom', ), 0x1028: ('ExternalFlashMode', ), 0x1029: ('Contrast int16u', {0: 'High', 1: 'Normal', 2: 'Low'}), 0x102a: ('SharpnessFactor', ), 0x102b: ('ColorControl', ), 0x102c: ('ValidBits', ), 0x102d: ('CoringFilter', ), 0x102e: ('OlympusImageWidth', ), 0x102f: ('OlympusImageHeight', ), 0x1034: ('CompressionRatio', ), 0x1035: ('PreviewImageValid', {0: 'No', 1: 'Yes'}), 0x1036: ('PreviewImageStart', ), 0x1037: ('PreviewImageLength', ), 0x1039: ('CCDScanMode', {0: 'Interlaced', 1: 'Progressive'}), 0x103a: ('NoiseReduction', {0: 'Off', 1: 'On'}), 0x103b: ('InfinityLensStep', ), 0x103c: ('NearLensStep', ), # TODO - these need extra definitions # http://search.cpan.org/src/EXIFTOOL/Image-ExifTool-6.90/html/TagNames/Olympus.html 0x2010: ('Equipment', ), 0x2020: ('CameraSettings', ), 0x2030: ('RawDevelopment', ), 0x2040: ('ImageProcessing', ), 0x2050: ('FocusInfo', ), 0x3000: ('RawInfo ', ), } # 0x2020 CameraSettings MAKERNOTE_OLYMPUS_TAG_0x2020={ 0x0100: ('PreviewImageValid', {0: 'No', 1: 'Yes'}), 0x0101: ('PreviewImageStart', ), 0x0102: ('PreviewImageLength', ), 0x0200: ('ExposureMode', {1: 'Manual', 2: 'Program', 3: 'Aperture-priority AE', 4: 'Shutter speed priority AE', 5: 'Program-shift'}), 0x0201: ('AELock', {0: 'Off', 1: 'On'}), 0x0202: ('MeteringMode', {2: 'Center Weighted', 3: 'Spot', 5: 'ESP', 261: 'Pattern+AF', 515: 'Spot+Highlight control', 1027: 'Spot+Shadow control'}), 0x0300: ('MacroMode', {0: 'Off', 1: 'On'}), 0x0301: ('FocusMode', {0: 'Single AF', 1: 'Sequential shooting AF', 2: 'Continuous AF', 3: 'Multi AF', 10: 'MF'}), 0x0302: ('FocusProcess', {0: 'AF Not Used', 1: 'AF Used'}), 0x0303: ('AFSearch', {0: 'Not Ready', 1: 'Ready'}), 0x0304: ('AFAreas', ), 0x0401: ('FlashExposureCompensation', ), 0x0500: ('WhiteBalance2', {0: 'Auto', 16: '7500K (Fine Weather with Shade)', 17: '6000K (Cloudy)', 18: '5300K (Fine Weather)', 20: '3000K (Tungsten light)', 21: '3600K (Tungsten light-like)', 33: '6600K (Daylight fluorescent)', 34: '4500K (Neutral white fluorescent)', 35: '4000K (Cool white fluorescent)', 48: '3600K (Tungsten light-like)', 256: 'Custom WB 1', 257: 'Custom WB 2', 258: 'Custom WB 3', 259: 'Custom WB 4', 512: 'Custom WB 5400K', 513: 'Custom WB 2900K', 514: 'Custom WB 8000K', }), 0x0501: ('WhiteBalanceTemperature', ), 0x0502: ('WhiteBalanceBracket', ), 0x0503: ('CustomSaturation', ), # (3 numbers: 1. CS Value, 2. Min, 3. Max) 0x0504: ('ModifiedSaturation', {0: 'Off', 1: 'CM1 (Red Enhance)', 2: 'CM2 (Green Enhance)', 3: 'CM3 (Blue Enhance)', 4: 'CM4 (Skin Tones)'}), 0x0505: ('ContrastSetting', ), # (3 numbers: 1. Contrast, 2. Min, 3. Max) 0x0506: ('SharpnessSetting', ), # (3 numbers: 1. Sharpness, 2. Min, 3. Max) 0x0507: ('ColorSpace', {0: 'sRGB', 1: 'Adobe RGB', 2: 'Pro Photo RGB'}), 0x0509: ('SceneMode', {0: 'Standard', 6: 'Auto', 7: 'Sport', 8: 'Portrait', 9: 'Landscape+Portrait', 10: 'Landscape', 11: 'Night scene', 13: 'Panorama', 16: 'Landscape+Portrait', 17: 'Night+Portrait', 19: 'Fireworks', 20: 'Sunset', 22: 'Macro', 25: 'Documents', 26: 'Museum', 28: 'Beach&Snow', 30: 'Candle', 35: 'Underwater Wide1', 36: 'Underwater Macro', 39: 'High Key', 40: 'Digital Image Stabilization', 44: 'Underwater Wide2', 45: 'Low Key', 46: 'Children', 48: 'Nature Macro'}), 0x050a: ('NoiseReduction', {0: 'Off', 1: 'Noise Reduction', 2: 'Noise Filter', 3: 'Noise Reduction + Noise Filter', 4: 'Noise Filter (ISO Boost)', 5: 'Noise Reduction + Noise Filter (ISO Boost)'}), 0x050b: ('DistortionCorrection', {0: 'Off', 1: 'On'}), 0x050c: ('ShadingCompensation', {0: 'Off', 1: 'On'}), 0x050d: ('CompressionFactor', ), 0x050f: ('Gradation', {'-1 -1 1': 'Low Key', '0 -1 1': 'Normal', '1 -1 1': 'High Key'}), 0x0520: ('PictureMode', {1: 'Vivid', 2: 'Natural', 3: 'Muted', 256: 'Monotone', 512: 'Sepia'}), 0x0521: ('PictureModeSaturation', ), 0x0522: ('PictureModeHue?', ), 0x0523: ('PictureModeContrast', ), 0x0524: ('PictureModeSharpness', ), 0x0525: ('PictureModeBWFilter', {0: 'n/a', 1: 'Neutral', 2: 'Yellow', 3: 'Orange', 4: 'Red', 5: 'Green'}), 0x0526: ('PictureModeTone', {0: 'n/a', 1: 'Neutral', 2: 'Sepia', 3: 'Blue', 4: 'Purple', 5: 'Green'}), 0x0600: ('Sequence', ), # 2 or 3 numbers: 1. Mode, 2. Shot number, 3. Mode bits 0x0601: ('PanoramaMode', ), # (2 numbers: 1. Mode, 2. Shot number) 0x0603: ('ImageQuality2', {1: 'SQ', 2: 'HQ', 3: 'SHQ', 4: 'RAW'}), 0x0901: ('ManometerReading', ), } MAKERNOTE_CASIO_TAGS={ 0x0001: ('RecordingMode', {1: 'Single Shutter', 2: 'Panorama', 3: 'Night Scene', 4: 'Portrait', 5: 'Landscape'}), 0x0002: ('Quality', {1: 'Economy', 2: 'Normal', 3: 'Fine'}), 0x0003: ('FocusingMode', {2: 'Macro', 3: 'Auto Focus', 4: 'Manual Focus', 5: 'Infinity'}), 0x0004: ('FlashMode', {1: 'Auto', 2: 'On', 3: 'Off', 4: 'Red Eye Reduction'}), 0x0005: ('FlashIntensity', {11: 'Weak', 13: 'Normal', 15: 'Strong'}), 0x0006: ('Object Distance', ), 0x0007: ('WhiteBalance', {1: 'Auto', 2: 'Tungsten', 3: 'Daylight', 4: 'Fluorescent', 5: 'Shade', 129: 'Manual'}), 0x000B: ('Sharpness', {0: 'Normal', 1: 'Soft', 2: 'Hard'}), 0x000C: ('Contrast', {0: 'Normal', 1: 'Low', 2: 'High'}), 0x000D: ('Saturation', {0: 'Normal', 1: 'Low', 2: 'High'}), 0x0014: ('CCDSpeed', {64: 'Normal', 80: 'Normal', 100: 'High', 125: '+1.0', 244: '+3.0', 250: '+2.0'}), } MAKERNOTE_FUJIFILM_TAGS={ 0x0000: ('NoteVersion', make_string), 0x1000: ('Quality', ), 0x1001: ('Sharpness', {1: 'Soft', 2: 'Soft', 3: 'Normal', 4: 'Hard', 5: 'Hard'}), 0x1002: ('WhiteBalance', {0: 'Auto', 256: 'Daylight', 512: 'Cloudy', 768: 'DaylightColor-Fluorescent', 769: 'DaywhiteColor-Fluorescent', 770: 'White-Fluorescent', 1024: 'Incandescent', 3840: 'Custom'}), 0x1003: ('Color', {0: 'Normal', 256: 'High', 512: 'Low'}), 0x1004: ('Tone', {0: 'Normal', 256: 'High', 512: 'Low'}), 0x1010: ('FlashMode', {0: 'Auto', 1: 'On', 2: 'Off', 3: 'Red Eye Reduction'}), 0x1011: ('FlashStrength', ), 0x1020: ('Macro', {0: 'Off', 1: 'On'}), 0x1021: ('FocusMode', {0: 'Auto', 1: 'Manual'}), 0x1030: ('SlowSync', {0: 'Off', 1: 'On'}), 0x1031: ('PictureMode', {0: 'Auto', 1: 'Portrait', 2: 'Landscape', 4: 'Sports', 5: 'Night', 6: 'Program AE', 256: 'Aperture Priority AE', 512: 'Shutter Priority AE', 768: 'Manual Exposure'}), 0x1100: ('MotorOrBracket', {0: 'Off', 1: 'On'}), 0x1300: ('BlurWarning', {0: 'Off', 1: 'On'}), 0x1301: ('FocusWarning', {0: 'Off', 1: 'On'}), 0x1302: ('AEWarning', {0: 'Off', 1: 'On'}), } MAKERNOTE_CANON_TAGS = { 0x0006: ('ImageType', ), 0x0007: ('FirmwareVersion', ), 0x0008: ('ImageNumber', ), 0x0009: ('OwnerName', ), } # this is in element offset, name, optional value dictionary format MAKERNOTE_CANON_TAG_0x001 = { 1: ('Macromode', {1: 'Macro', 2: 'Normal'}), 2: ('SelfTimer', ), 3: ('Quality', {2: 'Normal', 3: 'Fine', 5: 'Superfine'}), 4: ('FlashMode', {0: 'Flash Not Fired', 1: 'Auto', 2: 'On', 3: 'Red-Eye Reduction', 4: 'Slow Synchro', 5: 'Auto + Red-Eye Reduction', 6: 'On + Red-Eye Reduction', 16: 'external flash'}), 5: ('ContinuousDriveMode', {0: 'Single Or Timer', 1: 'Continuous'}), 7: ('FocusMode', {0: 'One-Shot', 1: 'AI Servo', 2: 'AI Focus', 3: 'MF', 4: 'Single', 5: 'Continuous', 6: 'MF'}), 10: ('ImageSize', {0: 'Large', 1: 'Medium', 2: 'Small'}), 11: ('EasyShootingMode', {0: 'Full Auto', 1: 'Manual', 2: 'Landscape', 3: 'Fast Shutter', 4: 'Slow Shutter', 5: 'Night', 6: 'B&W', 7: 'Sepia', 8: 'Portrait', 9: 'Sports', 10: 'Macro/Close-Up', 11: 'Pan Focus'}), 12: ('DigitalZoom', {0: 'None', 1: '2x', 2: '4x'}), 13: ('Contrast', {0xFFFF: 'Low', 0: 'Normal', 1: 'High'}), 14: ('Saturation', {0xFFFF: 'Low', 0: 'Normal', 1: 'High'}), 15: ('Sharpness', {0xFFFF: 'Low', 0: 'Normal', 1: 'High'}), 16: ('ISO', {0: 'See ISOSpeedRatings Tag', 15: 'Auto', 16: '50', 17: '100', 18: '200', 19: '400'}), 17: ('MeteringMode', {3: 'Evaluative', 4: 'Partial', 5: 'Center-weighted'}), 18: ('FocusType', {0: 'Manual', 1: 'Auto', 3: 'Close-Up (Macro)', 8: 'Locked (Pan Mode)'}), 19: ('AFPointSelected', {0x3000: 'None (MF)', 0x3001: 'Auto-Selected', 0x3002: 'Right', 0x3003: 'Center', 0x3004: 'Left'}), 20: ('ExposureMode', {0: 'Easy Shooting', 1: 'Program', 2: 'Tv-priority', 3: 'Av-priority', 4: 'Manual', 5: 'A-DEP'}), 23: ('LongFocalLengthOfLensInFocalUnits', ), 24: ('ShortFocalLengthOfLensInFocalUnits', ), 25: ('FocalUnitsPerMM', ), 28: ('FlashActivity', {0: 'Did Not Fire', 1: 'Fired'}), 29: ('FlashDetails', {14: 'External E-TTL', 13: 'Internal Flash', 11: 'FP Sync Used', 7: '2nd("Rear")-Curtain Sync Used', 4: 'FP Sync Enabled'}), 32: ('FocusMode', {0: 'Single', 1: 'Continuous'}), } MAKERNOTE_CANON_TAG_0x004 = { 7: ('WhiteBalance', {0: 'Auto', 1: 'Sunny', 2: 'Cloudy', 3: 'Tungsten', 4: 'Fluorescent', 5: 'Flash', 6: 'Custom'}), 9: ('SequenceNumber', ), 14: ('AFPointUsed', ), 15: ('FlashBias', {0xFFC0: '-2 EV', 0xFFCC: '-1.67 EV', 0xFFD0: '-1.50 EV', 0xFFD4: '-1.33 EV', 0xFFE0: '-1 EV', 0xFFEC: '-0.67 EV', 0xFFF0: '-0.50 EV', 0xFFF4: '-0.33 EV', 0x0000: '0 EV', 0x000C: '0.33 EV', 0x0010: '0.50 EV', 0x0014: '0.67 EV', 0x0020: '1 EV', 0x002C: '1.33 EV', 0x0030: '1.50 EV', 0x0034: '1.67 EV', 0x0040: '2 EV'}), 19: ('SubjectDistance', ), } # extract multibyte integer in Motorola format (little endian) def s2n_motorola(str): x = 0 for c in str: x = (x << 8) | ord(c) return x # extract multibyte integer in Intel format (big endian) def s2n_intel(str): x = 0 y = 0L for c in str: x = x | (ord(c) << y) y = y + 8 return x # ratio object that eventually will be able to reduce itself to lowest # common denominator for printing def gcd(a, b): if b == 0: return a else: return gcd(b, a % b) class Ratio: def __init__(self, num, den): self.num = num self.den = den def __repr__(self): self.reduce() if self.den == 1: return str(self.num) return '%d/%d' % (self.num, self.den) def reduce(self): div = gcd(self.num, self.den) if div > 1: self.num = self.num / div self.den = self.den / div # for ease of dealing with tags class IFD_Tag: def __init__(self, printable, tag, field_type, values, field_offset, field_length): # printable version of data self.printable = printable # tag ID number self.tag = tag # field type as index into FIELD_TYPES self.field_type = field_type # offset of start of field in bytes from beginning of IFD self.field_offset = field_offset # length of data field in bytes self.field_length = field_length # either a string or array of data items self.values = values def __str__(self): return self.printable def __repr__(self): try: s= '(0x%04X) %s=%s @ %d' % (self.tag, FIELD_TYPES[self.field_type][2], self.printable, self.field_offset) except: s= '(%s) %s=%s @ %s' % (str(self.tag), FIELD_TYPES[self.field_type][2], self.printable, str(self.field_offset)) return s # class that handles an EXIF header class EXIF_header: def __init__(self, file, endian, offset, fake_exif, strict, debug=0): self.file = file self.endian = endian self.offset = offset self.fake_exif = fake_exif self.strict = strict self.debug = debug self.tags = {} # convert slice to integer, based on sign and endian flags # usually this offset is assumed to be relative to the beginning of the # start of the EXIF information. For some cameras that use relative tags, # this offset may be relative to some other starting point. def s2n(self, offset, length, signed=0): self.file.seek(self.offset+offset) slice=self.file.read(length) if self.endian == 'I': val=s2n_intel(slice) else: val=s2n_motorola(slice) # Sign extension ? if signed: msb=1L << (8*length-1) if val & msb: val=val-(msb << 1) return val # convert offset to string def n2s(self, offset, length): s = '' for dummy in range(length): if self.endian == 'I': s = s + chr(offset & 0xFF) else: s = chr(offset & 0xFF) + s offset = offset >> 8 return s # return first IFD def first_IFD(self): return self.s2n(4, 4) # return pointer to next IFD def next_IFD(self, ifd): entries=self.s2n(ifd, 2) return self.s2n(ifd+2+12*entries, 4) # return list of IFDs in header def list_IFDs(self): i=self.first_IFD() a=[] while i: a.append(i) i=self.next_IFD(i) return a # return list of entries in this IFD def dump_IFD(self, ifd, ifd_name, dict=EXIF_TAGS, relative=0, stop_tag='UNDEF'): entries=self.s2n(ifd, 2) for i in range(entries): # entry is index of start of this IFD in the file entry = ifd + 2 + 12 * i tag = self.s2n(entry, 2) # get tag name early to avoid errors, help debug tag_entry = dict.get(tag) if tag_entry: tag_name = tag_entry[0] else: tag_name = 'Tag 0x%04X' % tag # ignore certain tags for faster processing if not (not detailed and tag in IGNORE_TAGS): field_type = self.s2n(entry + 2, 2) # unknown field type if not 0 < field_type < len(FIELD_TYPES): if not self.strict: continue else: raise ValueError('unknown type %d in tag 0x%04X' % (field_type, tag)) typelen = FIELD_TYPES[field_type][0] count = self.s2n(entry + 4, 4) # Adjust for tag id/type/count (2+2+4 bytes) # Now we point at either the data or the 2nd level offset offset = entry + 8 # If the value fits in 4 bytes, it is inlined, else we # need to jump ahead again. if count * typelen > 4: # offset is not the value; it's a pointer to the value # if relative we set things up so s2n will seek to the right # place when it adds self.offset. Note that this 'relative' # is for the Nikon type 3 makernote. Other cameras may use # other relative offsets, which would have to be computed here # slightly differently. if relative: tmp_offset = self.s2n(offset, 4) offset = tmp_offset + ifd - 8 if self.fake_exif: offset = offset + 18 else: offset = self.s2n(offset, 4) field_offset = offset if field_type == 2: # special case: null-terminated ASCII string # XXX investigate # sometimes gets too big to fit in int value if count != 0 and count < (2**31): self.file.seek(self.offset + offset) values = self.file.read(count) #print values # Drop any garbage after a null. values = values.split('\x00', 1)[0] else: values = '' else: values = [] signed = (field_type in [6, 8, 9, 10]) # XXX investigate # some entries get too big to handle could be malformed # file or problem with self.s2n if count < 1000: for dummy in range(count): if field_type in (5, 10): # a ratio value = Ratio(self.s2n(offset, 4, signed), self.s2n(offset + 4, 4, signed)) else: value = self.s2n(offset, typelen, signed) values.append(value) offset = offset + typelen # The test above causes problems with tags that are # supposed to have long values! Fix up one important case. elif tag_name == 'MakerNote' : for dummy in range(count): value = self.s2n(offset, typelen, signed) values.append(value) offset = offset + typelen #else : # print "Warning: dropping large tag:", tag, tag_name # now 'values' is either a string or an array if count == 1 and field_type != 2: printable=str(values[0]) elif count > 50 and len(values) > 20 : printable=str( values[0:20] )[0:-1] + ", ... ]" else: printable=str(values) # compute printable version of values if tag_entry: if len(tag_entry) != 1: # optional 2nd tag element is present if callable(tag_entry[1]): # call mapping function printable = tag_entry[1](values) else: printable = '' for i in values: # use lookup table for this tag printable += tag_entry[1].get(i, repr(i)) self.tags[ifd_name + ' ' + tag_name] = IFD_Tag(printable, tag, field_type, values, field_offset, count * typelen) if self.debug: print ' debug: %s: %s' % (tag_name, repr(self.tags[ifd_name + ' ' + tag_name])) if tag_name == stop_tag: break # extract uncompressed TIFF thumbnail (like pulling teeth) # we take advantage of the pre-existing layout in the thumbnail IFD as # much as possible def extract_TIFF_thumbnail(self, thumb_ifd): entries = self.s2n(thumb_ifd, 2) # this is header plus offset to IFD ... if self.endian == 'M': tiff = 'MM\x00*\x00\x00\x00\x08' else: tiff = 'II*\x00\x08\x00\x00\x00' # ... plus thumbnail IFD data plus a null "next IFD" pointer self.file.seek(self.offset+thumb_ifd) tiff += self.file.read(entries*12+2)+'\x00\x00\x00\x00' # fix up large value offset pointers into data area for i in range(entries): entry = thumb_ifd + 2 + 12 * i tag = self.s2n(entry, 2) field_type = self.s2n(entry+2, 2) typelen = FIELD_TYPES[field_type][0] count = self.s2n(entry+4, 4) oldoff = self.s2n(entry+8, 4) # start of the 4-byte pointer area in entry ptr = i * 12 + 18 # remember strip offsets location if tag == 0x0111: strip_off = ptr strip_len = count * typelen # is it in the data area? if count * typelen > 4: # update offset pointer (nasty "strings are immutable" crap) # should be able to say "tiff[ptr:ptr+4]=newoff" newoff = len(tiff) tiff = tiff[:ptr] + self.n2s(newoff, 4) + tiff[ptr+4:] # remember strip offsets location if tag == 0x0111: strip_off = newoff strip_len = 4 # get original data and store it self.file.seek(self.offset + oldoff) tiff += self.file.read(count * typelen) # add pixel strips and update strip offset info old_offsets = self.tags['Thumbnail StripOffsets'].values old_counts = self.tags['Thumbnail StripByteCounts'].values for i in range(len(old_offsets)): # update offset pointer (more nasty "strings are immutable" crap) offset = self.n2s(len(tiff), strip_len) tiff = tiff[:strip_off] + offset + tiff[strip_off + strip_len:] strip_off += strip_len # add pixel strip to end self.file.seek(self.offset + old_offsets[i]) tiff += self.file.read(old_counts[i]) self.tags['TIFFThumbnail'] = tiff # decode all the camera-specific MakerNote formats # Note is the data that comprises this MakerNote. The MakerNote will # likely have pointers in it that point to other parts of the file. We'll # use self.offset as the starting point for most of those pointers, since # they are relative to the beginning of the file. # # If the MakerNote is in a newer format, it may use relative addressing # within the MakerNote. In that case we'll use relative addresses for the # pointers. # # As an aside: it's not just to be annoying that the manufacturers use # relative offsets. It's so that if the makernote has to be moved by the # picture software all of the offsets don't have to be adjusted. Overall, # this is probably the right strategy for makernotes, though the spec is # ambiguous. (The spec does not appear to imagine that makernotes would # follow EXIF format internally. Once they did, it's ambiguous whether # the offsets should be from the header at the start of all the EXIF info, # or from the header at the start of the makernote.) def decode_maker_note(self): note = self.tags['EXIF MakerNote'] # Some apps use MakerNote tags but do not use a format for which we # have a description, so just do a raw dump for these. #if self.tags.has_key('Image Make'): make = self.tags['Image Make'].printable #else: # make = '' # model = self.tags['Image Model'].printable # unused # Nikon # The maker note usually starts with the word Nikon, followed by the # type of the makernote (1 or 2, as a short). If the word Nikon is # not at the start of the makernote, it's probably type 2, since some # cameras work that way. if 'NIKON' in make: if note.values[0:7] == [78, 105, 107, 111, 110, 0, 1]: if self.debug: print "Looks like a type 1 Nikon MakerNote." self.dump_IFD(note.field_offset+8, 'MakerNote', dict=MAKERNOTE_NIKON_OLDER_TAGS) elif note.values[0:7] == [78, 105, 107, 111, 110, 0, 2]: if self.debug: print "Looks like a labeled type 2 Nikon MakerNote" if note.values[12:14] != [0, 42] and note.values[12:14] != [42L, 0L]: raise ValueError("Missing marker tag '42' in MakerNote.") # skip the Makernote label and the TIFF header self.dump_IFD(note.field_offset+10+8, 'MakerNote', dict=MAKERNOTE_NIKON_NEWER_TAGS, relative=1) else: # E99x or D1 if self.debug: print "Looks like an unlabeled type 2 Nikon MakerNote" self.dump_IFD(note.field_offset, 'MakerNote', dict=MAKERNOTE_NIKON_NEWER_TAGS) return # Olympus if make.startswith('OLYMPUS'): self.dump_IFD(note.field_offset+8, 'MakerNote', dict=MAKERNOTE_OLYMPUS_TAGS) # XXX TODO #for i in (('MakerNote Tag 0x2020', MAKERNOTE_OLYMPUS_TAG_0x2020),): # self.decode_olympus_tag(self.tags[i[0]].values, i[1]) #return # Casio if 'CASIO' in make or 'Casio' in make: self.dump_IFD(note.field_offset, 'MakerNote', dict=MAKERNOTE_CASIO_TAGS) return # Fujifilm if make == 'FUJIFILM': # bug: everything else is "Motorola" endian, but the MakerNote # is "Intel" endian endian = self.endian self.endian = 'I' # bug: IFD offsets are from beginning of MakerNote, not # beginning of file header offset = self.offset self.offset += note.field_offset # process note with bogus values (note is actually at offset 12) self.dump_IFD(12, 'MakerNote', dict=MAKERNOTE_FUJIFILM_TAGS) # reset to correct values self.endian = endian self.offset = offset return # Canon if make == 'Canon': self.dump_IFD(note.field_offset, 'MakerNote', dict=MAKERNOTE_CANON_TAGS) for i in (('MakerNote Tag 0x0001', MAKERNOTE_CANON_TAG_0x001), ('MakerNote Tag 0x0004', MAKERNOTE_CANON_TAG_0x004)): try: self.canon_decode_tag(self.tags[i[0]].values, i[1]) # gd added except KeyError: pass return # XXX TODO decode Olympus MakerNote tag based on offset within tag def olympus_decode_tag(self, value, dict): pass # decode Canon MakerNote tag based on offset within tag # see http://www.burren.cx/david/canon.html by David Burren def canon_decode_tag(self, value, dict): for i in range(1, len(value)): x=dict.get(i, ('Unknown', )) if self.debug: print i, x name=x[0] if len(x) > 1: val=x[1].get(value[i], 'Unknown') else: val=value[i] # it's not a real IFD Tag but we fake one to make everybody # happy. this will have a "proprietary" type self.tags['MakerNote '+name]=IFD_Tag(str(val), None, 0, None, None, None) # process an image file (expects an open file object) # this is the function that has to deal with all the arbitrary nasty bits # of the EXIF standard def process_file(f, stop_tag='UNDEF', details=True, strict=False, debug=False): # yah it's cheesy... global detailed detailed = details # by default do not fake an EXIF beginning fake_exif = 0 # determine whether it's a JPEG or TIFF data = f.read(12) if data[0:4] in ['II*\x00', 'MM\x00*']: # it's a TIFF file f.seek(0) endian = f.read(1) f.read(1) offset = 0 elif data[0:2] == '\xFF\xD8': # it's a JPEG file if debug: print "JPEG format recognized." base = 0 while data[2] == '\xFF' and data[6:10] in ('JFIF', 'JFXX', 'OLYM', 'Phot'): length = ord(data[4])*256+ord(data[5]) f.read(length-8) # fake an EXIF beginning of file data = '\xFF\x00'+f.read(10) fake_exif = 1 base = base + length # Big ugly patch to deal with APP2 (or other) data coming before APP1 f.seek(0) data = f.read(base+4000) # in theory, this could be insufficient --gd base = 2 while 1: if data[base:base+2]=='\xFF\xE1': # APP1 #print "APP1 at base",hex(base) #print "Length",hex(ord(data[base+2])), hex(ord(data[base+3])) #print "Code",data[base+4:base+8] if data[base+4:base+8] == "Exif": base = base-2 break base=base+ord(data[base+2])*256+ord(data[base+3])+2 elif data[base:base+2]=='\xFF\xE2': # APP2 #print "APP2 at base",hex(base) #print "Length",hex(ord(data[base+2])), hex(ord(data[base+3])) #print "Code",data[base+4:base+8] base=base+ord(data[base+2])*256+ord(data[base+3])+2 elif data[base:base+2]=='\xFF\xE0': # APP0 #print "APP0 at base",hex(base) #print "Length",hex(ord(data[base+2])), hex(ord(data[base+3])) #print "Code",data[base+4:base+8] base=base+ord(data[base+2])*256+ord(data[base+3])+2 else: break f.seek(base+12) if data[2+base] == '\xFF' and data[6+base:10+base] == 'Exif': # detected EXIF header offset = f.tell() endian = f.read(1) #HACK TEST: endian = 'M' else: # no EXIF information if debug: print "no EXIF header" if debug: print "Had",hex(ord(data[2+base])) , "and", data[6+base:10+base] return {} else: # file format not recognized if debug: print "file format not recognized" return {} # deal with the EXIF info we found if debug: print {'I': 'Intel', 'M': 'Motorola'}[endian], 'format' hdr = EXIF_header(f, endian, offset, fake_exif, strict, debug) ifd_list = hdr.list_IFDs() ctr = 0 for i in ifd_list: if ctr == 0: IFD_name = 'Image' elif ctr == 1: IFD_name = 'Thumbnail' thumb_ifd = i else: IFD_name = 'IFD %d' % ctr if debug: print ' IFD %d (%s) at offset %d:' % (ctr, IFD_name, i) hdr.dump_IFD(i, IFD_name, stop_tag=stop_tag) # EXIF IFD exif_off = hdr.tags.get(IFD_name+' ExifOffset') if exif_off: if debug: print ' EXIF SubIFD at offset %d:' % exif_off.values[0] hdr.dump_IFD(exif_off.values[0], 'EXIF', stop_tag=stop_tag) # Interoperability IFD contained in EXIF IFD intr_off = hdr.tags.get('EXIF SubIFD InteroperabilityOffset') if intr_off: if debug: print ' EXIF Interoperability SubSubIFD at offset %d:' \ % intr_off.values[0] hdr.dump_IFD(intr_off.values[0], 'EXIF Interoperability', dict=INTR_TAGS, stop_tag=stop_tag) # GPS IFD gps_off = hdr.tags.get(IFD_name+' GPSInfo') if gps_off: if debug: print ' GPS SubIFD at offset %d:' % gps_off.values[0] hdr.dump_IFD(gps_off.values[0], 'GPS', dict=GPS_TAGS, stop_tag=stop_tag) ctr += 1 # extract uncompressed TIFF thumbnail thumb = hdr.tags.get('Thumbnail Compression') if thumb and thumb.printable == 'Uncompressed TIFF': hdr.extract_TIFF_thumbnail(thumb_ifd) # JPEG thumbnail (thankfully the JPEG data is stored as a unit) thumb_off = hdr.tags.get('Thumbnail JPEGInterchangeFormat') if thumb_off: f.seek(offset+thumb_off.values[0]) size = hdr.tags['Thumbnail JPEGInterchangeFormatLength'].values[0] hdr.tags['JPEGThumbnail'] = f.read(size) # deal with MakerNote contained in EXIF IFD # (Some apps use MakerNote tags but do not use a format for which we # have a description, do not process these). if 'EXIF MakerNote' in hdr.tags and 'Image Make' in hdr.tags and detailed: hdr.decode_maker_note() # Sometimes in a TIFF file, a JPEG thumbnail is hidden in the MakerNote # since it's not allowed in a uncompressed TIFF IFD if 'JPEGThumbnail' not in hdr.tags: thumb_off=hdr.tags.get('MakerNote JPEGThumbnail') if thumb_off: f.seek(offset+thumb_off.values[0]) hdr.tags['JPEGThumbnail']=file.read(thumb_off.field_length) return hdr.tags # show command line usage def usage(exit_status): msg = 'Usage: EXIF.py [OPTIONS] file1 [file2 ...]\n' msg += 'Extract EXIF information from digital camera image files.\n\nOptions:\n' msg += '-q --quick Do not process MakerNotes.\n' msg += '-t TAG --stop-tag TAG Stop processing when this tag is retrieved.\n' msg += '-s --strict Run in strict mode (stop on errors).\n' msg += '-d --debug Run in debug mode (display extra info).\n' print msg sys.exit(exit_status) # library test/debug function (dump given files) if __name__ == '__main__': import sys import getopt # parse command line options/arguments try: opts, args = getopt.getopt(sys.argv[1:], "hqsdt:v", ["help", "quick", "strict", "debug", "stop-tag="]) except getopt.GetoptError: usage(2) if args == []: usage(2) detailed = True stop_tag = 'UNDEF' debug = False strict = False for o, a in opts: if o in ("-h", "--help"): usage(0) if o in ("-q", "--quick"): detailed = False if o in ("-t", "--stop-tag"): stop_tag = a if o in ("-s", "--strict"): strict = True if o in ("-d", "--debug"): debug = True # output info for each file for filename in args: try: file=open(filename, 'rb') except: print "'%s' is unreadable\n"%filename continue print filename + ':' # get the tags data = process_file(file, stop_tag=stop_tag, details=detailed, strict=strict, debug=debug) if not data: print 'No EXIF information found' continue x=data.keys() x.sort() for i in x: if i in ('JPEGThumbnail', 'TIFFThumbnail'): continue try: print ' %s (%s): %s' % \ (i, FIELD_TYPES[data[i].field_type][2], data[i].printable) except: print 'error', i, '"', data[i], '"' if 'JPEGThumbnail' in data: print 'File has JPEG thumbnail' print ./PhotoImage.py0000664000076400007640000000534010661071020010546 0ustar ############################################################################## # # Photo for Zope # # Copyright (c) 2001 Logic Etc, Inc. All rights reserved. # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA # # Ron Bickers rbickers@logicetc.com # Logic Etc, Inc. http://www.logicetc.com/ # ############################################################################## """PhotoImage This is used as a wrapper for Photo to provide a common interface for both Zope Image objects and ExtImage objects. """ from cStringIO import StringIO from AccessControl import ClassSecurityInfo from Globals import InitializeClass from OFS.Image import Image import time class PhotoImage(Image): """Interface to Zope Image.""" security=ClassSecurityInfo() def __init__(self, id, title='', file='', content_type='', precondition='', path=''): PhotoImage.inheritedAttribute('__init__')(self, id, title, file, content_type, precondition) def _height(self): return self.height def _width(self): return self.width def _content_type(self): return self.content_type def _size(self): return self.size def _age(self): mtime = self.bobobase_modification_time().timeTime() / 60 now = time.time() / 60 return int(now - mtime) security.declareProtected('View', 'index_html') def index_html(self, REQUEST, RESPONSE): return PhotoImage.inheritedAttribute('index_html')(self, REQUEST, RESPONSE) def _data(self): return str(self.data) _IMdata = _data def data_as_stream(self): return StringIO(str(self.data)) def _PILdata(self): return StringIO(str(self.data)) def _newImage(self, id, file, path): return PhotoImage(id, '', file, self._content_type()) def _isValid(self): return self.width and self.height and self.data and self.content_type security.declareProtected('Change Photo', 'manage_upload') def manage_upload(self, file, content_type): return PhotoImage.inheritedAttribute('manage_upload')(self, file) InitializeClass(PhotoImage) ./FAQ.txt0000664000076400007640000000403610111151656007315 0ustar Photo FAQ --------- 1) Will you add property 'xyz' to the default Photo properites? In short, no. I purposefully left the properties to the minimum required id and title because everyone will want a different set of properties. I've gotten numerous requests for equally numerous different default properties. The Photo Folder object is designed to provide containing Photo objects with whatever default properties you want. It works like this: 1) Add a Photo Folder object. 2) Go to the 'Photo Properties' tab and add the properties you want each photo to have. 3) Go to the 'Displays' tab and add/remove/modify the display sizes you want each photo to have. 4) When you add photos to this Photo Folder, each one will automatically get the specified properties and generate the specified display sizes. 2) How do I add a Photo Folder/Photo object from DTML/Python Script? See the source for all of the optional parameters, but here are the basics: Photo Folder: context.manage_addProduct['Photo'].manage_addPhotoFolder(id, title) Photo: context.manage_addProduct['Photo'].manage_addPhoto(id, title, file) 3) How do I copy the EXIF creation date into a property The Photo product reads the EXIF values into a separate property sheet, because there are so many of little use, and they clutter up your own properties. If there is an EXIF property you want to show on all photos you can use this python script to copy it to a general property. for photo in container.objectValues('Photo'): exifprop = photo.propertysheets.get('exif') if exifprop is not None: for (key,value) in exifprop.propertyItems(): # This is about the only useful EXIF value if key == "EXIF_DateTimeOriginal": photo.manage_addProperty("created_date",value, "string") ./Photo.pyc0000644000016000001700000005123210630663044011527 0ustar zopezopem 5?c @sdZdkZdkZdklZlZdklZdkl Z dk l Z dk l Z dklZdklZd klZd klZlZd klZyd klZd klZWnej onXdklZy dkZ Wnej onXdk!Z!hdddf<dddf<dddf<dddf<dddf<dddfZ(e id?d@dAZ)e idBdCdDdEdFZ*dGZ+dHZ,e idId e-dJe.Z/e idId e-dKe.Z0e id?dLdedMZ1e idIde-dNe.Z2e idOdPedQZ3e idIde-dRe.Z4e idOdSeedTZ5e idOdUedVZ6e idOdWedXZ7e id?dYedZZ8e id?d[eed\Z9e id?d]eed^Z:d_Z;d`Z<daZ=RS(dsPhoto object. Photo objects contain as properties a series of resized Zope Image objects according to the given display sizes. RtidttitlettypetstringtmodetwtlabeltEdittactiontmanage_editPhotoFormtViewtmanage_viewPhototSettingstmanage_editSettingsFormtDisplaystmanage_editDisplaysFormttImaget ImageMagickiKic Csd|_||_||_|iidd|iid} | id|d| id|d| id|d| id| d | id | dti|_h|_dS( Ns1.2.3t photoconftstoreR tenginetqualitytinttpregentbooleanttimeout(tselft __version__RRtpropertysheetstmanage_addPropertySheettgetRtmanage_addPropertyRRRRR!tdefaultdisplaystcopyt _displayst_photos( R"RRtfilet content_typet preconditionRRRRR!R((t9/var/lib/zope2.9/instance/Classic/Products/Photo/Photo.pyt__init__Ys   sAccess contents informationtheightcCs |iiS(sOriginal photo height.N(R"t _originalt_height(R"((R/R1rstwidthcCs |iiS(sOriginal photo width.N(R"R2t_width(R"((R/R4wstsizecCs |iiS(sOriginal photo size in bytes.N(R"R2t_size(R"((R/R6|sR-cCs |iiS(sOriginal photo content_type.N(R"R2t _content_type(R"((R/R-sttagc Ks.|djo|iiidd}n|dj o|ii|ou|i|p|i |dn|i |} | i | i }}|o |iiid|ddqn|ii }|ii }|od|i|f} nd|i} |djot|dd}n|djo|i}nd | t|f} |od | |f} n|od | |f} nd tti|ijod | } n|dj od| |f} nx6|iD](}|i|} d| || f} qWd| } | S(sReturn HTML img tag.tdisplayitpatht/s%sN("R:tNoneR"tREQUESTtcookiesR&R*thas_keyt _isGeneratedt_makeDisplayPhotoR+timageR5R3R4R1tcookietRESPONSEt setCookieR2t absolute_urltresulttalttgetattrtgetIdt html_quotetmapR tlowertkwtkeyst css_classtkeytvalue( R"R:R1R4RERJRRRPRSRTRIRD((R/R9sD   $     texttagcKsl|djo|iiidd}n|dj o|ii|ou|i|p|i |dn|i |} | i | i }}|o |iiid|ddqn|ddjo|d}n|o|i |i} n |ii} t| tgjo|ti| d} n || } d| } |djot|dd}n|djo|i}nd | t|f} |od | |f} n|od | |f} nd tti|i!jod | } n|dj od| |f} nx6|i!D](} |i| } d| | | f} q2Wd| } | S(s-Return HTML img tag for serving outside Zope.R:iR;R<is %sN(%R:R>R"R?R@R&R*RARBRCR+RDR5R3R4R1RERFRGtprefixtfilenameR2R R tjoinRIRJRKRLRMRNRORPRQRRRSRT(R"RVR:R1R4RERJRRRPRSRTRIRDRW((R/RUsL   $        cCs |iS(N(R"R9(R"((R/t__str__st displayIdsRcCsc|ii}|o3x0|D]$}||jo|i|qqWn|i|id|S(sReturn list of display Ids.cCs5t||d||d||d||dS(Nii(tcmptdtxty(R]R^R\((R/t sN(R"R*RQtidstexcludeRtremovetsort(R"RaR`R((R/RZs t displayLinkscCsEg}x8|i|D]'}|id|id||fqW|S(s*Return list of HTML tags for displays.s%stURLN(tlinksR"RZRaR:tappendR?(R"RaR:Rf((R/Rds %t displayMapcCsg}x|i|D]}|i|oP|i|i}|i|i }|i|i }|i|i }nd \}}}}|ihd|<d|i|d<d|i|d<d|<d|<d|<d |<qW|S( s'Return list of displays with size info.RR4iR1it photo_widtht photo_heighttbytestageN(NNNN(tdisplaysR"RZRaRRBR+R5RiR3RjR7Rkt_ageRlR>RgR*(R"RaRiRkRlRmRRj((R/Rhsft index_htmlcCs|o|ii|o|i|p|i|dnX|iidid}|o5|i |i |djo|i |f|n|i |i ||Sn|ii ||S(sReturn the image data.iRR!iN(R:R"R*RARBRCR$R&t getPropertyR!R+Rnt_expireDisplaysRoR?RFR2(R"R?RFR:R!((R/Ro,s%t nextPhotocCse|i}|iidg}|i||djodSnt|i||i |dS(sReturn next Photo in folder.RiiN( R"RLRt aq_parentt objectIdstphotoIdsRcR>RKtindex(R"RuR((R/Rr?s  t prevPhotocCse|i}|iidg}|i||djodSnt|i||i |dS(s Return previous Photo in folder.RiiN( R"RLRRsRtRuRcR>RKRv(R"RuR((R/RwIs  tget_sizecCs |iiS(s'Return size in bytes of original photo.N(R"R2Rx(R"((R/RxSsc CsL|i} t}|djobyPtii| i }|i }|i ||f}|i||d|Wq;dSq;Xn|djotidjo3dkl} | d|||fd\} } n-dkl} | d|||f\} } | i| i| i|i| i| in|id |S( sResize and resample photo.tPILRRRtwin32(spopen2s'convert -quality %s -geometry %sx%s - -tbiN(R"R2torigimgtStringIOtnewimgRRyRtopent_PILdatatimgtformattfmttresizeR4R1tsaveRtsystplatformt win32pipetpopen2timgintimgouttwritet_IMdatatclosetreadtseek( R"R:R4R1RRRR~RRRRR|((R/t_resize[s0          cCs|i|\}}|djo/|djo"|ii}|ii}n|i||\}}|i i di d}|i i di d}|i|||||S(s(Return raw photo data for given display.iRRRN(R"R*R:R4R1R2R5R3t_getAspectRatioSizeR$R&RpRRR(R"R:RR1R4R((R/t_getDisplayDataxscCsy5ti|id\}}|d|d|}Wn$tj o|id|}nX|ii ||i ||i dS(s&Return photo object for given display.t.t_iN( R tsplitR"RtbasetextR:t ValueErrorR2t _newImageRRH(R"R:RRR((R/t_getDisplayPhotoscCs{|i|p|o`|i}|i|o'||i|i||i n|i |||<||_ndS(sCreate given display.N( R"t_shouldGenerateR:tforceR+tphotoRAt manage_uploadRR-R(R"R:RR((R/RCs 'cCs+x$|iiD]}|i|qWdS(sCreate all displays.N(R"R*RQR:RC(R"R:((R/t_makeDisplayPhotosscCsr|i|i}}y9||||jo|||}n|||}Wnd}d}nX||fS(s3Return proportional dimensions within desired size.iN(R"R4R1t img_widtht img_height(R"R4R1RR((R/Rs cCs |iiS(s$At least see if it *might* be valid.N(R"R2t_isValid(R"((R/t _validImagescCs|ii|S(s*Return whether display has been generated.N(R"R+RAR:(R"R:((R/RBscCs)|i|p|iididS(s+Return whether display should be generated.RRN(R"RBR:R$R&Rp(R"R:((R/RscCs|djo|iidid}n|pdSn|i}xq|iiD]`}||jod|i|_ qT|i|i |jo||i dd||=qTqTW||_dS(s"Remove displays that have expired.RR!Ni(R!R>R"R$R&RpR+tphotosRQR\Rat _p_changedRntmanage_beforeDelete(R"RaR!R\R((R/Rqs   s Change PhototPUTcCs|i||t|do|i||ddn|d}t|do8|ii||i |i o|i qn|i |_ |id|S(sHandle HTTP PUT requests.tdav__simpleifhandlertrefreshitBODYFILER2iN(R"t dav__initR?RFthasattrRR,R2RR-RRRt_datat setStatus(R"R?RFR,((R/Rs   s FTP accesst manage_FTPgettmanage_FTPstattmanage_FTPlistcCs |iiS(sHandle GET requests.N(R"R2R(R"((R/RscCs|ii|S(sHandle STAT requests.N(R"R2RR?(R"R?((R/RscCs|ii|S(sHandle LIST requests.N(R"R2RR?(R"R?((R/RssView management screenssdtml/viewPhotosdtml/editPhotoFormtmanage_editPhotocCst|do|io tdn|i||oB|io8|ii ||i |i o|i qn|dj o|i|ddSndS(sChanges Photo information.t wl_isLockedsPhoto is locked via WebDAV.tmanage_tabs_messagesPhoto information updated.N(RR"RtResourceLockedErrortmanage_changePropertiesR?R,RWR2RR-RRR>R(R"R,R?((R/Rs     sdtml/editSettingsFormsManage propertiestmanage_editSettingscCsG|iid}|i||dj o|i|ddSndS(sEdit photo settings.RRsPhoto settings updated.N(R"R$R&Rtmanage_editPropertiesR?R>R(R"R?R((R/Rs    sdtml/editDisplaysFormtmanage_editDisplayscCs|i}|i}x|D]}||i|i|i fjp |djod|i|i f||i<|i |io4||ii dd|i|i||iRR?R(R"RmRR?R\RR:((R/Rs  -%    tmanage_delDisplayscCs|i}|i}x>|D]6}y&||=||idd||=WqqXqW||_||_|dj o|i |ddSndS(sDelete displays.RsDisplays deleted.N( R"R*R\R+RR`RRR>R?R(R"R`R?R\RR((R/R,s        tmanage_addDisplaycCs|i}|i}||f||<|i|o|i |||R(R"RR4R1R?R\R((R/R=s      tmanage_regenDisplayscCs2|i|dj o|i|ddSndS(sRegenerate all displays.RsDisplays regenerated.N(R"RR?R>R(R"R?((R/RKs    tmanage_purgeDisplayscCsr|djo&|dj o|iidg}n|i|pgd|dj o|i|ddSndS(sPurge generated displays.R`iRsDisplays purged.N(RaR>R?tformR&R"RqR(R"RaR?((R/RSs  tmanage_cleanDisplayscCso|djo&|dj o|iidg}n|i|pg|dj o|i|ddSndS(s/Purge all generated displays that have expired.R`RsExpired displays purged.N(RaR>R?RR&R"RqR(R"RaR?((R/R]s  cCs;|ii|x$|iiD]}|i|q WdS(sPrepare photos for cloning.N(R"R2tmanage_afterClonetitemR+tvaluesR(R"RR((R/Rjs cCs1t|dp|iidid}|djodkl}n|djodkl}n||i|i d|i d|_ |i i t |i|it|d |io|iqn|i i||t|d o.x+|iiD]}|i||qWnd S( sHandle pasting of new photos.R2RRR(s PhotoImagetExtImageR;iRR+N(RR"R$R&RpRt PhotoImaget ExtPhotoImageRRRHR2RR}RR-tdelattrRRtmanage_afterAddRt containerR+RR(R"RRRRR((R/Rps"  '"  cCsA|ii||x'|iiD]}|i||q#WdS(s'Delete (mark for undo) each photo file.N(R"R2RRRR+RR(R"RRR((R/Rs (R(R(>t__name__t __module__t__doc__tWriteLockInterfacet__implements__t NameErrort meta_typet _propertiestPropertyManagertmanage_optionst RoleManagertItemtClassSecurityInfotsecurityR0tdeclareProtectedR1R4R6R-R>R9RURYRZRdRhRoRrRwRxRRRRCRRRRBRRqRRRRtDTMLFiletglobalsRRRRRRRRRRRRRRR(((R/R>s  $o     6<                        sdtml/addPhotoFormRRRiKic  CsLt|||d}|i}t||d|||||| | } |i| _|i|| |i|}|i}|idjoo|iid}xD|iD]6\} }y |i| ||i| WqqXqW|i i!|_ n| dj o<y|i$}Wn| d}nX| i&i'd|n|S(sAdd Photo object.iRs Photo FolderRtURL1s%s/manage_mainN((tcookIdRRR,t dispatchert DestinationtdestRR-R.RRRRR!RRRt _setObjectt_getObR"RstparentRR$R&tpropst propertyItemstpropidRTR'tgetPropertyTypeR*R)R?R>tDestinationURLturlRFtredirect(RRRR,R-R.RRRR!RR?RRR"RRRRRT((R/tmanage_addPhotos2     ((RRR t OFS.ImageRRt AcquisitiontImplicittGlobalst PersistenttOFS.SimpleItemRtOFS.PropertyManagerRtOFS.PropertySheetst PropertySheettAccessControl.RoleRt AccessControlRtInitializeClassRtProducts.PythonScripts.standardRMtwebdav.WriteLockInterfaceRtwebdav.LockableRt ImportErrort cStringIOR}t PIL.ImageRyttimeR(RRtmanage_addPhotoFormR>R(RR(RRyRRRR RRRRRRRRR}RRRRRRM((R/t?s:            ` "Q!./PhotoImage.pyc0000644000016000001700000000552510630663075012502 0ustar zopezopem F/var/lib/zope2.9/instance/Classic/Products/Photo/PhotoImage.pyR,scCs|iS(N(Rtheight(R((R t_height/scCs|iS(N(Rtwidth(R((R t_width2scCs|iS(N(RR(R((R t _content_type5scCs|iS(N(Rtsize(R((R t_size8scCs4|iid}tid}t||S(Ni<(Rtbobobase_modification_timettimeTimetmtimettimetnowtint(RRR((R t_age;stViewt index_htmlcCstid|||S(NR(RRRtREQUESTtRESPONSE(RRR((R RAscCs t|iS(N(tstrRtdata(R((R t_dataDscCstt|iS(N(tStringIORRR(R((R t_PILdataIscCst|d||iS(NR(RRRRR(RRRR ((R t _newImageLscCs%|io|io|io|iS(N(RRR RR(R((R t_isValidOss Change Photot manage_uploadcCstid||S(NR%(RRRR(RRR((R R%Ss(t__name__t __module__t__doc__tClassSecurityInfotsecurityRR RRRRtdeclareProtectedRR t_IMdataR"R#R$R%(((R R's"            ( R(t cStringIOR!t AccessControlR)tGlobalstInitializeClasst OFS.ImagetImageRR(RR!R2R)R0R((R t?s     /./Extensions/0000775000076400007640000000000011152640350010301 5ustar ./Extensions/Upgrade.py0000664000076400007640000001403610057365036012256 0ustar ############################################################################## # # Photo for Zope # # Copyright (c) 2001 Logic Etc, Inc. All rights reserved. # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA # # Ron Bickers rbickers@logicetc.com # Logic Etc, Inc. http://www.logicetc.com/ # ############################################################################## """Upgrade These functions provides upgrade support for prior versions of Photo and Photo Folder objects. """ from string import join __version__ = '1.2.3' def upgrade_PhotoFolder(self): """Upgrade prior Photo Folder objects.""" # Already up to date? if hasattr(self, '__version__') and self.__version__ == __version__: return None # Upgrade 0.9.x/1.0.x/1.1.x to 1.2.0 if not hasattr(self, '__version__'): self.__version__ = '1.2.0' engine = self.engine store = self.store sheet=self.propertysheets.get('default') vself = sheet.v_self() delattr(vself, 'engine') delattr(vself, 'store') pself=sheet.p_self() pself._properties=tuple(filter(lambda i, n='engine': i['id'] != n, pself._properties)) pself._properties=tuple(filter(lambda i, n='store': i['id'] != n, pself._properties)) self.propertysheets.manage_addPropertySheet('photoconf', 'photoconf') self.propertysheets.get('photoconf').manage_addProperty('store', store, 'string') self.propertysheets.get('photoconf').manage_addProperty('engine', engine, 'string') # Upgrade 1.2.0 to 1.2.1 if self.__version__ < '1.2.1': self.__version__ = '1.2.1' self.propertysheets.get('photoconf').manage_addProperty('quality', 75, 'int') # Upgrade 1.2.1 to 1.2.2 if self.__version__ < '1.2.2': self.__version__ = '1.2.2' self.propertysheets.get('photoconf').manage_addProperty('pregen', 0, 'boolean') self.propertysheets.get('photoconf').manage_addProperty('timeout', 0, 'int') # Upgrade 1.2.2 to 1.2.3 if self.__version__ < '1.2.3': self.__version__ = '1.2.3' def upgrade_Photo(self): """Upgrade prior Photo objects.""" # Already up to date? if hasattr(self, '__version__') and self.__version__ == __version__: return None # Upgrade 0.9.x/1.0.x/1.1.x to 1.2.0 if not hasattr(self, '__version__'): self.__version__ = '1.2.0' engine = self.engine # Dig for store since I didn't bother saving it before. if hasattr(self._original, 'rawsize'): store = 'ExtImage' else: store = 'Image' sheet=self.propertysheets.get('default') vself = sheet.v_self() delattr(vself, 'engine') pself=sheet.p_self() pself._properties=tuple(filter(lambda i, n='engine': i['id'] != n, pself._properties)) self.propertysheets.manage_addPropertySheet('photoconf', 'photoconf') self.propertysheets.get('photoconf').manage_addProperty('engine', engine, 'string') self.propertysheets.get('photoconf').manage_addProperty('store', store, 'string') # Upgrade 1.2.0 to 1.2.1 if self.__version__ < '1.2.1': self.__version__ = '1.2.1' self.propertysheets.get('photoconf').manage_addProperty('quality', 75, 'int') # Upgrade 1.2.1 to 1.2.2 if self.__version__ < '1.2.2': self.__version__ = '1.2.2' self.propertysheets.get('photoconf').manage_addProperty('pregen', 0, 'boolean') self.propertysheets.get('photoconf').manage_addProperty('timeout', 0, 'int') # Upgrade 1.2.2 to 1.2.3 if self.__version__ < '1.2.3': self.__version__ = '1.2.3' # Fix older, maybe broken upgrades if not self.propertysheets.get('photoconf').hasProperty('store'): if hasattr(self._original, 'rawsize'): store = 'ExtImage' else: store = 'Image' self.propertysheets.get('photoconf').manage_addProperty('store', store, 'string') def upgrade(self, REQUEST=None): """Upgrade all Photo Folders and Photos in the tree.""" output = '

The following objects were upgraded:

' folders = self.ZopeFind(self, obj_metatypes=['Photo Folder'], search_sub=1) for (id, folder) in folders: upgrade_PhotoFolder(folder) output = output + ('Photo Folder ' + join(folder.getPhysicalPath(), '/') + '
\n') photos = self.ZopeFind(self, obj_metatypes=['Photo'], search_sub=1) for (id, photo) in photos: upgrade_Photo(photo) output = output + ('Photo ' + join(photo.getPhysicalPath(), '/') + '
\n') if REQUEST is not None: return output def version(self, REQUEST): """Show versions of all Photo Folders and Photos in the tree.""" output = '' folders = self.ZopeFind(self, obj_metatypes=['Photo Folder'], search_sub=1) for (id, folder) in folders: output = output + ('Photo Folder ' + join(folder.getPhysicalPath(), '/') + ' - ' + getattr(folder, '__version__', 'None') + '
\n') photos = self.ZopeFind(self, obj_metatypes=['Photo'], search_sub=1) for (id, photo) in photos: output = output + ('Photo ' + join(photo.getPhysicalPath(), '/') + ' - ' + getattr(photo, '__version__', 'None') + '
\n') return output ./ExtPhotoImage.pyc0000644000016000001700000000641210635764446013170 0ustar zopezopem wFc@scdZdklZdklZdklZdkZdk Z defdYZ ee dS(sExtPhotoImage This is used as a wrapper for Photo to provide a common interface for both Zope Image objects and ExtImage objects. (sClassSecurityInfo(sInitializeClass(sExtImageNt PhotoImagecBstZdZeZddddddZdZdZdZdZ ei ddd Z d Z ei d d d Z dZeZdZdZdZei dddZddZRS(sInterface to ExtImage.tcCs&||_tid|||dS(Nt__init__(tpathtselft_pathRtinheritedAttributetidt content_type(RRttitletfileRt preconditionR((tA/var/lib/zope2.9/instance/Classic/Products/Photo/ExtPhotoImage.pyR-s cCs |iS(N(Rtheight(R((R t_height1scCs |iS(N(Rtwidth(R((R t_width4scCs|iS(N(RR(R((R t _content_type7scCs |iS(N(Rtrawsize(R((R t_size:ssAccess contents informationtsizecCs |iS(N(RR(R((R R>scCs4|iid}tid}t||S(Ni<(Rtbobobase_modification_timettimeTimetmtimettimetnowtint(RRR((R t_ageAstViewt index_htmlcCstid|d|S(NRtREQUEST(RRRR(RRtRESPONSE((R RGscCst|i|idiS(Ntrb(topenRt _get_filenametfilenametread(R((R t_dataJscCs|i|iS(N(RR"R#(R((R t_PILdataOscCs,t|d|}|i||i|S(NR(RRRtimgtmanage_file_uploadR RR(RRR RR'((R t _newImageRscCs!|io|io|iS(N(RRR R(R((R t_isValidWss Change Photot manage_uploadcCs|i||S(N(RR(R R(RR R((R R+[sicCs|id|iS(Nt/(RRR(Rtrelative((R t absolute_urlcs(t__name__t __module__t__doc__tClassSecurityInfotsecurityRRRRRtdeclareProtectedRRRR%t_IMdataR&R)R*R+R.(((R R(s(              ( R1t AccessControlR2tGlobalstInitializeClasstProducts.ExtFile.ExtImagetExtImaget PIL.ImagetPILRR(RR<R2R8R:R((R t?s     >./ExtImage.py0000664000076400007640000005325710364667241010247 0ustar """ExtImage product module.""" ############################################################################### # # Copyright (c) 2001 Gregor Heine . 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). $Id: ExtImage.py 5740 2006-01-22 11:38:09Z roug $""" __version__='$Release: 1.1.3 $'[10:-2] import Globals from __main__ import * import Zope from ExtFile import * from Globals import InitializeClass, DTMLFile from DateTime import DateTime from types import IntType, StringType import urllib, os, string from os.path import join, isfile try: from cStringIO import StringIO except: from StringIO import StringIO NO_PREVIEW = 0 GENERATE = 1 UPLOAD_NORESIZE = 2 UPLOAD_RESIZE = 3 manage_addExtImageForm = DTMLFile('extImageAdd', globals()) def manage_addExtImage(self, id='', title='', descr='', file='', preview='', content_type='', create_prev=0, maxx='', maxy='', ratio=0, permission_check=0, REQUEST=None): """ Add a ExtImage to a folder """ if not id and hasattr(file,'filename'): # generate id from filename and make sure, it has no 'bad' chars id = file.filename title = title or id id = id[max(string.rfind(id,'/'), string.rfind(id,'\\'), string.rfind(id,':') )+1:] id = string.translate(id, TRANSMAP) self = self.this() tempExtImage = ExtImage(id, title, descr, permission_check) self._setObject(id, tempExtImage) 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: message = 'The ExtImage %s was successfully created!' % id return self.manage_main(self,REQUEST,manage_tabs_message=message) class ExtImage(ExtFile): security = ClassSecurityInfo() security.declareProtected('View management screens', 'manage_tabs') security.declareProtected('View management screens', 'manage_main') security.declareProtected('View management screens', 'manage_uploadForm') security.declareProtected('Change permissions', 'manage_access') security.declareProtected('Change ExtFile/ExtImage', 'manage_editExtFile') security.declareProtected('FTP access', 'manage_FTPstat') security.declareProtected('FTP access', 'manage_FTPget') security.declareProtected('FTP access', 'manage_FTPlist') security.declareProtected('View', 'index_html') security.declareProtected('View', 'icon_html') security.declareProtected('View', 'icon_gif') security.declareProtected('View', 'link') # what permissions make sense for us? # what do people think they're adding? meta_type = 'ExtImage' # default,min,max-sizes for the preview image _image_size={'default':256,'min':10,'max':999} ################################ # Init method # ################################ def __init__(self, id, title='', descr='', permission_check=0): """initialize a new instance of ExtImage""" ExtImage.inheritedAttribute("__init__")(self, id, title, descr, permission_check) # determine the int-values of the size of preview-image self.prev_filename = [] self.prev_content_type = '' self.has_preview = 0 ################################ # Public methods # ################################ def __str__(self): return self.tag() security.declareProtected('View', '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 REQUEST is None and hasattr(self,'REQUEST'): REQUEST = self.REQUEST if not self._access_permitted(REQUEST): preview = 1 if preview or not self.is_webviewable(): url = '%s?preview=1' % self.absolute_url() img_width, img_height = self._getImageSize(self.prev_filename) elif icon: url = '%s?icon=1' % self.absolute_url() img_width, img_height = (32, 32) else: url = self.absolute_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_id() strg = '%sself._image_size['max']: maxx = self._image_size['max'] if maxyself._image_size['max']: maxy = self._image_size['max'] return maxx, maxy def _undo (self): """ restore filename after undo or copy-paste """ if self.has_preview: fn = self._get_filename(self.prev_filename) if not isfile(fn) and isfile(fn+'.undo'): os.rename(fn+'.undo', fn) # rename preview return ExtImage.inheritedAttribute("_undo")(self) def _get_ufn(self, filename=None): """ If no unique filename has been generated, generate one otherwise, return the existing one. """ if filename is not None: return ExtImage.inheritedAttribute("_get_ufn") (self, filename) new_fn = '' if self.filename: test_fn = self._get_filename(self.filename) + '.preview' if not isfile(test_fn) and not isfile(test_fn+'.undo'): new_fn = self.filename[:] if not new_fn: new_fn = ExtImage.inheritedAttribute("_get_ufn") (self, self.prev_filename) if new_fn != self.prev_filename: new_fn[-1] = new_fn[-1] + '.preview' return new_fn ################################ # Special management methods # ################################ 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.absolute_url(1) # this raises an exception, if no context except: pass else: new_fn = self._get_new_ufn() new_prev_fn = new_fn[:] new_prev_fn[-1] = new_prev_fn[-1] + '.preview' # rename preview-file if self.has_preview and self.filename!=self.prev_filename: old_prev_fn = self._get_filename(self.prev_filename) if isfile(old_prev_fn): self._copy(old_prev_fn, self._get_filename(new_prev_fn)) self.prev_filename = new_prev_fn else: self.prev_filename = [] self.has_preview = 0 elif self.has_preview: old_fn = self._get_filename(self.filename) if isfile(old_fn) or isfile(old_fn+'.undo'): self.prev_filename = new_fn else: self.prev_filename = [] self.has_preview = 0 else: self.prev_filename = [] return ExtImage.inheritedAttribute("manage_afterClone") \ (self, item) return ExtImage.inheritedAttribute("manage_afterClone") \ (self, item) 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) 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 are 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: prev_fn = self._get_filename(self.prev_filename) try: # if UNDO_POLICY==NO_BACKUPS: os.remove(prev_fn) # else: os.rename(prev_fn,prev_fn+'.undo') os.rename(prev_fn,prev_fn+'.undo') except OSError: pass return ExtImage.inheritedAttribute("manage_beforeDelete") \ (self, item, container) InitializeClass(ExtImage) ./__init__.pyc0000644000016000001700000000156110630663044012175 0ustar zopezopem ×

The following displays are defined for this Photo. To change display sizes, edit the values and click "Save Changes".

    Desired Actual Size Age
  Display Width Height W x H (bytes) (minutes)
x       Not generated.
 

There are no displays defined for this Photo.

To add a display, enter a name, width, and height, then click the "Add" button.

Display Width Height  
./dtml/editFolderDisplaysForm.dtml0000664000076400007640000000715210057365036014417 0ustar

The following displays are defined for the Photos in this folder.

  • If you delete displays, the display will be deleted from all contained Photos.
  • If you add displays, the display will be added to all contained Photos.
  • If you edit displays, the displays for all contained Photos will be updated.
    Desired  
  Display Width Height  
 
 

There are no displays defined for Photos in this folder.

To add a display, enter a name, width, and height, then click the "Add" button.

Display Width Height  
./dtml/editSettingsForm.dtml0000664000076400007640000000451510356435075013276 0ustar

You are currently working in version

Photo settings allow you to configure the various settings that effect the rendering of the photo.

Store: ZODB File System
Engine:

Quality:
checked>
Display Cache Timeout: minutes (0 = never)
./dtml/sampleFolderView.dtml0000664000076400007640000000176110236623256013251 0ustar

Photo folder
( photos)

./dtml/editPhotoPropertiesForm.dtml0000664000076400007640000002674410111145117014634 0ustar

You are currently working in version

Default Photo Settings

Default photo settings allow you to configure Photos that will be added to this Photo Folder. New Photos added to this folder will be created using these settings. If you select the Change contained photos option, existing Photos will be updated with these settings, but existing displays will not be rerendered. The Store cannot be changed for existing Photos.

Store:
Engine:
Quality:
Pregenerate Displays: checked>
Display Cache Timeout: minutes (0 = never)
  Change contained photos

Photo Properties

Photo properties allow you to assign properties for Photo objects contained in this Photo Folder. New Photos added to this folder will be given the properties listed here along with the value shown.

  • If you delete properties, the properties will be deleted from all contained Photos.
  • If you add properties, the property with the assigned value will be added to all contained Photos.
  • Editing properties has no effect on current Photos.
 
Name
Value
Type
"> "> "> "> CHECKED> ">
No value for .
No value for .
Unknown property type
&dtml-type;
 
This needs some community review before exposing it officially.  

Photo properties allow you to assign properties for Photo objects contained in this Photo Folder. New Photos added to this folder will be given the properties listed here along with the value shown.

  • If you delete properties, the properties will be deleted from all contained Photos.
  • If you add properties, the property with the assigned value will be added to all contained Photos.
  • Editing properties has no effect on current Photos.

To add a new property, enter a name, type and value for the new property and click the "Add" button.

Name
Type
Value
./dtml/viewPhoto.dtml0000664000076400007640000000043310057365036011760 0ustar

width="" height="" alt="" />

./dtml/zipfileAdd.dtml0000664000076400007640000000230610356435075012053 0ustar

Upload zipfile archive

The zipfile upload makes it possible for you to add a large number of files in one upload. The zipfile will be uploaded and unwrapped.

Zip file
 
 
 
./dtml/sampleView.dtml0000664000076400007640000000256310112622330012077 0ustar

< Previous

Next >

1">
./dtml/addPhotoForm.dtml0000664000076400007640000000552310356435075012372 0ustar
Id: (Leave blank to use image filename.)
Title:
Image File:
Store:
Engine:
Quality:
checked>
Display Cache Timeout: minutes (0 = never)
./dtml/addPhotoFolderForm.dtml0000664000076400007640000000436510057365036013526 0ustar
Id:
Title:
Store:
Engine:
Quality:
Pregenerate Displays:
Display Cache Timeout: minutes (0 = never)
Create sample views.
./dtml/editPhotoForm.dtml0000664000076400007640000001452510111132043012543 0ustar
Title
Image File

x (WxH)
bytes
"> "> "> "> checked="checked"> ">
No value for .
No value for .
Unknown property type
 

EXIF metadata let you see the various settings of the camera when the picture was taken.

./DEPENDENCIES.txt0000664000076400007640000000073610111132043010524 0ustar * Photo was developed and tested with Zope 2.6.4. It should work with older versions as well. * Photo requires the PIL (Python Imaging Library) module available at http://www.pythonware.com/products/pil/ or ImageMagick, available at http://www.imagemagick.org/ to render display sizes. If you use ImageMagick on Windows, be sure the directory for ImageMagick is in your PATH before Windows, or Zope will try to use the convert.exe from Windows, not ImageMagick. ./ExtFile.py0000664000076400007640000007642511152647003010074 0ustar ############################################################################## # # Photo for Zope # # Copyright (c) 2004 Soren Roug, All rights reserved. # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA # ############################################################################## __doc__ = """ ExtFile product module. The ExtFile-Product works like the Zope File-product, but stores the uploaded file externally in a repository-direcory. $Id: ExtFile.py 5740 2006-01-22 11:38:09Z roug $ """ __version__='$Release: 1.1.2 $'[10:-2] import Globals from __main__ import * import Zope from AccessControl import getSecurityManager, ClassSecurityInfo from OFS.SimpleItem import SimpleItem from OFS.PropertyManager import PropertyManager from OFS.ObjectManager import BeforeDeleteException from Globals import DTMLFile, MessageDialog from OFS.content_types import guess_content_type from webdav.common import rfc1123_date from DateTime import DateTime from webdav.WriteLockInterface import WriteLockInterface from mimetools import choose_boundary from ZPublisher import HTTPRangeSupport import urllib, os, types, string from os.path import join, isfile import stat try: from cStringIO import StringIO except: from StringIO import StringIO import zLOG # GD bad_chars = ' ,+&;()[]{}\xC4\xC5\xC1\xC0\xC2\xC3' \ '\xE4\xE5\xE1\xE0\xE2\xE3\xC7\xE7\xC9\xC8\xCA\xCB' \ '\xC6\xE9\xE8\xEA\xEB\xE6\xCD\xCC\xCE\xCF\xED\xEC' \ '\xEE\xEF\xD1\xF1\xD6\xD3\xD2\xD4\xD5\xD8\xF6\xF3' \ '\xF2\xF4\xF5\xF8\x8A\x9A\xDF\xDC\xDA\xD9\xDB\xFC' \ '\xFA\xF9\xFB\xDD\x9F\xFD\xFF\x8E\x9E' good_chars= '___________AAAAAA' \ 'aaaaaaCcEEEE' \ 'EeeeeeIIIIii' \ 'iiNnOOOOOOoo' \ 'ooooSssUUUUu' \ 'uuuYYyyZz' TRANSMAP = string.maketrans(bad_chars, good_chars) def cleanup_id(str): """ Cleanup an id Should be more thorough and e.g. remove trailing dots/spaces """ return string.translate(str, TRANSMAP) REPOS_LOCATION = "reposit" # some versions use "photos" for the repository sub-directory FLAT = 0 SYNC_ZODB = 1 SLICED = 2 REPOSITORY = SYNC_ZODB # format for the files in the repository: # %u=user, %p=path, %n=file name, %e=file extension, %c=counter, %t=time FILE_FORMAT = "%n%c%e" BACKUP_ON_DELETE = 0 ALWAYS_BACKUP = 1 UNDO_POLICY = BACKUP_ON_DELETE def manage_addExtFile(self, id='', title='', file='', content_type='', REQUEST=None): """Add a ExtFile to a folder.""" # content_type argument is probably not used anywhere. if id=='' and type(file) is not type('') and hasattr(file,'filename'): # generate id from filename and make sure, there are no spaces in the id id=file.filename id=id[max(string.rfind(id,'/'), string.rfind(id,'\\'), string.rfind(id,':') )+1:] id = cleanup_id(id) if id: self=self.this() self._setObject(id, ExtFile(id, title)) self._getOb(id).manage_file_upload(file, content_type) if REQUEST is not None: security=getSecurityManager() if security.checkPermission('View management screens',self): ppath = './manage_main' else: pobj = REQUEST.PARENTS[0] ppath = string.join(pobj.getPhysicalPath(), '/') return MessageDialog(title = 'Created', message = 'The ExtFile %s was successfully created!' % id, action = ppath,) else: if REQUEST is not None: return MessageDialog(title = 'Error!', message = 'You must specify a file!', action = './manage_main',) class ExtFile(SimpleItem, PropertyManager): "An External ExtFile allows indexing and conversions." __implements__ = (WriteLockInterface,) # what properties have we? _properties=( {'id':'title', 'type':'string'}, {'id':'descr', 'type':'string'}, {'id':'content_type', 'type':'string'}, ) # what management options are there? manage_options = ( {'label':'Edit', 'action': 'manage_main' }, {'label':'View/Download', 'action': '' }, {'label':'Upload', 'action': 'manage_uploadForm' }, {'label':'Properties', 'action': 'manage_propertiesForm' }, {'label':'Security', 'action': 'manage_access' }, ) # Create a SecurityInfo for this class. We will use this # in the rest of our class definition to make security # assertions. security = ClassSecurityInfo() security.declareProtected('Change permissions', 'manage_access') security.declareProtected('Change Photo', 'manage_editExtFile') security.declareProtected('Change Photo', 'manage_main') security.declareProtected('Change Photo', 'manage_uploadForm') security.declareProtected('Change Photo', 'manage_file_upload') security.declareProtected('Change Photo', 'PUT') security.declareProtected('FTP access', 'manage_FTPstat') security.declareProtected('FTP access', 'manage_FTPget') security.declareProtected('FTP access', 'manage_FTPlist') security.declareProtected('View', 'is_broken') security.declareProtected('View', 'get_size') security.declareProtected('View', 'getContentType') security.declareProtected('View', '_get_filename') security.declareProtected('View', '__str__') # what do people think they're adding? meta_type = 'ExtFile' # location of the file-repository _repository = ['var','photos'] _repository = ['var',REPOS_LOCATION] ################################ # Init method # ################################ def __init__(self, id, title='', content_type='', parent_path=None): """ Initialize a new instance of ExtFile If a extFile is created through FTP, self.absolute_url doesn't work. """ self.id = id self.title = title self.__version__ = __version__ self.filename = [] self.file_uploaded = 0 self.content_type = content_type self._v_parent_path = parent_path ################################ # Public methods # ################################ def __str__(self): return self.index_html() def __len__(self): return 1 HEAD__roles__=None def HEAD(self, REQUEST, RESPONSE): """ """ filename = self._get_filename() try: filesize = os.path.getsize(filename) filemtime = os.path.getmtime(filename) except: raise cant_read_exc, ("%s (%s)" %(self.id, filename)) RESPONSE.setHeader('Last-Modified', rfc1123_date(filemtime)) RESPONSE.setHeader('Content-Length', filesize) RESPONSE.setHeader('Content-Type', self.content_type) return '' def __setstate__(self,state): ExtFile.inheritedAttribute('__setstate__')(self, state) if not hasattr(self,'file_uploaded'): self.file_uploaded = 1 security.declareProtected('View', 'index_html') def index_html(self, REQUEST, RESPONSE): """ Returns the contents of the file. Also, sets the Content-Type HTTP header to the objects content type. """ icon = 0 if icon: filename = join(SOFTWARE_HOME, 'Products', 'Photo', self.getIconPath()) content_type = 'image/gif' else: filename = self._get_filename() content_type = self.content_type if not isfile(filename): self._undo() if not isfile(filename): filename = join(SOFTWARE_HOME, 'Products', 'Photo', 'icons', 'broken.gif') content_type = 'image/gif' self._output_file(REQUEST, RESPONSE, filename, content_type) def _output_file(self, REQUEST, RESPONSE, filename, content_type): """ Write the necesary header information for (possibly) chunked output """ cant_read_exc = "Can't read: " try: filesize = os.path.getsize(filename) filemtime = os.path.getmtime(filename) except: raise cant_read_exc, ("%s (%s)" %(self.id, filename)) # HTTP If-Modified-Since header handling. header=REQUEST.get_header('If-Modified-Since', None) if header is not None: header=string.split(header, ';')[0] # Some proxies seem to send invalid date strings for this # header. If the date string is not valid, we ignore it # rather than raise an error to be generally consistent # with common servers such as Apache (which can usually # understand the screwy date string as a lucky side effect # of the way they parse it). # This happens to be what RFC2616 tells us to do in the face of an # invalid date. try: mod_since=long(DateTime(header).timeTime()) except: mod_since=None if mod_since is not None: last_mod = long(filemtime) if last_mod > 0 and last_mod <= mod_since: # Set header values since apache caching will return Content-Length # of 0 in response if size is not set here RESPONSE.setHeader('Last-Modified', rfc1123_date(filemtime)) RESPONSE.setHeader('Content-Type', content_type) RESPONSE.setHeader('Content-Length', filesize) RESPONSE.setHeader('Accept-Ranges', 'bytes') RESPONSE.setStatus(304) return '' # HTTP Range header handling. Typical header line (folded): # Range:bytes=265089-266112, 257921-265088, 119720-121023, # 121024-151023, 151024-181023, 181024-211023, # 211024-241023, 241024-257920 range = REQUEST.get_header('Range', None) if_range = REQUEST.get_header('If-Range', None) if range is not None: ranges = HTTPRangeSupport.parseRange(range) if if_range is not None: # Only send ranges if the data isn't modified, otherwise send # the whole object. Support both ETags and Last-Modified dates! if len(if_range) > 1 and if_range[:2] == 'ts': # ETag: if if_range != self.http__etag(): # Modified, so send a normal response. We delete # the ranges, which causes us to skip to the 200 # response. ranges = None else: # Date date = string.split(if_range, ';')[0] try: mod_since=long(DateTime(date).timeTime()) except: mod_since=None if mod_since is not None: last_mod = long(filemtime) if last_mod > mod_since: # Modified, so send a normal response. We delete # the ranges, which causes us to skip to the 200 # response. ranges = None if ranges: # Search for satisfiable ranges. satisfiable = 0 for start, end in ranges: if start < filesize: satisfiable = 1 break if not satisfiable: RESPONSE.setHeader('Content-Range', 'bytes */%d' % filesize) RESPONSE.setHeader('Accept-Ranges', 'bytes') RESPONSE.setHeader('Last-Modified', rfc1123_date(filemtime)) RESPONSE.setHeader('Content-Type', content_type) RESPONSE.setHeader('Content-Length', filesize) RESPONSE.setStatus(416) return '' # Can we optimize? #ranges = HTTPRangeSupport.optimizeRanges(ranges, filesize) if len(ranges) == 1: # Easy case, set extra header and return partial set. start, end = ranges[0] size = end - start RESPONSE.setHeader('Last-Modified', rfc1123_date(filemtime)) RESPONSE.setHeader('Content-Type', content_type) RESPONSE.setHeader('Content-Length', size) RESPONSE.setHeader('Accept-Ranges', 'bytes') RESPONSE.setHeader('Content-Range', 'bytes %d-%d/%d' % (start, end - 1, filesize)) RESPONSE.setStatus(206) # Partial content fd = open(filename,'rb') self._writesegment(fd, RESPONSE,start,size) fd.close() return '' else: # Ignore multi-part ranges for now, pretend we don't know # about ranges at all. # When we get here, ranges have been optimized, so they are # in order, non-overlapping, and start and end values are # positive integers. boundary = choose_boundary() # Calculate the content length size = (8 + len(boundary) + # End marker length len(ranges) * ( # Constant lenght per set 49 + len(boundary) + len(content_type) + len('%d' % filesize))) for start, end in ranges: # Variable length per set size = (size + len('%d%d' % (start, end - 1)) + end - start) RESPONSE.setHeader('Content-Length', size) RESPONSE.setHeader('Accept-Ranges', 'bytes') RESPONSE.setHeader('Last-Modified', rfc1123_date(filemtime)) RESPONSE.setHeader('Content-Type', 'multipart/byteranges; boundary=%s' % boundary) RESPONSE.setStatus(206) # Partial content pos = 0 fd = open(filename,'rb') for start, end in ranges: RESPONSE.write('\r\n--%s\r\n' % boundary) RESPONSE.write('Content-Type: %s\r\n' % content_type) RESPONSE.write( 'Content-Range: bytes %d-%d/%d\r\n\r\n' % ( start, end - 1, filesize)) self._writesegment(fd, RESPONSE,start,end-start) RESPONSE.write('\r\n--%s--\r\n' % boundary) fd.close() return '' RESPONSE.setHeader('Last-Modified', rfc1123_date(filemtime)) RESPONSE.setHeader('Content-Type', content_type) RESPONSE.setHeader('Content-Length', filesize) RESPONSE.setHeader('Accept-Ranges', 'bytes') self._copy(filename, RESPONSE) return '' def view_image_or_file(self): """ The default view of the contents of the File or Image. """ raise 'Redirect', self.absolute_url() security.declareProtected('View', 'link') def link(self, text='', **args): """ return a HTML link tag to the file """ if text=='': text = self.title_or_id() strg = '' % self.absolute_url() def is_broken(self): """ Check if external file exists and return true (1) or false (0) """ fn = self._get_filename() if not isfile(fn): self._undo() if not isfile(fn): return 1 return 0 def get_size(self): """ Returns the size of the file or image """ if not self.file_uploaded: zLOG.LOG("GDDEBUG: ExtFile.py get_size: not self.file_uploaded", zLOG.ERROR, "") return 0 fn = self._get_filename() if not isfile(fn): self._undo() if isfile(fn): size = os.stat(fn)[6] else: size = 0 return size rawsize = get_size # getSize = get_size def size(self): """ Returns a formatted stringified version of the file size """ return self._bytetostring(self.get_size()) def _get_filename(self, filename=None): """ Generate the full filename, including directories from self._repository and self.filename """ if filename == None: filename=self.filename path = INSTANCE_HOME for item in self._repository: path = join(path,item) if type(filename)==types.ListType: for item in filename: path = join(path,item) elif filename!='': path = join(path,filename) return path ################################ # Protected management methods # ################################ # Management Interface manage_main = DTMLFile('dtml/extFileEdit', globals()) def manage_editExtFile(self, title='', content_type='', REQUEST=None): """ Manage the edited values """ if content_type != '': self.content_type = content_type if self.title != title: self.title = title if REQUEST is not None: message = "The properties of %s have been changed!" % self.id return self.manage_main(self,REQUEST,manage_tabs_message=message) # File upload Interface manage_uploadForm = DTMLFile('dtml/docUpload', globals()) def manage_file_upload(self, file='', content_type='', REQUEST=None): """ Upload file from local directory """ new_fn = self._get_ufn(self.filename) self._copy(file, self._get_filename(new_fn)) try: file.seek(0) except: pass content = file.read() self.content_type = self._get_content_type(file, content[:100], self.id, content_type or self.content_type) self.filename = new_fn file.close() self.file_uploaded = 1 if REQUEST is not None: message = "The file was uploaded successfully!" return self.manage_main(self,REQUEST,manage_tabs_message=message) manage_FTPget = index_html def PUT(self, REQUEST, RESPONSE): """ Handle HTTP/FTP PUT requests """ self.dav__init(REQUEST, RESPONSE) self.dav__simpleifhandler(REQUEST, RESPONSE) content_type = REQUEST.get_header('content-type', None) instream = REQUEST['BODYFILE'] new_fn = self._get_ufn(self.filename) self._copy(instream, self._get_filename(new_fn)) try: instream.seek(0) except: pass self.file_uploaded = 1 try: self.content_type = self._get_content_type(instream, instream.read(100), self.id, content_type or self.content_type) except: if UNDO_POLICY==ALWAYS_BACKUP: os.remove(self._get_filename(new_fn)) self.file_uploaded = 0 else: self.filename = new_fn RESPONSE.setStatus(204) return RESPONSE ################################ # Private methods # ################################ def _get_content_type(self, file, body, id, content_type=None): """ Determine the mime-type """ headers = getattr(file, 'headers', None) if headers and headers.has_key('content-type'): content_type = headers['content-type'] else: if type(body) is not type(''): body = body.data content_type, enc = guess_content_type(getattr(file,'filename',id), body, content_type) return content_type def _writesegment(self, instream, outstream, start, length): """ Write a segment of the file. The file is already open. """ instream.seek(start) blocksize = 2<<16 if length < blocksize: nextsize = length else: nextsize = blocksize try: while length > 0: block = instream.read(nextsize) outstream.write(block) length = length - len(block) if length < blocksize: nextsize = length else: nextsize = blocksize except IOError: raise IOError, ("%s (%s)" %(self.id, filename)) def _copy(self, infile, outfile, maxblocks=16384): """ Read binary data from infile and write it to outfile infile and outfile may be strings, in which case a file with that name is opened, or filehandles, in which case they are accessed directly. A block is 131072 bytes. maxblocks prevents it from >2GB """ if type(infile) is types.StringType: try: instream = open(infile, 'rb') except IOError: self._undo() try: instream = open(infile, 'rb') except IOError: raise IOError, ("%s (%s)" %(self.id, infile)) close_in = 1 else: instream = infile close_in = 0 if type(outfile) is types.StringType: try: outstream = open(outfile, 'wb') except IOError: raise IOError, ("%s (%s)" %(self.id, outfile)) close_out = 1 else: outstream = outfile close_out = 0 try: blocksize = 2<<16 block = instream.read(blocksize) outstream.write(block) maxblocks = maxblocks - 1 while len(block)==blocksize and maxblocks > 0: maxblocks = maxblocks - 1 block = instream.read(blocksize) outstream.write(block) except IOError: raise IOError, ("%s (%s)" %(self.id, filename)) if close_in: instream.close() if close_out: outstream.close() def _bytetostring (self, value): """ Convert an int-value (file-size in bytes) to an String with the file-size in Byte, KB or MB """ bytes = float(value) if bytes >= 1000: bytes = bytes/1024 typ = 'KB' if bytes >= 1000: bytes = bytes/1024 typ = 'MB' strg = '%4.2f' % bytes strg = strg[:4] if strg[3]=='.': strg = strg[:3] else: typ = 'Bytes' strg = '%4.0f' % bytes strg = strg+ ' ' + typ return strg def _undo (self): """ restore filename after undo or copy-paste """ if self.filename == []: return fn = self._get_filename() if not isfile(fn) and isfile(fn+'.undo'): self._restorefile(fn) self.file_uploaded = 1 def _deletefile(self, filename): """ Move the file to the undo file """ try: os.rename(filename, filename + '.undo') except: pass self.file_uploaded = 0 def _copyfile(self, old_fn, new_fn): """ Copy a file in the repository This actually involves copying two files """ self._copy(old_fn, new_fn) def _restorefile(self, filename): """ Recover the file from undo """ try: os.rename(filename + '.undo', filename) except: pass def _get_ufn(self, filename): """ If no unique filename has been generated, generate one otherwise, return the existing one. """ if UNDO_POLICY==ALWAYS_BACKUP or filename==[]: new_fn = self._get_new_ufn() else: new_fn = filename[:] if filename: old_fn = self._get_filename(filename) if UNDO_POLICY==ALWAYS_BACKUP: self._deletefile(old_fn) else: self._restorefile(old_fn) return new_fn def _get_new_ufn(self): """ Create a new unique filename """ # We can get in the situation that the object is floating in memory # when the upload is taking place. In that case we don't have a # absolute_url, and must rely on _v_parent_path - set in __init__ if hasattr(self,'_v_parent_path') and self._v_parent_path: rel_url_list = string.split(self._v_parent_path, '/') else: rel_url_list = string.split(self.absolute_url(1), '/')[:-1] rel_url_list = filter(None, rel_url_list) pos = string.rfind(self.id, '.') if (pos+1): id_name = self.id[:pos] id_ext = self.id[pos:] else: id_name = self.id id_ext = '' # generate directory structure dirs = [] if REPOSITORY==SYNC_ZODB: dirs = rel_url_list elif REPOSITORY==SLICED: slice_depth = 2 # modify here, if you want a different slice depth slice_width = 1 # modify here, if you want a different slice width temp = id_name for i in range(slice_depth): if len(temp)=0: fileformat = string.replace(fileformat, "%t", "%c") counter = int(DateTime().strftime('%m%d%H%M%S')) else: counter = 0 invalid_format_exc = "Invalid file format: " if string.find(fileformat, "%c")==-1: raise invalid_format_exc, FILE_FORMAT # user (%u) if string.find(fileformat, "%u")>=0: if (hasattr(self, "REQUEST") and self.REQUEST.has_key('AUTHENTICATED_USER')): user = self.REQUEST['AUTHENTICATED_USER'].name fileformat = string.replace(fileformat, "%u", user) else: fileformat = string.replace(fileformat, "%u", "") # path (%p) if string.find(fileformat, "%p") >= 0: temp = string.joinfields (rel_url_list, "_") fileformat = string.replace(fileformat, "%p", temp) # file and extension (%n and %e) if string.find(fileformat,"%n") >= 0 or string.find(fileformat,"%e") >= 0: fileformat = string.replace(fileformat, "%n", id_name) fileformat = string.replace(fileformat, "%e", id_ext) # make the directories path = self._get_filename(dirs) if not os.path.isdir(path): mkdir_exc = "Can't create directory: " try: os.makedirs(path) except: raise mkdir_exc, path # search for unique filename if counter: fn = join(path, string.replace(fileformat, "%c", `counter`)) else: fn = join(path, string.replace(fileformat, "%c", '')) while (isfile(fn) or isfile(fn+'.undo')): counter = counter+1 fn = join(path, string.replace(fileformat, "%c", `counter`)) if counter: fileformat = string.replace(fileformat, "%c", `counter`) else: fileformat = string.replace(fileformat, "%c", '') dirs.append(fileformat) return dirs ################################ # Special management methods # ################################ 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. Called AFTER manage_afterAdd """ old_fn = self._get_filename() new_fn = self._get_new_ufn() if isfile(old_fn): self._copyfile(old_fn,self._get_filename(new_fn)) self.filename = new_fn self.file_uploaded = 1 return ExtFile.inheritedAttribute ("manage_afterClone") (self, item) def manage_afterAdd(self, item, container, new_fn=None): """ This method is called, whenever _setObject in ObjectManager gets called. This is the case after a normal add and if the object is a result of cut-paste- or rename-operation. In the first case, the external files doesn't exist yet, otherwise it was renamed to .undo by manage_beforeDelete before and must be restored by _undo(). When FTP PUT: __init__, PUT, _setObject called and file_uploaded == 1, filename!=[] When cut-n-paste: file_uploaded set to 0 in manage_beforeDelete and file is renamed to x.undo. Filename points to original file. When copy-n-paste: file_uploaded == 1, and filename points to original file. """ if self.file_uploaded == 0 and self.filename != []: old_fn = self._get_filename() new_fn = new_fn or self._get_new_ufn() if isfile(old_fn): self._copyfile(old_fn,self._get_filename(new_fn)) else: if isfile(old_fn + '.undo'): self._copyfile(old_fn + '.undo', self._get_filename(new_fn)) self.filename = new_fn self.file_uploaded = 1 return ExtFile.inheritedAttribute ("manage_afterAdd") \ (self, item, container) 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 are just renamed to filename.undo and remains in the repository, until it is deleted manually. """ fn = self._get_filename() self._deletefile(fn) self.file_uploaded = 0 return ExtFile.inheritedAttribute ("manage_beforeDelete") \ (self, item, container) Globals.InitializeClass(ExtFile) ./THANKS.txt0000664000076400007640000000053710111151656007700 0ustar This product would not be possible without the contributions of others, including the following: - Zope Corporation for creating Zope and making it open source. - Andrew Lahser for the first Photo product, which inspired this one. - Soren Roug for the new features in version 1.3. ...and others that helped with bugs and such listed in CHANGES.txt. ./UPGRADE.txt0000664000076400007640000000657011152647201010004 0ustar Upgrading to 1.4 from any other version - ExtFile.py has a variable ( REPOS_LOCATION ) that specifies where the filesystem repository is. The version old versions of rbickers code use "reposit", but some versions use "photos". If you are upgrading from an oldermodult, make sure to use the right setting. Upgrading from 0.9.x and above to 1.2.3 Photo comes with an External Method called Upgrade.py. To upgrade your Photo and Photo Folder objects, create an External Method in your Zope root as follows. Id: upgrade Module Name: Photo.Upgrade Function Name: upgrade When you run this method, all of your Photo and Photo Folder objects will be upgraded. You can then delete the External Method. Upgrading from Photo 0.8.0 to 0.9.0 In order to support different image storages (specifically, ExtImage), the way in which the original image is stored has changed. This means Photo objects created under version 0.8.0 are not compatible with 0.9.0. To upgrade, you can follow the instructions below on upgrading from Andrew Lahser's Photo Product, substituting the following Python Script:: """Convert 0.8.0 Photo objects to 0.9.0 Photo objects.""" REQUEST = context.REQUEST # Upgrade Photo Folder context.manage_addProperty('engine', 'image_engines', 'selection') context.manage_addProperty('store', 'image_stores', 'selection') context.manage_changeProperties(engine = 'PIL', store = 'Image') # Upgrade Photos for photo in context.objectItems(['Photo']): # Convert old photo object to new. photoid = photo[0] photo = photo[1] context.manage_delObjects([photoid,], REQUEST=REQUEST) id = context.manage_addProduct['Photo'].manage_addPhoto( photoid, photo.title, photo.data, store='Image', engine='PIL', REQUEST=REQUEST) newphoto = getattr(context, id) # Add old properties to new photo. for prop in photo.propertyMap(): try: newphoto.manage_addProperty(prop['id'], None, prop['type']) except: pass # Assign old property values to new photo. propmap = {} for id, value in photo.propertyItems(): propmap[id] = value try: newphoto.manage_changeProperties(propmap) except: pass # Clear new Photo displays. displayids = newphoto.displayIds(exclude=None) newphoto.manage_delDisplays(displayids) # Create old display sizes. for display in photo.displayMap(exclude=None): id = display['id'] width = display['width'] height = display['height'] newphoto.manage_addDisplay(id, width, height) return 'Done.' Upgrading from Andrew Lahser's Photo Product Unfortunately, the new Photo product is now quite a bit different than the old Photo product. Because of this, there is no direct way to upgrade old Photo objects. It would be possible to create a script, but since there are several additional options in the new product, it would be better to recreate the photos from scratch. Since Photo now supports WebDAV/FTP, you can create a Photo Folder, set the settings as desired, and transfer the Photos to the Photo Folder. This will create Photo objects with the default settings from your Photo Folder instead of creating Zope Image objects that would need to be converted. ./index_html_example0000644000000000000000000000366711152647454013527 0ustar rootroot
  • Go up to parent folder "> ""

    • (Sorry, sometimes the thumbnail images do not appear.)
    • ( photos)


    • ( photos)





    Movie
    ./ExtPhotoImage.py0000664000076400007640000000661211156204657011250 0ustar ############################################################################## # # Photo for Zope # # Copyright (c) 2001 Logic Etc, Inc. All rights reserved. # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA # # Ron Bickers rbickers@logicetc.com # Logic Etc, Inc. http://www.logicetc.com/ # ############################################################################## """ExtPhotoImage This is used as a wrapper for Photo to provide a common interface for both Zope Image objects and ExtImage objects. """ from AccessControl import ClassSecurityInfo from Globals import InitializeClass from ExtImage import ExtImage #import PIL.Image import time class PhotoImage(ExtImage): """Interface to ExtImage.""" security=ClassSecurityInfo() def __init__(self, id, title='', file='', content_type='', precondition='', path=''): self._path = path PhotoImage.inheritedAttribute('__init__')(self, id, content_type) def _height(self): return self.height() def _width(self): return self.width() def _content_type(self): return self.content_type def _size(self): return self.rawsize() security.declareProtected('Access contents information', 'size') def size(self): return self.rawsize() def _age(self): mtime = self.bobobase_modification_time().timeTime() / 60 now = time.time() / 60 return int(now - mtime) security.declareProtected('View', 'index_html') def index_html(self, REQUEST, RESPONSE): return PhotoImage.inheritedAttribute('index_html')(self, REQUEST=REQUEST, RESPONSE=RESPONSE) def _data(self): return open(self._get_filename(self.filename), 'rb').read() _IMdata = _data def data_as_stream(self): try: filename = self._original._get_filename() except: filename = self._get_filename() return open(filename, 'rb') def _PILdata(self): return self._get_filename(self.filename) def _newImage(self, id, file, path): img = PhotoImage(id, path=path) img.manage_file_upload(file, self._content_type()) return img def _isValid(self): return self.width() and self.height() and self.content_type security.declareProtected('Change Photo', 'manage_upload') def manage_upload(self, file, content_type): return self.manage_file_upload(file, content_type) # ExtImage uses absolute_url() to determine the directory and # filename to save the image. Since we can't use ExtImage's # absolute_url() (for some reason I'm sure of), we use the URL # of the main Photo object which is passed when a new PhotoImage # is created. def absolute_url(self, relative=0): return self._path + '/' + self.id InitializeClass(PhotoImage) ./refresh.txt0000664000076400007640000000000010057365036010337 0ustar ./CHANGES.txt0000664000076400007640000002027211156453112007760 0ustar * Release 3.1 (Stable) - March 13, 2009 - Version from Gregory Dudek. - ExtFile.py has a variable ( REPOS_LOCATION ) that specifies where the filesystem repository is. The version old versions of rbickers code use "reposit", but some versions use "photos". If you are upgrading from an oldermodult, make sure to use the right setting. - Combined code from 1.3.2 and 1.2.4 to avoid a the requirement for a read method being needed (thus allowing images to be re-created as photos). This also provides some other small advantages that the respective versions had, but didn't have in common, notably incuding EXIF support. - Modified EXIF.py to do much more robust parsing of JPEG files so that files with more varied structures can be handled (i.e. APP2 segment coming before APP1, as produced by iPhoto). See http://www.dudek.org/blog/154 for more details. - supports the key externally-callable method exifdata?pretty=1 that takes an optional argument pretty=1, and field. e.g. exifdata?pretty=1 or exifdata?field=Date. The field can be any requested exif data field, and the special meta-field Date mens return any of several possible EXIF date fields to try and get some kind of photo date. - the viewPhoto example provides a more full-feature viewPhoto methods you might want to try out. * Release 1.3.1 (Stable) - Jan. 21, 2006 - Added: CatalogAwareness. You can use this to e.g. search on titles in your photo album. - Fixed: FTP upload - Added: Can show a folder index and a photo without having a script in the photo folder. If you have rolled your own from a previous version of Photo, you must rename 'view' to 'photo_view' and 'folderview' to 'photo_folder_index'. * Release 1.3.0 (Stable) - Aug. 20, 2004 - Added: The ability to read the description and EXIF values from the image file. - Removed: Dependency on ExtFile. - Added: Zipping of albums (if they are stored on filesystem). - Added: The sample views now use semantically correct HTML and CSS for styling. * Release 1.2.3 (Stable) - Dec. 20, 2001 - Fixed: bug preventing Add Photo form from displaying when adding a Photo outside of a Photo Folder. Thanks to Timothy Wilson for reporting this. - Fixed: img tag alt attributes were not HTML quoted. Thanks to Michael Bernstein for reporting this. - Changed: upgrading returns more useful information; the objects that were upgraded. - Fixed: Photo now supports the SYNC_ZODB option of ExtImage, where the image files are stored in subdirectories that correspond to the Zope path. Each display is stored in a subdirectory named after the Photo object's id. Thanks to Emmanuel Viennet for reporting the lack of support for this feature. - Fixed: ExtImage display files weren't removed (or marked with .undo) when they were purged or expired. - Fixed: New ExtImage files were created when updating the image data of an existing Photo. This would leave stale files that were not tied to a Photo object. * Release 1.2.2 (Stable) - Nov. 8, 2001 - Removed: a script is no longer available for upgrading from the old Photo product. Too many things are different. - Added: option to generate displays on-the-fly instead of when the photo is added. - Added: timeout (in minutes) for displays to remain generated. This is somewhat experimental, because of the unknown practical effects on how the ZODB will grow with these updates. When a display is viewed, if more than half of timeout has passed since the display's mod time, the mod time is updated to the current time and the other displays are flushed if their mod time's are greater than timeout. If timeout is 0, the displays are never removed. - Added: Purge All action in displays will remove all generated displays. If any displays are "checked", they will not be removed and their mod times will be reset. - Added: Clean Up action in displays will remove all generated displays that have expired. If any displays are "checked", they will not be removed and their mod times will be reset. - Changed: moved Upgrade.py to the Extensions directory so it no longer needs to be copied to do an upgrade. Thanks to Robert Rottermann for the tip. * Release 1.2.1 (Stable) - Oct. 26, 2001 - Added: creating a display size of 0 width x 0 height will render a display with the same dimensions of the original photo, but will be processed by the engine. This is useful for storing high quality originals, but having a "same size" photo that has been compressed for faster viewing online. - Added: compression quality setting. This is a number from 1 (worst) to 100 (best) that is passed to the engine and determines the compression quality used for rendered displays. The default is 75. - Added: External Method for easier upgrading of all Photo and Photo Folder objects. See UPGRADE.txt for details. - Added: FAQ.txt for FAQs * Release 1.2.0 (Stable) - Oct. 19, 2001 - Fixed: support for WebDAV and FTP only partially worked. It should now work with Zope 2.3.2+ and Zope 2.4+ to the extent that Zope itself supports WebDAV/FTP in these versions. - Changed: separated Photo settings from Photo properties to prevent name clashing with user-defined properties and in preparation of adding more settings to future versions. See UPGRADE.txt to update old Photo objects. - Changed: management interface modified to reflect separation of Photo settings vs. properties. - Fixed: new Photos uploaded via WebDAV/FTP were not acquiring the Photo Folder's settings/properties. - Changed: ImageMagick is now the default rendering engine instead of PIL. Even though it is a fair amount slower, it produces much better images and is generally easier to install. * Release 1.1.0 (Development) - Oct. 12, 2001 - Added: support for WebDAV and FTP - Added: Image types uploaded to a Photo Folder are created as Photo objects instead of the default Zope Image object. * Release 1.0.0 (Stable) - Oct. 12, 2001 - Fixed: minor bug in tag() when display is not specified. Thanks Robert Rottermann. * Release 0.9.2 (Development) - Sep. 2, 2001 - Fixed: support for ImageMagick on Win32 was broken. - Fixed: PIL is no longer required, so silently ignore ImportError when it's not installed. - Fixed: typo in manage_addDisplay security declaration. * Release 0.9.1 (Development) - Aug. 29, 2001 - Fixed: editing properties in the Edit tab kills the original image. - Added: new method manage_regenDisplays makes it easier to regenerate all displays. * Release 0.9.0 (Development) - Aug. 29, 2001 - Added: support was added for ExtImage so that photo files can be stored in the file system instead of the ZODB. - Added: you can now use ImageMagick to render images as well as PIL. ImageMagick rendering is done by running 'convert' as a subprocess, not via a Python module, so this may or may not work for you. IM is much slower, but produces smoother images. - Added: exttag() method returns an HTML img tag for serving the photos outside of Zope (eg, via Apache). Only useful with ExtImage storage. - Changed: Photo object is now a simple object, not a subclass of Image. This allows for supporting ExtImage. The original image is now stored as an attribute like all of the displays. See UPGRADE.txt for upgrading prior photos. - Added: default 'engine' property on Photo Folders gives new photo objects the default rendering engine (PIL or ImageMagick) on the add form. - Added: default 'store' property on Photo Folders gives new Photo objects the default storage (Image - ZODB, or ExtImage - File System) on the add form. - Added: a Regenerate All button in the displays tab will update all of the displays. This is useful after you change the rendering engine. - Fixed: manage_editPhoto did not update photo, only properties. - Changed: cookie now defaults to 0 (off). cookie=0 seemed to be used more often than cookie=1. * Release 0.8.0 (Development) - Aug. 23, 2001 - Initial public release. ./version.txt0000664000076400007640000000001410661071020010357 0ustar Photo 1.3.2 ./viewPhoto_example0000644000000000000000000001072011156453007013335 0ustar rootroot ************** Link to parent folder ">Browse

    ************** Main body in 3 columns ************** Left column: Link to previous photo in this folder ************** Mud column: Name of main content ************** main content spans all 3 columns: photo and details (this is a long hunk of stuff handling both plain photos and then movies)
    <   

    ************** Right column: Link to next photo in this folder     		 >  
    ">
    : :
    "> ">
    (movie)
     ">
    "> Download full-size image
    "> ">Play Movie Meg
     
    Edit info
    ./JpgComment.py0000664000076400007640000001272110063134124010557 0ustar # ################################################## # AlbumEXIF.py # Handle EXIF data collected by EXIFbp.py # ################################################## # Module of PyAlbum (http://pyalbum.sourceforge.net) # (c) 2004 Bernd Preusing # License: GPL # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA # ################################################## ######################################## # This part is from PIL.JpegImagePlugin V 0.5 # It skipped the part 0xFFFE (COM), but this is just # the part we need! ######################################## def i16(c,o=0): return ord(c[o+1]) + (ord(c[o])<<8) def i32(c,o=0): return ord(c[o+3]) + (ord(c[o+2])<<8) + (ord(c[o+1])<<16) + (ord(c[o])<<24) # # Parser def Skip(self, marker): self.fp.read(i16(self.fp.read(2))-2) def COM(self, marker): # # COM comment 0xFFFE # s = self.fp.read(i16(self.fp.read(2))-2) self.COM = s # # JPEG marker table MARKER = { 0xFFC0: ("SOF0", "Baseline DCT", Skip), 0xFFC1: ("SOF1", "Extended Sequential DCT", Skip), 0xFFC2: ("SOF2", "Progressive DCT", Skip), 0xFFC3: ("SOF3", "Spatial lossless", Skip), 0xFFC4: ("DHT", "Define Huffman table", Skip), 0xFFC5: ("SOF5", "Differential sequential DCT", Skip), 0xFFC6: ("SOF6", "Differential progressive DCT", Skip), 0xFFC7: ("SOF7", "Differential spatial", Skip), 0xFFC8: ("JPG", "Extension", None), 0xFFC9: ("SOF9", "Extended sequential DCT (AC)", Skip), 0xFFCA: ("SOF10", "Progressive DCT (AC)", Skip), 0xFFCB: ("SOF11", "Spatial lossless DCT (AC)", Skip), 0xFFCC: ("DAC", "Define arithmetic coding conditioning", Skip), 0xFFCD: ("SOF13", "Differential sequential DCT (AC)", Skip), 0xFFCE: ("SOF14", "Differential progressive DCT (AC)", Skip), 0xFFCF: ("SOF15", "Differential spatial (AC)", Skip), 0xFFD0: ("RST0", "Restart 0", None), 0xFFD1: ("RST1", "Restart 1", None), 0xFFD2: ("RST2", "Restart 2", None), 0xFFD3: ("RST3", "Restart 3", None), 0xFFD4: ("RST4", "Restart 4", None), 0xFFD5: ("RST5", "Restart 5", None), 0xFFD6: ("RST6", "Restart 6", None), 0xFFD7: ("RST7", "Restart 7", None), 0xFFD8: ("SOI", "Start of image", None), 0xFFD9: ("EOI", "End of image", None), 0xFFDA: ("SOS", "Start of scan", Skip), 0xFFDB: ("DQT", "Define quantization table", Skip), 0xFFDC: ("DNL", "Define number of lines", Skip), 0xFFDD: ("DRI", "Define restart interval", Skip), 0xFFDE: ("DHP", "Define hierarchical progression", Skip), 0xFFDF: ("EXP", "Expand reference component", Skip), 0xFFE0: ("APP0", "Application segment 0", Skip), 0xFFE1: ("APP1", "Application segment 1", Skip), 0xFFE2: ("APP2", "Application segment 2", Skip), 0xFFE3: ("APP3", "Application segment 3", Skip), 0xFFE4: ("APP4", "Application segment 4", Skip), 0xFFE5: ("APP5", "Application segment 5", Skip), 0xFFE6: ("APP6", "Application segment 6", Skip), 0xFFE7: ("APP7", "Application segment 7", Skip), 0xFFE8: ("APP8", "Application segment 8", Skip), 0xFFE9: ("APP9", "Application segment 9", Skip), 0xFFEA: ("APP10", "Application segment 10", Skip), 0xFFEB: ("APP11", "Application segment 11", Skip), 0xFFEC: ("APP12", "Application segment 12", Skip), 0xFFED: ("APP13", "Application segment 13", Skip), 0xFFEE: ("APP14", "Application segment 14", Skip), 0xFFEF: ("APP15", "Application segment 15", Skip), 0xFFF0: ("JPG0", "Extension 0", None), 0xFFF1: ("JPG1", "Extension 1", None), 0xFFF2: ("JPG2", "Extension 2", None), 0xFFF3: ("JPG3", "Extension 3", None), 0xFFF4: ("JPG4", "Extension 4", None), 0xFFF5: ("JPG5", "Extension 5", None), 0xFFF6: ("JPG6", "Extension 6", None), 0xFFF7: ("JPG7", "Extension 7", None), 0xFFF8: ("JPG8", "Extension 8", None), 0xFFF9: ("JPG9", "Extension 9", None), 0xFFFA: ("JPG10", "Extension 10", None), 0xFFFB: ("JPG11", "Extension 11", None), 0xFFFC: ("JPG12", "Extension 12", None), 0xFFFD: ("JPG13", "Extension 13", None), 0xFFFE: ("COM", "Comment", COM) } class DummyJpegImageFile: "This class is for getting the JPEG comment only." def __init__(self, file): # open file self.fp = file self.COM = "" def getCOM(self): """ Skip all markers except COM """ self.fp.seek(0) # who knows... s = self.fp.read(1) if ord(s[0]) != 255: raise AttributeError("not a JPEG file") while 1: s = s + self.fp.read(1) i = i16(s) if MARKER.has_key(i): name, description, handler = MARKER[i] if handler is not None: handler(self, i) if i == 0xFFDA: # start of scan break s = self.fp.read(1) elif i == 65535: # padded marker; move on s = "\xff" else: raise SyntaxError("no marker found") return self.COM if __name__ == "__main__": # try to get COM comment fname = "AlbumEXIF.py" infile=open(fname, 'rb') dummy = DummyJpegImageFile(infile) # does not close!! comment = dummy.getCOM() # string! Should be part of PIL.Image! infile.close() print comment ./TODO.txt0000664000076400007640000000045510111145117007447 0ustar TODO, in no particular order: * Add online Zope help. * Come up with some better icons, at least for Photo Folder. * Option for not resizing photos above their original size. * File system syncronization to keep Photo objects up to date with corresponding image files in the file system. ./__init__.py0000664000076400007640000000357311152647277010302 0ustar ############################################################################## # # Photo for Zope # # Copyright (c) 2001 Logic Etc, Inc. All rights reserved. # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA # # Ron Bickers rbickers@logicetc.com # Logic Etc, Inc. http://www.logicetc.com/ # ############################################################################## """Photo and Photo Folder""" __version__ = '1.4.0' from Photo import Photo, manage_addPhotoForm, manage_addPhoto from PhotoFolder import PhotoFolder, manage_addPhotoFolderForm, manage_addPhotoFolder from ImageFile import ImageFile def initialize(registrar): registrar.registerClass( Photo, constructors = (manage_addPhotoForm, manage_addPhoto), icon = 'www/photo.gif' ) registrar.registerClass( PhotoFolder, constructors = (manage_addPhotoFolderForm, manage_addPhotoFolder), icon = 'www/photofolder.gif' ) # Define shared web objects that are used by products. # This is usually (always ?) limited to images used # when displaying an object in contents lists. # These objects are accessed as: # /misc_/Product/name misc_ = { "folder_icon": ImageFile("www/folder40.gif", globals()), } ./Photo.py0000664000076400007640000011270511156345343007623 0ustar ############################################################################## # # Photo for Zope # # Copyright (c) 2001 Logic Etc, Inc. All rights reserved. # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA # # Ron Bickers rbickers@logicetc.com # Logic Etc, Inc. http://www.logicetc.com/ # ############################################################################## """Photo Photo objects provide a way to manage various display sizes of an image. They are very similar to Zope Image objects but generate and store multiple copies of the image in different sizes. """ import sys, string from OFS.Image import Image, cookId from Acquisition import Implicit from Globals import Persistent from OFS.SimpleItem import Item from OFS.PropertyManager import PropertyManager from OFS.PropertySheets import PropertySheet from AccessControl.Role import RoleManager from AccessControl import ClassSecurityInfo from Globals import InitializeClass, DTMLFile from Products.PythonScripts.standard import html_quote from Products.ZCatalog.CatalogAwareness import CatalogAware try: from webdav.WriteLockInterface import WriteLockInterface from webdav.Lockable import ResourceLockedError except ImportError: pass from cStringIO import StringIO try: import PIL.Image except ImportError: pass import time from JpgComment import DummyJpegImageFile from EXIF import process_file from zLOG import LOG,ERROR import zLOG,sys defaultdisplays = {'thumbnail': (128,128), 'xsmall': (200,200), 'small': (320,320), 'medium': (480,480), 'large': (768,768), 'xlarge': (1024,1024) } class Photo(CatalogAware, Implicit, Persistent, PropertyManager, RoleManager, Item): """Photo object. Photo objects contain as properties a series of resized Zope Image objects according to the given display sizes. """ try: __implements__ = (WriteLockInterface,) except NameError: pass meta_type = "Photo" _properties = ( {'id':'title', 'type': 'string', 'mode': 'w'}, ) manage_options = ( {'label': 'Edit', 'action': 'manage_editPhotoForm'}, {'label': 'View', 'action': 'manage_viewPhoto'}, {'label': 'Settings', 'action': 'manage_editSettingsForm'}, {'label': 'Displays', 'action': 'manage_editDisplaysForm'}, ) + PropertyManager.manage_options \ + RoleManager.manage_options \ + Item.manage_options security = ClassSecurityInfo() def __init__(self, id, title, file, content_type='', precondition='', store='Image', engine='PIL', quality=75, pregen=0, timeout=0): self.__version__ = '1.2.3' self.id = id self.title = title # Sheet to store photo settings. self.propertysheets.manage_addPropertySheet('photoconf', 'photoconf') photoconf = self.propertysheets.get('photoconf') photoconf.manage_addProperty('store', store, 'string') photoconf.manage_addProperty('engine', engine, 'string') photoconf.manage_addProperty('quality', quality, 'int') photoconf.manage_addProperty('pregen', pregen, 'boolean') photoconf.manage_addProperty('timeout', timeout, 'int') # Initialize with default hardcoded sizes. self._displays = defaultdisplays.copy() self._photos = {} # # Original photo attributes # security.declareProtected('Access contents information', 'height') def height(self): """Original photo height.""" return self._original._height() security.declareProtected('Access contents information', 'width') def width(self): """Original photo width.""" return self._original._width() security.declareProtected('Access contents information', 'size') def size(self): """Original photo size in bytes.""" return self._original._size() security.declareProtected('Access contents information', 'content_type') def content_type(self): """Original photo content_type.""" return self._original._content_type() # # Photo display methods # security.declareProtected('View', 'tag') def tag(self, display=None, height=None, width=None, cookie=0, alt=None, css_class=None, **kw): """Return HTML img tag.""" # Get cookie if display is not specified. if display is None: display = self.REQUEST.cookies.get('display', None) # display may be set from a cookie. if display is not None and self._displays.has_key(display): if not self._isGenerated(display): # Generate photo on-the-fly self._makeDisplayPhoto(display, 1) image = self._photos[display] width, height = (image._width(), image._height()) # Set cookie for chosen size if cookie: self.REQUEST.RESPONSE.setCookie('display', display, path="/") else: # TODO: Add support for on-the-fly resize? height = self._original._height() width = self._original._width() if display: result = ' tags for displays.""" links = [] for display in self.displayIds(exclude): links.append('%s' % (self.REQUEST['URL'], display, display)) return links security.declareProtected('Access contents information', 'displayMap') def displayMap(self, exclude=None): """Return list of displays with size info.""" displays = [] for id in self.displayIds(exclude): if self._isGenerated(id): photo_width = self._photos[id]._width() photo_height = self._photos[id]._height() bytes = self._photos[id]._size() age = self._photos[id]._age() else: (photo_width, photo_height, bytes, age) = (None, None, None, None) displays.append({'id': id, 'width': self._displays[id][0], 'height': self._displays[id][1], 'photo_width': photo_width, 'photo_height': photo_height, 'bytes': bytes, 'age': age }) return displays security.declareProtected('View', 'index_html') def index_html(self, REQUEST, RESPONSE, display=None): """Return the image data.""" # display may be set from a cookie (?) if display and self._displays.has_key(display): if not self._isGenerated(display): # Generate photo on-the-fly self._makeDisplayPhoto(display, 1) else: timeout = self.propertysheets.get('photoconf').getProperty('timeout') if timeout and self._photos[display]._age() > (timeout / 2): self._expireDisplays((display,), timeout) # Return resized image return self._photos[display].index_html(REQUEST, RESPONSE) # Return original image return self._original.index_html(REQUEST, RESPONSE) security.declareProtected('View', 'default_html') default_html = DTMLFile('dtml/sampleView', globals()) security.declareProtected('View', 'view') def view(self, client=None, REQUEST=None, RESPONSE=None, **kw): """ Show default view """ # Get the template to use template_id = 'photo_view' if hasattr(self.aq_base, template_id): # Look in base template = getattr(self.aq_base, template_id) template = template.__of__(self) elif hasattr(self.aq_parent, template_id): # Look in parent template = getattr(self.aq_parent, template_id) template = template.__of__(self) else: template = self.default_html # Use default_html return apply(template, ((client, self), REQUEST), kw) security.declareProtected('View', 'exifdata') def exifdata(self, field=None, pretty=None): """ Return just one field. """ exif = self.getExifValues() if field and exif: if exif.has_key(field): return str(exif[field]) if exif.has_key("EXIF DateTimeDigitized") and (field=="Date & Time" or field=="Date"): return str(exif["EXIF DateTimeDigitized"]) if exif.has_key("EXIF DateTimeOriginal") and (field=="Date & Time" or field=="Date"): return str(exif["EXIF DateTimeOriginal"]) if exif.has_key("Image DateTime") and (field=="Date & Time" or field=="Date"): return str(exif["Image DateTime"]) if exif.has_key("EXIF ExposureTime") and field=="Exposure Time": return str(exif["EXIF ExposureTime"])+"s" return("") if pretty: exif=str(exif) exif = exif.replace(",",",\n") exif = exif.replace(":",": ") return exif security.declareProtected('View', 'getExifValues') def getExifValues(self): """ Extract the EXIF info from the photo. Weed out the uninteresting ones. """ instream = self._original.data_as_stream() exifdata = process_file(instream) instream.close() x=exifdata.keys() for i in x: if i in ('JPEGThumbnail', 'TIFFThumbnail'): del exifdata[i] continue if i[:10] == 'Thumbnail_' or i[:14] == 'MakerNote_Tag_' or i[:9] == 'EXIF_Tag_': del exifdata[i] continue if not exifdata[i].field_type in (2, 3, 4, 5, 10): del exifdata[i] return exifdata security.declareProtected('Change Photo', 'setExifValues') def setExifValues(self): """ Set the EXIF info as properties to the Zope object """ instream = self._original.data_as_stream() self._setPropertiesFromExif(instream) instream.close() security.declareProtected('View', 'getinfo') def getinfo(self): """ Get debugging info - hack, gd """ s = str( self.absolute_url() )+"

    \n\n" s = s + str(self.__dict__) + "

    \n\n" s = s + str(self._original.__dict__) return s security.declareProtected('View', 'imagecomment') def imagecomment(self): """ Return the JPEG comment """ if self._original.content_type == 'image/jpeg': instream = self._original.data_as_stream() dummy = DummyJpegImageFile(instream) comment = ' '.join(dummy.getCOM().split()) instream.close() return comment else: return "" security.declareProtected('Access contents information', 'nextPhoto') def nextPhoto(self): """Return next Photo in folder.""" id = self.getId() photoIds = self.aq_parent.objectIds(['Photo']) photoIds.sort() if id == photoIds[-1]: return None return getattr(self.aq_parent, photoIds[photoIds.index(id)+1]) security.declareProtected('Access contents information', 'prevPhoto') def prevPhoto(self): """Return previous Photo in folder.""" id = self.getId() photoIds = self.aq_parent.objectIds(['Photo']) photoIds.sort() if id == photoIds[0]: return None return getattr(self.aq_parent, photoIds[photoIds.index(id)-1]) security.declareProtected('View', 'get_size') def get_size(self): """Return size in bytes of original photo.""" return self._original.get_size() # # Photo processing # def _resize(self, display, width, height, engine='PIL', quality=75): """Resize and resample photo.""" origimg = self._original newimg = StringIO() if engine == 'PIL': # Use PIL img = PIL.Image.open(origimg._PILdata()) fmt = img.format try: img = img.resize((width, height), PIL.Image.ANTIALIAS) except AttributeError: img = img.resize((width, height)) img.save(newimg, fmt, quality=quality) elif engine == 'ImageMagick': # Use ImageMagick if sys.platform == 'win32': from win32pipe import popen2 imgin, imgout = popen2('convert -quality %s -geometry %sx%s - -' % (quality, width, height), 'b') else: from popen2 import popen2 imgout, imgin = popen2('convert -quality %s -geometry %sx%s - -' % (quality, width, height)) imgin.write(origimg._IMdata()) imgin.close() newimg.write(imgout.read()) imgout.close() newimg.seek(0) return newimg def _getDisplayData(self, display): """Return raw photo data for given display.""" (width, height) = self._displays[display] if width == 0 and height == 0: width = self._original._width() height = self._original._height() (width, height) = self._getAspectRatioSize(width, height) engine = self.propertysheets.get('photoconf').getProperty('engine') quality = self.propertysheets.get('photoconf').getProperty('quality') return self._resize(display, width, height, engine, quality) def _getDisplayPhoto(self, display): """Return photo object for given display.""" try: base, ext = string.split(self.id, '.') id = base+'_'+display+'.'+ext except ValueError: id = self.id+'_'+display return self._original._newImage(id, self._getDisplayData(display), self.absolute_url(1)) def _makeDisplayPhoto(self, display, force=0): """Create given display.""" if self._shouldGenerate(display) or force: photo = self._photos if photo.has_key(display): photo[display].manage_upload(self._getDisplayData(display), self.content_type()) else: photo[display] = self._getDisplayPhoto(display) self._photos = photo def _makeDisplayPhotos(self): """Create all displays.""" for display in self._displays.keys(): self._makeDisplayPhoto(display) def _getAspectRatioSize(self, width, height): """Return proportional dimensions within desired size.""" img_width, img_height = (self.width(), self.height()) if height > img_height * width / img_width: height = img_height * width / img_width else: width = img_width * height / img_height return (width, height) def _validImage(self): """At least see if it *might* be valid.""" return self._original._isValid() def _isGenerated(self, display): """Return whether display has been generated.""" return self._photos.has_key(display) def _shouldGenerate(self, display): """Return whether display should be generated.""" return (self._isGenerated(display) or self.propertysheets.get('photoconf').getProperty('pregen')) def _expireDisplays(self, exclude=[], timeout=None): """Remove displays that have expired.""" if timeout is None: timeout = self.propertysheets.get('photoconf').getProperty('timeout') if not timeout: return photos = self._photos for d in self._photos.keys(): if d in exclude: self._photos[d]._p_changed = 1 elif self._photos[d]._age() > timeout: photos[d].manage_beforeDelete(None, None) # ExtImage support del photos[d] self._photos = photos def _getDisplayData(self, display): """Return raw photo data for given display.""" (width, height) = self._displays[display] if width == 0 and height == 0: width = self._original._width() height = self._original._height() (width, height) = self._getAspectRatioSize(width, height) engine = self.propertysheets.get('photoconf').getProperty('engine') quality = self.propertysheets.get('photoconf').getProperty('quality') return self._resize(display, width, height, engine, quality) def _getDisplayPhoto(self, display): """Return photo object for given display.""" try: base, ext = string.split(self.id, '.') id = base+'_'+display+'.'+ext except ValueError: id = self.id+'_'+display return self._original._newImage(id, self._getDisplayData(display), self.absolute_url(1)) def _makeDisplayPhoto(self, display, force=0): """Create given display.""" if self._shouldGenerate(display) or force: photo = self._photos if photo.has_key(display): photo[display].manage_upload(self._getDisplayData(display), self.content_type()) else: photo[display] = self._getDisplayPhoto(display) self._photos = photo def _makeDisplayPhotos(self): """Create all displays.""" for display in self._displays.keys(): self._makeDisplayPhoto(display) def _getAspectRatioSize(self, width, height): """Return proportional dimensions within desired size.""" img_width, img_height = (self.width(), self.height()) if height > img_height * width / img_width: height = img_height * width / img_width else: width = img_width * height / img_height return (width, height) def _validImage(self): """At least see if it *might* be valid.""" return self._original._isValid() def _isGenerated(self, display): """Return whether display has been generated.""" return self._photos.has_key(display) def _shouldGenerate(self, display): """Return whether display should be generated.""" return (self._isGenerated(display) or self.propertysheets.get('photoconf').getProperty('pregen')) def _expireDisplays(self, exclude=[], timeout=None): """Remove displays that have expired.""" if timeout is None: timeout = self.propertysheets.get('photoconf').getProperty('timeout') if not timeout: return photos = self._photos for d in self._photos.keys(): if d in exclude: self._photos[d]._p_changed = 1 elif self._photos[d]._age() > timeout: photos[d].manage_beforeDelete(None, None) # ExtImage support del photos[d] self._photos = photos # # FTP/WebDAV support # security.declareProtected('Change Photo', 'PUT') def PUT(self, REQUEST, RESPONSE): """Handle HTTP PUT requests.""" self.dav__init(REQUEST, RESPONSE) if hasattr(self, 'dav__simpleifhandler'): self.dav__simpleifhandler(REQUEST, RESPONSE, refresh=1) file=REQUEST['BODYFILE'] if hasattr(self, '_original'): # Updating existing Photo self._original.manage_upload(file, self.content_type()) if self._validImage(): self._makeDisplayPhotos() else: # Adding a new Photo. # At this point, the object is not yet in its final context. # Since ExtImage needs to know the URL of the new Photo object # so it can determine where to create new files, we store # the image data and let manage_afterAdd() generate the displays # once the Photo is in its final context. self._data = file.read() # Zope 2.7.4 and after does _setObject before calling this PUT(), # so we can do all the work now. if self.absolute_url(1): store = self.propertysheets.get('photoconf').getProperty('store') if store == 'Image': from PhotoImage import PhotoImage elif store == 'ExtImage': from ExtPhotoImage import PhotoImage self._original = PhotoImage(self.id, self.title, path=self.absolute_url(1)) self._original.manage_upload(StringIO(self._data), self.content_type()) delattr(self, '_data') if self._validImage(): self._makeDisplayPhotos() RESPONSE.setStatus(204) return RESPONSE security.declareProtected('FTP access', 'manage_FTPget', 'manage_FTPstat', 'manage_FTPlist') def manage_FTPget(self): """Handle GET requests.""" return self._original._data() def manage_FTPstat(self, REQUEST): """Handle STAT requests.""" return self._original.manage_FTPstat(REQUEST) def manage_FTPlist(self, REQUEST): """Handle LIST requests.""" return self._original.manage_FTPlist(REQUEST) # # Management Interface # security.declareProtected('View management screens', 'manage_viewPhoto') manage_viewPhoto = DTMLFile('dtml/viewPhoto', globals()) security.declareProtected('View management screens', 'manage_editPhotoForm') manage_editPhotoForm = DTMLFile('dtml/editPhotoForm', globals()) security.declareProtected('Change Photo', 'manage_editPhoto') def manage_editPhoto(self, file='', REQUEST=None): """Changes Photo information.""" if hasattr(self, 'wl_isLocked') and self.wl_isLocked(): raise ResourceLockedError, "Photo is locked via WebDAV." self.manage_changeProperties(REQUEST) if file and file.filename: self._original.manage_upload(file, self.content_type()) if self._validImage(): self._makeDisplayPhotos() self.reindex_object() # update ZCatalog if REQUEST is not None: return self.manage_editPhotoForm(REQUEST, manage_tabs_message='Photo information updated.') security.declareProtected('View management screens', 'manage_editSettingsForm') manage_editSettingsForm = DTMLFile('dtml/editSettingsForm', globals()) security.declareProtected('Manage properties', 'manage_editSettings') def manage_editSettings(self, REQUEST=None): """Edit photo settings.""" photoconf = self.propertysheets.get('photoconf') photoconf.manage_editProperties(REQUEST) if REQUEST is not None: return self.manage_editSettingsForm(REQUEST, manage_tabs_message='Photo settings updated.') security.declareProtected('View management screens', 'manage_editDisplaysForm') manage_editDisplaysForm = DTMLFile('dtml/editDisplaysForm', globals()) security.declareProtected('Manage properties', 'manage_editDisplays') def manage_editDisplays(self, displays, manage_editDisplays=None, REQUEST=None): """Edit displays.""" d = self._displays p = self._photos for display in displays: if (d[display.id] != (display.width, display.height) or manage_editDisplays == ' Regenerate All '): d[display.id] = (display.width, display.height) f._data = file.read() RESPONSE.setStatus(204) return RESPONSE security.declareProtected('FTP access', 'manage_FTPget', 'manage_FTPstat', 'manage_FTPlist') def manage_FTPget(self): """Handle GET requests.""" return self._original._data() def manage_FTPstat(self, REQUEST): """Handle STAT requests.""" return self._original.manage_FTPstat(REQUEST) def manage_FTPlist(self, REQUEST): """Handle LIST requests.""" return self._original.manage_FTPlist(REQUEST) # # Management Interface # security.declareProtected('View management screens', 'manage_viewPhoto') manage_viewPhoto = DTMLFile('dtml/viewPhoto', globals()) security.declareProtected('View management screens', 'manage_editPhotoForm') manage_editPhotoForm = DTMLFile('dtml/editPhotoForm', globals()) security.declareProtected('Change Photo', 'manage_editPhoto') def manage_editPhoto(self, file='', REQUEST=None): """Changes Photo information.""" if hasattr(self, 'wl_isLocked') and self.wl_isLocked(): raise ResourceLockedError, "Photo is locked via WebDAV." self.manage_changeProperties(REQUEST) if file and file.filename: self._original.manage_upload(file, self.content_type()) if self._validImage(): self._makeDisplayPhotos() self.reindex_object() # update ZCatalog if REQUEST is not None: return self.manage_editPhotoForm(REQUEST, manage_tabs_message='Photo information updated.') security.declareProtected('View management screens', 'manage_editSettingsForm') manage_editSettingsForm = DTMLFile('dtml/editSettingsForm', globals()) security.declareProtected('Manage properties', 'manage_editSettings') def manage_editSettings(self, REQUEST=None): """Edit photo settings.""" photoconf = self.propertysheets.get('photoconf') photoconf.manage_editProperties(REQUEST) if REQUEST is not None: return self.manage_editSettingsForm(REQUEST, manage_tabs_message='Photo settings updated.') security.declareProtected('View management screens', 'manage_editDisplaysForm') manage_editDisplaysForm = DTMLFile('dtml/editDisplaysForm', globals()) security.declareProtected('Manage properties', 'manage_editDisplays') def manage_editDisplays(self, displays, manage_editDisplays=None, REQUEST=None): """Edit displays.""" d = self._displays p = self._photos for display in displays: if (d[display.id] != (display.width, display.height) or manage_editDisplays == ' Regenerate All '): d[display.id] = (display.width, display.height) if self._shouldGenerate(display.id): p[display.id].manage_beforeDelete(None, None) # ExtImage support p[display.id] = self._getDisplayPhoto(display.id) self._displays = d self._photos = p if REQUEST is not None: return self.manage_editDisplaysForm(REQUEST, manage_tabs_message='Displays changed.') security.declareProtected('Manage properties', 'manage_delDisplays') def manage_delDisplays(self, ids, REQUEST=None): """Delete displays.""" d = self._displays p = self._photos for id in ids: try: del d[id] p[id].manage_beforeDelete(None, None) # ExtImage support del p[id] except: pass self._displays = d self._photos = p if REQUEST is not None: return self.manage_editDisplaysForm(REQUEST, manage_tabs_message='Displays deleted.') security.declareProtected('Manage properties', 'manage_addDisplay') def manage_addDisplay(self, id, width, height, REQUEST=None): """Add display.""" d = self._displays p = self._photos d[id] = (width, height) if self._shouldGenerate(id): p[id] = self._getDisplayPhoto(id) self._displays = d self._photos = p if REQUEST is not None: return self.manage_editDisplaysForm(REQUEST, manage_tabs_message='Display added.') security.declareProtected('Change Photo', 'manage_regenDisplays') def manage_regenDisplays(self, REQUEST=None): """Regenerate all displays.""" self._makeDisplayPhotos() if REQUEST is not None: return self.manage_editDisplaysForm(REQUEST, manage_tabs_message='Displays regenerated.') security.declareProtected('Change Photo', 'manage_purgeDisplays') def manage_purgeDisplays(self, exclude=None, REQUEST=None): """Purge generated displays.""" if exclude is None and REQUEST is not None: exclude = REQUEST.form.get('ids', []) self._expireDisplays(exclude or [], -1) if REQUEST is not None: return self.manage_editDisplaysForm(REQUEST, manage_tabs_message='Displays purged.') security.declareProtected('Change Photo', 'manage_cleanDisplays') def manage_cleanDisplays(self, exclude=None, REQUEST=None): """Purge all generated displays that have expired.""" if exclude is None and REQUEST is not None: exclude = REQUEST.form.get('ids', []) self._expireDisplays(exclude or []) if REQUEST is not None: return self.manage_editDisplaysForm(REQUEST, manage_tabs_message='Expired displays purged.') # # ExtImage management support # def manage_afterClone(self, item): """Prepare photos for cloning.""" self._original.manage_afterClone(item) for photo in self._photos.values(): photo.manage_afterClone(item) return Photo.inheritedAttribute ("manage_afterClone") \ (self, item) def manage_afterAdd(self, item, container): """Handle pasting of new photos.""" # For Zope 2.7.3 and before. # See notes in PUT() if not hasattr(self, '_original'): # Added Photo (vs. imported) # See note in PUT() store = self.propertysheets.get('photoconf').getProperty('store') if store == 'Image': from PhotoImage import PhotoImage elif store == 'ExtImage': from ExtPhotoImage import PhotoImage self._original = PhotoImage(self.id, self.title, path=self.absolute_url(1)) if hasattr(self, '_data'): self._original.manage_upload(StringIO(self._data), self.content_type()) self._setPropertiesFromExif(StringIO(self._data)) delattr(self, '_data') if self.title == '': self.title = self.imagecomment() if self._validImage(): self._makeDisplayPhotos() self._original.manage_afterAdd(item, container) # could call parent's like this: -gd # super(Photo, self).manage_afterAdd(item, container) # -gd # if hasattr(self, '_photos'): for photo in self._photos.values(): photo.manage_afterAdd(item, container) return Photo.inheritedAttribute ("manage_afterAdd") \ (self, item, container) def manage_beforeDelete(self, item, container): """Delete (mark for undo) each photo file.""" self._original.manage_beforeDelete(item, container) for photo in self._photos.values(): photo.manage_beforeDelete(item, container) return Photo.inheritedAttribute ("manage_beforeDelete") \ (self, item, container) def _setPropertiesFromExif(self, file): """ Read the EXIF information """ exifprop = self.propertysheets.get('exif') if exifprop is None: self.propertysheets.manage_addPropertySheet('exif', 'exif') exifprop = self.propertysheets.get('exif') exifdata = process_file(file) x=exifdata.keys() x.sort() for i in x: if i in ('JPEGThumbnail', 'TIFFThumbnail'): continue if i[:10] == 'Thumbnail_' or i[:14] == 'MakerNote_Tag_' or i[:9] == 'EXIF_Tag_': continue if exifdata[i].field_type in (2, 3, 4, 5, 10): try: exifprop.manage_addProperty(i, exifdata[i].printable, "string") except: pass # # Factory methods # manage_addPhotoForm = DTMLFile('dtml/addPhotoForm', globals()) def manage_addPhoto(dispatcher, id, title, file, content_type='', precondition='', store='Image', engine='ImageMagick', quality=75, timeout=0, pregen=0, REQUEST=None): """Add Photo object.""" id = cookId(id, title, file)[0] dest = dispatcher.Destination() photo = Photo(id, title, '', content_type, precondition, store, engine, quality, pregen, timeout) try: photo._data = file.read() except AttributeError: photo._data = str(file) dest._setObject(id, photo) # Images are generated at this point by manage_afterAdd() self = dest._getOb(id) # Init properties and displays from Photo Folder if present parent = self.aq_parent if parent.meta_type == 'Photo Folder': props = parent.propertysheets.get('photos') for prop in props.propertyMap(): try: if prop['type'] in ('selection', 'multiple selection'): self.manage_addProperty(prop['id'], prop['select_variable'], prop['type']) self.manage_changeProperties({prop['id']: props.getProperty(prop['id'])}) else: self.manage_addProperty(prop['id'], props.getProperty(prop['id']), prop['type']) except: pass # Properties may have been added automatically self._displays = parent._displays.copy() if REQUEST is not None: try: url=dispatcher.DestinationURL() except: url=REQUEST['URL1'] if REQUEST.form.get('action', None) == ' Add and Edit ': REQUEST.RESPONSE.redirect('%s/%s/manage_workspace' % (url, id)) else: REQUEST.RESPONSE.redirect('%s/manage_workspace' % url) return id InitializeClass(Photo) ./help/0000775000016000007640000000000007330634067007771 5ustar zope./README.txt0000664000076400007640000005336211152647241007657 0ustar Photo and Photo Folder Overview This product provides a Photo object and a Photo Folder object for managing digital images in Zope. Photo objects provide multiple configurable sizes of the photo. Photo Folders provide a way to manage a group of Photo objects by providing a way to specify display sizes and properties for all contained photos. This document has been updated for version 1.3.1. Updated to 1.3.2 and then edited by GD to incorporate changes from 1.2.4, thus making 1.4 (some other minor changes included). Installation Photo can be downloaded from the "Zope community site":http://www.zope.org/Members/Roug/Photo/. Extract the distribution file in your Zope installation's Product directory. The product is an update of "Ron Bickers' photo product":http://www.zope.org/Members/rbickers/Photo Photo requires the Python Image Library module (PIL) to be installed such that Zope can find it, or ImageMagic's 'convert' program in the path. Visit the "PIL Web site":http://www.pythonware.com/products/pil/ for information on downloading and installing PIL, and the "ImageMagick Web site":http://www.imagemagick.org/ for information on ImageMagick. Photo Overview Photo objects provide a way to manage various display sizes of an image. They are very similar to Zope Image objects but generate and store multiple copies of the image in different sizes. These sizes are configurable for each Photo. Displays A default set of display sizes are given to each new Photo object. These defaults can be overridden by configuring display sizes in a Photo Folder and adding Photos to that folder. See the section on Photo Folders for more details. The default sizes are as follows:: Desired Display Name Width x Height thumbnail 128 x 128 xsmall 200 x 200 small 320 x 320 medium 480 x 480 large 768 x 768 xlarge 1024 x 1024 Note that the dimensions are the *desired* dimensions. When resized, each photo will be made as large as possible within the desired limits while still maintaining its aspect ratio. Making the width and height the same number will ensure that portrait and landscape images maintain a consistent physical size when displayed. For example, if you scan a standard 4x6 photograph taken with a camera in its normal position, and save it as a 1200w x 800h Photo, the *medium* display will resize to 480w x 320h. A photograph taken with the camera sideways and saved as a 800w x 1200h image would be resized to 320w x 480h. The same dimensions, just a different orientation. In contrast, if you configure a dimension such as 640w x 480h, the first photo would resize to 640w x 427h, and the second photo would resize to 320w x 480h. The size of these two rendered images is considerably different, even though the originals have the same dimensions (ignoring orientation). If you set both width and height to zero (0), the display size will be that of the original photo, but will have been processed by the engine. Settings Each photo has various settings that determine certain properties of the photo. The following is a list of the available settings: * Store - determines the format for the image storage. See Stores and Engines below for details. * Engine - determines which image rendering engine is used to create the different display sizes. See Stores and Engines below for details. * Quality - this is the compression quality number from 1 to 100, 1 being the worst image quality, 100 being the best. * Pregenerate Displays - determines if Photo should generate the displays when the Photo is created (and regenerate when it is updated), or if it should generate the displays on-the-fly when they are requested. * Display Cache Timeout - specifies the time in minutes that the displays should remain stored. Zero (0) means never purge. See the section on 'Display Cache' for details. Properties In addition to display sizes and settings, Photo objects provide configurable properties to associate information with each photo. These properties are the same properties that many other Zope objects provide. The standard Properties tab is available for adding and deleting properties. However, the default management view displays a thumbnail of the image along with each defined property for one-screen access to updating the Photo information. In this *Edit* view, property ids are displayed *capitalized* and *spacified*, which means a property with an id 'photo_date' will display as 'Photo date'. Stores and Engines There are two options for storing the image data: 'Image' and 'ExtImage'. 'Image' (the default) uses Zopes built in Image object to store the images in the ZODB. 'ExtImage' uses the ExtFile/Image product to store the image files on the file system. For this option, you must have ExtFile/Image installed and configured. Once a store is chosen for a photo, it cannot be changed without deleting and recreating the photo. IMPORTANT NOTE: Zope 2.4.0 has a bug which prevents ExtImage from properly handling copying and pasting objects. You should not use Zope 2.4.0 with the ExtImage option. Zope 2.4.1 with ExtImage 1.1.3 works properly, as does Zope 2.3. There are also two options for the engine to use for rendering display sizes: 'PIL' and 'ImageMagick'. 'PIL' uses the Python Imaging Library. This option is relatively fast, but the images it produces are not the best quality, with features such as edges that are not smooth. 'ImageMagick' produces much smoother images at the expense of performance. It can take quite a bit longer to produce displays with 'ImageMagick' over using 'PIL' depending on your hardware and the image itself. Also, there is no up to date Python module support for 'ImageMagick'. Photo runs an external program to process the images. This may or may not work on your system. Because of ImageMagick's superior rendering quality, ImageMagick is the default engine. Display Cache Photo objects consist of the original image and a series of configurable display sizes that are generated from the original image. These display sizes are stored in the database (or as separate files if you're using ExtImage) for faster retrieval since rendering displays can be resource intensive and time consuming. However, since many of the display sizes may never be viewed, or may be viewed infrequently, Photo allows you to choose whether or not to generate these displays when the Photo is created, or to generate them on-the-fly when they are requested. In addition, if you choose to generate them on-the-fly, you can optionally set a timeout (in minutes) to purge the display from storage. If you select the 'Pregenerate Displays' option, all display sizes will be generated when the Photo is added and all of them will be regenerated when the Photo is updated. If the 'Pregenerate Displays' option is not chosen, the displays will only be created when the display is requested. Note that if the 'Pregenerate Displays' option is not chosen, the 'Regenerate All' option in the 'Displays' tab will not generate displays that have not already been generated. The 'Purge All' option will remove all generated displays from storage, regardless of the 'Pregenerate Displays' setting. In any case, if a display is requested, and has not been generated, it will be generated on-the-fly. If you set a timeout, Photo will purge displays whose age exceeds the timeout. Purging is done as follows: When a display is requested, Photo checks the age of the display. If it is greater than half of the timeout setting, Photo a) resets the age of the requested display to zero, and b) purges any displays in that Photo object whose age is greater than the timeout. The 'Clean Up' option can be used to force a purge. If a display's age is greater than the timeout, it will be purged. Otherwise it will remain unchanged. If you want to exclude a particular display or displays from being purged, you can 'check' those displays before selecting 'Clean Up'. You can force all displays to be purged regardless of their age using the 'Purge All' option. If you want to exclude a particular display or displays from being purged, you can 'check' those displays before selecting 'Purge All'. Because purging a display does not actually remove it from the database (ZODB is an append only database), you'll need to pack regularly if your timeout is low and many displays are generated and purged. A timeout of several days (depending on site traffic) is recommended. Usage (API) Photo objects provide several methods for viewing the different display sizes and to assist in creating navigable Web pages. * tag(display=None, height=None, width=None, cookie=0, alt=None, css_class=None, **kw) Inserts an HTML img tag to display the image. If 'display' is specified, the image will be shown in that display size. If it is not specified, or if the display doesn't exist, the original image is displayed. 'height' and 'width' are currently not used, but may in future releases allow for on-the-fly resizing of images. If 'cookie' is true, and 'display' is specified, Photo will set a browser cookie to save the display size. If 'cookie' is true, and 'display' is *not* specified, the Photo will be displayed in the size specified by the browser cookie. If the cookie is not set, the original image will be displayed. The 'alt', 'css_class', and additional keyword arguments will add 'alt', 'class', and additional attributes to the image tag. If 'alt' is not specified, the Photo's 'title' or 'id' will be used. The additional attributes are useful for adding things such as 'border=1' to provide a border around the image. * exttag(prefix, display=None, cookie=0, alt=None, css_class=None, **kw) Inserts an HTML img tag to display the image via a server other than Zope. This option only makes sense for the 'ExtImage' store. The 'prefix' is a URL that the image server can use to read files from the 'ExtImage' repository. The 'src' attribute of the img tag will be 'prefix' + the filename of the requested display size as stored by 'ExtImage'. If 'display' is specified, the tag will use the file for that display size. If it is not specified, or if the display doesn't exist, the original image file will be used. If 'cookie' is true, and 'display' is specified, Photo will set a browser cookie to save the display size. If 'cookie' is true, and 'display' is *not* specified, the Photo will be displayed in the size specified by the browser cookie. If the cookie is not set, the original image will be displayed. The 'alt', 'css_class', and additional keyword arguments will add 'alt', 'class', and additional attributes to the image tag. If 'alt' is not specified, the Photo's 'title' or 'id' will be used. The additional attributes are useful for adding things such as 'border=1' to provide a border around the image. * displayIds(exclude=('thumbnail',)) Returns a list of display ids, excluding those specified by 'exclude'. This is useful for creating a list of available display sizes from which to choose. The default is to exclude 'thumbnail' since it is normally not wanted as an option for viewing a Photo. The list is sorted by the smallest display image in bytes. * displayLinks(exclude=('thumbnail',)) Returns a list of HTML link tags for each display size. For example:: small This is useful for providing quick links to the different display sizes. The list is sorted by the smallest display image in bytes. See 'displayIds' for an explanation of 'exclude'. * nextPhoto() Returns the next Photo object in the current folder, or 'None' if this is the last object. Objects are sorted by id. This is useful for providing navigational links to adjacent photos. For example:: * prevPhoto() Returns the previous Photo object in the current folder, or 'None' if this is the first object. Objects are sorted by id. This is useful for providing navigational links to adjacent photos. See 'nextPhoto' for an example. In addition to the configured properties, Photo objects also have a few properties that are not configurable: * content_type The content type of the image. * width The width, in pixels, of the original uploaded image. * height The height, in pixels, of the original uploaded image. * size The size, in bytes, of the original uploaded image. Photo Folder Overview Photo Folder objects help manage a group of Photo objects by providing an interface for adding, removing, and modifying the properties and display sizes off all contained photos, and by providing defaults for newly created photos. It is not required that Photo objects be created inside of a Photo Folder. They will function properly in a normal folder. However, if you do not use Photo Folders, you will have to modify properties and display sizes of each individual Photo once it has been added. Displays The 'Displays' tab in the Photo Folder management interface is where you manage display sizes for contained photos. See the displays section under 'Photo' for details on displays. The displays in the Photo Folder will be used as the default displays for each new Photo object that is added to that Photo Folder. If you add a display, every Photo object contained in the folder will be given the new display. If the display already exists in a particular photo, it will be left unmodified. If you delete a display, every contained Photo object will have that display size removed. If the display does not exist in a particular photo, it will be ignored. If you modify a display, every contained photo that has the modified displays will be updated to reflect the new width and height. If a photo does not have the displays modified, it will be ignored. The display will not be added. Properties Photo Folders have two tabs for properites: the standard 'Properties' tab, and a 'Photo Properties' tab. * Properties Tab The standard 'Properties' tab is where Photo Folder properties are created as is done with many other Zope objects. These might include a 'title' and 'description' for the collection of photos, or an 'image' that specifies a representative photo from the collection to display when listing multiple Photo Folders. * Photo Properties Tab The 'Photo Properties' tab provides two sections relating to the Photo objects contained in the Photo Folder: 'Default Settings' and 'Photo Properties'. The 'Default Settings' provides newly created Photo objects with default values for their settings as well as allows you to modify the settings for all contained Photos. See the Photo object documentation for details on the available settings. The 'Photo Properties' is very similar to a standard 'Properties', except that the properties apply to the contained Photo objects. When you add a property, the property is added to all contained Photo objects with the given value. If a particular photo already has the added property, it is left unmodified for that photo. When you delete a property, the property is deleted from all contained Photo objects. If a particular photo doesn't have that property, it is ignored. Modifying property values in this screen will *not* change property values for any contained photos, but new photos added to this Photo Folder will be given the new value for the modified property. When you add a new Photo object to a Photo Folder, it has a 'title' property plus all of the properties and values listed on this screen. Usage (API) Photo Folder objects provide a few helper methods to assist in creating views of the contained folders. * numPhotos() Returns the number of Photo objects in the Photo Folder. * nextPhotoFolder() Returns the next Photo Folder object in the current folder, or 'None' if this is the last object. Objects are sorted by id. This is useful for providing navigational links to adjacent Photo Folders. For example:: * prevPhotoFolder() Returns the previous Photo Folder object in the current folder, or 'None' if this is the first object. Objects are sorted by id. This is useful for providing navigational links to adjacent Photo Folders. See 'nextPhotoFolder' for an example. Converting Image Objects to Photo Objects You can convert existing Zope Image objects to Photo objects with the following Python Script:: """Convert all Image objects in folder to Photo objects""" for image in context.objectValues(['Image']): context.manage_delObjects([image.getId(),], REQUEST=context.REQUEST) context.manage_addProduct['Photo'].manage_addPhoto(image.getId(), image.title, image.data, REQUEST=context.REQUEST) If you save this script as 'Image2Photo', you can run it on a folder with Image objects to convert them. For example, if you have images in /Personal/Photos, you can run http://myhost/Personal/Photos/Image2Photo. FTP/WebDAV Support Photos can be transferred via FTP/WebDAV. If you upload an image file to an existing Photo Folder, a Photo object will be created using the default settings provided by the Photo Folder. If you upload an image file to an existing Photo object, only the image data itself will be updated and the displays will be rerendered. Downloading from a Photo object will get the original image file. Notes * There is no internal link or association between a Photo Folder and a contained Photo. Photo objects can be created, copied and pasted outside of Photo Folders and they will still function properly. If you paste a Photo inside a Photo Folder and the folder 'Photo Properties' and 'Displays' do not correspond with those of the pasted Photo, the photo will *not* be modified. It's up to you to modify the photo to bring it in sync with the folder. Future versions may provide a method of syncronizing contained folders for this case. * Rendering display sizes takes time, especially with the 'ImageMagick' engine option. It is most efficient to create a Photo Folder, set the display sizes and properties as desired, and then add new Photo objects. When you add or modify Photo Folder display sizes, each contained photo must be updated by regenerating the display sizes, which can be a slow process if there are many photos. This is minimized somewhat by only regenerating the display sizes that were modified. * When you add a Photo Folder, you are given the option to create sample views. This will create two DTML Methods, named 'photo_folder_index' and 'photo_view'. 'index_html' will display the 'thumbnail' size of the contained photos and provide a link to view the photo using the 'view' method. The 'view' method allows you to view the photo in its various sizes and provides links to the previous and next photos in the folder. Neither output is very pretty, but you can use these to help construct your own view methods. The outputs use CSS2 styling for extra flexibility. To get going you include the content of CSS_EXAMPLE into your own stylesheet. Beware that the styles have special handling of print. Those parts must be installed into your print stylesheet. If you don't have a 'photo_folder_index' of 'photo_view' in the photo folder in any parent, the product will use default methods to display the pictures. * Currently, "contained" Photo objects means that the Photo object is directly in the Photo Folder. 'Photo Properties' and 'Displays' settings of a Photo Folder do not apply to sub folders and their Photo objects. More Information Visit the "Source Forge site":http://sourceforge.net/projects/zopephoto/ for questions, comments, bug reports, the latest release, and CVS access. You may also visit the "Zope community Web site":http://www.zope.org/Members/Roug/Photo/. ./www/0000775000076400007640000000000010661072261006772 5ustar ./www/photofolder.gif0000664000076400007640000000020310057365036012005 0ustar GIF89aPPP@,@P@B1 pN aİUIB`MEmkH5. cj`le*ԉzޠz%JY!mW;./www/photo.gif0000664000076400007640000000016610057365036010621 0ustar GIF89a"""DDD!,;h0@ " *`,`, R+A4{'@aS0Z)@hLB$;./www/folder40.gif0000664000076400007640000000064610111132432011071 0ustar GIF89a((!,((Hyμ8}y'|FH Zl,t=+Q6R2Rz,P9D(G☧]ITu&%Fq&{m"gR ~T.g:k[A@0S9jH@q))8x&o]B^ɫp.9ĠgH&HizoiCūAolw'7180TpӸ5Nh0UT 8Q\N3u2fPh,}*A}GdҰD+544*UzuSX3";./CSS_EXAMPLE0000664000076400007640000000501310111132043007654 0ustar /* PRINT START */ @media print { #photo-previous, #photo-next, #photo-sizes, #photo-ziplink { display: none; } } /* PRINT END */ /* SCREEN */ @media screen { #photo-previous { float: left; font-size: 8pt; text-decoration: none; } #photo-next { float: right; font-size: 8pt; text-decoration: none; } #photo-sizes { margin: 0; padding: 1em 0; list-style: none; text-align: center; display: block; } #photo-sizes li { margin: 0; padding: 0; display: inline; } #photo-sizes a { background-color: rgb(210,210,210); border: 1px solid #555; text-decoration: none; margin: 0; padding: 0.3em 1em; } #photo-sizes a.photo-current { background-color: rgb(230,230,230); } #photo-sizes a:hover { background-color: rgb(190,190,190); } #photo-ziplink { padding: 1em 0; text-align: center; clear: left; } #photo-ziplink a { background-color: rgb(210,210,210); border: 1px solid #555; text-decoration: none; margin: 0; padding: 0.3em 1em; } } /* SCREEN END */ #photo-properties { border-collapse: collapse; margin: 0.1em auto; white-space: nowrap; border: 1px solid rgb(190,190,190); width: 80%; } #photo-properties th { text-align: right; width:25%; margin: 0; vertical-align:top; padding: 2px; border: 1px solid rgb(190,190,190); } #photo-properties td { text-align: left; width:75%; margin: 0; vertical-align:top; padding: 2px; border: 1px solid rgb(190,190,190); } #photo-title { text-align: center; } #photo { text-align: center; border: none; } #photo-thumbnails a { display: block; float:left; width: 130px; height: 158px; margin: 2px; text-align:center; border: 1px solid black; text-decoration: none; font-size: 8pt; color: black; } #photo-thumbnails .thumbtitle { display: block; background-color: #fff; } #photo-thumbnails .thumbpicture { display: block; width: 128px; height: 128px; margin: 1px; } #photo-thumbnails img { border: none; } #photo-thumbnails .thumbfolder { display: block; width: 48px; height: 52px; margin: 1px; padding: 30px 40px 46px 40px; border: none; } ./PhotoFolder.pyc0000644000016000001700000002732010630663044012664 0ustar zopezopem eed?Z#e i d+d@eedAZ$dBZ%RS(Ds1Photo Folder object implementation. Photo Folder objects are folders that can contain Photo objects and other supporting objects. They provide properties to all Photos and other Photo Folders in them. They also provide support methods for displaying Photos in an album-like manner. s Photo Foldertidttitlettypetstringtmodetwtimaget selectiontwdtselect_variablet image_selecttlabeltContentstactiont manage_mainsPhoto Propertiestmanage_editPhotoPropertiesFormtDisplaystmanage_editDisplaysFormtViewttImaget ImageMagickiKic Csd|_||_||_d|_|iidd|iid}|i d|d|i d|d|i d|d|i d |d |i d |d|iid d ti|_dS( Ns1.2.3Rt photoconftstoreR tenginetqualitytinttpregentbooleanttimeouttphotos(tselft __version__RRR tpropertysheetstmanage_addPropertySheettgetRtmanage_addPropertyRRR R"R$tdefaultdisplaystcopyt _displays( R&RRRRR R"R$R((t?/var/lib/zope2.9/instance/Classic/Products/Photo/PhotoFolder.pyt__init__Us    sAccess contents informationtphotoIdscCs|idgS(s%Return list of Photos in this folder.tPhotoN(R&t objectIds(R&((R/R1qscCsdg|iS(NR(R&R1(R&((R/Rust numPhotoscCsIt|idg}x*|idgD]}||i}q+W|S(s'Return number of Photos in folder tree.R2s Photo FolderN(tlenR&R3R%t objectValuestfolderR4(R&R%R7((R/R4ys tnextPhotoFoldercCse|i}|iidg}|i||djodSnt|i||i |dS(sReturn next Photo Folder.s Photo FolderiiN( R&tgetIdRt aq_parentR3t folderIdstsorttNonetgetattrtindex(R&R;R((R/R8s  tprevPhotoFoldercCse|i}|iidg}|i||djodSnt|i||i |dS(sReturn previous Photo Folder.s Photo FolderiiN( R&R9RR:R3R;R<R=R>R?(R&R;R((R/R@s  t displayIdsRcCsX|ii}x,|D]$}||jo|i|qqW|i|id|S(sReturn list of display Ids.cCs5t||d||d||d||dS(Nii(tcmptdtxty(RDRERC((R/tsN(R&R.tkeystidstexcludeRtremoveR<(R&RIRHR((R/RAs t displayMapcCsbg}xU|igD]D}|ihd|<d|i|d<d|i|d<qW|S(s'Return list of displays with size info.RtwidthitheightiN(tdisplaysR&RARtappendR.(R&RNR((R/RKs BsManage propertiessdtml/editPhotoPropertiesFormtmanage_editPhotoSettingscCs|iid}|i||iiddo_x\|idgD]D}|i d|iidi d|iidi|qHWn|dj o|i |ddSndS(sEdit photo settings.Rt changeallR2Rtmanage_tabs_messagesDefault photo settings updated.N( R&R(R*Rtmanage_editPropertiestREQUESTtformR=R6tphototsett getPropertyR(R&RTRVR((R/RPs %!  tmanage_editPhotoPropertiescCsG|iid}|i||dj o|i|ddSndS(sEdit photo properties.R%RRsPhoto properties updated.N(R&R(R*t photosheetRSRTR=R(R&RTRZ((R/RYs    tmanage_delPhotoPropertiescCs|iid}|i|x5|idgD]!}y|i|Wq2q2Xq2W|dj o|i |ddSndS(sDelete photo properties.R%R2RRsPhoto properties deleted.N( R&R(R*RZtmanage_delPropertiesRHR6RVRTR=R(R&RHRTRVRZ((R/R[s   tmanage_addPhotoPropertycCs|iid}|i|||x;|idgD]'}y|i|||Wq8q8Xq8W|dj o|i |ddSndS(sAdd photo property.R%R2RRsPhoto property added.N( R&R(R*RZR+RtvalueR R6RVRTR=R(R&RR^R RTRVRZ((R/R]s  sdtml/editFolderDisplaysFormtmanage_editDisplayscCs|i}xK|D]C}||i|i|ifjo|i|if||i