def _on_new_preferences(self, use_http, use_proxy, proxy_host, proxy_port,
use_auth, user, passwd, session_id, service,
server_host, server_port):
'''
called when the user press accept on the preferences dialog
'''
self.proxy = e3.Proxy(use_proxy, proxy_host, proxy_port, use_auth,
user, passwd)
self.session_id = session_id
self.use_http = use_http
self.server_host = server_host
self.server_port = server_port
self.on_preferences_changed(self.use_http, self.proxy, self.session_id,
service)
self._update_fields(self.cmb_account.get_active_text(), True)
def searchService(model, path, iter, user_data):
if (model.get(iter, 0)[0] == user_data[0]):
user_data[2].set_active(user_data[1])
return True
user_data[1] += 1
return False
i = 0
for combo in self._combo_session_list:
combo.get_model().foreach(searchService, [service, i, combo])
def __init__(self,
session,
cid,
host,
port,
account,
session_id,
p2p_input,
auth_id=None,
proxy=None,
use_http=False):
'''class constructor, create a socket and connect it to the specified
server'''
threading.Thread.__init__(self)
self.setDaemon(True)
self.use_http = use_http
if proxy is None:
self.proxy = e3.Proxy()
else:
self.proxy = proxy
self.cid = cid
self.host = host
self.port = port
self.session = session
self.account = account
self.auth_id = auth_id
self.session_id = session_id
self.socket = self._get_socket(host, port)
self.status = Conversation.STATUS_PENDING
self.started = False
# the last account to leave the conversation
self.last_member = None
self.pending_invites = []
# indicates if the first action made by the user to justify opening
# a new conversation has been made or not
self.first_action = False
self.p2p_input = p2p_input
# this queue receives a Command object
self.command_queue = Queue.Queue()
self._handlers = {}
self.members = []
# messages that are requested to be sent before we are ready to do it
# are stored here and sent when we stablish the conversation
self.pending_messages = []
# a dict that contains the tid where the message was sent and the
# message, when we receive an ack, we emit the message send succeed
# and remove it from the dict, if we get a NAK we remove it and emit
# the message send failed.
self.sent_messages = {}
self._set_handlers()
def _on_new_preferences(self, use_http, use_proxy, proxy_host, proxy_port,
use_auth, user, passwd, session_id, server_host, server_port):
'''
called when the user press accept on the preferences dialog
'''
self.proxy = e3.Proxy(use_proxy, proxy_host, proxy_port, use_auth, user, passwd)
self.session_id = session_id
self.use_http = use_http
self.server_host = server_host
self.server_port = server_port
self.on_preferences_changed(self.use_http, self.proxy, self.session_id)
def _get_proxy_settings(self):
'''return the values of the proxy settings as a e3.Proxy object
initialize the values on config if not exist'''
use_proxy = self.config.get_or_set('b_use_proxy', False)
use_proxy_auth = self.config.get_or_set('b_use_proxy_auth', False)
host = self.config.get_or_set('proxy_host', '')
port = self.config.get_or_set('proxy_port', '')
user = self.config.get_or_set('proxy_user', '')
passwd = self.config.get_or_set('proxy_passwd', '')
self.config.get_or_set('b_use_http', False)
return e3.Proxy(use_proxy, host, port, use_proxy_auth, user, passwd)
def new_preferences_cb(use_http, use_proxy, proxy_host, proxy_port,
use_auth, user, passwd, session_id, service,
server_host, server_port):
'''called when the user press accept on the preferences dialog'''
self.proxy = e3.Proxy(use_proxy, proxy_host,
proxy_port, use_auth, user, passwd)
self.server_host = server_host
self.server_port = server_port
account_email = str(self._widget_d['account_combo'].currentText())
if account_email != '':
self.config.d_user_service[account_email] = service
# to trigger eventual update of dp:
self._on_account_combo_text_changed(account_email)
self.on_preferences_changed(use_http, self.proxy, session_id,
service)
def __init__(self,
dest_ip='messenger.hotmail.com',
port_unused=1863,
dest_type='SB',
proxy=None):
'''class contructor, port_unused is unused (duh!) but there for
API compatibility with MsnSocket'''
threading.Thread.__init__(self)
self.setDaemon(True)
self.tid = 1
if proxy is None:
self.proxy = e3.Proxy()
else:
self.proxy = proxy
self.host = 'http://gateway.messenger.hotmail.com'
self.dest_type = dest_type
self.dest_ip = dest_ip
self.path = '/gateway/gateway.dll?Action=open&Server=' + \
self.dest_type + '&IP=' + self.dest_ip
self.session_id = None
self.timestamp = time.time()
if self.proxy.use_proxy:
proxy_info = {'host': self.proxy.host, 'port': self.proxy.port}
if self.proxy.use_auth:
proxy_info['user'] = self.proxy.user
proxy_info['pass'] = self.proxy.passwd
proxy_support = urllib2.ProxyHandler({"http" : \
"http://%(user)s:%(pass)s@%(host)s:%(port)s" % proxy_info})
else:
proxy_support = urllib2.ProxyHandler({"http" : \
"http://%(host)s:%(port)s" % proxy_info})
opener = urllib2.build_opener(proxy_support, urllib2.HTTPHandler)
# install it
urllib2.install_opener(opener)
self.input = Queue.Queue()
self.output = Queue.Queue()
self.setDaemon(True)
def __init__(self, app_name, session, proxy=None, use_http=False):
'''class constructor'''
e3.Worker.__init__(self, app_name, session)
self.host = session.DEFAULT_HOST
self.port = session.DEFAULT_PORT
if proxy is None:
self.proxy = e3.Proxy()
else:
self.proxy = proxy
self.use_http = use_http
self.socket = self._get_socket()
self.in_login = False
# the class used to create the conversation sockets, since sockets
# or http method can be used
self.last_ping_response = 0.0
self._login_handlers = None
self._common_handlers = None
self.start_time = None
self._set_handlers()
self.conversations = {}
self.transfers = {}
# contains the tid when the switchboard was requested as key and the
# account that should be invited when we get the switchboard as value
self.pending_conversations = {}
# this list contains all the conversation ids that are not still
# opened, it is used to store pending messages to be sent when
# the conversation is ready to send messages
self.pending_cids = []
# contains a pending cid as key and a list of messages as value
self.pending_messages = {}
self.p2p = Queue.Queue() # p2p manager input queue
self.msg_manager = msgs.Manager(session) # msg manager
self.msg_manager.start()
def response_cb(response):
'''called on any response (close, accept, cancel) if accept
get the new values and call callback with those values'''
if response == gui.stock.ACCEPT:
use_http = http_chk.isChecked()
use_ipv6 = ipv6_chk.isChecked()
use_proxy = proxy_chk.isChecked()
use_auth = auth_chk.isChecked()
proxy_host = str(proxy_host_edit.text())
proxy_port = str(proxy_port_edit.text())
server_host = str(server_host_edit.text())
server_port = str(server_port_edit.text())
user = str(user_edit.text())
passwd = str(pwd_edit.text())
proxy = e3.Proxy(use_proxy, proxy_host, proxy_port, use_auth,
user, passwd)
callback(use_http, use_ipv6, proxy, service, server_host,
server_port)
dialog.hide()
def __init__(self,
callback,
on_preferences_changed,
config,
config_dir,
config_path,
proxy=None,
use_http=None,
use_ipv6=None,
session_id=None,
no_autologin=False):
'''constructor'''
self.callback = callback
self.on_preferences_changed = on_preferences_changed
self.config = config
self.config_dir = config_dir
self.config_path = config_path
self.no_autologin = no_autologin
# the id of the default extension that handles the session
# used to select the default session on the preference dialog
self.use_http = use_http
self.use_ipv6 = use_ipv6
self.session_id = session_id
self.proxy = proxy or e3.Proxy()
self.server_host = None
self.server_port = None
self.account_uuid = str(uuid.uuid4())
self.config.get_or_set('service', 'msn')
self.remembers = self.config.get_or_set('d_remembers', {})
self.config.get_or_set('d_user_service', {})
self.status = self.config.get_or_set('d_status', {})
self.uuids = self.config.get_or_set('d_uuids', {})
account = self.config.get_or_set('last_logged_account', '')
self._setup_account(account)
self.services = {}
self.service2id = {}
self._setup_services(session_id)
def __init__(self,
callback,
on_preferences_changed,
config,
config_dir,
config_path,
proxy=None,
use_http=None,
session_id=None,
cancel_clicked=False,
no_autologin=False):
LoginBase.__init__(self, callback)
self.config = config
self.config_dir = config_dir
self.config_path = config_path
self.callback = callback
self.cancel_clicked = cancel_clicked
self.on_preferences_changed = on_preferences_changed
self.no_autologin = no_autologin
# the id of the default extension that handles the session
# used to select the default session on the preference dialog
self.use_http = use_http
self.session_id = session_id
account = self.config.get_or_set('last_logged_account', '')
self.config.get_or_set('service', 'msn')
self.remembers = self.config.get_or_set('d_remembers', {})
self.config.get_or_set('d_user_service', {})
self.status = self.config.get_or_set('d_status', {})
self.accounts = self.config.d_accounts
self.b_connect.connect('clicked', self._on_connect_clicked)
self._reload_account_list()
self.__combo_session_list = []
if proxy is None:
self.proxy = e3.Proxy()
else:
self.proxy = proxy
self.services = {}
if session_id is not None:
for ext_id, ext in extension.get_extensions('session').iteritems():
for service_name, service_data in ext.SERVICES.iteritems():
self.services[service_name] = service_data
if session_id == ext_id and self.config.service in ext.SERVICES:
self.server_host = ext.SERVICES[
self.config.service]['host']
self.server_port = ext.SERVICES[
self.config.service]['port']
break
else:
self.config.service = 'msn'
self.server_host = 'messenger.hotmail.com'
self.server_port = '1863'
else:
self.config.service = 'msn'
self.server_host = 'messenger.hotmail.com'
self.server_port = '1863'
avatar_path = self.config_dir.join(self.server_host, account,
'avatars', 'last')
self.avatar.set_from_file(avatar_path)
self.nicebar.hide()
self.throbber.hide()
self.label_timer.hide()
self.b_cancel.hide()
if account != '':
self.cmb_account.get_children()[0].set_text(account)
if not self.cancel_clicked:
self._check_autologin()
self._show_sessions()
def __init__(self, callback, on_preferences_changed,
config, config_dir, config_path, proxy=None,
use_http=None, session_id=None):
gtk.Alignment.__init__(self, xalign=0.5, yalign=0.5, xscale=0.0,
yscale=1.0)
self.config = config
self.config_dir = config_dir
self.config_path = config_path
self.callback = callback
self.on_preferences_changed = on_preferences_changed
# the id of the default extension that handles the session
# used to select the default session on the preference dialog
self.use_http = use_http
self.session_id = session_id
account = self.config.get_or_set('last_logged_account', '')
self.remembers = self.config.get_or_set('d_remembers', {})
self.status = self.config.get_or_set('d_status',{})
self.accounts = self.config.d_accounts
if proxy is None:
self.proxy = e3.Proxy()
else:
self.proxy = proxy
self.dialog = extension.get_default('dialog')
Avatar = extension.get_default('avatar')
NiceBar = extension.get_default('nice bar')
if session_id is not None:
for ext_id, ext in extension.get_extensions('session').iteritems():
if session_id == ext_id:
self.server_host = ext.DEFAULT_HOST
self.server_port = ext.DEFAULT_PORT
else:
self.server_host = extension.get_default('session').DEFAULT_HOST
self.server_port = extension.get_default('session').DEFAULT_PORT
else:
self.server_host = extension.get_default('session').DEFAULT_HOST
self.server_port = extension.get_default('session').DEFAULT_PORT
self.liststore = gtk.ListStore(gobject.TYPE_STRING, gtk.gdk.Pixbuf)
completion = gtk.EntryCompletion()
completion.set_model(self.liststore)
pixbufcell = gtk.CellRendererPixbuf()
completion.pack_start(pixbufcell)
completion.add_attribute(pixbufcell, 'pixbuf', 1)
completion.set_text_column(0)
completion.set_inline_selection(True)
self.pixbuf = utils.safe_gtk_pixbuf_load(gui.theme.user)
self._reload_account_list()
self.cmb_account = gtk.ComboBoxEntry(self.liststore, 0)
self.cmb_account.get_children()[0].set_completion(completion)
self.cmb_account.get_children()[0].connect('key-press-event',
self._on_account_key_press)
self.cmb_account.connect('changed',
self._on_account_changed)
self.btn_status = StatusButton.StatusButton()
self.btn_status.set_status(e3.status.ONLINE)
self.txt_password = gtk.Entry()
self.txt_password.set_visibility(False)
self.txt_password.connect('key-press-event',
self._on_password_key_press)
self.txt_password.connect('changed', self._on_password_changed)
self.txt_password.set_sensitive(False)
pix_account = utils.safe_gtk_pixbuf_load(gui.theme.user)
pix_password = utils.safe_gtk_pixbuf_load(gui.theme.password)
self.avatar = Avatar()
avatar_path = self.config_dir.join(self.server_host, account, 'avatars', 'last')
self.avatar.set_from_file(avatar_path)
self.remember_account = gtk.CheckButton(_('Remember me'))
self.remember_password = gtk.CheckButton(_('Remember password'))
self.auto_login = gtk.CheckButton(_('Auto-login'))
self.remember_account.connect('toggled',
self._on_remember_account_toggled)
self.remember_password.connect('toggled',
self._on_remember_password_toggled)
self.auto_login.connect('toggled',
self._on_auto_login_toggled)
self.remember_account.set_sensitive(False)
self.remember_password.set_sensitive(False)
self.auto_login.set_sensitive(False)
self.forget_me = gtk.Button()
self.forget_me.set_tooltip_text(_('Delete user'))
forget_img = gtk.image_new_from_stock(gtk.STOCK_CANCEL, gtk.ICON_SIZE_MENU)
self.forget_me.set_image(forget_img)
self.forget_me.set_relief(gtk.RELIEF_NONE)
self.forget_me.set_border_width(0)
self.forget_me.connect('clicked', self._on_forget_me_clicked)
self.forget_me.set_sensitive(False)
hboxremember = gtk.HBox(spacing=2)
hboxremember.pack_start(self.remember_account, False, False)
vbox_remember = gtk.VBox(spacing=4)
vbox_remember.set_border_width(8)
vbox_remember.pack_start(hboxremember)
vbox_remember.pack_start(self.remember_password)
vbox_remember.pack_start(self.auto_login)
self.b_connect = gtk.Button(stock=gtk.STOCK_CONNECT)
self.b_connect.connect('clicked', self._on_connect_clicked)
self.b_connect.set_border_width(8)
self.b_connect.set_sensitive(False)
vbox = gtk.VBox()
hbox_account = gtk.HBox(spacing=6)
img_accountpix = gtk.Image()
img_accountpix.set_from_pixbuf(utils.scale_nicely(pix_account))
hbox_account.pack_start(img_accountpix, False)
hbox_account.pack_start(self.cmb_account, True, True)
hbox_account.pack_start(self.forget_me, False)
hbox_password = gtk.HBox(spacing=6)
img_password = gtk.Image()
img_password.set_from_pixbuf(utils.scale_nicely(pix_password))
hbox_password.pack_start(img_password, False)
hbox_password.pack_start(self.txt_password, True, True)
hbox_password.pack_start(self.btn_status, False)
vbox_entries = gtk.VBox(spacing=12)
vbox_entries.set_border_width(8)
vbox_entries.pack_start(hbox_account)
vbox_entries.pack_start(hbox_password)
self.b_preferences = gtk.Button()
self.img_preferences = gtk.image_new_from_stock(gtk.STOCK_PREFERENCES,
gtk.ICON_SIZE_MENU)
self.img_preferences.set_sensitive(False)
self.b_preferences.set_image(self.img_preferences)
self.b_preferences.set_relief(gtk.RELIEF_NONE)
self.b_preferences.connect('enter-notify-event',
self._on_preferences_enter)
self.b_preferences.connect('leave-notify-event',
self._on_preferences_leave)
self.b_preferences.connect('clicked',
self._on_preferences_selected)
self.nicebar = NiceBar()
al_vbox_entries = gtk.Alignment(xalign=0.5, yalign=0.5, xscale=0.2,
yscale=0.0)
al_vbox_remember = gtk.Alignment(xalign=0.5, yalign=0.5, xscale=0.0,
yscale=0.2)
al_button = gtk.Alignment(xalign=0.5, yalign=0.5, xscale=0.20)
al_account = gtk.Alignment(xalign=0.5, yalign=0.5, xscale=0.0,
yscale=0.0)
al_preferences = gtk.Alignment(xalign=1.0, yalign=0.5)
al_vbox_entries.add(vbox_entries)
al_vbox_remember.add(vbox_remember)
al_button.add(self.b_connect)
al_account.add(self.avatar)
al_preferences.add(self.b_preferences)
vbox.pack_start(self.nicebar, False)
vbox.pack_start(al_account, True, False)
vbox.pack_start(al_vbox_entries, True, True)
vbox.pack_start(al_vbox_remember, True, False)
vbox.pack_start(al_button, True, True)
vbox.pack_start(al_preferences, False)
self.add(vbox)
vbox.show_all()
self.nicebar.hide()
if account != '':
self.cmb_account.get_children()[0].set_text(account)
