/gtk/prep-images : contents of src/add_copyright_to_images/main

: (revision 1)

To get this branch, use:

bzr branch
http://bzr.ed.am/gtk/prep-images

# main_window.py
#
# Copyright (C) 2011 Tim Marston <edam@waxworlds.org>
#
# This file is part of add-copyright-to-images (hereafter referred to as "this
# program").
# See http://www.waxworlds.org/edam/software/add-copyright-to-images for more
# information.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published
# by the Free Software Foundation, either version 3 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 Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.


import sys
import os
import gobject
import pygtk
pygtk.require( '2.0' );
import gtk
from subprocess import call
from .preferences import *
from .prefs_dialog import *


class MainWindow:

	DRAWING_AREA_INIT_WIDTH = 550
	DRAWING_AREA_INIT_HEIGHT = 500
	IMAGEMAGICK_CONVERT_BIN = '/usr/bin/convert'

	def __init__( self, filename ):
		self.filename = filename

		# load preferences
		self.prefs = Preferences()

		# load main image and reset copyright image state to unloaded
		self.load_main_image()
		self.copyright_pic = None

		# init pos
		self.pos = "bottom-left";

		# work out the initial size of the drawing area so that the greatest of
		# the two dimensions is 450px
		scale = min( \
				float( self.DRAWING_AREA_INIT_WIDTH ) / self.pic.get_width(), \
				float( self.DRAWING_AREA_INIT_HEIGHT ) / self.pic.get_height() )
		init_width = int( round( scale * self.pic.get_width() ) )
		init_height = int( round( scale * self.pic.get_height() ) )

		# create window
		self.window = gtk.Window( gtk.WINDOW_TOPLEVEL )
		self.window.connect( "delete_event", self.delete_event )
		self.window.connect( "destroy", self.destroy )
		self.window.connect( "key-press-event", self.key_press_event )
		self.window.set_title( "Add Copyright to Images" );
		self.window.set_border_width( 10 )
		self.window.set_position( gtk.WIN_POS_CENTER )
		vbox = gtk.VBox( False, 10 )
		self.window.add( vbox )

		# create drawing area
		self.drawing_area = gtk.DrawingArea()
		self.drawing_area.set_size_request( init_width, init_height )
		self.drawing_area.add_events( gtk.gdk.POINTER_MOTION_MASK | \
				gtk.gdk.POINTER_MOTION_HINT_MASK | \
				gtk.gdk.BUTTON_PRESS_MASK )
		self.drawing_area.connect( "configure_event", \
				self.drawing_area_configure_event )
		self.drawing_area.connect( "expose_event", \
				self.drawing_area_expose_event )
		self.drawing_area.connect( "motion_notify_event", \
				self.motion_notify_event )
		self.drawing_area.connect( "button_press_event", \
				self.drawing_area_button_press_event )
		vbox.pack_start( self.drawing_area, True, True, 0 )

		# create buttons
		hbox = gtk.HBox( False, 10 )
		vbox.pack_end( hbox, False, False, 0 )
		left_button_box = gtk.HButtonBox()
		left_button_box.set_layout( gtk.BUTTONBOX_START )
		hbox.pack_start( left_button_box, True, True, 0 )
		button_box = gtk.HButtonBox()
		button_box.set_layout( gtk.BUTTONBOX_END )
		button_box.set_spacing( 10 )
		hbox.pack_end( button_box, True, True, 0 )
		prefs_button = gtk.Button( stock = gtk.STOCK_PREFERENCES )
		prefs_button.connect( "clicked", self.prefs_button_pressed )
		left_button_box.pack_start( prefs_button, True, True, 0 )
		cancel_button = gtk.Button( stock = gtk.STOCK_CANCEL )
		cancel_button.connect_object( "clicked", gtk.Widget.destroy, \
				self.window )
		button_box.pack_end( cancel_button, True, True, 0 )
		self.ok_button = gtk.Button( stock = gtk.STOCK_APPLY )
		self.ok_button.connect( "clicked", self.ok_button_pressed )
		button_box.pack_end( self.ok_button, True, True, 0 )
		self.ok_button.set_flags( gtk.CAN_DEFAULT )
		self.ok_button.grab_default()
		self.ok_button.grab_focus()

		# show it all
		self.window.show_all()

		# load copyright image
		self.load_copyright_image()

	def load_main_image( self ):
		# load image file
		try:
			self.pic = gtk.gdk.pixbuf_new_from_file( self.filename )
		except gobject.GError as e:
			dialog = gtk.MessageDialog( None, gtk.DIALOG_MODAL, \
					gtk.MESSAGE_ERROR, gtk.BUTTONS_CLOSE, e.message )
			dialog.run()
			dialog.destroy()
			exit( 1 )

		# scale it
		if self.prefs.resize:
			scale = min( \
					float( self.prefs.resize_width ) / self.pic.get_width(), \
					float( self.prefs.resize_height ) / self.pic.get_height() )
			self.pic = self.pic.scale_simple( \
				int( round( scale * self.pic.get_width() ) ), \
				int( round( scale * self.pic.get_height() ) ), \
				gtk.gdk.INTERP_BILINEAR )

	def load_copyright_image( self ):

		# reset state
		self.copyright_pic = None
		self.ok_button.set_sensitive( False )

		# check if we've got a copyright filename set
		if self.prefs.copyright_filename == '':
			dialog = gtk.MessageDialog( self.window, gtk.DIALOG_MODAL, \
					gtk.MESSAGE_INFO, gtk.BUTTONS_OK, \
					"No copyright image has been set. " + \
					"Please set one in the Preferences." )
			dialog.format_secondary_text( "While this issue persists, you " + \
					"can not proceed with this operation" )
			dialog.run()
			dialog.destroy()
			return

		# load copyright overlay image file
		try:
			self.copyright_pic = gtk.gdk.pixbuf_new_from_file( \
					os.path.expanduser( self.prefs.copyright_filename ) )
		except gobject.GError as e:
			dialog = gtk.MessageDialog( None, gtk.DIALOG_MODAL, \
					gtk.MESSAGE_ERROR, gtk.BUTTONS_OK, \
					"Unable to load copyright overlay image: " + \
					e.message )
			dialog.format_secondary_text( "While this issue persists, you " + \
					"can not proceed with this operation" )
			dialog.run()
			dialog.destroy()
			return

		# check the copyright overlay pic is smaller than the main pic
		if self.copyright_pic.get_width() > self.pic.get_width() or \
				self.copyright_pic.get_height() > self.pic.get_height():
			dialog = gtk.MessageDialog( None, gtk.DIALOG_MODAL, \
					gtk.MESSAGE_ERROR, gtk.BUTTONS_OK, \
					"The copyright overlay image is larger than the photo!" )
			dialog.format_secondary_text( "While this issue persists, you " + \
					"can not proceed with this operation" )
			dialog.run()
			dialog.destroy()
			self.copyright_pic = None
			return

		# enable the "ok" button and reconfigure the drawing area to generate
		# scaled puixbufs
		self.ok_button.set_sensitive( True )
		self.drawing_area.queue_resize()

	def main( self ):
		gtk.main()

	def ok_button_pressed( self, widget ):

		# calculate output filename
		pos = self.filename.rindex( '.' )
		if self.prefs.export_inplace:
			append = ".tmp"
		else:
			append = self.prefs.export_append
		out_filename = self.filename[ : self.filename.rindex( '.' ) ] + \
				append + self.filename[ self.filename.rindex( '.' ) : ]

		# calculate geometry
		top = 0 if self.pos.find( 'top' ) != -1 else \
				self.pic.get_height() - self.copyright_pic.get_height()
		left = 0 if self.pos.find( 'left' ) != -1 else \
				self.pic.get_width() - self.copyright_pic.get_width()

		infile = self.filename

		# caluclate program args
		resize_geometry = str( self.prefs.resize_width ) + "x" + \
				str( self.prefs.resize_height )
		copyright_geometry = str( self.copyright_pic.get_width() ) + \
				"x" + str( self.copyright_pic.get_height() ) + "+" + \
				str( left ) + "+" + str( top )
		args = [ self.IMAGEMAGICK_CONVERT_BIN, \
				os.path.expanduser( self.prefs.copyright_filename ), \
				"-geometry", copyright_geometry, \
				"-compose", "screen", "-composite", \
				out_filename ]
		if( self.prefs.resize ):
			args[ 1 : 1 ] = [ "(", "-resize", resize_geometry, \
					self.filename, ")" ]
		else:
			args[ 1 : 1 ] = [ self.filename ]

		# call ImageMagick to do our dirtywork
		try:
			ret = call( args )
			if ret != 0:
				print >>sys.stderr, "ImageMagick failed, returned ", ret
				return
		except OSError as e:
			print >>sys.stderr, "Failed to execute ImageMagick: ", e
			return

		if self.prefs.export_inplace:
			# move original file out of the way
			try:
				os.rename( self.filename, self.filename + ".old" )
			except OSError as e:
				print >>sys.stderr, "Could not rename original image file: ", \
						e.strerror
				exit( 1 )

			# move new file in-place
			try:
				os.rename( out_filename, self.filename )
			except OSError as e:
				# try and put the original file back again
				try:
					os.rename( self.filename + ".old", self.filename )
				except OSError:
					pass
				print >>sys.stderr, e.strerror
				exit( 1 )

			# delete original
			try:
				os.unlink( self.filename + ".old" )
			except OSError as e:
				print >>sys.stderr, "Unable to remove original image file (it ", \
					"now has '.old' appended to it's name): ", e.strerror
				exit( 1 )

		# close this window
		self.window.destroy()

	def prefs_button_pressed( self, widget ):
		PreferencesDialog( self.window ).main()
		self.prefs = Preferences()
		self.load_main_image()
		self.load_copyright_image()
		self.drawing_area.queue_resize()
		self.drawing_area.queue_draw()

	def key_press_event( self, widget, event ):
		if event.keyval == gtk.keysyms.Escape:
			self.window.destroy()
		elif event.keyval == gtk.keysyms.Up:
			self.move_pos( "bottom", "top" )
		elif event.keyval == gtk.keysyms.Down:
			self.move_pos( "top", "bottom" )
		elif event.keyval == gtk.keysyms.Left:
			self.move_pos( "right", "left" )
		elif event.keyval == gtk.keysyms.Right:
			self.move_pos( "left", "right" )
		else:
			return False

		return True

	def delete_event( self, widget, event, data = None ):
		return False

	def destroy( self, widget, data = None ):
		gtk.main_quit()

	def motion_notify_event( self, widget, event ):
		x, y, width, height = widget.get_allocation()

		# get mouse position
		if event.is_hint:
			x, y, state = event.window.get_pointer()
		else:
			x = event.x
			y = event.y
			state = event.state

		# calculate copyright overlay pos
		pos =   ( "top" if y <= height / 2 else "bottom" ) + "-" + \
				( "left" if x <= width / 2 else "right" )

		# redraw if necessary
		if getattr( self, "pos", None ) != pos:
			self.pos = pos
			self.generate_pixmap()
			widget.queue_draw()

		return True

	def drawing_area_button_press_event( self, widget, event ):
		if self.ok_button.get_property( "sensitive" ):
			self.ok_button.clicked()

	def drawing_area_configure_event( self, widget, event ):
		x, y, width, height = widget.get_allocation()

		# work out minimum scale required to fit pic_orig in to the widget area
		scale = min( float( width ) / self.pic.get_width(),
				float( height ) / self.pic.get_height() )

		# scale the images
		self.pic_scale = self.pic.scale_simple( \
				int( round( scale * self.pic.get_width() ) ), \
				int( round( scale * self.pic.get_height() ) ), \
				gtk.gdk.INTERP_BILINEAR )
		if self.copyright_pic != None:
			self.copyright_pic_scale = self.copyright_pic.scale_simple( \
					int( round( scale * self.copyright_pic.get_width() ) ), \
					int( round( scale * self.copyright_pic.get_height() ) ), \
					gtk.gdk.INTERP_BILINEAR )

		# recreate the pixmap to render to the screen
		self.generate_pixmap()

	def generate_pixmap( self ):
		widget = self.drawing_area
		x, y, width, height = widget.get_allocation()

		# calculate offsets to center pic in drawing area
		pre_width = ( width - self.pic_scale.get_width() ) / 2
		pre_height = ( height - self.pic_scale.get_height() ) / 2
		post_width = width - self.pic_scale.get_width() - pre_width
		post_height = height - self.pic_scale.get_height() - pre_height

		# create pixmap
		self.pixmap = gtk.gdk.Pixmap( widget.window, width, height )

		# create composite pixbuf containing the main image
		pixbuf = self.pic_scale.copy()

		if self.copyright_pic != None and \
				getattr( self, "copyright_pic_scale", None ) != None:

			# work out position of copyright overlay
			if self.pos == "top-left" or self.pos == "bottom-left":
				x = 0
			if self.pos == "top-right" or self.pos == "bottom-right":
				x = self.pic_scale.get_width() - \
						self.copyright_pic_scale.get_width()
			if self.pos == "top-left" or self.pos == "top-right":
				y = 0
			if self.pos == "bottom-left" or self.pos == "bottom-right":
				y = self.pic_scale.get_height() - \
						self.copyright_pic_scale.get_height()

			# draw copyright
			self.copyright_pic_scale.composite( pixbuf, x, y, \
					self.copyright_pic_scale.get_width(), \
					self.copyright_pic_scale.get_height(), \
					x, y, 1, 1, gtk.gdk.INTERP_NEAREST, 255 )

		# draw composit pixbuf to the off-screen pixmap
		self.pixmap.draw_pixbuf( widget.get_style().white_gc, \
				pixbuf, 0, 0, pre_width, pre_height, \
				pixbuf.get_width(), pixbuf.get_height() )

		# draw black rectangles if the pic is being centered
		if pre_width > 0 or pre_height > 0:
			self.pixmap.draw_rectangle( widget.get_style().black_gc, True, \
					0, 0, \
					pre_width if pre_width > 0 else width, \
					pre_height if pre_height > 0 else height )
		if post_width > 0 or post_height > 0:
			self.pixmap.draw_rectangle( widget.get_style().black_gc, True, \
					width - post_width if post_width > 0 else 0, \
					height - post_height if post_height > 0 else 0, \
					post_width if post_width > 0 else width, \
					post_height if post_height > 0 else height )

	def move_pos( self, tok_from, tok_to ):
		# calculate copyright overlay pos
		pos = self.pos.replace( tok_from, tok_to, 1 )

		# redraw if necessary
		if self.pos != pos:
			self.pos = pos
			self.generate_pixmap()
			self.drawing_area.queue_draw()

	def drawing_area_expose_event( self, widget, event ):
		x, y, width, height = event.area
		widget.window.draw_drawable( \
				widget.get_style().fg_gc[ gtk.STATE_NORMAL ], \
				self.pixmap, x, y, x, y, width, height )
		return False

