gajim.py

			bus = dbus.SessionBus()
			if not 'com.google.code.Awn' in bus.list_names():
				# Awn is not installed
				return
		except Exception:
			return
		iconset = gajim.config.get('iconset')
		prefix = os.path.join(helpers.get_iconset_path(iconset), '32x32')
		if status in ('chat', 'away', 'xa', 'dnd', 'invisible', 'offline'):
			status = status + '.png'
		elif status == 'online':
			prefix = os.path.join(gajim.DATA_DIR, 'pixmaps')
			status = 'gajim.png'
		path = os.path.join(prefix, status)
		try:
			obj = bus.get_object('com.google.code.Awn', '/com/google/code/Awn')
			awn = dbus.Interface(obj, 'com.google.code.Awn')
			awn.SetTaskIconByName('Gajim', os.path.abspath(path))
		except Exception:
			pass

	def enable_music_listener(self):
		listener = MusicTrackListener.get()
		if not self.music_track_changed_signal:
			self.music_track_changed_signal = listener.connect(
				'music-track-changed', self.music_track_changed)
		track = listener.get_playing_track()
		self.music_track_changed(listener, track)

	def disable_music_listener(self):
		listener = MusicTrackListener.get()
		listener.disconnect(self.music_track_changed_signal)
		self.music_track_changed_signal = None

	def music_track_changed(self, unused_listener, music_track_info, account=''):
		if account == '':
			accounts = gajim.connections.keys()
		else:
			accounts = [account]
		if music_track_info is None:
			artist = ''
			title = ''
			source = ''
		elif hasattr(music_track_info, 'paused') and music_track_info.paused == 0:
			artist = ''
			title = ''
			source = ''
		else:
			artist = music_track_info.artist
			title = music_track_info.title
			source = music_track_info.album
		for acct in accounts:
			if acct not in gajim.connections:
				continue
			if not gajim.account_is_connected(acct):
				continue
			if not gajim.connections[acct].pep_supported:
				continue
			if gajim.connections[acct].music_track_info == music_track_info:
				continue
			pep.user_send_tune(acct, artist, title, source)
			gajim.connections[acct].music_track_info = music_track_info

	def get_bg_fg_colors(self):
		def gdkcolor_to_rgb (gdkcolor):
			return [c / 65535. for c in (gdkcolor.red, gdkcolor.green,
				gdkcolor.blue)]

		def format_rgb (r, g, b):
			return ' '.join([str(c) for c in ('rgb', r, g, b)])

		def format_gdkcolor (gdkcolor):
			return format_rgb (*gdkcolor_to_rgb (gdkcolor))
		
		# get style colors and create string for dvipng
		dummy = gtk.Invisible()
		dummy.ensure_style()
		style = dummy.get_style()
		bg_str = format_gdkcolor(style.base[gtk.STATE_NORMAL])
		fg_str = format_gdkcolor(style.text[gtk.STATE_NORMAL])
		return (bg_str, fg_str)

	def read_sleepy(self):
		'''Check idle status and change that status if needed'''
		if not self.sleeper.poll():
			# idle detection is not supported in that OS
			return False # stop looping in vain
		state = self.sleeper.getState()
		for account in gajim.connections:
			if account not in gajim.sleeper_state or \
			not gajim.sleeper_state[account]:
				continue
			if state == common.sleepy.STATE_AWAKE and \
			gajim.sleeper_state[account] in ('autoaway', 'autoxa'):
				# we go online
				self.roster.send_status(account, 'online',
					gajim.status_before_autoaway[account])
				gajim.status_before_autoaway[account] = ''
				gajim.sleeper_state[account] = 'online'
			elif state == common.sleepy.STATE_AWAY and \
			gajim.sleeper_state[account] == 'online' and \
			gajim.config.get('autoaway'):
				# we save out online status
				gajim.status_before_autoaway[account] = \
					gajim.connections[account].status
				# we go away (no auto status) [we pass True to auto param]
				auto_message = gajim.config.get('autoaway_message')
				if not auto_message:
					auto_message = gajim.connections[account].status
				else:
					auto_message = auto_message.replace('$S','%(status)s')
					auto_message = auto_message.replace('$T','%(time)s')
					auto_message = auto_message % {
						'status': gajim.status_before_autoaway[account],
						'time': gajim.config.get('autoawaytime')
						}
				self.roster.send_status(account, 'away', auto_message, auto=True)
				gajim.sleeper_state[account] = 'autoaway'
			elif state == common.sleepy.STATE_XA and \
			gajim.sleeper_state[account] in ('online', 'autoaway',
			'autoaway-forced') and gajim.config.get('autoxa'):
				# we go extended away [we pass True to auto param]
				auto_message = gajim.config.get('autoxa_message')
				if not auto_message:
					auto_message = gajim.connections[account].status
				else:
					auto_message = auto_message.replace('$S','%(status)s')
					auto_message = auto_message.replace('$T','%(time)s')
					auto_message = auto_message % {
						'status': gajim.status_before_autoaway[account],
						'time': gajim.config.get('autoxatime')
						}
				self.roster.send_status(account, 'xa', auto_message, auto=True)
				gajim.sleeper_state[account] = 'autoxa'
		return True # renew timeout (loop for ever)

	def autoconnect(self):
		'''auto connect at startup'''
		# dict of account that want to connect sorted by status
		shows = {}
		for a in gajim.connections:
			if gajim.config.get_per('accounts', a, 'autoconnect'):
				if gajim.config.get_per('accounts', a, 'restore_last_status'):
					self.roster.send_status(a, gajim.config.get_per('accounts', a,
						'last_status'), helpers.from_one_line(gajim.config.get_per(
						'accounts', a, 'last_status_msg')))
					continue
				show = gajim.config.get_per('accounts', a, 'autoconnect_as')
				if not show in gajim.SHOW_LIST:
					continue
				if not show in shows:
					shows[show] = [a]
				else:
					shows[show].append(a)
		def on_message(message, pep_dict):
			if message is None:
				return
			for a in shows[show]:
				self.roster.send_status(a, show, message)
				self.roster.send_pep(a, pep_dict)
		for show in shows:
			message = self.roster.get_status_message(show, on_message)
		return False

	def show_systray(self):
		self.systray_enabled = True
		self.systray.show_icon()

	def hide_systray(self):
		self.systray_enabled = False
		self.systray.hide_icon()

	def on_launch_browser_mailer(self, widget, url, kind):
		helpers.launch_browser_mailer(kind, url)

	def process_connections(self):
		''' Called each foo (200) miliseconds. Check for idlequeue timeouts.	'''
		try:
			gajim.idlequeue.process()
		except Exception:
			# Otherwise, an exception will stop our loop
			timeout, in_seconds = gajim.idlequeue.PROCESS_TIMEOUT
			if in_seconds:
				gobject.timeout_add_seconds(timeout, self.process_connections)
			else:
				gobject.timeout_add(timeout, self.process_connections)
			raise
		return True # renew timeout (loop for ever)

	def save_config(self):
		err_str = parser.write()
		if err_str is not None:
			print >> sys.stderr, err_str
			# it is good to notify the user
			# in case he or she cannot see the output of the console
			dialogs.ErrorDialog(_('Could not save your settings and preferences'),
				err_str)
			sys.exit()

	def save_avatar_files(self, jid, photo, puny_nick = None, local = False):
		'''Saves an avatar to a separate file, and generate files for dbus notifications. An avatar can be given as a pixmap directly or as an decoded image.'''
		puny_jid = helpers.sanitize_filename(jid)
		path_to_file = os.path.join(gajim.AVATAR_PATH, puny_jid)
		if puny_nick:
			path_to_file = os.path.join(path_to_file, puny_nick)
		# remove old avatars
		for typ in ('jpeg', 'png'):
			if local:
				path_to_original_file = path_to_file + '_local'+  '.' + typ
			else:
				path_to_original_file = path_to_file + '.' + typ
			if os.path.isfile(path_to_original_file):
				os.remove(path_to_original_file)
		if local and photo:
			pixbuf = photo
			typ = 'png'
			extension = '_local.png' # save local avatars as png file
		else:
			pixbuf, typ = gtkgui_helpers.get_pixbuf_from_data(photo, want_type = True)
			if pixbuf is None:
				return
			extension = '.' + typ
			if typ not in ('jpeg', 'png'):
				gajim.log.debug('gtkpixbuf cannot save other than jpeg and png formats. saving %s\'avatar as png file (originaly %s)' % (jid, typ))
				typ = 'png'
				extension = '.png'
		path_to_original_file = path_to_file + extension
		try:
			pixbuf.save(path_to_original_file, typ)
		except Exception, e:
			log.error('Error writing avatar file %s: %s' % (path_to_original_file,
				str(e)))
		# Generate and save the resized, color avatar
		pixbuf = gtkgui_helpers.get_scaled_pixbuf(pixbuf, 'notification')
		if pixbuf:
			path_to_normal_file = path_to_file + '_notif_size_colored' + extension
			try:
				pixbuf.save(path_to_normal_file, 'png')
			except Exception, e:
				log.error('Error writing avatar file %s: %s' % \
					(path_to_original_file, str(e)))
			# Generate and save the resized, black and white avatar
			bwbuf = gtkgui_helpers.get_scaled_pixbuf(
				gtkgui_helpers.make_pixbuf_grayscale(pixbuf), 'notification')
			if bwbuf:
				path_to_bw_file = path_to_file + '_notif_size_bw' + extension
				try:
					bwbuf.save(path_to_bw_file, 'png')
				except Exception, e:
					log.error('Error writing avatar file %s: %s' % \
						(path_to_original_file, str(e)))

	def remove_avatar_files(self, jid, puny_nick = None, local = False):
		'''remove avatar files of a jid'''
		puny_jid = helpers.sanitize_filename(jid)
		path_to_file = os.path.join(gajim.AVATAR_PATH, puny_jid)
		if puny_nick:
			path_to_file = os.path.join(path_to_file, puny_nick)
		for ext in ('.jpeg', '.png'):
			if local:
				ext = '_local' + ext
			path_to_original_file = path_to_file + ext
			if os.path.isfile(path_to_file + ext):
				os.remove(path_to_file + ext)
			if os.path.isfile(path_to_file + '_notif_size_colored' + ext):
				os.remove(path_to_file + '_notif_size_colored' + ext)
			if os.path.isfile(path_to_file + '_notif_size_bw' + ext):
				os.remove(path_to_file + '_notif_size_bw' + ext)

	def auto_join_bookmarks(self, account):
		'''autojoin bookmarked GCs that have 'auto join' on for this account'''
		for bm in gajim.connections[account].bookmarks:
			if bm['autojoin'] in ('1', 'true'):
				jid = bm['jid']
				# Only join non-opened groupchats. Opened one are already
				# auto-joined on re-connection
				if not jid in gajim.gc_connected[account]:
					# we are not already connected
					minimize = bm['minimize'] in ('1', 'true')
					gajim.interface.join_gc_room(account, jid, bm['nick'],
					bm['password'], minimize = minimize)
				elif jid in self.minimized_controls[account]:
					# more or less a hack:
					# On disconnect the minimized gc contact instances
					# were set to offline. Reconnect them to show up in the roster.
					self.roster.add_groupchat(jid, account)

	def add_gc_bookmark(self, account, name, jid, autojoin, minimize, password,
		nick):
		'''add a bookmark for this account, sorted in bookmark list'''
		bm = {
			'name': name,
			'jid': jid,
			'autojoin': autojoin,
			'minimize': minimize,
			'password': password,
			'nick': nick
		}
		place_found = False
		index = 0
		# check for duplicate entry and respect alpha order
		for bookmark in gajim.connections[account].bookmarks:
			if bookmark['jid'] == bm['jid']:
				dialogs.ErrorDialog(
					_('Bookmark already set'),
					_('Group Chat "%s" is already in your bookmarks.') % bm['jid'])
				return
			if bookmark['name'] > bm['name']:
				place_found = True
				break
			index += 1
		if place_found:
			gajim.connections[account].bookmarks.insert(index, bm)
		else:
			gajim.connections[account].bookmarks.append(bm)
		gajim.connections[account].store_bookmarks()
		self.roster.set_actions_menu_needs_rebuild()
		dialogs.InformationDialog(
				_('Bookmark has been added successfully'),
				_('You can manage your bookmarks via Actions menu in your roster.'))


	# does JID exist only within a groupchat?
	def is_pm_contact(self, fjid, account):
		bare_jid = gajim.get_jid_without_resource(fjid)

		gc_ctrl = self.msg_win_mgr.get_gc_control(bare_jid, account)

		if not gc_ctrl and \
		bare_jid in self.minimized_controls[account]:
			gc_ctrl = self.minimized_controls[account][bare_jid]

		return gc_ctrl and gc_ctrl.type_id == message_control.TYPE_GC

	def create_ipython_window(self):
		try:
			from ipython_view import IPythonView
		except ImportError:
			print 'ipython_view not found'
			return
		import pango

		if os.name == 'nt':
			font = 'Lucida Console 9'
		else:
			font = 'Luxi Mono 10'

		window = gtk.Window()
		window.set_size_request(750,550)
		window.set_resizable(True)
		sw = gtk.ScrolledWindow()
		sw.set_policy(gtk.POLICY_AUTOMATIC,gtk.POLICY_AUTOMATIC)
		view = IPythonView()
		view.modify_font(pango.FontDescription(font))
		view.set_wrap_mode(gtk.WRAP_CHAR)
		sw.add(view)
		window.add(sw)
		window.show_all()
		def on_delete(win, event):
			win.hide()
			return True
		window.connect('delete_event',on_delete)
		view.updateNamespace({'gajim': gajim})
		gajim.ipython_window = window

	def run(self):
		if self.systray_capabilities and gajim.config.get('trayicon') != 'never':
			self.show_systray()

		self.roster = roster_window.RosterWindow()
		for account in gajim.connections:
			gajim.connections[account].load_roster_from_db()

		# get instances for windows/dialogs that will show_all()/hide()
		self.instances['file_transfers'] = dialogs.FileTransfersWindow()

		gobject.timeout_add(100, self.autoconnect)
		timeout, in_seconds = gajim.idlequeue.PROCESS_TIMEOUT
		if in_seconds:
			gobject.timeout_add_seconds(timeout, self.process_connections)
		else:
			gobject.timeout_add(timeout, self.process_connections)
		gobject.timeout_add_seconds(gajim.config.get(
			'check_idle_every_foo_seconds'), self.read_sleepy)

		# when using libasyncns we need to process resolver in regular intervals
		if resolver.USE_LIBASYNCNS:
			gobject.timeout_add(200, gajim.resolver.process)

		# setup the indicator
		if gajim.HAVE_INDICATOR:
			notify.setup_indicator_server()

		def remote_init():
			if gajim.config.get('remote_control'):
				try:
					import remote_control
					self.remote_ctrl = remote_control.Remote()
				except Exception:
					pass
		gobject.timeout_add_seconds(5, remote_init)

		for account in gajim.connections:
			if gajim.config.get_per('accounts', account, 'publish_tune') and \
			dbus_support.supported:
				self.enable_music_listener()
				break

	def __init__(self):
		gajim.interface = self
		gajim.thread_interface = ThreadInterface
		# This is the manager and factory of message windows set by the module
		self.msg_win_mgr = None
		self.jabber_state_images = {'16': {}, '32': {}, 'opened': {},
			'closed': {}}
		self.emoticons_menu = None
		# handler when an emoticon is clicked in emoticons_menu
		self.emoticon_menuitem_clicked = None
		self.minimized_controls = {}
		self.status_sent_to_users = {}
		self.status_sent_to_groups = {}
		self.gpg_passphrase = {}
		self.pass_dialog = {}
		self.default_colors = {
			'inmsgcolor': gajim.config.get('inmsgcolor'),
			'outmsgcolor': gajim.config.get('outmsgcolor'),
			'statusmsgcolor': gajim.config.get('statusmsgcolor'),
			'urlmsgcolor': gajim.config.get('urlmsgcolor'),
		}

		cfg_was_read = parser.read()
		gajim.logger.reset_shown_unread_messages()
		# override logging settings from config (don't take care of '-q' option)
		if gajim.config.get('verbose'):
			logging_helpers.set_verbose()

		# Is Gajim default app?
		if os.name != 'nt' and gajim.config.get('check_if_gajim_is_default'):
			gtkgui_helpers.possibly_set_gajim_as_xmpp_handler()

		for account in gajim.config.get_per('accounts'):
			if gajim.config.get_per('accounts', account, 'is_zeroconf'):
				gajim.ZEROCONF_ACC_NAME = account
				break
		# Is gnome configured to activate row on single click ?
		try:
			import gconf
			client = gconf.client_get_default()
			click_policy = client.get_string(
				'/apps/nautilus/preferences/click_policy')
			if click_policy == 'single':
				gajim.single_click = True
		except Exception:
			pass
		# add default status messages if there is not in the config file
		if len(gajim.config.get_per('statusmsg')) == 0:
			default = gajim.config.statusmsg_default
			for msg in default:
				gajim.config.add_per('statusmsg', msg)
				gajim.config.set_per('statusmsg', msg, 'message', default[msg][0])
				gajim.config.set_per('statusmsg', msg, 'activity', default[msg][1])
				gajim.config.set_per('statusmsg', msg, 'subactivity',
					default[msg][2])
				gajim.config.set_per('statusmsg', msg, 'activity_text',
					default[msg][3])
				gajim.config.set_per('statusmsg', msg, 'mood', default[msg][4])
				gajim.config.set_per('statusmsg', msg, 'mood_text', default[msg][5])
		#add default themes if there is not in the config file
		theme = gajim.config.get('roster_theme')
		if not theme in gajim.config.get_per('themes'):
			gajim.config.set('roster_theme', _('default'))
		if len(gajim.config.get_per('themes')) == 0:
			d = ['accounttextcolor', 'accountbgcolor', 'accountfont',
				'accountfontattrs', 'grouptextcolor', 'groupbgcolor', 'groupfont',
				'groupfontattrs', 'contacttextcolor', 'contactbgcolor',
				'contactfont', 'contactfontattrs', 'bannertextcolor',
				'bannerbgcolor']

			default = gajim.config.themes_default
			for theme_name in default:
				gajim.config.add_per('themes', theme_name)
				theme = default[theme_name]
				for o in d:
					gajim.config.set_per('themes', theme_name, o,
						theme[d.index(o)])

		if gajim.config.get('autodetect_browser_mailer') or not cfg_was_read:
			gtkgui_helpers.autodetect_browser_mailer()

		gajim.idlequeue = idlequeue.get_idlequeue()
		# resolve and keep current record of resolved hosts
		gajim.resolver = resolver.get_resolver(gajim.idlequeue)
		gajim.socks5queue = socks5.SocksQueue(gajim.idlequeue,
			self.handle_event_file_rcv_completed,
			self.handle_event_file_progress,
			self.handle_event_file_error)
		gajim.proxy65_manager = proxy65_manager.Proxy65Manager(gajim.idlequeue)
		gajim.default_session_type = ChatControlSession
		self.register_handlers()
		if gajim.config.get_per('accounts', gajim.ZEROCONF_ACC_NAME, 'active') \
		and gajim.HAVE_ZEROCONF:
			gajim.connections[gajim.ZEROCONF_ACC_NAME] = \
				connection_zeroconf.ConnectionZeroconf(gajim.ZEROCONF_ACC_NAME)
		for account in gajim.config.get_per('accounts'):
			if not gajim.config.get_per('accounts', account, 'is_zeroconf') and \
			gajim.config.get_per('accounts', account, 'active'):
				gajim.connections[account] = common.connection.Connection(account)

		# gtk hooks
		gtk.about_dialog_set_email_hook(self.on_launch_browser_mailer, 'mail')
		gtk.about_dialog_set_url_hook(self.on_launch_browser_mailer, 'url')
		gtk.link_button_set_uri_hook(self.on_launch_browser_mailer, 'url')

		self.instances = {}

		for a in gajim.connections:
			self.instances[a] = {'infos': {}, 'disco': {}, 'gc_config': {},
				'search': {}, 'online_dialog': {}}
			# online_dialog contains all dialogs that have a meaning only when we
			# are not disconnected
			self.minimized_controls[a] = {}
			gajim.contacts.add_account(a)
			gajim.groups[a] = {}
			gajim.gc_connected[a] = {}
			gajim.automatic_rooms[a] = {}
			gajim.newly_added[a] = []
			gajim.to_be_removed[a] = []
			gajim.nicks[a] = gajim.config.get_per('accounts', a, 'name')
			gajim.block_signed_in_notifications[a] = True
			gajim.sleeper_state[a] = 0
			gajim.encrypted_chats[a] = []
			gajim.last_message_time[a] = {}
			gajim.status_before_autoaway[a] = ''
			gajim.transport_avatar[a] = {}
			gajim.gajim_optional_features[a] = []
			gajim.caps_hash[a] = ''

		helpers.update_optional_features()

		self.remote_ctrl = None

		if gajim.config.get('networkmanager_support') and dbus_support.supported:
			import network_manager_listener

		# Handle gnome screensaver
		if dbus_support.supported:
			def gnome_screensaver_ActiveChanged_cb(active):
				if not active:
					for account in gajim.connections:
						if gajim.sleeper_state[account] == 'autoaway-forced':
							# We came back online ofter gnome-screensaver autoaway
							self.roster.send_status(account, 'online',
								gajim.status_before_autoaway[account])
							gajim.status_before_autoaway[account] = ''
							gajim.sleeper_state[account] = 'online'
					return
				if not gajim.config.get('autoaway'):
					# Don't go auto away if user disabled the option
					return
				for account in gajim.connections:
					if account not in gajim.sleeper_state or \
							not gajim.sleeper_state[account]:
						continue
					if gajim.sleeper_state[account] == 'online':
						# we save out online status
						gajim.status_before_autoaway[account] = \
							gajim.connections[account].status
						# we go away (no auto status) [we pass True to auto param]
						auto_message = gajim.config.get('autoaway_message')
						if not auto_message:
							auto_message = gajim.connections[account].status
						else:
							auto_message = auto_message.replace('$S','%(status)s')
							auto_message = auto_message.replace('$T','%(time)s')
							auto_message = auto_message % {
								'status': gajim.status_before_autoaway[account],
								'time': gajim.config.get('autoxatime')
							}
						self.roster.send_status(account, 'away', auto_message,
							auto=True)
						gajim.sleeper_state[account] = 'autoaway-forced'

			try:
				bus = dbus.SessionBus()
				bus.add_signal_receiver(gnome_screensaver_ActiveChanged_cb,
					'ActiveChanged', 'org.gnome.ScreenSaver')
			except Exception:
				pass

		self.show_vcard_when_connect = []

		self.sleeper = common.sleepy.Sleepy(
			gajim.config.get('autoawaytime') * 60, # make minutes to seconds
			gajim.config.get('autoxatime') * 60)

		gtkgui_helpers.make_jabber_state_images()

		self.systray_enabled = False
		self.systray_capabilities = False

		if (os.name == 'nt'):
			import statusicon
			self.systray = statusicon.StatusIcon()
			self.systray_capabilities = True
		else: # use ours, not GTK+ one
			# [FIXME: remove this when we migrate to 2.10 and we can do
			# cool tooltips somehow and (not dying to keep) animation]
			import systray
			self.systray_capabilities = systray.HAS_SYSTRAY_CAPABILITIES
			if self.systray_capabilities:
				self.systray = systray.Systray()

		path_to_file = os.path.join(gajim.DATA_DIR, 'pixmaps', 'gajim.png')
		pix = gtk.gdk.pixbuf_new_from_file(path_to_file)
		# set the icon to all windows
		gtk.window_set_default_icon(pix)

		self.init_emoticons()
		self.make_regexps()

		# get transports type from DB
		gajim.transport_type = gajim.logger.get_transports_type()

		# test is dictionnary is present for speller
		if gajim.config.get('use_speller'):
			lang = gajim.config.get('speller_language')
			if not lang:
				lang = gajim.LANG
			tv = gtk.TextView()
			try:
				import gtkspell
				spell = gtkspell.Spell(tv, lang)
			except (ImportError, TypeError, RuntimeError, OSError):
				dialogs.AspellDictError(lang)

		if gajim.config.get('soundplayer') == '':
			# only on first time Gajim starts
			commands = ('aplay', 'play', 'esdplay', 'artsplay', 'ossplay')
			for command in commands:
				if helpers.is_in_path(command):
					if command == 'aplay':
						command += ' -q'
					gajim.config.set('soundplayer', command)
					break

		self.last_ftwindow_update = 0

		self.music_track_changed_signal = None

