path: root/totem/plugin/ppstream.py

import totem
import gobject, gtk, gconf
gobject.threads_init()
import urllib
import httplib
import threading
import time
import re
import os
import random

from xml.dom import minidom

import PPSVideoList

try:
	from hashlib import md5

	def url_digest (url):
		m = md5 ()
		m.update (url)
		return m.hexdigest ()
except ImportError:
	import md5

	def url_digest (url):
		m = md5.new ()
		m.update (url)
		return m.hexdigest ()

gconf_key = '/apps/totem/plugins/ppstream'
pps_cache_dir = os.path.expanduser ('~/.local/share/totem/plugin/ppstream')


pps_xmls_dir = os.path.join (pps_cache_dir, "xmls")
pps_images_dir = os.path.join (pps_cache_dir, "images")
for p in [ pps_xmls_dir, pps_images_dir ]:
	if not os.path.exists (p):
		os.makedirs (p)

def xml_node_value (node):
	return node.firstChild.nodeValue

def xml_child_value (node, id):
	child = node.getElementsByTagName(id)[0].firstChild;
	if child:
		return child.nodeValue
	return None

class PPSClass:
	def __init__ (self):
		self.id = 0
		self.title = ""
		self.type = 1
		self.contentnum = 0
		self.subclasses = []
		self.films = []
		self.fetching_films = False
		self.films_fetched = False
		self.last_films = ''

	def __str__(self):
		return '<' + str (self.id) + ' ' + self.title + '>'

	def parse (self, node):
		self.id = int(xml_child_value (node, 'ID'))
		self.title = str(xml_child_value (node, 'Title'))
		self.type = int(xml_child_value (node, 'Type'))
		self.contentnum = int(xml_child_value (node, 'ContentNum'))
		self.subclasses = []
		self.films = []
		self.fetching_films = False
		self.films_fetched = False
		self.last_films = ''
		return self

class PPSSubClass:
	def __str__(self):
		return '<' + str (self.subid) + ' ' + self.title + '>'

	def parse (self, node):
		self.subid = int(xml_child_value (node, 'SubID') or 0)
		self.title = str(xml_child_value (node, 'Title'))
		self.filmtitle = str(xml_child_value (node, 'FilmTitle'))
		self.director = str(xml_child_value (node, 'Dirt'))
		self.actor = str(xml_child_value (node, 'Actor'))
		self.bigimage = str(xml_child_value (node, 'BIUrl'))
		self.smallimage = str(xml_child_value (node, 'SIUrl'))
		self.contentnum = int(xml_child_value (node, 'ContentNum'))
		self.contents = []
		self.films = []
		self.fetching_films = False
		self.films_fetched = False
		self.last_films = ''
		return self

class PPSFile:
	elements = [ ('ID', 'id'), ('CI', 'ci'),
		     ('Size', 'size'), ('Form', 'format'),
		     ('Rate', 'rate'), ('DUrl', 'url'),
		     ('VF', 'vipflag')]

	def __str__ (self):
		return '<' + str (self.id) + ' ' + self.url + '>'

	def __eq__ (self, other):
		for i in PPSFile.elements:
			if getattr (self, i[1]) != getattr (other, i[1]):
				return False
		return True

	def parse (self, node):
		self.id = int(xml_child_value (node, 'ID'))
		self.ci = int(xml_child_value (node, 'CI'))
		self.size = int(xml_child_value (node, 'Size'))
		self.format = str(xml_child_value (node, 'Form'))
		self.rate = int(xml_child_value (node, 'Rate'))
		self.url = str(xml_child_value (node, 'DUrl'))
		self.vipflag = int(xml_child_value (node, 'VF'))
		return self

	def to_cdata_element (self, dom, tag, data):
		if type (data) is not str:
			data = str (data)

		ele = dom.createElement (tag)
		child = dom.createCDATASection (data)
		ele.childNodes.append (child)
		return ele

	def toxml (self, dom):
		ele = dom.createElement ('Url')
		for child in PPSFile.elements:
			childele = self.to_cdata_element (dom, child[0],
							  getattr (self, child[1]))
			ele.childNodes.append (childele)
		return ele

class PPSFilm:
	elements = [ ('ID', 'id'), ('Title', 'title'),
		     ('Dirt', 'director'), ('Actor', 'actor'),
		     ('Area', 'area'), ('Size', 'size'),
		     ('PT', 'pubtime'), ('LT', 'length'),
		     ('Lang', 'lang'), ('Score', 'score'),
		     ('Desc', 'desc'), ('Ldesc', 'longdesc'),
		     ('BIUrl', 'bigimage'), ('SIUrl', 'smallimage'),
		     ('CN', 'cn')]
	def __str__(self):
		return '<' + str (self.id) + ' ' + self.title + '>'

	def __eq__ (self, other):
		for i in PPSFilm.elements:
			if getattr (self, i[1]) != getattr (other, i[1]):
				return False
		return self.files == other.files

	def parse (self, node):
		self.id = int(xml_child_value (node, 'ID'))
		self.title = str(xml_child_value (node, 'Title'))
		self.director = str(xml_child_value (node, 'Dirt'))
		self.actor = str(xml_child_value (node, 'Actor'))
		self.area = str(xml_child_value (node, 'Area'))
		self.size = int(xml_child_value (node, 'Size'))
		self.pubtime = str(xml_child_value (node, 'PT'))
		self.length = str(xml_child_value (node, 'LT'))
		self.lang = str(xml_child_value (node, 'Lang') or '')
		self.score = float(xml_child_value (node, 'Score'))
		self.desc = str(xml_child_value (node, 'Desc'))
		self.longdesc = str(xml_child_value (node, 'Ldesc'))
		self.bigimage = str(xml_child_value (node, 'BIUrl'))
		self.smallimage = str(xml_child_value (node, 'SIUrl'))
		self.cn = int(xml_child_value (node, 'CN'))
		self.files = []
		self.pixbuf = None

		down = node.getElementsByTagName ('Down')
		if not down:
			return
		files = down[0].getElementsByTagName ('Url')
		for f in files:
			self.files += [PPSFile ().parse (f)]
		return self

	def to_cdata_element (self, dom, tag, data):
		if not type (data) is str:
			if data is None:
				print 'tag ', tag, 'is None'
				data = ''
			else:
				data = str (data)

		ele = dom.createElement (tag)
		child = dom.createCDATASection (data)
		ele.childNodes.append (child)
		return ele

	def toxml (self, dom):
		ele = dom.createElement ('Film')
		for child in PPSFilm.elements:
			childele = self.to_cdata_element (dom, child[0],
							  getattr (self, child[1]))
			ele.childNodes.append (childele)
		childele =  dom.createElement ('Down')
		for f in self.files:
			childele.childNodes.append (f.toxml (dom))
		ele.childNodes.append (childele)
		return ele

