Revelation / src / revelation

#!/usr/bin/env python

#

# Revelation 0.3.1 - a password manager for GNOME 2

# http://oss.codepoet.no/revelation/

# $Id$

#

# Copyright (c) 2003-2004 Erik Grinaker

#

# 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, gnome, revelation, os, os.path, sys, gobject

class Revelation(revelation.widget.App):

	"Main application class"

	def __init__(self):

		gnome.init(revelation.APPNAME, revelation.APPNAME)

		revelation.widget.App.__init__(self, revelation.APPNAME)

		os.umask(0077)

		gtk.window_set_default_icon_list(

			gtk.gdk.pixbuf_new_from_file(revelation.DATADIR + "/pixmaps/revelation.png"),

			gtk.gdk.pixbuf_new_from_file(revelation.DATADIR + "/pixmaps/revelation-16x16.png")

		)

		self.__init_facilities()

		self.__init_toolbar()

		self.__init_menu()

		self.__init_mainarea()

		self.__init_states()

	# init methods

	def __init_facilities(self):

		"Sets up various application facilities"

		try:

			self.config = revelation.data.Config()

		except revelation.data.ConfigError:

			revelation.dialog.Error(

				None, "Configuration error",

				"The Revelation configuration data could not be found in gconf. This indicates a fault in your installation, please re-install Revelation."

			).run()

			sys.exit(1)

		self.icons	= revelation.stock.IconFactory(self)

		self.data	= revelation.data.EntryStore()

		self.clipboard	= revelation.data.EntryClipboard()

		self.undoqueue	= revelation.data.UndoQueue(self.data)

		self.finder	= revelation.data.EntrySearch(self.data)

		self.data.connect("file-changed", self.__cb_state_file)

		self.clipboard.connect("copy", self.__cb_state_clipboard)

		self.clipboard.connect("cut", self.__cb_state_clipboard)

		self.undoqueue.connect("changed", self.__cb_state_undo)

		self.finder.connect("changed", self.__cb_state_find)

	def __init_mainarea(self):

		"Sets up the main application area"

		self.tree = revelation.widget.Tree(self.data)

		self.tree.connect("popup", self.__cb_popup_tree)

		self.tree.connect("doubleclick", lambda w,d: self.entry_edit())

		self.tree.selection.connect("changed", lambda w: self.dataview.display_entry(self.data.get_entry(self.tree.get_active())))

		self.tree.selection.connect("changed", self.__cb_state_entry)

		scrolledwindow = revelation.widget.ScrolledWindow(self.tree)

		self.dataview = revelation.widget.DataView()

		alignment = gtk.Alignment(0.5, 0.4, 0, 0)

		alignment.add(self.dataview)

		self.hpaned = revelation.widget.HPaned(scrolledwindow, alignment, self.config.get("view/pane-position"))

		self.set_contents(self.hpaned)

	def __init_menu(self):

		"Sets up the application menu"

		self.create_menu((

			("/_File",		None,			None,					None,							0,	"<Branch>"),

			("/File/_New",		"<Control>N",		"Create a new file",			lambda w,d: self.file_new(),				0,	"<StockItem>",	gtk.STOCK_NEW),

			("/File/_Open...",	"<Control>O",		"Open a file",				lambda w,d: self.file_open(),				0,	"<StockItem>",	gtk.STOCK_OPEN),

			("/File/sep1",		None,			None,					None,							0,	"<Separator>"),

			("/File/_Save",		"<Control>S",		"Save data to file",			lambda w,d: self.file_save(self.data.file, self.data.password),	0,	"<StockItem>",	gtk.STOCK_SAVE),

			("/File/Save _As...",	"<Shift><Control>S",	"Save data to different file",		lambda w,d: self.file_save(),				0,	"<StockItem>",	gtk.STOCK_SAVE_AS),

			("/File/_Revert",	None,			"Revert to the saved copy of the file",	lambda w,d: self.file_revert(),				0,	"<StockItem>",	gtk.STOCK_REVERT_TO_SAVED),

			("/File/sep2",		None,			None,					None,							0,	"<Separator>"),

			("/File/Change _Password...",	None,		"Change password of current file",	lambda w,d: self.change_password(),			0,	"<StockItem>",	revelation.stock.STOCK_PASSWORD),

			("/File/_Lock...",	"<Control>L",		"Lock the current data file",		lambda w,d: self.file_lock(),				0,	"<StockItem>",	revelation.stock.STOCK_LOCK),

			("/File/sep3",		None,			None,					None,							0,	"<Separator>"),

			("/File/_Import...",	None,			"Import data from a foreign file",	lambda w,d: self.file_import(),				0,	"<StockItem>",	revelation.stock.STOCK_IMPORT),

			("/File/_Export...",	None,			"Export data to a different format",	lambda w,d: self.file_export(),				0,	"<StockItem>",	revelation.stock.STOCK_EXPORT),

			("/File/sep4",		None,			None,					None,							0,	"<Separator>"),

			("/File/_Close",	"<Control>W",		"Close the application",		lambda w,d: self.quit(),				0, 	"<StockItem>",	gtk.STOCK_CLOSE),

			("/File/_Quit",		"<Control>Q",		"Quit the application",			lambda w,d: self.quit(),				0, 	"<StockItem>",	gtk.STOCK_QUIT),

			("/_Edit",		None,			None,					None,							0,	"<Branch>"),

			("/Edit/_Add Entry...",	"Insert",		"Create a new entry",			lambda w,d: self.entry_add(),				0,	"<StockItem>",	revelation.stock.STOCK_ADD),

			("/Edit/_Edit",		"Return",		"Edit the selected entry",		lambda w,d: self.entry_edit(),				0,	"<StockItem>",	revelation.stock.STOCK_EDIT),

			("/Edit/Re_move",	"Delete",		"Remove the selected entry",		lambda w,d: self.entry_remove(),			0,	"<StockItem>",	revelation.stock.STOCK_REMOVE),

			("/Edit/sep1",		None,			None,					None,							0,	"<Separator>"),

			("/Edit/_Undo",		"<Control>Z",		"Undo the last action",			lambda w,d: self.undo(),				0,	"<StockItem>",	gtk.STOCK_UNDO),

			("/Edit/_Redo",		"<Shift><Control>Z",	"Redo the previously undone action",	lambda w,d: self.redo(),				0,	"<StockItem>",	gtk.STOCK_REDO),

			("/Edit/sep2",		None,			None,					None,							0,	"<Separator>"),

			("/Edit/Cu_t",		"<Control>X",		"Cut the entry to the clipboard",	lambda w,d: self.clip_cut(),				0,	"<StockItem>",	gtk.STOCK_CUT),

			("/Edit/_Copy",		"<Control>C",		"Copy the entry to the clipboard",	lambda w,d: self.clip_copy(),				0,	"<StockItem>",	gtk.STOCK_COPY),

			("/Edit/_Paste",	"<Control>V",		"Paste entry from clipboard",		lambda w,d: self.clip_paste(),				0,	"<StockItem>",	gtk.STOCK_PASTE),

			("/Edit/sep3",		None,			None,					None,							0,	"<Separator>"),

			("/Edit/_Find...",	"<Control>F",		"Search for an entry",			lambda w,d: self.entry_find(),				0,	"<StockItem>",	gtk.STOCK_FIND),

			("/Edit/Find Ne_xt",	"<Control>G",		"Find the next search match",		lambda w,d: self.__entry_find(self, revelation.data.SEARCH_NEXT),	0,	"<Item>"),

			("/Edit/Find Pre_vious",	"<Shift><Control>G",		"Find the previous search match",	lambda w,d: self.__entry_find(self, revelation.data.SEARCH_PREV),	0,	"<Item>"),

			("/Edit/sep4",		None,			None,					None,							0,	"<Separator>"),

			("/Edit/_Select All",	"<Control>A",		"Select all entries",			lambda w,d: self.tree.select_all(),			0,	"<Item>"),

			("/Edit/_Deselect All",	"<Shift><Control>A",	"Deselect all entries",			lambda w,d: self.tree.unselect_all(),			0,	"<Item>"),

			("/Edit/sep5",		None,			None,					None,							0,	"<Separator>"),

			("/Edit/Prefere_nces",	None,			"Edit preferences",			lambda w,d: revelation.dialog.Preferences(self, self.config).run(),	0,	"<StockItem>",	gtk.STOCK_PREFERENCES),

			("/_View",		None,			None,					None,							0,	"<Branch>"),

			("/View/_Toolbar",	None,			"Toggle display of the toolbar",	None,							0,	"<CheckItem>"),

			("/View/_Statusbar",	None,			"Toggle display of the statusbar",	None,							0,	"<CheckItem>"),

			("/View/sep1",		None,			None,					None,							0,	"<Separator>"),

			("/View/Show _Passwords",	"<Control>P",	"Show passwords",			None,							0,	"<CheckItem>"),

			("/_Help",		None,			None,					None,							0,	"<Branch>"),

			("/Help/_Homepage",	None,			"Visit the Revelation homepage",	lambda w,d: gnome.url_show(revelation.URL),		0,	"<StockItem>", gtk.STOCK_HOME),

			("/Help/_About",	None,			"Show info about this application",	lambda w,d: revelation.dialog.About(self).run(),	0,	"<StockItem>", "gnome-stock-about")

		))

	def __init_states(self):

		"Sets the initial application state"

		self.set_default_size(self.config.get("view/window-width"), self.config.get("view/window-height"))

		self.move(self.config.get("view/window-position-x"), self.config.get("view/window-position-y"))

		self.connect("delete_event", lambda w,d: gtk.TRUE ^ self.quit())

		self.tree.select(None)

		self.dataview.display_info()

		self.data.set_file(None)

		self.if_menu.get_widget("<main>/Edit/Find Next").set_sensitive(gtk.FALSE)

		self.if_menu.get_widget("<main>/Edit/Find Previous").set_sensitive(gtk.FALSE)

		self.if_menu.get_widget("<main>/Edit/Undo").set_sensitive(gtk.FALSE)

		self.if_menu.get_widget("<main>/Edit/Redo").set_sensitive(gtk.FALSE)

		self.show_all()

		self.config.bind_widget("view/passwords", self.if_menu.get_widget("<main>/View/Show Passwords"))

		self.config.bind_widget("view/statusbar", self.if_menu.get_widget("<main>/View/Statusbar"))

		self.config.bind_widget("view/toolbar", self.if_menu.get_widget("<main>/View/Toolbar"))

		self.config.notify_add("view/statusbar", self.__cb_config_statusbar)

		self.config.notify_add("view/toolbar", self.__cb_config_toolbar)

	def __init_toolbar(self):

		"Sets up the application toolbar"

		self.toolbar.button_new		= self.toolbar.append_stock(gtk.STOCK_NEW, "New file", lambda w,d: self.file_new())

		self.toolbar.button_open	= self.toolbar.append_stock(gtk.STOCK_OPEN, "Open file", lambda w,d: self.file_open())

		self.toolbar.button_save	= self.toolbar.append_stock(gtk.STOCK_SAVE, "Save file", lambda w,d: self.file_save(self.data.file, self.data.password))

		self.toolbar.append_space()

		self.toolbar.button_entry_add	= self.toolbar.append_stock(revelation.stock.STOCK_ADD, "Add a new entry", lambda w,d: self.entry_add())

		self.toolbar.button_entry_edit	= self.toolbar.append_stock(revelation.stock.STOCK_EDIT, "Edit the selected entry", lambda w,d: self.entry_edit())

		self.toolbar.button_entry_remove = self.toolbar.append_stock(revelation.stock.STOCK_REMOVE, "Remove the selected entry", lambda w,d: self.entry_remove())

	# config callbacks

	def __cb_config_statusbar(self, config, value, data):

		"Config callback for statusbar changes"

		if value == gtk.TRUE:

			self.statusbar.show()

		else:

			self.statusbar.hide()

	def __cb_config_toolbar(self, config, value, data):

		"Config callback for toolbar changes"

		if value == gtk.TRUE:

			self.toolbar.show()

		else:

			self.toolbar.hide()

	# callbacks for handling ui states

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

		"Sets clipboard item sensitivity as appropriate"

		self.if_menu.get_widget("<main>/Edit/Paste").set_sensitive(self.clipboard.has_contents())

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

		"Sets state for entry-dependent ui items"

		selcount = len(self.tree.get_selected())

		self.toolbar.button_entry_add.set_sensitive(selcount < 2)

		self.if_menu.get_widget("<main>/Edit/Add Entry...").set_sensitive(selcount < 2)

		self.if_menu.get_widget("<main>/Edit/Paste").set_sensitive(selcount < 2 and self.clipboard.has_contents())

		self.toolbar.button_entry_edit.set_sensitive(selcount == 1)

		self.if_menu.get_widget("<main>/Edit/Edit").set_sensitive(selcount == 1)

		self.toolbar.button_entry_remove.set_sensitive(selcount > 0)

		self.if_menu.get_widget("<main>/Edit/Remove").set_sensitive(selcount > 0)

		self.if_menu.get_widget("<main>/Edit/Cut").set_sensitive(selcount > 0)

		self.if_menu.get_widget("<main>/Edit/Copy").set_sensitive(selcount > 0)

	def __cb_state_file(self, widget, file = None):

		"Sets various states based on current file"

		self.if_menu.get_widget("<main>/File/Revert").set_sensitive(file is not None)

		self.if_menu.get_widget("<main>/File/Lock...").set_sensitive(file is not None)

		if file is None:

			self.set_title("[New file]")

		else:

			self.set_title(os.path.basename(file))

			os.chdir(os.path.dirname(file))

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

		"Sets ui item states for find-related items"

		self.if_menu.get_widget("<main>/Edit/Find Next").set_sensitive(self.finder.string != "")

		self.if_menu.get_widget("<main>/Edit/Find Previous").set_sensitive(self.finder.string != "")

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

		"Sets states for undo-related ui items"

		# update undo widgets

		widget = self.if_menu.get_widget("<main>/Edit/Undo")

		action = "_Undo"

		if self.undoqueue.can_undo():

			widget.get_children()[0].set_label(action + " " + self.undoqueue.get_action(revelation.data.UNDO).name)

			widget.set_sensitive(gtk.TRUE)

		else:

			widget.get_children()[0].set_label(action)

			widget.set_sensitive(gtk.FALSE)

		# update redo widgets

		widget = self.if_menu.get_widget("<main>/Edit/Redo")

		action = "_Redo"

		if self.undoqueue.can_redo():

			widget.get_children()[0].set_label(action + " " + self.undoqueue.get_action(revelation.data.REDO).name)

			widget.set_sensitive(gtk.TRUE)

		else:

			widget.get_children()[0].set_label(action)

			widget.set_sensitive(gtk.FALSE)

	# other, normal callbacks

	def __cb_popup_tree(self, widget, menuitems):

		"Create a popup-menu for the treeview"

		# create the popup menu

		iters = self.tree.get_selected()

		if len(iters) == 0 or (len(iters) == 1 and self.data.get_entry(iters[0]).type == revelation.entry.ENTRY_FOLDER):

			menuitems.append(("/_Add Entry...", None, "Create a new entry", lambda w,d: self.entry_add(), 0, "<StockItem>", revelation.stock.STOCK_ADD))

		if len(iters) == 1:

			menuitems.append(("/_Edit", None, "Edit the selected entry", lambda w,d: self.entry_edit(), 0, "<StockItem>", revelation.stock.STOCK_EDIT))

		if len(iters) > 0:

			menuitems.append(("/Re_move", None, "Remove the selected entry", lambda w,d: self.entry_remove(), 0, "<StockItem>", revelation.stock.STOCK_REMOVE))

		clipboardmenu = []

		if len(iters) > 0:

			clipboardmenu.append(("/Cu_t", "", "Cut the selected entry to the clipboard", lambda w,d: self.clip_cut(), 0, "<StockItem>", gtk.STOCK_CUT))

			clipboardmenu.append(("/_Copy", "", "Copy the selected entry to the keyboard", lambda w,d: self.clip_copy(), 0, "<StockItem>", gtk.STOCK_COPY))

		if len(iters) < 2 and self.clipboard.has_contents():

			clipboardmenu.append(("/_Paste", "", "Paste entry from clipboard", lambda w,d: self.clip_paste(), 0, "<StockItem>", gtk.STOCK_PASTE))

		if len(clipboardmenu) > 0:

			menuitems.append(("/sep1", None, None, None, 0, "<Separator>"))

			menuitems.extend(clipboardmenu)

	# various private methods

	def __entry_find(self, parent, direction = revelation.data.SEARCH_NEXT):

		"Searches for an entry"

		self.finder.folders = self.config.get("search/folders")

		self.finder.casesens = self.config.get("search/casesens")

		self.finder.namedesc = self.config.get("search/namedesc")

		match = self.finder.find(self.tree.get_active(), direction)

		if match is None:

			revelation.dialog.Error(parent, "No match found", "The string you searched for did not match any entries. Try using a different search-phrase.").run()

		else:

			self.tree.select(match)

	def __file_autosave(self):

		"Autosaves the current file, due to data modification"

		if self.data.file is None or self.data.password is None:

			return

		if not self.config.get("file/autosave"):

			return

		self.file_save(self.data.file, self.data.password)

	def __file_load(self, datafile):

		"Loads data from a file into an entrystore"

		try:

			if datafile.handler is None:

				datafile.detect_type()

			datafile.check_file()

			dialog = revelation.dialog.PasswordLoad(self, datafile.file)

			entrystore = None

			while 1:

				# load datafile, ask for password if needed

				try:

					if datafile.needs_password() and datafile.password is None:

						datafile.password = dialog.run()

					entrystore = datafile.load()

				except revelation.datahandler.PasswordError:

					datafile.password = None

					revelation.dialog.Error(

						self, "Incorrect password",

						"The password you entered for the file'" + datafile.file + "' was not correct."

					).run()

				except:

					dialog.destroy()

					raise

				else:

					dialog.destroy()

					break

			return entrystore

		except revelation.datahandler.FormatError:

			self.statusbar.set_status("Open failed")

			revelation.dialog.Error(

				self, "Invalid file format",

				"The file '" + datafile.file + "' contains invalid data."

			).run()

		except revelation.entry.EntryError:

			self.statusbar.set_status("Open failed")

			revelation.dialog.Error(

				self, "Unknown data",

				"The file '" + datafile.file + "' contains unknown data. It may have been created by a future version of Revelation, try upgrading to a newer version."

			).run()

		except revelation.datahandler.VersionError:

			self.statusbar.set_status("Open failed")

			revelation.dialog.Error(

				self, "Unknown data version",

				"The file '" + datafile.file + "' has a future version number - upgrade Revelation to a more recent version to open it."

			).run()

		except revelation.io.DetectError:

			self.statusbar.set_status("Open failed")

			revelation.dialog.Error(

				self, "Filetype autodetection failed",

				"The format of the file '" + datafile.file + "' could not be detected automatically. It may still be possible to open the file, try specifying the file type manually."

			).run()

		except IOError:

			self.statusbar.set_status("Open failed")

			revelation.dialog.Error(

				self, "Unable to open file",

				"The file '" + datafile.file + "' could not be opened. Make sure that the file exists, and that you have the proper permissions to open it."

			).run()

		except revelation.CancelError:

			dialog.destroy()

			raise

	def __file_save(self, datafile):

		"Saves data to a file"

		try:

			if datafile.file != self.data.file and revelation.io.file_exists(datafile.file):

				revelation.dialog.FileOverwrite(self, datafile.file).run()

			if not datafile.needs_password():

				revelation.dialog.FileExportInsecure(self).run()

			elif datafile.password is None:

				try:

					dialog = revelation.dialog.PasswordSave(self, datafile.file)

					datafile.password = dialog.run()

					dialog.destroy()

				except revelation.CancelError:

					dialog.destroy()

					raise

			datafile.save(self.data)

			return gtk.TRUE

		except IOError:

			revelation.dialog.Error(self, "Unable to write to file", "The file '" + datafile.file + "' could not be opened for writing. Make sure that you have the proper permissions to write to it.").run()

			self.statusbar.set_status("Save failed")

			return gtk.FALSE

	def __save_changes(self, dialog):

		"Asks the user if she wants to save her changes"

		try:

			if not self.data.changed:

				return gtk.TRUE

			if dialog(self).run() == gtk.TRUE:

				return self.file_save(self.data.file, self.data.password)

			return gtk.TRUE

		except revelation.CancelError:

			return gtk.FALSE

	# public methods

	def change_password(self):

		"Changes the password of the current data file"

		try:

			dialog = revelation.dialog.PasswordChange(self, self.data.password)

			self.data.password = dialog.run()

			self.__file_autosave()

			self.statusbar.set_status("Password changed")

		except revelation.CancelError:

			self.statusbar.set_status("Password change cancelled")

		dialog.destroy()

	def clip_copy(self):

		"Copies selected entries to the clipboard"

		iters = self.data.filter_parents(self.tree.get_selected())

		self.clipboard.copy(self.data, iters)

	def clip_cut(self):

		"Cuts selected entries to the clipboard"

		iters = self.data.filter_parents(self.tree.get_selected())

		self.undoqueue.add_action(revelation.data.UNDO_ACTION_CUT, iters)

		self.clipboard.cut(self.data, iters)

		self.__file_autosave()

		self.tree.unselect_all()

	def clip_paste(self):

		"Pastes entries from the clipboard"

		if not self.clipboard.has_contents():

			return

		iters = self.clipboard.paste(self.data, self.tree.get_active())

		self.undoqueue.add_action(revelation.data.UNDO_ACTION_PASTE, iters)

		self.__file_autosave()

		self.tree.select(iters[0])

	def entry_add(self):

		"Adds an entry"

		try:

			entry = revelation.dialog.EntryEdit(self, "Add entry").run()

			iter = self.data.add_entry(self.tree.get_active(), entry)

			self.undoqueue.add_action(revelation.data.UNDO_ACTION_ADD, iter)

			self.__file_autosave()

			self.tree.select(iter)

			self.statusbar.set_status("Added entry '" + entry.name + "'")

		except revelation.CancelError:

			self.statusbar.set_status("Add entry cancelled")

	def entry_edit(self):

		"Edits an entry"

		iter = self.tree.get_active()

		if iter is None:

			return

		try:

			entry = self.data.get_entry(iter)

			dialog = revelation.dialog.EntryEdit(self, "Edit entry", entry)

			if entry.type == revelation.entry.ENTRY_FOLDER and self.data.iter_n_children(iter) > 0:

				dialog.set_typechange_allowed(gtk.FALSE)

			newentry = dialog.run()

			self.data.update_entry(iter, newentry)

			self.undoqueue.add_action(revelation.data.UNDO_ACTION_EDIT, iter, entry)

			self.__file_autosave()

			self.tree.select(iter)

			self.statusbar.set_status("Updated entry '" + newentry.name + "'")

		except revelation.CancelError:

			self.statusbar.set_status("Update entry cancelled")

	def entry_find(self):

		"Searches for an entry"

		dialog = revelation.dialog.Find(self, self.config)

		dialog.entry_phrase.set_text(self.finder.string)

		dialog.dropdown.set_type(self.finder.type)

		while 1:

			response = dialog.run()

			self.finder.string = dialog.entry_phrase.get_text()

			self.finder.type = dialog.dropdown.get_type()

			if response == revelation.dialog.RESPONSE_NEXT:

				self.__entry_find(dialog, revelation.data.SEARCH_NEXT)

			elif response == revelation.dialog.RESPONSE_PREVIOUS:

				self.__entry_find(dialog, revelation.data.SEARCH_PREV)

			else:

				dialog.destroy()

				break

	def entry_remove(self):

		"Removes one or more entries"

		iters = self.tree.get_selected()

		if len(iters) == 0:

			return

		entries = self.data.get_entries(iters)

		try:

			if revelation.dialog.EntryRemove(self, entries).run() != gtk.TRUE:

				raise revelation.CancelError

			if len(iters) == 1:

				statustext = "Removed entry '" + entries[0].name + "'"

			else:

				statustext = "Removed " + str(len(entries)) + " entries"

			iters = self.data.filter_parents(iters)

			self.undoqueue.add_action(revelation.data.UNDO_ACTION_REMOVE, iters)

			for iter in iters:

				self.data.remove_entry(iter)

			self.__file_autosave()

			self.tree.unselect_all()

			self.statusbar.set_status(statustext)

		except revelation.CancelError:

			self.statusbar.set_status("Remove entry cancelled")

	def file_export(self):

		"Exports data to a foreign file format"

		try:

			file, handler = revelation.dialog.ExportFileSelector(self).run()

			datafile = revelation.io.DataFile(file, handler)

			self.__file_save(datafile)

			self.statusbar.set_status("Data exported to " + datafile.file)

		except revelation.CancelError:

			self.statusbar.set_status("Export cancelled")

	def file_import(self):

		"Imports data from a foreign file"

		try:

			file, handler = revelation.dialog.ImportFileSelector(self).run()

			datafile = revelation.io.DataFile(file, handler)

			entrystore = self.__file_load(datafile)

			if entrystore is None:

				return

			iters = self.data.import_entrystore(entrystore)

			self.undoqueue.add_action(revelation.data.UNDO_ACTION_IMPORT, iters)

			self.__file_autosave()

			self.statusbar.set_status("Data imported from " + datafile.file)

		except revelation.CancelError:

			self.statusbar.set_status("Import cancelled")

	def file_lock(self):

		"Locks the current data file"

		if self.data.password is None:

			return

		iter = self.tree.get_active()

		self.tree.set_model(None)

		self.dataview.clear()

		self.statusbar.set_status("File locked")

		dialog = revelation.dialog.PasswordLock(self)

		while 1:

			if dialog.run() == self.data.password:

				break

			else:

				revelation.dialog.Error(

					dialog, "Incorrect password",

					"The password you entered was not correct, please try again."

				).run()

		dialog.destroy()

		self.tree.set_model(self.data)

		self.tree.select(iter)

		self.statusbar.set_status("File unlocked")

	def file_new(self):

		"Opens a new file"

		if not self.__save_changes(revelation.dialog.FileChangedNew):

			self.statusbar.set_status("New file cancelled")

			return

		self.data.clear()

		self.statusbar.set_status("New file created")

	def file_open(self, file = None, password = None):

		"Opens a data file"

		try:

			if not self.__save_changes(revelation.dialog.FileChangedOpen):

				raise revelation.CancelError

			if file is None:

				file = revelation.dialog.FileSelector(self, "Select file to open").run()

			datafile = revelation.io.DataFile(file, revelation.datahandler.Revelation, password)

			entrystore = self.__file_load(datafile)

			if entrystore is None:

				return

			self.data.replace_entrystore(entrystore)

			self.statusbar.set_status("Opened file " + datafile.file)

		except revelation.CancelError:

			self.statusbar.set_status("Open cancelled")

	def file_revert(self):

		"Reverts to the saved version of the file"

		if not self.__save_changes(revelation.dialog.FileChangedRevert):

			self.statusbar.set_status("Revert cancelled")

			return gtk.FALSE

		self.data.changed = gtk.FALSE

		self.file_open(self.data.file, self.data.filepassword)

	def file_save(self, file = None, password = None):

		"Saves a data file"

		try:

			if file is None:

				file = revelation.dialog.FileSelector(self, "Select file to save data to").run()

			datafile = revelation.io.DataFile(file, revelation.datahandler.Revelation, password)

			if self.__file_save(datafile) == gtk.TRUE:

				self.data.set_file(file, password)

				self.statusbar.set_status("Data saved to file " + file)

				return gtk.TRUE

		except revelation.CancelError:

			self.statusbar.set_status("Save cancelled")

			return gtk.FALSE

	def quit(self):

		"Quits the application"

		if not self.__save_changes(revelation.dialog.FileChangedQuit):

			self.statusbar.set_status("Quit cancelled")

			return gtk.FALSE

		width, height = self.get_size()

		self.config.set("view/window-width", width)

		self.config.set("view/window-height", height)

		x, y = self.get_position()

		self.config.set("view/window-position-x", x)

		self.config.set("view/window-position-y", y)

		self.config.set("view/pane-position", self.hpaned.get_position())

		gtk.mainquit()

		return gtk.TRUE

	def redo(self):

		"Redo the previously undone operation"

		if not self.undoqueue.can_redo():

			return

		action = self.undoqueue.get_action(revelation.data.REDO)

		iters = self.undoqueue.redo()

		if len(iters) > 0:

			self.tree.select(iters[0])

		else:

			self.tree.unselect_all()

		self.__file_autosave()

		self.statusbar.set_status(action.name.capitalize() + " redone")

	def run(self):

		"Run the application"

		if len(sys.argv) > 1:

			self.file_open(os.path.abspath(sys.argv[1]))

		elif self.config.get("file/autoload") and self.config.get("file/autoload_file") != "":

			self.file_open(self.config.get("file/autoload_file"))

		gtk.main()

	def undo(self):

		"Attempts to undo the previous operation"

		if not self.undoqueue.can_undo():

			return

		action = self.undoqueue.get_action()

		iters = self.undoqueue.undo()

		if len(iters) > 0:

			self.tree.select(iters[0])

		else:

			self.tree.unselect_all()

		self.__file_autosave()

		self.statusbar.set_status(action.name.capitalize() + " undone")

if __name__ == "__main__":

	Revelation().run()