saver.py

#!/usr/bin/env python

# This is a plug-in intended to be bound to Ctrl-S, and to act as
# a combination of Save, Save as..., Overwrite, and Export...
#
# It saves the image (whether its type would normally require Saving
# or Exporting), and optionally allows for a copy of the image to be
# exported to another file, possibly also scaled differently.
# The copy must be saved to the same directory as the original
# (because juggling two file choosers would make the dialog too huge
# to fit on most screens!)
#
# Regardless of image format chosen, the image will be marked clean
# so you won't get prompted for an unsaved image at quit or close time.
#
# The first time you save a file, you should be prompted for filename
# (even if you opened an existing file).
# After that, the plug-in will remember the filename you set.
# You can always change it with Saver as...
#
# So you can have your XCF with high resolution and all layers,
# and automatically export to a quarter-scale JPEG copy every time
# you save the original. Or you can just overwrite your JPG if
# all you're doing is a quick edit.
#
# The basic save filename follows img.filename.
# The copy, if any, is saved in a parasite:
# export-scaled: filename\npercent\nwidth\nheight

# This plug-in is hosted at https://github.com/akkana/gimp-plugins/blob/master/saver.py

# Copyright 2013,2014 by Akkana Peck, http://www.shallowsky.com/software/
# You may use and distribute this plug-in under the terms of the GPL v2
# or, at your option, any later GPL version.

from gimpfu import *
import gtk
import os
import collections

# Image original size
orig_width = 0
orig_height = 0

# The three gtk.Entry widgets we'll monitor:
percent_e = None
width_e = None
height_e = None

# A way to show errors to the user:
warning_label = None

# A way to turn off notifications while we're calculating
busy = False

