/gtk/prep-images

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

		# calculate 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 centre 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 composite 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 centred
		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