![[Home page]](../PythonPowered.gif "Home page"){kind=small}
| Books | Code | Blog | Python | Author | Train | Find | ©M.Lutz |
File: pygadgets-products/unzipped/_PyPhoto/PIL/pyphoto.py
#!/usr/bin/env python3
"""
############################################################################
PyPhoto 2.2: a basic but open-source and portable image viewer,
with scrolling, resizing, saves, and cached thumbnails for speed.
Copyright: 2006-2018 by M. Lutz, https://learning-python.com.
License: provided freely, but with no warranties of any kind.
Platforms: This program runs on Mac OS, Windows, and Linux
Requires: Source-code versions (only) require Python 3.X and Pillow
Originally from the book "Programming Python, 4th Edition" by M. Lutz
Release History:
2.2, Sep-2018: image auto-rotation, Pillow file/format workarounds.
2.1, Nov-2017: store a folder's thumbnails in a single pickle file.
2.0, Sep-2017: standalone release with PyGadgets, numerous changes.
Earlier versions appeared in the book noted above in 2010 and 2006.
============================================================================
OVERVIEW
============================================================================
This Python 3.X desktop-GUI program displays cached image-folder thumbnails
which open full-size images when clicked; scrolls both images and thumbnail
displays; and provides a variety of viewing functionality.
It supports multiple image-directory thumb windows. The initial image
folder is either passed in via user configs, uses the "images-mixed"
default, or is selected via a main-window button. Later directories are
opened by pressing "D" in either image-view or thumbnail-view windows.
For startup speed, folder thumbnails are cached in a pickle file in
writeable folders (subfolder caching is also coded for other programs).
The image viewer automatically resizes and scrolls images too large for
the screen, and supports scaling to display sides and full-size views.
A limited save option also allows resized images to be saved to files.
See the in-program Help popup for more usage details.
PyPhoto never modifies your image files in any way. The only change it
makes to your computer is to add a single file named "_PyPhoto-thumbs.pkl"
to each folder you open in the program. This file is the folder's
thumbnails cache; it allows the folder to be opened quickly after its
first open builds thumbs, and is automatically kept in synch with changes
in the folder's images, but can be removed freely if PyPhoto is not used.
This program is still something of a placeholder for more photo editing
ops, but it demonstrates PIL basics well enough to ship and use as is.
For more Python photo-related tools, see the "thumbspage" web-page gallery
generator (at learning-python.com/thumbspage.html) as well as the "tagpix"
photo-folder organizer (at learning-python.com/tagpix.html).
============================================================================
VERSION DETAILS
============================================================================
NEW IN 2.2, Sep-2018:
This version was released with a new PyGadgets (all packages), to
incorporate two changes drawn from the thumbspage program noted above:
1) Image auto-rotation
Automatically rotate images and their thumbnails to display right-side
up, if they have "Orientation" Exif tags and tilted content. This format
is common for photos shot on smartphones: the natural portrait (vertical)
device orientation yields an image tilted to the side. Less commonly,
photos shot on physically tilted digital cameras may also be stored in
this tilted format. Without rotation, such images would not display
with their top side on top in either thumbnail or full-size form, and
PyPhoto has no general rotate operation to manually adjust images.
Auto-rotation is used both for thumbnails and source images, though only
thumbnails record rotation permanently in their files here - source images
are rotated in memory only, and the original image file is never changed.
This differs from the implementation in thumbspage, which inspired the
auto-rotation change (learning-python.com/thumbspage.html). Thumbspage
must update image files too, because the viewing browser won't rotate
images displayed as in-page elements; PyPhoto can rotate when viewed.
Users of the prior version should delete their "_PyPhoto-thumbs.pkl"
cache files in image folders to enable the auto-rotation enhancement.
Else images will rotate when viewed, but thumbnails will remain askew.
2) Pillow files auto-close bug workaround
This version also adds a workaround for a Pillow (PIL) library bug, which
could trigger too-many-open-files errors when generating many thumbnails
in some contexts (most commonly, Mac OS source-code usage). The thumbspage
program, from which this work around was borrowed, has additional notes on
the bug; see learning-python.com/thumbspage/viewer_thumbs.py.
3) Pillow buffer-file format issue workaround
This version also codes a workaround for an obscure buffer-file format
issue in older Pillows, that could impact some source-code users only,
and is not required in thumbspage; see file viewer_thumbs.py here.
NEW IN 2.1, Nov-2017:
This version was released with a new PyGadgets (all packages), to
incorporate one major change and a set of minor enhancements:
1) Thumbnails pickle-file storage
Store a folder's thumbnails in a single pickle file, instead of individual
image files in a subfolder as before. This has the same performance, but
avoids extra files (15k images formerly meant 15k thumbs); multiple file
loads and saves; and nasty modtime-copy issues for backup programs (thumbnails
might not be backed up when their size was changed). See viewer_thumbs.py
for more details.
Version 2.0 users: run the included delete-pyphoto2.0-thumbs-folders.py
Python script (or its executable), to delete all 2.0 subfolders when
upgrading to 2.1; else, the subfolders will be unused and wasted space.
2) Miscellaneous enhancements
Version 2.1 also now reports thumbnail-save errors in GUI popups; prints
all exceptions; and supports a new config-file setting to ignore image
modtime-based change tests during thumbnail generation where desirable
(e.g., to accommodate modtime skew between incompatible filesystems).
There were also other minor improvements to thumbnail processing (see
viewer_thumbs.py for details), and images with errors are caught and
reported here and their thumbnails are no longer omitted in the GUI.
NEW IN 2.0, Sep-2017 [SA]:
This version was released as part of PyGadgets' first standalone
release (outside the book), along with PyCalc, PyClock, and PyToe.
It incorporated multiple and major extensions to boost utility:
- New help dialog, tweak hints in window titles
- Mac OS port: menus, reopens, focus, clicks
- Auto-resize large images to screen size on views
- Bind arrow keys to scroll both thumbs and images
- Add N/P=next/prior image in folder (as displayed)
- Add A/S=actual/scaled size (a=prior viewer sole mode)
- Old key S (save) is now W (write)
- Show busy message in window while creating thumbnails
- Use LANCZOS resize filter in all resize contexts in newer Pillows:
now the best quality (if slowest) for both shrinking and expanding:
pillow.readthedocs.io/en/4.2.x/handbook/concepts.html#concept-filters
- Move window to upper-left corner if too large for display or partially
off-screen, but do not center if smaller than display (a user choice)
- Get screen max size reliably (this is a bit loose in Tk)
- Implement ViewSize fixed-size option for image views and scaling
- Workaround a C libs hardcrash for tiff thumbnail saves: no compress
PyPhoto is still a bit primitive, and something of a PIL demo
(e.g. images are not resized on window resizes, and there is no
cropping, etc.), but is also illustrative of general PIL use.
Older versions appeared as examples in the book "Programming Python."
The current PyPhoto derives from the original in 2010's 4th Edition.
NEW IN 1.1, 2010, PP4E
Updated to run in Python 3.1 and latest PIL.
NEW IN 1.0, 2006, PP3E
Now does two flavors of resizing: the image is resized to one of the
display's dimensions if clicked, and zoomed in or out in 10% increments
on key presses; generalize me. Caveat: images seem to lose quality
and/or pixels after many resizes (this is probably a limitation of PIL).
============================================================================
SCALING NOTES
============================================================================
The following scaler adapted from PIL's thumbnail code is similar to the
screen height scaler here, but only shrinks:
x, y = imgwide, imghigh
if x > scrwide: y = max(y * scrwide // x, 1); x = scrwide
if y > scrhigh: x = max(x * scrhigh // y, 1); y = scrhigh
The related thumbspage program (at learning-python.com/thumbspage.html)
uses an alternative display-fit scaling method which might work here too;
it's coded and run in JavaScript:
// per smallest-fit side
ratio = Math.min(displayWidth / trueWidth, displayHeight / trueHeight);
if (! stretchBeyondActual) {
ratio = Math.min(ratio, 1.0); // don't expand beyond actual size
}
return {width: (trueWidth * ratio),
height: (trueHeight * ratio)};
============================================================================
CAVEATS/TBDS
============================================================================
1) TIFF drawing quality on Mac OS El Capitan
On test and development machines, TIFF images and their thumbnails
render poorly (with artifacts) in Mac OS apps and source-code on
El Capitan, but accurately on Mac OS Sierra in all modes (and always
flawlessly on Windows and Linux). This may indicate a newer shared
libtiff on Sierra, which might be fixed by installs on El Capitan.
2) Image-save limitations
Saves ("W") work well in typical roles, but are not always as simple
as giving a ".xxx" filename extension (e.g., this may discard GIF
transparencies), and some image-type saves may not work at all due
to the Pillow library's constraints, especially for conversions
(e.g., they may leave zero-length files). To be improved if usage
warrants. Version 2.1 at least adds a GUI popup on save errors.
3) Image auto-placement is one-sided
The automatic move-to-upper-left-corner works only when the image
is off-screen to the right, not left; this could be generalized
to work on either screen side, but that seems a bit superfluous.
4) Mac OS screenshot shadows on Mac OS El Capitan
The default shadows that Mac OS adds around its screenshots sometimes
render as all-black in Pillow images and thumbnails as they're used here.
Oddly, this has been observed ONLY on a Mac OS El Capitan machine; it
does not occur on a Mac OS Sierra machine, and Windows and Linux seem
to always render the shadow properly too. Hence, this appears to be
Mac-only, and specific to either Mac OS version or a single machine.
(See also #1 above: El Capitan's image-drawing stack seems flaky.)
If not, this may be prohibitively complex. A magic-but-sadly-undocumented
Pillow remedy seems unlikely, and removing shadows manually seems absurd:
https://stackoverflow.com/questions/18293290/
programmatically-remove-apple-screen-capture-shadow-borders
5) And so on (this project is open ended, and awaits user feedback)
Other TBDs include:
- Rearrange thumbnails when window resized, based on current window size?
- [DONE] Resize images to fit display/window size when first opened?
- Avoid scrolls if image size is less than window max size (e.g., use
a simple Label if imgwide <= scrwide and imghigh <= scrhigh)?
- Better fit scaled images to display (it's not a 100% match everywhere)?
- Add filename labels to the thumbs window (as it, it's like a proof sheet)?
- Image cropping, annotation, drawing, ... (this gets silly at some point)?
############################################################################
"""
import sys, math, os, traceback
from tkinter import *
from tkinter.filedialog import SaveAs, Directory
from tkinter.messagebox import showerror
# [SA] require PIL/Pillow install
pillowerror = """
Pillow 3rd-party package is not installed.
...This package is required by PyPhoto for both thumbnails generation
...and image file types not supported by Pythons without Pillow. Any
...Python supports GIFs, and Pythons using Tk 8.6 or later add PNGs, but
...thumbnails expect Pillow. See https://pypi.python.org/pypi/Pillow.
"""
try:
from PIL import Image # get image wrapper + widget
from PIL.ImageTk import PhotoImage # replaces tkinter's version
except ImportError:
print(pillowerror)
sys.exit(0)
# don't continue: some image types may load, but need PIL to make thumbnails
# Pillow install required for source-code only: apps/exes have PIL "baked in"
# thumbnail generation code, developed earlier in book
from viewer_thumbs import makeThumbs, isImageFileName, sortedDisplayOrder
# [2.2] auto-rotation of tilted images, avoid Pillow too-many-open-files bug
from viewer_thumbs import reorientImage, openImageSafely
# [SA] Mac port (and other backports)
RunningOnMac = sys.platform.startswith('darwin')
RunningOnWindows = sys.platform.startswith('win')
RunningOnLinux = sys.platform.startswith('linux')
# [SA]: set window icons on Windows and Linux
from windowicons import trySetWindowIcon
# remember last dirs across all windows
saveDialog = SaveAs(title='Save As (filename extension gives image type)')
if RunningOnMac:
openargs = dict(message='Select Image Directory To Open') # [SA]
else:
openargs = dict(title='Select Image Directory To Open')
openDialog = Directory(**openargs)
trace = print # or lambda *x: None
appname = 'PyPhoto 2.2'
############################################################################
# Canvas with dual scroll bars, used by both thumbnail and image windows
############################################################################
class ScrolledCanvas(Canvas):
"""
a canvas in a container that automatically makes
vertical and horizontal scroll bars for itself
"""
def __init__(self, container):
Canvas.__init__(self, container)
self.config(borderwidth=0)
vbar = Scrollbar(container)
hbar = Scrollbar(container, orient='horizontal')
vbar.pack(side=RIGHT, fill=Y) # pack canvas after bars
hbar.pack(side=BOTTOM, fill=X) # so clipped first
self.pack(side=TOP, fill=BOTH, expand=YES)
vbar.config(command=self.yview) # call on scroll move
hbar.config(command=self.xview)
self.config(yscrollcommand=vbar.set) # call on canvas move
self.config(xscrollcommand=hbar.set)
############################################################################
# View a single image selected in thumbnails window
############################################################################
class ViewOne(Toplevel):
"""
--------------------------------------------------------------
A pop-up window that opens a single image when created.
Scrollable vertically and horizontally if too big for display.
This was initially coded as a class because PhotoImage objects
must be saved, else images may be erased from GUI if reclaimed.
On mouse clicks, resizes to display's height or width, either
stretching or shrinking. On I/O keypress, zooms image in/out.
Both resizing schemes maintain the original aspect ratio; its
code is factored to avoid redundancy here as possible.
[SA] See 2.0 changes list in main docstring for updates:
there were too many extensions to list here.
[2.1] Catch and report exceptions for images with errors,
whose thumbnails are no longer omitted in 2.1. Pillow uses
a "lazy" model in which open() just identifies the file, but
the complete load() is deferred until later processing. This
can be a major problem, as exceptions might occur anywhere and
anytime for images with errors. Here, and on next/prior image,
call load() explicitly to force errors to happen immediately.
--------------------------------------------------------------
"""
def __init__(self,
imgdir, imgfile, # image path+name to display
dirwinsize=(), # thumbs: pass along on "D"
viewsize=(), # fixed display size
opener=None, # refocus on errors?
nothumbchanges=False): # thumbs: pass along on "D"
Toplevel.__init__(self)
self.setTitle(imgfile)
trySetWindowIcon(self, 'icons', 'pygadgets') # [SA] for win+lin
self.viewsize = viewsize # fixed scaling size
# try to load image
imgpath = os.path.join(imgdir, imgfile) # img file to open
try:
# load img object to be reused by ops
imgpil = openImageSafely(imgpath) # [2.2] avoid pillow files bug
imgpil.load() # [2.1] load now so errors here
imgpil = reorientImage(imgpil) # [2.2] right-side up, iff needed
except:
# [2.1] can fail on OSError+ in Pillow
traceback.print_exc()
self.destroy()
showerror('PyPhoto: Image Load',
'Cannot load image file:\n%s' % imgpath)
if opener:
opener.focus_force() # abandon after error popup
if RunningOnLinux: opener.lift() # else root win stays above
return # abandon after error popup
self.trueimage = imgpil # for all ops till N/P
self.canvas = ScrolledCanvas(self) # tk canvas to be reused
self.drawImageFirst() # show scaled or actual now
# bind keys/events for this image-view window
self.canvas.bind('<Button-1>', self.onSizeToDisplayHeight)
self.canvas.bind('<Button-3>', self.onSizeToDisplayWidth)
if RunningOnMac:
self.canvas.bind('<Button-2>', self.onSizeToDisplayWidth) # [SA]
self.bind('<Control-Button-1>', self.onSizeToDisplayWidth)
self.bind('<KeyPress-i>', self.onZoomIn)
self.bind('<KeyPress-o>', self.onZoomOut)
self.bind('<KeyPress-w>', self.onSaveImage)
self.bind('<KeyPress-d>',
lambda event: onDirectoryOpen(self, dirwinsize, viewsize, nothumbchanges))
# [SA] question=? but portable, help key in all gadgets
self.bind('<KeyPress-question>', lambda event: onHelp(self))
# [SA] bind arrow keys to scroll canvas too (tbd: increment?)
self.bind('<Up>', lambda event: self.canvas.yview_scroll(-1, 'units'))
self.bind('<Down>', lambda event: self.canvas.yview_scroll(+1, 'units'))
self.bind('<Left>', lambda event: self.canvas.xview_scroll(-1, 'units'))
self.bind('<Right>', lambda event: self.canvas.xview_scroll(+1, 'units'))
# [SA] add next/prior image in this image's folder
self.bind('<KeyPress-n>', self.onNextImage)
self.bind('<KeyPress-p>', self.onPrevImage)
self.imgdir, self.imgfile, self.dirwinsize = imgdir, imgfile, dirwinsize
# [SA] add actual/scaled size (actual=former version's only mode)
self.bind('<KeyPress-a>', lambda event: self.drawImageSized(self.trueimage))
self.bind('<KeyPress-s>', lambda event: self.drawImageFirst())
self.focus() # on Windows, make sure new window catches events now
# [SA] set min size as partial fix for odd window shinkage on zoomout
# on Mac; later made mostly moot by auto-resize to screen/fixed size
"""
self.minsize(500, 500) # w, h
"""
def setTitle(self, imgfile):
"""
[SA] split off from constructor for next/prior
"""
helptxt = 'I/O=zoom, N/P=move, A/S=size, arrows=scroll'
self.title('%s: %s (%s)' % (appname, imgfile, helptxt))
def getMaxSize(self, constrained=True):
"""
[SA] fullscreen (W, H) size, factored to common code;
viewsize is experimental, but suffices to limit scaling max;
oddness: Tk's self.maxsize() height varies across calls, and
on Mac is < self.winfo_screenwidth()/.winfo_screenheight();
"""
#trace('==>', self.maxsize())
#trace('==>', (self.winfo_screenwidth(), self.winfo_screenheight()))
scrwide, scrhigh = self.winfo_screenwidth(), self.winfo_screenheight()
if not constrained:
return (scrwide, scrhigh) # wm screen size (x,y)
else:
return self.viewsize or (scrwide, scrhigh) # user limit, or wm
#
# Drawing
#
def drawImageFirst(self):
"""
[SA] draw from self.trueimage, ether scaled or actual;
called on first open, next/prior, and S=scale key, but
trueimage is set by the first two of these only, and is
used by most ops (viewimage is used by zooms and saves);
resize large images to screen or fixed size initially;
smaller images are still drawn by actual size, as before;
viewsize is still experimental (scaling to screen size in
onSizeToDisplayBoth is better), but suffices to limit max;
[SA] imgpil.width and imgpil.height are not available in
earlier Pillows: use the older .size tuple-pair instead;
"""
imgpil = self.trueimage
imgwide, imghigh = imgpil.size # size in pixels (x,y)
scrwide, scrhigh = self.getMaxSize() # wm screen size (x,y)
if imgwide <= scrwide and imghigh <= scrhigh: # too big for display?
self.drawImageSized(imgpil) # no: win size per img
else: # yes: resize to screen
self.onSizeToDisplayBoth() # scale to screen W and H
"""
# this else was not as good...
diffwide = imgwide - scrwide # use most-exceeded edge
diffhigh = imghigh - scrhigh
if diffwide > diffhigh: # either may be negative
self.onSizeToDisplayWidth(event=None)
else:
self.onSizeToDisplayHeight(event=None)
"""
def drawImageSized(self, imgpil):
"""
draw imgpil, as it is sized, in current window/canvas;
imgpil may be the original actual size, or a temp resize;
"""
imgtk = PhotoImage(image=imgpil) # not file=imgpath
imgwide = imgtk.width() # size in pixels
imghigh = imgtk.height() # same as imgpil.size
scrwide, scrhigh = self.getMaxSize() # wm screen size (x,y)
fullsize = (0, 0, imgwide, imghigh) # scrollable
viewwide = min(imgwide, scrwide) # viewable
viewhigh = min(imghigh, scrhigh)
canvas = self.canvas
canvas.delete('all') # clear prior photo
canvas.config(height=viewhigh, width=viewwide) # viewable window size
canvas.config(scrollregion=fullsize) # scrollable area size
canvas.create_image(0, 0, image=imgtk, anchor=NW)
self.savephoto = imgtk # keep reference on me
self.viewimage = imgpil # currently shown size
trace((scrwide, scrhigh), imgpil.size)
# [SA] move to upper-left if too big or partially off-screen
self.update()
coords = self.geometry() # e.g., '721x546+521+23'
wmsizeX, wmsizeY = \
[int(x) for x in coords.split('+')[0].split('x')]
upleftX, upleftY = \
[int(x) for x in coords.split('+')[1:3]]
truewide, truehigh = self.getMaxSize(constrained=False)
if (upleftX + wmsizeX > truewide) or (upleftY + wmsizeY > truehigh):
self.geometry('+0+0')
#trace((upleftX, wmsizeX, truewide), (upleftY, wmsizeY, truehigh))
# [SA] the point of this seems lost in translation...
"""
if imgwide <= scrwide and imghigh <= scrhigh: # too big for display?
self.state('normal') # no: win size per img
elif sys.platform[:3] == 'win': # do windows fullscreen
self.state('zoomed') # others use geometry()
else: # [SA] Mac is different...
win.wm_attributes('-fullscreen', 1)
"""
#
# Scaling
#
def sizeToDisplaySide(self, scaler):
"""
resize to fill one side (or both) of the display;
[SA] start from self.trueimage, not last view size;
[SA] lanczos filter not available in earlier Pillows;
"""
imgpil = self.trueimage # scale from full size
imgwide, imghigh = imgpil.size # img size in pixels
scrwide, scrhigh = self.getMaxSize() # wm screen size (x,y)
newwide, newhigh = scaler(scrwide, scrhigh, imgwide, imghigh)
if hasattr(Image, 'LANCZOS'):
filter = Image.LANCZOS # [SA] best for all, if available
else:
if (newwide * newhigh < imgwide * imghigh):
filter = Image.ANTIALIAS # shrink: antialias
else: # grow: bicub sharper
filter = Image.BICUBIC
newimg = imgpil.resize((newwide, newhigh), filter)
self.drawImageSized(newimg)
def onSizeToDisplayHeight(self, event):
def scaleHigh(scrwide, scrhigh, imgwide, imghigh):
newwide = int(imgwide * (scrhigh / imghigh)) # 3.x true div
newhigh = scrhigh # [SA] -border
return (newwide, newhigh) # proportional
self.sizeToDisplaySide(scaleHigh)
def onSizeToDisplayWidth(self, event):
def scaleWide(scrwide, scrhigh, imgwide, imghigh):
newhigh = int(imghigh * (scrwide / imgwide)) # 3.x true div
newwide = scrwide # [SA] -border
return (newwide, newhigh)
self.sizeToDisplaySide(scaleWide)
def onSizeToDisplayBoth(self):
"""
[SA] scale to fit both height and width of screen;
the 90% scale-down is meant allow for window borders:
should this happen in sizeToDisplaySide for all (tbd)?
"""
def scaleBoth(scrwide, scrhigh, imgwide, imghigh):
scrwide, scrhigh = (int(x * .90) for x in (scrwide, scrhigh))
newwide, newhigh = imgwide, imghigh
if imgwide > scrwide:
newhigh = int(imghigh * (scrwide / imgwide))
newwide = scrwide
if imghigh > scrhigh:
newwide = int(imgwide * (scrhigh / imghigh))
newhigh = scrhigh
return (newwide, newhigh)
self.sizeToDisplaySide(scaleBoth)
#
# Zooming
#
def zoom(self, factor):
"""
zoom in or out in increments;
[SA] must use viewimage here, else not cumulative;
[SA] lanczos filter not available in earlier Pillows;
"""
imgpil = self.viewimage # zoom from last display size
wide, high = imgpil.size # may be scaled, actual, zoomed
if hasattr(Image, 'LANCZOS'):
filter = Image.LANCZOS # [SA] best for all, if available
else:
if factor < 1.0: # antialias best if shrink
filter = Image.ANTIALIAS # also nearest, bilinear
else:
filter = Image.BICUBIC
newimg = imgpil.resize((int(wide * factor), int(high * factor)), filter)
self.drawImageSized(newimg)
def onZoomIn(self, event, incr=.10):
self.zoom(1.0 + incr)
def onZoomOut(self, event, decr=.10):
self.zoom(1.0 - decr)
#
# Saving
#
def onSaveImage(self, event):
"""
save current image size/state to a file;
per PIL, fiename extension gives image type;
[SA] save from viewimage: currently shown size;
[SA] set initialfile name for convenience;
[2.1] catch/report save errors, console+GUI
"""
filename = saveDialog.show(initialfile=self.imgfile)
if filename:
try:
self.viewimage.save(filename)
except:
traceback.print_exc()
print('Error saving image file: not saved')
showerror('PyPhoto: Image Save',
'Cannot save image file:\n%s' % filename)
self.focus_force() # [SA] for Mac
#
# Navigating
#
def switchimage(self, ixmod):
"""
[SA] add next/prior image in this image's folder;
redraws in same window/canvas, to avoid flicker if
draw in a new window and erase the old one (and the
"ViewOne" class name now really means one at a time);
[2.1] catch/report images with errors (whose thumbs
are no longer omitted); error imgs stop the next/prior
progression: users must click a new thumb past it;
[2.1] must call viewer_thumb's sortedDisplayOrder(),
not os.listdir() directly, so the next/prior order
implemented here matches thumbs-display order;
"""
currdir, currfile = self.imgdir, self.imgfile
allfiles = sortedDisplayOrder(currdir)
imgfiles = list(filter(isImageFileName, allfiles))
currix = imgfiles.index(currfile)
newix = currix + ixmod
newix = len(imgfiles)-1 if newix < 0 else newix % len(imgfiles)
nextfile = imgfiles[newix] # wrapped around
imgpath = os.path.join(currdir, nextfile) # img file to open
try:
# open image object to be reused
nextimgpil = openImageSafely(imgpath) # [2.2] avoid Pillow files bug
nextimgpil.load() # [2.1] load now so errors here
nextimgpil = reorientImage(nextimgpil) # [2.2] right-side up, iff needed
except:
# [2.1] can fail on OSError+ in Pillow
traceback.print_exc()
showerror('PyPhoto: Image Load',
'Cannot load image file:\n%s' % imgpath)
self.focus_force()
if RunningOnLinux: self.lift() # else root stays above
else:
# move iff image loaded
self.imgfile = nextfile
self.setTitle(nextfile)
self.trueimage = nextimgpil # save for ops on image
self.drawImageFirst() # new image, same win/canvas
"""
# or new window: this worked but was too twitchy...
ViewOne(currdir, nextfile, self.dirwinsize, (plus new stuff))
self.destroy()
"""
def onNextImage(self, event):
self.switchimage(+1)
def onPrevImage(self, event):
self.switchimage(-1)
############################################################################
# View the thumbnails window for an initial or chosen directory
############################################################################
def viewThumbs(imgdir, # open this folder
kind=Toplevel, # thumbs window: Tk or Toplevel
dirwinsize=(), # size of this thumbs window
viewsize=(), # size of each image-view window
numcols=None, # fixed, else per #thumbnails
nothumbchanges=False): # don't detect image changes?
"""
--------------------------------------------------------------
Make main (Tk) or pop-up (Toplevel) thumbnail-buttons window.
Uses fixed-size buttons, and a bi-scrollable canvas.
Sets scrollable (full) size of canvas, and places thumbs
at absoute x,y coordinates in the canvas.
No longer assumes that all thumbs are the same size:
uses max of all (x,y) for all, as some may be smaller.
[SA] See 2.0 changes list in main docstring for updates:
there were too many extensions to list here.
CAUTION: changing thumb size can defeat backup programs;
delete all thumbs on size changes (see viewer_thumbs.py).
--------------------------------------------------------------
"""
win = kind()
helptxt = 'D=open'
win.title('%s: %s (%s)' % (appname, imgdir, helptxt))
trySetWindowIcon(win, 'icons', 'pygadgets') # [SA] for win+lin
# [SA] add new Help button
# [SA] Quit=destroy (this window only unless last Tk), not quit (entire app)
tools = Frame(win, bg='beige')
tools.pack(side=BOTTOM, fill=X)
quit = Button(tools, text=' Quit ', command=win.destroy) # [SA] no bg= on Mac
quit.pack(side=RIGHT, expand=YES)
help = Button(tools, text=' Help ', command=lambda: onHelp(win))
help.pack(side=LEFT, expand=YES)
# [SA] question=? but portable, help key in all gadgets
win.bind('<KeyPress-question>', lambda event: onHelp(win))
# make or load thumbs ==> [(imgfile, imgobj)]
thumbs = makeThumbs(imgdir, # all images in folder
size=(128, 128), # fixed thumbnails size
busywindow=win, # announce in GUI
nothumbchanges=nothumbchanges) # don't detect changes?
numthumbs = len(thumbs)
if numthumbs == 0: # no-image dir?
numcols = numrows = 0 # [SA] avoid / 0 exc
else:
if not numcols:
numcols = int(math.ceil(math.sqrt(numthumbs))) # fixed or N x N
numrows = int(math.ceil(numthumbs / numcols)) # 3.x true div
width, height = dirwinsize # [SA] new configs model
canvas = ScrolledCanvas(win) # init viewable window size
canvas.config(height=height, width=width) # changes if user resizes
# max w|h: thumb=(name, obj), obj.size=(width, height)
if numthumbs == 0:
linksize = 0 # [SA] avoid empty-seq max() exc
else:
linksize = max(max(thumb[1].size) for thumb in thumbs)
trace(linksize)
fullsize = (0, 0, # upper left X,Y
(linksize * numcols), (linksize * numrows) ) # lower right X,Y
canvas.config(scrollregion=fullsize) # scrollable area size
rowpos = 0
savephotos = []
while thumbs:
thumbsrow, thumbs = thumbs[:numcols], thumbs[numcols:]
colpos = 0
for (imgfile, imgobj) in thumbsrow:
photo = PhotoImage(imgobj)
link = Button(canvas, image=photo)
def handler(_imgfile=imgfile):
ViewOne(imgdir, _imgfile, dirwinsize, viewsize, win, nothumbchanges)
link.config(command=handler, width=linksize, height=linksize)
link.pack(side=LEFT, expand=YES)
canvas.create_window(colpos, rowpos, anchor=NW,
window=link, width=linksize, height=linksize)
colpos += linksize
savephotos.append(photo)
rowpos += linksize
win.savephotos = savephotos # keep references to all to avoid gc
# bind keys/events for this directory-view window
win.bind('<KeyPress-d>',
lambda event: onDirectoryOpen(win, dirwinsize, viewsize, nothumbchanges))
# [SA] bind arrow keys to scroll canvas too (tbd: increment?)
win.bind('<Up>', lambda event: canvas.yview_scroll(-1, 'units'))
win.bind('<Down>', lambda event: canvas.yview_scroll(+1, 'units'))
win.bind('<Left>', lambda event: canvas.xview_scroll(-1, 'units'))
win.bind('<Right>', lambda event: canvas.xview_scroll(+1, 'units'))
win.focus() # [SA] on Windows, make sure new window catches events now
return win
############################################################################
# Utilities, having multiple class and non-class clients
############################################################################
def onDirectoryOpen(parentwin, dirwinsize, viewsize, nothumbchanges):
"""
open a new image directory in a new main window;
available via "D" in both thumb and img windows
"""
dirname = openDialog.show()
if dirname:
viewThumbs(dirname, Toplevel, dirwinsize, viewsize,
nothumbchanges=nothumbchanges)
else:
parentwin.focus_force() # [SA] for Mac
def onHelp(parentwin):
"""
[SA] new help dialog - simple but sufficient;
used for 'help' button click, '?' keyboard press, Mac menus;
'?' keypress and Mac menus work in both thumb and image windows;
"""
from helpmessage import showhelp
showhelp(parentwin, 'PyPhoto', HelpText, forcetext=False,
setwinicon=lambda win:
trySetWindowIcon(win, 'icons', 'pygadgets'))
#parentwin.focus_force() # now done in helpmessage
HelpText = ('PyPhoto 2.2\n'
'\n'
'A Python/tkinter/PIL image-viewer GUI.\n'
'For Mac OS, Windows, and Linux.\n'
'From the book Programming Python.\n'
'Author and © M. Lutz 2006-2018.\n'
'\n'
'In directory windows:\n'
'▶ Key D opens another image directory\n'
'▶ Clicking an image\'s thumbnail opens it in an '
'image-view window at scaled size\n'
'\n'
'In image-view windows:\n'
'▶ Key D opens another image directory\n'
'▶ Keys N/P open the next/prior image\n'
'▶ Keys I/O zoom the image in/out\n'
'▶ Keys A/S show actual/scaled size\n'
'▶ Key W saves (writes) the current image\n'
'▶ Leftclick and rightclick resize to screen height '
'and width, respectively (on Macs, rightclick=two-finger '
'click or control+click)\n'
'\n'
'In both window types, key ?=Help, and the Up/Down '
'and Left/Right arrow keys scroll vertically and '
'horizontally, respectively.\n'
'\n'
'For W saves, the filename\'s ".xxx" extension gives its '
'image type. For example, to both shrink a PNG and convert '
'it to GIF, zoom out with O and save as ".gif" with W.\n'
'\n'
'A "_PyPhoto-thumbs.pkl" file is created in each opened image '
'folder when possible, to store image thumbnails for fast access. '
'Its thumbs are kept in sync with images.\n'
'\n'
'PyPhoto source-code distributions (but not apps or '
'executables) require installation of the Pillow extension '
'package from https://pypi.python.org/pypi/Pillow.\n'
'\n'
'For downloads and more apps, visit:\n'
'http://learning-python.com/programs.html'
)
############################################################################
# Top-level logic: get configs, get first folder, display thumbnails
############################################################################
if __name__ == '__main__':
"""
open dir = default or cmdline arg
else show simple window to select
"""
from getConfigs import getConfigs # [SA] new gadgets utility
defaults = dict(InitialSize='500x400', # size of dir/thumbs window
InitialFolder='images-mixed', # None = ask for dir
ViewSize=None, # None = scale to screen
NoThumbChanges=False) # True = skip change detection [2.1]
configs = getConfigs('PyPhoto', defaults) # load from file or args
imgdir = configs.InitialFolder
dirwinsize = configs.InitialSize.split('x') # 'WidthxHeight'
dirwinsize = [int(x) for x in dirwinsize] # (Width, Height)
viewsize = configs.ViewSize
viewsize = viewsize.split('x') if viewsize else () # e.g., '800x600'
viewsize = list(map(int, viewsize)) # (800, 600)
nothumbchanges = configs.NoThumbChanges
if imgdir and os.path.exists(imgdir):
mainwin = viewThumbs(imgdir, Tk, dirwinsize, viewsize,
nothumbchanges=nothumbchanges)
else:
mainwin = Tk()
mainwin.geometry('250x50')
mainwin.title(appname + 'Open')
handler = lambda: onDirectoryOpen(mainwin, dirwinsize, viewsize, nothumbchanges)
Button(mainwin, text='Open Image Directory',
command=handler).pack(expand=YES, fill=BOTH)
trySetWindowIcon(mainwin, 'icons', 'pygadgets') # [SA] for win+lin
if RunningOnMac:
# Mac requires menus, deiconifies, focus
# [SA] on Mac, customize app-wide automatic top-of-display menu
from guimaker_pp4e import fixAppleMenuBar
fixAppleMenuBar(window=mainwin,
appname='PyPhoto',
helpaction=lambda: onHelp(mainwin),
aboutaction=None,
quitaction=mainwin.quit) # immediate, bound method
# [SA] reopen auto on dock/app click and fix tk focus loss on deiconify
def onReopen():
mainwin.lift()
mainwin.update()
temp = Toplevel()
temp.lower()
temp.destroy()
mainwin.createcommand('::tk::mac::ReopenApplication', onReopen)
mainwin.mainloop()