def save_both(img, drawable, filename, copyname, width, height):
    '''Save the image, and also save the copy if appropriate,
       doing any duplicating or scaling that might be necessary.
       Returns None on success, else a nonempty string error message.
    '''
    msg = "Saving " + filename

    if copyname:
        if width and height:
            msg += " and a scaled copy, " + copyname
        else:
            msg += " and a copy, " + copyname
    print msg
    # Don't use gimp_message -- it can pop up a dialog.
    # pdb.gimp_message_set_handler(MESSAGE_BOX)
    # pdb.gimp_message(msg)
    # Alternately, could use gimp_progress, though that's not ideal.
    # If you use gimp_progress, don't forget to call pdb.gimp_progress_end()
    #pdb.gimp_progress_set_text(msg)

    # Is there any point to pushing and popping the context?
    #gimp.context_pop()

    # Set up the parasite with information about the copied image,
    # so it will be saved with the main XCF image.
    if copyname:
        if (width and height):
            percent = width * 100.0 / img.width
            # XXX note that this does not guard against changed aspect ratios.
            parastring = '%s\n%d\n%d\n%d' % (copyname, percent, width, height)
        else:
            parastring = '%s\n100.0\nNone\nNone' % (copyname)

        print "Saving parasite", parastring
        para = img.attach_new_parasite('export-copy', 1, parastring)
        # The second argument is is_persistent

        # Also make sure that copyname is a full path (if filename is).
        copypath = os.path.split(copyname)
        if not copypath[0] or len(copypath) == 1:
            filepath = os.path.split(filename)
            if len(filepath) > 1 and filepath[0]:
                print "Turning", copyname, "into a full path:",
                copyname = os.path.join(filepath[0], copyname)
                print copyname

    # Now the parasite is safely attached, and we can save.
    # Alas, we can't attach the JPEG settings parasite until after
    # we've saved the copy, so that won't get saved with the main image
    # though it will be attached to the image and remembered in
    # this session, and the next time we save it should be remembered.

    def is_xcf(thefilename):
        base, ext = os.path.splitext(thefilename)
        ext = ext.lower()
        if ext == '.gz' or ext == '.bz2':
            base, ext = os.path.splitext(base)
            ext = ext.lower()
        return (ext == '.xcf')

    # First, save the original image.
    if is_xcf(filename) or len(img.layers) < 2:
        pdb.gimp_file_save(img, drawable, filename, filename)
    else:
        # It's not XCF and it has multiple layers.
        # We need to make a new image and flatten it.
        copyimg = pdb.gimp_image_duplicate(img)
        # Don't actually flatten since that will prevent saving transparent png.
        #copyimg.flatten()
        pdb.gimp_image_merge_visible_layers(copyimg, CLIP_TO_IMAGE)
        pdb.gimp_file_save(copyimg, copyimg.active_layer, filename, filename)
        gimp.delete(copyimg)

    # We've done the important part, so mark the image clean.
    img.filename = filename
    pdb.gimp_image_clean_all(img)

    # If we don't have to save a copy, return.
    if not copyname:
        return None

    # We'll need a new image if the copy is non-xcf and we have more
    # than one layer, or if we're scaling.
    if (width and height):
        # We're scaling!
        copyimg = pdb.gimp_image_duplicate(img)
        copyimg.scale(width, height)
        print "Scaling to", width, 'x', height
        print "Set parastring to", parastring, "(end of parastring)"

    elif len(img.layers) > 1 and not is_xcf(copyname):
        # We're not scaling, but we still need to flatten.
        copyimg = pdb.gimp_image_duplicate(img)
        # copyimg.flatten()
        pdb.gimp_image_merge_visible_layers(copyimg, CLIP_TO_IMAGE)
        print "Flattening but not scaling"
    else:
        copyimg = img
        print "Not scaling or flattening"

    # gimp-file-save insists on being passed a valid layer,
    # even if saving to a multilayer format such as XCF. Go figure.

    # I don't get it. What's the rule for whether gimp_file_save
    # will prompt for jpg parameters? Saving back to an existing
    # file doesn't seem to help.
    # run_mode=RUN_WITH_LAST_VALS is supposed to prevent prompting,
    # but actually seems to do nothing. Copying the -save-options
    # parasites is more effective.
    try:
        pdb.gimp_file_save(copyimg, copyimg.active_layer, copyname, copyname,
                           run_mode=RUN_WITH_LAST_VALS)
    except RuntimeError, e:
        gimp.delete(copyimg)
        print "Runtime error -- didn't save"
        return "Runtime error -- didn't save"

    # Find any image type settings parasites (e.g. jpeg settings)
    # that got set during save, so we'll be able to use them
    # next time.
    def copy_settings_parasites(fromimg, toimg):
        for pname in fromimg.parasite_list():
            if pname[-9:] == '-settings' or pname[-13:] == '-save-options':
                para = fromimg.parasite_find(pname)
                if para:
                    toimg.attach_new_parasite(pname, para.flags, para.data)

    # Copy any settings parasites we may have saved from previous runs:
    copy_settings_parasites(copyimg, img)

    gimp.delete(copyimg)
    #gimp.Display(copyimg)
    return None

def init_from_parasite(img):
    '''Returns copyname, percent, width, height.'''
    para = img.parasite_find('export-copy')
    if para:
        #copyname, percent, width, height = \
        paravals = \
            map(lambda x: 0 if x == 'None' or x == '' else x,
                para.data.split('\n'))
        copyname = paravals[0]
        percent = float(paravals[1])
        width = int(paravals[2])
        height = int(paravals[3])
        print "Read parasite values", copyname, percent, width, height
        return copyname, percent, width, height
    else:
        return None, 100.0, img.width, img.height

def python_fu_saver(img, drawable):
    # Figure out whether this image already has filenames chosen;
    # if so, just save and export;
    # if not, call python_fu_saver_as(img, drawable).

    # Figure out whether there's an export parasite
    # so we can pass width and height to save_both.
    copyname, export_percent, export_width, export_height = \
        init_from_parasite(img)

    if img.filename:
        save_both(img, drawable, img.filename, copyname,
                export_width, export_height)
    else:
        # If we don't have a filename, either from the current session
        # or saved as a parasite, then we'd better prompt for one.
        python_fu_saver_as(img, drawable)