class ProcessThread (threading.Thread):
	def __init__ (self, data, process, callback, *args, **kwargs):
		self.data = data
		self.process = process
		self.callback = callback
		self.args = args
		self.kwargs = kwargs
		threading.Thread.__init__ (self)

	def run (self):
		try:
			res = self.process (self.data, *self.args, **self.kwargs)
		except Exception, e:
			print "Couldn't process data: ", e
			res = None

		gobject.idle_add (self.publish_results, res)

	def publish_results(self, res):
		self.callback (res, *self.args, **self.kwargs)
		return False

class DownloadThread (threading.Thread):
	def __init__ (self, url, callback, *args, **kwargs):
		self.url = url
		self.callback = callback
		self.args = args
		self.kwargs = kwargs
		threading.Thread.__init__ (self)

	def run (self):
		for i in range (3):
			try:
				res = urllib.urlopen (self.url).read ()
			except Exception, e:
				print "Coudn't open url: ", e
				res = None
			if res:
				break
		gobject.idle_add (self.publish_results, res)

	def publish_results(self, res):
		self.callback (res, *self.args, **self.kwargs)
		return False

class RetrieveImageTask:
	pass

class RetrieveImage (threading.Thread):
	def __init__ (self):
		self.queue = []
		self._cache = {}
		self._lock = threading.Lock ()
		self._done = False
		threading.Thread.__init__ (self)

	def retrieve (self, url, callback, *args):
		task = RetrieveImageTask ()
		task.url = url
		task.callback = callback
		task.args = args
		self._lock.acquire ()
		self.queue.append (task)
		self._lock.release ()

	def cancel_tasks (self):
		self._lock.acquire (True)
		self.queue = []
		self._cache = {}
		self._lock.release ()

	def cancel (self):
		self._done = True
		self._lock.acquire (True)
		self.queue = []
		self._cache = {}
		self._lock.release ()

	def is_busy (self):
		self._lock.acquire (True)
		busy = len (self.queue) != 0
		self._lock.release ()

		return busy

	def image_name_from_url (self, url):
		ext = url.rfind('.')
		if ext >= 0:
			ext = url[ext:]
		else:
			ext = ''
		filename = url_digest (url) + ext
		return os.path.join (pps_cache_dir, "images", filename)

	def load_image_from_disk (self, url):
		filename = self.image_name_from_url (url)
		if not os.access (filename, os.R_OK):
			return None

		#print 'loading image', filename
		try:
			pixbuf = gtk.gdk.pixbuf_new_from_file (filename)
		except gobject.GError:
			return None
		return pixbuf

	def store_image_to_disk (self, url, origin):
		filename = self.image_name_from_url (url)
		df = None
		sf = None
		try:
			df = file (filename, 'wb')
			sf = file (origin, 'rb')
			while True:
				buf = sf.read (4096)
				if not buf:
					break
				df.write (buf)
		except Exception, e:
			print 'Failed to copy ', origin, ' to ', filename
			print e
		finally:
			if df:
				df.close ()
			if sf:
				sf.close ()

	def load_pixbuf (self, url):
		pixbuf = self.load_image_from_disk (url)
		if pixbuf:
			return pixbuf

		try:
			filename, headers = urllib.urlretrieve (url)
		except IOError:
			return None

		try:
			pixbuf = gtk.gdk.pixbuf_new_from_file (filename)
		except gobject.GError:
			return None

		self.store_image_to_disk (url, filename)
		os.unlink (filename)
		return pixbuf

	def load_from_cache (self, url):
		pixbuf = None
		self._lock.acquire (True)
		if url in self._cache:
			pixbuf = self._cache [url]
		self._lock.release ()
		return pixbuf

	def put_in_cache (self, url, pixbuf):
		self._lock.acquire (True)
		self._cache[url] = pixbuf
		self._lock.release ()

	def run (self):
		import time
		while not self.done:
			task = None
			self._lock.acquire (True)
			if len (self.queue):
				#print 'pending tasks:', len(self.queue)
				task = self.queue.pop (0)
			self._lock.release ()

			if not task:
				time.sleep (0.1)
				continue

			pixbuf = self.load_from_cache (task.url)
			if not pixbuf:
				#print 'loading:', task.url
				pixbuf = self.load_pixbuf (task.url)
				if pixbuf:
					self.put_in_cache (task.url, pixbuf)
					time.sleep (0.10)

			if not pixbuf:
				continue

			#print 'image loaded:', task.url
			gobject.timeout_add (50, self.publish_result, pixbuf, task)

	def publish_result (self, pixbuf, task):
		task.callback (pixbuf, *task.args)
		return False

	@property
	def done (self):
		self._lock.acquire (True)
		res = self._done
		self._lock.release ()
		return res

class PPStream (totem.Plugin):
	def __init__ (self):
		totem.Plugin.__init__ (self)
		self.debug = False
		self.gstreamer_plugins_present = True

		self.gconf = gconf.client_get_default ()

		self.max_results = 20
		self.button_down = False

		self.categories_terms = ""
		self.ppstream_id = ""

		self.start_index = {}
		self.results = {} # This is just the number of results from the last pagination query
		self.entry = {}

		self.current_treeview_name = ""
		self.notebook_pages = []

		self.vadjust = {}
		self.liststore = {}
		self.treeview = {}

		self.classes = []
		self.subclass_index = 0

	def activate (self, totem_object):
		"""Check for the availability of the ppssrc GStreamer plugins"""
		bvw_name = totem_object.get_video_widget_backend_name ()

		if bvw_name.find ("GStreamer") != -1:
			try:
				import pygst
				pygst.require ("0.10")
				import gst

				registry = gst.registry_get_default ()
				if registry.find_plugin ("pps") == None:
					"""This means an error will be displayed when they try to play anything"""
					self.gstreamer_plugins_present = False
			except ImportError:
				"""Do nothing; either it's using xine or python-gstreamer isn't installed"""

		"""Continue loading the plugin as before"""
		self.builder = self.load_interface ("ppstream.ui", True, totem_object.get_main_window (), self)
		self.config_builder = self.load_interface ("ppstream-config.ui", True, totem_object.get_main_window (), self)
		self.totem = totem_object

		self.search_entry = self.builder.get_object ("pps_search_entry")
		self.search_entry.connect ("activate", self.on_search_entry_activated)
		self.refresh_button = self.builder.get_object ("pps_refresh_button")
		self.refresh_button.connect ("clicked", self.on_refresh_button_clicked)
		self.progress_bar = self.builder.get_object ("pps_progress_bar")

		self.notebook = self.builder.get_object ("pps_notebook")
		self.notebook.connect ("switch-page", self.on_notebook_page_changed)

		self.notebook_pages = ["categories", "films", "files"]
		self.current_treeview_name = "categories"
		self.load_config ()
		self.setup_favourites ()
		self.setup_categories ()
		self.setup_films ()
		self.setup_files ()
		self.setup_config_dialog ()

		self.vbox = self.builder.get_object ("pps_vbox")
		self.vbox.show_all ()
		totem_object.add_sidebar_page ("ppstream", _("PPStream"), self.vbox)

		self.retrieveimage = RetrieveImage ()
		self.retrieveimage.start ()

		self.classes = []
		self.fetch_classes ()

	def deactivate (self, totem):
		self.clear_ui ()
		self.categories_count +=1
		self.films_count += 1
		self.classes = []
		self.retrieveimage.cancel ()
		self.retrieveimage.join ()

		totem.remove_sidebar_page ("ppstream")

	def is_configurable (self):
		return True

	def create_configure_dialog (self):
		dialog = self.config_builder.get_object ("pps_config_dialog")
		show_posters = self.config_builder.get_object ("pps_config_show_posters")
		show_posters.set_active (self.configs['show_posters'])
		return dialog

	def fetch_classes (self, force = False):
		if force:
			self.classes = []
		if self.classes == []:
			self.films_ids = (-1, -1)
			self.subclass_index = 0
			self.categories_count += 1
			self.films_count += 1
			self.clear_ui ()
			self.retrieveimage.cancel_tasks ()

			### show favourites
			self.subclass_index += 1
			self.classes = [self.favourites]

			url = 'http://playlist.pps.tv/classfortv.php'
			thread = DownloadThread (url, self.classes_fetched,
						 self.categories_count)
			thread.start()

	def classes_fetched (self, res, count):
		if res:
			### check if this is a canceled task
			if self.categories_count == count:
				self.parse_class (res)
		else:
			print "Couldn't load ppstream media list"

	def subclasses_fetched (self, res, *args):
		if not self.classes:
			return
		### parse the xml
		self.parse_subclass (res)

		### fill categories view
		self.fill_categories (self.classes[self.subclass_index].id)

		### fetch next subclass
		self.fetch_next_subclass (True)

	def threaded_parse_films (self, res, clsid, subclsid, count):
		if not res:
			return None
		try:
			result = self.parse_films (res, clsid, subclsid)
		except Exception, e:
			print "Couldn't parse xml", clsid, subclsid, e
			result = None

		return result

	def films_fetched (self, res, clsid, subclsid, count, new = True):
		if self.films_count != count:
			return

		### check if the server repeats the last page
		cls, subcls = self.get_class_pair (clsid, subclsid)
		if not subcls:
			subcls = cls

		if res == subcls.last_films:
			subcls.fetching_films = False
			subcls.films_fetched = True
			return

		if res is None:
			subcls.fetching_films = False
			return

		subcls.last_films = res

		if new:
			self.store_films_to_disk (clsid, subclsid, res)
		### If the xml is larger then 4k, parse it in another thread.
		### Blocking the main thread is bad.
		if res and len(res) > 1024 * 4:
			process = ProcessThread (res, self.threaded_parse_films,
						 self.add_parsed_films,
						 clsid, subclsid, count)
			process.start ()
			return

		result = self.threaded_parse_films (res, clsid, subclsid, count)
		self.add_parsed_films (result, clsid, subclsid,count)

	def add_parsed_films (self, result, clsid, subclsid, count):
		if self.films_count != count:
			return
		cls, subcls = self.get_class_pair (clsid, subclsid)
		if not subcls:
			subcls = cls

		if result:
			subcls.films += result
		if len (subcls.films) >= subcls.contentnum:
			finished = True
			subcls.fetching_films = False
			subcls.films_fetched = True
		else:
			finished = False

		if result:
			self.fill_films (result, clsid, subclsid)
			if not finished:
				self.fetch_films (clsid, subclsid)
		else:
			subcls.fetching_films = False

	def parse_class (self, res):
		xmldoc = minidom.parseString (res)
		ch = xmldoc.getElementsByTagName ('PPSChannels')
		if not ch:
			return
		ch = ch[0]
		cls = ch.getElementsByTagName ('Class')
		for cl in cls:
			self.classes += [PPSClass ().parse (cl)]

		if cls:
			self.fetch_subclass (0, True)

	def fetch_subclass (self, index, show = False):
		self.subclass_index = index
		if self.classes[index].type == 1:
			if show:
				self.fill_categories (self.classes[index].id)
			self.fetch_next_subclass (show)
			return
		url = 'http://playlist.pps.tv/subclassfortv.php?class='
		classid = str(self.classes[index].id);
		thread = DownloadThread (url + classid, self.subclasses_fetched)
		thread.start()

	def fetch_next_subclass (self, show = False):
		if self.subclass_index < len(self.classes) - 1:
			self.fetch_subclass (self.subclass_index + 1, show)

	def parse_subclass (self, res):
		if not res:
			return
		xmldoc = minidom.parseString (res)
		clses = xmldoc.getElementsByTagName ('PPSSClasses')
		if not clses:
			return
		cls = clses[0].getElementsByTagName ('SubClass')
		curclass = self.classes[self.subclass_index]
		for cl in cls:
			curclass.subclasses += [PPSSubClass ().parse (cl)]

	def get_class_index (self, clsid):
		i = 0
		for cls in self.classes:
			if cls.id == clsid:
				return i
			i += 1
		return -1

	def get_subclass_index (self, clsindex, subclsid):
		i = 0
		for cls in self.classes[clsindex].subclasses:
			if cls.subid == subclsid:
				return i
			i += 1
		return -1

	def parse_films (self, res, clsid, subclsid):
		if not res:
			return []
		xmldoc = minidom.parseString (res)
		data = xmldoc.getElementsByTagName ('FilmData')
		if not data:
			return []
		films = data[0].getElementsByTagName ('Film')
		if not films:
			return []


		result = []
		for film in films:
			result += [PPSFilm ().parse (film)]

		return result

	def get_class_pair (self, clsid, subclsid):
		clsindex = self.get_class_index (clsid)
		cls = self.classes[clsindex]
		if cls.type == 0:
			subclsindex = self.get_subclass_index (clsindex, subclsid)

		if cls.type == 0:
			subcls = cls.subclasses[subclsindex]
		else:
			subcls = None
		return cls, subcls

	def films_disk_name (self, clsid, subclsid):
		cls, subcls = self.get_class_pair (clsid, subclsid)
		if cls.type == 1:
			subcls = cls
		filename = 'films' + '-' + str(clsid) + '-' + str(subclsid)
		filename += '-' + str(subcls.contentnum) + '-' + str(subcls.page)
		filename += '.xml'
		return os.path.join (pps_cache_dir, "xmls", filename)

	def store_films_to_disk (self, clsid, subclsid, res):
		filename = self.films_disk_name (clsid, subclsid)
		#print 'writing', filename
		f = file (filename, 'wb')
		f.write (res)
		f.close ()

	def load_films_from_disk (self, url, callback, clsid, subclsid, count):
		filename = self.films_disk_name (clsid, subclsid)
		if not os.access (filename, os.R_OK):
			return False

		#print 'reading', filename
		try:
			st = os.stat (filename)
			now = time.time ()
			if now - st.st_ctime > 60 * 60 * 24:
				os.unlink (filename)
				return None
		except OSError:
			return None
		try:
			res = file(filename, 'rb').read ()
		except:
			return False
		callback (res, clsid, subclsid, count, False)
		return True

	def purge_cached_films (self, clsid, subclsid):
		import glob

		cls, subcls = self.get_class_pair (clsid, subclsid)
		if cls.type == 1:
			subcls = cls
		filename = 'films' + '-' + str(clsid) + '-' + str(subclsid)
		filename += '-*' + '.xml'
		pattern = os.path.join (pps_cache_dir, "xmls", filename)
		for f in glob.glob (pattern):
			os.unlink (f)

	def download_films (self, url, callback, clsid, subclsid, count):
		if self.load_films_from_disk (url, callback, clsid, subclsid,
					      count):
			return

		thread = DownloadThread (url, callback, clsid, subclsid,
					 count)
		thread.start()

	def fetch_films (self, clsid, subclsid):
		cls, subcls = self.get_class_pair (clsid, subclsid)
		if cls.type == 1:
			subcls = cls
		if len (subcls.films) >= subcls.contentnum:
			return

		url = 'http://playlist.pps.tv/channelsfortv.php?'
		url += 'class=' + str(clsid)
		if cls.type == 0:
			url += '&subclass=' + str(subclsid)
		if not len (subcls.films):
			subcls.page = 0
		elif subcls.fetching_films:
			subcls.page += 1
		#print len(subcls.films), subcls.films, subcls.contentnum
		url += '&page=' + str(subcls.page + 1)
		#print 'fetchfilm url = ', url, len(subcls.films), subcls.contentnum
		subcls.fetching_films = True

		self.download_films (url, self.films_fetched, clsid, subclsid,
				     self.films_count)

	def on_cat_treeview_row_activated(self, treeview, path, view_column, data=None):
		model, rows = treeview.get_selection ().get_selected_rows ()
		iter = model.get_iter (rows[0])
		title = model.get_value (iter, 3)
		classid = model.get_value (iter, 0)
		subclassid = model.get_value (iter, 2)

		#print title, classid, subclassid
		self.show_films (classid, subclassid)
		self.notebook.set_current_page (1)

	def setup_categories (self):
		treeview_name = 'categories'
		treeview = self.builder.get_object ("pps_treeview_" + treeview_name)
		renderer = gtk.CellRendererText()
		renderer.set_property("xalign", 0.0)

		column = gtk.TreeViewColumn(_("Name"), renderer, text = 3)
		column.set_clickable(True)
		treeview.append_column(column)

		column = gtk.TreeViewColumn(_("Number"), renderer, text = 4)
		treeview.append_column(column)

		self.vadjust[treeview_name] = treeview.get_vadjustment ()
		self.vadjust[treeview_name].connect ("value-changed", self.on_value_changed)
		vscroll = self.builder.get_object ("pps_scrolled_window_" + treeview_name).get_vscrollbar ()
		vscroll.connect ("button-press-event", self.on_button_press_event)
		vscroll.connect ("button-release-event", self.on_button_release_event)

		self.liststore[treeview_name] = self.builder.get_object ("pps_liststore_" + treeview_name)
		self.treeview[treeview_name] = treeview
		treeview.set_model (self.liststore[treeview_name])

		treeview.connect("row_activated", self.on_cat_treeview_row_activated)

		self.categories_count = 0

	def on_add_to_favourites (self, button):
		selection = self.treeview['films'].get_selection ()
		model, rows = selection.get_selected_rows ()
		if not rows:
			return
		iter = model.get_iter (rows[0])
		clsid = model.get_value (iter, 4)
		subclsid = model.get_value (iter, 5)

		for row in rows:
			iter = model.get_iter (row)
			clsid = model.get_value (iter, 4)
			subclsid = model.get_value (iter, 5)
			self.add_favourites (clsid, subclsid, row[0], False)
		self.save_favourites ()
		self.refresh_favourites ()

	def on_remove_from_favourites (self, button):
		selection = self.treeview['films'].get_selection ()
		model, rows = selection.get_selected_rows ()
		if not rows:
			return
		rows.reverse ()
		for row in rows:
			iter = model.get_iter (row)
			clsid = model.get_value (iter, 4)
			subclsid = model.get_value (iter, 5)
			self.remove_favourites (clsid, subclsid, row[0], False)
		self.save_favourites ()
		self.refresh_favourites ()

	def setup_favourites (self):
		button = self.builder.get_object ('pps_add_to_favourites_button')
		self.add_to_favourites_button = button
		button.set_sensitive (False)
		button.connect ('clicked', self.on_add_to_favourites)
		button = self.builder.get_object ('pps_remove_from_favourites_button')
		button.set_sensitive (False)
		button.connect ('clicked', self.on_remove_from_favourites)
		self.remove_from_favourites_button = button
		self.load_favourites ()

	def load_favourites (self):
		treeview_name = 'categories'
		filename = os.path.join (pps_cache_dir, 'favourites.xml')

		self.favourites = PPSClass ()
		self.favourites.title = _('Favourites')
		self.favourites.films_fetched = True

		if not os.path.exists (filename):
			return
		try:
			res = file (filename, 'rb').read ()
			films = self.parse_films (res, 0, 0)
		except Exception, e:
			print "Couldn't load favourites.xml:", e
			return
		#print 'loaded favourite films', films
		if not films:
			return
		self.favourites.films = films
		self.favourites.contentnum = len (films)

	def save_favourites (self):
		treeview_name = 'categories'
		filename = os.path.join (pps_cache_dir, 'favourites.xml')
		fp = None
		try:
			fp = file (filename, 'w')
		except:
			return
		impl = minidom.getDOMImplementation ()
		doc = impl.createDocument(None, "FilmData", None)
		filmdata = doc.documentElement
		for film in self.favourites.films:
			filmdata.childNodes.append (film.toxml (doc))
		fp.write (doc.toxml (encoding = 'utf-8'))
		fp.close ()

	def add_favourites (self, clsid, subclsid, index, update = True):
		cls, subcls = self.get_class_pair (clsid, subclsid)
		if cls.type == 1:
			subcls = cls
		film = subcls.films[index]
		if film in self.favourites.films:
			return
		self.favourites.films.append (film)
		self.favourites.contentnum = len (self.favourites.films)

		if not update:
			return
		self.refresh_favourites ()
		self.save_favourites ()

	def remove_favourites (self, clsid, subclsid, index, update = False):
		cls, subcls = self.get_class_pair (clsid, subclsid)
		if cls.type == 1:
			subcls = cls
		film = subcls.films[index]
		#print self.favourites.films, film
		if not film in self.favourites.films:
			print "Couldn't find ", film, ' in favourites'
			return
		self.favourites.films.remove (film)
		self.favourites.contentnum = len (self.favourites.films)

		if not update:
			return
		self.refresh_favourites ()
		self.save_favourites ()

	def refresh_favourites (self):
		treeview_name = 'categories'
		treeview = self.builder.get_object ("pps_liststore_" + treeview_name)
		if not len (treeview):
			return

		iter = treeview.get_iter (0)
		treeview.set (iter, 4, self.favourites.contentnum)

		clsid, subclsid = self.films_ids
		if (clsid, subclsid) != (0, 0):
			return

		self.films_ids = (-1, -1)
		self.show_films (clsid, subclsid, False, True)

	def fill_all_categories (self):
		treeview_name = 'categories'
		treeview = self.builder.get_object ("pps_liststore_" + treeview_name)
		treeview.clear ()
		for cls in self.classes:
			iter = treeview.append(None)
			treeview.set(iter,
				     0, cls.id,
				     1, cls.type,
				     2, 0,
				     3, cls.title,
				     4, cls.contentnum)

			# add children
			for subcls in cls.subclasses:
				child_iter = treeview.append(iter);
				treeview.set(child_iter,
					     0, cls.id,
					     1, cls.type,
					     2, subcls.subid,
					     3, subcls.title,
					     4, subcls.contentnum)

	def fill_categories (self, clsid):
		treeview_name = 'categories'
		treeview = self.builder.get_object ("pps_liststore_" + treeview_name)
		for cls in self.classes:
			if cls.id != clsid:
				continue

			iter = treeview.append(None)
			treeview.set(iter,
				     0, cls.id,
				     1, cls.type,
				     2, 0,
				     3, cls.title,
				     4, cls.contentnum)

			# add children
			for subcls in cls.subclasses:
				child_iter = treeview.append(iter);
				treeview.set(child_iter,
					     0, cls.id,
					     1, cls.type,
					     2, subcls.subid,
					     3, subcls.title,
					     4, subcls.contentnum)
			break

	def gettipfromfilm (self, film, f):
		tip = film.title
		tip += '\n' + _("Director: ") + film.director
		tip += '\n' + _("Actor: ") + film.actor
		tip += '\n' + _("Area: ") + film.area
		tip += '\n' + _("Size: ") + str(film.size) + _('MB')
		tip += '\n' + _("Pubtime: ") + film.pubtime
		tip += '\n' + _("Length: ") + str(film.length) + _('Min')
		tip += '\n' + _("Score: ") + str(film.score)
		tip += '\n' + _("Episodes: ") + str(film.cn)
		tip += '\n' + _("Description: ") + film.desc
		tip += '\n' + _("Long Description: ") + film.longdesc

		return tip

	def retrieveimage_cb (self, pixbuf, film, iter, clsid, subclsid, count):
		treeview_name = 'films'
		treeview = self.builder.get_object ("pps_liststore_" + treeview_name)
		film.pixbuf = pixbuf

		try:
			### check whether the treeview has been cleared.
			if self.films_ids == (clsid, subclsid) and self.films_count == count:
				if self.configs['show_posters']:
					treeview.set (iter, 0, pixbuf)
				else:
					print 'not showing posters'
		except:
			pass

	def storelist_append_film (self, treeview, film, clsid, subclsid):
		if not film.files:
			return
		f = film.files[0]
		tip = self.gettipfromfilm (film, f)
		pixbuf = film.pixbuf
		if not self.configs['show_posters']:
			pixbuf = None
		it = treeview.append ([pixbuf, film.title, f.url, tip, clsid, subclsid])
		if not film.pixbuf and film.smallimage and self.configs['show_posters']:
			self.retrieveimage.retrieve (film.smallimage, self.retrieveimage_cb,
						     film, it, clsid, subclsid,
						     self.films_count)

	def clear_files (self):
		treeview_name = 'files'
		treeview = self.builder.get_object ("pps_liststore_" + treeview_name)
		treeview.clear ()

	def fill_files (self, film):
		treeview_name = 'files'
		treeview = self.builder.get_object ("pps_liststore_" + treeview_name)
		treeview.clear ()
		for f in film.files:
			no = str(f.ci) + '/' + str(film.cn)
			it = treeview.append ([no, film.title, f.url])

	def fill_all_films (self, clsid, subclsid):
		cls, subcls = self.get_class_pair (clsid, subclsid)
		if cls.type == 1:
			subcls = cls
		treeview_name = 'films'
		treeview = self.builder.get_object ("pps_liststore_" + treeview_name)
		for film in subcls.films:
			self.storelist_append_film (treeview, film, clsid, subclsid)

	def fill_films (self, films, clsid, subclsid):
		if self.films_ids != (clsid, subclsid):
			return
		treeview_name = 'films'
		treeview = self.builder.get_object ("pps_liststore_" + treeview_name)
		for film in films:
			self.storelist_append_film (treeview, film, clsid, subclsid)

	def refetch_films (self, clsid = None, subclsid = None):
		if clsid is None and subclsid is None:
			clsid, subclsid = self.films_ids

		self.purge_cached_films (clsid, subclsid)
		self.retrieveimage.cancel_tasks ()
		self.films_ids = (-1, -1)
		self.show_films (clsid, subclsid, True)

	def show_films (self, clsid, subclsid, force = False, cancel = True):
		### FIXME what to do when the subclasses is empty?
		if self.films_ids == (clsid, subclsid):
			return
		self.films_ids = (clsid, subclsid)

		if cancel:
			self.films_count += 1
			if self.films_ids != (-1, -1):
				cls, subcls = self.get_class_pair (*self.films_ids)
				if cls.type == 1:
					subcls = cls
				subcls.fetching_films = False

		self.films_ids = (clsid, subclsid)

		if not self.configs['show_posters']:
			self.retrieveimage.cancel_tasks ()

		self.clear_pages (['films', 'files'])

		cls, subcls = self.get_class_pair (clsid, subclsid)
		if cls.type == 1:
			subcls = cls
		if force and (clsid, subclsid) != (0, 0):
			subcls.films = []
			subcls.films_fetched = False
			subcls.last_films = ''

		if cancel or (not subcls.fetching_films and not self.retrieveimage.is_busy ()):
			self.add_progress_callback (clsid, subclsid, self.films_count)

		if subcls.films_fetched:
			self.fill_all_films (clsid, subclsid)
			return
		if not subcls.fetching_films:
			self.fetch_films (clsid, subclsid)
		else:
			print 'fetching films list for', clsid, subclsid, 'is already in progress'
			self.fill_all_films (clsid, subclsid)

	def setup_films (self):
		treeview_name = 'films'
		self.start_index[treeview_name] = 1
		self.results[treeview_name] = 0
		self.entry[treeview_name] = None
		self.films_ids = (-1, -1)
		self.films_count = 0

		"""This is done here rather than in the UI file,
		because UI files parsed in C and GObjects created in
		Python apparently don't mix."""
		renderer = totem.CellRendererVideo (use_placeholder = self.configs['show_posters'])
		treeview = self.builder.get_object ("pps_treeview_" + treeview_name)
		treeview.set_property ("totem", self.totem)
		treeview.connect ("row-activated", self.on_films_row_activated)
		treeview.connect_after ("starting-video", self.on_films_starting_video)
		treeview.insert_column_with_attributes (0, _("Videos"), renderer, thumbnail=0, title=1)
		self.cell_video_renderer = renderer

		self.vadjust[treeview_name] = treeview.get_vadjustment ()
		self.vadjust[treeview_name].connect ("value-changed", self.on_value_changed)
		vscroll = self.builder.get_object ("pps_scrolled_window_" + treeview_name).get_vscrollbar ()
		vscroll.connect ("button-press-event", self.on_button_press_event)
		vscroll.connect ("button-release-event", self.on_button_release_event)

		self.liststore[treeview_name] = self.builder.get_object ("pps_liststore_" + treeview_name)
		self.treeview[treeview_name] = treeview
		treeview.set_model (self.liststore[treeview_name])

		selection = treeview.get_selection ()
		selection.connect ("changed", self.on_films_selection_changed_cb)

	def add_to_playlist_cb (self, treeview):
		treeview_name = 'files'
		treeview = self.builder.get_object ("pps_treeview_" + treeview_name)
		selection = treeview.get_selection ()
		model = treeview.get_model ()
		model, rows = selection.get_selected_rows ()

		for row in rows:
			iter = model.get_iter (row)
			mrl = model.get_value (iter, 2)
			self.totem.action_remote (totem.REMOTE_COMMAND_ENQUEUE, mrl)

	def copy_location_cb (self, action):
		treeview_name = 'files'
		treeview = self.builder.get_object ("pps_treeview_" + treeview_name)
		selection = treeview.get_selection ()
		model = treeview.get_model ()
		model, rows = selection.get_selected_rows ()
		iter = model.get_iter (rows[0])
		mrl = model.get_value (iter, 2)

		clip = gtk.Clipboard ()
		clip.set_text (mrl)
		clip = gtk.Clipboard (display = gtk.gdk.display_get_default(),
				      selection = "PRIMARY")
		clip.set_text (mrl)


	def setup_files_action (self):
		self.files_uimanager = gtk.UIManager ()
		action_group = gtk.ActionGroup ("pps-files-action-group")
		action_group.add_actions ([('add-to-list', gtk.STOCK_ADD, _('_Add to Playlist'), None,
					    _("Add the video to playlist"), self.add_to_playlist_cb),
					   ('copy-location', gtk.STOCK_COPY, _('_Copy Location'), None,
					   _("Copy location to the clipboard"), self.copy_location_cb)])
		self.files_uimanager.insert_action_group(action_group, 0)
		ui = """
		<popup name="pps-file-list-group">
		       <menuitem name="add-to-list" action="add-to-list"/>
		       <menuitem name="copy-location" action="copy-location"/>
		</popup>"""
		self.files_uimanager.add_ui_from_string (ui)

	def files_show_popup_menu (self, event = None):
		treeview_name = 'files'
		treeview = self.builder.get_object ("pps_treeview_" + treeview_name)
		selection = treeview.get_selection ()

		if event:
			button = event.button
			time = event.time
			path = treeview.get_path_at_pos (int(event.x), int(event.y))
			if not path or not selection.path_is_selected (path[0]):
				selection.unselect_all ()
		else:
			time = gtk.get_current_event_time ()
			button = None

		count = selection.count_selected_rows ()
		if not count:
			return False

		action_group = self.files_uimanager.get_action_groups () [0]
		action = action_group.get_action ("copy-location")
		action.set_sensitive (count == 1)

		menu = self.files_uimanager.get_widget ("/pps-file-list-group")
		menu.select_first (False)
		menu.popup (None, None, None, button, time)

		return True

	def files_popup_menu_cb (self):
		print 'popup menu'
		self.files_show_popup_menu ()

	def files_button_pressed_cb (self, widget, event, user_data = None):
		if event.type == gtk.gdk.BUTTON_PRESS and event.button == 3:
			return self.files_show_popup_menu (event)

		return False

	def setup_files (self):
		treeview_name = 'files'
		treeview = self.builder.get_object ("pps_treeview_" + treeview_name)
		renderer = gtk.CellRendererText()
		renderer.set_property("xalign", 0.0)

		column = gtk.TreeViewColumn(_("No"), renderer, text = 0)
		column.set_clickable(True)
		treeview.append_column(column)

		column = gtk.TreeViewColumn(_("Title"), renderer, text = 1)
		treeview.append_column(column)

		column = gtk.TreeViewColumn(_("Mrl"), renderer, text = 2)
		treeview.append_column(column)

		self.vadjust[treeview_name] = treeview.get_vadjustment ()
		self.vadjust[treeview_name].connect ("value-changed", self.on_value_changed)
		vscroll = self.builder.get_object ("pps_scrolled_window_" + treeview_name).get_vscrollbar ()
		vscroll.connect ("button-press-event", self.on_button_press_event)
		vscroll.connect ("button-release-event", self.on_button_release_event)

		self.liststore[treeview_name] = self.builder.get_object ("pps_liststore_" + treeview_name)
		self.treeview[treeview_name] = treeview
		treeview.set_model (self.liststore[treeview_name])

		treeview.connect("row_activated", self.on_files_treeview_row_activated)

		self.setup_files_action ()
		treeview.connect ("popup-menu", self.files_popup_menu_cb)
		treeview.connect ("button-press-event", self.files_button_pressed_cb)

		selection = treeview.get_selection ()
		selection.set_mode (gtk.SELECTION_MULTIPLE)

	def on_files_treeview_row_activated(self, treeview, path, view_column, data=None):
		model, rows = treeview.get_selection ().get_selected_rows ()
		try:
			iter = model.get_iter (rows[0])
		except IndexError:
			print 'activated invalid index:', rows[0]
			return

		title = model.get_value (iter, 1)
		mrl = model.get_value (iter, 2)
		#print title, mrl
		if hasattr(self.totem, "add_to_playlist_and_play"):
			self.totem.add_to_playlist_and_play (mrl, title, False)
		else:
			self.totem.action_remote (totem.REMOTE_COMMAND_REPLACE, mrl)

	def on_films_selection_changed_cb (self, selection):
		model, rows = selection.get_selected_rows ()
		if not rows:
			return
		iter = model.get_iter (rows[0])
		clsid = model.get_value (iter, 4)
		subclsid = model.get_value (iter, 5)

		cls, subcls = self.get_class_pair (clsid, subclsid)
		if cls.type == 1:
			subcls = cls

		#print clsid, subclsid, cls, subcls, rows, len(subcls.films)
		if subcls.films:
			self.fill_files (subcls.films[rows[0][0]])

	def on_notebook_page_changed (self, notebook, notebook_page, page_num):
		self.current_treeview_name = self.notebook_pages[page_num]
		self.add_to_favourites_button.set_sensitive (False)
		self.remove_from_favourites_button.set_sensitive (False)
		if self.current_treeview_name == 'files':
			self.refresh_button.set_sensitive (False)
		elif self.current_treeview_name == 'films':
			if self.films_ids == (-1, -1):
				self.refresh_button.set_sensitive (False)
			elif self.films_ids == (0, 0):
				self.remove_from_favourites_button.set_sensitive (True)
			else:
				self.refresh_button.set_sensitive (True)
				self.add_to_favourites_button.set_sensitive (True)

		else:
			self.refresh_button.set_sensitive (True)

	def update_progress_bar (self):
		if self.films_ids == (-1, -1):
			self.progress_bar.set_fraction (0.0)
			self.progress_bar.set_text ("")

			return True

		cls, subcls = self.get_class_pair (*self.films_ids)
		if not subcls:
			subcls = cls
		if subcls.fetching_films:
			progress = float(len (subcls.films)) / subcls.contentnum
			if progress > 1.0:
				progress = 1.0
			self.progress_bar.set_fraction (progress)
			progressstr = str(len (subcls.films)) + '/' + str(subcls.contentnum)
			self.progress_bar.set_text ("Loading film list(" + progressstr + ')...')
			return True
		elif self.retrieveimage.is_busy ():
			self.progress_bar.set_text ('loading posters...')
			self.progress_bar.pulse ()
		else:
			self.progress_bar.set_fraction (0.0)
			self.progress_bar.set_text ("")

			return False

		return True

	def update_progress_bar_cb (self, clsid, subclsid, count):
		if self.films_ids == (clsid, subclsid) and self.films_count == count:
			return self.update_progress_bar ()
		return False

	def add_progress_callback (self, clsid, subclsid, count):
		gobject.timeout_add (350, self.update_progress_bar_cb,
				     clsid, subclsid, count)

	def on_films_row_activated (self, treeview, path, column):
		pass

	def on_films_starting_video (self, treeview, path, user_data):
		"""Display an error if the required GStreamer plugins aren't installed"""
		if self.gstreamer_plugins_present == False:
			self.totem.interface_error_with_link (_("Totem cannot play this type of media (%s) because you do not have the appropriate plugins to handle it.") % _("Ppstream"),
							      _("Please install the necessary plugins and restart Totem to be able to play this media."),
							      "http://www.gnome.org/projects/totem/#codecs",
							      _("More information about media plugins"),
							      self.totem.get_main_window ())
			return False

		return True

	def on_button_press_event (self, widget, event):
		self.button_down = True

	def on_button_release_event (self, widget, event):
		self.button_down = False
		self.on_value_changed (self.vadjust[self.current_treeview_name])

	def on_value_changed (self, adjustment):
		"""Load more results when we get near the bottom of the treeview"""
		pass

	def clear_ui (self, what = None):
		#window = self.vbox.window
		#window.set_cursor (None)
		self.progress_bar.set_fraction (0.0)
		self.progress_bar.set_text ("")
		self.clear_pages (what)

	def clear_pages (self, what = None):
		if what is None:
			what = self.notebook_pages
		if not type(what) is list:
			what = [what]

		for treeview_name in what:
			treeview = self.builder.get_object ("pps_liststore_" + treeview_name)
			treeview.clear ()

	def refresh_categories (self):
		self.fetch_classes (True)

	def refresh_films (self):
		if self.films_ids != (-1, -1):
			self.refetch_films ()

	def set_show_posters (self, show = True):
		self.cell_video_renderer.set_property ('use_placeholder', show)
		if self.films_ids == (-1, -1):
			return
		clsid, subclsid = self.films_ids
		self.films_ids = (-1, -1)
		self.show_films (clsid, subclsid, False, False)

	def sync_config (self):
		for key in self.input_configs.keys ():
			keyname = gconf_key + '/' + key
			value = self.input_configs [key]
			if type (value) is bool:
				self.gconf.set_bool (keyname, value)
			elif type (value) is int:
				self.gconf.set_int (keyname, value)
			elif type (value) is float:
				self.gconf.set_float (keyname, value)
			else:
				self.gconf.set_string (keyname, value)
		if self.input_configs['show_posters'] == self.configs['show_posters']:
			return

		self.configs['show_posters'] = self.input_configs['show_posters']
		self.set_show_posters (self.configs['show_posters'])

	def on_refresh_button_clicked (self, button):
		search_terms = self.search_entry.get_text ()
		if self.current_treeview_name == 'categories':
			self.refresh_categories ()
		elif self.current_treeview_name == 'films':
			self.refresh_films ()

	def on_search_entry_activated (self, entry):
		search_terms = self.search_entry.get_text ()

	def on_config_dialog_delete (self, dialog, event):
		dialog.hide ()
		return True

	def on_config_dialog_close (self, dialog):
		dialog.hide ()

	def on_config_dialog_response (self, dialog, response_id):
		dialog.hide ()
		if response_id == gtk.RESPONSE_DELETE_EVENT:
			return
		elif response_id == 1:
			return

		self.sync_config ()

	def on_show_posers_toggle (self, button):
		self.input_configs['show_posters'] = button.get_active ()

	def load_config (self):
		### current configs
		self.configs = {}
		self.configs['show_posters'] = self.gconf.get_bool ('%s/show_posters' % gconf_key)

		### user input configs
		self.input_configs = self.configs.copy ()

	def setup_config_dialog (self):
		dialog = self.config_builder.get_object ("pps_config_dialog")
		dialog.connect ("response", self.on_config_dialog_response)
		dialog.connect ("close", self.on_config_dialog_close)
		dialog.connect ("delete-event", self.on_config_dialog_delete)

		show_posters = self.config_builder.get_object ("pps_config_show_posters")
		show_posters.set_active (self.configs['show_posters'])
		show_posters.connect ("toggled", self.on_show_posers_toggle)