/gtk/prep-images

# prefs_dialog.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 *

class PreferencesDialog:

	def __init__( self, parent_window = None ):

		self.prefs = Preferences()

		# create window

		self.window = gtk.Window( gtk.WINDOW_TOPLEVEL )

		self.window.connect( "delete_event", self.destroy )

		self.window.connect( "destroy", self.destroy )

		self.window.set_title( "Add Copyright to Images Preferences" );

		self.window.set_border_width( 10 )

		self.window.set_modal( True )

		self.window.connect( "key-press-event", self.key_press_event )

		if parent_window != None:

			self.window.set_transient_for( parent_window )

		vbox = gtk.VBox( False, 10 )

		self.window.add( vbox )

		# copyright image frame

		copyright_frame = gtk.Frame()

		copyright_frame.set_shadow_type( gtk.SHADOW_NONE )

		label1 = gtk.Label( "<b>Copyright Overlay Image</b>" )

		label1.set_use_markup( True )

		copyright_frame.set_label_widget( label1 )

		vbox.pack_start( copyright_frame, False, False, 0 )

		alignment1 = gtk.Alignment( 0.5, 0.5, 1.0, 1.0 )

		alignment1.set_padding( 5, 0, 12, 0 )

		copyright_frame.add( alignment1 )

		hbox1 = gtk.HBox( False, 2 )

		alignment1.add( hbox1 )

		self.copyright_entry = gtk.Entry( 0 )

		self.copyright_entry.set_text( self.prefs.copyright_filename )

		hbox1.pack_start( self.copyright_entry, True, True, 0 )

		button1 = gtk.Button( stock = gtk.STOCK_OPEN )

		button1.connect( "clicked", self.open_button_pressed )

		hbox1.pack_end( button1, False, False, 0 )

		# resize frame

		resize_frame = gtk.Frame()

		resize_frame.set_shadow_type( gtk.SHADOW_NONE )

		label2 = gtk.Label( "<b>Resize Image</b>" )

		label2.set_use_markup( True )

		resize_frame.set_label_widget( label2 )

		vbox.pack_start( resize_frame, False, False, 0 )

		alignment2 = gtk.Alignment( 0.5, 0.5, 1.0, 1.0 )

		alignment2.set_padding( 5, 0, 12, 0 )

		resize_frame.add( alignment2 )

		vbox1 = gtk.VBox( False, 0 )

		alignment2.add( vbox1 )

		self.resize_check_button = gtk.CheckButton( \

				"Resize image when adding copyright overlay" )

		self.resize_check_button.set_active( self.prefs.resize )

		self.resize_check_button.connect( "clicked", \

				self.resize_check_button_pressed )

		vbox1.pack_start( self.resize_check_button, False, False, 0 )

		alignment3 = gtk.Alignment( 0.5, 0.5, 1.0, 1.0 )

		alignment3.set_padding( 5, 0, 12, 0 )

		vbox1.pack_start( alignment3, False, False, 0 )

		self.resize_hbox = gtk.HBox( False, 10 )

		alignment3.add( self.resize_hbox )

		label3 = gtk.Label( "Width:" )

		self.resize_hbox.pack_start( label3, False, False, 0 )

		adjustment1 = gtk.Adjustment( self.prefs.resize_width, \

				1, 9999999, 1 )

		self.resize_width_spin_button = gtk.SpinButton( adjustment1 )

		self.resize_width_spin_button.set_numeric( True )

		self.resize_hbox.pack_start( \

				self.resize_width_spin_button, True, True, 0 )

		label4 = gtk.Label( "Height:" )

		self.resize_hbox.pack_start( label4, False, False, 0 )

		adjustment2 = gtk.Adjustment( self.prefs.resize_height, \

				1, 9999999, 1 )

		self.resize_height_spin_button = gtk.SpinButton( adjustment2 )

		self.resize_height_spin_button.set_numeric( True )

		self.resize_hbox.pack_start( \

				self.resize_height_spin_button, True, True, 0 )

		# export frame

		export_frame = gtk.Frame()

		export_frame.set_shadow_type( gtk.SHADOW_NONE )

		label5 = gtk.Label( "<b>Saving</b>" )

		label5.set_use_markup( True )

		export_frame.set_label_widget( label5 )

		vbox.pack_start( export_frame, False, False, 0 )

		alignment6 = gtk.Alignment( 0.5, 0.5, 1.0, 1.0 )

		alignment6.set_padding( 5, 0, 12, 0 )

		export_frame.add( alignment6 )

		vbox2 = gtk.VBox( False, 0 )

		alignment6.add( vbox2 )

		self.export_radio_button = gtk.RadioButton( None, \

				"Resize and add copyright to image in place" )

		self.export_radio_button.set_active( self.prefs.export_inplace )

		vbox2.pack_start( self.export_radio_button, False, False, 0 )

		hbox3 = gtk.HBox( False, 10 )

		vbox2.pack_start( hbox3, False, False, 0 )

		radio_button1 = gtk.RadioButton( self.export_radio_button, \

				"Append" )

		radio_button1.set_active( not self.prefs.export_inplace )

		hbox3.pack_start( radio_button1, False, False, 0 )

		self.export_append_entry = gtk.Entry()

		self.export_append_entry.set_width_chars( 10 )

		self.export_append_entry.set_text( self.prefs.export_append )

		hbox3.pack_start( self.export_append_entry, True, True, 0 )

		label6 = gtk.Label( "to filename" )

		hbox3.pack_start( label6, False, False, 0 )

		# buttons

		bbox1 = gtk.HButtonBox()

		bbox1.set_layout( gtk.BUTTONBOX_END )

		vbox.pack_end( bbox1, False, False, 0 )

		ok_button = gtk.Button( stock = gtk.STOCK_OK )

		ok_button.connect( "clicked", self.ok_button_pressed )

		bbox1.pack_end( ok_button )

		ok_button.set_flags( gtk.CAN_DEFAULT )

		ok_button.grab_default()

		# show it all

		self.resize_check_button_pressed()

		self.window.show_all()

	def main( self ):

		gtk.main()

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

		return False

	def destroy( self, widget, data = None ):

		gtk.main_quit()

	def key_press_event( self, widget, event ):

		if event.keyval == gtk.keysyms.Escape:

			self.window.destroy()

		else:

			return False

		return True

	def ok_button_pressed( self, widget ):

		self.prefs.copyright_filename = \

				self.copyright_entry.get_text().strip()

		self.prefs.resize = \

				self.resize_check_button.get_active()

		self.prefs.resize_width = \

				int( self.resize_width_spin_button.get_value_as_int() )

		self.prefs.resize_height = \

				int( self.resize_height_spin_button.get_value_as_int() )

		self.prefs.export_inplace = \

				self.export_radio_button.get_active()

		self.prefs.export_append = \

				self.export_append_entry.get_text().strip()

		self.prefs.save()

		self.window.destroy()

	def open_button_pressed( self, widget ):

		dialog = gtk.FileChooserDialog( "Choose Copyright Overlay Image", \

				self.window, gtk.FILE_CHOOSER_ACTION_OPEN, \

				( gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, \

				gtk.STOCK_OPEN, gtk.RESPONSE_OK) )

		dialog.set_default_response(gtk.RESPONSE_OK)

		filter = gtk.FileFilter()

		filter.set_name( "Images" )

		filter.add_mime_type( "image/png" )

		filter.add_mime_type( "image/jpeg" )

		filter.add_mime_type( "image/gif" )

		filter.add_pattern( "*.jpg" )

		filter.add_pattern( "*.png" )

		filter.add_pattern( "*.jpg" )

		filter.add_pattern( "*.gif" )

		filter.add_pattern( "*.tif" )

		filter.add_pattern( "*.xpm" )

		dialog.add_filter( filter )

		filter = gtk.FileFilter()

		filter.set_name( "All files" )

		filter.add_pattern( "*" )

		dialog.add_filter( filter )

		if dialog.run() == gtk.RESPONSE_OK:

			self.copyright_entry.set_text( dialog.get_filename() )

		dialog.destroy()

	def resize_check_button_pressed( self, widget = None ):

		self.resize_hbox.set_sensitive(

				self.resize_check_button.get_active() )