def python_fu_saver_as(img, drawable):
    global percent_e, width_e, height_e, orig_width, orig_height, warning_label
    orig_filename = img.filename

    orig_width = img.width
    orig_height = img.height

    # Do we already have defaults?
    copyname, export_percent, export_width, export_height = \
        init_from_parasite(img)

    chooser = gtk.FileChooserDialog(title=None,
                                    action=gtk.FILE_CHOOSER_ACTION_SAVE,
                                    buttons=(gtk.STOCK_CANCEL,
                                             gtk.RESPONSE_CANCEL,
                                             gtk.STOCK_SAVE,
                                             gtk.RESPONSE_OK))

    # Set a current folder, since otherwise it'll be empty
    # and will nag the user to set one.
    if img.filename:
        chooser.set_current_name(os.path.basename(img.filename))
        chooser.set_current_folder(os.path.dirname(img.filename))
    else:
        # No directory set yet. So pick a likely directory
        # that's used by a lot of images currently open.
        counts = collections.Counter()
        for i in gimp.image_list() :
            if i.filename :
                counts[os.path.dirname(i.filename)] += 1
        try :
            common = counts.most_common(1)[0][0]
            chooser.set_current_folder(common)
        except :
            # GIMP has no images open with pathnames associated.
            # So we can't guess at a directory; just leave it blank.
            pass

    copybox = gtk.Table(rows=3, columns=7)

    l = gtk.Label("Export a copy to:")
    l.set_alignment(1.0, 0.5)        # Right align
    copybox.attach(l, 0, 1, 0, 1,
                   xpadding=5, ypadding=5)

    copyname_e = gtk.Entry()
    if copyname:
        copyname_e.set_text(copyname)
    copybox.attach(copyname_e, 1, 7, 0, 1,
                   xpadding=5, ypadding=5)

    l = gtk.Label("Scale the copy:")
    l.set_alignment(1.0, 0.5)
    copybox.attach(l, 0, 1, 1, 2,
                   xpadding=5, ypadding=5)

    l = gtk.Label("Percent:")
    l.set_alignment(1.0, 0.5)
    copybox.attach(l, 1, 2, 1, 2,
                   xpadding=5, ypadding=5)

    adj = gtk.Adjustment(int(export_percent), 1, 10000, 1, 10, 0)
    percent_e = gtk.SpinButton(adj, 0, 0)
    percent_e.connect("changed", entry_changed, 'p');
    copybox.attach(percent_e, 2, 3, 1, 2,
                   xpadding=5, ypadding=5)

    l = gtk.Label("Width:")
    l.set_alignment(1.0, 0.5)
    copybox.attach(l, 3, 4, 1, 2,
                   xpadding=5, ypadding=5)

    adj = gtk.Adjustment(int(export_width), 1, 10000, 1, 10, 0)
    width_e = gtk.SpinButton(adj, 0, 0)
    width_e.connect("changed", entry_changed, 'w');
    copybox.attach(width_e, 4, 5, 1, 2,
                   xpadding=5, ypadding=5)

    l = gtk.Label("Height:")
    l.set_alignment(1.0, 0.5)
    copybox.attach(l, 5, 6, 1, 2,
                   xpadding=5, ypadding=5)

    adj = gtk.Adjustment(int(export_height), 1, 10000, 1, 10, 0)
    height_e = gtk.SpinButton(adj, 0, 0)
    height_e.connect("changed", entry_changed, 'h');
    copybox.attach(height_e, 6, 7, 1, 2,
                   xpadding=5, ypadding=5)

    warning_label = gtk.Label("")
    copybox.attach(warning_label, 0, 7, 2, 3,
                   xpadding=5, ypadding=5)

    copybox.show_all()
    chooser.set_extra_widget(copybox)

    # Oh, cool, we could have shortcuts to image folders,
    # and maybe remove the stupid fstab shortcuts GTK adds for us.
        #chooser.add_shortcut_folder(folder)
        #chooser.remove_shortcut_folder(folder)

    # Loop to catch errors/warnings:
    while True:
        response = chooser.run()
        if response != gtk.RESPONSE_OK:
            chooser.destroy()
            return

        try:
            percent = float(percent_e.get_text())
        except ValueError:
            percent = None
        try:
            width = int(width_e.get_text())
        except ValueError:
            width = None
        try:
            height = int(height_e.get_text())
        except ValueError:
            height = None

        filename = chooser.get_filename()
        copyname = copyname_e.get_text()

        if copyname == orig_filename:
            warning_label.set_text("Change the name or the directory -- don't overwrite original file!")
            continue

        # Whew, it's not the original filename, so now we can save.
        dpy = chooser.get_display()
        chooser.hide()
        dpy.sync()

        err = save_both(img, drawable, filename, copyname, width, height)
        if err:
            markup = '<span foreground="red" size="larger" weight=\"bold">'
            markup_end = '</span>'
            warning_label.set_markup(markup + "Didn't save to " + filename
                                     + ":" + str(e) + markup_end)
            warning_label.set_text(err)
            print "Error:", err
            chooser.show()
            continue
        else:
            pdb.gimp_image_clean_all(img)

        # Otherwise, save_both was happy so we can continue.
        chooser.destroy()

        #gimp.context_pop()

        return

