path: root/totem/plugin/sopcast.py

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

from xml.dom import minidom

from channelguide import ChannelGuide
from sopcast_translation import _

def unescape_charref (ref):
    name = ref[2:-1]
    base = 10
    if name[0] == 'x':
        name = name[1:]
        base = 16
    return unichr (int(name, base))

def replace_entities (match):
    ent = match.group ()
    if ent[1] == "#":
        return unescape_charref (ent)

    repl = htmlentitydefs.name2codepoint.get (ent[1:-1])
    if repl is not None:
        repl = unichr (repl)
    else:
        repl = ent
    return repl

def unescape (data):
    return re.sub (r"&#?[A-Za-z0-9]+?;", replace_entities, data)

def unescape_xml (data):
	ustr = unicode(data, 'utf-8')
	return unescape(ustr).encode ('utf-8')

gconf_key = '/apps/totem/plugins/sctream'
sc_cache_dir = os.path.expanduser ('~/.local/share/totem/plugin/sopcast')
sc_system_playlist = os.path.join (os.path.dirname (__file__), 'channels.pls')
sc_playlist = os.path.join (sc_cache_dir, 'channels.pls')

sc_xmls_dir = os.path.join (sc_cache_dir, "xmls")
sc_images_dir = os.path.join (sc_cache_dir, "images")
for p in [ sc_xmls_dir, sc_images_dir ]:
	if not os.path.exists (p):
		os.makedirs (p)

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 Sopcast (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.channels_terms = ""

		self.entry = {}

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

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

		self.channels = [ 'http://channel.sopcast.com/gchlxml' ]
		self.channels += [ 'http://channel.sopcast.cn/gchlxml' ]
		self.channels += [ 'http://people.freedesktop.org/~jinghua/sopcast/gchlxml' ]
		self.channels_index = 0
                self.source_id = 0
                self.playlist = []

	def update_translation (self, builder):
		for obj in builder.get_objects ():
			try:
				if type(obj) is gtk.Label:
					if obj.get_label ():
						obj.set_markup(_(obj.get_label ()))
				elif hasattr(obj, 'set_label'):
					if obj.get_label ():
						obj.set_label(_(obj.get_label ()))
				elif hasattr(obj, 'set_title'):
					if obj.get_title ():
						obj.set_title(_(obj.get_title ()))
				else:
					if obj.get_text ():
						obj.set_text(_(obj.get_text ()))
			except AttributeError:
				pass

			try:
				text = obj.get_property ('tooltip_text')
				if text:
					obj.set_property('tooltip_text', _(text))
			except TypeError:
				pass

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

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

				registry = gst.registry_get_default ()
				if registry.find_plugin ("sopcast") == None:
					"""This means an error will be displayed when they try to play anything"""
					self.gstreamer_plugins_present = False
				else:
					versions = registry.find_plugin ("sopcast").get_version ().split ('.')
					versions = [ int(v) for v in versions ]
					if len (versions) < 4:
						versions += [0] * (4 - len(versions))
					### 0.0.17.10 or later is ok
					if versions[0] > 0 or versions[1] > 0 or \
					   versions[2] > 17 or versions[3] >= 10:
						self.can_recode_mrl = True
			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 ("sopcast.ui", True, totem_object.get_main_window (), self)
		self.config_builder = self.load_interface ("sopcast-config.ui", True,
							   totem_object.get_main_window (), self)
		self.update_translation (self.builder)
		self.update_translation (self.config_builder)

		self.totem = totem_object

		self.search_entry = self.builder.get_object ("sc_search_entry")
		self.search_entry.connect ("activate", self.on_search_entry_activated)
		self.search_button = self.builder.get_object ("sc_search_button")
		#self.search_button.set_label ('')
		self.search_button.connect ("clicked", self.on_search_button_clicked)
		self.refresh_button = self.builder.get_object ("sc_refresh_button")
		#self.refresh_button.set_label ('')
		self.refresh_button.connect ("clicked", self.on_refresh_button_clicked)
		self.progress_bar = self.builder.get_object ("sc_progress_bar")

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

		self.notebook_pages = ["channels", 'playlist']
		self.current_treeview_name = "channels"
		self.load_config ()
                self.setup_popup_menu ()
		self.setup_channels ()
                self.setup_playlist ()
		self.setup_config_dialog ()

		self.vbox = self.builder.get_object ("sc_vbox")
		self.vbox.show_all ()
		totem_object.add_sidebar_page ("sopcast", _("Sopcast"), self.vbox)

		self.search_terms = ''
		self.classes = []

		self.start_idle_task ()

	def deactivate (self, totem):
		self.clear_ui ()
		self.channels_count +=1
		self.classes = []

		self.stop_idle_task ()

		totem.remove_sidebar_page ("sopcast")

	def is_configurable (self):
		return False

	def create_configure_dialog (self):
		dialog = self.config_builder.get_object ("sc_config_dialog")
		button = self.config_builder.get_object ("sc_config_show_chinese_name")
		button.set_active (self.configs['show_chinese_name'])
		button = self.config_builder.get_object ("sc_config_compatible")
		button.set_active (self.configs['compatible'])
		return dialog

	def start_idle_task (self):
		if self.configs['compatible']:
			self.source_id = gobject.idle_add (self.on_idle)
		else:
			self.source_id = 0

	def stop_idle_task (self):
		if self.source_id:
			gobject.source_remove (self.source_id)
			self.source_id = 0

	def on_idle (self):
		time.sleep (0.001)
		return True

	def on_add_to_channel_list (self, treeview):
		treeview_name = self.current_treeview_name
		treeview = self.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)
                        title = model.get_value (iter, 0)
			mrl = model.get_value (iter, 2)
                        #print title, mrl
                        self.add_to_playlist (title, mrl)

	def on_remove_from_channel_list (self, treeview):
		treeview_name = self.current_treeview_name
                assert treeview_name == 'playlist'

		treeview = self.treeview[treeview_name]
		selection = treeview.get_selection ()
		model = treeview.get_model ()
		model, rows = selection.get_selected_rows ()

                rows.reverse ()
		for row in rows:
                        self.remove_from_playlist (row[0])

	def on_copy_location (self, action):
		treeview_name = self.current_treeview_name
		treeview = self.treeview[treeview_name]
		selection = treeview.get_selection ()
		model = treeview.get_model ()
		model, rows = selection.get_selected_rows ()
		iter = model.get_iter (rows[0])
                if treeview_name == 'channels':
                    mrl = model.get_value (iter, 2)
                else:
                    mrl = model.get_value (iter, 1)

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

	def on_add_channel (self, action):
		treeview_name = self.current_treeview_name
                dialog = self.builder.get_object ('sopcast_add_channel_dialog')
                dialog.run ()

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

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

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

                name = self.builder.get_object ('sopcast_add_channel_name_entry').get_text ().strip ()
                location = self.builder.get_object ('sopcast_add_channel_location_entry').get_text ().strip ()
                if not name or not location:
                    return
                self.add_to_playlist (name, location)

	def setup_popup_menu (self):
                self.ui_manager = self.builder.get_object ('sopcast-ui-manager')
		action_group = self.ui_manager.get_action_groups () [0]
		action = action_group.get_action ("add-to-channel-list")
		action.connect ('activate', self.on_add_to_channel_list)
                action = action_group.get_action ("remove-from-channel-list")
		action.connect ('activate', self.on_remove_from_channel_list)
		action = action_group.get_action ("copy-location")
		action.connect ('activate', self.on_copy_location)
		action = action_group.get_action ("add-channel")
		action.connect ('activate', self.on_add_channel)

                dialog = self.builder.get_object ('sopcast_add_channel_dialog')
		dialog.connect ("response", self.on_add_channel_dialog_response)
		dialog.connect ("close", self.on_add_channel_dialog_close)
		dialog.connect ("delete-event", self.on_add_channel_dialog_delete)

	def on_channels_row_activated (self, treeview, path, view_column, data=None):
		model, rows = treeview.get_selection ().get_selected_rows ()
		row = rows[0]

		iter = model.get_iter (row)
		title = model.get_value (iter, 0)
		num = model.get_value (iter, 1)
		mrl = model.get_value (iter, 2)

		#print row, title, num, mrl
		#channel = self.channel_guide.channels[row[0]][row[1]]
		#print channel

		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 download_channels (self):
		if self.channels_downloading:
			return
		self.channels_index = 0
		self.channels_downloading = True
		self.channels_count += 1
		download = DownloadThread (self.channels[self.channels_index],
					   self.on_channel_xml_downloaded,
					   self.channels_count)
		download.start ()

		gobject.timeout_add (350, self.on_update_progress_bar, self.channels_count)

	def on_update_progress_bar (self, count):
		if self.channels_count != count:
			return False
		if self.channels_downloading:
			self.progress_bar.pulse ()
			self.progress_bar.set_text (_('Downloading channel list...'))
		else:
			self.progress_bar.set_fraction (0.0)
			self.progress_bar.set_text ('')
			return False
		return True

	def download_next_channel (self):
		self.channels_index += 1
		download = DownloadThread (self.channels[self.channels_index],
					   self.on_channel_xml_downloaded,
                                           self.channels_count)
		download.start ()

	def on_channel_xml_downloaded (self, res, count):
		if self.channels_count != count:
			self.channels_downloading = False
			self.load_channels ()
			self.show_channels ()
			return

		if not res:
			if self.channels_index == len (self.channels):
				self.channels_downloading = False
			else:
				self.download_next_channel ()
			return

		filename = os.path.join (sc_cache_dir, 'channels.xml')
		if not os.path.exists (filename):
			old = ''
		else:
			old = file(filename, 'r').read ()
		if res != old:
			file (filename, 'w').write (res)
		self.channels_downloading = False

		self.channel_guide.load (res)
		self.show_channels ()

	def load_channels (self):
		filename = os.path.join (sc_cache_dir, 'channels.xml')
		if not os.path.exists (filename):
			return
		res = file(filename, 'r').read ()
		self.channel_guide.load (res)
		return res

	def show_channels (self):
		#for i in range (len (self.channel_guide.groups)):
		#	print str(i) + '.',self.channel_guide.groups[i]
		#	for j in range (len (self.channel_guide.channels[i])):
		#		print '\t', str(j) + '.', self.channel_guide.channels[i][j]

		treeview_name = 'channels'
		treeview = self.liststore[treeview_name]
		self.clear_pages (treeview_name)

		chinese = self.configs['show_chinese_name']
		for i in range (len (self.channel_guide.groups)):
			group = self.channel_guide.groups[i]
			channels = self.channel_guide.channels[i]
			iter = treeview.append (None)
			if chinese:
				title = group[3]
			else:
				title = group[2]
			num_channels = len (channels)
			treeview.set (iter,
				      0, title,
				      1, num_channels,
				      2, '')

			for channel in channels:
				child_iter = treeview.append (iter);
				if chinese:
					name = channel[4]
				else:
					name = channel[3]
				treeview.set (child_iter,
					      0, name,
					      1, 1,
					      2, channel[21])

	def setup_channels (self):
		treeview_name = 'channels'
		treeview = self.builder.get_object ("sc_treeview_" + treeview_name)
		renderer = gtk.CellRendererText()
		renderer.set_property("xalign", 0.0)

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

		column = gtk.TreeViewColumn(_("Number"), renderer, text = 1)
		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 ("sc_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 ("sc_liststore_" + treeview_name)
		self.treeview[treeview_name] = treeview
		treeview.set_model (self.liststore[treeview_name])

		treeview.connect("row_activated", self.on_channels_row_activated)
		treeview.connect ("popup-menu", self.on_treeview_popup_menu)
		treeview.connect ("button-press-event", self.on_treeview_button_pressed)

		self.channels_count = 0
		self.channels_downloading = False
		self.channel_guide = ChannelGuide ()
		if self.load_channels ():
			self.show_channels ()
		else:
			self.download_channels ()

        def load_playlist (self, path = sc_playlist):
                parser = ConfigParser.ConfigParser ()
                if not parser.read ([path]):
                    return []
                if not parser.has_section ('playlist'):
                    return []
                result = {}
                for item in parser.items ('playlist'):
                    key = item[0]
                    if key[0:4] == 'file':
                        index = int(key[4:])
                        key = 'file'
                    elif key[0:5] == 'title':
                        index = int(key[5:])
                        key = 'title'
                    else:
                        continue
                    if index not in result.keys ():
                        result[index] = {}
                    result[index][key] = item[1]
                    #print item, key, index, result[index]

                keys = result.keys ()
                keys.sort ()
                playlist = []
                for i in range (len (keys)):
                    title = result[keys[i]]['title']
                    url = result[keys[i]]['file']
                    playlist.append ((title, url))

                return playlist

        def save_playlist (self, playlist):
                if not playlist:
                    return False
                fp = None
                try:
                    fp = file (sc_playlist, 'wb')
                except:
                    return False
                fp.write ('[playlist]\n')
                fp.write ('NumberOfEntries=%d\n' % (len (playlist)))
                for i in range (len (playlist)):
                    fp.write ('File%d=%s\n' % (i + 1, playlist[i][1]))
                    fp.write ('Title%d=%s\n' % (i + 1, playlist[i][0]))
                fp.write ('\n')
                fp.close ()
                return True

        def show_playlist (self):
		treeview_name = 'playlist'
		treeview = self.liststore[treeview_name]
		self.clear_pages (treeview_name)

		for item in self.playlist:
			iter = treeview.append (None)
			treeview.set (iter,
				      0, item[0],
				      1, item[1])

        def add_to_playlist (self, title, mrl):
		treeview_name = 'playlist'
		treeview = self.liststore[treeview_name]
                if (title, mrl) in self.playlist:
                    return

                self.playlist.append ((title, mrl))
                self.save_playlist (self.playlist)

                iter = treeview.append (None)
                treeview.set (iter,
                              0, title,
                              1, mrl)

        def remove_from_playlist (self, row):
		treeview_name = 'playlist'
		treeview = self.liststore[treeview_name]

                del self.playlist[row]
                self.save_playlist (self.playlist)

                iter = treeview.get_iter (row)
                treeview.remove (iter)

	def on_playlist_row_activated (self, treeview, path, view_column, data=None):
		model, rows = treeview.get_selection ().get_selected_rows ()
		row = rows[0]

		iter = model.get_iter (row)
		title = model.get_value (iter, 0)
		mrl = model.get_value (iter, 1)

		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 setup_playlist (self):
		treeview_name = 'playlist'
		treeview = self.builder.get_object ("sc_treeview_" + treeview_name)
		renderer = gtk.CellRendererText ()
		renderer.set_property("xalign", 0.0)

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

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

		self.vadjust[treeview_name] = treeview.get_vadjustment ()
		#self.vadjust[treeview_name].connect ("value-changed", self.on_playlist_value_changed)
		vscroll = self.builder.get_object ("sc_scrolled_window_" + treeview_name).get_vscrollbar ()
		#vscroll.connect ("button-press-event", self.on_playlist_button_press_event)
		#vscroll.connect ("button-release-event", self.on_playlist_button_release_event)

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

		treeview.connect("row_activated", self.on_playlist_row_activated)
		treeview.connect ("popup-menu", self.on_treeview_popup_menu)
		treeview.connect ("button-press-event", self.on_treeview_button_pressed)
		treeview.connect ("key-press-event", self.on_playlist_key_pressed)

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

                try:
                    self.playlist = self.load_playlist ()
                    if not self.playlist:
                        self.playlist = self.load_playlist (sc_system_playlist)
                except Exception, e:
                    print 'Failed to load play list', e
                    self.playlist = []

                self.show_playlist ()

	def show_popup_menu (self, event = None):
		treeview_name = self.current_treeview_name
		treeview = self.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.ui_manager.get_action_groups () [0]
		action = action_group.get_action ("copy-location")
		action.set_sensitive (count == 1)

		action = action_group.get_action ("add-to-channel-list")
                action.set_sensitive (treeview_name == 'channels')

		action = action_group.get_action ("remove-from-channel-list")
                action.set_sensitive (treeview_name == 'playlist')

		action = action_group.get_action ("add-channel")
                action.set_sensitive (treeview_name == 'playlist')

		menu = self.ui_manager.get_widget ("/sopcast-popup")
		menu.select_first (False)
		menu.popup (None, None, None, button, time)

		return True

	def on_treeview_popup_menu (self):
		self.show_popup_menu ()

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

        def on_playlist_key_pressed (self, wiget, event, user_data = None):
		if event.type == gtk.gdk.KEY_PRESS and \
                    gtk.gdk.keyval_name (event.keyval) == 'Delete':
                    self.on_remove_from_channel_list (self.treeview['playlist'])
                    return True
		return False

	def on_notebook_page_changed (self, notebook, notebook_page, page_num):
		self.current_treeview_name = self.notebook_pages[page_num]

	def on_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.") % _("Sopcast"),
							      _("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):
		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.treeview[treeview_name]
			treeview.get_selection ().unselect_all ()
			liststore = self.liststore[treeview_name]
			liststore.clear ()

	def refresh_channels (self):
		self.download_channels ()

	def set_show_chinese_name (self, show = True):
		self.show_channels ()

	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_chinese_name'] != self.configs['show_chinese_name']:
			self.configs['show_chinese_name'] = self.input_configs['show_chinese_name']
			self.set_show_chinese_name (self.configs['show_chinese_name'])

		if self.input_configs['compatible'] != self.configs['compatible']:
			self.configs['comptiable'] = self.input_configs['compatible']
			self.stop_idle_task ()
			self.start_idle_task ()

	def on_refresh_button_clicked (self, button):
		if self.current_treeview_name == 'channels':
			self.refresh_channels ()

	def on_search_entry_activated (self, entry):
		self.search_terms = self.search_entry.get_text ()
		#self.treeview['channels'].get_model ().refilter ()

	def on_search_button_clicked (self, button):
		self.on_search_entry_activated (self.search_entry)

	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_config_checkbutton_toggle (self, button, which):
		self.input_configs[which] = button.get_active ()

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

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

	def setup_config_dialog (self):
		dialog = self.config_builder.get_object ("sc_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)

		button = self.config_builder.get_object ("sc_config_show_chinese_name")
		button.set_active (self.configs['show_chinese_name'])
		button.connect ("toggled", self.on_config_checkbutton_toggle, 'show_chinese_name')

		button = self.config_builder.get_object ("sc_config_compatible")
		button.set_active (self.configs['compatible'])
		button.connect ("toggled", self.on_config_checkbutton_toggle, 'compatible')