import gtk
import gobject
from time import strftime
from pyneheaders import *
import pynei18n

COL_NAME = 0
COL_STATS = 1
COL_UID = 2

class folder_tree(gtk.TreeView):
	"""
	A TreeView specifically for showing user.contents
	mailboxes.
	"""
	def __init__(self, user):
		gtk.TreeView.__init__(self)
		cell = gtk.CellRendererText()
		self.append_column(gtk.TreeViewColumn(_("Boxes"), cell, text=COL_NAME))
		self.append_column(gtk.TreeViewColumn(_("Items"), cell, text=COL_STATS))
		#self.set_column_width(0, 150)
		#self.set_expander_style(gtk.CTREE_EXPANDER_SQUARE)
		#self.set_line_style(gtk.CTREE_LINES_DOTTED)
		# Last user clicked folder (used in DND to determine source)
		self.user_selected = None
		self.button_press_function = None
		self.cur_contents = None # remember last contents shown
					 # currently unused
		self.set_model(gtk.TreeStore(gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING))
		#self.open_folder_uid = None
		#self.open_folder = None
		self.user = user

		# setup DND
		targets = [ ("pyne_boxid", 0, -1) ]
		def dnd_drag_data_get(w, context, selection_data, info, time, self=self):
			# give folder.uid
			selected = str(self.user_selected)
			selection_data.set(selection_data.target, 8, selected)
		self.connect("drag_data_get", dnd_drag_data_get)
		self.drag_source_set(gtk.gdk.BUTTON1_MASK|gtk.gdk.BUTTON3_MASK, targets, gtk.gdk.ACTION_MOVE)

		def click_tree_item(w, event, self=self):
			"""
			Update self.user_selected if anything was clicked on.
			"""
			mousebutton = event.button
			
			# Absolute coords of click in the tree view
			x, y = event.x, event.y# - w.get_vadjustment().get_value()
			# Ignore right mouse button
			path = w.get_path_at_pos(int(x), int(y))

			if path == None:
				# Didn't click on a folder
				return
			iter = self.get_model().get_iter(path[0])
			uid = self.get_model().get_value(iter, 2)
			selected_folder = self.user.get_folder_by_uid(uid)
			
			if selected_folder == None:
				return
			
			# remember selected item
			self.user_selected = selected_folder.uid
			# Call secondary event handler
			if self.button_press_function != None:
				self.button_press_function(w, event, self)

		self.connect("button_press_event", click_tree_item)

	def get_selected_folder_uids(self):
		"""
		Return list of selected folder uids.
		"""
		uids = []
		def _get_uids(w, path, iter):
			uid = self.get_model().get_value(iter, COL_UID)
			uids.append(uid)

		self.get_selection().selected_foreach(_get_uids)
		return uids

	def connect_button_press_event(self, function):
		"""
		Allow "button_press_event"s to be passed to a secondary
		function for things like right click menus and doing more
		than just remembering what is selected :-)
		"""
		self.button_press_function = function

	def update(self, contents, update_all=0):
		"""
		Update view of mailboxes... :-/
		contents=None if just update currently shown.
		"""
		if contents == None and self.cur_contents != None:
			contents = self.cur_contents
		
		# remember expanded nodes
		expanded = []
		expand_paths = []
		def _addexpanded(liststore, path, iter):
			# Add uid if it is an expanded node
			if self.row_expanded(path):
				expanded.append(self.get_model().get_value(iter, 2))
		# Redrawing same folder. Remember what nodes are expanded.
		self.get_model().foreach(_addexpanded)
		
		# remember selected nodes
		selected = []
		select_paths = []
		def _addselected(liststore, path, iter):
			selected.append(self.get_model().get_value(iter, 2))
		self.get_selection().selected_foreach(_addselected)
		
		# remember last contents shown
		self.cur_contents = contents

		def build_tree(tree_store, folder, parent):
			if parent == None:
				# 'user' node is root
				iter = tree_store.append(None)
				tree_store.set(iter, 0, "User", 1, "")
			else:
				iter = tree_store.append(parent)
				tree_store.set(iter, COL_NAME, folder.name, COL_STATS, str(folder.getstats()[0]), COL_UID, folder.uid)
				if folder.uid in expanded:
					expand_paths.append(tree_store.get_path(iter))
				if folder.uid in selected:
					select_paths.append(tree_store.get_path(iter))
			# Recurse into children
			if folder.__dict__.has_key("contents"):
				for kid in folder.contents:
					build_tree(tree_store, kid, iter)

		tree_store = self.get_model()
		tree_store.clear()

		build_tree(tree_store, contents, None)

		self.expand_row((0,), False)
		# Expand previously expanded nodes
		for path in expand_paths:
			self.expand_row(path, False)

		# select previously selected folder(s)
		for path in select_paths:
			self.get_selection().select_path(path)