# Doesn't work to compare entry against percent_e, etc.
# Must pass that info in a separate arg, darnit.
def entry_changed(entry, which):
    global percent_e, width_e, height_e, orig_width, orig_height, busy
    if busy:
        return

    # Can't use get_value() or get_value_as_int() because they
    # don't work before an update(), but update() will usually
    # overwrite what the user typed. So define a function:
    def get_num_value(spinbox):
        s = spinbox.get_text()
        if not s:
            return 0

        try:
            p = int(s)
            return p
        except ValueError:
            try:
                p = float(s)
                return p
            except ValueError:
                return 0

    if which == 'p':
        p = get_num_value(percent_e)
        if not p: return
        busy = True
        w = int(orig_width * p / 100.)
        width_e.set_text(str(w))
        h = int(orig_height * p / 100.)
        height_e.set_text(str(h))
        busy = False

    elif which == 'w':
        w = get_num_value(width_e)
        if not w: return
        busy = True
        p = w * 100. / orig_width
        percent_e.set_text(str(p))
        h = int(orig_height * p / 100.)
        height_e.set_text(str(h))
        busy = False

    elif which == 'h':
        h = get_num_value(height_e)
        if not h: return
        busy = True
        p = h * 100. / orig_height
        percent_e.set_text(str(p))
        w = int(orig_width * p / 100.)
        width_e.set_text(str(w))
        busy = False
    else:
        print "I'm confused -- not width, height or percentage"

register(
    "python_fu_saver",
    "Save or export the current image, optionally also exporting a scaled version, prompting for filename only if needed.",
    "Save or export the current image, optionally also exporting a scaled version, prompting for filename only if needed.",
    "Akkana Peck",
    "Akkana Peck",
    "2014",
    "Saver",
    "*",
    [
        (PF_IMAGE, "image", "Input image", None),
        (PF_DRAWABLE, "drawable", "Input drawable", None),
    ],
    [],
    python_fu_saver,
    menu = "<Image>/File/Save/"
)

register(
    "python_fu_saver_as",
    "Prompt to save or export the current image, optionally also exporting a scaled version.",
    "Prompt to save or export the current image, optionally also exporting a scaled version.",
    "Akkana Peck",
    "Akkana Peck",
    "2014",
    "Saver as...",
    "*",
    [
        (PF_IMAGE, "image", "Input image", None),
        (PF_DRAWABLE, "drawable", "Input drawable", None),
    ],
    [],
    python_fu_saver_as,
    menu = "<Image>/File/Save/"
)

