Revelation / src / lib / data.py

#

# Revelation - a password manager for GNOME 2

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

# $Id$

#

# Module containing data-related functionality

#

#

# Copyright (c) 2003-2006 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 datahandler, entry

import gobject, gtk, gtk.gdk, time

COLUMN_NAME	= 0

COLUMN_ICON	= 1

COLUMN_ENTRY	= 2

SEARCH_NEXT	= "next"

SEARCH_PREVIOUS	= "prev"

class Clipboard(gobject.GObject):

	"A normal text-clipboard"

	def __init__(self):

		gobject.GObject.__init__(self)

		self.clip_clipboard	= gtk.clipboard_get("CLIPBOARD")

		self.clip_primary	= gtk.clipboard_get("PRIMARY")

		self.cleartimer		= Timer(10)

		self.cleartimeout	= 60

		self.cleartimer.connect("ring", self.__cb_clear_ring)

		self.content		= None

		self.contentpointer	= 0

	def __cb_clear(self, clipboard, data = None):

		"Clears the clipboard data"

		return

	def __cb_clear_ring(self, widget):

		"Handles cleartimer rings"

		self.content		= None

		self.contentpointer	= 0

	def __cb_get(self, clipboard, selectiondata, info, data):

		"Returns text for clipboard requests"

		if self.content == None:

			text = ""

		elif type(self.content) == list:

			if len(self.content) == 0:

				text = ""

			else:

				text = self.content[self.contentpointer]

			if self.contentpointer < len(self.content) - 1:

				self.contentpointer += 1

		else:

			text = str(self.content)

		selectiondata.set_text(text, len(text))

	def clear(self):

		"Clears the clipboard"

		self.clip_clipboard.clear()

		self.clip_primary.clear()

	def get(self):

		"Fetches text from the clipboard"

		text = self.clip_clipboard.wait_for_text()

		if text is None:

			text = ""

		return text

	def has_contents(self):

		"Checks if the clipboard has any contents"

		return self.clip_clipboard.wait_is_text_available()

	def set(self, content, secret = False):

		"Copies text to the clipboard"

		self.content		= content

		self.contentpointer	= 0

		targets = (

			( "text/plain",		0,	0 ),

			( "STRING",		0,	0 ),

			( "TEXT",		0,	0 ),

			( "COMPOUND_TEXT",	0,	0 ),

			( "UTF8_STRING",	0,	0 )

		)

		self.clip_clipboard.set_with_data(targets, self.__cb_get, self.__cb_clear, None)

		self.clip_primary.set_with_data(targets, self.__cb_get, self.__cb_clear, None)

		if secret == True:

			self.cleartimer.start(self.cleartimeout)

		else:

			self.cleartimer.stop()

class EntryClipboard(gobject.GObject):

	"A clipboard for entries"

	def __init__(self):

		gobject.GObject.__init__(self)

		self.clipboard = gtk.Clipboard(gtk.gdk.display_get_default(), "_REVELATION_ENTRY")

		self.__has_contents = False

		gobject.timeout_add(500, lambda: self.__check_contents())

	def __check_contents(self):

		"Callback which check the clipboard"

		state = self.has_contents()

		if state != self.__has_contents:

			self.emit("content-toggled", state)

			self.__has_contents = state

		return True

	def clear(self):

		"Clears the clipboard"

		self.clipboard.clear()

		self.__check_contents()

	def get(self):

		"Fetches entries from the clipboard"

		try:

			xml = self.clipboard.wait_for_text()

			if xml in ( None, "" ):

				return None

			handler = datahandler.RevelationXML()

			entrystore = handler.import_data(xml)

			return entrystore

		except datahandler.HandlerError:

			return None

	def has_contents(self):

		"Checks if the clipboard has any contents"

		return self.clipboard.wait_for_text() is not None

	def set(self, entrystore, iters):

		"Copies entries from an entrystore to the clipboard"

		copystore = EntryStore()

		for iter in entrystore.filter_parents(iters):

			copystore.import_entry(entrystore, iter)

		xml = datahandler.RevelationXML().export_data(copystore)

		self.clipboard.set_text(xml)

		self.__check_contents()

gobject.signal_new("content-toggled", EntryClipboard, gobject.SIGNAL_ACTION, gobject.TYPE_BOOLEAN, ( gobject.TYPE_BOOLEAN, ))

