diff -urN gajim-0.8.orig/scripts/gajim-remote gajim-0.8/scripts/gajim-remote
--- gajim-0.8.orig/scripts/gajim-remote	2005-08-19 12:58:20.182083440 +0200
+++ gajim-0.8/scripts/gajim-remote	2005-08-19 12:59:44.453272272 +0200
@@ -22,6 +22,6 @@
 	echo "You must not launch gajim-remote as root, it is INSECURE"
 fi
 
-cd PREFIX/share/gajim/scripts
+cd PREFIX/share/gajim/src
 export PYTHONPATH="$PYTHONPATH:PREFIXLIB/gajim"
 python gajim-remote.py $@
diff -urN gajim-0.8.orig/src/gajim-remote.py gajim-0.8/src/gajim-remote.py
--- gajim-0.8.orig/src/gajim-remote.py	1970-01-01 01:00:00.000000000 +0100
+++ gajim-0.8/src/gajim-remote.py	2005-08-19 12:47:58.598578496 +0200
@@ -0,0 +1,493 @@
+#!/bin/sh
+''':'
+exec python -OOt "$0" ${1+"$@"}
+' '''
+##	scripts/gajim-remote.py
+##
+## Gajim Team:
+##	- Yann Le Boulanger <asterix@lagaule.org>
+##	- Vincent Hanquez <tab@snarc.org>
+##	- Nikos Kouremenos <kourem@gmail.com>
+##	- Dimitur Kirov <dkirov@gmail.com>
+##
+##	Copyright (C) 2003-2005 Gajim Team
+##
+## This program is free software; you can redistribute it and/or modify
+## it under the terms of the GNU General Public License as published
+## by the Free Software Foundation; version 2 only.
+##
+## This program is distributed in the hope that it will be useful,
+## but WITHOUT ANY WARRANTY; without even the implied warranty of
+## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+## GNU General Public License for more details.
+##
+
+# gajim-remote help will show you the DBUS API of Gajim
+
+import sys
+import gtk
+import gobject
+
+import signal
+
+signal.signal(signal.SIGINT, signal.SIG_DFL) # ^C exits the application
+
+import i18n
+
+_ = i18n._
+i18n.init()
+
+
+try:
+	import dbus
+except:
+	send_error('Dbus is not supported.\n')
+
+_version = getattr(dbus, 'version', (0, 20, 0))
+if _version[1] >= 41:
+	import dbus.service
+	import dbus.glib
+
+OBJ_PATH = '/org/gajim/dbus/RemoteObject'
+INTERFACE = 'org.gajim.dbus.RemoteInterface'
+SERVICE = 'org.gajim.dbus'
+BASENAME = 'gajim-remote'
+
+class GajimRemote:
+	
+	def __init__(self):
+		self.argv_len = len(sys.argv) 
+		# define commands dict. Prototype :
+		# {
+		#	'command': [comment, [list of arguments] ]
+		# }
+		#
+		# each argument is defined as a tuple:
+		#    (argument name, help on argument, is mandatory)
+		#
+		self.commands = {
+			'help':[
+					_('show a help on specific command'),
+					[
+						#parameter, named "on_command". User gets help for the command, specified by this parameter
+						(_('on_command'), 
+						_('show help on command'), False)
+					]
+				], 
+			'toggle_roster_appearance' : [
+					_('Shows or hides the roster window'),
+					[]
+				], 
+			'show_next_unread': [
+					_('Popup a window with the next unread message'),
+					[]
+				],
+			'list_contacts': [
+					_('Print a list of all contacts in the roster. \
+Each contact appear on a separate line'),
+					[
+						(_('account'), _('show only contacts of the \
+given account'), False)
+					]
+					
+				],	
+			'list_accounts': [
+					_('Print a list of registered accounts'),
+					[]
+				], 
+			'change_status': [
+					_('Change the status of account or accounts'),
+					[
+						(_('status'), _('one of: offline, online, chat, away, \
+xa, dnd, invisible '), True), 
+						(_('message'), _('status message'), False), 
+						(_('account'), _('change status of account "account". \
+If not specified, try to change status of all accounts that \
+have "sync with global status" option set'), False)
+					]
+				],
+			'open_chat': [ 
+					_('Show the chat dialog so that you can send message to a \
+contact'), 
+					[
+						#tell nkour that should be JID of the contact
+						('jid', _('jid of the contact that you want to chat \
+with'),
+							True), 
+						(_('account'), _('if specified, contact is taken from \
+the contact list of this account'), False)
+					]
+				],
+			'send_message':[
+					#OpenPGP key here too (tlel that to nkour)
+					_('Send new message to a contact in the roster. Both OpenPGP \
+key and account are optional. If you want to set only \'account\', without \
+\'pgp key\', just set \'pgp key\' to \'\'.'), 
+					[
+						#tell nkour that should be JID of the contact
+						('jid', _('jid of the contact that will receive the \
+message'), True),
+						(_('message'), _('message contents'), True),
+						#tell to nkour it should be OpenPGP key
+						(_('pgp key'), _('if specified, the message will be \
+encrypted using this public key'), False),
+						(_('account'), _('if specified, the message will be \
+sent using this account'), False),
+					]
+				], 
+			'contact_info': [
+					_('Get detailed info on a contact'), 
+					[
+						#JID of the contact (tell that to nkour)
+						('jid', _('jid of the contact'), True)
+					]
+				]
+			}
+		if self.argv_len  < 2 or \
+			sys.argv[1] not in self.commands.keys(): # no args or bad args
+			self.send_error(self.compose_help())
+		self.command = sys.argv[1]
+		
+		if self.command == 'help':
+			if self.argv_len == 3:
+				print self.help_on_command(sys.argv[2])
+			else:
+				print self.compose_help()
+			sys.exit()
+		
+		self.init_connection()
+		self.check_arguments()
+		
+		if self.command == 'contact_info':
+			if self.argv_len < 3:
+				self.send_error(_('Missing argument "contact_jid"'))
+			try:
+				id = self.sbus.add_signal_receiver(self.show_vcard_info, 
+					'VcardInfo', INTERFACE, SERVICE, OBJ_PATH)
+			except:
+				self.send_error(_('Service not available'))
+		
+		res = self.call_remote_method()
+		self.print_result(res)
+		
+		if self.command == 'contact_info':
+			gobject.timeout_add(10000, self.gtk_quit) # wait 10 sec for response
+			gtk.main()
+	
+	def print_result(self, res):
+		''' Print retrieved result to the output '''
+		if res is not None:
+			if self.command in ['open_chat', 'send_message']:
+				if self.command == 'send_message':
+					self.argv_len -= 2
+				
+				if res == False:
+					if self.argv_len < 4:
+						self.send_error(_('\'%s\' is not in your roster.\n\
+Please specify account for sending the message.') % sys.argv[2])
+					else:
+						self.send_error(_('You have no active account'))
+			elif self.command == 'list_accounts':
+				if type(res) == list:
+					for account in res:
+						print account
+			elif self.command == 'list_contacts':
+				for single_res in res:
+					accounts = self.unrepr(single_res)
+					for account_dict in accounts:
+						print self.print_info(0, account_dict)
+			elif res:
+				print res
+	
+	def init_connection(self):
+		''' create the onnection to the session dbus,
+		or exit if it is not possible '''
+		try:
+			self.sbus = dbus.SessionBus()
+		except:
+			self.send_error(_('Session bus is not available.'))
+		
+		if _version[1] >= 30 and _version[1] <= 42:
+			obj = self.sbus.get_object(SERVICE, OBJ_PATH)
+			interface = dbus.Interface(obj, INTERFACE)
+		elif _version[1] < 30:
+			self.service = self.sbus.get_service(SERVICE)
+			interface = self.service.get_object(OBJ_PATH, INTERFACE)
+		else:
+			#say to nkour that this should be Unknown D-Bus version: %s (thanks nebulam)
+			send_error(_('Unknown dbus version: %s') % _version)
+			
+		# get the function asked
+		self.method = interface.__getattr__(self.command)
+		
+	def make_arguments_row(self, args):
+		''' return arguments list. Mandatory arguments are enclosed with:
+		'<', '>', optional arguments - with '[', ']' '''
+		str = ''
+		for argument in args:
+			str += ' '
+			if argument[2]:
+				str += '<'
+			else:
+				str += '['
+			str += argument[0]
+			if argument[2]:
+				str += '>'
+			else:
+				str += ']'
+		return str
+		
+	def help_on_command(self, command):
+		''' return help message for a given command '''
+		if command in self.commands:
+			command_props = self.commands[command]
+			arguments_str = self.make_arguments_row(command_props[1])
+			str = _('Usage: %s %s %s \n\t') % (BASENAME, command, 
+					arguments_str)
+			str += command_props[0] + '\n\n' + _('Arguments:') + '\n'
+			for argument in command_props[1]:
+				str += ' ' +  argument[0] + ' - ' + argument[1] + '\n'
+			return str
+		self.send_error(_('%s not found') % command)
+			
+	def compose_help(self):
+		''' print usage, and list available commands '''
+		str = _('Usage: %s command [arguments]\nCommand is one of:\n' ) % BASENAME
+		for command in self.commands.keys():
+			str += '  ' + command 
+			for argument in self.commands[command][1]:
+				str += ' '
+				if argument[2]:
+					str += '<'
+				else:
+					str += '['
+				str += argument[0]
+				if argument[2]:
+					str += '>'
+				else:
+					str += ']'
+			str += '\n'
+		return str
+		
+	def print_info(self, level, prop_dict):
+		''' return formated string from serialized vcard data '''
+		if prop_dict is None or type(prop_dict) \
+			not in [dict, list, tuple]:
+			return ''
+		ret_str = ''
+		if type(prop_dict) in [list, tuple]:
+			ret_str = ''
+			spacing = ' ' * level * 4
+			for val in prop_dict:
+				if val is None:
+					ret_str +='\t'
+				elif type(val) == unicode or type(val) == int or \
+					type(val) == str:
+					ret_str +='\t' + str(val)
+				elif type(val) == list or type(val) == tuple:
+					res = ''
+					for items in val:
+						res += self.print_info(level+1, items)
+					if res != '':
+						ret_str += '\t' + res
+			ret_str = '%s(%s)\n' % (spacing, ret_str[1:])
+		elif type(prop_dict) is dict:
+			for key in prop_dict.keys():
+				val = prop_dict[key]
+				spacing = ' ' * level * 4
+				if type(val) == unicode or type(val) == int or \
+					type(val) == str:
+					if val is not None:
+						val = val.strip()
+						ret_str += '%s%-10s: %s\n' % (spacing, key, val)
+				elif type(val) == list or type(val) == tuple:
+					res = ''
+					for items in val:
+						res += self.print_info(level+1, items)
+					if res != '':
+						ret_str += '%s%s: \n%s' % (spacing, key, res)
+				elif type(val) == dict:
+					res = self.print_info(level+1, val)
+					if res != '':
+						ret_str += '%s%s: \n%s' % (spacing, key, res)
+				else:
+					self.send_warning(_('Unknown type %s ') % type(val))
+		return ret_str
+		
+	def unrepr(self, serialized_data):
+		''' works the same as eval, but only for structural values, 
+		not functions! e.g. dicts, lists, strings, tuples '''
+		if not serialized_data:
+			return (None, '') 
+		value = serialized_data.strip()
+		first_char = value[0]
+		is_unicode  = False
+		is_int  = False
+		
+		if first_char == 'u':
+			is_unicode = True
+			value = value[1:]
+			first_char = value[0]
+		elif '0123456789.'.find(first_char) != -1:
+			is_int = True
+			_str = first_char
+			if first_char == '.':
+				is_float = True
+			else:
+				is_float =  False
+			for i in range(len(value) - 1):
+				chr = value[i+1]
+				if chr == '.':
+					is_float = True
+				elif '0123456789'.find(chr) == -1:
+					break
+				_str += chr
+			if is_float:
+				return (float(_str), value[len(_str):])
+			else:
+				return (int(_str), value[len(_str):])
+		elif first_char == 'N':
+			if value[1:4] == 'one':
+				return (None, value[4:])
+			else:
+				return (None, '')
+		if first_char == "'" or first_char == '"': # handle strings and unicode
+			if len(value) < 2:
+				return ('',value[1:])
+			_str = ''
+			previous_slash = False
+			for i in range(len(value) - 1):
+				chr = value[i+1]
+				if previous_slash:
+					previous_slash = False
+					if chr == '\\':
+						_str += '\\'
+					elif chr == 'n':
+						_str += '\n'
+					elif chr == 't':
+						_str += '\t'
+					elif chr == 'r':
+						_str += '\r'
+					elif chr == 'b':
+						_str += '\b'
+					elif chr == '\'':
+						_str += '\''
+					elif chr == '\"':
+						_str += '\"'
+					elif chr == 'u' and is_unicode:
+						_str += '\\u'
+				elif chr == first_char:
+					break
+				elif chr == '\\':
+					previous_slash = True
+				else:
+					_str += chr
+			substr_len = len(_str)+2
+			if is_unicode and _str:
+				_str = _str.decode('unicode-escape').encode('utf-8')
+			return (_str, value[substr_len :])
+		elif first_char == '{': # dict
+			_dict = {}
+			while True:
+				if value[1] == '}':
+					break
+				key, next = self.unrepr(value[1:])
+				if type(key) != str and type(key) != unicode:
+					send_error('Wrong string: %s' % value)
+				next = next.strip()
+				if not next or next[0] != ':':
+					send_error('Wrong string: %s' % (value))
+				val, next = self.unrepr(next[1:])
+				_dict[key] = val
+				next = next.strip()
+				if not next:
+					break
+				if next[0] == ',':
+					value = next
+				elif next[0] == '}':
+					break
+				else:
+					break
+			return (_dict, next[1:])
+		elif first_char in ['[', '(']: # return list 
+			_tuple = []
+			while True:
+				if value[1] == ']':
+					break
+				val, next = self.unrepr(value[1:])
+				next = next.strip()
+				if not next:
+					send_error('Wrong string: %s' % val)
+				_tuple.append(val)
+				next = next.strip()
+				if not next:
+					break
+				if next[0] == ',':
+					value = next
+				elif next[0] in [']', ')']:
+					break
+			return (_tuple, next[1:])
+		
+	def show_vcard_info(self, *args, **keyword):
+		''' write user vcart in a formated output '''
+		props_dict = None
+		if _version[1] >= 30:
+			props_dict = self.unrepr(args[0])
+		else:
+			if args and len(args) >= 5:
+				props_dict = self.unrepr(args[4].get_args_list()[0])
+
+		if props_dict:
+			print self.print_info(0,props_dict[0])
+		# remove_signal_receiver is broken in lower versions (< 0.35), 
+		# so we leave the leak - nothing can be done
+		if _version[1] >= 41:
+			self.sbus.remove_signal_receiver(show_vcard_info, 'VcardInfo', 
+				INTERFACE, SERVICE, OBJ_PATH)
+	
+		gtk.main_quit()
+		
+	def check_arguments(self):
+		''' Make check if all necessary arguments are given '''
+		argv_len = self.argv_len - 2
+		args = self.commands[self.command][1]
+		if len(args) > argv_len:
+			if args[argv_len][2]:
+				self.send_error(_('Argument "%s" is not specified. \n\
+Type "%s help %s" for more info') % (args[argv_len][0], BASENAME, self.command))
+
+	def gtk_quit(self):
+		if _version[1] >= 41:
+			self.sbus.remove_signal_receiver(show_vcard_info, 'VcardInfo', 
+				INTERFACE, SERVICE, OBJ_PATH)
+		gtk.main_quit()
+	
+	# FIXME - didn't find more clever way for the below method.
+	# method(sys.argv[2:]) doesn't work, cos sys.argv[2:] is a tuple
+	def call_remote_method(self):
+		''' calls self.method with arguments from sys.argv[2:] '''
+		try:
+			if self.argv_len == 2:
+				res = self.method()
+			elif self.argv_len == 3:
+				res = self.method(sys.argv[2])
+			elif self.argv_len == 4:
+				res = self.method(sys.argv[2], sys.argv[3])
+			elif self.argv_len == 5:
+				res = self.method(sys.argv[2], sys.argv[3], sys.argv[4])
+			elif argv_len == 6:
+				res = self.method(sys.argv[2], sys.argv[3], sys.argv[4], 
+					sys.argv[5])
+			return res
+		except:
+			self.send_error(_('Service not available'))
+		return None
+
+	def send_error(self, error_message):
+		'''  Writes error message to stderr and exits '''
+		sys.stderr.write(error_message + '\n')
+		sys.stderr.flush()
+		sys.exit(1)
+
+if __name__ == '__main__':
+	GajimRemote()
diff -urN gajim-0.8.orig/src/i18n.py gajim-0.8/src/i18n.py
--- gajim-0.8.orig/src/i18n.py	1970-01-01 01:00:00.000000000 +0100
+++ gajim-0.8/src/i18n.py	2005-08-19 13:05:59.485258744 +0200
@@ -0,0 +1,41 @@
+##	common/i18n.py
+##
+## Gajim Team:
+##  - Yann Le Boulanger <asterix@lagaule.org>
+##  - Vincent Hanquez <tab@snarc.org>
+##  - Nikos Kouremenos <kourem@gmail.com>
+##  - Dimitur Kirov <dkirov@gmail.com>
+##
+##	Copyright (C) 2003-2005 Gajim Team
+##
+## This program is free software; you can redistribute it and/or modify
+## it under the terms of the GNU General Public License as published
+## by the Free Software Foundation; version 2 only.
+##
+## This program is distributed in the hope that it will be useful,
+## but WITHOUT ANY WARRANTY; without even the implied warranty of
+## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+## GNU General Public License for more details.
+##
+
+APP='gajim'
+DIR='../po'
+
+import locale
+import gettext
+
+locale.setlocale(locale.LC_ALL, '')
+_translation = None
+
+def init():
+	global _translation
+	try:
+		_translation = gettext.translation(APP, DIR)
+	except IOError:
+		_translation = gettext.NullTranslations()
+
+def _(s):
+	if s == '':
+		return s
+	assert s
+	return _translation.gettext(s)