if __name__ == '__main__':
	def sigint_cb(num, stack):
		sys.exit(5)
	# ^C exits the application normally to delete pid file
	signal.signal(signal.SIGINT, sigint_cb)

	log.info("Encodings: d:%s, fs:%s, p:%s", sys.getdefaultencoding(), \
		sys.getfilesystemencoding(), locale.getpreferredencoding())

	if os.name != 'nt':
		# Session Management support
		try:
			import gnome.ui
		except ImportError:
			pass
		else:
			def die_cb(cli):
				gajim.interface.roster.quit_gtkgui_interface()
			gnome.program_init('gajim', gajim.version)
			cli = gnome.ui.master_client()
			cli.connect('die', die_cb)

			path_to_gajim_script = gtkgui_helpers.get_abspath_for_script(
				'gajim')

			if path_to_gajim_script:
				argv = [path_to_gajim_script]
				# FIXME: remove this typeerror catch when gnome python is old and
				# not bad patched by distro men [2.12.0 + should not need all that
				# NORMALLY]
				try:
					cli.set_restart_command(argv)
				except AttributeError:
					cli.set_restart_command(len(argv), argv)

	check_paths.check_and_possibly_create_paths()

	interface = Interface()
	interface.run()

	try:
		if os.name != 'nt':
			# This makes Gajim unusable under windows, and threads are used only
			# for GPG, so not under windows
			gtk.gdk.threads_init()
		gtk.main()
	except KeyboardInterrupt:
		print >> sys.stderr, 'KeyboardInterrupt'

# vim: se ts=3: