deluge/plugins/FlexRSS/plugin.py

def gtk_treeview_search_cb_stristr(model, column, key, iter, data=None):
	value = model.get_value(iter, column)
	if value.lower().find(key.lower()) > -1:
		return False
	else:
		return True

class plugin_FlexRSS_Config:
	constants = {
		'Generic'         : 0,
		'TV Show'         : 1,
		'TV Show (dated)' : 2 }
	feeds_counter = 0
	filters_counter = 0
	feeds = None
	filters = None
	version = 0
	show_toolbar_button = False
	threaded_retrieval = False

	def getFilter(self, id):
		if not self.filters:
			return None

		for filter in self.filters:
			if filter['id'] == id:
				return filter

		return None

	def setFilter(self, id, key, value):
		filter = self.getFilter(id)

		if not filter:
			return False
		else:
			filter[key] = value
			return True

	def addFilter(self, name, type, patterns, feeds):
		id = self.feeds_counter + 1
		self.feeds_counter = id

		if not self.filters:
			self.filters = []

		filter = { "id"       : id,
				   "name"     : name,
				   "type"     : type,
				   "patterns" : patterns,
				   "feeds"    : feeds,
				   "history"  : {},
				   "path"     : None,
				   "enabled"  : True,
				   "queue_top": False,
				   "pause"    : False,
				   "delete"   : False}

		self.filters.append(filter)

		return id

	def deleteFilter(self, id):
		if not self.filters:
			return False

		i = 0
		while i < len(self.filters):
			if self.filters[i]['id'] == id:
				del self.filters[i]
				return True
			i = i + 1

	def checkHistory(self, id, type, data):
		filter = self.getFilter(id)

		if not filter:
			return False

		try:
			if type == self.constants['TV Show']:
				filter['history'][type][data['series']].index(data['episode'])
				return True
			elif type == self.constants['TV Show (dated)']:
				filter['history'][type][data['year']][data['month']].index(data['day'])
				return True
			else:
				filter['history'][type].index(data['url'])
				return True
		except:
			return False

	def checkRange(self, id, type, data):
		filter = self.getFilter(id)

		if not filter:
			return False

		if type == self.constants['TV Show']:
			if filter['history'][type].has_key('from'):
				if data['series'] < filter['history'][type]['from']['season']:
					return False
				elif data['series'] == filter['history'][type]['from']['season']:
					if data['episode'] < filter['history'][type]['from']['episode']:
						return False

			if filter['history'][type].has_key('thru'):
				if data['series'] > filter['history'][type]['thru']['season']:
					return False
				elif data['series'] == filter['history'][type]['thru']['season']:
					if data['episode'] > filter['history'][type]['thru']['episode']:
						return False

			return True

		elif type == self.constants['TV Show (dated)']:
			if filter['history'][type].has_key('from'):
				if data['year'] < filter['history'][type]['from']['year']:
					return False
				elif data['year'] == filter['history'][type]['from']['year']:
					if data['month'] < filter['history'][type]['from']['month']:
						return False
					elif data['month'] == filter['history'][type]['from']['month']:
						if data['day'] < filter['history'][type]['from']['day']:
							return False

			if filter['history'][type].has_key('thru'):
				if data['year'] > filter['history'][type]['thru']['year']:
					return False
				elif data['year'] == filter['history'][type]['thru']['year']:
					if data['month'] > filter['history'][type]['thru']['month']:
						return False
					elif data['month'] == filter['history'][type]['thru']['month']:
						if data['day'] > filter['history'][type]['thru']['day']:
							return False

			return True

		else:
			return True

	def addHistory(self, id, type, data):
		filter = self.getFilter(id)

		if not filter:
			return False

		if type == self.constants['TV Show']:
			if not filter['history'].has_key(type):
				filter['history'][type] = {}
			if not filter['history'][type].has_key(data['series']):
				filter['history'][type][data['series']] = []
			filter['history'][type][data['series']].append(data['episode'])
		elif type == self.constants['TV Show (dated)']:
			if not filter['history'].has_key(type):
				filter['history'][type] = {}
			if not filter['history'][type].has_key(data['year']):
				filter['history'][type][data['year']] = {}
			if not filter['history'][type][data['year']].has_key(data['month']):
				filter['history'][type][data['year']][data['month']] = []
			filter['history'][type][data['year']][data['month']].append(data['day'])
		else:
			if not filter['history'].has_key(type):
				filter['history'][type] = []
			try:
				filter['history'][type].append(data['url'])
			except AttributeError, e:
				filter['history'][type] = [data['url']]

	def getFeed(self, id):
		if not self.feeds:
			return None

		for feed in self.feeds:
			if feed['id'] == id:
				return feed

		return None

	def setFeed(self, id, key, value):
		feed = self.getFeed(id)

		if not feed:
			return False
		else:
			feed[key] = value
			return True

	def addFeed(self, name, url, interval):
		# Uhhh... no ++? WTF is the increment operator?
		id = self.feeds_counter + 1
		self.feeds_counter = id

		if not self.feeds:
			self.feeds = []

		self.feeds.append({ "id"       : id,
							"name"     : name,
							"url"      : url,
							"interval" : interval,
							"enabled"  : True })

		return id

	def deleteFeed(self, id):
		if not self.feeds:
			return False

		i = 0
		while i < len(self.feeds):
			if self.feeds[i]['id'] == id:
				del self.feeds[i]
				return True
			i = i + 1