class EntrySearch(gobject.GObject):

	"Handles searching in an EntryStore"

	def __init__(self, entrystore):

		gobject.GObject.__init__(self)

		self.entrystore	= entrystore

		self.folders		= True

		self.namedesconly	= False

		self.casesensitive	= False

	def find(self, string, entrytype = None, offset = None, direction = SEARCH_NEXT):

		"Searches for an entry, starting at the given offset"

		iter = offset

		while 1:

			if direction == SEARCH_NEXT:

				iter = self.entrystore.iter_traverse_next(iter)

			else:

				iter = self.entrystore.iter_traverse_prev(iter)

			# if we've wrapped around, return None

			if self.entrystore.get_path(iter) == self.entrystore.get_path(offset):

				return None

			if self.match(iter, string, entrytype) == True:

				return iter

	def find_all(self, string, entrytype = None):

		"Searches for all entries matching a term"

		matches = []

		iter = self.entrystore.iter_children(None)

		while iter != None:

			if self.match(iter, string, entrytype) == True:

				matches.append(iter)

			iter = self.entrystore.iter_traverse_next(iter)

		return matches

	def match(self, iter, string, entrytype = None):

		"Check if an entry matches the search criteria"

		if iter is None or not string:

			return False

		e = self.entrystore.get_entry(iter)

		# check entry type

		if type(e) == entry.FolderEntry and self.folders == False:

			return False

		if entrytype is not None and type(e) not in ( entrytype, entry.FolderEntry ):

			return False

		# check entry fields

		items = [ e.name, e.description ]

		if self.namedesconly == False:

			items.extend([ field.value for field in e.fields if field.value != "" ])

		# run the search

		for item in items:

			if self.casesensitive == True and string in item:

				return True

			elif self.casesensitive == False and string.decode("utf-8").lower() in item.decode("utf-8").lower():

				return True

		return False

class EntryStore(gtk.TreeStore):

	"A data structure for storing entries"

	def __init__(self):

		gtk.TreeStore.__init__(

			self,

			gobject.TYPE_STRING,	# name

			gobject.TYPE_STRING,	# icon

			gobject.TYPE_PYOBJECT	# entry

		)

		self.changed = False

		self.connect("row-has-child-toggled", self.__cb_iter_has_child)

	def __cb_iter_has_child(self, widget, path, iter):

		"Callback for iters having children"

		if self.iter_n_children(iter) == 0:

			self.folder_expanded(iter, False)

	def add_entry(self, e, parent = None, sibling = None):

		"Adds an entry"

		# place after parent if it's not a folder

		if parent is not None and type(self.get_entry(parent)) != entry.FolderEntry:

			iter = self.insert_after(self.iter_parent(parent), parent)

		# place before sibling, if given

		elif sibling is not None:

			iter = self.insert_before(parent, sibling)

		# otherwise, append to parent

		else:

			iter = self.append(parent)

		self.update_entry(iter, e)

		self.changed = True

		return iter

	def clear(self):

		"Removes all entries"

		gtk.TreeStore.clear(self)

		self.changed = False

	def copy_entry(self, iter, parent = None, sibling = None):

		"Copies an entry recursively"

		newiter = self.add_entry(self.get_entry(iter), parent, sibling)

		for i in range(self.iter_n_children(iter)):

			child = self.iter_nth_child(iter, i)

			self.copy_entry(child, newiter)

		return newiter

	def filter_parents(self, iters):

		"Removes all descendants from the list of iters"

		parents = []

		for child in iters:

			for parent in iters:

				if self.is_ancestor(parent, child):

					break

			else:

				parents.append(child)

		return parents

	def folder_expanded(self, iter, expanded):

		"Sets the expanded state of an entry"

		e = self.get_entry(iter)

		if e == None or type(e) != entry.FolderEntry:

			return

		elif expanded == True:

			self.set_value(iter, COLUMN_ICON, e.openicon)

		else:

			self.set_value(iter, COLUMN_ICON, e.icon)

	def get_entry(self, iter):

		"Fetches data for an entry"

		if iter is None:

			return None

		e = self.get_value(iter, COLUMN_ENTRY)

		if e is None:

			return None

		else:

			return e.copy()

	def get_iter(self, path):

		"Gets an iter from a path"

		try:

			if path in ( None, "", (), [] ):

				return None

			if type(path) == list:

				path = tuple(path)

			return gtk.TreeStore.get_iter(self, path)

		except ValueError:

			return None

	def get_path(self, iter):

		"Gets a path from an iter"

		return iter is not None and gtk.TreeStore.get_path(self, iter) or None

	def get_popular_values(self, fieldtype, threshold = 3):

		"Gets popular values for a field type"

		valuecount = {}

		iter = self.iter_nth_child(None, 0)

		while iter is not None:

			e = self.get_entry(iter)

			if e.has_field(fieldtype) == False:

				iter = self.iter_traverse_next(iter)

				continue

			value = e[fieldtype].strip()

			if value != "":

				if valuecount.has_key(value) == False:

					valuecount[value] = 0

				valuecount[value] += 1

			iter = self.iter_traverse_next(iter)

		popular = [ value for value, count in valuecount.items() if count >= threshold ]

		popular.sort()

		return popular

	def import_entry(self, source, iter, parent = None, sibling = None):

		"Recursively copies an entry from a different entrystore"

		if iter is not None:

			copy = self.add_entry(source.get_entry(iter), parent, sibling)

			parent, sibling = copy, None

		else:

			copy = None

		newiters = []

		for i in range(source.iter_n_children(iter)):

			child = source.iter_nth_child(iter, i)

			newiter = self.import_entry(source, child, parent, sibling)

			newiters.append(newiter)

		return copy is not None and copy or newiters

	def iter_traverse_next(self, iter):

		"Gets the 'logically next' iter"

		# get the first child, if any

		child = self.iter_nth_child(iter, 0)

		if child is not None:

			return child

		# check for a sibling or, if not found, a sibling of any ancestors

		parent = iter

		while parent is not None:

			sibling = parent.copy()

			sibling = self.iter_next(sibling)

			if sibling is not None:

				return sibling

			parent = self.iter_parent(parent)

		return None

	def iter_traverse_prev(self, iter):

		"Gets the 'logically previous' iter"

		# get the previous sibling, or parent, of the iter - if any

		if iter is not None:

			parent = self.iter_parent(iter)

			index = self.get_path(iter)[-1]

			# if no sibling is found, return the parent

			if index == 0:

				return parent

			# otherwise, get the sibling

			iter = self.iter_nth_child(parent, index - 1)

		# get the last, deepest child of the sibling or root, if any

		while self.iter_n_children(iter) > 0:

			iter = self.iter_nth_child(iter, self.iter_n_children(iter) - 1)

		return iter

	def move_entry(self, iter, parent = None, sibling = None):

		"Moves an entry"

		newiter = self.copy_entry(iter, parent, sibling)

		self.remove_entry(iter)

		return newiter

	def remove_entry(self, iter):

		"Removes an entry, and its children if any"

		if iter is None:

			return None

		self.remove(iter)

		self.changed = True

	def update_entry(self, iter, e):

		"Updates an entry"

		if None in ( iter, e):

			return None

		self.set_value(iter, COLUMN_NAME, e.name)

		self.set_value(iter, COLUMN_ICON, e.icon)

		self.set_value(iter, COLUMN_ENTRY, e.copy())

		self.changed = True

class Timer(gobject.GObject):

	"Handles timeouts etc"

	def __init__(self, resolution = 1):

		gobject.GObject.__init__(self)

		self.offset		= None

		self.timeout		= None

		gobject.timeout_add(resolution * 1000, self.__cb_check)

	def __cb_check(self):

		"Checks if the timeout has been reached"

		if None not in (self.offset, self.timeout) and int(time.time()) >= (self.offset + self.timeout):

			self.stop()

			self.emit("ring")

		return True

	def reset(self):

		"Resets the timer"

		if self.offset != None:

			self.offset = int(time.time())

	def start(self, timeout):

		"Starts the timer"

		if timeout == 0:

			self.stop()

		else:

			self.offset = int(time.time())

			self.timeout = timeout

	def stop(self):

		"Stops the timer"

		self.offset = None

		self.timeout = None

gobject.signal_new("ring", Timer, gobject.SIGNAL_ACTION, gobject.TYPE_BOOLEAN, ())

class UndoQueue(gobject.GObject):

	"Handles undo/redo tracking"

	def __init__(self):

		gobject.GObject.__init__(self)

		self.queue	= []

		self.pointer	= 0

	def add_action(self, name, cb_undo, cb_redo, actiondata):

		"Adds an action to the undo queue"

		del self.queue[self.pointer:]

		self.queue.append(( name, cb_undo, cb_redo, actiondata ))

		self.pointer = len(self.queue)

		self.emit("changed")

	def can_redo(self):

		"Checks if a redo action is possible"

		return self.pointer < len(self.queue)

	def can_undo(self):

		"Checks if an undo action is possible"

		return self.pointer > 0

	def clear(self):

		"Clears the queue"

		self.queue = []

		self.pointer = 0

		self.emit("changed")

	def get_redo_action(self):

		"Returns data for the next redo operation"

		if self.can_redo() == False:

			return None

		name, cb_undo, cb_redo, actiondata = self.queue[self.pointer]

		return cb_redo, name, actiondata

	def get_undo_action(self):

		"Returns data for the next undo operation"

		if self.can_undo() == False:

			return None

		name, cb_undo, cb_redo, actiondata = self.queue[self.pointer - 1]

		return cb_undo, name, actiondata

	def redo(self):

		"Executes a redo operation"

		if self.can_redo() == False:

			return None

		cb_redo, name, actiondata = self.get_redo_action()

		self.pointer += 1

		cb_redo(name, actiondata)

		self.emit("changed")

	def undo(self):

		"Executes an undo operation"

		if self.can_undo() == False:

			return None

		cb_undo, name, actiondata = self.get_undo_action()

		self.pointer -= 1

		cb_undo(name, actiondata)

		self.emit("changed")

gobject.type_register(UndoQueue)

gobject.signal_new("changed", UndoQueue, gobject.SIGNAL_ACTION, gobject.TYPE_BOOLEAN, ())