1 by edam - initial commit, includes project and build setup	1	# main_window.py
	2	#
	3	# Copyright (C) 2011 Tim Marston <edam@waxworlds.org>
	4	#
	5	# This file is part of add-copyright-to-images (hereafter referred to as "this
	6	# program").
	7	# See http://www.waxworlds.org/edam/software/add-copyright-to-images for more
	8	# information.
	9	#
	10	# This program is free software: you can redistribute it and/or modify
	11	# it under the terms of the GNU Lesser General Public License as published
	12	# by the Free Software Foundation, either version 3 of the License, or
	13	# (at your option) any later version.
	14	#
	15	# This program is distributed in the hope that it will be useful,
	16	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	17	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	18	# GNU Lesser General Public License for more details.
	19	#
	20	# You should have received a copy of the GNU Lesser General Public License
	21	# along with this program. If not, see <http://www.gnu.org/licenses/>.
	22
	23
	24	import sys
	25	import os
	26	import gobject
	27	import pygtk
	28	pygtk.require( '2.0' );
	29	import gtk
	30	from subprocess import call
	31	from .preferences import *
	32	from .prefs_dialog import *
	33
	34
	35	class MainWindow:
	36
	37	DRAWING_AREA_INIT_WIDTH = 550
	38	DRAWING_AREA_INIT_HEIGHT = 500
	39	IMAGEMAGICK_CONVERT_BIN = '/usr/bin/convert'
	40
	41	def __init__( self, filename ):
	42	self.filename = filename
	43
	44	# load preferences
	45	self.prefs = Preferences()
	46
	47	# load main image and reset copyright image state to unloaded
	48	self.load_main_image()
	49	self.copyright_pic = None
	50
	51	# init pos
	52	self.pos = "bottom-left";
	53
	54	# work out the initial size of the drawing area so that the greatest of
	55	# the two dimensions is 450px
	56	scale = min( \
	57	float( self.DRAWING_AREA_INIT_WIDTH ) / self.pic.get_width(), \
	58	float( self.DRAWING_AREA_INIT_HEIGHT ) / self.pic.get_height() )
	59	init_width = int( round( scale * self.pic.get_width() ) )
	60	init_height = int( round( scale * self.pic.get_height() ) )
	61
	62	# create window
	63	self.window = gtk.Window( gtk.WINDOW_TOPLEVEL )
	64	self.window.connect( "delete_event", self.delete_event )
