#!/usr/bin/env python
# -*- coding: utf-8 -*-

#================================================
#
#    Comix 2.1 - GTK Comic Book Viewer
#    Copyright (C) 2005 Pontus Ekberg <herrekberg@users.sourceforge.net>
#
#================================================
#
#    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 2 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, write to the Free Software
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
#
#================================================


import pygtk
pygtk.require('2.0')
import gtk, os, sys, gc, shutil, stat, zipfile, tarfile, urllib, locale

class Comic:
	
	optionlist = [0, 0, gtk.gdk.INTERP_TILES, 1, 0, 0, 10, 1, 0, 0, gtk.gdk.screen_get_default().get_width() / 2, gtk.gdk.screen_get_default().get_height() * 3 / 4,
	0, 0, 0, os.environ["HOME"], 1, 100, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 'txt nfo', 0, 0, 0, gtk.TOOLBAR_ICONS] # All the preferences are stored here.
	temp_optionlist = [0] # Used in the preferences dialog to store the options as they are being changed.
	old_optionlist = [0] # Used in the preferences dialog to restore the old state if Cancel is pressed.
	
	# Preferences
	# -------------------------
	# 0 = Fullscreen
	# 1 = Default fullscreen
	# 2 = Scaling quality
	# 3 = Hide *bars in fullscreen
	# 4 = Double page mode
	# 5 = Default double page mode
	# 6 = Saturation
	# 7 = Cache
	# 8 = Flip double page (manga)
	# 9 = Stretch small images
	# 10 = Window width
	# 11 = Window height
	# 12 = Window x position
	# 13 = Window y position
	# 14 = Save window size/position
	# 15 = Default path
	# 16 = Fit to screen as default
	# 17 = Zooming scale
	# 18 = Fit to screen
	# 19 = Bg red value
	# 20 = Bg green value
	# 21 = Bg blue value
	# 22 = Hide scrollbars
	# 23 = Go to next archive after last page
	# 24 = Hide cursor
	# 25 = Show menubar
	# 26 = Show toolbar
	# 27 = Show statusbar
	# 28 = Show comments
	# 29 = Comment extensions
	# 30 = Flip when scrolling 3 times extra
	# 31 = Start scrolling sideways when top/bottom is reached
	# 32 = Smart scaling
	# 33 = toolbar style
	
	# Various variables
	# -------------------------
	file = [] # Array for the image filenames.
	file_number = 0 # The image in file[] currently viewed.
	old_file_number = -1 # The image in file[] previously viewed.
	comment = [] # Array for the comment filenames.
	comment_number = 0 # The comment in comment[] currently viewed.
	show_comments = 0 # True if a comment is/should be viewed instead of an image.
	bookmarks = [] # Stores the bookmark paths.
	bookmark_numbers = [] # Stores the bookmark page numbers.
	file_exist = 0 # If no valid files are opened selected.
	archive_type = "" # The type of archive being viewed if any.
	path = "" # Path to the archive or image opened.
	filetype_error = 0 # Tells refresh_image() that there is no file loaded because of a file type error, and that it should not blank out the statusbar.
	x_motion = -1 #Stores coordinates fo the image dragging feature. 
	y_motion = -1 
	motion_number = 0 # Stores the number of motion_notify events given to the application, so that it should not update to often causing resource hogging.
	file_removed = 0 # Used to tell the convert utility that a file has been overwritten.
	mouse_moved = 0 # True if the mouse is moved while pressing the button, separates dragging from page flipping.
	change_adjustment = 0 # Tells refresh_image() that it should change the adjustment of the scrollbars.
	image1_width = 0 # Stores the sizes of images, used for various things.
	image1_height = 0
	image2_width = 0
	image2_height = 0
	image1_scaled_width = 0
	image1_scaled_height = 0
	image2_scaled_width = 0
	image2_scaled_height = 0
	resize_event = 0 # Tells refresh_image() that a resizing is going on, stopping it from updating the widgets in the middle of the function since it would be to choppy.
	base_dir = ''
	scroll_events_down = 0
	scroll_events_up = 0
	
	# Cache variables
	# -------------------------
	stored_pixbuf = 0 # The previously viewed pixbuf(s).
	stored_pixbuf2 = 0 
	cached_pixbuf = 0 # The cached pixbuf(s).
	cached_pixbuf2 = 0
	stored_double = 0 # True if two pixbufs are stored (for double page mode).
	cached = 0 # 0 if no pixbufs are cached; 1 if 1 pixbuf is cached; 2 if 2 pixbufs are cached.
	
	# All the windows and dialogs.
	# -------------------------
	window = gtk.Window(gtk.WINDOW_TOPLEVEL) # Main window.
	options_window = gtk.Dialog("Preferences", window, 0, ()) # Preferences dialog.
	file_dialog = gtk.Dialog("Properties", window, 0, (gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE)) # Properties dialog.
	invalid_filename_dialog = gtk.Dialog("Invalid filename", window, 0, (gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE)) # Invalig filename dialog.
	permission_dialog = gtk.Dialog("Permission denied", window, 0, (gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE)) # Wrong permissions dialog.
	about_dialog = gtk.Dialog("About", window, 0, (gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE)) # About dialog.
	bookmark_dialog = gtk.Dialog("Edit bookmarks", window, 0, (gtk.STOCK_ADD, gtk.RESPONSE_YES, gtk.STOCK_REMOVE, gtk.RESPONSE_NO, gtk.STOCK_OK, gtk.RESPONSE_OK))  # Bookmark manager dialog.
	page_dialog = gtk.Dialog("Go to page", window, 0, (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OK, gtk.RESPONSE_OK)) # Go-to-page dialog.
	convert_dialog = gtk.Dialog("Convert", window, 0, (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OK, gtk.RESPONSE_OK)) # Convert dialog.
	overwrite_dialog = gtk.Dialog("Overwrite", window, 0, (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OK, gtk.RESPONSE_OK)) # Overwrite dialog.
	filechooser_dialog = gtk.FileChooserDialog("Select folder", window, gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER, (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OK, gtk.RESPONSE_OK)) # Default path dialog.
	
	# Various widgets
	# -------------------------
	tooltips = gtk.Tooltips()
	button_fullscreen = gtk.CheckButton("Fullscreen as default")
	button_page = gtk.CheckButton("Double page mode as default")
	button_fit = gtk.CheckButton("Fit-to-screen mode as default")
	button_stretch = gtk.CheckButton("Stretch small images in fit-to-screen mode")
	button_smart_scale = gtk.CheckButton("Use smart scaling in double page mode")
	button_comment = gtk.CheckButton("Always view comments when opening a new file")
	button_hide_bars = gtk.CheckButton("Hide menubar, scrollbars etc. in fullscreen mode")
	button_cache_next = gtk.CheckButton("Cache pages for faster forward flipping")
	button_flip_page = gtk.CheckButton("Manga mode (read right-to-left etc.)")
	button_scroll_horiz = gtk.CheckButton("Scroll wheel scrolls horizontally at top and bottom of page")
	button_scroll_flips = gtk.CheckButton("Flip page when scrolling off the top or bottom of page")
	button_save_size = gtk.CheckButton("Save window position and size for future sessions")
	button_next_archive = gtk.CheckButton("Go to the next archive in directory after last page")
	button_hide_cursor = gtk.CheckButton("Hide cursor in fullscreen mode")
	colorbutton = gtk.ColorButton(color=gtk.gdk.Color(0,0,0))
	button_saturation = gtk.SpinButton(gtk.Adjustment(1.0, 0, 3, 0.1, 0.1, page_size=0), climb_rate=0.0, digits=1)
	button_page_spin = gtk.SpinButton(gtk.Adjustment(1, 1, 1000, 1, 1, page_size=0), climb_rate=0.0, digits=0)
	button_1 = gtk.RadioButton(None, "Nearest (quickest, worst quality)")
	button_2 = gtk.RadioButton(button_1, "Tiles")
	button_3 = gtk.RadioButton(button_2, "Bilinear")
	button_4 = gtk.RadioButton(button_3, "Hyper (slowest, best quality)")
	file_select = gtk.FileChooserDialog(title="Open",action=gtk.FILE_CHOOSER_ACTION_OPEN,
	buttons=(gtk.STOCK_CANCEL,gtk.RESPONSE_CANCEL,gtk.STOCK_OPEN,gtk.RESPONSE_OK))
	file_select.set_default_response(gtk.RESPONSE_OK)
	comment_extensions_entry = gtk.Entry(max=100)
	go_to_page_label = gtk.Label()
	file_info_label = gtk.Label()
	file_info_label2 = gtk.Label()
	invalid_filename_info_label = gtk.Label()
	permission_label = gtk.Label()
	image = gtk.Image()
	image2 = gtk.Image()
	image_box = gtk.HBox(False, 2)
	image_box.show()
	image_box.add(image)
	image_box.add(image2)
	button_zin = gtk.ToolButton(gtk.STOCK_ZOOM_IN)
	button_zout = gtk.ToolButton(gtk.STOCK_ZOOM_OUT)
	button_z100 = gtk.ToolButton(gtk.STOCK_ZOOM_100)
	button_zfit = gtk.ToolButton(gtk.STOCK_ZOOM_FIT)
	button_previous = gtk.ToolButton(gtk.STOCK_GO_BACK)
	button_next = gtk.ToolButton(gtk.STOCK_GO_FORWARD)
	button_first = gtk.ToolButton(gtk.STOCK_GOTO_FIRST)
	button_last = gtk.ToolButton(gtk.STOCK_GOTO_LAST)
	button_go = gtk.ToolButton(gtk.STOCK_JUMP_TO)
	button_apply = gtk.Button("Apply", gtk.STOCK_APPLY)
	combobox_convert = gtk.combo_box_new_text()
	combobox_tool = gtk.combo_box_new_text()
	filename_entry = gtk.Entry(max=100)
	button_delete_archive = gtk.CheckButton("Delete old archive/directory")
	overwrite_label = gtk.Label()
	comment_label = gtk.Label()
	liststore = gtk.ListStore(str, str)
	bookmark_manager_tree_view = gtk.TreeView(liststore)
	bookmark_column = gtk.TreeViewColumn('Title')
	bookmark_column2 = gtk.TreeViewColumn('Page')
	cell = gtk.CellRendererText()
	cell2 = gtk.CellRendererText()
	filechooser_button = gtk.Button()
	notebook = gtk.Notebook()
	
	layout = gtk.Layout()
	layout.put(image_box, 0, 0)
	layout.put(comment_label, 0, 0)

	vadjust = layout.get_vadjustment()
	hadjust = layout.get_hadjustment()
	vadjust.step_increment = 15
	vadjust.page_increment = 1
	hadjust.step_increment = 15
	hadjust.page_increment = 1
	old_vadjust_value = 0
	old_hadjust_value = 0
	vadjust_upper = 0
	hadjust_upper = 0
	
	hscroll = gtk.HScrollbar(None)
	hscroll.set_adjustment(hadjust)
	vscroll = gtk.VScrollbar(None)
	vscroll.set_adjustment(vadjust)
	
	ui = -1
	actiongroup = gtk.ActionGroup('')
	accelgroup = 0
	merge_id = -1
	toolbar = gtk.Toolbar()
	statusbar = gtk.Statusbar()
	
	table = gtk.Table(2, 2, False)
	table.attach(layout, 0, 1, 2, 3, gtk.FILL|gtk.EXPAND, gtk.FILL|gtk.EXPAND, 0, 0)
	table.attach(vscroll,1, 2, 2, 3, gtk.FILL|gtk.SHRINK, gtk.FILL|gtk.SHRINK, 0, 0)
	table.attach(hscroll, 0, 1, 4, 5, gtk.FILL|gtk.SHRINK, gtk.FILL|gtk.SHRINK, 0, 0)
	window.add(table)
	
	def create_windows(self, event):
		
		# Main window
		self.table.show()
		self.layout.show()
		self.comment_label.set_selectable(True)
		
		# Preferences dialog
		self.options_window.set_has_separator(False)
		self.options_window.action_area.set_size_request(0, 0)
		self.notebook.show()
		self.options_window.set_title("Preferences")
		
		box = gtk.VBox(False, 0)
		box.set_border_width(1)
		box.show()
		
		self.options_window.vbox.pack_start(box, False, False, 2)
		box.pack_start(self.notebook, False, False, 2)
		
		vbox = gtk.VBox(False, 0)
		vbox.set_border_width(12)
		
		label = gtk.Label()
		label.set_markup('<b>General</b>\n')
		label.set_alignment(0, 0)
		vbox.pack_start(label, False, False, 0)
		label.show()
		
		hbox = gtk.HBox(False, 2)
		hbox.show()
		vbox.pack_start(hbox, False, False, 0)
		
		padding_box = gtk.VBox(False, 0)
		padding_box.set_border_width(10)
		padding_box.show()
		hbox.pack_start(padding_box, False, False, 0)
		
		general_box = gtk.VBox(False, 0)
		hbox.pack_start(general_box, True, True, 0)
		general_box.show()
		
		self.button_fullscreen.connect("toggled", self.options, 0)
		general_box.pack_start(self.button_fullscreen, True, True, 2)
		self.button_fullscreen.show()
		
		self.button_page.connect("toggled", self.options, 1)
		general_box.pack_start(self.button_page, True, True, 2)
		self.button_page.show()
		
		self.button_fit.connect("toggled", self.options, 11)
		general_box.pack_start(self.button_fit, True, True, 2)
		self.button_fit.show()
		
		self.button_save_size.connect("toggled", self.options, 10)
		general_box.pack_start(self.button_save_size, True, True, 2)
		self.button_save_size.show()
		
		self.button_cache_next.connect("toggled", self.options, 7)
		general_box.pack_start(self.button_cache_next, True, True, 2)
		self.button_cache_next.show()
		
		label = gtk.Label("\nAlways go to this directory when opening a new file:")
		label.set_alignment(0, 0)
		general_box.pack_start(label, False, False, 0)
		label.show()
		
		self.filechooser_button.connect_object("clicked", self.open_filechooser, None)
		self.filechooser_button.set_use_underline(False)
		general_box.pack_start(self.filechooser_button, False, True, 0)
		self.filechooser_button.show()
		
		label = gtk.Label()
		label.set_markup('\n<b>Scroll</b>\n')
		label.set_alignment(0, 0)
		vbox.pack_start(label, False, False, 0)
		label.show()
		
		hbox = gtk.HBox(False, 2)
		hbox.show()
		vbox.pack_start(hbox, False, False, 0)
		
		padding_box = gtk.VBox(False, 0)
		padding_box.set_border_width(10)
		padding_box.show()
		hbox.pack_start(padding_box, False, False, 0)
		
		scroll_box = gtk.VBox(False, 0)
		hbox.pack_start(scroll_box, True, True, 0)
		scroll_box.show()
		
		self.button_next_archive.connect("toggled", self.options, 14)
		scroll_box.pack_start(self.button_next_archive, True, True, 2)
		self.button_next_archive.show()
		
		self.button_scroll_horiz.connect("toggled", self.options, 17)
		scroll_box.pack_start(self.button_scroll_horiz, True, True, 2)
		self.button_scroll_horiz.show()
		
		self.button_scroll_flips.connect("toggled", self.options, 18)
		scroll_box.pack_start(self.button_scroll_flips, True, True, 2)
		self.button_scroll_flips.show()
		
		label = gtk.Label()
		label.set_markup('\n<b>Comments</b>\n')
		label.set_alignment(0, 0)
		vbox.pack_start(label, False, False, 0)
		label.show()
		
		hbox = gtk.HBox(False, 2)
		hbox.show()
		vbox.pack_start(hbox, False, False, 0)
		
		padding_box = gtk.VBox(False, 0)
		padding_box.set_border_width(10)
		padding_box.show()
		hbox.pack_start(padding_box, False, False, 0)
		
		comments_box = gtk.VBox(False, 0)
		hbox.pack_start(comments_box, True, True, 0)
		comments_box.show()
		
		self.button_comment.connect("toggled", self.options, 16)
		comments_box.pack_start(self.button_comment, True, True, 2)
		self.button_comment.show()
		
		label = gtk.Label("\nTreat files with the following extensions as comments:")
		label.set_alignment(0, 0)
		comments_box.pack_start(label, False, False, 0)
		label.show()
		comments_box.pack_start(self.comment_extensions_entry, True, True, 0)
		self.comment_extensions_entry.show()
		
		self.notebook.insert_page(vbox, gtk.Label("Behaviour"))
		
		vbox_scaling = gtk.VBox(False, 0)
		vbox_scaling.set_border_width(12)
		vbox_scaling.show()
		
		label = gtk.Label()
		label.set_markup('<b>General</b>\n')
		label.set_alignment(0, 0)
		vbox_scaling.pack_start(label, False, False, 0)
		label.show()
		
		hbox = gtk.HBox(False, 2)
		hbox.show()
		vbox_scaling.pack_start(hbox, False, False, 0)
		
		padding_box = gtk.VBox(False, 0)
		padding_box.set_border_width(10)
		padding_box.show()
		hbox.pack_start(padding_box, False, False, 0)
		
		general_box = gtk.VBox(False, 0)
		hbox.pack_start(general_box, True, True, 0)
		general_box.show()
		
		hbox = gtk.HBox(False, 0)
		hbox.show()
		label_box = gtk.VBox(False, 0)
		label_box.show()
		entry_box = gtk.VBox(False, 0)
		entry_box.show()
		hbox.pack_start(label_box, True, True, 0)
		hbox.pack_start(entry_box, True, True, 0)
		general_box.pack_start(hbox, True, True, 0)
		
		label = gtk.Label("Saturation (default 1.0):")
		label.set_alignment(0, 0.5)
		label_box.pack_start(label, True, True, 0)
		label.show()
		entry_box.pack_start(self.button_saturation, True, True, 2)
		self.button_saturation.show()
		
		label = gtk.Label("Background colour: ")
		label.set_alignment(0, 0.5)
		label_box.pack_start(label, True, False, 0)
		label.show()
		self.colorbutton.set_title("Background colour")
		entry_box.pack_start(self.colorbutton, True, True, 2)
		self.colorbutton.show()
		
		label = gtk.Label("Toolbar button labels:")
		label.set_alignment(0, 0.5)
		label_box.pack_start(label, True, True, 0)
		label.show()
		entry_box.pack_start(self.combobox_tool, True, True, 2)
		self.combobox_tool.show()
		self.combobox_tool.append_text('Icons only')
		self.combobox_tool.append_text('Text only')
		self.combobox_tool.append_text('Icons and text')
		
		label = gtk.Label("")
		label.set_alignment(0, 0)
		general_box.pack_start(label, False, False, 0)
		label.show()
		
		self.button_hide_cursor.connect("toggled", self.options, 15)
		general_box.pack_start(self.button_hide_cursor, True, True, 2)
		self.button_hide_cursor.show()
		
		self.button_flip_page.connect("toggled", self.options, 8)
		general_box.pack_start(self.button_flip_page, True, True, 2)
		self.button_flip_page.show()
		
		self.button_hide_bars.connect("toggled", self.options, 12)
		general_box.pack_start(self.button_hide_bars, True, True, 2)
		self.button_hide_bars.show()
		
		label = gtk.Label("")
		label.set_alignment(0, 0)
		general_box.pack_start(label, False, False, 0)
		label.show()		
		
		label = gtk.Label()
		label.set_markup('\n<b>Scaling</b>\n')
		label.set_alignment(0, 0)
		vbox_scaling.pack_start(label, False, False, 0)
		label.show()
		
		hbox = gtk.HBox(False, 2)
		hbox.show()
		vbox_scaling.pack_start(hbox, False, False, 0)
		
		padding_box = gtk.VBox(False, 0)
		padding_box.set_border_width(10)
		padding_box.show()
		hbox.pack_start(padding_box, False, False, 0)
		
		scaling_box = gtk.VBox(False, 0)
		hbox.pack_start(scaling_box, True, True, 0)
		scaling_box.show()
		
		self.button_stretch.connect("toggled", self.options, 9)
		scaling_box.pack_start(self.button_stretch, True, True, 2)
		self.button_stretch.show()
		
		self.button_smart_scale.connect("toggled", self.options, 19)
		scaling_box.pack_start(self.button_smart_scale, True, True, 2)
		self.button_smart_scale.show()
		
		label = gtk.Label()
		label.set_markup('\n<b>Scaling quality</b>\n')
		label.set_alignment(0, 0)
		vbox_scaling.pack_start(label, False, False, 0)
		label.show()
		
		hbox = gtk.HBox(False, 2)
		hbox.show()
		vbox_scaling.pack_start(hbox, False, False, 0)
		
		padding_box = gtk.VBox(False, 0)
		padding_box.set_border_width(10)
		padding_box.show()
		hbox.pack_start(padding_box, False, False, 0)
		
		button_box = gtk.VBox(True, 0)
		hbox.pack_start(button_box, True, True, 0)
		
		self.button_1.connect("toggled", self.options, 2)
		button_box.pack_start(self.button_1, False, False, 2)
		self.button_1.show()
		
		self.button_2.connect("toggled", self.options, 3)
		button_box.pack_start(self.button_2, False, False, 2)
		self.button_2.show()
		
		self.button_3.connect("toggled", self.options, 4)
		button_box.pack_start(self.button_3, False, False, 2)
		self.button_3.show()
		
		self.button_4.connect("toggled", self.options, 5)
		button_box.pack_start(self.button_4, False, False, 2)
		self.button_4.show()
		
		button_box.show()
		
		self.notebook.insert_page(vbox_scaling, gtk.Label("Display"))
		
		hbox = gtk.HBox(True, 0)
		self.options_window.vbox.pack_start(hbox, False, False, 0)
		hbox.show()
		
		self.button_apply.connect_object("clicked", self.save_and_close_options, None)
		hbox.pack_start(self.button_apply, False, True, 0)
		self.button_apply.show()
		
		alignment = gtk.Alignment(0.0, 0.0, 1.0, 0.0)
		hbox.pack_start(alignment, True, True, 0)
		alignment.show()
		
		button = gtk.Button("Cancel", gtk.STOCK_CANCEL)
		button.connect_object("clicked", self.close_options, None, None)
		hbox.pack_start(button, False, True, 0)
		button.show()
		
		button = gtk.Button("Ok", gtk.STOCK_OK)
		button.connect_object("clicked", self.save_and_close_options, 'close')
		hbox.pack_start(button, False, True, 0)
		button.show()
		
		vbox.show()
		
		# Go-to-page dialog	
		hbox = gtk.HBox(False, 0)
		hbox.set_border_width(5)
		self.page_dialog.vbox.pack_start(hbox, True, True, 10)
		self.page_dialog.set_has_separator(False)
		hbox.show()
		hbox.pack_start(self.button_page_spin, True, True, 0)
		self.button_page_spin.show()
		self.go_to_page_label.set_alignment(0, 1)
		hbox.pack_start(self.go_to_page_label, False, False, 0)
		self.go_to_page_label.show()
		
		# Bookmark dialog
		self.bookmark_dialog.set_has_separator(False)
		box = gtk.VBox(False, 2)
		box.show()
		box.set_border_width(7)
		self.bookmark_dialog.vbox.pack_start(box, True, True, 2)
		box.pack_start(self.bookmark_manager_tree_view, True, True, 2)
		self.bookmark_manager_tree_view.show()
		self.bookmark_column.set_expand(True)
		self.bookmark_column.set_sizing(gtk.TREE_VIEW_COLUMN_AUTOSIZE)
		self.bookmark_column2.set_sizing(gtk.TREE_VIEW_COLUMN_AUTOSIZE)
		self.bookmark_manager_tree_view.append_column(self.bookmark_column)
		self.bookmark_manager_tree_view.append_column(self.bookmark_column2)
		self.bookmark_column.pack_start(self.cell, True)
		self.bookmark_column2.pack_start(self.cell2, True)
		self.bookmark_column.set_attributes(self.cell, text=0)
		self.bookmark_column2.set_attributes(self.cell2, text=1)
		
		# About dialog
		self.about_dialog.set_has_separator(False)
		box = gtk.VBox(False, 0)
		box.set_border_width(5)
		box.show()
		self.about_dialog.vbox.pack_start(box, False, False, 0)
		
		if os.path.exists(os.getenv('XDG_DATA_DIRS', '') + '/pixmaps/comix.png'):
			icon_path = os.getenv('XDG_DATA_DIRS','') + '/pixmaps/comix.png'
		elif os.path.exists(os.getenv('XDG_DATA_DIRS','') + 'pixmaps/comix.png'):
			icon_path = os.getenv('XDG_DATA_DIRS','') + 'pixmaps/comix.png'				
		elif os.path.exists('/usr/local/share/pixmaps/comix.png'):
			icon_path = '/usr/local/share/pixmaps/comix.png'
		elif os.path.exists('/usr/share/pixmaps/comix.png'):
			icon_path = '/usr/share/pixmaps/comix.png'
		
		try:
			icon_pixbuf = gtk.gdk.pixbuf_new_from_file(icon_path)
			icon_image = gtk.Image()
			icon_image.set_from_pixbuf(icon_pixbuf)
			box.pack_start(icon_image, False, False, 10)
			icon_image.show()
		except:
			pass
		
		label = gtk.Label()
		label.set_markup('<big><big><big><b>Comix 2.1</b></big></big></big>\n' + 
		"\n" + 
		"Comix is a comic book viewer. It reads ZIP, RAR and tar archives\n" +
		"(also gzip or bzip2 compressed), as well as plain image files.\n" +
		"\n" +
		"Comix is licensed under the GNU General Public License.\n" +
		"\n" +
		"<small>Copyright © 2005 Pontus Ekberg\n\n" +
		"herrekberg@users.sourceforge.net</small>\n" +
		"<small>http://comix.sourceforge.net</small>\n")
		box.pack_start(label, True, True, 0)
		label.set_justify(gtk.JUSTIFY_CENTER)
		label.show()
		label.set_selectable(True)
		
		# Properties dialog
		vbox = gtk.VBox(True, 2)
		vbox.show()
		vbox.set_border_width(5)
		hbox = gtk.HBox(False, 10)
		hbox.show()
		vbox.pack_start(hbox, True, True, 0)
		hbox.pack_start(self.file_info_label, True, True, 0)
		hbox.pack_start(self.file_info_label2, True, True, 0)
		self.file_dialog.set_has_separator(False)
		self.file_dialog.vbox.pack_start(vbox, True, True, 2)
		self.file_info_label.show()
		self.file_info_label2.show()
		self.file_info_label.set_justify(gtk.JUSTIFY_RIGHT)
		
		# Invalid filename dialog
		self.invalid_filename_dialog.set_has_separator(False)
		hbox = gtk.HBox(False, 10)
		hbox.set_border_width(5)
		hbox.show()
		self.invalid_filename_dialog.vbox.pack_start(hbox, True, True, 0)
		box = gtk.VBox(False, 0)
		box.show()
		hbox.pack_start(box, False, False, 2)
		stock = gtk.image_new_from_stock(gtk.STOCK_DIALOG_ERROR, gtk.ICON_SIZE_DIALOG)
		box.pack_start(stock, False, False, 2)
		stock.show()
		alignment = gtk.Alignment(0.0, 0.0, 0.0, 1.0)
		box.pack_start(alignment, True, True, 0)
		alignment.show()
		hbox.pack_start(self.invalid_filename_info_label, True, True, 2)
		self.invalid_filename_info_label.show()
		
		# Wrong permissions dialog
		self.permission_dialog.set_has_separator(False)
		hbox = gtk.HBox(False, 10)
		hbox.set_border_width(5)
		hbox.show()
		self.permission_dialog.vbox.pack_start(hbox, True, True, 0)
		box = gtk.VBox(False, 0)
		box.show()
		hbox.pack_start(box, False, False, 2)
		stock = gtk.image_new_from_stock(gtk.STOCK_DIALOG_ERROR, gtk.ICON_SIZE_DIALOG)
		box.pack_start(stock, False, False, 2)
		stock.show()
		alignment = gtk.Alignment(0.0, 0.0, 0.0, 1.0)
		box.pack_start(alignment, True, True, 0)
		alignment.show()
		hbox.pack_start(self.permission_label, True, True, 2)
		self.permission_label.show()
		
		# Convert dialog
		self.convert_dialog.set_has_separator(False)
		box = gtk.VBox(False, 0)
		box.show()
		self.convert_dialog.vbox.pack_start(box, False, False, 0)
		box.set_border_width(5)
		self.combobox_convert.append_text('Select new archive type:')
		box.pack_start(self.combobox_convert, False, False, 7)
		self.combobox_convert.show()
		label = gtk.Label('\nNew filename:')
		label.set_alignment(0, 0)
		box.pack_start(label)
		label.show()
		box.pack_start(self.filename_entry)
		self.filename_entry.show()
		box.pack_start(self.button_delete_archive)
		self.button_delete_archive.connect("toggled", self.options, None)
		self.button_delete_archive.show()
		label = gtk.Label('\n')
		box.pack_start(label)
		label.show()
		
		# Overwrite dialog
		self.overwrite_dialog.set_has_separator(False)
		hbox = gtk.HBox(False, 10)
		hbox.set_border_width(5)
		hbox.show()
		self.overwrite_dialog.vbox.pack_start(hbox, True, True, 0)
		box = gtk.VBox(False, 0)
		box.show()
		hbox.pack_start(box, False, False, 2)
		stock = gtk.image_new_from_stock(gtk.STOCK_DIALOG_WARNING, gtk.ICON_SIZE_DIALOG)
		box.pack_start(stock, False, False, 2)
		stock.show()
		alignment = gtk.Alignment(0.0, 0.0, 0.0, 1.0)
		box.pack_start(alignment, True, True, 0)
		alignment.show()
		hbox.pack_start(self.overwrite_label, True, True, 2)
		self.overwrite_label.show()
	
	def close_application(self, widget, event):
		
		self.window.show()
		self.optionlist[12], self.optionlist[13] = self.window.get_position()
		
		if os.path.exists(self.base_dir):
			shutil.rmtree(self.base_dir)
			
			if len(os.listdir('/tmp/comix')) == 0:
				shutil.rmtree('/tmp/comix')
				
		gtk.main_quit()
		return False
		
	def short_close_application(self, event):
		
		self.close_application(None, None)
	
	def key_press_event(self, widget, event, data=None):
		
		self.scroll_events_down = 0
		self.scroll_events_up = 0
		
		if self.optionlist[0]:
			menu_size = abs(self.optionlist[3] - 1) * self.optionlist[25] * self.ui.get_widget('/Menu').size_request()[1]
			tool_size = abs(self.optionlist[3] - 1) * self.optionlist[26] * self.toolbar.size_request()[1]
			status_size = abs(self.optionlist[3] - 1) * self.optionlist[27] * self.statusbar.size_request()[1]
			
		else:
			menu_size = self.optionlist[25] * self.ui.get_widget('/Menu').size_request()[1]
			tool_size = self.optionlist[26] * self.toolbar.size_request()[1]
			status_size = self.optionlist[27] * self.statusbar.size_request()[1]
		
		if event.keyval == gtk.keysyms.Escape:
			
			if self.optionlist[0] == 1:
				
				self.actiongroup.get_action('Fullscreen').set_active(False)	
			
		elif event.keyval == gtk.keysyms.Down:
			
			if self.optionlist[18] == 0 or self.show_comments:
				
				height = self.layout.get_size()[1]
				
				if (self.vadjust.get_value() + 20 > height - self.window.get_size()[1] + self.hscroll.size_request()[1]
				- self.hscroll.size_request()[1] * self.optionlist[22] + menu_size + tool_size + status_size):
					
					self.vadjust.set_value(height - self.window.get_size()[1] + self.hscroll.size_request()[1] - self.hscroll.size_request()[1] 
					* self.optionlist[22] + menu_size + tool_size + status_size)
					
				else:
					
					self.vadjust.set_value(self.vadjust.get_value() + 20)
			
		elif event.keyval == gtk.keysyms.Up:
			
			if self.optionlist[18] == 0 or self.show_comments:
				
				if self.vadjust.get_value() - 20 < 0:
					
					self.vadjust.set_value(0)
					
				else:
					
					self.vadjust.set_value(self.vadjust.get_value() - 20)	
					
		elif event.keyval == gtk.keysyms.Right:
			
			if self.optionlist[18] == 0 or self.show_comments:
				
				if (self.hadjust.get_value() + 20 > self.layout.get_size()[0] - self.window.get_size()[0] + self.vscroll.size_request()[0]
				- self.vscroll.size_request()[0] * self.optionlist[22]):
					
					self.hadjust.set_value(self.layout.get_size()[0] - self.window.get_size()[0] + self.vscroll.size_request()[0] - self.vscroll.size_request()[0] * self.optionlist[22])
					
				else:
					
					self.hadjust.set_value(self.hadjust.get_value() + 20)
					
		elif event.keyval == gtk.keysyms.Left:
			
			if self.optionlist[18] == 0 or self.show_comments:
				
				if self.hadjust.get_value() - 20 < 0:
					
					self.hadjust.set_value(0)
					
				else:
					
					self.hadjust.set_value(self.hadjust.get_value() - 20)
					
		elif event.keyval == gtk.keysyms.space:
			
			if self.optionlist[18] == 1 and not self.show_comments:
				
				self.next_page(None)
				
			else:
				
				height = self.layout.get_size()[1]
				
				if (self.vadjust.get_value() + 20 > height - self.window.get_size()[1] + self.hscroll.size_request()[1] 
				- self.hscroll.size_request()[1] * self.optionlist[22] + menu_size + tool_size + status_size):
						
					self.vadjust.set_value(height - self.window.get_size()[1] + self.hscroll.size_request()[1] - self.hscroll.size_request()[1] *
					self.optionlist[22] + menu_size + tool_size + status_size)
				
				if (self.vadjust.get_value() >= height - self.window.get_size()[1] + self.hscroll.size_request()[1] - self.hscroll.size_request()[1] 
				* self.optionlist[22] + menu_size + tool_size + status_size):
					
					self.next_page(None)
					
				else:
					
					if (self.vadjust.get_value() + self.window.get_size()[1] - self.hscroll.size_request()[1] + self.hscroll.size_request()[1] * self.optionlist[22]
					- menu_size - tool_size > 
					height - self.window.get_size()[1] + self.hscroll.size_request()[1] - self.hscroll.size_request()[1] * self.optionlist[22]
					+ menu_size + tool_size + status_size):
						
						self.vadjust.set_value(height - self.window.get_size()[1] + self.hscroll.size_request()[1] - self.hscroll.size_request()[1] 
						* self.optionlist[22] + menu_size + tool_size + status_size)
						
					else:
						
						self.vadjust.set_value(self.vadjust.get_value() + self.window.get_size()[1] - self.hscroll.size_request()[1] + self.hscroll.size_request()[1] 
						* self.optionlist[22] - menu_size 
						- tool_size - status_size)	
	
	def scroll_wheel_event(self, view, event, data=None):
		
		if self.optionlist[0]:
			menu_size = abs(self.optionlist[3] - 1) * self.optionlist[25] * self.ui.get_widget('/Menu').size_request()[1]
			tool_size = abs(self.optionlist[3] - 1) * self.optionlist[26] * self.toolbar.size_request()[1]
			status_size = abs(self.optionlist[3] - 1) * self.optionlist[27] * self.statusbar.size_request()[1]
			
		else:
			menu_size = self.optionlist[25] * self.ui.get_widget('/Menu').size_request()[1]
			tool_size = self.optionlist[26] * self.toolbar.size_request()[1]
			status_size = self.optionlist[27] * self.statusbar.size_request()[1]
		
		if event.direction == gtk.gdk.SCROLL_UP:
			
			self.scroll_events_down = 0
			
			if self.optionlist[18] == 1 and not self.show_comments:
				
				self.previous_page(None)
				
			else:
				
				if self.vadjust.get_value() <= 0:
					
					if self.optionlist[31] and self.hadjust.get_value() > 0 and not self.optionlist[8]:
						
						if self.hadjust.get_value() - 40 <= 0:
							self.hadjust.set_value(0)
							
						else:
							self.hadjust.set_value(self.hadjust.get_value() - 40)
							
					elif (self.optionlist[31] and self.hadjust.get_value() < self.layout.get_size()[0] - self.window.get_size()[0] + 
					self.vscroll.size_request()[0] - self.vscroll.size_request()[0] * self.optionlist[22] and self.optionlist[8]):
						
						if (self.hadjust.get_value() + 40 > self.layout.get_size()[0] - self.window.get_size()[0] + self.vscroll.size_request()[0]
						- self.vscroll.size_request()[0] * self.optionlist[22]):
							
							self.hadjust.set_value(self.layout.get_size()[0] - self.window.get_size()[0] + self.vscroll.size_request()[0] - self.vscroll.size_request()[0] * self.optionlist[22])
							
						else:
							
							self.hadjust.set_value(self.hadjust.get_value() + 40)
							
					elif self.optionlist[30]:
						
						self.scroll_events_up += 1
						
						if self.scroll_events_up > 2:
							self.previous_page(None)
							self.scroll_events_up = 0
				
				elif self.vadjust.get_value() - 40 < 0:
					
					self.vadjust.set_value(0)
					
				else:
					
					self.vadjust.set_value(self.vadjust.get_value() - 40)	
			
		elif event.direction == gtk.gdk.SCROLL_DOWN:
			
			self.scroll_events_up = 0
			
			if self.optionlist[18] == 1 and not self.show_comments:
				
				self.next_page(None)
				
			else:
				
				if (self.vadjust.get_value() >= self.layout.get_size()[1] - self.window.get_size()[1] + self.hscroll.size_request()[1] - 
				self.hscroll.size_request()[1] * self.optionlist[22] + menu_size + tool_size + status_size):
					
					if self.optionlist[31] and self.hadjust.get_value() > 0 and self.optionlist[8]:
						
						if self.hadjust.get_value() - 40 <= 0:
							self.hadjust.set_value(0)
							
						else:
							self.hadjust.set_value(self.hadjust.get_value() - 40)
							
					elif (self.optionlist[31] and self.hadjust.get_value() < self.layout.get_size()[0] - self.window.get_size()[0] + 
					self.vscroll.size_request()[0] - self.vscroll.size_request()[0] * self.optionlist[22] and not self.optionlist[8]):
						
						if (self.hadjust.get_value() + 40 > self.layout.get_size()[0] - self.window.get_size()[0] + self.vscroll.size_request()[0]
						- self.vscroll.size_request()[0] * self.optionlist[22]):
							
							self.hadjust.set_value(self.layout.get_size()[0] - self.window.get_size()[0] + self.vscroll.size_request()[0] - self.vscroll.size_request()[0] * self.optionlist[22])
							
						else:
							
							self.hadjust.set_value(self.hadjust.get_value() + 40)
							
					elif self.optionlist[30]:
						
						self.scroll_events_down += 1
						
						if self.scroll_events_down > 2:
							self.next_page(None)
							self.scroll_events_down = 0
					
				elif (self.vadjust.get_value() + 40 > self.layout.get_size()[1] - self.window.get_size()[1] + self.hscroll.size_request()[1] - self.hscroll.size_request()[1] * self.optionlist[22]
				+ menu_size + tool_size + status_size):
					
					self.vadjust.set_value(self.layout.get_size()[1] - self.window.get_size()[1] + self.hscroll.size_request()[1] - self.hscroll.size_request()[1] * self.optionlist[22]
					+ menu_size + tool_size + status_size)
					
				else:
					
					self.vadjust.set_value(self.vadjust.get_value() + 40)
					
		elif event.direction == gtk.gdk.SCROLL_LEFT:
			
			self.previous_page(None)
		
		elif event.direction == gtk.gdk.SCROLL_RIGHT:
			
			self.next_page(None)			

	def area_resize_event(self, widget, allocation):
		
		if allocation.width != self.optionlist[10] or allocation.height != self.optionlist[11]:
			
			self.optionlist[10] = allocation.width
			self.optionlist[11] = allocation.height
			self.resize_event = 1
			self.refresh_image()
			self.resize_event = 0
			
	def drag_image(self, widget, event):		
		
		if not self.show_comments:
			
			self.mouse_moved = 1
			
			for x in gtk.gdk.window_get_toplevels():
				x.set_cursor(gtk.gdk.Cursor(gtk.gdk.FLEUR))
			
			if self.optionlist[18] == 0 or self.show_comments:
				
				self.motion_number += 1
				
				if self.motion_number > 1:
					
					if self.old_vadjust_value - event.y_root + self.y_motion > self.vadjust_upper:
					
						self.vadjust.set_value(self.vadjust_upper)
						self.y_motion = event.y_root
						self.old_vadjust_value = self.vadjust.value
						
					elif self.old_vadjust_value - event.y_root + self.y_motion < 0:
						
						self.vadjust.set_value(0)
						self.y_motion = event.y_root
						self.old_vadjust_value = self.vadjust.value
						
					else:
						
						self.vadjust.set_value(self.old_vadjust_value - event.y_root + self.y_motion)
						
					if self.old_hadjust_value - event.x_root + self.x_motion > self.hadjust_upper:
						
						self.hadjust.set_value(self.hadjust_upper)
						self.x_motion = event.x_root
						self.old_hadjust_value = self.hadjust.value
						
					elif self.old_hadjust_value - event.x_root + self.x_motion < 0:
						
						self.hadjust.set_value(0)
						self.x_motion = event.x_root
						self.old_hadjust_value = self.hadjust.value
					
					else:
						
						self.hadjust.set_value(self.old_hadjust_value - event.x_root + self.x_motion)
						
					self.motion_number = 0
		
	def button_release(self, widget, event):
		
		if not self.show_comments:
			
			if self.optionlist[24] and self.optionlist[0]:
				
				pixmap = gtk.gdk.Pixmap(None, 1, 1, 1)
				color = gtk.gdk.Color()
				cursor = gtk.gdk.Cursor(pixmap, pixmap, color, color, 0, 0)
				for x in gtk.gdk.window_get_toplevels():
					x.set_cursor(None)
				gtk.gdk.window_get_toplevels()[1].set_cursor(cursor)
				
				
			else:
				
				for x in gtk.gdk.window_get_toplevels():
					x.set_cursor(None)
					
			if self.mouse_moved == 0 and event.button == 1:
				
				self.next_page(None)
		
	def fullscreen_switch(self, event):
		
		if self.optionlist[0]:
			
			self.optionlist[0] = 0
			self.window.unfullscreen()
			
		else:
			
			self.optionlist[0] = 1
			self.window.fullscreen()			
			
	def double_page_switch(self, event):
		
		if self.optionlist[4] == 1:
			
			self.optionlist[4] = 0
			
		else:
			
			self.optionlist[4] = 1
			
		self.refresh_image()
		
	def fit_to_screen_switch(self, event):
		
		if self.optionlist[18] == 1:
			
			self.optionlist[18] = 0
			self.actiongroup.get_action('Zin').set_sensitive(True)
			self.actiongroup.get_action('Zout').set_sensitive(True)
			self.actiongroup.get_action('Zoriginal').set_sensitive(True)
			self.actiongroup.get_action('Zwidth').set_sensitive(True)
			self.actiongroup.get_action('Zheight').set_sensitive(True)
			self.actiongroup.get_action('Zfit').set_sensitive(True)
			self.actiongroup.get_action('Scrollbars').set_sensitive(True)
			self.button_zin.set_sensitive(True)
			self.button_zout.set_sensitive(True)
			self.button_z100.set_sensitive(True)
			self.button_zfit.set_sensitive(True)
			
		else:
			
			self.optionlist[18] = 1
			self.actiongroup.get_action('Zin').set_sensitive(False)
			self.actiongroup.get_action('Zout').set_sensitive(False)
			self.actiongroup.get_action('Zoriginal').set_sensitive(False)
			self.actiongroup.get_action('Zwidth').set_sensitive(False)
			self.actiongroup.get_action('Zheight').set_sensitive(False)
			self.actiongroup.get_action('Zfit').set_sensitive(False)
			self.actiongroup.get_action('Scrollbars').set_sensitive(False)
			self.button_zin.set_sensitive(False)
			self.button_zout.set_sensitive(False)
			self.button_z100.set_sensitive(False)
			self.button_zfit.set_sensitive(False)
			
		self.change_adjustment = 1
		self.refresh_image()
		
	def menubar_switch(self, event):
		
		if self.optionlist[25] == 1:
			
			self.optionlist[25] = 0
			
		else:
			
			self.optionlist[25] = 1
			
		self.refresh_image()
		
	def toolbar_switch(self, event):
		
		if self.optionlist[26] == 1:
			
			self.optionlist[26] = 0
			
		else:
			
			self.optionlist[26] = 1
			
		self.refresh_image()
		
	def statusbar_switch(self, event):
		
		if self.optionlist[27] == 1:
			
			self.optionlist[27] = 0
			
		else:
			
			self.optionlist[27] = 1
			
		self.refresh_image()
		
	def scrollbars_switch(self, event):
		
		if self.optionlist[22] == 1:
			
			self.optionlist[22] = 0
			
		else:
			
			self.optionlist[22] = 1
			
		self.refresh_image()
		
	def comment_switch(self, event):
		
		if len(self.comment) > 0:
			
			if self.show_comments:
				
				self.show_comments = 0
				
			else:
				
				self.show_comments = 1
				self.comment_number = 0
				
			self.refresh_image()
		
	def zoom_in(self, event):
		
		if self.optionlist[18] == 0:
			
			if self.optionlist[17] * 1.15 > 5000:
				
				self.optionlist[17] = 5000
				
			else:
				
				self.optionlist[17] = self.optionlist[17] * 1.15
				
			self.refresh_image()
			
	def zoom_out(self, event):
		
		if self.optionlist[18] == 0:
			
			if self.optionlist[17] * 0.85 < 10:
				
				self.optionlist[17] = 10
				
			else:
				
				self.optionlist[17] = self.optionlist[17] * 0.85
				
			self.refresh_image()
			
	def zoom_original(self, event):
		
		if self.optionlist[18] == 0:
			
			self.optionlist[17] = 100
			self.refresh_image()
			
	def zoom_width(self, event):
		
		if self.optionlist[0] and self.optionlist[3]:
			vscroll_size = 0
			
		else:
			vscroll_size = self.vscroll.size_request()[0] * (1 - self.optionlist[22])
		
		if self.optionlist[18] == 0 and self.file_exist == 1:
			
			if self.optionlist[4] == 0:
				
				self.optionlist[17] = 100.0 * (self.window.get_size()[0] - vscroll_size) / self.image1_width
				
			else:
				
				self.optionlist[17] = 100.0 * (self.window.get_size()[0] - vscroll_size) / (self.image1_width + self.image2_width)
				
			self.refresh_image()
			
	def zoom_height(self, event):
		
		if self.optionlist[18] == 0 and self.file_exist == 1:
			
			if self.optionlist[0] and self.optionlist[3]:
				menu_size = 0
				tool_size = 0
				status_size = 0
				hscroll_size = 0
				
			else:
				menu_size = self.optionlist[25] * self.ui.get_widget('/Menu').size_request()[1]
				tool_size = self.optionlist[26] * self.toolbar.size_request()[1]
				status_size = self.optionlist[27] * self.statusbar.size_request()[1]
				hscroll_size = self.hscroll.size_request()[1] * (1 - self.optionlist[22])
			
			if self.optionlist[4] == 0:
				
				self.optionlist[17] = (100.0 * (self.window.get_size()[1] - hscroll_size - menu_size - tool_size - status_size) / self.image1_height)
				
			else:
				
				if self.image1_height > self.image2_height:
					
					height = self.image1_height
					
				else:
					
					height = self.image2_height
					
				self.optionlist[17] = (100.0 * (self.window.get_size()[1] - hscroll_size - menu_size - tool_size - status_size) / height)
				
			self.refresh_image()
			
	def zoom_fit(self, event):
		
		if self.optionlist[18] == 0 and self.file_exist == 1:
			
			if self.optionlist[0] and self.optionlist[3]:
				menu_size = 0
				tool_size = 0
				status_size = 0
				hscroll_size = 0
				vscroll_size = 0
				
			else:
				menu_size = self.optionlist[25] * self.ui.get_widget('/Menu').size_request()[1]
				tool_size = self.optionlist[26] * self.toolbar.size_request()[1]
				status_size = self.optionlist[27] * self.statusbar.size_request()[1]
				hscroll_size = self.hscroll.size_request()[1] * (1 - self.optionlist[22])
				vscroll_size = self.vscroll.size_request()[0] * (1 - self.optionlist[22])
			
			if self.optionlist[4] == 0:
				
				if (100.0 * (self.window.get_size()[0] - vscroll_size) / self.image1_width 
				< 100.0 * (self.window.get_size()[1] - hscroll_size - menu_size - tool_size - status_size) / self.image1_height):
					
					self.optionlist[17] = 100.0 * (self.window.get_size()[0] - vscroll_size) / self.image1_width
					
				else:
					
					self.optionlist[17] = (100.0 * (self.window.get_size()[1] - hscroll_size - menu_size - tool_size - status_size) / self.image1_height)
					
			else:
				
				if self.image1_height > self.image2_height:
					
					height = self.image1_height
					
				else:
					
					height = self.image2_height
				
				if (100.0 * (self.window.get_size()[0] - vscroll_size) 
				/ (self.image1_width + self.image2_width) < 100.0 * (self.window.get_size()[1] - hscroll_size - menu_size - tool_size - status_size) / height):
					
					self.optionlist[17] = (100.0 * (self.window.get_size()[0] - vscroll_size) / (self.image1_width + self.image2_width))
					
				else:
					
					self.optionlist[17] = (100.0 * (self.window.get_size()[1] - hscroll_size - menu_size - tool_size - status_size) / height)
					
			self.refresh_image()
				
	def next_page(self, event):
		
		if self.show_comments:
			
			if self.comment_number < len(self.comment) - 1:
				
				self.comment_number = self.comment_number + 1
				self.change_adjustment = 1
				self.refresh_image()
				
			else:
				
				self.show_comments = 0
				self.change_adjustment = 1
				self.refresh_image()
		
		else:
			
			if self.optionlist[4] == 0:
				
				if self.file_number < len(self.file) - 1:
					
					self.file_number = self.file_number + 1
					self.change_adjustment = 1
					self.refresh_image()
					
				elif self.archive_type != "" and self.optionlist[23] == 1:
					
					temp_list = os.listdir(os.path.dirname(self.path))
					directory_list = []
					
					for file in temp_list:
						
						if os.path.isfile(os.path.dirname(self.path) + '/' + file):
							
							if (zipfile.is_zipfile(os.path.dirname(self.path) + '/' + file) or tarfile.is_tarfile(os.path.dirname(self.path) + '/' + file)
							or self.archive_mime_type(os.path.dirname(self.path) + '/' + file) == 'rar'):
								
								directory_list.append(file)
						
					directory_list.sort(locale.strcoll)
					
					if directory_list.count(os.path.basename(self.path)) > 0:
						
						while(True):
							
							if directory_list.index(os.path.basename(self.path)) < len(directory_list) - 1:
								
								if os.path.isfile(os.path.dirname(self.path) + '/' + directory_list[directory_list.index(os.path.basename(self.path)) + 1]):
									
									self.load_file(os.path.dirname(self.path) + '/' + directory_list[directory_list.index(os.path.basename(self.path)) + 1])
									
									if self.file_exist == 1:
										
										self.refresh_image()
										break
								
							else:
								
								break
							
			else:
				
				if self.file_number < len(self.file) - 2:
					
					self.file_number = self.file_number + 2
					self.change_adjustment = 1
					self.refresh_image()
					
				elif self.archive_type != "" and self.optionlist[23] == 1:
					
					temp_list = os.listdir(os.path.dirname(self.path))
					directory_list = []
					
					for file in temp_list:
						
						if os.path.isfile(os.path.dirname(self.path) + '/' + file):
							
							if (zipfile.is_zipfile(os.path.dirname(self.path) + '/' + file) or tarfile.is_tarfile(os.path.dirname(self.path) + '/' + file)
							or self.archive_mime_type(os.path.dirname(self.path) + '/' + file) == 'rar'):
								
								directory_list.append(file)
						
					directory_list.sort(locale.strcoll)
					
					if directory_list.count(os.path.basename(self.path)) > 0:
						
						while(True):
							
							if directory_list.index(os.path.basename(self.path)) < len(directory_list) - 1:
								
								if os.path.isfile(os.path.dirname(self.path) + '/' + directory_list[directory_list.index(os.path.basename(self.path)) + 1]):
									
									self.load_file(os.path.dirname(self.path) + '/' + directory_list[directory_list.index(os.path.basename(self.path)) + 1])
									
									if self.file_exist == 1:
										
										self.refresh_image()
										break
								
							else:
								
								break
		
	def previous_page(self, event):
		
		if self.show_comments:
			
			if self.comment_number > 0:
				
				self.comment_number = self.comment_number - 1
				self.change_adjustment = 1
				self.refresh_image()
		
		else:
			
			if self.optionlist[4] == 0:
				
				if self.file_number > 0:
					
					self.file_number = self.file_number - 1
					self.change_adjustment = 1
					self.refresh_image()
					
				elif self.archive_type != "" and self.optionlist[23] == 1:
					
					temp_list = os.listdir(os.path.dirname(self.path))
					directory_list = []
					
					for file in temp_list:
						
						if os.path.isfile(os.path.dirname(self.path) + '/' + file):
							
							if (zipfile.is_zipfile(os.path.dirname(self.path) + '/' + file) or tarfile.is_tarfile(os.path.dirname(self.path) + '/' + file)
							or self.archive_mime_type(os.path.dirname(self.path) + '/' + file) == 'rar'):
								
								directory_list.append(file)
						
					directory_list.sort(locale.strcoll)
					directory_list.reverse()
					
					if directory_list.count(os.path.basename(self.path)) > 0:
						
						while(True):
							
							if directory_list.index(os.path.basename(self.path)) < len(directory_list) - 1:
								
								if os.path.isfile(os.path.dirname(self.path) + '/' + directory_list[directory_list.index(os.path.basename(self.path)) + 1]):
									
									self.load_file(os.path.dirname(self.path) + '/' + directory_list[directory_list.index(os.path.basename(self.path)) + 1])
									
									if self.file_exist == 1:
										
										self.file_number = len(self.file) - 1
										self.refresh_image()
										break
								
							else:
								
								break
					
			else:
				
				if self.file_number > 1:
					
					self.file_number = self.file_number - 2
					self.change_adjustment = 1
					self.refresh_image()
					
				else:
					
					if self.file_number > 0:
					
						self.file_number = self.file_number - 1
						self.refresh_image()
						
					elif self.archive_type != "" and self.optionlist[23] == 1:
						
						temp_list = os.listdir(os.path.dirname(self.path))
						directory_list = []
						
						for file in temp_list:
							
							if os.path.isfile(os.path.dirname(self.path) + '/' + file):
								
								if (zipfile.is_zipfile(os.path.dirname(self.path) + '/' + file) or tarfile.is_tarfile(os.path.dirname(self.path) + '/' + file)
								or self.archive_mime_type(os.path.dirname(self.path) + '/' + file) == 'rar'):
									
									directory_list.append(file)
							
						directory_list.sort(locale.strcoll)
						directory_list.reverse()
						
						if directory_list.count(os.path.basename(self.path)) > 0:
							
							while(True):
								
								if directory_list.index(os.path.basename(self.path)) < len(directory_list) - 1:
									
									if os.path.isfile(os.path.dirname(self.path) + '/' + directory_list[directory_list.index(os.path.basename(self.path)) + 1]):
										
										self.load_file(os.path.dirname(self.path) + '/' + directory_list[directory_list.index(os.path.basename(self.path)) + 1])
										
										if self.file_exist == 1:
											
											if len(self.file) > 1:
												
												self.file_number = len(self.file) - 2
												
											else:
												
												self.file_number = len(self.file) - 1
												
											self.refresh_image()
											break
									
								else:
									
									break
			
	def first_page(self, event):
		
		self.file_number = 0
		self.change_adjustment = 1
		self.refresh_image()
		
	def last_page(self, event):
		
		self.file_number = len(self.file) - 1
		self.change_adjustment = 1
		self.refresh_image()
		
	def open_go_to_page(self, event):
		
		self.button_page_spin.set_range(1, len(self.file))
		self.button_page_spin.set_value(self.file_number + 1)
		self.button_page_spin.grab_focus()
		command = " of " + str(len(self.file))
		self.go_to_page_label.set_text(command)		
		self.page_dialog.show()
		
	def save_and_close_go_to_page(self, event, data):
		
		self.page_dialog.hide()
		
		if data == -5:
			
			if int(self.button_page_spin.get_value()) > 0 and int(self.button_page_spin.get_value()) <= len(self.file):
				
				self.show_comments = 0
				self.file_number = int(self.button_page_spin.get_value()) - 1
				self.change_adjustment = 1
				self.refresh_image()
		
	def close_go_to_page(self, event, data=None):
		
		self.page_dialog.hide()
		return True
		
	def open_bookmark_manager(self, event):
		
		self.bookmark_dialog.resize(50, 200)
		self.liststore.clear()
		
		for i, bookmark in enumerate(self.bookmarks):
			
			dir = 0
			
			if not os.path.isdir(bookmark):
				if gtk.gdk.pixbuf_get_file_info(bookmark) != None:
					if (gtk.gdk.pixbuf_get_file_info(bookmark)[0]['mime_types'][0] in 
					['image/jpeg', 'image/bmp', 'image/gif', 'image/png', 'image/tiff', 'image/x-icon', 'image/x-xpixmap', 'image/x-xbitmap']):
						
						dir = 1
						self.liststore.append([unicode(os.path.basename(os.path.dirname(bookmark)), sys.getfilesystemencoding()), str(self.bookmark_numbers[i])])
						
				if not dir:
					self.liststore.append([unicode(os.path.basename(bookmark), sys.getfilesystemencoding()), str(self.bookmark_numbers[i])])
					
		if len(self.bookmarks) == 0:
			self.bookmark_dialog.action_area.get_children()[1].set_sensitive(False)
		else:
			self.bookmark_dialog.action_area.get_children()[1].set_sensitive(True)
			
		if self.file_exist:
			self.bookmark_dialog.action_area.get_children()[2].set_sensitive(True)
		else:
			self.bookmark_dialog.action_area.get_children()[2].set_sensitive(False)
		
		self.bookmark_dialog.show()
	
	def save_and_close_bookmark_manager(self, event, data):
		
		if data == -5:
			self.bookmark_dialog.hide()
			
		elif data == -9:
			if len(self.bookmark_manager_tree_view.get_selection().get_selected_rows()[1]) > 0:
				self.bookmarks.pop(self.bookmark_manager_tree_view.get_selection().get_selected_rows()[1][0][0])
				self.bookmark_numbers.pop(self.bookmark_manager_tree_view.get_selection().get_selected_rows()[1][0][0])
			
			self.liststore.clear()
			
			for i, bookmark in enumerate(self.bookmarks):
				
				dir = 0
				
				if not os.path.isdir(bookmark):
					if gtk.gdk.pixbuf_get_file_info(bookmark) != None:
						if (gtk.gdk.pixbuf_get_file_info(bookmark)[0]['mime_types'][0] in 
						['image/jpeg', 'image/bmp', 'image/gif', 'image/png', 'image/tiff', 'image/x-icon', 'image/x-xpixmap', 'image/x-xbitmap']):
							
							dir = 1
							self.liststore.append([unicode(os.path.basename(os.path.dirname(bookmark)), sys.getfilesystemencoding()), str(self.bookmark_numbers[i])])
					
					if not dir:
						self.liststore.append([unicode(os.path.basename(bookmark), sys.getfilesystemencoding()), str(self.bookmark_numbers[i])])
			
			self.update_bookmarks()
			
		elif data == -8:
			
			self.save_bookmark(None)
		
	def close_bookmark_manager(self, event, data=None):
		
		self.bookmark_dialog.hide()
		return True
		
	def open_filechooser(self, data):
		
		if os.path.isdir(self.temp_optionlist[15]):
			self.filechooser_dialog.set_current_folder(self.temp_optionlist[15])
		else:
			self.filechooser_dialog.set_current_folder(os.getenv('HOME'))
		response = self.filechooser_dialog.run()
		
		if int(response) == int(gtk.RESPONSE_OK):
			
			if len(unicode(self.filechooser_dialog.get_filename(), sys.getfilesystemencoding())) > 50:
				self.filechooser_button.set_label('... ' + unicode(self.filechooser_dialog.get_filename(), sys.getfilesystemencoding())[-47:])
			else:
				self.filechooser_button.set_label(unicode(self.filechooser_dialog.get_filename(), sys.getfilesystemencoding()))
			
			self.temp_optionlist[15] = self.filechooser_dialog.get_filename()
			
		self.filechooser_dialog.hide()
			
	def close_filechooser(self, event, data=None):
		
		self.filechooser_dialog.hide()
		return True
	
	def open_convert(self, event):
		
		while len(self.combobox_convert.get_model()) > 1:
			
			for i in range(len(self.combobox_convert.get_model()) - 1):
				
				self.combobox_convert.remove_text(i + 1)
				break
			
		if self.archive_type in ['', 'RAR archive']:
			
			self.combobox_convert.append_text('Zip archive')
			self.combobox_convert.append_text('Tar archive')
			self.combobox_convert.append_text('Gzip compressed tar archive')
			self.combobox_convert.append_text('Bzip2 compressed tar archive')
			
		elif self.archive_type in ['Zip archive']:
			
			self.combobox_convert.append_text('Tar archive')
			self.combobox_convert.append_text('Gzip compressed tar archive')
			self.combobox_convert.append_text('Bzip2 compressed tar archive')
			
		elif self.archive_type in ['Tar archive']:
			
			self.combobox_convert.append_text('Zip archive')
			self.combobox_convert.append_text('Gzip compressed tar archive')
			self.combobox_convert.append_text('Bzip2 compressed tar archive')
			
		elif self.archive_type in ['Gzip compressed tar archive']:
			
			self.combobox_convert.append_text('Zip archive')
			self.combobox_convert.append_text('Tar archive')
			self.combobox_convert.append_text('Bzip2 compressed tar archive')
			
		elif self.archive_type in ['Bzip2 compressed tar archive']:
			
			self.combobox_convert.append_text('Zip archive')
			self.combobox_convert.append_text('Tar archive')
			self.combobox_convert.append_text('Gzip compressed tar archive')
			
		self.combobox_convert.set_active(0)
		self.filename_entry.set_sensitive(False)
		self.convert_dialog.show()
		self.filename_entry.set_text('')
		self.dir_removed = 0
		
	def save_and_close_convert(self, event, data):
		
		self.convert_dialog.hide()
		
		if data == -5:
			
			if ('/' in self.filename_entry.get_text() or len(self.filename_entry.get_text()) <= 0
			or self.filename_entry.get_text() == '.' or self.filename_entry.get_text() == '..'):
				
				self.open_invalid_filename(self.filename_entry.get_text())
				return 0
			
			if self.combobox_convert.get_active() >= 0:
				
				if self.file_removed == 0:
					
					if os.path.exists(self.base_dir + 'convert'):
						shutil.rmtree(self.base_dir + 'convert')
					
					if self.archive_type == '':
						
						shutil.copytree(os.path.dirname(self.path), self.base_dir + 'convert/')
					
					else:
						
						os.mkdir(self.base_dir + 'convert')
						
						if zipfile.is_zipfile(self.path):
							
							zip = zipfile.ZipFile(self.path)
							zipfiles = zip.namelist()
							
							for x in zipfiles:
								if zip.getinfo(x).file_size > 0:
									if not os.path.exists(os.path.dirname(self.base_dir + 'convert/' + x)):
										os.makedirs(os.path.dirname(self.base_dir + 'convert/' + x))
									new = open(self.base_dir + 'convert/' + x, 'w')
									new.write(zip.read(x))
									new.close()
								
							zip.close()
							
						elif tarfile.is_tarfile(self.path):
							
							tar = tarfile.open(self.path, 'r')
							tarfiles = tar.getmembers()
							
							for x in tarfiles:
								tar.extract(x, self.base_dir + 'convert/')
								
							tar.close()
							
						elif self.archive_mime_type(self.path) == 'rar':
							
							os.popen('unrar x "' + self.path + '" ' + self.base_dir + 'convert')
					
				if self.archive_type == '':
					
					if os.path.exists(os.path.dirname(os.path.dirname(self.path)) + '/' + self.filename_entry.get_text()):
						
						if (self.button_delete_archive.get_active() and os.path.dirname(os.path.dirname(self.path))
						+ '/' + self.filename_entry.get_text() == os.path.dirname(self.path)):
							
							try:
								
								if os.path.isdir(os.path.dirname(os.path.dirname(self.path)) + '/' + self.filename_entry.get_text()):
									shutil.rmtree(os.path.dirname(os.path.dirname(self.path)) + '/' + self.filename_entry.get_text())
									
								else:
									os.remove(os.path.dirname(os.path.dirname(self.path)) + '/' + self.filename_entry.get_text())
								
							except:
								
								self.open_permission_dialog(os.path.dirname(os.path.dirname(self.path)))
								return 0
							
						else:
							
							self.overwrite_label.set_markup('<big><b>File exists</b></big>\n\n' + 
							self.filename_entry.get_text() + ' already exists.\nOverwrite?')
							self.overwrite_dialog.show()
							return 0
				
				else:
					
					if os.path.exists(os.path.dirname(self.path) + '/' + self.filename_entry.get_text()):
						
						if (self.button_delete_archive.get_active() and os.path.dirname(self.path) 
						+ '/' + self.filename_entry.get_text() == self.path):
							
							try:
								
								if os.path.isdir(os.path.dirname(self.path) + '/' + self.filename_entry.get_text()):
									shutil.rmtree(os.path.dirname(self.path) + '/' + self.filename_entry.get_text())
									
								else:
									os.remove(os.path.dirname(self.path) + '/' + self.filename_entry.get_text())
									
							except:
								
								self.open_permission_dialog(os.path.dirname(self.path) + '/' + self.filename_entry.get_text())
								return 0
							
						else:
							
							self.overwrite_label.set_markup('<big><b>File exists</b></big>\n\n' + 
							self.filename_entry.get_text() + ' already exists.\nOverwrite?')
							self.overwrite_dialog.show()
							return 0
							
				for x in gtk.gdk.window_get_toplevels():
					x.set_cursor(gtk.gdk.Cursor(gtk.gdk.WATCH))
				
				if self.combobox_convert.get_model()[self.combobox_convert.get_active()][0] == 'Zip archive':
					
					if self.archive_type != '' and self.dir_removed == 0:
						new_zip = zipfile.ZipFile(os.path.dirname(self.path) + '/' + self.filename_entry.get_text().encode(sys.getfilesystemencoding()), 'w')
					else:
						new_zip = zipfile.ZipFile(os.path.dirname(os.path.dirname(self.path)) + '/' + self.filename_entry.get_text().encode(sys.getfilesystemencoding()), 'w')
					
					dir = os.getcwd()
					os.chdir(self.base_dir + 'convert')
					files = os.listdir('.')
					
					loop = 1
					
					while loop:
						
						loop = 0
						
						for i, file in enumerate(files):
							
							if os.path.isdir(file):
								
								files.pop(i)
								temp_files = os.listdir(file)
								
								for temp_file in temp_files:
									
									temp_file = file + '/' + temp_file
									files.append(temp_file)
									
								loop = 1
								break
					
					for file in files:
						
						file = unicode(file, sys.getfilesystemencoding())
						new_zip.write(file, file.encode('cp437'))
					
					new_zip.close()
					os.chdir(dir)
					
				elif (self.combobox_convert.get_model()[self.combobox_convert.get_active()][0] in 
				['Tar archive', 'Gzip compressed tar archive', 'Bzip2 compressed tar archive']):
					
					if self.combobox_convert.get_model()[self.combobox_convert.get_active()][0] == 'Tar archive':
						type = 'w'
					elif self.combobox_convert.get_model()[self.combobox_convert.get_active()][0] == 'Gzip compressed tar archive':
						type = 'w:gz'
					else:
						type = 'w:bz2'
					
					if self.archive_type != '' and self.dir_removed == 0:
						new_tar = tarfile.open(os.path.dirname(self.path) + '/' + self.filename_entry.get_text().encode(sys.getfilesystemencoding()), type)
					else:
						new_tar = tarfile.open(os.path.dirname(os.path.dirname(self.path)) + '/' + self.filename_entry.get_text().encode(sys.getfilesystemencoding()), type)
					
					dir = os.getcwd()
					os.chdir(self.base_dir + 'convert')
					files = os.listdir('.')
					
					loop = 1
					
					while loop:
						
						loop = 0
						
						for i, file in enumerate(files):
							
							if os.path.isdir(file):
								
								files.pop(i)
								temp_files = os.listdir(file)
								
								for temp_file in temp_files:
									
									temp_file = file + '/' + temp_file
									files.append(temp_file)
									
								loop = 1
								break
					
					for file in files:
						
						new_tar.add(file)
					
					new_tar.close()
					os.chdir(dir)
					
				if os.path.exists(self.base_dir + 'convert'):
					shutil.rmtree(self.base_dir + 'convert')
					
				if self.archive_type != '':
					
					if os.path.exists(self.path) and self.button_delete_archive.get_active() and os.path.dirname(self.path) + '/' + self.filename_entry.get_text() != self.path:
						
						try:
							
							os.remove(self.path)
							
						except:
							
							self.open_permission_dialog(self.path)
							return 0
						
				else:
					
					if (os.path.exists(os.path.dirname(self.path)) and self.button_delete_archive.get_active() and os.path.dirname(os.path.dirname(self.path)) 
					+ '/' + self.filename_entry.get_text() != os.path.dirname(self.path)):
						
						try:
							
							shutil.rmtree(os.path.dirname(self.path))
						
						except:
							
							self.open_permission_dialog(os.path.dirname(self.path))
							return 0
						
				if self.archive_type != '':
					
					if self.button_delete_archive.get_active() or os.path.dirname(self.path) + '/' + self.filename_entry.get_text() == self.path:
						
						self.archive_type = self.combobox_convert.get_model()[self.combobox_convert.get_active()][0]
						self.path = os.path.dirname(self.path) + '/' + self.filename_entry.get_text()
						self.refresh_image()
						
				else:
					
					if self.button_delete_archive.get_active() or os.path.dirname(os.path.dirname(self.path)) + '/' + self.filename_entry.get_text() == os.path.dirname(self.path):
						
						temp = self.file_number
						self.load_file(os.path.dirname(os.path.dirname(self.path)) + '/' + self.filename_entry.get_text())
						self.file_number = temp
						self.refresh_image()
					
				if self.optionlist[24] and self.optionlist[0]:
					
					pixmap = gtk.gdk.Pixmap(None, 1, 1, 1)
					color = gtk.gdk.Color()
					cursor = gtk.gdk.Cursor(pixmap, pixmap, color, color, 0, 0)
					for x in gtk.gdk.window_get_toplevels():
						x.set_cursor(None)
					gtk.gdk.window_get_toplevels()[1].set_cursor(cursor)
					
				else:
					
					for x in gtk.gdk.window_get_toplevels():
						x.set_cursor(None)
						
				self.file_removed = 0
		
	def close_convert(self, event, data=None):
		
		self.convert_dialog.hide()
		return True
		
	def change_convert(self, event, data=None):
		
		if self.combobox_convert.get_active() >=0:
			
			if self.combobox_convert.get_model()[self.combobox_convert.get_active()][0] == 'Zip archive':
				
				suffix = '.cbz'
				
			elif self.combobox_convert.get_model()[self.combobox_convert.get_active()][0] in ['Tar archive', 'Gzip compressed tar archive', 'Bzip2 compressed tar archive']:
				
				suffix = '.cbt'
				
			else:
				
				suffix = ''
			
		if suffix != '':
			
			if self.archive_type != '':
				
				self.filename_entry.set_text(os.path.splitext(os.path.basename(self.path))[0] + suffix)
				self.filename_entry.set_sensitive(True)
				
			else:
				
				self.filename_entry.set_text(os.path.basename(os.path.dirname(self.path)) + suffix)
				self.filename_entry.set_sensitive(True)
			
		else:
			
			self.filename_entry.set_text('')
			self.filename_entry.set_sensitive(False)
		
	def close_overwrite(self, event, data=None):
		
		self.overwrite_dialog.hide()
		self.overwrite = 0
		return True
		
	def save_and_close_overwrite(self, event, data):
		
		self.overwrite_dialog.hide()
		
		if data == -5:
			
			if self.archive_type != '':
				
				try:
					
					if os.path.isdir(os.path.dirname(self.path) + '/' + self.filename_entry.get_text()):
						shutil.rmtree(os.path.dirname(self.path) + '/' + self.filename_entry.get_text())
						
					else:
						os.remove(os.path.dirname(self.path) + '/' + self.filename_entry.get_text())
					
				except:
					
					self.open_permission_dialog(os.path.dirname(self.path) + '/' + self.filename_entry.get_text())
					return 0
				
			else:
				
				try:
					
					if os.path.isdir(os.path.dirname(os.path.dirname(self.path)) + '/' + self.filename_entry.get_text()):
						shutil.rmtree(os.path.dirname(os.path.dirname(self.path)) + '/' + self.filename_entry.get_text())
						
					else:
						os.remove(os.path.dirname(os.path.dirname(self.path)) + '/' + self.filename_entry.get_text())
						
				except:
					
					self.open_permission_dialog(os.path.dirname(os.path.dirname(self.path)) + '/' + self.filename_entry.get_text())
					return 0
				
			self.file_removed = 1
			self.save_and_close_convert(self, -5)
				
	def open_options(self, event):
		
		self.notebook.set_current_page(0)
		
		self.temp_optionlist = []
		self.old_optionlist = []
		
		for x in self.optionlist:
			
			self.temp_optionlist.append(x)
			self.old_optionlist.append(x)
		
		self.button_fullscreen.set_active(self.optionlist[1])
			
		self.button_page.set_active(self.optionlist[5])
			
		self.button_cache_next.set_active(self.optionlist[7])
			
		self.button_flip_page.set_active(self.optionlist[8])
			
		self.button_stretch.set_active(self.optionlist[9])
		
		self.button_save_size.set_active(self.optionlist[14])	
		
		self.button_fit.set_active(self.optionlist[16])	
		
		self.button_comment.set_active(self.optionlist[28])	
		
		self.button_next_archive.set_active(self.optionlist[23])
		
		self.button_hide_cursor.set_active(self.optionlist[24])
		
		self.button_hide_bars.set_active(self.optionlist[3])
		
		self.button_scroll_flips.set_active(self.optionlist[30])
		
		self.button_scroll_horiz.set_active(self.optionlist[31])
		
		self.button_smart_scale.set_active(self.optionlist[32])
			
		if self.optionlist[2] == gtk.gdk.INTERP_NEAREST:
			self.button_1.set_active(True)
		
		if self.optionlist[2] == gtk.gdk.INTERP_TILES:
			self.button_2.set_active(True)
		
		if self.optionlist[2] == gtk.gdk.INTERP_BILINEAR:
			self.button_3.set_active(True)
		
		if self.optionlist[2] == gtk.gdk.INTERP_HYPER:
			self.button_4.set_active(True)
		
		self.button_saturation.set_value(self.optionlist[6] / 10.0)
		self.comment_extensions_entry.set_text(unicode(self.optionlist[29], sys.getfilesystemencoding()))
		self.colorbutton.set_color(gtk.gdk.colormap_get_system().alloc_color(gtk.gdk.Color(self.optionlist[19], self.optionlist[20], self.optionlist[21]), False, True))
		
		if len(unicode(self.optionlist[15], sys.getfilesystemencoding())) > 50:
			self.filechooser_button.set_label('... ' + unicode(self.optionlist[15], sys.getfilesystemencoding())[-47:])
		else:
			self.filechooser_button.set_label(unicode(self.optionlist[15], sys.getfilesystemencoding()))
			
		if self.optionlist[33] == gtk.TOOLBAR_TEXT:
			self.combobox_tool.set_active(1)
		elif self.optionlist[33] == gtk.TOOLBAR_BOTH:
			self.combobox_tool.set_active(2)
		else:
			self.combobox_tool.set_active(0)
		
		self.options_window.show()
		
	def save_and_close_options(self, data):
		
		if data == 'close':
			self.options_window.hide()
		
		fullscreen = self.optionlist[0]
		x_res = self.optionlist[10]
		y_res = self.optionlist[11]
		fit_to_screen = self.optionlist[18]
		double_page_mode = self.optionlist[4]
		scrollbar = self.optionlist[22]
		menubar = self.optionlist[25]
		toolbar = self.optionlist[26]
		statusbar = self.optionlist[27]
		
		if not os.path.exists(self.temp_optionlist[15]):	
			self.temp_optionlist[15] = self.optionlist[15]
			
		for i in range(len(self.optionlist)):
			self.optionlist.pop()
		
		for x in self.temp_optionlist:
			self.optionlist.append(x)
			
		self.optionlist[0] = fullscreen
		self.optionlist[10] = x_res
		self.optionlist[11] = y_res
		self.optionlist[18] = fit_to_screen
		self.optionlist[4] = double_page_mode
		self.optionlist[22] = scrollbar
		self.optionlist[25] = menubar
		self.optionlist[26] = toolbar
		self.optionlist[27] = statusbar
			
		self.optionlist[6] = self.button_saturation.get_value() * 10
		
		self.optionlist[19] = self.colorbutton.get_color().red
		self.optionlist[20] = self.colorbutton.get_color().green
		self.optionlist[21] = self.colorbutton.get_color().blue
		
		self.layout.modify_bg(gtk.STATE_NORMAL, gtk.gdk.colormap_get_system().alloc_color(gtk.gdk.Color(self.optionlist[19], self.optionlist[20], self.optionlist[21]), False, True))
		
		if self.optionlist[29] != self.comment_extensions_entry.get_text():
			
			self.optionlist[29] = self.comment_extensions_entry.get_text()
			
			self.comment = []
			
			if self.file_exist:
				
				comment_extensions_temp = self.optionlist[29]
				comment_extensions = []
				
				while comment_extensions_temp.count(' '):
					
					if comment_extensions_temp.index(' ') > 0:
						
						comment_extensions.append('.' + comment_extensions_temp[:comment_extensions_temp.index(' ')])
					
					comment_extensions_temp = comment_extensions_temp[comment_extensions_temp.index(' ') + 1:]
				
				if len(comment_extensions_temp) > 0:
					
					comment_extensions.append('.' + comment_extensions_temp)
					
				if self.archive_type != '':
					comment_dir = self.base_dir
				else:
					comment_dir = os.path.dirname(self.path)
					
				for infile in os.listdir(comment_dir):
					
					infile = comment_dir + infile
					
					if not os.path.isdir(infile):
						
						if gtk.gdk.pixbuf_get_file_info(infile) == None and os.path.splitext(infile)[1].lower() in comment_extensions:
							
							self.comment.append(infile)
							
				if self.comment_number > len(self.comment) - 1:
					
					self.comment_number = 0
					
				if len(self.comment) > 0:
					
					self.actiongroup.get_action('Comments').set_sensitive(True)
					
				else:
					
					self.show_comments = 0
					self.actiongroup.get_action('Comments').set_sensitive(False)
			
		if self.combobox_tool.get_active_text() == 'Text only':
			self.optionlist[33] = gtk.TOOLBAR_TEXT
		elif self.combobox_tool.get_active_text() == 'Icons and text':
			self.optionlist[33] = gtk.TOOLBAR_BOTH
		else:
			self.optionlist[33] = gtk.TOOLBAR_ICONS
		
		self.refresh_image()
		
	def close_options(self, event, data=None):
		
		self.options_window.hide()
		
		fullscreen = self.optionlist[0]
		x_res = self.optionlist[10]
		y_res = self.optionlist[11]
		fit_to_screen = self.optionlist[18]
		double_page_mode = self.optionlist[4]
		scrollbar = self.optionlist[22]
		menubar = self.optionlist[25]
		toolbar = self.optionlist[26]
		statusbar = self.optionlist[27]
		
		for i in range(len(self.optionlist)):
			self.optionlist.pop()
			
		for x in self.old_optionlist:
			self.optionlist.append(x)
			
		self.optionlist[0] = fullscreen
		self.optionlist[10] = x_res
		self.optionlist[11] = y_res
		self.optionlist[18] = fit_to_screen
		self.optionlist[4] = double_page_mode
		self.optionlist[22] = scrollbar
		self.optionlist[25] = menubar
		self.optionlist[26] = toolbar
		self.optionlist[27] = statusbar
		
		self.layout.modify_bg(gtk.STATE_NORMAL, gtk.gdk.colormap_get_system().alloc_color(gtk.gdk.Color(self.optionlist[19], self.optionlist[20], self.optionlist[21]), False, True))
			
		self.refresh_image()
		return True
		
	def options(self, widget, data):
		
		if data == 0:
			
			if self.button_fullscreen.get_active():
				
				self.temp_optionlist[1] = 1
				
			else:
				
				self.temp_optionlist[1] = 0
			
		elif data == 1:
			
			if self.button_page.get_active():
				
				self.temp_optionlist[5] = 1
				
			else:
				
				self.temp_optionlist[5] = 0
				
		elif data == 7:
			
			if self.button_cache_next.get_active():
				
				self.temp_optionlist[7] = 1
				
			else:
				
				self.temp_optionlist[7] = 0
			
		elif data == 8:
			
			if self.button_flip_page.get_active():
				
				self.temp_optionlist[8] = 1
				
			else:
				
				self.temp_optionlist[8] = 0
				
		elif data == 9:
			
			if self.button_stretch.get_active():
				
				self.temp_optionlist[9] = 1
				
			else:
				
				self.temp_optionlist[9] = 0
				
		elif data == 10:
			
			if self.button_save_size.get_active():
				
				self.temp_optionlist[14] = 1
				
			else:
				
				self.temp_optionlist[14] = 0
				
		elif data == 11:
			
			if self.button_fit.get_active():
				
				self.temp_optionlist[16] = 1
				
			else:
				
				self.temp_optionlist[16] = 0
		
		elif data == 12:
			
			if self.button_hide_bars.get_active():
				
				self.temp_optionlist[3] = 1
				
			else:
				
				self.temp_optionlist[3] = 0
				
		#elif data == 13: NOT USED
				
		elif data == 14:
			
			if self.button_next_archive.get_active():
				
				self.temp_optionlist[23] = 1
				
			else:
				
				self.temp_optionlist[23] = 0
				
		elif data == 15:
			
			if self.button_hide_cursor.get_active():
				
				self.temp_optionlist[24] = 1
				
			else:
				
				self.temp_optionlist[24] = 0
				
		elif data == 16:
			
			if self.button_comment.get_active():
				
				self.temp_optionlist[28] = 1
				
			else:
				
				self.temp_optionlist[28] = 0
				
		elif data == 17:
			
			if self.button_scroll_horiz.get_active():
				
				self.temp_optionlist[31] = 1
				
			else:
				
				self.temp_optionlist[31] = 0
				
		elif data == 18:
			
			if self.button_scroll_flips.get_active():
				
				self.temp_optionlist[30] = 1
				
			else:
				
				self.temp_optionlist[30] = 0
				
		elif data == 19:
			
			if self.button_smart_scale.get_active():
				
				self.temp_optionlist[32] = 1
				
			else:
				
				self.temp_optionlist[32] = 0
				
		elif data == 2:
			
			self.temp_optionlist[2] = gtk.gdk.INTERP_NEAREST
			
		elif data == 3:
			
			self.temp_optionlist[2] = gtk.gdk.INTERP_TILES
			
		elif data == 4:
			
			self.temp_optionlist[2] = gtk.gdk.INTERP_BILINEAR
			
		elif data == 5:
			
			self.temp_optionlist[2] = gtk.gdk.INTERP_HYPER
	
	def open_about(self, data=None):
		
		self.about_dialog.show()
		
	def close_about(self, event, data=None):
		
		self.about_dialog.hide()
		return True
		
	def open_file_info(self, data=None):
		
		if self.file_exist == 1:
			
			self.file_dialog.resize(100, 100)
			
			if self.archive_type != "":
				
				command = '<b>Name:\nLocation:\nPage:\nArchive type:\nArchive size:\n'
				
			elif self.optionlist[4] == 1 and len(self.file) != self.file_number + 1:
				
				command = '<b>Image #1 name:\nImage #2 name:\nLocation:\nPage:\n'
				
			else:
				
				command = '<b>Name:\nLocation:\nPage:\n'
				
			if self.optionlist[4] == 1 and len(self.file) != self.file_number + 1:
				
				command = (command + 'Image #1 type:\nImage #2 type:\nImage #1 size:\nImage ' +
				'#2 size:\nImage #1 resolution:\nImage #2 resolution:\nImage #1 scaling:\nImage #2 scaling:\n</b>')
				
			else:
				
				command = command + 'Image type:\nImage size:\nResolution:\nScaling:\n</b>'
				
			if self.archive_type != "":
				
				command2 = os.path.basename(self.path) + '\n' + os.path.dirname(self.path) + '\n' + str(self.file_number + 1) + ' of ' + str(len(self.file)) + '\n' + self.archive_type + '\n' + str('%.1f' % (os.stat(self.path)[stat.ST_SIZE] / 1048576.0)) + ' MiB\n'
				
			elif self.optionlist[4] == 1 and len(self.file) != self.file_number + 1:
				
				command2 = os.path.basename(self.file[self.file_number]) + '\n' + os.path.basename(self.file[self.file_number + 1]) + '\n' + os.path.dirname(self.path) + '\n' + str(self.file_number + 1) + ' and ' + str(self.file_number + 2) + ' of ' + str(len(self.file)) + '\n'
				
			else:
				
				command2 = os.path.basename(self.file[self.file_number]) + '\n' + os.path.dirname(self.path) + '\n' + str(self.file_number + 1) + ' of ' + str(len(self.file)) + '\n'
				
			if self.optionlist[4] == 1 and len(self.file) != self.file_number + 1:
				
				command2 = (command2 + gtk.gdk.pixbuf_get_file_info(self.file[self.file_number])[0]['mime_types'][0][6:].upper() + "\n" + gtk.gdk.pixbuf_get_file_info(self.file[self.file_number + 1])[0]['mime_types'][0][6:].upper() + "\n"
				+ str('%.1f' % (os.stat(self.file[self.file_number])[stat.ST_SIZE] / 1024.0)) + " kiB\n" + str('%.1f' % (os.stat(self.file[self.file_number + 1])[stat.ST_SIZE] / 1024.0)) + " kiB\n" +
				str(self.image1_width) + " x " + str(self.image1_height) + " px\n" + str(self.image2_width) + " x " + str(self.image2_height) + " px\n")
				
				command2 = (command2 + str(self.image1_scaled_width) + " x " + str(self.image1_scaled_height) + " px (" + str('%.1f' % (100.0 * self.image1_scaled_height / self.image1_height)) + " %)\n" + str(self.image2_scaled_width) + 
				" x " + str(self.image2_scaled_height) + " px (" + str('%.1f' % (100.0 * self.image2_scaled_height / self.image2_height)) + " %)\n")
				
			else:
				
				command2 = (command2 + gtk.gdk.pixbuf_get_file_info(self.file[self.file_number])[0]['mime_types'][0][6:].upper() + "\n" + str('%.1f' % (os.stat(self.file[self.file_number])[stat.ST_SIZE] / 1024.0)) + " kiB\n"
				+ str(self.image1_width) + " x " + str(self.image1_height) + " px\n")
				
				command2 = command2 + str(self.image1_scaled_width) + " x " + str(self.image1_scaled_height) + " px (" + str('%.1f' % (100.0 * self.image1_scaled_height / self.image1_height)) + " %)\n"
			
			self.file_info_label.set_markup(unicode(command, sys.getfilesystemencoding()))
			self.file_info_label2.set_markup(unicode(command2, sys.getfilesystemencoding()))
			self.file_info_label2.set_selectable(True)
			self.file_dialog.show()
		
	def open_invalid_filename(self, data):
		
		self.invalid_filename_info_label.set_markup('<b><big>Invaild filename</big></b>\n\n' +
		'"' + data + '" is an invalid filename.\nFile was not created.')
		self.invalid_filename_dialog.show()
		
	def close_file_info(self, event, data=None):
		
		self.file_dialog.hide()
		return True
		
	def close_invalid_filename(self, event, data=None):
		
		self.invalid_filename_dialog.hide()
		return True
		
	def open_permission_dialog(self, path):
		
		if self.optionlist[24] and self.optionlist[0]:
			
			pixmap = gtk.gdk.Pixmap(None, 1, 1, 1)
			color = gtk.gdk.Color()
			cursor = gtk.gdk.Cursor(pixmap, pixmap, color, color, 0, 0)
			for x in gtk.gdk.window_get_toplevels():
				x.set_cursor(None)
			gtk.gdk.window_get_toplevels()[1].set_cursor(cursor)
			
		else:
			
			for x in gtk.gdk.window_get_toplevels():
				x.set_cursor(None)
		
		self.file_removed = 0
		self.permission_label.set_markup('<b><big>Permission denied</big></b>\n\n' +
		'Could not delete "' + path + '"\nPlease check your permissions.')
		self.permission_dialog.show()
		
	def close_permission_dialog(self, event, data=None):
		
		self.permission_dialog.hide()
		return True
		
	def open_file(self, event, data=None):
		
		if self.optionlist[15][-1:] != '/':
			
			self.optionlist[15] = self.optionlist[15] + '/'
			
		self.file_select.set_current_folder(self.optionlist[15])
		self.file_select.show()
		
		response = self.file_select.run()
		
		if int(response) == int(gtk.RESPONSE_OK):
			
			self.file_select_ok(None)
			
		else:
			
			self.file_select_cancel(None)
		
	def file_select_ok(self, event, data=None):
		
		self.file_select.hide()
		self.load_file(self.file_select.get_filename())
		self.change_adjustment = 1
		self.refresh_image()
		
	def file_select_cancel(self, event, data=None):
		
		self.file_select.hide()
		return True
		
	def mouse_click_event(self, view, event, data=None):
		
		self.scroll_events_down = 0
		self.scroll_events_up = 0
		
		if event.button == 3:
			
			self.ui.get_widget('/Pop').popup(None, None, None, event.button, event.time)
			
		elif event.button == 1 or event.button == 2:
			
			self.x_motion = event.x_root
			self.y_motion = event.y_root
			self.mouse_moved = 0
			self.old_vadjust_value = self.vadjust.value
			self.old_hadjust_value = self.hadjust.value
		
	def open_bookmark(self, event):
		
		self.load_file(self.bookmarks[int(event.get_name()[4:]) - 1])
			
		if self.bookmark_numbers[int(event.get_name()[4:]) - 1] <= len(self.file) and self.bookmark_numbers[int(event.get_name()[4:]) - 1] > 0:
			
			self.file_number = self.bookmark_numbers[int(event.get_name()[4:]) - 1] - 1
			
		self.change_adjustment = 1
		self.refresh_image()
		
	def save_bookmark(self, event):
		
		if self.file_exist == 1:
			
			if self.bookmarks.count(self.path) > 0:
				
				self.bookmark_numbers.pop(self.bookmarks.index(self.path))
				self.bookmarks.pop(self.bookmarks.index(self.path))
				
			self.bookmarks.insert(0, self.path)
			self.bookmark_numbers.insert(0, self.file_number + 1)
			self.update_bookmarks()
		
	def clear_bookmarks(self, event):
		
		for x in range(len(self.bookmarks)):
			self.bookmarks.pop()
			
		for x in range(len(self.bookmark_numbers)):
			self.bookmark_numbers.pop()
			
		self.update_bookmarks()
			
	def update_bookmarks(self):
		
		self.liststore.clear()
		
		for i, bookmark in enumerate(self.bookmarks):
			
			dir = 0
			
			if not os.path.isdir(bookmark):
				if gtk.gdk.pixbuf_get_file_info(bookmark) != None:
					if (gtk.gdk.pixbuf_get_file_info(bookmark)[0]['mime_types'][0] in 
					['image/jpeg', 'image/bmp', 'image/gif', 'image/png', 'image/tiff', 'image/x-icon', 'image/x-xpixmap', 'image/x-xbitmap']):
						
						dir = 1
						self.liststore.append([unicode(os.path.basename(os.path.dirname(bookmark)), sys.getfilesystemencoding()), str(self.bookmark_numbers[i])])
				
				if not dir:
					self.liststore.append([unicode(os.path.basename(bookmark), sys.getfilesystemencoding()), str(self.bookmark_numbers[i])])
					
		for i, bookmark in enumerate(self.bookmarks):
			
			dir = 0
			
			if not os.path.isdir(bookmark):
				if gtk.gdk.pixbuf_get_file_info(bookmark) != None:
					if (gtk.gdk.pixbuf_get_file_info(bookmark)[0]['mime_types'][0] in 
					['image/jpeg', 'image/bmp', 'image/gif', 'image/png', 'image/tiff', 'image/x-icon', 'image/x-xpixmap', 'image/x-xbitmap']):
						
						dir = 1
						
						if len(os.path.basename(os.path.dirname(bookmark))) <= 30:
							name = unicode(os.path.basename(os.path.dirname(bookmark)), sys.getfilesystemencoding()) + ', page ' + str(self.bookmark_numbers[i])
							
						else:
							name = unicode(os.path.basename(os.path.dirname(bookmark))[:13], sys.getfilesystemencoding()) + ' ... ' + unicode(os.path.basename(os.path.dirname(bookmark))[-12:], sys.getfilesystemencoding()) + ', page ' + str(self.bookmark_numbers[i])
						
			if dir == 0:
				if len(os.path.basename(bookmark)) <= 30:
					name = unicode(os.path.basename(bookmark), sys.getfilesystemencoding()) + ', page ' + str(self.bookmark_numbers[i])
					
				else:
					name = unicode(os.path.basename(bookmark)[:13], sys.getfilesystemencoding()) + ' ... ' + unicode(os.path.basename(bookmark)[-12:], sys.getfilesystemencoding()) + ', page ' + str(self.bookmark_numbers[i])
			
			self.actiongroup.add_actions([('Book' + str(i+1), gtk.STOCK_FILE, name, '', None, self.open_bookmark)])
		
		try:
			self.ui.get_widget('/Menu').hide()
		except:
			pass
		
		try:
			self.ui.remove_ui(self.merge_id)
		except:
			pass
			
		gc.collect()
		
		self.ui = gtk.UIManager()
		
		ui_description = """<ui>
			<popup name="Pop">
				<menu action="menu_go">
					<menuitem action="Next" />
					<menuitem action="Previous" />
					<menuitem action="First" />
					<menuitem action="Last" />
					<separator />
					<menuitem action="Go" />
				</menu>
				<separator />
				<menu action="menu_view">
					<menuitem action="Fullscreen" />
					<menuitem action="Double" />
					<menuitem action="Fit" />
					<separator />
					<menuitem action="Menubar" />
					<menuitem action="Toolbar" />
					<menuitem action="Statusbar" />
					<menuitem action="Scrollbars" />
				</menu>
				<menu action="Zoom">
					<menuitem action="Zin" />
					<menuitem action="Zout" />
					<menuitem action="Zoriginal" />
					<menuitem action="Zwidth" />
					<menuitem action="Zheight" />
					<menuitem action="Zfit" />
				</menu>
				<menu action="Book">
					<menuitem action="Save_book" />
					<menuitem action="Bookmark_manager" />
					<menuitem action="Clear_book" />
					<separator />"""
			
		for i, bookmark in enumerate(self.bookmarks):
			ui_description = ui_description + '\n<menuitem action="Book' + str(i+1) + '" />'
		
		ui_description = ui_description + """
				</menu>
				<separator />
				<menuitem action="Options" />
				<menuitem action="File" />
				<menuitem action="Comments" />
				<menuitem action="About" />
				<separator />
				<menuitem action="Open" />
				<menuitem action="Convert" />
				<menuitem action="Close" />
				<menuitem action="Quit" />
			</popup>
			<menubar name="Menu">
				<menu action="menu_file">
					<menuitem action="Open" />
					<menuitem action="Convert" />
					<separator />
					<menuitem action="File" />
					<menuitem action="Comments" />
					<separator />
					<menuitem action="Close" />
					<menuitem action="Quit" />
				</menu>
				<menu action="menu_edit">
					<menuitem action="Options" />
				</menu>
				<menu action="menu_view">
					<menuitem action="Fullscreen" />
					<menuitem action="Double" />
					<menuitem action="Fit" />
					<separator />
					<menuitem action="Zin" />
					<menuitem action="Zout" />
					<menuitem action="Zoriginal" />
					<menuitem action="Zwidth" />
					<menuitem action="Zheight" />
					<menuitem action="Zfit" />
					<separator />
					<menuitem action="Menubar" />
					<menuitem action="Toolbar" />
					<menuitem action="Statusbar" />
					<menuitem action="Scrollbars" />
				</menu>
				<menu action="menu_go">
					<menuitem action="Next" />
					<menuitem action="Previous" />
					<menuitem action="First" />
					<menuitem action="Last" />
					<separator />
					<menuitem action="Go" />
				</menu>
				<menu action="Book">
					<menuitem action="Save_book" />
					<menuitem action="Bookmark_manager" />
					<menuitem action="Clear_book" />
					<separator />"""
					
		for i,bookmark in enumerate(self.bookmarks):
			ui_description = ui_description + '\n<menuitem action="Book' + str(i+1) + '" />'
				
		ui_description = ui_description + """</menu>
				<menu action="menu_help">
					<menuitem action="About" />
				</menu>
			</menubar>
		</ui>"""
		
		self.merge_id = self.ui.add_ui_from_string(ui_description)
		self.ui.insert_action_group(self.actiongroup, 0)
		self.table.attach(self.ui.get_widget('/Menu'), 0, 3, 0, 1, gtk.FILL|gtk.SHRINK, gtk.FILL|gtk.SHRINK, 0, 0)
		
		if len(self.bookmarks) == 0:
			self.actiongroup.get_action('Clear_book').set_sensitive(False)
			self.bookmark_dialog.action_area.get_children()[1].set_sensitive(False)
		else:
			self.actiongroup.get_action('Clear_book').set_sensitive(True)
			self.bookmark_dialog.action_area.get_children()[1].set_sensitive(True)
			
		if self.optionlist[3] and self.optionlist[0] or not self.optionlist[25]:
			
			self.ui.get_widget('/Menu').hide()
			
		else:
			
			self.ui.get_widget('/Menu').show()
			
	def blank_page(self, data=None):
		
		if os.path.exists(self.base_dir):
			shutil.rmtree(self.base_dir)
			os.makedirs(self.base_dir)
		
		for i in range(len(self.file)):
			self.file.pop()
		
		self.file_number = 0
		self.file_exist = 0
		self.refresh_image()
		self.actiongroup.get_action('File').set_sensitive(False)
		self.actiongroup.get_action('Save_book').set_sensitive(False)
		self.actiongroup.get_action('Convert').set_sensitive(False)
		self.actiongroup.get_action('Close').set_sensitive(False)
		self.actiongroup.get_action('Go').set_sensitive(False)
		self.actiongroup.get_action('Next').set_sensitive(False)
		self.actiongroup.get_action('Previous').set_sensitive(False)
		self.actiongroup.get_action('First').set_sensitive(False)
		self.actiongroup.get_action('Last').set_sensitive(False)
		self.button_previous.set_sensitive(False)
		self.button_next.set_sensitive(False)
		self.button_first.set_sensitive(False)
		self.button_last.set_sensitive(False)
		self.button_go.set_sensitive(False)
		self.bookmark_dialog.action_area.get_children()[2].set_sensitive(False)
		
	def archive_mime_type(self, path):
		
		file = open(path, 'rb')
			
		if file.read(3) == 'BZh':
			
			file.close()
			return 'bzip2'
			
		file.seek(0)
			
		if file.read(2) == '\037\213':
			
			file.close()
			return 'gzip'
			
		file.seek(0)	
			
		if file.read(4) == 'Rar!':
			
			file.close()
			return 'rar'
			
		file.close()
		return None
		
		
	def drag_motion(self, wid, context, x, y, time):
		
		context.drag_status(gtk.gdk.ACTION_COPY, time)
		return True
		
	def drag_data(self, widget, drag_context, x, y, selection, info, time):
		
		uri = selection.data.strip()
		path = urllib.url2pathname(uri)
		
		if path.startswith('file://'): # Nautilus etc.
			path = path[7:]
		elif path.startswith('file:'): # Xffm etc.
			path = path[5:]
		
		self.load_file(path)
		self.refresh_image()
		
	def load_file(self, path):
		
		# Set the watch cursor to signal that the application is working
		for x in gtk.gdk.window_get_toplevels():
			x.set_cursor(gtk.gdk.Cursor(gtk.gdk.WATCH))
			
		self.path = path		
		self.file = []
		self.file_number = 0
		self.old_file_number = -1
		self.cached = 0
		self.comment = []
		self.comment_number = 0
		self.show_comments = 0
		self.archive_type = ''
		self.change_adjustment = 1
		
		if os.path.exists(self.base_dir):
			shutil.rmtree(self.base_dir)
			os.makedirs(self.base_dir)
			
		# If the given path is invalid, do nothing
		if not os.path.isfile(path):
			
			self.file_exist = 0
			if os.path.isdir(path):
				self.statusbar.push(0, unicode('"' + os.path.basename(path) + '" is not a file.', sys.getfilesystemencoding()))	
			else:
				self.statusbar.push(0, unicode('"' + os.path.basename(path) + '" does not exist.', sys.getfilesystemencoding()))		
			self.filetype_error = 1
			self.actiongroup.get_action('File').set_sensitive(False)
			self.actiongroup.get_action('Save_book').set_sensitive(False)
			self.actiongroup.get_action('Convert').set_sensitive(False)
			self.actiongroup.get_action('Close').set_sensitive(False)
			self.actiongroup.get_action('Go').set_sensitive(False)
			self.actiongroup.get_action('Next').set_sensitive(False)
			self.actiongroup.get_action('Previous').set_sensitive(False)
			self.actiongroup.get_action('First').set_sensitive(False)
			self.actiongroup.get_action('Last').set_sensitive(False)
			self.button_previous.set_sensitive(False)
			self.button_next.set_sensitive(False)
			self.button_first.set_sensitive(False)
			self.button_last.set_sensitive(False)
			self.button_go.set_sensitive(False)
			self.bookmark_dialog.action_area.get_children()[2].set_sensitive(False)
			
			if self.optionlist[24] and self.optionlist[0]:
				
				pixmap = gtk.gdk.Pixmap(None, 1, 1, 1)
				color = gtk.gdk.Color()
				cursor = gtk.gdk.Cursor(pixmap, pixmap, color, color, 0, 0)
				for x in gtk.gdk.window_get_toplevels():
					x.set_cursor(None)
				gtk.gdk.window_get_toplevels()[1].set_cursor(cursor)
				
			else:
				
				for x in gtk.gdk.window_get_toplevels():
					x.set_cursor(None)
			
			return 0
			
		# The file exists
		else:
			
			# Check which file extensions are for comment files
			comment_extensions_temp = self.optionlist[29]
			comment_extensions = []
			
			while comment_extensions_temp.count(' '):
				
				if comment_extensions_temp.index(' ') > 0:
					comment_extensions.append('.' + comment_extensions_temp[:comment_extensions_temp.index(' ')])
				comment_extensions_temp = comment_extensions_temp[comment_extensions_temp.index(' ') + 1:]
			
			if len(comment_extensions_temp) > 0:
				comment_extensions.append('.' + comment_extensions_temp)
			
			# The file is a Zip archive
			if zipfile.is_zipfile(path):
				
				#os.mkdir('/tmp/comix')
				zip = zipfile.ZipFile(path)
				zipfiles = zip.namelist()
				
				for x in zipfiles:
					if zip.getinfo(x).file_size > 0:
						if not os.path.exists(os.path.dirname(self.base_dir + x)):
							os.makedirs(os.path.dirname(self.base_dir + x))
						new = open(self.base_dir + x, 'w')
						new.write(zip.read(x))
						new.close()
					
				zip.close()			
				self.archive_type = "Zip archive"
			
			# The file is a tar archive
			elif tarfile.is_tarfile(path):
				
				#os.mkdir('/tmp/comix')
				tar = tarfile.open(path, 'r')
				tarfiles = tar.getmembers()
				
				for x in tarfiles:
					tar.extract(x, self.base_dir)
					
				tar.close()
				
				if self.archive_mime_type(path) == 'gzip':
					self.archive_type = "Gzip compressed tar archive"
				elif self.archive_mime_type(path) == 'bzip2':
					self.archive_type = "Bzip2 compressed tar archive"
				else:
					self.archive_type = "Tar archive"
				
			# The file is a RAR archive
			elif self.archive_mime_type(path) == 'rar':
				
				#os.mkdir('/tmp/comix')
				os.popen('unrar x "' + path + '" ' + self.base_dir)
				self.archive_type = "RAR archive"
			
			# The file is an archive
			if self.archive_type != '':
				
				dir = 1
				
				# Move/rename files in /tmp/comix so that Comix can handle them easily
				while (dir):
					
					dir = 0
					temp = os.listdir(self.base_dir)
					
					for infile in temp:
						infile = self.base_dir + infile
						
						# Directories will be removed and their contents will be moved up one step in the directory structure 
						if os.path.isdir(infile):
							
							for x in os.listdir(infile):
								src = infile + "/" + x
								dst = os.path.dirname(infile) + "/" + os.path.basename(infile) + x
								
								while (True):
									
									if os.path.exists(dst):
										dst = dst[:-len(x)] + "z" +  x
									else:
										break
									
								shutil.move(src, dst)
								
							shutil.rmtree(infile)
							temp.remove(infile[len(self.base_dir):])
							dir = 1
							self.file = []
							break
						
						# Archives will be extracted in new directories and then removed
						# Zip archive
						elif zipfile.is_zipfile(infile):
							
							i = 1
							
							while(1):
								
								temp_dir = infile + 'z' * i + '/'
								
								if os.path.exists(temp_dir):
									i = i + 1
								else:
									break
									
							os.mkdir(temp_dir)
							zip = zipfile.ZipFile(infile)
							zipfiles = zip.namelist()
							
							for x in zipfiles:
								if zip.getinfo(x).file_size > 0:
									if not os.path.exists(os.path.dirname(temp_dir + x)):
										os.makedirs(os.path.dirname(temp_dir + x))
									new = open(temp_dir + x, 'w')
									new.write(zip.read(x))
									new.close()
								
							zip.close()
							os.remove(infile)
							dir = 1
						
						# tar archive
						elif tarfile.is_tarfile(infile):
							
							i = 1
							
							while(1):
								
								temp_dir = infile + 'z' * i + '/'
								
								if os.path.exists(temp_dir):
									i = i + 1
								else:
									break
							
							os.mkdir(temp_dir)
							tar = tarfile.open(infile, 'r')
							tarfiles = tar.getmembers()
							
							for x in tarfiles:
								tar.extract(x, temp_dir)
								
							tar.close()
							os.remove(infile)
							dir = 1
							
						# RAR archive
						elif self.archive_mime_type(infile) == 'rar':
							
							i = 1
							
							while(1):
								
								temp_dir = infile + 'z' * i + '/'
								
								if os.path.exists(temp_dir):
									i = i + 1
								else:
									break
							
							os.mkdir(temp_dir)
							os.popen('unrar x "' + infile + '" "' + temp_dir + '"')				
							os.remove(infile)
							dir = 1
					
				# When moving/renaming of files is done they should be added to their corresponding list
				for infile in temp:
					infile = self.base_dir + infile
					
					if gtk.gdk.pixbuf_get_file_info(infile) != None:
						
						if (gtk.gdk.pixbuf_get_file_info(infile)[0]['mime_types'][0] in
						['image/jpeg', 'image/bmp', 'image/gif', 'image/png', 'image/tiff', 'image/x-icon', 'image/x-xpixmap', 'image/x-xbitmap']):
							
							self.file.append(infile)
							
					elif os.path.splitext(infile)[1].lower() in comment_extensions:
						
						self.comment.append(infile)
				
				# Sort the list after the standards set up by the LC_COLLATE environmental variable
				self.file.sort(locale.strcoll)
				
			# Plain image files
			else:
				
				self.archive_type = ""
				temp = os.listdir(os.path.dirname(path))
				
				# Add files to their corresponding list
				for infile in temp:
					infile = os.path.dirname(path) + '/' + infile
					
					if not os.path.isdir(infile):
						
						if gtk.gdk.pixbuf_get_file_info(infile) != None:
							
							if (gtk.gdk.pixbuf_get_file_info(infile)[0]['mime_types'][0] in
							['image/jpeg', 'image/bmp', 'image/gif', 'image/png', 'image/tiff', 'image/x-icon', 'image/x-xpixmap', 'image/x-xbitmap']):
								
								self.file.append(infile)
								
						elif os.path.splitext(infile)[1].lower() in comment_extensions:
								
								self.comment.append(infile)
				
				# If the specific file opened is invalid
				if self.file.count(path) == 0:
					
					for i in range(len(self.file)):
						self.file.pop()
						
					self.statusbar.push(0, unicode('Filetype of "' + os.path.basename(path) + '" not recognized.', sys.getfilesystemencoding()))		
					self.filetype_error = 1
					
				# Sort by LC_COLLATE and set the filenumber to that of the opened file
				else:
					
					self.file.sort(locale.strcoll)
					self.file_number = self.file.index(path)
		
		# If there are no viewable files opened
		if len(self.file) == 0:
			
			if self.archive_type != '':
				
				self.statusbar.push(0, unicode('No viewable files in "' + os.path.basename(path) + '".', sys.getfilesystemencoding()))		
				self.filetype_error = 1
			
			self.file_exist = 0
			self.actiongroup.get_action('File').set_sensitive(False)
			self.actiongroup.get_action('Save_book').set_sensitive(False)
			self.actiongroup.get_action('Convert').set_sensitive(False)
			self.actiongroup.get_action('Close').set_sensitive(False)
			self.actiongroup.get_action('Go').set_sensitive(False)
			self.actiongroup.get_action('Next').set_sensitive(False)
			self.actiongroup.get_action('Previous').set_sensitive(False)
			self.actiongroup.get_action('First').set_sensitive(False)
			self.actiongroup.get_action('Last').set_sensitive(False)
			self.button_previous.set_sensitive(False)
			self.button_next.set_sensitive(False)
			self.button_first.set_sensitive(False)
			self.button_last.set_sensitive(False)
			self.button_go.set_sensitive(False)
			self.bookmark_dialog.action_area.get_children()[2].set_sensitive(False)
			
		else:
			
			self.file_exist = 1
			self.filetype_error = 0
			self.actiongroup.get_action('File').set_sensitive(True)
			self.actiongroup.get_action('Save_book').set_sensitive(True)
			self.actiongroup.get_action('Convert').set_sensitive(True)
			self.actiongroup.get_action('Close').set_sensitive(True)
			self.actiongroup.get_action('Go').set_sensitive(True)
			self.actiongroup.get_action('Next').set_sensitive(True)
			self.actiongroup.get_action('Previous').set_sensitive(True)
			self.actiongroup.get_action('First').set_sensitive(True)
			self.actiongroup.get_action('Last').set_sensitive(True)
			self.button_previous.set_sensitive(True)
			self.button_next.set_sensitive(True)
			self.button_first.set_sensitive(True)
			self.button_last.set_sensitive(True)
			self.button_go.set_sensitive(True)
			self.bookmark_dialog.action_area.get_children()[2].set_sensitive(True)
			
		if len(self.comment) > 0:
			self.actiongroup.get_action('Comments').set_sensitive(True)
		else:
			self.actiongroup.get_action('Comments').set_sensitive(False)
		
		# Set the cursor back to normal (or invisible)
		if self.optionlist[24] and self.optionlist[0]:
			
			pixmap = gtk.gdk.Pixmap(None, 1, 1, 1)
			color = gtk.gdk.Color()
			cursor = gtk.gdk.Cursor(pixmap, pixmap, color, color, 0, 0)
			for x in gtk.gdk.window_get_toplevels():
				x.set_cursor(None)
			gtk.gdk.window_get_toplevels()[1].set_cursor(cursor)
			
		else:
			
			for x in gtk.gdk.window_get_toplevels():
				x.set_cursor(None)
		
		if self.optionlist[28] and len(self.comment) > 0:
			self.show_comments = 1
	
	def refresh_image(self):
		
		self.scroll_events_down = 0
		self.scroll_events_up = 0
		
		# Hide everything if in fullscreen with the hide in fullscreen option set
		if self.optionlist[3] and self.optionlist[0]:
			
			self.actiongroup.get_action('Menubar').set_sensitive(False)
			self.actiongroup.get_action('Toolbar').set_sensitive(False)
			self.actiongroup.get_action('Statusbar').set_sensitive(False)
			self.actiongroup.get_action('Scrollbars').set_sensitive(False)
			
			self.ui.get_widget('/Menu').hide()
			self.toolbar.hide()
			self.statusbar.hide()
			self.hscroll.hide()
			self.vscroll.hide()
			
		# Else hide/show according to each corresponding option
		else:
			
			self.actiongroup.get_action('Menubar').set_sensitive(True)
			self.actiongroup.get_action('Toolbar').set_sensitive(True)
			self.actiongroup.get_action('Statusbar').set_sensitive(True)
			self.actiongroup.get_action('Scrollbars').set_sensitive(True)
			
			if self.optionlist[22] or self.optionlist[18]:
				self.hscroll.hide()
				self.vscroll.hide()
			else:
				self.hscroll.show()
				self.vscroll.show()
			
			if self.optionlist[25] == 0:
				self.ui.get_widget('/Menu').hide()
			else:
				self.ui.get_widget('/Menu').show()
				
			if self.optionlist[26] == 0:
				self.toolbar.hide()
			else:
				self.toolbar.show()
				
			if self.optionlist[27] == 0:
				self.statusbar.hide()
			else:
				self.statusbar.show()
				
		self.toolbar.set_style(self.optionlist[33])
		
		# Get the window size 
		if self.optionlist[0]:
			
			x = gtk.gdk.screen_get_default().get_monitor_geometry(gtk.gdk.screen_get_default().get_monitor_at_window(gtk.gdk.window_get_toplevels()[0])).width
			y = gtk.gdk.screen_get_default().get_monitor_geometry(gtk.gdk.screen_get_default().get_monitor_at_window(gtk.gdk.window_get_toplevels()[0])).height
		
		else:
			
			x = self.optionlist[10]
			y = self.optionlist[11]
			self.window.resize(x, y)
			
		# Set the sizes of the widgets
		if self.optionlist[0] and self.optionlist[3]:
			menu_size = 0
			tool_size = 0
			status_size = 0
			hscroll_size = 0
			vscroll_size = 0
		
		elif self.optionlist[18]:
			
			menu_size = self.optionlist[25] * self.ui.get_widget('/Menu').size_request()[1]
			tool_size = self.optionlist[26] * self.toolbar.size_request()[1]
			status_size = self.optionlist[27] * self.statusbar.size_request()[1]
			hscroll_size = 0
			vscroll_size = 0
			
		else:
			menu_size = self.optionlist[25] * self.ui.get_widget('/Menu').size_request()[1]
			tool_size = self.optionlist[26] * self.toolbar.size_request()[1]
			status_size = self.optionlist[27] * self.statusbar.size_request()[1]
			hscroll_size = self.hscroll.size_request()[1] * (1 - self.optionlist[22])
			vscroll_size = self.vscroll.size_request()[0] * (1 - self.optionlist[22])
		
		self.window.show()
		
		# Show comments
		if self.show_comments:
			
			self.image.hide()
			self.image2.hide()
			
			# Always show scrollbars when viewing comments
			hscroll_size = self.hscroll.size_request()[1] * (1 - self.optionlist[22])
			vscroll_size = self.vscroll.size_request()[0] * (1 - self.optionlist[22])
			self.hscroll.show()
			self.vscroll.show()
			
			# Set the text colour to white if using a dark background and to black if using light background 
			if self.optionlist[19] + self.optionlist[20] + self.optionlist[21] < 80000:
				self.comment_label.modify_fg(gtk.STATE_NORMAL, gtk.gdk.color_parse('#FFFFFF'))
			else:
				self.comment_label.modify_fg(gtk.STATE_NORMAL, gtk.gdk.color_parse('#000000'))
			
			# Try to open the comments file
			try:
				comment_file = open(self.comment[self.comment_number], 'r')
				comment = unicode('--- Comment file ' + str(self.comment_number + 1) + ' of ' + str(len(self.comment)) + 
				' - ' + os.path.basename(self.comment[self.comment_number]) + ' ---\n\n' + comment_file.read(), sys.getfilesystemencoding())
				comment_file.close()
				self.comment_label.set_text(comment)
			except:
				comment = unicode('Could not read "' + os.path.basename(self.comment[self.comment_number]) + '"', sys.getfilesystemencoding())
				self.comment_label.set_text(comment)
				
			self.comment_label.show()
			self.comment_label.set_padding(10, 10)
			self.layout.set_size(self.comment_label.get_layout().get_pixel_size()[0] + 20, self.comment_label.get_layout().get_pixel_size()[1] + 20)
			
			self.vadjust_upper = (self.vadjust.upper - self.window.get_size()[1] + hscroll_size + status_size + tool_size + menu_size)
			self.hadjust_upper = self.hadjust.upper - self.window.get_size()[0] + vscroll_size
			
			# Set window title and statusbar message
			if self.archive_type != "":
				
				self.window.set_title(unicode(os.path.basename(self.path) + ' --- Comment ' + str(self.comment_number + 1) + 
				' of ' + str(len(self.comment)) + '', sys.getfilesystemencoding()))
				
				self.statusbar.push(0, unicode('Comment ' + str(self.comment_number + 1) + ' of ' + str(len(self.comment)) + 
				'    ---    ' + os.path.basename(self.path) , sys.getfilesystemencoding()))
				
			else:
				
				self.window.set_title(unicode(os.path.basename(os.path.dirname(self.path)) + ' --- Comment ' + 
				str(self.comment_number + 1) + ' of ' + str(len(self.comment)) + '', sys.getfilesystemencoding()))
				
				self.statusbar.push(0, unicode('Comment ' + str(self.comment_number + 1) + ' of ' + str(len(self.comment)) +
				'    ---    ' + os.path.basename(os.path.dirname(self.path)), sys.getfilesystemencoding()))
			
		# Not viewing comments
		else:
			
			self.comment_label.hide()
			
			if self.file_exist == 1:
				
				backwards_caching = 0
				
				# Single page mode
				if self.optionlist[4] == 0 or len(self.file) == self.file_number + 1:
					
					self.stored_double = 0
					
					# Switching from double page mode to single page mode
					if self.file_number == self.old_file_number and self.cached == 2 and self.optionlist[7]:
						
						pixbuf = self.stored_pixbuf
						self.cached_pixbuf = self.stored_pixbuf2
						self.cached = 1
						backwards_caching = 1
						
					# Refreshing the same image as is already being viewed
					elif self.file_number == self.old_file_number:
						
						pixbuf = self.stored_pixbuf
						
					# Using nornal single mode cache
					elif (self.file_number == self.old_file_number + 1 or self.file_number == self.old_file_number + 2) and self.cached == 1 and self.optionlist[7]:
						
						pixbuf = self.cached_pixbuf
						self.stored_pixbuf = pixbuf
						
					# No valid cache is present or cache option turned off
					else:
						
						# Flipping backwards the previously viewed image is used as the new cache
						if self.file_number == self.old_file_number - 1 and self.cached == 1 and self.optionlist[7]:
							
							self.cached_pixbuf = self.stored_pixbuf
							backwards_caching = 1
						
						# Load new image file from disk
						try:
							pixbuf = gtk.gdk.pixbuf_new_from_file(self.file[self.file_number])
							self.stored_pixbuf = pixbuf
						except:
							if os.path.exists(self.base_dir):
								shutil.rmtree(self.base_dir)
							if len(os.listdir('/tmp/comix')) == 0:
								shutil.rmtree('/tmp/comix')
							print ''
							print 'ERROR:'
							print 'Could not load image "' + os.path.basename(self.file[self.file_number]) + '" in ' + os.path.dirname(self.file[self.file_number]) + '.'
							print ''
							print 'Either "' + os.path.basename(self.file[self.file_number]) + '" is not readable, corrupt'
							print 'or "' + os.path.basename(self.file[self.file_number]) + '" is incorrectly identified as an image file.'
							print 'The application has been terminated, please check the image file and/or'
							print 'read and write permissions in ' + os.path.dirname(self.file[self.file_number]) + '.'
							print ''
							sys.exit(1)
							
					try:
						del self.stored_pixbuf2
					except:
						pass
					try:
						del self.cached_pixbuf2
					except:
						pass
					try:
						del self.pixbuf2
					except:
						pass
					gc.collect()
					
					self.image1_width = pixbuf.get_width()
					self.image1_height = pixbuf.get_height()
					
					# Scale the image to fit screen or to the current zoom level
					if ((pixbuf.get_width() > x - vscroll_size or pixbuf.get_height() > y - hscroll_size - menu_size - tool_size - status_size
					or self.optionlist[9] == 1) and self.optionlist[18] == 1 or (self.optionlist[17] != 100 and self.optionlist[18] == 0)):
						
						if self.optionlist[18] == 1:
							
							if (1.0 * pixbuf.get_width() / x) > (1.0 * pixbuf.get_height() / (y - menu_size - tool_size)):
								
								pixbuf = pixbuf.scale_simple(x, pixbuf.get_height() * x / pixbuf.get_width(), self.optionlist[2])
								
							else:
								
								pixbuf = (pixbuf.scale_simple(pixbuf.get_width() * (y - menu_size - tool_size - status_size) 
								/ pixbuf.get_height(), y - menu_size - tool_size - status_size, self.optionlist[2]))
							
						else:
							
							pixbuf = pixbuf.scale_simple(int(pixbuf.get_width() * self.optionlist[17] / 100), int(pixbuf.get_height() * self.optionlist[17] / 100), self.optionlist[2])
							
					self.image1_scaled_width = pixbuf.get_width()
					self.image1_scaled_height = pixbuf.get_height()
					pixbuf.saturate_and_pixelate(pixbuf, self.optionlist[6] / 10, False)
					
					# Move the layout to align the image in the center
					x_move = (x - pixbuf.get_width() - vscroll_size) / 2
					y_move = (y - pixbuf.get_height() - hscroll_size - menu_size - tool_size - status_size) / 2
						
					if x_move < 0:
						x_move = 0
					if y_move < 0:
						y_move = 0
						
					self.layout.set_size(pixbuf.get_width(), pixbuf.get_height())
					self.layout.move(self.image_box, x_move, y_move)
					
					# Set the image from the pixbuf
					self.image.set_from_pixbuf(pixbuf)
					self.image2.hide()
					self.image.show()
					
					# Set window title and statusbar message
					if self.archive_type != "":
						
						self.window.set_title(unicode(os.path.basename(self.path) + ' --- [' + str(self.file_number + 1) +
						' / ' + str(len(self.file)) + ']', sys.getfilesystemencoding()))
						
						self.statusbar.push(0, unicode(('[' + str(self.file_number + 1) + ' / ' + str(len(self.file)) + ']    ---    ' + 
						os.path.basename(self.path) + '    ---    ' + str(self.image1_width) + 'x' + str(self.image1_height) + '    ---    ' 
						+ str('%.1f' % (100.0 * self.image1_scaled_height / self.image1_height)) + '%'), sys.getfilesystemencoding()))
						
					else:
						
						self.window.set_title(unicode(os.path.basename(os.path.dirname(self.path)) + ' --- [' + 
						str(self.file_number + 1) + ' / ' + str(len(self.file)) + ']', sys.getfilesystemencoding()))
						
						self.statusbar.push(0, unicode(('[' + str(self.file_number + 1) + ' / ' + str(len(self.file)) + ']    ---    ' + 
						os.path.basename(os.path.dirname(self.path)) + '    ---    ' + str(self.image1_width) + 'x' + str(self.image1_height) + '    ---    ' 
						+ str('%.1f' % (100.0 * self.image1_scaled_height / self.image1_height)) + '%'), sys.getfilesystemencoding()))
				
				# Double page mode
				else:
					
					# If refreshing the two images previously viewed
					if self.file_number == self.old_file_number and self.stored_double == 1:
						
						pixbuf = self.stored_pixbuf
						pixbuf2 = self.stored_pixbuf2
						
					# Using normal double page mode cache
					elif self.file_number == self.old_file_number + 2 and self.cached == 2 and self.optionlist[7]:
						
						pixbuf = self.cached_pixbuf
						pixbuf2 = self.cached_pixbuf2
						self.stored_pixbuf = pixbuf
						self.stored_pixbuf2 = pixbuf2
					
					# No valid caches present or the cache option turned off
					else:
						
						# If flipping backwards the previously viewed images is used as the new cache
						if self.file_number == self.old_file_number - 2 and self.cached == 2 and self.optionlist[7]:
							
							self.cached_pixbuf = self.stored_pixbuf
							self.cached_pixbuf2 = self.stored_pixbuf2
							backwards_caching = 1
						
						# Load new files from disk
						try:
							pixbuf = gtk.gdk.pixbuf_new_from_file(self.file[self.file_number])
							pixbuf2 = gtk.gdk.pixbuf_new_from_file(self.file[self.file_number + 1])
							self.stored_pixbuf = pixbuf
							self.stored_pixbuf2 = pixbuf2
							self.stored_double = 1
						except:
							if os.path.exists(self.base_dir):
								shutil.rmtree(self.base_dir)
							if len(os.listdir('/tmp/comix')) == 0:
								shutil.rmtree('/tmp/comix')
							print ''
							print 'ERROR:'
							print 'Could not load image "' + os.path.basename(self.file[self.file_number]) + '" or "' +  os.path.basename(self.file[self.file_number + 1]) + '" in ' + os.path.dirname(self.file[self.file_number]) + '.'
							print ''
							print 'Either "' + os.path.basename(self.file[self.file_number]) + '" or "' +  os.path.basename(self.file[self.file_number + 1]) + '" is not readable, corrupt'
							print 'or "' + os.path.basename(self.file[self.file_number]) + '" or "' +  os.path.basename(self.file[self.file_number + 1]) + '" is incorrectly identified as an image file.'
							print 'The application has been terminated, please check the image files and/or'
							print 'read and write permissions in ' + os.path.dirname(self.file[self.file_number]) + '.'
							print ''
							sys.exit(1)
						
					self.image1_width = pixbuf.get_width()
					self.image1_height = pixbuf.get_height()
					self.image2_width = pixbuf2.get_width()
					self.image2_height = pixbuf2.get_height()
					
					if pixbuf.get_height() > pixbuf2.get_height():
						height = pixbuf.get_height()
					else:
						height = pixbuf2.get_height()
						
					width = pixbuf.get_width() + pixbuf2.get_width()
					
					# Scale the images to fit screen or to the current zoom level
					if ((width > x - vscroll_size or height > y - hscroll_size - menu_size - tool_size - status_size 
					or self.optionlist[9] == 1) and self.optionlist[18] == 1 or (self.optionlist[17] != 100 and self.optionlist[18] == 0)):
						
						if self.optionlist[18] == 1:
							
							if self.optionlist[32] and (1.0 * width / x) < (1.0 * height / (y - menu_size - tool_size - status_size)):
								
								if pixbuf.get_height() > pixbuf2.get_height():
									
									pixbuf = (pixbuf.scale_simple((y - menu_size - tool_size - status_size) * pixbuf.get_width() / 
									height, (y - menu_size - tool_size - status_size) * pixbuf.get_height() / height, self.optionlist[2]))
									
									if pixbuf2.get_width() > x - pixbuf.get_width() or pixbuf2.get_height() > y - menu_size - tool_size - status_size or self.optionlist[9] == 1:
										
										if 1.0 * pixbuf2.get_width() / (x - pixbuf.get_width()) > 1.0 * pixbuf2.get_height() / (y - menu_size - tool_size - status_size):
											
											pixbuf2 = pixbuf2.scale_simple(x - pixbuf.get_width(), pixbuf2.get_height() * (x - pixbuf.get_width()) / pixbuf2.get_width(), self.optionlist[2])
											
										else:
											
											pixbuf2 = (pixbuf2.scale_simple(pixbuf2.get_width() * (y - menu_size - tool_size - status_size) 
											/ pixbuf2.get_height(), y - menu_size - tool_size - status_size, self.optionlist[2]))
										
								else:
									
									pixbuf2 = (pixbuf2.scale_simple((y - menu_size - tool_size - status_size) * pixbuf2.get_width() / 
									height, (y - menu_size - tool_size - status_size) * pixbuf2.get_height() / height, self.optionlist[2]))
									
									if pixbuf.get_width() > x - pixbuf2.get_width() or pixbuf.get_height() > y - menu_size - tool_size - status_size or self.optionlist[9] == 1:
										
										if 1.0 * pixbuf.get_width() / (x - pixbuf2.get_width()) > 1.0 * pixbuf.get_height() / (y - menu_size - tool_size - status_size):
											
											pixbuf = pixbuf.scale_simple(x - pixbuf2.get_width(), pixbuf.get_height() * (x - pixbuf2.get_width()) / pixbuf.get_width(), self.optionlist[2])
											
										else:
											
											pixbuf = (pixbuf.scale_simple(pixbuf.get_width() * (y - menu_size - tool_size - status_size) 
											/ pixbuf.get_height(), y - menu_size - tool_size - status_size, self.optionlist[2]))
										
							else:
								
								if (1.0 * width / x) > (1.0 * height / (y - menu_size - tool_size - status_size)):
									
									pixbuf = pixbuf.scale_simple(x * pixbuf.get_width() / width, x * pixbuf.get_height() / width, self.optionlist[2])
									pixbuf2 = pixbuf2.scale_simple(x * pixbuf2.get_width() / width, x * pixbuf2.get_height() / width, self.optionlist[2])
									
								else:
									
									pixbuf = (pixbuf.scale_simple((y - menu_size - tool_size - status_size) * pixbuf.get_width() / 
									height, (y - menu_size - tool_size - status_size) * pixbuf.get_height() / height, self.optionlist[2]))
									pixbuf2 = (pixbuf2.scale_simple((y - menu_size - tool_size - status_size) * pixbuf2.get_width() / 
									height, (y - menu_size - tool_size - status_size) * pixbuf2.get_height() / height, self.optionlist[2]))
								
						else:
							
							pixbuf = pixbuf.scale_simple(int(pixbuf.get_width() * self.optionlist[17] / 100), int(pixbuf.get_height() * self.optionlist[17] / 100), self.optionlist[2])
							pixbuf2 = pixbuf2.scale_simple(int(pixbuf2.get_width() * self.optionlist[17] / 100), int(pixbuf2.get_height() * self.optionlist[17] / 100), self.optionlist[2])
					
					# Switch position of the images if in "manga mode"
					if self.optionlist[8] == 1:
						self.image_box.reorder_child(self.image, -1)
					else:
						self.image_box.reorder_child(self.image, 0)
						
					pixbuf.saturate_and_pixelate(pixbuf, self.optionlist[6] / 10, False)
					pixbuf2.saturate_and_pixelate(pixbuf2, self.optionlist[6] / 10, False)				
					self.image1_scaled_width = pixbuf.get_width()
					self.image1_scaled_height = pixbuf.get_height()
					self.image2_scaled_width = pixbuf2.get_width()
					self.image2_scaled_height = pixbuf2.get_height()
					
					if pixbuf.get_height() > pixbuf2.get_height():
						height = pixbuf.get_height()
					else:
						height = pixbuf2.get_height()
						
					# Move the layout to align the images in the center
					x_move = (x - (pixbuf.get_width() + pixbuf2.get_width()) - vscroll_size) / 2
					y_move = (y - height - hscroll_size - menu_size - tool_size - status_size) / 2
						
					if x_move < 0:
						x_move = 0
					if y_move < 0:
						y_move = 0
						
					self.layout.move(self.image_box, x_move, y_move)
					self.layout.set_size(pixbuf.get_width() + pixbuf2.get_width(), height)
					
					# Set the images from the pixbuf
					self.image.set_from_pixbuf(pixbuf)
					self.image2.set_from_pixbuf(pixbuf2)
					self.image.show()
					self.image2.show()
					
					# Set window title and statusbar message
					if self.archive_type != "":
						
						self.window.set_title(unicode(os.path.basename(self.path) + ' --- [' + str(self.file_number + 1) + ',' 
						+ str(self.file_number + 2) + ' / ' + str(len(self.file)) + ']', sys.getfilesystemencoding()))
						
						self.statusbar.push(0, unicode(('[' + str(self.file_number + 1) + ',' + str(self.file_number + 2) + ' / ' + str(len(self.file)) + ']    ---    ' 
						+ os.path.basename(self.path) + '    ---    ' + str(self.image1_width) + 'x' + str(self.image1_height) + ' , ' + str(self.image2_width) + 'x' + str(self.image2_height) 
						+ '    ---    ' + str('%.1f' % (100.0 * self.image1_scaled_height / self.image1_height)) + '%' +
						' , ' + str('%.1f' % (100.0 * self.image2_scaled_height / self.image2_height)) + '%'), sys.getfilesystemencoding()))
						
					else:
						
						self.window.set_title(unicode(os.path.basename(os.path.dirname(self.path)) + ' --- [' + str(self.file_number + 1) +
						',' + str(self.file_number + 2) + ' / ' + str(len(self.file)) + ']', sys.getfilesystemencoding()))
						
						self.statusbar.push(0, unicode(('[' + str(self.file_number + 1) + ',' + str(self.file_number + 2) + ' / ' + str(len(self.file)) + ']    ---    ' 
						+ os.path.basename(os.path.dirname(self.path) ) + '    ---    ' + str(self.image1_width) + 'x' + str(self.image1_height) + ' , ' + str(self.image2_width) + 'x' + str(self.image2_height) 
						+ '    ---    ' + str('%.1f' % (100.0 * self.image1_scaled_height / self.image1_height)) + '%' +
						' , ' + str('%.1f' % (100.0 * self.image2_scaled_height / self.image2_height)) + '%'), sys.getfilesystemencoding()))
				
				# Set values used when dragging the image sround 				
				self.vadjust_upper = self.vadjust.upper - self.window.get_size()[1] + hscroll_size + status_size + tool_size + menu_size
				self.hadjust_upper = self.hadjust.upper - self.window.get_size()[0] + vscroll_size 
			
			# No file loaded		
			else:
				
				self.window.set_title("Comix")
				self.image.hide()
				
				if not self.filetype_error:
					
					self.statusbar.push(0, '')
				
		# Update the cursor
		if self.optionlist[24] and self.optionlist[0]:
			
			pixmap = gtk.gdk.Pixmap(None, 1, 1, 1)
			color = gtk.gdk.Color()
			cursor = gtk.gdk.Cursor(pixmap, pixmap, color, color, 0, 0)
			gtk.gdk.window_get_toplevels()[1].set_cursor(cursor)
				
		else:
			
			gtk.gdk.window_get_toplevels()[1].set_cursor(None)
		
		# Set the scrollbars back to default
		if self.change_adjustment:
			
			self.vadjust.set_value(0)
			if self.optionlist[8] and not self.show_comments:
				self.hadjust.set_value(self.hadjust_upper)
			else:
				self.hadjust.set_value(0)
				
			self.change_adjustment = 0
		
		# Update image(s) now except when resizing the image (looks choppy then)
		if not self.resize_event:
			while gtk.events_pending():
				gtk.main_iteration(False)
		
		# Cache page(s)
		if self.file_exist and self.optionlist[7] and not self.show_comments:
			
			# Cache in double page mode
			if self.file_number + 3 < len(self.file) and self.optionlist[4] and (self.file_number != self.old_file_number or self.cached != 2) and not backwards_caching:
				
				try:
					self.cached_pixbuf = gtk.gdk.pixbuf_new_from_file(self.file[self.file_number + 2])
					self.cached_pixbuf2 = gtk.gdk.pixbuf_new_from_file(self.file[self.file_number + 3])
					self.cached = 2
				except:
					if os.path.exists(self.base_dir):
						shutil.rmtree(self.base_dir)
					print ''
					print 'ERROR:'
					print 'Could not load image "' + os.path.basename(self.file[self.file_number + 2]) + '" or "' +  os.path.basename(self.file[self.file_number + 3]) + '" in ' + os.path.dirname(self.file[self.file_number]) + '.'
					print ''
					print 'Either "' + os.path.basename(self.file[self.file_number]) + '" or "' +  os.path.basename(self.file[self.file_number + 1]) + '" is not readable, corrupt'
					print 'or "' + os.path.basename(self.file[self.file_number]) + '" or "' +  os.path.basename(self.file[self.file_number + 1]) + '" is incorrectly identified as an image file.'
					print 'The application has been terminated, please check the image files and/or'
					print 'read and write permissions in ' + os.path.dirname(self.file[self.file_number]) + '.'
					print ''
					sys.exit(1)
			
			# Cache for last page in double page mode
			elif self.file_number + 2 < len(self.file) and self.optionlist[4] and (self.file_number != self.old_file_number or self.cached != 2) and not backwards_caching:
				
				try:
					self.cached_pixbuf = gtk.gdk.pixbuf_new_from_file(self.file[self.file_number + 2])
					self.cached = 1
				except:
					if os.path.exists(self.base_dir):
						shutil.rmtree(self.base_dir)
					if len(os.listdir('/tmp/comix')) == 0:
						shutil.rmtree('/tmp/comix')
					print ''
					print 'ERROR:'
					print 'Could not load image "' + os.path.basename(self.file[self.file_number + 2]) + '" in ' + os.path.dirname(self.file[self.file_number]) + '.'
					print ''
					print 'Either "' + os.path.basename(self.file[self.file_number]) + '" or "' +  os.path.basename(self.file[self.file_number + 1]) + '" is not readable, corrupt'
					print 'or "' + os.path.basename(self.file[self.file_number]) + '" or "' +  os.path.basename(self.file[self.file_number + 1]) + '" is incorrectly identified as an image file.'
					print 'The application has been terminated, please check the image files and/or'
					print 'read and write permissions in ' + os.path.dirname(self.file[self.file_number]) + '.'
					print ''
					sys.exit(1)
				
			# Cache for single page mode
			elif self.file_number + 1 < len(self.file) and not self.optionlist[4] and self.file_number != self.old_file_number and not backwards_caching:
				
				try:
					self.cached_pixbuf = gtk.gdk.pixbuf_new_from_file(self.file[self.file_number + 1])
					self.cached = 1
				except:
					if os.path.exists(self.base_dir):
						shutil.rmtree(self.base_dir)
					if len(os.listdir('/tmp/comix')) == 0:
						shutil.rmtree('/tmp/comix')
					print ''
					print 'ERROR:'
					print 'Could not load image "' + os.path.basename(self.file[self.file_number + 1]) + '" in ' + os.path.dirname(self.file[self.file_number]) + '.'
					print ''
					print 'Either "' + os.path.basename(self.file[self.file_number]) + '" is not readable, corrupt'
					print 'or "' + os.path.basename(self.file[self.file_number]) + '" is incorrectly identified as an image file.'
					print 'The application has been terminated, please check the image file and/or'
					print 'read and write permissions in ' + os.path.dirname(self.file[self.file_number]) + '.'
					print ''
					sys.exit(1)
					
		self.old_file_number = self.file_number
		
		try:
			del pixbuf
		except:
			pass
		try:
			del pixbuf2
		except:
			pass
			
		if not self.optionlist[7]:
			
			self.cached = 0
			
			try:
				del self.cached_pixbuf
			except:
				pass
			try:
				del self.cached_pixbuf2
			except:
				pass
			
		gc.collect()
		
	def __init__(self):
		
		dir_number = 1
		
		while(1):
			
			if not os.path.exists('/tmp/comix/' + str(dir_number)):
				
				os.makedirs('/tmp/comix/' + str(dir_number))
				self.base_dir = '/tmp/comix/' + str(dir_number) + '/'
				break
				
			dir_number += 1
		
		# Set window icon
		if os.path.exists(os.getenv('XDG_DATA_DIRS', '') + '/pixmaps/comix.png'):
			icon_path = os.getenv('XDG_DATA_DIRS','') + '/pixmaps/comix.png'
		elif os.path.exists(os.getenv('XDG_DATA_DIRS','') + 'pixmaps/comix.png'):
			icon_path = os.getenv('XDG_DATA_DIRS','') + 'pixmaps/comix.png'				
		elif os.path.exists('/usr/local/share/pixmaps/comix.png'):
			icon_path = '/usr/local/share/pixmaps/comix.png'
		elif os.path.exists('/usr/share/pixmaps/comix.png'):
			icon_path = '/usr/share/pixmaps/comix.png'
		
		try:
			icon = gtk.gdk.pixbuf_new_from_file(icon_path)
			gtk.window_set_default_icon(icon)
		except:
			pass
		
		# Parse comixrc file and set the corresponding preferences
		if os.path.exists(os.getenv('HOME', '') + "/.comix/comixrc"):
			
			comixrc = open(os.getenv('HOME', '') + "/.comix/comixrc", 'r')
			temp = comixrc.readlines()
			comixrc.close()
			
			if len(temp) > 29:
				
				if temp[0] == "fullscreen=TRUE\n":
					self.optionlist[1] = 1
					
				if temp[1] == "double_page=TRUE\n":
					self.optionlist[5] = 1
					
				if temp[2] == "quality=NEAREST\n":
					self.optionlist[2] = gtk.gdk.INTERP_NEAREST
				elif temp[2] == "quality=BILINEAR\n":
					self.optionlist[2] = gtk.gdk.INTERP_BILINEAR
				elif temp[2] == "quality=HYPER\n":
					self.optionlist[2] = gtk.gdk.INTERP_HYPER
					
				if temp[4] == "cache_next=FALSE\n":
					self.optionlist[7] = 0
					
				if temp[5] == "flip_double=TRUE\n":
					self.optionlist[8] = 1
					
				if temp[6][:-1].isdigit():
					if float(temp[6]) >=0 and float(temp[6]) <= 30:
						self.optionlist[6] = float(temp[6])
						
				if temp[7] == "stretch=TRUE\n":
					self.optionlist[9] = 1
					
				if temp[12] == "save_position_and_size=TRUE\n":
					self.optionlist[14] = 1
					if temp[8][:-1].isdigit():
						if (int(temp[8][:-1]) >= 100 and int(temp[8][:-1]) <= gtk.gdk.screen_get_default().get_monitor_geometry(
						gtk.gdk.screen_get_default().get_monitor_at_window(gtk.gdk.window_get_toplevels()[0])).width):
							self.optionlist[10] = int(temp[8][:-1])	
					if temp[9][:-1].isdigit():
						if (int(temp[9][:-1]) >= 100 and int(temp[9][:-1]) <= gtk.gdk.screen_get_default().get_monitor_geometry(
							gtk.gdk.screen_get_default().get_monitor_at_window(gtk.gdk.window_get_toplevels()[0])).height):
							self.optionlist[11] = int(temp[9][:-1])
					if temp[10][:-1].isdigit():
						if (int(temp[10][:-1]) >= 0 and int(temp[10][:-1]) <= gtk.gdk.screen_get_default().get_monitor_geometry(
							gtk.gdk.screen_get_default().get_monitor_at_window(gtk.gdk.window_get_toplevels()[0])).width):
							self.optionlist[12] = int(temp[10][:-1])
					if temp[11][:-1].isdigit():
						if (int(temp[11][:-1]) >= 0 and int(temp[11][:-1]) <= gtk.gdk.screen_get_default().get_monitor_geometry(
							gtk.gdk.screen_get_default().get_monitor_at_window(gtk.gdk.window_get_toplevels()[0])).height):
							self.optionlist[13] = int(temp[11][:-1])	
					self.window.move(self.optionlist[12], self.optionlist[13])
					
				if os.path.exists(temp[13][:-1]):
					self.optionlist[15] = temp[13][:-1]
					
				if temp[14] == "fit_to_screen=FALSE\n":
					self.optionlist[16] = 0
					self.optionlist[18] = 0
					
				if temp[15] == "scroll_off_page=TRUE\n":
					self.optionlist[30] = 1
				
				if temp[3] == "hide_bars=FALSE\n":
					self.optionlist[3] = 0
					
				if temp[16][:-1].isdigit():
					if int(temp[16][:-1]) >= 0 and int(temp[16][:-1]) <= 65535:
						self.optionlist[19] = int(temp[16][:-1])
							
				if temp[17][:-1].isdigit():
					if int(temp[17][:-1]) >= 0 and int(temp[17][:-1]) <= 65535:
						self.optionlist[20] = int(temp[17][:-1])
							
				if temp[18][:-1].isdigit():
					if int(temp[18][:-1]) >= 0 and int(temp[18][:-1]) <= 65535:
						self.optionlist[21] = int(temp[18][:-1])
							
				if temp[19] == "hide_scrollbars=TRUE\n":
					self.optionlist[22] = 1
					
				if temp[20] == "next_archive=TRUE\n":
					self.optionlist[23] = 1
					
				if temp[21] == "hide_cursor=TRUE\n":
					self.optionlist[24] = 1
					
				if temp[22] == "show_menubar=FALSE\n":
					self.optionlist[25] = 0
					
				if temp[23] == "show_toolbar=FALSE\n":
					self.optionlist[26] = 0
					
				if temp[24] == "show_statusbar=FALSE\n":
					self.optionlist[27] = 0
					
				if temp[25] == "view_comments=TRUE\n":
					self.optionlist[28] = 1
					
				if len(temp[26]) > 1:
					self.optionlist[29] = temp[26][:-1]
					
				if temp[27] == "scroll_horiz=TRUE\n":
					self.optionlist[31] = 1
					
				if temp[28] == "smart_scale=TRUE\n":
					self.optionlist[32] = 1
					
				if temp[29] == "tool_style=text\n":
					self.optionlist[33] = gtk.TOOLBAR_TEXT
				elif temp[29] == "tool_style=both\n":
					self.optionlist[33] = gtk.TOOLBAR_BOTH
				else:
					self.optionlist[33] = gtk.TOOLBAR_ICONS
		
		# Parse bookmarks file
		if os.path.exists(os.environ['HOME'] + "/.comix/bookmarks"):
			
			bookmarks = open(os.environ['HOME'] + "/.comix/bookmarks", 'r')
			temp = bookmarks.readlines()
			bookmarks.close()
			
			for i in range(len(temp)):
				
				if i % 2 == 0:
					
					self.bookmarks.append(temp[i][:-1])
					
				else:
					
					if temp[i][:-1].isdigit():
						self.bookmark_numbers.append(int(temp[i][:-1]))
					else:
						self.bookmark_numbers.append(1)
		
		# Create window and set background colour
		self.window.set_size_request(100, 100)
		self.layout.modify_bg(gtk.STATE_NORMAL, gtk.gdk.colormap_get_system().alloc_color(gtk.gdk.Color(self.optionlist[19], self.optionlist[20], self.optionlist[21]), False, True))
		self.create_windows(None)
		
		# Apply masks
		self.layout.drag_dest_set(gtk.DEST_DEFAULT_HIGHLIGHT | gtk.DEST_DEFAULT_DROP, [("text/plain", 0, 80)], gtk.gdk.ACTION_DEFAULT)
		self.layout.set_events(gtk.gdk.BUTTON1_MOTION_MASK|gtk.gdk.BUTTON2_MOTION_MASK|gtk.gdk.BUTTON_RELEASE_MASK)
		self.window.add_events(gtk.gdk.BUTTON_PRESS_MASK)
		
		# Connect event handlers
		self.window.connect('delete_event', self.close_application)
		self.window.connect('key_press_event', self.key_press_event)
		self.window.connect('button_press_event', self.mouse_click_event)
		self.window.connect('configure_event',self.area_resize_event)
		self.window.connect('scroll_event', self.scroll_wheel_event)
		self.options_window.connect('delete_event', self.close_options)
		self.file_select.connect('delete_event', self.file_select_cancel)
		self.invalid_filename_dialog.connect('response', self.close_invalid_filename)
		self.invalid_filename_dialog.connect('delete_event', self.close_invalid_filename)
		self.permission_dialog.connect('response', self.close_permission_dialog)
		self.permission_dialog.connect('delete_event', self.close_permission_dialog)
		self.file_dialog.connect('response', self.close_file_info)
		self.file_dialog.connect('delete_event', self.close_file_info)
		self.about_dialog.connect('response', self.close_about)
		self.about_dialog.connect('delete_event', self.close_about)
		self.page_dialog.connect('response', self.save_and_close_go_to_page)
		self.page_dialog.connect('delete_event', self.close_go_to_page)
		self.bookmark_dialog.connect('response', self.save_and_close_bookmark_manager)
		self.bookmark_dialog.connect('delete_event', self.close_bookmark_manager)
		self.filechooser_dialog.connect('delete_event', self.close_filechooser)
		self.convert_dialog.connect('response', self.save_and_close_convert)
		self.convert_dialog.connect('delete_event', self.close_convert)
		self.combobox_convert.connect('changed', self.change_convert)
		self.overwrite_dialog.connect('response', self.save_and_close_overwrite)
		self.overwrite_dialog.connect('delete_event', self.close_overwrite)
		self.layout.connect('drag_motion', self.drag_motion)
		self.layout.connect('drag_data_received', self.drag_data)
		self.layout.connect('motion_notify_event', self.drag_image)
		self.layout.connect('button_release_event', self.button_release)
		
		# Create actions for the menus
		self.actiongroup.add_actions([('Next', gtk.STOCK_GO_FORWARD, 'Next page', 'Page_Down', None, self.next_page),
		('Previous', gtk.STOCK_GO_BACK, 'Previous page', 'Page_Up', None, self.previous_page),
		('First', gtk.STOCK_GOTO_FIRST, 'First page', 'Home', None, self.first_page),
		('Last',gtk.STOCK_GOTO_LAST, 'Last page', 'End', None, self.last_page),
		('Go', gtk.STOCK_JUMP_TO, '_Go to page...', 'g', None, self.open_go_to_page),
		('Zoom', None, 'Zoom'),
		('Zin', gtk.STOCK_ZOOM_IN, 'Zoom in', 'KP_Add', None, self.zoom_in),
		('Zout', gtk.STOCK_ZOOM_OUT, 'Zoom out', 'KP_Subtract', None, self.zoom_out),
		('Zoriginal', gtk.STOCK_ZOOM_100, 'Original size', '<Control>0', None, self.zoom_original),
		('Zwidth', gtk.STOCK_ZOOM_FIT, 'Fit _width', 'w', None, self.zoom_width),
		('Zheight', gtk.STOCK_ZOOM_FIT, 'Fit _height', 'h', None, self.zoom_height),
		('Zfit', gtk.STOCK_ZOOM_FIT, '_Best fit', 'b', None, self.zoom_fit),
		('Book', None, 'Bookmarks'),
		('Save_book', gtk.STOCK_ADD, 'A_dd bookmark', '<Control>d', None, self.save_bookmark),
		('Clear_book', gtk.STOCK_CLEAR, 'Clear bookmarks', '', None, self.clear_bookmarks),
		('Bookmark_manager', gtk.STOCK_EDIT, '_Edit bookmarks...', '<Control>b', None, self.open_bookmark_manager),
		('Options', gtk.STOCK_PREFERENCES, 'Preferences', '', None, self.open_options),
		('About', gtk.STOCK_ABOUT, 'About', '', None, self.open_about),
		('File', gtk.STOCK_PROPERTIES, 'Properties', '<Alt>Return', None, self.open_file_info),
		('Comments', gtk.STOCK_DIALOG_INFO, 'View _comments', 'c', None, self.comment_switch),
		('Open', gtk.STOCK_OPEN, '_Open...', '<Control>o', None, self.open_file),
		('Convert', gtk.STOCK_CONVERT, 'Convert...', '', None, self.open_convert),
		('Close', gtk.STOCK_CLOSE, '_Close', '<Control>w', None, self.blank_page),
		('Quit', gtk.STOCK_QUIT, '_Quit', '<Control>q', None, self.short_close_application),
		('menu_file', None, 'File'),
		('menu_edit', None, 'Edit'),
		('menu_view', None, 'View'),
		('menu_go', None, 'Go'),
		('menu_help', None, 'Help')])
		self.actiongroup.add_toggle_actions([('Fullscreen', None, '_Fullscreen', 'f', None, self.fullscreen_switch),
		('Double', None, '_Double page mode', 'd', None, self.double_page_switch),
		('Toolbar', None, 'Toolbar', '', None, self.toolbar_switch),
		('Menubar', None, 'Menubar', '', None, self.menubar_switch),
		('Statusbar', None, 'Statusbar', '', None, self.statusbar_switch),
		('Scrollbars', None, 'Scrollbars', '', None, self.scrollbars_switch),
		('Fit', gtk.STOCK_ZOOM_FIT, 'Fit-to-_screen mode', 's', None, self.fit_to_screen_switch)])
		
		self.update_bookmarks()
		
		self.accelgroup = self.ui.get_accel_group()
		self.window.add_accel_group(self.accelgroup)
		
		# Add buttons to the toolbar
		self.button_previous.connect_object("clicked", self.previous_page, None)
		self.toolbar.insert(self.button_previous, -1)
		self.button_previous.show()	
		
		self.button_next.connect_object("clicked", self.next_page, None)
		self.toolbar.insert(self.button_next, -1)
		self.button_next.show()	
		
		self.button_first.connect_object("clicked", self.first_page, None)
		self.toolbar.insert(self.button_first, -1)
		self.button_first.show()	
		
		self.button_last.connect_object("clicked", self.last_page, None)
		self.toolbar.insert(self.button_last, -1)
		self.button_last.show()	
		
		self.button_go.connect_object("clicked", self.open_go_to_page, None)
		self.toolbar.insert(self.button_go, -1)
		self.button_go.show()	
		
		item = gtk.ToolItem()
		item.show()
		item.set_expand(True)
		self.toolbar.insert(item, -1)
		
		self.button_zin.connect_object("clicked", self.zoom_in, None)
		self.toolbar.insert(self.button_zin, -1)
		self.button_zin.show()	
		
		self.button_zout.connect_object("clicked", self.zoom_out, None)
		self.toolbar.insert(self.button_zout, -1)
		self.button_zout.show()	
		
		self.button_z100.connect_object("clicked", self.zoom_original, None)
		self.toolbar.insert(self.button_z100, -1)
		self.button_z100.show()	
		
		self.button_zfit.connect_object("clicked", self.zoom_fit, None)
		self.toolbar.insert(self.button_zfit, -1)
		self.button_zfit.show()
		
		self.toolbar.set_focus_child(self.button_zfit) # Needed unless space key should activate buttons
		
		# Attach bars to the main table
		self.table.attach(self.toolbar, 0, 3, 1, 2, gtk.FILL|gtk.SHRINK, gtk.FILL|gtk.SHRINK, 0, 0)
		self.table.attach(self.statusbar, 0, 2, 5, 6, gtk.FILL|gtk.SHRINK, gtk.FILL|gtk.SHRINK, 0, 0)
		
		# Default fullscreen
		if self.optionlist[1] == 1:
			self.window.resize(gtk.gdk.screen_get_default().get_width() / 2, gtk.gdk.screen_get_default().get_height() * 3 / 4)
			self.optionlist[0] == 1
			self.actiongroup.get_action('Fullscreen').set_active(True)
			
		# Default double page mode
		if self.optionlist[5] == 1:
			self.optionlist[4] == 1
			self.actiongroup.get_action('Double').set_active(True)
			
		# Default fit to screen mode
		if self.optionlist[16] == 1:
			self.optionlist[18] == 1
			self.actiongroup.get_action('Fit').set_active(True)
			self.actiongroup.get_action('Zin').set_sensitive(False)
			self.actiongroup.get_action('Zout').set_sensitive(False)
			self.actiongroup.get_action('Zoriginal').set_sensitive(False)
			self.actiongroup.get_action('Zwidth').set_sensitive(False)
			self.actiongroup.get_action('Zheight').set_sensitive(False)
			self.actiongroup.get_action('Zfit').set_sensitive(False)
			self.actiongroup.get_action('Scrollbars').set_sensitive(False)
			self.button_zin.set_sensitive(False)
			self.button_zout.set_sensitive(False)
			self.button_z100.set_sensitive(False)
			self.button_zfit.set_sensitive(False)
			
		# Set the bars visibility according to the preferences
		if self.optionlist[25] == 1:
			self.optionlist[25] = 0
			self.actiongroup.get_action('Menubar').set_active(True)
			
		if self.optionlist[26] == 1:
			self.optionlist[26] = 0
			self.actiongroup.get_action('Toolbar').set_active(True)
			
		if self.optionlist[27] == 1:
			self.optionlist[27] = 0
			self.actiongroup.get_action('Statusbar').set_active(True)
			
		if self.optionlist[22] == 0:
			self.optionlist[22] = 1
			self.actiongroup.get_action('Scrollbars').set_active(True)
			
		if len(self.bookmarks) == 0:
			self.actiongroup.get_action('Clear_book').set_sensitive(False)
		else:
			self.actiongroup.get_action('Clear_book').set_sensitive(True)
		
		#self.tooltips.enable()
		self.tooltips.set_tip(self.button_fullscreen, 'Enter fullscreen mode automatically when Comix is started.')
		self.tooltips.set_tip(self.button_page, 'Enter double page mode automatically when Comix is started.')
		self.tooltips.set_tip(self.button_fit, 'Enter fit-to-screen mode automatically when Comix is started.')
		self.tooltips.set_tip(self.button_stretch, 'Also scale images to a size that is larger than their original size in fit-to-screen mode.')
		self.tooltips.set_tip(self.button_smart_scale, 'Scale the images independently when in double page mode and fit-to-screen mode.' + 
		' The smaller of the two images will scale up to fill any extra space that is given.')
		self.tooltips.set_tip(self.button_comment, 'Automatically show any available comments when opening a new file.')
		self.tooltips.set_tip(self.button_hide_bars, 'Automatically hide scrollbars, menubar, toolbar and statusbar when in fullscreen mode.')
		self.tooltips.set_tip(self.button_cache_next, 'Cache the next page in the archive/directory to increase the perceived speed.' +
		' This is generally recommended unless you are running low on RAM.')
		self.tooltips.set_tip(self.button_flip_page, 'View comics in manga mode. This means that the pages will be aligned right-to-left in double page mode' +
		' and that the scrollbars will behave more convenient for right-to-left reading.')
		self.tooltips.set_tip(self.button_scroll_horiz, 'Move the horizontal scrollbar instead of the vertical when using the scroll wheel at the top or the' +
		' bottom of the page. The direction will be determined by whether you use manga mode or not.')
		self.tooltips.set_tip(self.button_scroll_flips, 'Flip pages when scrolling "off the page" with the scroll wheel, even when not in fit-to-screen mode.'+
		' It takes three "steps" with the scroll wheel to trigger this behaviour.')
		self.tooltips.set_tip(self.button_save_size, 'Save the position and the size of the window to the next time you start Comix.')
		self.tooltips.set_tip(self.button_next_archive, 'Automatically open the next archive in the directory when scrolling past the last page of the current archive,' +
		' and automatically open the previous archive in the directory when scrolling past the first page of the current archive.')
		self.tooltips.set_tip(self.button_hide_cursor, 'Hide the cursor when in fullscreen mode.')
		self.tooltips.set_tip(self.button_1, 'Set the image scaling method to be used. The best choice is often "Tiles", it is quite quick and' +
		' produces almost as good results as "Bilinear" or "Hyper".')
		self.tooltips.set_tip(self.button_2, 'Set the image scaling method to be used. The best choice is often "Tiles", it is quite quick and' +
		' produces almost as good results as "Bilinear" or "Hyper".')
		self.tooltips.set_tip(self.button_3, 'Set the image scaling method to be used. The best choice is often "Tiles", it is quite quick and' +
		' produces almost as good results as "Bilinear" or "Hyper".')
		self.tooltips.set_tip(self.button_4, 'Set the image scaling method to be used. The best choice is often "Tiles", it is quite quick and' +
		' produces almost as good results as "Bilinear" or "Hyper".')
		self.tooltips.set_tip(self.comment_extensions_entry, 'Treat files with the following extensions as comment files.' +
		' Extensions should be separated by whitespaces, they are not case sensitive.')
		self.tooltips.set_tip(self.filechooser_button, 'Automatically go to this directory when opening the file selection dialog.')
		
		# Load file if given a command-line parameter
		if len(sys.argv) == 2:
			
			path = os.path.abspath(sys.argv[1])
			self.load_file(path)
			
		# Else do nothing
		else:
			
			self.actiongroup.get_action('Comments').set_sensitive(False)
			self.actiongroup.get_action('File').set_sensitive(False)
			self.actiongroup.get_action('Save_book').set_sensitive(False)
			self.actiongroup.get_action('Convert').set_sensitive(False)
			self.actiongroup.get_action('Close').set_sensitive(False)
			self.actiongroup.get_action('Go').set_sensitive(False)
			self.actiongroup.get_action('Next').set_sensitive(False)
			self.actiongroup.get_action('Previous').set_sensitive(False)
			self.actiongroup.get_action('First').set_sensitive(False)
			self.actiongroup.get_action('Last').set_sensitive(False)
			self.button_previous.set_sensitive(False)
			self.button_next.set_sensitive(False)
			self.button_first.set_sensitive(False)
			self.button_last.set_sensitive(False)
			self.button_go.set_sensitive(False)
			
		self.change_adjustment = 1
		self.refresh_image()
	