main()
	#!/usr/bin/env python

	# This is a plug-in intended to be bound to Ctrl-S, and to act as
	# a combination of Save, Save as..., Overwrite, and Export...
	#
	# It saves the image (whether its type would normally require Saving
	# or Exporting), and optionally allows for a copy of the image to be
	# exported to another file, possibly also scaled differently.
	# The copy must be saved to the same directory as the original
	# (because juggling two file choosers would make the dialog too huge
	# to fit on most screens!)
	#
	# Regardless of image format chosen, the image will be marked clean
	# so you won't get prompted for an unsaved image at quit or close time.
	#
	# The first time you save a file, you should be prompted for filename
	# (even if you opened an existing file).
	# After that, the plug-in will remember the filename you set.
	# You can always change it with Saver as...
	#
	# So you can have your XCF with high resolution and all layers,
	# and automatically export to a quarter-scale JPEG copy every time
	# you save the original. Or you can just overwrite your JPG if
	# all you're doing is a quick edit.
	#
	# The basic save filename follows img.filename.
	# The copy, if any, is saved in a parasite:
	# export-scaled: filename\npercent\nwidth\nheight

	# This plug-in is hosted at https://github.com/akkana/gimp-plugins/blob/master/saver.py

	# Copyright 2013,2014 by Akkana Peck, http://www.shallowsky.com/software/
	# You may use and distribute this plug-in under the terms of the GPL v2
	# or, at your option, any later GPL version.

	from gimpfu import *
	import gtk
	import os
	import collections

	# Image original size
	orig_width = 0
	orig_height = 0

	# The three gtk.Entry widgets we'll monitor:
	percent_e = None
	width_e = None
	height_e = None

	# A way to show errors to the user:
	warning_label = None

	# A way to turn off notifications while we're calculating
	busy = False

	def save_both(img, drawable, filename, copyname, width, height):
	'''Save the image, and also save the copy if appropriate,
	doing any duplicating or scaling that might be necessary.
	Returns None on success, else a nonempty string error message.
	'''
	msg = "Saving " + filename

	if copyname:
	if width and height:
	msg += " and a scaled copy, " + copyname
	else:
	msg += " and a copy, " + copyname
	print msg
	# Don't use gimp_message -- it can pop up a dialog.
	# pdb.gimp_message_set_handler(MESSAGE_BOX)
	# pdb.gimp_message(msg)
	# Alternately, could use gimp_progress, though that's not ideal.
	# If you use gimp_progress, don't forget to call pdb.gimp_progress_end()
	#pdb.gimp_progress_set_text(msg)

	# Is there any point to pushing and popping the context?
	#gimp.context_pop()

	# Set up the parasite with information about the copied image,
	# so it will be saved with the main XCF image.
	if copyname:
	if (width and height):
	percent = width * 100.0 / img.width
	# XXX note that this does not guard against changed aspect ratios.
	parastring = '%s\n%d\n%d\n%d' % (copyname, percent, width, height)
	else:
	parastring = '%s\n100.0\nNone\nNone' % (copyname)

	print "Saving parasite", parastring
	para = img.attach_new_parasite('export-copy', 1, parastring)
	# The second argument is is_persistent

	# Also make sure that copyname is a full path (if filename is).
	copypath = os.path.split(copyname)
	if not copypath[0] or len(copypath) == 1:
	filepath = os.path.split(filename)
	if len(filepath) > 1 and filepath[0]:
	print "Turning", copyname, "into a full path:",
	copyname = os.path.join(filepath[0], copyname)
	print copyname

	# Now the parasite is safely attached, and we can save.
	# Alas, we can't attach the JPEG settings parasite until after
	# we've saved the copy, so that won't get saved with the main image
	# though it will be attached to the image and remembered in
	# this session, and the next time we save it should be remembered.

	def is_xcf(thefilename):
	base, ext = os.path.splitext(thefilename)
	ext = ext.lower()
	if ext == '.gz' or ext == '.bz2':
	base, ext = os.path.splitext(base)
	ext = ext.lower()
	return (ext == '.xcf')

	# First, save the original image.
	if is_xcf(filename) or len(img.layers) < 2:
	pdb.gimp_file_save(img, drawable, filename, filename)
	else:
	# It's not XCF and it has multiple layers.
	# We need to make a new image and flatten it.
	copyimg = pdb.gimp_image_duplicate(img)
	# Don't actually flatten since that will prevent saving transparent png.
	#copyimg.flatten()
	pdb.gimp_image_merge_visible_layers(copyimg, CLIP_TO_IMAGE)
	pdb.gimp_file_save(copyimg, copyimg.active_layer, filename, filename)
	gimp.delete(copyimg)

	# We've done the important part, so mark the image clean.
	img.filename = filename
	pdb.gimp_image_clean_all(img)

	# If we don't have to save a copy, return.
	if not copyname:
	return None

	# We'll need a new image if the copy is non-xcf and we have more
	# than one layer, or if we're scaling.
	if (width and height):
	# We're scaling!
	copyimg = pdb.gimp_image_duplicate(img)
	copyimg.scale(width, height)
	print "Scaling to", width, 'x', height
	print "Set parastring to", parastring, "(end of parastring)"

	elif len(img.layers) > 1 and not is_xcf(copyname):
	# We're not scaling, but we still need to flatten.
	copyimg = pdb.gimp_image_duplicate(img)
	# copyimg.flatten()
	pdb.gimp_image_merge_visible_layers(copyimg, CLIP_TO_IMAGE)
	print "Flattening but not scaling"
	else:
	copyimg = img
	print "Not scaling or flattening"

	# gimp-file-save insists on being passed a valid layer,
	# even if saving to a multilayer format such as XCF. Go figure.

	# I don't get it. What's the rule for whether gimp_file_save
	# will prompt for jpg parameters? Saving back to an existing
	# file doesn't seem to help.
	# run_mode=RUN_WITH_LAST_VALS is supposed to prevent prompting,
	# but actually seems to do nothing. Copying the -save-options
	# parasites is more effective.
	try:
	pdb.gimp_file_save(copyimg, copyimg.active_layer, copyname, copyname,
	run_mode=RUN_WITH_LAST_VALS)
	except RuntimeError, e:
	gimp.delete(copyimg)
	print "Runtime error -- didn't save"
	return "Runtime error -- didn't save"

	# Find any image type settings parasites (e.g. jpeg settings)
	# that got set during save, so we'll be able to use them
	# next time.
	def copy_settings_parasites(fromimg, toimg):
	for pname in fromimg.parasite_list():
	if pname[-9:] == '-settings' or pname[-13:] == '-save-options':
	para = fromimg.parasite_find(pname)
	if para:
	toimg.attach_new_parasite(pname, para.flags, para.data)

	# Copy any settings parasites we may have saved from previous runs:
	copy_settings_parasites(copyimg, img)

	gimp.delete(copyimg)
	#gimp.Display(copyimg)
	return None

	def init_from_parasite(img):
	'''Returns copyname, percent, width, height.'''
	para = img.parasite_find('export-copy')
	if para:
	#copyname, percent, width, height = \
	paravals = \
	map(lambda x: 0 if x == 'None' or x == '' else x,
	para.data.split('\n'))
	copyname = paravals[0]
	percent = float(paravals[1])
	width = int(paravals[2])
	height = int(paravals[3])
	print "Read parasite values", copyname, percent, width, height
	return copyname, percent, width, height
	else:
	return None, 100.0, img.width, img.height

	def python_fu_saver(img, drawable):
	# Figure out whether this image already has filenames chosen;
	# if so, just save and export;
	# if not, call python_fu_saver_as(img, drawable).

	# Figure out whether there's an export parasite
	# so we can pass width and height to save_both.
	copyname, export_percent, export_width, export_height = \
	init_from_parasite(img)

	if img.filename:
	save_both(img, drawable, img.filename, copyname,
	export_width, export_height)
	else:
	# If we don't have a filename, either from the current session
	# or saved as a parasite, then we'd better prompt for one.
	python_fu_saver_as(img, drawable)

	def python_fu_saver_as(img, drawable):
	global percent_e, width_e, height_e, orig_width, orig_height, warning_label
	orig_filename = img.filename

	orig_width = img.width
	orig_height = img.height

	# Do we already have defaults?
	copyname, export_percent, export_width, export_height = \
	init_from_parasite(img)

	chooser = gtk.FileChooserDialog(title=None,
	action=gtk.FILE_CHOOSER_ACTION_SAVE,
	buttons=(gtk.STOCK_CANCEL,
	gtk.RESPONSE_CANCEL,
	gtk.STOCK_SAVE,
	gtk.RESPONSE_OK))

	# Set a current folder, since otherwise it'll be empty
	# and will nag the user to set one.
	if img.filename:
	chooser.set_current_name(os.path.basename(img.filename))
	chooser.set_current_folder(os.path.dirname(img.filename))
	else:
	# No directory set yet. So pick a likely directory
	# that's used by a lot of images currently open.
	counts = collections.Counter()
	for i in gimp.image_list() :
	if i.filename :
	counts[os.path.dirname(i.filename)] += 1
	try :
	common = counts.most_common(1)[0][0]
	chooser.set_current_folder(common)
	except :
	# GIMP has no images open with pathnames associated.
	# So we can't guess at a directory; just leave it blank.
	pass

	copybox = gtk.Table(rows=3, columns=7)

	l = gtk.Label("Export a copy to:")
	l.set_alignment(1.0, 0.5) # Right align
	copybox.attach(l, 0, 1, 0, 1,
	xpadding=5, ypadding=5)

	copyname_e = gtk.Entry()
	if copyname:
	copyname_e.set_text(copyname)
	copybox.attach(copyname_e, 1, 7, 0, 1,
	xpadding=5, ypadding=5)

	l = gtk.Label("Scale the copy:")
	l.set_alignment(1.0, 0.5)
	copybox.attach(l, 0, 1, 1, 2,
	xpadding=5, ypadding=5)

	l = gtk.Label("Percent:")
	l.set_alignment(1.0, 0.5)
	copybox.attach(l, 1, 2, 1, 2,
	xpadding=5, ypadding=5)

	adj = gtk.Adjustment(int(export_percent), 1, 10000, 1, 10, 0)
	percent_e = gtk.SpinButton(adj, 0, 0)
	percent_e.connect("changed", entry_changed, 'p');
	copybox.attach(percent_e, 2, 3, 1, 2,
	xpadding=5, ypadding=5)

	l = gtk.Label("Width:")
	l.set_alignment(1.0, 0.5)
	copybox.attach(l, 3, 4, 1, 2,
	xpadding=5, ypadding=5)

	adj = gtk.Adjustment(int(export_width), 1, 10000, 1, 10, 0)
	width_e = gtk.SpinButton(adj, 0, 0)
	width_e.connect("changed", entry_changed, 'w');
	copybox.attach(width_e, 4, 5, 1, 2,
	xpadding=5, ypadding=5)

	l = gtk.Label("Height:")
	l.set_alignment(1.0, 0.5)
	copybox.attach(l, 5, 6, 1, 2,
	xpadding=5, ypadding=5)

	adj = gtk.Adjustment(int(export_height), 1, 10000, 1, 10, 0)
	height_e = gtk.SpinButton(adj, 0, 0)
	height_e.connect("changed", entry_changed, 'h');
	copybox.attach(height_e, 6, 7, 1, 2,
	xpadding=5, ypadding=5)

	warning_label = gtk.Label("")
	copybox.attach(warning_label, 0, 7, 2, 3,
	xpadding=5, ypadding=5)

	copybox.show_all()
	chooser.set_extra_widget(copybox)

	# Oh, cool, we could have shortcuts to image folders,
	# and maybe remove the stupid fstab shortcuts GTK adds for us.
	#chooser.add_shortcut_folder(folder)
	#chooser.remove_shortcut_folder(folder)

	# Loop to catch errors/warnings:
	while True:
	response = chooser.run()
	if response != gtk.RESPONSE_OK:
	chooser.destroy()
	return

	try:
	percent = float(percent_e.get_text())
	except ValueError:
	percent = None
	try:
	width = int(width_e.get_text())
	except ValueError:
	width = None
	try:
	height = int(height_e.get_text())
	except ValueError:
	height = None

	filename = chooser.get_filename()
	copyname = copyname_e.get_text()

	if copyname == orig_filename:
	warning_label.set_text("Change the name or the directory -- don't overwrite original file!")
	continue

	# Whew, it's not the original filename, so now we can save.
	dpy = chooser.get_display()
	chooser.hide()
	dpy.sync()

	err = save_both(img, drawable, filename, copyname, width, height)
	if err:
	markup = '<span foreground="red" size="larger" weight=\"bold">'
	markup_end = '</span>'
	warning_label.set_markup(markup + "Didn't save to " + filename
	+ ":" + str(e) + markup_end)
	warning_label.set_text(err)
	print "Error:", err
	chooser.show()
	continue
	else:
	pdb.gimp_image_clean_all(img)

	# Otherwise, save_both was happy so we can continue.
	chooser.destroy()

	#gimp.context_pop()

	return

	# Doesn't work to compare entry against percent_e, etc.
	# Must pass that info in a separate arg, darnit.
	def entry_changed(entry, which):
	global percent_e, width_e, height_e, orig_width, orig_height, busy
	if busy:
	return

	# Can't use get_value() or get_value_as_int() because they
	# don't work before an update(), but update() will usually
	# overwrite what the user typed. So define a function:
	def get_num_value(spinbox):
	s = spinbox.get_text()
	if not s:
	return 0

	try:
	p = int(s)
	return p
	except ValueError:
	try:
	p = float(s)
	return p
	except ValueError:
	return 0

	if which == 'p':
	p = get_num_value(percent_e)
	if not p: return
	busy = True
	w = int(orig_width * p / 100.)
	width_e.set_text(str(w))
	h = int(orig_height * p / 100.)
	height_e.set_text(str(h))
	busy = False

	elif which == 'w':
	w = get_num_value(width_e)
	if not w: return
	busy = True
	p = w * 100. / orig_width
	percent_e.set_text(str(p))
	h = int(orig_height * p / 100.)
	height_e.set_text(str(h))
	busy = False

	elif which == 'h':
	h = get_num_value(height_e)
	if not h: return
	busy = True
	p = h * 100. / orig_height
	percent_e.set_text(str(p))
	w = int(orig_width * p / 100.)
	width_e.set_text(str(w))
	busy = False
	else:
	print "I'm confused -- not width, height or percentage"

	register(
	"python_fu_saver",
	"Save or export the current image, optionally also exporting a scaled version, prompting for filename only if needed.",
	"Save or export the current image, optionally also exporting a scaled version, prompting for filename only if needed.",
	"Akkana Peck",
	"Akkana Peck",
	"2014",
	"Saver",
	"*",
	[
	(PF_IMAGE, "image", "Input image", None),
	(PF_DRAWABLE, "drawable", "Input drawable", None),
	],
	[],
	python_fu_saver,
	menu = "<Image>/File/Save/"
	)

	register(
	"python_fu_saver_as",
	"Prompt to save or export the current image, optionally also exporting a scaled version.",
	"Prompt to save or export the current image, optionally also exporting a scaled version.",
	"Akkana Peck",
	"Akkana Peck",
	"2014",
	"Saver as...",
	"*",
	[
	(PF_IMAGE, "image", "Input image", None),
	(PF_DRAWABLE, "drawable", "Input drawable", None),
	],
	[],
	python_fu_saver_as,
	menu = "<Image>/File/Save/"
	)

	main()