65	self.window.connect( "destroy", self.destroy )
66	self.window.connect( "key-press-event", self.key_press_event )
67	self.window.set_title( "Add Copyright to Images" );
68	self.window.set_border_width( 10 )
69	self.window.set_position( gtk.WIN_POS_CENTER )
70	vbox = gtk.VBox( False, 10 )
71	self.window.add( vbox )
72
73	# create drawing area
74	self.drawing_area = gtk.DrawingArea()
75	self.drawing_area.set_size_request( init_width, init_height )
76	self.drawing_area.add_events( gtk.gdk.POINTER_MOTION_MASK \| \
77	gtk.gdk.POINTER_MOTION_HINT_MASK \| \
78	gtk.gdk.BUTTON_PRESS_MASK )
79	self.drawing_area.connect( "configure_event", \
80	self.drawing_area_configure_event )
81	self.drawing_area.connect( "expose_event", \
82	self.drawing_area_expose_event )
83	self.drawing_area.connect( "motion_notify_event", \
84	self.motion_notify_event )
85	self.drawing_area.connect( "button_press_event", \
86	self.drawing_area_button_press_event )
87	vbox.pack_start( self.drawing_area, True, True, 0 )
88
89	# create buttons
90	hbox = gtk.HBox( False, 10 )
91	vbox.pack_end( hbox, False, False, 0 )
92	left_button_box = gtk.HButtonBox()
93	left_button_box.set_layout( gtk.BUTTONBOX_START )
94	hbox.pack_start( left_button_box, True, True, 0 )
95	button_box = gtk.HButtonBox()
96	button_box.set_layout( gtk.BUTTONBOX_END )
97	button_box.set_spacing( 10 )
98	hbox.pack_end( button_box, True, True, 0 )
99	prefs_button = gtk.Button( stock = gtk.STOCK_PREFERENCES )
100	prefs_button.connect( "clicked", self.prefs_button_pressed )
101	left_button_box.pack_start( prefs_button, True, True, 0 )
102	cancel_button = gtk.Button( stock = gtk.STOCK_CANCEL )
103	cancel_button.connect_object( "clicked", gtk.Widget.destroy, \
104	self.window )
105	button_box.pack_end( cancel_button, True, True, 0 )
106	self.ok_button = gtk.Button( stock = gtk.STOCK_APPLY )
107	self.ok_button.connect( "clicked", self.ok_button_pressed )
108	button_box.pack_end( self.ok_button, True, True, 0 )
109	self.ok_button.set_flags( gtk.CAN_DEFAULT )
110	self.ok_button.grab_default()
111	self.ok_button.grab_focus()
112
113	# show it all
114	self.window.show_all()
115
116	# load copyright image
117	self.load_copyright_image()
118
119	def load_main_image( self ):
120	# load image file
121	try:
122	self.pic = gtk.gdk.pixbuf_new_from_file( self.filename )
123	except gobject.GError as e:
124	dialog = gtk.MessageDialog( None, gtk.DIALOG_MODAL, \
125	gtk.MESSAGE_ERROR, gtk.BUTTONS_CLOSE, e.message )
126	dialog.run()
127	dialog.destroy()
128	exit( 1 )
129
130	# scale it
131	if self.prefs.resize:
132	scale = min( \
133	float( self.prefs.resize_width ) / self.pic.get_width(), \
134	float( self.prefs.resize_height ) / self.pic.get_height() )
135	self.pic = self.pic.scale_simple( \
136	int( round( scale * self.pic.get_width() ) ), \
137	int( round( scale * self.pic.get_height() ) ), \
138	gtk.gdk.INTERP_BILINEAR )
139
140	def load_copyright_image( self ):
141
142	# reset state
143	self.copyright_pic = None
144	self.ok_button.set_sensitive( False )
145
146	# check if we've got a copyright filename set
147	if self.prefs.copyright_filename == '':
148	dialog = gtk.MessageDialog( self.window, gtk.DIALOG_MODAL, \
149	gtk.MESSAGE_INFO, gtk.BUTTONS_OK, \
150	"No copyright image has been set. " + \
151	"Please set one in the Preferences." )
152	dialog.format_secondary_text( "While this issue persists, you " + \
153	"can not proceed with this operation" )
154	dialog.run()
155	dialog.destroy()
156	return
157
158	# load copyright overlay image file
159	try:
160	self.copyright_pic = gtk.gdk.pixbuf_new_from_file( \
161	os.path.expanduser( self.prefs.copyright_filename ) )
162	except gobject.GError as e:
163	dialog = gtk.MessageDialog( None, gtk.DIALOG_MODAL, \
164	gtk.MESSAGE_ERROR, gtk.BUTTONS_OK, \
165	"Unable to load copyright overlay image: " + \
166	e.message )
167	dialog.format_secondary_text( "While this issue persists, you " + \
168	"can not proceed with this operation" )
169	dialog.run()
170	dialog.destroy()
171	return
172
173	# check the copyright overlay pic is smaller than the main pic
174	if self.copyright_pic.get_width() > self.pic.get_width() or \
175	self.copyright_pic.get_height() > self.pic.get_height():
176	dialog = gtk.MessageDialog( None, gtk.DIALOG_MODAL, \
177	gtk.MESSAGE_ERROR, gtk.BUTTONS_OK, \
178	"The copyright overlay image is larger than the photo!" )
179	dialog.format_secondary_text( "While this issue persists, you " + \
180	"can not proceed with this operation" )
181	dialog.run()
182	dialog.destroy()
183	self.copyright_pic = None
184	return
185
186	# enable the "ok" button and reconfigure the drawing area to generate
187	# scaled puixbufs
188	self.ok_button.set_sensitive( True )
189	self.drawing_area.queue_resize()
190
191	def main( self ):
192	gtk.main()
193
194	def ok_button_pressed( self, widget ):
195
196	# calculate output filename
197	pos = self.filename.rindex( '.' )
198	if self.prefs.export_inplace:
199	append = ".tmp"
200	else:
201	append = self.prefs.export_append
202	out_filename = self.filename[ : self.filename.rindex( '.' ) ] + \
203	append + self.filename[ self.filename.rindex( '.' ) : ]
204
205	# calculate geometry
206	top = 0 if self.pos.find( 'top' ) != -1 else \
207	self.pic.get_height() - self.copyright_pic.get_height()
208	left = 0 if self.pos.find( 'left' ) != -1 else \
209	self.pic.get_width() - self.copyright_pic.get_width()
210
211	infile = self.filename
212
213	# caluclate program args
214	resize_geometry = str( self.prefs.resize_width ) + "x" + \
215	str( self.prefs.resize_height )
216	copyright_geometry = str( self.copyright_pic.get_width() ) + \
217	"x" + str( self.copyright_pic.get_height() ) + "+" + \
218	str( left ) + "+" + str( top )
219	args = [ self.IMAGEMAGICK_CONVERT_BIN, \
220	os.path.expanduser( self.prefs.copyright_filename ), \
221	"-geometry", copyright_geometry, \
222	"-compose", "screen", "-composite", \
223	out_filename ]
224	if( self.prefs.resize ):
225	args[ 1 : 1 ] = [ "(", "-resize", resize_geometry, \
226	self.filename, ")" ]
227	else:
228	args[ 1 : 1 ] = [ self.filename ]
229
230	# call ImageMagick to do our dirtywork
231	try:
232	ret = call( args )
233	if ret != 0:
234	print >>sys.stderr, "ImageMagick failed, returned ", ret
235	return
236	except OSError as e:
237	print >>sys.stderr, "Failed to execute ImageMagick: ", e
238	return
239
240	if self.prefs.export_inplace:
241	# move original file out of the way
242	try:
243	os.rename( self.filename, self.filename + ".old" )
244	except OSError as e:
245	print >>sys.stderr, "Could not rename original image file: ", \
246	e.strerror
247	exit( 1 )
248
249	# move new file in-place
250	try:
251	os.rename( out_filename, self.filename )
252	except OSError as e:
253	# try and put the original file back again
254	try:
255	os.rename( self.filename + ".old", self.filename )
256	except OSError:
257	pass
258	print >>sys.stderr, e.strerror
259	exit( 1 )
260
261	# delete original
262	try:
263	os.unlink( self.filename + ".old" )
264	except OSError as e:
265	print >>sys.stderr, "Unable to remove original image file (it ", \
266	"now has '.old' appended to it's name): ", e.strerror
267	exit( 1 )
268
269	# close this window
270	self.window.destroy()
271
272	def prefs_button_pressed( self, widget ):
273	PreferencesDialog( self.window ).main()
274	self.prefs = Preferences()
275	self.load_main_image()
276	self.load_copyright_image()
277	self.drawing_area.queue_resize()
278	self.drawing_area.queue_draw()
279
280	def key_press_event( self, widget, event ):
281	if event.keyval == gtk.keysyms.Escape:
282	self.window.destroy()
283	elif event.keyval == gtk.keysyms.Up:
284	self.move_pos( "bottom", "top" )
285	elif event.keyval == gtk.keysyms.Down:
286	self.move_pos( "top", "bottom" )
287	elif event.keyval == gtk.keysyms.Left:
288	self.move_pos( "right", "left" )
289	elif event.keyval == gtk.keysyms.Right:
290	self.move_pos( "left", "right" )
291	else:
292	return False
293
294	return True
295
296	def delete_event( self, widget, event, data = None ):
297	return False
298
299	def destroy( self, widget, data = None ):
300	gtk.main_quit()
301
302	def motion_notify_event( self, widget, event ):
303	x, y, width, height = widget.get_allocation()
304
305	# get mouse position
306	if event.is_hint:
307	x, y, state = event.window.get_pointer()
308	else:
309	x = event.x
310	y = event.y
311	state = event.state
312
313	# calculate copyright overlay pos
314	pos = ( "top" if y <= height / 2 else "bottom" ) + "-" + \
315	( "left" if x <= width / 2 else "right" )
316
317	# redraw if necessary
318	if getattr( self, "pos", None ) != pos:
319	self.pos = pos
320	self.generate_pixmap()
321	widget.queue_draw()
322
323	return True
324
325	def drawing_area_button_press_event( self, widget, event ):
326	if self.ok_button.get_property( "sensitive" ):
327	self.ok_button.clicked()
328
329	def drawing_area_configure_event( self, widget, event ):
330	x, y, width, height = widget.get_allocation()
331
332	# work out minimum scale required to fit pic_orig in to the widget area
333	scale = min( float( width ) / self.pic.get_width(),
334	float( height ) / self.pic.get_height() )
335
336	# scale the images
337	self.pic_scale = self.pic.scale_simple( \
338	int( round( scale * self.pic.get_width() ) ), \
339	int( round( scale * self.pic.get_height() ) ), \
340	gtk.gdk.INTERP_BILINEAR )
341	if self.copyright_pic != None:
342	self.copyright_pic_scale = self.copyright_pic.scale_simple( \
343	int( round( scale * self.copyright_pic.get_width() ) ), \
344	int( round( scale * self.copyright_pic.get_height() ) ), \
345	gtk.gdk.INTERP_BILINEAR )
346
347	# recreate the pixmap to render to the screen
348	self.generate_pixmap()
349
350	def generate_pixmap( self ):
351	widget = self.drawing_area
352	x, y, width, height = widget.get_allocation()
353
354	# calculate offsets to center pic in drawing area
355	pre_width = ( width - self.pic_scale.get_width() ) / 2
356	pre_height = ( height - self.pic_scale.get_height() ) / 2
357	post_width = width - self.pic_scale.get_width() - pre_width
358	post_height = height - self.pic_scale.get_height() - pre_height
359
360	# create pixmap
361	self.pixmap = gtk.gdk.Pixmap( widget.window, width, height )
362
363	# create composite pixbuf containing the main image
364	pixbuf = self.pic_scale.copy()
365
366	if self.copyright_pic != None and \
367	getattr( self, "copyright_pic_scale", None ) != None:
368
369	# work out position of copyright overlay
370	if self.pos == "top-left" or self.pos == "bottom-left":
371	x = 0
372	if self.pos == "top-right" or self.pos == "bottom-right":
373	x = self.pic_scale.get_width() - \
374	self.copyright_pic_scale.get_width()
375	if self.pos == "top-left" or self.pos == "top-right":
376	y = 0
377	if self.pos == "bottom-left" or self.pos == "bottom-right":
378	y = self.pic_scale.get_height() - \
379	self.copyright_pic_scale.get_height()
380
381	# draw copyright
382	self.copyright_pic_scale.composite( pixbuf, x, y, \
383	self.copyright_pic_scale.get_width(), \
384	self.copyright_pic_scale.get_height(), \
385	x, y, 1, 1, gtk.gdk.INTERP_NEAREST, 255 )
386
387	# draw composit pixbuf to the off-screen pixmap
388	self.pixmap.draw_pixbuf( widget.get_style().white_gc, \
389	pixbuf, 0, 0, pre_width, pre_height, \
390	pixbuf.get_width(), pixbuf.get_height() )
391
392	# draw black rectangles if the pic is being centered
393	if pre_width > 0 or pre_height > 0:
394	self.pixmap.draw_rectangle( widget.get_style().black_gc, True, \
395	0, 0, \
396	pre_width if pre_width > 0 else width, \
397	pre_height if pre_height > 0 else height )
398	if post_width > 0 or post_height > 0:
399	self.pixmap.draw_rectangle( widget.get_style().black_gc, True, \
400	width - post_width if post_width > 0 else 0, \
401	height - post_height if post_height > 0 else 0, \
402	post_width if post_width > 0 else width, \
403	post_height if post_height > 0 else height )
404
405	def move_pos( self, tok_from, tok_to ):
406	# calculate copyright overlay pos
407	pos = self.pos.replace( tok_from, tok_to, 1 )
408
409	# redraw if necessary
410	if self.pos != pos:
411	self.pos = pos
412	self.generate_pixmap()
413	self.drawing_area.queue_draw()
414
415	def drawing_area_expose_event( self, widget, event ):
416	x, y, width, height = event.area
417	widget.window.draw_drawable( \
418	widget.get_style().fg_gc[ gtk.STATE_NORMAL ], \
419	self.pixmap, x, y, x, y, width, height )
420	return False