class plugin_FlexRSS:
	config = None
	glade = None
	feeds = None
	toolbar_button = None
	history_calendarbuttons = None

	def update_config(self):
		if self.config.version >= 5:
			return

		if self.config.version < 1:
			print 'Updating config to v1'
			i = 0
			while i < len(self.config.filters):
				self.config.filters[i]['enabled'] = True
				i = i + 1

		if self.config.version < 2:
			print 'Updating config to v2'
			i = 0
			while i < len(self.config.feeds):
				self.config.feeds[i]['enabled'] = True
				i = i + 1

		if self.config.version < 3:
			print 'Updating config to v3'
			i = 0
			while i < len(self.config.filters):
				type_s = self.config.filters[i]['type']
				type_i = self.config.constants[type_s]
				if self.config.filters[i]['history'].has_key(type_s):
					history = { type_i: self.config.filters[i]['history'][type_s] }
					self.config.filters[i]['history'] = history
				self.config.filters[i]['type'] = self.config.constants[self.config.filters[i]['type']];
				i = i + 1

		if self.config.version < 4:
			print 'Updating config to v4'
			i = 0
			while i < len(self.config.filters):
				self.config.filters[i]['queue_top'] = False
				self.config.filters[i]['pause'] = False
				i = i + 1

		if self.config.version < 5:
			print 'Updating config to v5'
			i = 0
			while i < len(self.config.filters):
				self.config.filters[i]['delete'] = False
				i = i + 1

		self.config.version = 5
		self.write_config()

	def load_config(self):
		import deluge.common, os, cookielib

		file = deluge.common.CONFIG_DIR + "/flexrss.dat"
		if os.path.isfile(file):
			import pickle

			fd = open(file, 'r')
			self.config = pickle.load(fd)
			fd.close()
		else:
			self.config = plugin_FlexRSS_Config()
			self.config.version = 5

		self.update_config()

		cookie_file = deluge.common.CONFIG_DIR + "/flexrss-cookies.txt"
		self.cookies = cookielib.MozillaCookieJar()
		if os.path.isfile(cookie_file):
			self.cookies.load(cookie_file)

	def write_config(self, write_cookies=False):
		import deluge.common, os, pickle

		file = deluge.common.CONFIG_DIR + "/flexrss.dat"
		fd = open(file, 'w')
		pickle.dump(self.config, fd)
		fd.close()

		if write_cookies:
			print "Saving cookies."
			self.cookies.save(deluge.common.CONFIG_DIR + "/flexrss-cookies.txt")

	def configure_cb_closed(self, args):
		self.glade = None
		self.history_calendarbuttons = None

	def configure_cb_feed_new(self, args):
		feed = { "name"     : 'Untitled',
				 "url"      : 'http://',
				 "interval" : 900,
				 "id"       : 0 }

		feed["id"] = self.config.addFeed(feed["name"], feed["url"], feed["interval"])

		view = self.glade.get_widget("FlexRSS_Feeds")
		model = view.get_model()
		view.get_selection().select_iter(model.append(None, (feed["id"], feed["name"], feed["url"])))

	def configure_cb_feed_selected(self, selection):
		model, iter = selection.get_selected()

		if not iter:
			return

		parent = model.iter_parent(iter)
		if parent: # Selected a filter
			self.glade.get_widget('FlexRSS_Filters_Test_Pattern').set_text(model.get_value(iter, 1))
			self.configure_cb_test_filter(None)

			iter = parent

		# We want to edit a feed.
		feed = self.config.getFeed(model.get_value(iter, 0))
		if not feed:
			print 'Error: could not find feed #' + str(model.get_value(iter, 0))
			return

		self.glade.get_widget("FlexRSS_EditFeed_Name").set_text(feed["name"])
		self.glade.get_widget("FlexRSS_EditFeed_URL").set_text(feed["url"])
		self.glade.get_widget("FlexRSS_EditFeed_Interval").set_text(str(feed["interval"]))
		if feed["enabled"] == True:
			self.glade.get_widget("FlexRSS_EditFeed_Status_Enabled").set_active(True)
		else:
			self.glade.get_widget("FlexRSS_EditFeed_Status_Disabled").set_active(True)
		self.glade.get_widget('FlexRSS_Feeds_Editor').show()

	def configure_cb_feed_delete(self, arg, id=None):
		if not id:
			# Which feed is selected?
			selection = self.glade.get_widget("FlexRSS_Feeds").get_selection()
			model, iter = selection.get_selected()

			if not iter:
				return

			id = model.get_value(iter, 0)
			if id == 0:
				id = model.get_value(model.iter_parent(iter), 0)
		else:
			model = self.glade.get_widget("FlexRSS_Feeds").get_model()
			iter = model.get_iter_first()
			while iter:
				if model.get_value(iter, 0) == id:
					break
				iter = model.iter_next(iter)

		if not iter:
			print 'Couldn\'t find feed.'
			return

		# Remove from config
		if not self.config.deleteFeed(id):
			print 'Unable to delete feed #' + str(id)
			return

		# Remove from UI
		model.remove(iter)

		self.write_config()

		# We are no longer editing a feed, so hide the editing widgets.
		self.glade.get_widget('FlexRSS_Feeds_Editor').hide()

	def configure_cb_feed_save(self, arg, id=None):
		if not id:
			# Which feed is selected?
			selection = self.glade.get_widget("FlexRSS_Feeds").get_selection()
			model, iter = selection.get_selected()

			if not iter:
				return

			id = model.get_value(iter, 0)
			if id == 0:
				iter = model.iter_parent(iter)
				id = model.get_value(iter, 0)
		else:
			model = self.glade.get_widget("FlexRSS_Feeds").get_model()
			iter = model.iter_first()
			while iter:
				if model.get_value(iter, 0) == id:
					break
				iter = iter.iter_next(iter)

		if not iter:
			print 'Couldn\'t find feed.'
			return

		# Update configuration
		self.config.setFeed(id, "name", self.glade.get_widget("FlexRSS_EditFeed_Name").get_text())
		self.config.setFeed(id, "url", self.glade.get_widget("FlexRSS_EditFeed_URL").get_text())
		interval = self.configure_ui_get_text_as_int("FlexRSS_EditFeed_Interval", 900)
		if interval < 300:
			# It's just not polite to hit a server that often.
			self.glade.get_widget("FlexRSS_EditFeed_Interval").set_text('300')
			interval = 300
		self.config.setFeed(id, "interval", interval)
		self.config.setFeed(id, "enabled", self.glade.get_widget("FlexRSS_EditFeed_Status_Enabled").get_active())
		self.write_config()

		# Update UI
		feed = self.config.getFeed(id)
		model.set_value(iter, 0, feed["id"])
		model.set_value(iter, 1, feed["name"])
		model.set_value(iter, 2, feed["url"])

		if not self.feeds.has_key(id):
			self.feeds[id] = { 'cfg'     : feed,
							   'updated' : 0,
							   'data'    : [] }

	def escape_regex_special_chars(self, pattern):
		escape_chars = '[]()^$\\.?*+|'
		out = []
		for c in pattern:
			try:
				escape_chars.index(c)
				out.append('\\' + c)
			except:
				out.append(c)
		return ''.join(out)

	def configure_cb_filter_new(self, arg, test_pattern=None):
		filter = { "name"     : "Untitled",
				   "type"     : "Generic",
				   "patterns" : [('', 'Title')],
				   "feeds"    : [0],
				   "id"       : 0 }

		if test_pattern:
			# Try to guess a good pattern
			import re, string

			trans_table = string.maketrans(' ', '.')

			# TV Show
			exp = re.compile(r'(.*?)S([0-9]+)E([0-9]+)', re.IGNORECASE)
			match = exp.match(test_pattern)
			if match:
				pattern = self.escape_regex_special_chars(match.group(1)).lower().translate(trans_table) + 's%se%e'
				filter['patterns'][0] = (pattern, 'Title')
				filter['name'] = match.group(1)
				filter['type'] = self.config.constants['TV Show']

			if not match:
				exp = re.compile(r'(.*?)([0-9]{4}).([0-9]{1,2}).([0-9]{1,2})', re.IGNORECASE)
				match = exp.match(test_pattern)
				if match:
					pattern = None
					if ((int(match.group(3)) <= 12) and (int(match.group(4)) <= 31)):
						pattern = self.escape_regex_special_chars(match.group(1)).lower().translate(trans_table) + '%Y.%m.%d'
					elif ((int(match.group(3)) <= 31) and (int(match.group(4)) <= 12)):
						pattern = self.escape_regex_special_chars(match.group(1)).lower().translate(trans_table) + '%Y.%d.%m'

					if pattern:
						filter['patterns'][0] = (pattern, 'Title')
						filter['name'] = match.group(1)
						filter['type'] = self.config.constants['TV Show (dated)']
					else:
						match = None

			if not match:
				exp = re.compile(r'(.*?)([0-9]{2}).([0-9]{2}).([0-9]{2})', re.IGNORECASE)
				match = exp.match(test_pattern)
				if match:
					pattern = None
					if ((int(match.group(2)) <= 12) and (int(match.group(3)) <= 31)):
						pattern = self.escape_regex_special_chars(match.group(1)).lower().translate(trans_table) + '%m.%d.%y'
					elif ((int(match.group(3)) <= 31) and (int(match.group(2)) <= 12)):
						pattern = self.escape_regex_special_chars(match.group(1)).lower().translate(trans_table) + '%d.%m.%y'

					if pattern:
						filter['patterns'][0] = (pattern, 'Title')
						filter['name'] = match.group(1)
						filter['type'] = self.config.constants['TV Show (dated)']
					else:
						match = None

			if not match:
				exp = re.compile(r'(.*?)([0-9]+)([x\.\-_]{1})([0-9]+)', re.IGNORECASE)
				match = exp.match(test_pattern)
				if match:
					pattern = self.escape_regex_special_chars(match.group(1)).lower().translate(trans_table) + '%s' + self.escape_regex_special_chars(match.group(3)) + '%e'
					filter['patterns'][0] = (pattern, 'Title')
					filter['name'] = match.group(1)
					filter['type'] = self.config.constants['TV Show']

			if not match:
				exp = re.compile(r'(.*?)([0-9]+)$', re.IGNORECASE)
				match = exp.match(test_pattern)
				if match:
					pattern = self.escape_regex_special_chars(match.group(1)).lower().translate(trans_table) + '%e'
					filter['patterns'][0] = (pattern, 'Title')
					filter['name'] = match.group(1)
					filter['type'] = self.config.constants['TV Show']

		# Add to config
		filter['id'] = self.config.addFilter(filter['name'], filter['type'], filter['patterns'], [0])

		# Add to UI
		self.configure_ui_add_filter(self.config.getFilter(filter['id']), test_pattern)

	def configure_cb_filter_selected(self, selection):
		model, iter = selection.get_selected()

		if not iter:
			return

		# We want to edit a filter.
		filter = self.config.getFilter(model.get_value(iter, 0))
		if not filter:
			print 'Error: could not find filter #' + str(model.get_value(iter, 0))
			return

		self.configure_ui_reset_filter()

		self.glade.get_widget('FlexRSS_Filters_Name').set_text(filter['name'])

		if filter['type'] == self.config.constants['TV Show']:
			type_i = 1
		elif filter['type'] == self.config.constants['TV Show (dated)']:
			type_i = 2
		else:
			type_i = 0

		self.glade.get_widget('FlexRSS_Filters_Type').set_active(type_i)

		selection = self.glade.get_widget('FlexRSS_Filters_Feed').get_selection()
		selection.unselect_all()
		feed_model = self.glade.get_widget('FlexRSS_Filters_Feed').get_model()
		for i in filter['feeds']:
			if i == 0:
				selection.select_all()
			else:
				iter = feed_model.get_iter_first()
				while iter:
					if feed_model.get_value(iter, 0) == i:
						selection.select_iter(iter)
					iter = feed_model.iter_next(iter)

		for pattern in filter['patterns']:
			self.configure_ui_add_pattern(pattern)

		if filter['type'] == self.config.constants['TV Show']:
			if filter['history'].has_key(filter['type']) and filter['history'][filter['type']].has_key('from'):
				self.glade.get_widget('FlexRSS_History_TVShow_From_Enabled').set_active(True)
				self.glade.get_widget('FlexRSS_History_TVShow_From_Season').set_sensitive(True)
				self.glade.get_widget('FlexRSS_History_TVShow_From_Episode').set_sensitive(True)
				self.glade.get_widget('FlexRSS_History_TVShow_From_Season').set_text(str(filter['history'][filter['type']]['from']['season']))
				self.glade.get_widget('FlexRSS_History_TVShow_From_Episode').set_text(str(filter['history'][filter['type']]['from']['episode']))
			else:
				self.glade.get_widget('FlexRSS_History_TVShow_From_Enabled').set_active(False)
				self.glade.get_widget('FlexRSS_History_TVShow_From_Season').set_sensitive(False)
				self.glade.get_widget('FlexRSS_History_TVShow_From_Episode').set_sensitive(False)
				self.glade.get_widget('FlexRSS_History_TVShow_From_Season').set_text('0')
				self.glade.get_widget('FlexRSS_History_TVShow_From_Episode').set_text('0')

			if filter['history'].has_key(filter['type']) and filter['history'][filter['type']].has_key('thru'):
				self.glade.get_widget('FlexRSS_History_TVShow_Thru_Enabled').set_active(True)
				self.glade.get_widget('FlexRSS_History_TVShow_Thru_Season').set_sensitive(True)
				self.glade.get_widget('FlexRSS_History_TVShow_Thru_Episode').set_sensitive(True)
				self.glade.get_widget('FlexRSS_History_TVShow_Thru_Season').set_text(str(filter['history'][filter['type']]['thru']['season']))
				self.glade.get_widget('FlexRSS_History_TVShow_Thru_Episode').set_text(str(filter['history'][filter['type']]['thru']['episode']))
			else:
				self.glade.get_widget('FlexRSS_History_TVShow_Thru_Enabled').set_active(False)
				self.glade.get_widget('FlexRSS_History_TVShow_Thru_Season').set_sensitive(False)
				self.glade.get_widget('FlexRSS_History_TVShow_Thru_Episode').set_sensitive(False)
				self.glade.get_widget('FlexRSS_History_TVShow_Thru_Season').set_text('0')
				self.glade.get_widget('FlexRSS_History_TVShow_Thru_Episode').set_text('0')

			self.glade.get_widget("FlexRSS_History_TVShow_Dated").hide()
			self.glade.get_widget("FlexRSS_History_TVShow").show()
			self.glade.get_widget("FlexRSS_Filter_History_Range").show()
		elif filter['type'] == self.config.constants['TV Show (dated)']:
			import time

			cal_from, cal_thru = self.history_calendarbuttons
			today = time.localtime()

			if filter['history'].has_key(filter['type']) and filter['history'][filter['type']].has_key('from'):
				self.glade.get_widget('FlexRSS_History_TVShow_Dated_From_Enabled').set_active(True)
				cal_from.set_sensitive(True)
				cal_from.set_date(filter['history'][filter['type']]['from']['year'],
								  filter['history'][filter['type']]['from']['month'],
								  filter['history'][filter['type']]['from']['day'])
			else:
				self.glade.get_widget('FlexRSS_History_TVShow_Dated_From_Enabled').set_active(False)
				cal_from.set_sensitive(False)
				cal_from.set_date(today[0], today[1], today[2])

			if filter['history'].has_key(filter['type']) and filter['history'][filter['type']].has_key('thru'):
				self.glade.get_widget('FlexRSS_History_TVShow_Dated_Thru_Enabled').set_active(True)
				cal_thru.set_sensitive(True)
				cal_thru.set_date(filter['history'][filter['type']]['thru']['year'],
								  filter['history'][filter['type']]['thru']['month'],
								  filter['history'][filter['type']]['thru']['day'])
			else:
				self.glade.get_widget('FlexRSS_History_TVShow_Dated_Thru_Enabled').set_active(False)
				cal_thru.set_sensitive(False)
				cal_thru.set_date(today[0], today[1], today[2])

			self.glade.get_widget("FlexRSS_History_TVShow").hide()
			self.glade.get_widget("FlexRSS_History_TVShow_Dated").show()
			self.glade.get_widget("FlexRSS_Filter_History_Range").show()
		else:
			self.glade.get_widget("FlexRSS_History_TVShow").hide()
			self.glade.get_widget("FlexRSS_History_TVShow_Dated").hide()
			self.glade.get_widget("FlexRSS_Filter_History_Range").hide()

		self.glade.get_widget('FlexRSS_Filter_Download_QueueTop').set_active(filter.get('queue_top', False))
		self.glade.get_widget('FlexRSS_Filter_Download_Pause').set_active(filter.get('pause', False))
		self.glade.get_widget('FlexRSS_Filter_Download_Delete').set_active(filter.get('delete', False))

		self.configure_cb_test_filter(None)

		if filter['path'] != None:
			self.glade.get_widget('FlexRSS_Filter_Output_Location').set_current_folder(filter['path'])
			self.glade.get_widget('FlexRSS_Filter_Output_Type_Custom').set_active(True)
		else:
			self.glade.get_widget('FlexRSS_Filter_Output_Type_Default').set_active(True)

		replace = filter.get('replace', {'pattern': '', 'with': ''})
		self.glade.get_widget('FlexRSS_Filter_Rewrite_Pattern').set_text(replace['pattern'])
		self.glade.get_widget('FlexRSS_Filter_Rewrite_Replacement').set_text(replace['with'])

	def configure_cb_filter_history_toggle(self, box):
		name = box.get_name()
		active = box.get_active()

		if name == 'FlexRSS_History_TVShow_From_Enabled':
			self.glade.get_widget('FlexRSS_History_TVShow_From_Season').set_sensitive(active)
			self.glade.get_widget('FlexRSS_History_TVShow_From_Episode').set_sensitive(active)
		elif name == 'FlexRSS_History_TVShow_Thru_Enabled':
			self.glade.get_widget('FlexRSS_History_TVShow_Thru_Season').set_sensitive(active)
			self.glade.get_widget('FlexRSS_History_TVShow_Thru_Episode').set_sensitive(active)
		elif name == 'FlexRSS_History_TVShow_Dated_From_Enabled':
			self.history_calendarbuttons[0].set_sensitive(active)
		elif name == 'FlexRSS_History_TVShow_Dated_Thru_Enabled':
			self.history_calendarbuttons[1].set_sensitive(active)

		self.configure_cb_test_filter(None)

	def configure_ui_get_text_as_int(self, widget_name, default=0):
		try:
			return int(self.glade.get_widget(widget_name).get_text())
		except:
			return default

	def configure_ui_get_history_restriction(self):
		h_from = None
		h_thru = None

		type = self.glade.get_widget('FlexRSS_Filters_Type').get_active()
		if type == 1:
			type_s = self.config.constants['TV Show']
		elif type == 2:
			type_s = self.config.constants['TV Show (dated)']
		else:
			type_s = self.config.constants['Generic']

		if type_s == self.config.constants['TV Show']:
			if self.glade.get_widget('FlexRSS_History_TVShow_From_Enabled').get_active():
				from_season = self.configure_ui_get_text_as_int('FlexRSS_History_TVShow_From_Season')
				from_episode = self.configure_ui_get_text_as_int('FlexRSS_History_TVShow_From_Episode')
				h_from = {'season': from_season, 'episode': from_episode}
		elif type_s == self.config.constants['TV Show (dated)']:
			if self.glade.get_widget('FlexRSS_History_TVShow_Dated_From_Enabled').get_active():
				from_y, from_m, from_d = self.history_calendarbuttons[0].get_date()
				h_from = {'year': from_y, 'month': from_m, 'day': from_d}

		if type_s == self.config.constants['TV Show']:
			if self.glade.get_widget('FlexRSS_History_TVShow_Thru_Enabled').get_active():
				thru_season = self.configure_ui_get_text_as_int('FlexRSS_History_TVShow_Thru_Season')
				thru_episode = self.configure_ui_get_text_as_int('FlexRSS_History_TVShow_Thru_Episode')
				h_thru = {'season': thru_season, 'episode': thru_episode}
		elif type_s == self.config.constants['TV Show (dated)']:
			if self.glade.get_widget('FlexRSS_History_TVShow_Dated_Thru_Enabled').get_active():
				thru_y, thru_m, thru_d = self.history_calendarbuttons[1].get_date()
				h_thru = {'year': thru_y, 'month': thru_m, 'day': thru_d}

		return (h_from, h_thru)

	def configure_cb_filter_save(self, arg):
		# Which feed is selected?
		selection = self.glade.get_widget("FlexRSS_Filters_List").get_selection()
		model, iter = selection.get_selected()

		if not iter:
			return

		id = model.get_value(iter, 0)
		name = self.glade.get_widget('FlexRSS_Filters_Name').get_text()
		self.config.setFilter(id, 'name', name)
		iter = model.get_iter_first()
		while iter:
			if model.get_value(iter, 0) == id:
				model.set_value(iter, 1, name)
			iter = model.iter_next(iter)

		type = self.glade.get_widget('FlexRSS_Filters_Type').get_active()
		if type == 1:
			type_s = self.config.constants['TV Show']
		elif type == 2:
			type_s = self.config.constants['TV Show (dated)']
		else:
			type_s = self.config.constants['Generic']
		self.config.setFilter(id, 'type', type_s)

		model, paths = self.glade.get_widget('FlexRSS_Filters_Feed').get_selection().get_selected_rows()
		feeds = []
		for path in paths:
			feeds.append(model.get_value(model.get_iter(path), 0))
		if len(feeds) == 0:
			feeds.append(0)
		self.config.setFilter(id, 'feeds', feeds)

		patterns = []
		filter_patterns = self.glade.get_widget('FlexRSS_Filter_Patterns_List')
		for i in filter_patterns.get_children():
			data = i.get_children()
			pattern = data[0].get_text()
			if data[2].get_active() == 1:
				type = 'Link'
			else:
				type = 'Title'
			patterns.append((pattern, type))
		self.config.setFilter(id, 'patterns', patterns)

		if self.glade.get_widget('FlexRSS_Filter_Output_Type_Custom').get_active():
			path = self.glade.get_widget('FlexRSS_Filter_Output_Location').get_current_folder()
		else:
			path = None

		self.config.setFilter(id, 'path', path)

		self.config.setFilter(id, 'queue_top', self.glade.get_widget('FlexRSS_Filter_Download_QueueTop').get_active())
		self.config.setFilter(id, 'pause', self.glade.get_widget('FlexRSS_Filter_Download_Pause').get_active())
		self.config.setFilter(id, 'delete', self.glade.get_widget('FlexRSS_Filter_Download_Delete').get_active())

		filter = self.config.getFilter(id)

		h_from, h_thru = self.configure_ui_get_history_restriction()
		if filter['type'] != self.config.constants['Generic']:
			if not filter['history'].has_key(filter['type']):
				filter['history'][filter['type']] = {}

			if h_from != None:
				filter['history'][filter['type']]['from'] = h_from
			else:
				if filter['history'][filter['type']].has_key('from'):
					del filter['history'][filter['type']]['from']

				if h_thru != None:
					filter['history'][filter['type']]['thru'] = h_thru
				else:
					if filter['history'][filter['type']].has_key('thru'):
						del filter['history'][filter['type']]['thru']

		filter['replace'] = { 'pattern': self.glade.get_widget('FlexRSS_Filter_Rewrite_Pattern').get_text(),
							  'with'   : self.glade.get_widget('FlexRSS_Filter_Rewrite_Replacement').get_text() }

		self.write_config()

	def configure_cb_remove_pattern(self, arg):
		arg.get_parent().destroy()

	def configure_ui_add_pattern(self, pattern):
		import gtk, gobject

		filter_patterns = self.glade.get_widget('FlexRSS_Filter_Patterns_List')

		hbox = gtk.HBox()
		filter_patterns.pack_start(hbox)

		input = gtk.Entry()
		input.set_text(pattern[0])
		input.connect("changed", self.configure_cb_test_filter)

		on = gtk.Label()
		on.set_text('On')
		on.show()

		combo = gtk.combo_box_new_text()
		combo.append_text('Title')
		combo.append_text('Link')
		if pattern[1] == 'Link':
			combo.set_active(1)
		else:
			combo.set_active(0)

		remove = gtk.Button(stock=gtk.STOCK_REMOVE)
		remove.connect("pressed", self.configure_cb_remove_pattern)

		hbox.pack_start(input)
		hbox.pack_start(on, expand=False)
		hbox.pack_start(combo, expand=False)
		hbox.pack_start(remove, expand=False)

		hbox.show_all()

	def configure_cb_add_pattern(self, args):
		self.configure_ui_add_pattern(('', 'Title'))

	def configure_ui_add_filter(self, filter, test_pattern=None):
		if not filter:
			print 'No filter to add'
			return None

		self.configure_ui_reset_filter()

		model = self.glade.get_widget("FlexRSS_Filters_List").get_model()
		iter = model.append((filter['id'], filter['name'], filter['enabled']))

		if not iter:
			return

		view = self.glade.get_widget("FlexRSS_Filters_List")
		model = view.get_model()
		view.get_selection().select_iter(iter)

		if test_pattern:
			self.glade.get_widget('FlexRSS_Filters_Test_Pattern').set_text(test_pattern)
			self.configure_cb_test_filter(None)

		self.glade.get_widget('FlexRSS_MainNotebook').set_current_page(1)

	def configure_ui_test_result(self, result, h_match=False):
		if result and h_match:
			self.glade.get_widget('FlexRSS_Filters_Test_Result').set_text('Match')
		else:
			self.glade.get_widget('FlexRSS_Filters_Test_Result').set_text('Doesn\'t match')

		type = self.glade.get_widget('FlexRSS_Filters_Type').get_active()

		if type == 0: # Generic
			self.glade.get_widget('FlexRSS_Filters_Test_Results_TVShow').hide()
			self.glade.get_widget('FlexRSS_Filters_Test_Results_TVShow_Dated').hide()
			self.glade.get_widget('FlexRSS_History_TVShow').hide()
			self.glade.get_widget('FlexRSS_History_TVShow_Dated').hide()
		elif type == 1: # TV Show
			self.glade.get_widget('FlexRSS_Filters_Test_Results_TVShow').show()
			self.glade.get_widget('FlexRSS_Filters_Test_Results_TVShow_Dated').hide()
			self.glade.get_widget('FlexRSS_History_TVShow').show()
			self.glade.get_widget('FlexRSS_History_TVShow_Dated').hide()
			if result:
				self.glade.get_widget('FlexRSS_Filters_Test_Results_TVShow_Series').set_text(str(result['series']))
				self.glade.get_widget('FlexRSS_Filters_Test_Results_TVShow_Episode').set_text(str(result['episode']))
			else:
				self.glade.get_widget('FlexRSS_Filters_Test_Results_TVShow_Series').set_text('0')
				self.glade.get_widget('FlexRSS_Filters_Test_Results_TVShow_Episode').set_text('0')
		else: # TV Show (dated)
			self.glade.get_widget('FlexRSS_Filters_Test_Results_TVShow').hide()
			self.glade.get_widget('FlexRSS_Filters_Test_Results_TVShow_Dated').show()
			self.glade.get_widget('FlexRSS_History_TVShow').hide()
			self.glade.get_widget('FlexRSS_History_TVShow_Dated').show()
			if result:
				self.glade.get_widget('FlexRSS_Filters_Test_Results_TVShow_Dated_Year').set_text(str(result['year']))
				self.glade.get_widget('FlexRSS_Filters_Test_Results_TVShow_Dated_Month').set_text(str(result['month']))
				self.glade.get_widget('FlexRSS_Filters_Test_Results_TVShow_Dated_Day').set_text(str(result['day']))
			else:
				self.glade.get_widget('FlexRSS_Filters_Test_Results_TVShow_Dated_Year').set_text('0')
				self.glade.get_widget('FlexRSS_Filters_Test_Results_TVShow_Dated_Month').set_text('0')
				self.glade.get_widget('FlexRSS_Filters_Test_Results_TVShow_Dated_Day').set_text('0')

	def configure_cb_test_filter(self, source=None, date=None):
		subject = self.glade.get_widget('FlexRSS_Filters_Test_Pattern').get_text()

		type = self.glade.get_widget('FlexRSS_Filters_Type').get_active()
		if type == 1:
			type_s = self.config.constants['TV Show']
		elif type == 2:
			type_s = self.config.constants['TV Show (dated)']
		else:
			type_s = self.config.constants['Generic']

		filter_patterns = self.glade.get_widget('FlexRSS_Filter_Patterns_List')
		for i in filter_patterns.get_children():
			data = i.get_children()
			pattern = data[0].get_text()
			result = self.test_pattern(type_s, subject, pattern)
			if result:
				# Pattern matched, let's try history restriction.
				h_from, h_thru = self.configure_ui_get_history_restriction()
				h_match = self.test_range(type_s, result, h_from, h_thru)
				self.configure_ui_test_result(result, h_match)
				return

		self.configure_ui_test_result(False)		

	def configure_cb_delete_filter(self, arg):
		# Which filter is selected?
		selection = self.glade.get_widget("FlexRSS_Filters_List").get_selection()
		model, iter = selection.get_selected()

		if not iter:
			return

		id = model.get_value(iter, 0)

		# Remove from config
		if not self.config.deleteFilter(id):
			print 'Unable to delete filter #' + str(id)
			return
		self.write_config()

		# Remove from UI
		model.remove(iter)

		self.configure_ui_reset_filter()

	def configure_cb_feed_refresh(self, caller, id=None):
		if not id:
			selection = self.glade.get_widget("FlexRSS_Feeds").get_selection()
			model, iter = selection.get_selected()

			if not iter:
				return

			id = model.get_value(iter, 0)

		if id:
			if ( self.config.threaded_retrieval ):
				import threading
				threading.Thread(target=self.parse_feed, args=(id,)).start()
			else:
				self.parse_feed(id)

	def configure_cb_download_torrent(self, caller, url):
		self.download_torrent(url)

	def configure_cb_feed_popup(self, view, event):
		if event.button != 3:
			return

		model = view.get_model()
		coords = event.get_coords()
		path = view.get_path_at_pos(int(coords[0]), int(coords[1]))
		if path:
			iter = model.get_iter(path[0])
		else:
			iter = None

		import gtk

		popup = gtk.Menu()

		if iter:
			id = model.get_value(iter, 0)
			if id: # Feed
				item_refresh = gtk.MenuItem(_("Refresh feed"))
				item_refresh.connect("activate", self.configure_cb_feed_refresh, id)
				popup.append(item_refresh)

				item_delete = gtk.MenuItem(_("Delete feed"))
				item_delete.connect("activate", self.configure_cb_feed_delete, id)
				popup.append(item_delete)

			else: # Filter
				item_filter = gtk.MenuItem(_("Create filter"))
				item_filter.connect("activate", self.configure_cb_filter_new, model.get_value(iter, 1))
				popup.append(item_filter)

				item_download = gtk.MenuItem(_("Download torrent"))
				item_download.connect("activate", self.configure_cb_download_torrent, model.get_value(iter, 2))
				popup.append(item_download)

		else: # Neither
			item_new = gtk.MenuItem("New feed")
			item_new.connect("activate", self.configure_cb_feed_new)
			popup.append(item_new)

		popup.popup(None, None, None, event.button, event.time)
		popup.show_all()

	def configure_cb_output_set(self, chooser):
		self.glade.get_widget('FlexRSS_Filter_Output_Type_Custom').set_active(True)

	def configure_ui_reset_filter(self):
		# Just resets the crap in the filter tab to defaults.
		self.glade.get_widget('FlexRSS_Filters_Name').set_text('')
		self.glade.get_widget('FlexRSS_Filters_Type').set_active(0)
		self.glade.get_widget('FlexRSS_Filters_Feed').get_selection().unselect_all()
		for filter in self.glade.get_widget('FlexRSS_Filter_Patterns_List').get_children():
			filter.destroy()
		self.glade.get_widget('FlexRSS_Filters_Test_Results_TVShow').hide()
		self.glade.get_widget('FlexRSS_Filters_Test_Results_TVShow_Dated').hide()
		file_chooser = self.glade.get_widget('FlexRSS_Filter_Output_Location')
		file_chooser.set_current_folder(self.interface.config.get('default_download_path'))
		self.glade.get_widget('FlexRSS_Filter_Output_Type_Default').set_active(True)

	def strcasecmp(self, s1, s2):
		try:
			t1 = s1.lower()
			t2 = s2.lower()

			if s1 < s2:
				return -1
			elif s1 > s2:
				return 1
		except:
			pass

		return 0

	def configure_ui_sort_cmp(self, model, iter1, iter2, user_data=None):
		if (model.get_value(iter1, 0) == 0) or (model.get_value(iter2, 0) == 0):
			return 0

		return self.strcasecmp(model.get_value(iter1, 1), model.get_value(iter2, 1))

	def configure_cb_filter_toggled(self, renderer, path):
		old_val = renderer.get_active()
		model = self.glade.get_widget('FlexRSS_Filters_List').get_model()
		iter = model.get_iter(path)
		if old_val:
			model.set_value(iter, 2, False)
			self.config.setFilter(model.get_value(iter, 0), 'enabled', False)
		else:
			model.set_value(iter, 2, True)
			self.config.setFilter(model.get_value(iter, 0), 'enabled', True)
		self.write_config()

	def configure_cb_cookie_new(self, src):
		self.configure_ui_cookie_reset()
		self.glade.get_widget("FlexRSS_Cookies_Editor").show()

	def configure_cb_cookie_save(self, src):
		import cookielib, time

		domain = self.glade.get_widget("FlexRSS_Cookie_Domain").get_text()
		path = self.glade.get_widget("FlexRSS_Cookie_Path").get_text()
		name = self.glade.get_widget("FlexRSS_Cookie_Name").get_text()
		value = self.glade.get_widget("FlexRSS_Cookie_Value").get_text()

		if (domain == ""):
			return

		if path == '':
			path = '/'

		# Fragile.
		self.cookies._policy._now = self.cookies._now = int(time.time())
		cookie = self.cookies._cookie_from_cookie_tuple((name, value, {"domain": domain, "path":path, "expires":2147483647}, {}), None)

		self.cookies.set_cookie(cookie)
		self.configure_ui_add_cookie(None, cookie)
		self.configure_ui_cookie_reset()
		self.glade.get_widget("FlexRSS_Cookies_Editor").hide()
		self.write_config(True)

	def configure_ui_add_cookie(self, model, cookie):
		if cookie.domain[0] == '.':
			domain = cookie.domain[1:]
		else:
			domain = cookie.domain

		if model == None:
			model = self.glade.get_widget("FlexRSS_Cookies_List").get_model()

		parent = None
		iter = model.get_iter_first()
		while iter:
			t = model.get_value(iter, 0)
			if t == domain:
				parent = iter
				break
			iter = model.iter_next(iter)

		if parent == None:
			parent = model.append(iter, (domain, "", "", ""))
		model.append(parent, (cookie.domain, cookie.path, cookie.name, cookie.value))

	def configure_ui_cookie_reset(self):
		self.glade.get_widget("FlexRSS_Cookie_Domain").set_text('')
		self.glade.get_widget("FlexRSS_Cookie_Path").set_text('/')
		self.glade.get_widget("FlexRSS_Cookie_Name").set_text('')
		self.glade.get_widget("FlexRSS_Cookie_Value").set_text('')

	def configure_cb_cookie_selected(self, selection):
		model, iter = selection.get_selected()

		self.configure_ui_cookie_reset()
		self.glade.get_widget("FlexRSS_Cookies_Editor").hide()

	def configure_cb_cookie_delete(self, src):
		selection = self.glade.get_widget("FlexRSS_Cookies_List").get_selection()
		model, iter = selection.get_selected()

		domain = None
		path = None
		name = None

		if not model.iter_has_child(iter):
			path = model.get_value(iter, 1)
			name = model.get_value(iter, 2)
		domain = model.get_value(iter, 0)

		try:
			self.cookies.clear("." + domain, path, name)
		except:
			pass
		try:
			self.cookies.clear(domain, path, name)
		except:
			pass

		# UI
		if model.iter_has_child(iter):
			i = model.iter_children(iter)
			while model.remove(i):
				pass
			model.remove(iter)
		else:
			p = model.iter_parent(iter)
			model.remove(iter)
			if not model.iter_has_child(p):
				model.remove(p)

		self.write_config(True)

	def configure_cb_toolbar_clicked(self, button):
		self.configure()

	def configure_ui_show_toolbar_button(self):
		if self.toolbar_button == None:
			import gtk

			icon = gtk.Image()
			icon.set_from_file(self.path + "/FlexRSS.png")
			self.toolbar_button = gtk.ToolButton(icon_widget=icon, label="FlexRSS")
			self.toolbar_button.connect("clicked", self.configure_cb_toolbar_clicked)
			self.interface.toolbar.add(self.toolbar_button)
			self.toolbar_button.show_all()

	def configure_cb_toolbar_toggled(self, box):
		if box.get_active():
			self.configure_ui_show_toolbar_button()
			self.config.show_toolbar_button = True
			self.write_config()
		else:
			self.toolbar_button.destroy()
			self.toolbar_button = None
			self.config.show_toolbar_button = False
			self.write_config()

	def configure_cb_threaded_toggled(self, box):
		self.config.threaded_retrieval = box.get_active()
		self.write_config()

	def configure(self, widget=None):
		if self.glade: # Dialog already running
			return

		import gtk, gtk.glade, gobject

		self.glade = gtk.glade.XML(self.path + "/FlexRSS.glade")

		# Intialize feed lists
		feeds_model = gtk.TreeStore(gobject.TYPE_INT, gobject.TYPE_STRING, gobject.TYPE_STRING)
		feeds_view = self.glade.get_widget("FlexRSS_Feeds")
		filters_feeds_view = self.glade.get_widget("FlexRSS_Filters_Feed")
		feeds_view.set_model(feeds_model)
		filters_feeds_view.set_model(feeds_model)
		feeds_model.set_sort_func(1, self.configure_ui_sort_cmp)
		feeds_model.set_sort_column_id(1, gtk.SORT_ASCENDING)

		# Setup columns for feeds tab
		renderer_name = gtk.CellRendererText()
		column_name = gtk.TreeViewColumn(_("Feed Name"), renderer_name, text=1)
		feeds_view.append_column(column_name)
		renderer_url = gtk.CellRendererText()
		column_url = gtk.TreeViewColumn(_("URL"), renderer_url, text=2)
		feeds_view.append_column(column_url)
		feeds_view.set_search_column(1)
		feeds_view.set_search_equal_func(gtk_treeview_search_cb_stristr)

		# Set callback for when selection is changed in feeds tab
		# I can't figure out how to do this in Glade
		feeds_view.get_selection().connect("changed", self.configure_cb_feed_selected)

		# Setup columns for feed list on filters tab
		renderer_name = gtk.CellRendererText()
		column_name = gtk.TreeViewColumn(_("Feed Name"), renderer_name, text=1)
		filters_feeds_view.append_column(column_name)

		# Allow multiple selections of feeds in filters tab
		# I can't figure out how to do this in Glade
		filters_feeds_view.get_selection().set_mode(gtk.SELECTION_MULTIPLE)

		# Populate feed lists
		if self.config.feeds:
			for feed in self.config.feeds:
				this_feed = feeds_model.append(None, (feed['id'], feed['name'], feed['url']))
				for item in self.feeds[feed['id']]['data']:
					feeds_model.append(this_feed, (0, item['title'], item['link']))
					

		# Initialize filters list
		filters_model = gtk.ListStore(gobject.TYPE_INT, gobject.TYPE_STRING, gobject.TYPE_BOOLEAN)
		filters_view = self.glade.get_widget("FlexRSS_Filters_List")
		filters_view.set_model(filters_model)
		feeds_model.set_sort_func(1, self.configure_ui_sort_cmp)
		filters_model.set_sort_column_id(1, gtk.SORT_ASCENDING)

		# Setup columns for filters list
		renderer_enabled = gtk.CellRendererToggle()
		column_enabled = gtk.TreeViewColumn(_("Enabled"), renderer_enabled, active=2)
		filters_view.append_column(column_enabled)
		renderer_enabled.connect('toggled', self.configure_cb_filter_toggled)
		renderer_name = gtk.CellRendererText()
		column_name = gtk.TreeViewColumn(_("Filter Name"), renderer_name, text=1)
		filters_view.append_column(column_name)

		# Set callback for when selection is changed in feeds tab
		# I can't figure out how to do this in Glade
		filters_view.get_selection().connect("changed", self.configure_cb_filter_selected)

		# Populate filters list
		if self.config.filters:
			for filter in self.config.filters:
				filters_model.append((filter['id'], filter['name'], filter['enabled']))

		# Filter types
		filter_types = self.glade.get_widget('FlexRSS_Filters_Type')
		filter_types.append_text(_("Generic"))
		filter_types.append_text(_("TV Show"))
		filter_types.append_text(_("TV Show (dated)"))

		# Calendar buttons for dated tv show history restrictions
		from CalendarButton import CalendarButton
		dated_from = CalendarButton()
		dated_from.connect('date-selected', self.configure_cb_test_filter)
		dated_to = CalendarButton()
		dated_to.connect('date-selected', self.configure_cb_test_filter)
		dated_from.show()
		dated_to.show()
		history_table = self.glade.get_widget('FlexRSS_History_TVShow_Dated')
		history_table.attach(dated_from, 1, 2, 0, 1, gtk.EXPAND|gtk.FILL, gtk.FILL)
		history_table.attach(dated_to, 1, 2, 1, 2, gtk.EXPAND|gtk.FILL, gtk.FILL)
		self.history_calendarbuttons = (dated_from, dated_to)

		# Initialize cookies list
		cookies_model = gtk.TreeStore(gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING)
		cookies_view = self.glade.get_widget("FlexRSS_Cookies_List")
		cookies_view.set_model(cookies_model)
		cookies_view.get_selection().connect("changed", self.configure_cb_cookie_selected)

		# Setup column for cookies
		domain_renderer = gtk.CellRendererText()
		domain_column = gtk.TreeViewColumn(_("Domain"), domain_renderer, text=0)
		path_renderer = gtk.CellRendererText()
		path_column = gtk.TreeViewColumn(_("Path"), path_renderer, text=1)
		name_renderer = gtk.CellRendererText()
		name_column = gtk.TreeViewColumn(_("Name"), name_renderer, text=2)
		value_renderer = gtk.CellRendererText()
		value_column = gtk.TreeViewColumn(_("Value"), value_renderer, text=3)
		cookies_view.append_column(domain_column)
		cookies_view.append_column(path_column)
		cookies_view.append_column(name_column)
		cookies_view.append_column(value_column)

		for cookie in self.cookies:
			self.configure_ui_add_cookie(cookies_model, cookie)

		# Interface
		self.glade.get_widget("FlexRSS_Interface_ShowButton").set_active(self.config.show_toolbar_button)
		self.glade.get_widget("FlexRSS_Retrieval_Threaded").set_active(self.config.threaded_retrieval)

		# Callbacks for UI events
		actions = {
			# Feeds tab
			"on_FlexRSS_MainWindow_destroy"           : self.configure_cb_closed,
			"on_FlexRSS_Feeds_New_pressed"            : self.configure_cb_feed_new,
			"on_FlexRSS_Feeds_Save_pressed"           : self.configure_cb_feed_save,
			"on_FlexRSS_Feeds_Delete_pressed"         : self.configure_cb_feed_delete,
			"on_FlexRSS_Feeds_button_press_event"     : self.configure_cb_feed_popup,

			# Filters tab
			"on_FlexRSS_Filters_Add_pressed"          : self.configure_cb_filter_new,
			"on_FlexRSS_Action_Save_pressed"          : self.configure_cb_filter_save,
			"on_FlexRSS_Filter_Patern_Add_pressed"    : self.configure_cb_add_pattern,
			"on_FlexRSS_Filters_Type_changed"         : self.configure_cb_test_filter,
			"on_FlexRSS_Filters_Test_Pattern"         : self.configure_cb_test_filter,
			"on_FlexRSS_Filters_Delete_pressed"       : self.configure_cb_delete_filter,
			"on_FlexRSS_History_TVShow_From_Enabled_toggled" : self.configure_cb_filter_history_toggle,
			"on_FlexRSS_History_TVShow_Thru_Enabled_toggled" : self.configure_cb_filter_history_toggle,
			"on_FlexRSS_History_TVShow_Dated_From_Enabled_toggled" : self.configure_cb_filter_history_toggle,
			"on_FlexRSS_History_TVShow_Dated_Thru_Enabled_toggled" : self.configure_cb_filter_history_toggle,
			"on_FlexRSS_History_TVShow_From_Season_changed" : self.configure_cb_test_filter,
			"on_FlexRSS_History_TVShow_From_Episode_changed" : self.configure_cb_test_filter,
			"on_FlexRSS_History_TVShow_Thru_Season_changed" : self.configure_cb_test_filter,
			"on_FlexRSS_History_TVShow_Thru_Episode_changed" : self.configure_cb_test_filter,

			# Configuration tab
			"on_FlexRSS_Cookie_New_pressed"           : self.configure_cb_cookie_new,
			"on_FlexRSS_Cookie_Save_pressed"          : self.configure_cb_cookie_save,
			"on_FlexRSS_Cookie_Delete_pressed"        : self.configure_cb_cookie_delete,
			"on_FlexRSS_Interface_ShowButton_toggled" : self.configure_cb_toolbar_toggled,
			"on_FlexRSS_Retrieval_Threaded_toggled"   : self.configure_cb_threaded_toggled }
		if hasattr(self.interface, 'interactive_add_torrent_path'):
			actions["on_FlexRSS_Filter_Output_Location_current_folder_changed"] = self.configure_cb_output_set
		else:
			self.glade.get_widget('FlexRSS_Filter_Output').hide()
		self.glade.signal_autoconnect(actions)

		self.glade.get_widget("FlexRSS_MainWindow").show()

	def cmp_history(a, b):
		try:
			if a.has_key('series'):
				if a['series'] > b['series']:
					return 1
				elif a['series'] < b['series']:
					return -1
				else:
					if a['episode'] > b['episode']:
						return 1
					elif a['episode'] < b['episode']:
						return -1
					else:
						return 0
		except:
			return 0

	def strptime2regex(self, input):
		# Does'n exactly live up to its name yet. Currently just
		# replaces %y,%Y,%m,%d with named patterns. In the future, it
		# would be nice to allow escaping (e.g., %%Y means literal %Y)
		# and expand it to support other formats.
		patterns = [('%Y', '(?P<Y>[0-9]{4})'),
					('%y', '(?P<y>[0-9]{2})'),
					('%m', '(?P<m>[0-9]{1,2})'),
					('%d', '(?P<d>[0-9]{1,2})')]

		out = input
		for p in patterns:
			out = out.replace(p[0], p[1])

		return out

	def replace_tv_show_patterns(self, input):
		patterns = [('%s', '(?P<s>[0-9]+)'),
					('%e', '(?P<e>[0-9]+)')]

		out = input
		for p in patterns:
			out = out.replace(p[0], p[1])

		return out

	def test_range(self, type, data, h_from=None, h_thru=None):
		if type == self.config.constants['TV Show']:
			if h_from != None:
				if data['series'] < h_from['season']:
					return False
				elif data['series'] == h_from['season']:
					if data['episode'] < h_from['episode']:
						return False

			if h_thru != None:
				if data['series'] > h_thru['season']:
					return False
				elif data['series'] == h_thru['season']:
					if data['episode'] > h_thru['episode']:
						return False

			return True

		elif type == self.config.constants['TV Show (dated)']:
			if h_from != None:
				if data['year'] < h_from['year']:
					return False
				elif data['year'] == h_from['year']:
					if data['month'] < h_from['month']:
						return False
					elif data['month'] == h_from['month']:
						if data['day'] < h_from['day']:
							return False

			if h_thru != None:
				if data['year'] < h_thru['year']:
					return False
				elif data['year'] == h_thru['year']:
					if data['month'] < h_thru['month']:
						return False
					elif data['month'] == h_thru['month']:
						if data['day'] < h_thru['day']:
							return False

			return True

		else:
			return True

	def test_pattern(self, type, subject, pattern):
		import re, time
		result = False

		if len(pattern) < 1:
			return False

		if type == self.config.constants['TV Show (dated)']:
			pattern = self.strptime2regex(pattern)
		elif type == self.config.constants['TV Show']:
			pattern = self.replace_tv_show_patterns(pattern)

		# Wow, so this is lame...
		if pattern[0] != '^':
			pattern = '.*' + pattern

		try:
			exp = re.compile(pattern, re.IGNORECASE)
		except:
			print 'Broken expression: ' + pattern
			return False

		match = exp.match(subject)
		if match:
# 			print 'Match: ' + subject
# 			print '       ' + pattern
			if type == self.config.constants['TV Show']:
				try:
					series = int(match.group('s'))
				except:
					series = 0

				try:
					episode = int(match.group('e'))
				except:
					episode = 0

				result = { 'series'  : series,
						   'episode' : episode }

			elif type == self.config.constants['TV Show (dated)']:
				try:
					year = int(match.group('Y'))
				except:
					try:
						year = int(match.group('y'))
						if year > 70:
							year += 1900
						else:
							year += 2000
					except:
						year = 0

				try:
					month = int(match.group('m'))
				except:
					month = 0

				try:
					day = int(match.group('d'))
				except:
					day = 0

				result = { 'year'  : year,
						   'month' : month,
						   'day'   : day }

			else:
				result = True

		return result

	def make_opener(self):
		import urllib2

		return urllib2.build_opener(urllib2.HTTPCookieProcessor(self.cookies))

	def make_request(self, location, referer=None):
		import urllib2, deluge.common

		req = urllib2.Request(location)
		req.add_header("User-Agent", "FlexRSS/%d.%d.%d (%s/%s)" % (self.version[0], self.version[1], self.version[2], deluge.common.PROGRAM_NAME, deluge.common.PROGRAM_VERSION))
		if referer != None:
			req.add_header('Referer', referer)

		return req

	def open_url(self, location):
		return self.make_opener().open(self.make_request(location))

	def download_torrent(self, location, path=None, queue_top=False, pause=False, referer=None):
		import tempfile, os, deluge.core

		try:
			fd = self.open_url(location)
		except:
			return False

		inf = fd.info()
		if inf["content-type"] != "application/x-bittorrent":
			print "Warning: torrent content-type not application/x-bittorrent"

		(tmpfd, filename) = tempfile.mkstemp(".torrent", "flexrss-")
		tfd = os.fdopen(tmpfd, 'wb')
		tfd.write(fd.read())
		fd.close()
		tfd.close()

		unique_id = False

		try:
			if path is None:
				path = self.interface.config.get('default_download_path')
			unique_id = self.interface.manager.add_torrent(filename, path, self.interface.config.get('use_compact_storage'))
			self.interface.torrent_model_append(unique_id)

			if queue_top == True:
				try:
					self.interface.manager.queue_top(unique_id)
				except:
					pass
			if pause == True:
				try:
					self.interface.manager.set_user_pause(unique_id, True)
				except:
					pass
		except deluge.core.DuplicateTorrentError, e:
			print 'FlexRSS: torrent already exists.'
			return True
		except:
			print '*** FlexRSS error: unable to add torrent.'
			return False

		return True

	def parse_feed(self, id):
		import time, feedparser, urllib2, cookielib

		feed = self.config.getFeed(id)

		#print 'Parsing feed: ' + feed['url']
 		try:
			parsed = feedparser.parse(self.open_url(feed['url']))
			if (not parsed) or (not parsed.entries):
				print 'Unable to parse feed: ' + feed['url']
				return
		except:
			print 'Unable to update feed: ' + feed['url']
			return
		#print 'Retrieval successful: ' + feed['url']

		data = []

		for entry in parsed.entries:
			entryTitle = entry['title']

			try:
				entryLink = entry.links[0]['href']
			except:
				try:
					entryLink = entry.enclosures[0]['href']
				except:
					print "Skipping %s\n" % entryTitle
					continue

			try:
				data.append({ 'title': entryTitle, 'link': entryLink })
			except:
				continue

			if self.config.filters:
				for filter in self.config.filters:
					try:
						if not ((feed['id'] in filter['feeds']) or (0 in filter['feeds'])):
							continue
					except TypeError:
						filter['feeds'] = [0]

					if filter['enabled'] != True:
						continue

					for pattern in filter['patterns']:
						# (setq python-indent 4
						#       tab-width 4)
						# Okay, I dislike python substantially less now.
						# Edit (~a month later): I still dislike it a lot, though.
						try:
							if pattern[1] == 'Title':
								subject = entryTitle
							else:
								subject = entryLink
						except:
							print 'Unable to find subject.'

						match = self.test_pattern(filter['type'], subject, pattern[0])
						if match:
							# Filter matched. Check history to see if
							# we should download it.
							if filter['type'] == self.config.constants['Generic']: # Dirty hack.
								match = { 'url' : entryLink }

							torrent_url = entryLink
							replace = filter.get('replace', {'pattern': '', 'with': ''})
							if len(replace['pattern']) > 0:
								try:
									import re

									p = re.compile(replace['pattern'], re.IGNORECASE)
									torrent_url = p.sub(replace['with'], torrent_url)
								except:
									print '*** FlexRSS error: s/%s/%s/i failed.' % (replace['pattern'], replace['with'])
									return

							if not self.config.checkHistory(filter['id'], filter['type'], match):
								print filter
								if filter.has_key('history'):
									res = False

									if filter['type'] == self.config.constants['Generic']:
										if filter['history'].get(filter['type'], []).count(torrent_url) == 0:
											res = self.download_torrent(torrent_url, filter.get('path', None), filter['queue_top'], filter['pause'], feed['url'])
									else:
										h_from = filter['history'][filter['type']].get('from', None)
										h_thru = filter['history'][filter['type']].get('thru', None)
										if self.test_range(filter['type'], match, h_from, h_thru):
											res = self.download_torrent(torrent_url, filter.get('path', None), filter['queue_top'], filter['pause'], feed['url'])

									print res
									if res == True:
										if filter['delete'] == True:
											self.config.deleteFilter(filter['id'])
											self.write_config()

											model = self.glade.get_widget("FlexRSS_Filters_List").get_model()
											iter = model.get_iter_first();
											while iter != None:
												if model.get_value(iter, 0) == filter['id']:
													model.remove(iter)
													break
												iter = model.iter_next(iter)
										else:
											self.config.addHistory(filter['id'], filter['type'], match)
										self.write_config()

			self.feeds[feed['id']]['data'] = data
			if self.glade: # Update config window...
				feeds_model = self.glade.get_widget("FlexRSS_Feeds").get_model()
				iter = feeds_model.get_iter_first()
				while iter != None:
					if id == feeds_model.get_value(iter, 0):
						break
					iter = feeds_model.iter_next(iter)

				i = feeds_model.iter_children(iter)
				if i != None:
					while feeds_model.remove(i):
						pass

				for item in data:
					feeds_model.append(iter, (0, item['title'], item['link']))

	def update(self):
		import time, threading

		current_time = time.time()

		# I feel dirty for this. Oh, how I miss C.
		for id in self.feeds:
			if self.feeds[id]['cfg']['enabled'] == True:
				if (current_time - self.feeds[id]['cfg']['interval']) > self.feeds[id]['updated']:
					self.feeds[id]['updated'] = current_time
					if ( self.config.threaded_retrieval ):
						threading.Thread(target=self.parse_feed, args=(self.feeds[id]['cfg']['id'],)).start()
					else:
						self.parse_feed(self.feeds[id]['cfg']['id'])
	
	def unload(self):
		if self.toolbar_button:
			self.toolbar_button.destroy()
			self.toolbar_button = None

	def deluge_version_compare(self, version):
		import deluge.common
		va = deluge.common.PROGRAM_VERSION.split('.')
		dv = int(va[0]) * 1000000
		dv = dv + (int(va[1]) * 10000)
		dv = dv + (int(va[2]) * 100)
		if len(va) >= 4:
			dv = dv + int(va[3])

		if dv < version:
			return -1
		elif dv > version:
			return 1
		else:
			return 0

	def __init__(self, path, core, interface, defaults):
		self.path = path
		self.core = core
		self.interface = interface
		self.version = defaults['VERSION']

		self.load_config()

		if self.config.show_toolbar_button == True:
			self.configure_ui_show_toolbar_button()

		self.feeds = {}
		if self.config.feeds:
			for feed in self.config.feeds:
				self.feeds[feed['id']] = { 'cfg'     : feed,
										   'updated' : 0,
										   'data'    : [] }

		# Debugging
		# self.configure()