def main():
	
	gtk.main()
	
	if not os.path.exists(os.environ['HOME'] + "/.comix"):
		
		os.mkdir(os.environ['HOME'] + "/.comix")
		
	comixrc = open(os.environ['HOME'] + "/.comix/comixrc", 'w')
	
	if Comic.optionlist[1]:
		option_string = "fullscreen=TRUE\n"
	else: 
		option_string = "fullscreen=FALSE\n"
		
	if Comic.optionlist[5]:
		option_string = option_string + "double_page=TRUE\n"
	else: 
		option_string = option_string + "double_page=FALSE\n"
		
	if Comic.optionlist[2] == gtk.gdk.INTERP_NEAREST:
		option_string = option_string + "quality=NEAREST\n"
	elif Comic.optionlist[2] == gtk.gdk.INTERP_HYPER:
		option_string = option_string + "quality=HYPER\n"
	elif Comic.optionlist[2] == gtk.gdk.INTERP_BILINEAR:
		option_string = option_string + "quality=BILINEAR\n"
	else:
		option_string = option_string + "quality=TILES\n"
		
	if not Comic.optionlist[3]:
		option_string = option_string + "hide_bars=FALSE\n"
	else:
		option_string = option_string + "hide_bars=TRUE\n"
		
	if Comic.optionlist[7]:
		option_string = option_string + "cache_next=TRUE\n"
	else:
		option_string = option_string + "cache_next=FALSE\n"
		
	if Comic.optionlist[8]:
		option_string = option_string + "flip_double=TRUE\n"
	else:
		option_string = option_string + "flip_double=FALSE\n"
		
	option_string = option_string + str(int(Comic.optionlist[6])) + "\n"
	
	if Comic.optionlist[9]:
		option_string = option_string + "stretch=TRUE\n"
	else:
		option_string = option_string + "stretch=FALSE\n"
		
	if Comic.optionlist[14] and not Comic.optionlist[0]:
		option_string = option_string + str(Comic.optionlist[10]) + "\n"
		option_string = option_string + str(Comic.optionlist[11]) + "\n"
		option_string = option_string + str(Comic.optionlist[12]) + "\n"
		option_string = option_string + str(Comic.optionlist[13]) + "\n"
		option_string = option_string + "save_position_and_size=TRUE\n"
	else:
		option_string = option_string + "0\n"
		option_string = option_string + "0\n"
		option_string = option_string + "0\n"
		option_string = option_string + "0\n"
		option_string = option_string + "save_position_and_size=FALSE\n"
		
	option_string = option_string + Comic.optionlist[15] + "\n"
	
	if Comic.optionlist[16]:
		option_string = option_string + "fit_to_screen=TRUE\n"
	else:
		option_string = option_string + "fit_to_screen=FALSE\n"
		
	if Comic.optionlist[30]:
		option_string = option_string + "scroll_off_page=TRUE\n"
	else:
		option_string = option_string + "scroll_off_page=FALSE\n"
	
	option_string = option_string + str(Comic.optionlist[19]) + "\n"
	option_string = option_string + str(Comic.optionlist[20]) + "\n"
	option_string = option_string + str(Comic.optionlist[21]) + "\n"
	
	if Comic.optionlist[22]:
		option_string = option_string + "hide_scrollbars=TRUE\n"
	else:
		option_string = option_string + "hide_scrollbars=FALSE\n"
		
	if Comic.optionlist[23]:
		option_string = option_string + "next_archive=TRUE\n"
	else:
		option_string = option_string + "next_archive=FALSE\n"
		
	if Comic.optionlist[24]:
		option_string = option_string + "hide_cursor=TRUE\n"
	else:
		option_string = option_string + "hide_cursor=FALSE\n"
		
	if Comic.optionlist[25]:
		option_string = option_string + "show_menubar=TRUE\n"
	else:
		option_string = option_string + "show_menubar=FALSE\n"
		
	if Comic.optionlist[26]:
		option_string = option_string + "show_toolbar=TRUE\n"
	else:
		option_string = option_string + "show_toolbar=FALSE\n"
		
	if Comic.optionlist[27]:
		option_string = option_string + "show_statusbar=TRUE\n"
	else:
		option_string = option_string + "show_statusbar=FALSE\n"
		
	if Comic.optionlist[28]:
		option_string = option_string + "view_comments=TRUE\n"
	else:
		option_string = option_string + "view_comments=FALSE\n"
	option_string = option_string + Comic.optionlist[29] + "\n"
	
	if Comic.optionlist[31]:
		option_string = option_string + "scroll_horiz=TRUE\n"
	else:
		option_string = option_string + "scroll_horiz=FALSE\n"
		
	if Comic.optionlist[32]:
		option_string = option_string + "smart_scale=TRUE\n"
	else:
		option_string = option_string + "smart_scale=FALSE\n"
		
	if Comic.optionlist[33] == gtk.TOOLBAR_TEXT:
		option_string = option_string + "tool_style=text\n"
	elif Comic.optionlist[33] == gtk.TOOLBAR_BOTH:
		option_string = option_string + "tool_style=both\n"
	else:
		option_string = option_string + "tool_style=icons\n"
	
	comixrc.write(option_string)
	comixrc.close()
	
	bookmarks = open(os.environ['HOME'] + "/.comix/bookmarks", 'w')
	
	option_string = ""
	
	for i, bookmark in enumerate(Comic.bookmarks):
		
		option_string = option_string + bookmark + "\n"
		option_string = option_string + str(Comic.bookmark_numbers[i]) + "\n"
		
	bookmarks.write(option_string)
	bookmarks.close()
	
	if os.path.exists(Comic.base_dir):
		shutil.rmtree(Comic.base_dir)
	if os.path.isdir('/tmp/comix'):
		if len(os.listdir('/tmp/comix')) == 0:
			shutil.rmtree('/tmp/comix')
	
	return 0

if __name__ == "__main__":
	
	Comic()
	main()
