def __init__(self, session, radio=False, use_tabs=False):
'''constructor'''
ExtensionListTab.__init__(self, session, radio, use_tabs)
self.updated_amount = 0
self.config_dir = e3.common.ConfigDir('emesene2')
self.list_types = ['plugins', 'themes']
self.collections = \
{
'plugins':
{
'supported': extension.get_and_instantiate(
'supported plugins collection',
self.config_dir.join('plugins')),
'community': extension.get_and_instantiate(
'community plugins collection',
self.config_dir.join('plugins'))
},
'themes':
{
'supported': extension.get_and_instantiate(
'supported themes collection',
self.config_dir.join('themes')),
'community': extension.get_and_instantiate(
'community themes collection',
self.config_dir.join('themes'))
}
}
def _new_session(self, account=None):
'''create a new session object'''
if self.session:
self.close_session(False)
self.session = extension.get_and_instantiate('session')
self.session.cb_gui_send_message = extension.get_and_instantiate('send message callback handler')
self.session.cb_gui_recv_message = extension.get_and_instantiate('receive message callback handler')
# if you add a signal here, add it on _remove_subscriptions
signals = self.session.signals
signals.close.subscribe(self.on_close)
signals.login_succeed.subscribe(self.on_login_succeed)
signals.login_failed.subscribe(self.on_login_failed)
signals.contact_list_ready.subscribe(self.on_contact_list_ready)
signals.conv_first_action.subscribe(self.on_new_conversation)
signals.disconnected.subscribe(self.on_disconnected)
signals.picture_change_succeed.subscribe(self.on_picture_change_succeed)
#let's start dbus and unity launcher
self.dbus_ext.set_new_session(self.session, self.window)
if self.unity_launcher is not None:
self.unity_launcher.set_session(self.session)
def __init__(self, session, on_new_conversation, on_close, on_disconnect_cb):
"""class constructor"""
gtk.VBox.__init__(self)
self.session = session
UserPanel = extension.get_default("user panel")
ContactList = extension.get_default("contact list")
self.below_menu = extension.get_and_instantiate("below menu", self)
self.below_panel = extension.get_and_instantiate("below panel", self)
self.below_userlist = extension.get_and_instantiate("below userlist", self)
self.contact_list = ContactList(session)
scroll = gtk.ScrolledWindow()
scroll.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
scroll.set_shadow_type(gtk.SHADOW_IN)
scroll.set_border_width(1)
self.on_new_conversation = on_new_conversation
self.on_close = on_close
self.on_disconnect_cb = on_disconnect_cb
self.session.signals.contact_attr_changed.subscribe(self._on_contact_attr_changed)
self.menu = None
self.contact_menu = None
self.contact_menu = None
self.group_menu = None
self._build_menus()
self.panel = UserPanel(session)
self.panel.nick.connect("text-changed", self._on_nick_changed)
self.panel.message.connect("text-changed", self._on_message_changed)
self.panel.search.connect("toggled", self._on_search_toggled)
self.panel.enabled = False
self.entry = gtk.Entry()
self.entry.connect("changed", self._on_entry_changed)
self.entry.connect("key-press-event", self._on_entry_key_press)
self.pack_start(self.menu, False)
self.pack_start(self.below_menu, False)
self.pack_start(self.panel, False)
self.pack_start(self.below_panel, False)
self.pack_start(scroll, True, True)
self.pack_start(self.below_userlist, False)
self.pack_start(self.entry, False)
self.contact_list.contact_selected.subscribe(self._on_contact_selected)
self.contact_list.group_selected.subscribe(self._on_group_selected)
self.contact_list.contact_menu_selected.subscribe(self._on_contact_menu_selected)
self.contact_list.group_menu_selected.subscribe(self._on_group_menu_selected)
scroll.add(self.contact_list)
scroll.show_all()
if self.session.config.b_show_userpanel:
self.panel.hide()
self.session.config.subscribe(self._on_show_userpanel_changed, "b_show_userpanel")
def _parse_commandline(self):
'''parse command line options'''
options = optionprovider.PluggableOptionParser.get_parsing()[0]
debugger.init(debuglevel=options.debuglevel)
if options.version:
print "Current Emesene Version: " + Info.EMESENE_VERSION
print "Last Stable Version: " + Info.EMESENE_LAST_STABLE
print "\n" + Info.EMESENE_WEBSITE
sys.exit(0)
#needed to check for autologin
self.emesene_is_running = False
try:
if os.name == 'posix':
from SingleInstance import SingleInstancePosix as SingleInstance
else:
from SingleInstance import SingleInstanceWin32 as SingleInstance
self.single_instance = SingleInstance()
if self.single_instance.emesene_is_running():
self.emesene_is_running = True
# try to show the instance that's already running
if options.single_instance:
print "Another instance of emesene is already running."
self.single_instance.show()
extension.get_and_instantiate('quit')
except ImportError:
pass
if options.minimized:
self.minimize = True
def _setup(self):
"""register core extensions"""
extension.category_register("session", dummy.Session, single_instance=True)
if xmpp is not None:
extension.register("session", xmpp.Session)
extension.register("session", dummy.Session)
if webqq is not None:
extension.register("session", webqq.Session)
extension.register("session", dummy.Session)
if papylib is not None:
extension.register("session", papylib.Session)
extension.set_default("session", papylib.Session)
else:
extension.set_default("session", dummy.Session)
# external API stuff
self.dbus_ext = extension.get_and_instantiate("external api")
self.network_checker = extension.get_and_instantiate("network checker")
self.unity_launcher = extension.get_and_instantiate("unity launcher")
extension.category_register("sound", e3.common.Sounds.SoundPlayer, None, True)
extension.category_register("notification", e3.common.notification.Notification)
extension.category_register("history exporter", e3.Logger.save_logs_as_txt)
extension.register("history exporter", e3.Logger.save_logs_as_xml)
if self.config.session is None:
default_id = extension.get_category("session").default_id
self.config.session = default_id
else:
default_id = self.config.session
extension.set_default_by_id("session", default_id)
def on_login_succeed(self):
'''callback called on login succeed'''
self._save_login_dimensions()
self.config.save(self.config_path)
plugin_manager = get_pluginmanager()
plugin_manager.scan_directory('plugins')
plugin_dir = self.config_dir.join('plugins')
if not os.path.exists(plugin_dir):
os.makedirs(plugin_dir)
plugin_manager.scan_directory(plugin_dir)
self.draw_main_screen()
self.session.config.get_or_set('l_active_plugins', [])
for plugin in self.session.config.l_active_plugins:
plugin_manager.plugin_start(plugin, self.session)
# hack: where do we start this? how do we generalize for other
# extensions?
if plugin == "music":
extension.get_and_instantiate('listening to',
self.window.content)
self.set_default_extensions_from_config()
self._sync_emesene1()
self.logged_in = True
if self.network_checker is not None:
self.network_checker.set_new_session(self.session)
def on_preferences_selected(self):
"""called when the preference button is selected"""
instance = extension.get_and_instantiate("preferences", self.session)
if self.session is not instance.session:
extension.delete_instance("preferences")
instance = extension.get_and_instantiate("preferences", self.session)
instance.show()
instance.present()
def on_preferences_selected(self):
'''called when the preference button is selected'''
instance = extension.get_and_instantiate('preferences', self.session)
if self.session is not instance.session:
extension.delete_instance('preferences')
instance = extension.get_and_instantiate('preferences', self.session)
instance.show()
instance.present()
def __init__(self, session):
"""constructor"""
self.session = session
self.instance = extension.get_and_instantiate('preferences', self.session)
if self.session is not self.instance.session:
extension.delete_instance('preferences')
self.instance = extension.get_and_instantiate('preferences', self.session)
self.page = DownloadExtension(self.session)
def _setup(self):
'''register core extensions'''
extension.category_register('session', dummy.Session,
single_instance=True)
#extension.category_register('session', msn.Session,
# single_instance=True)
if jabber is not None:
extension.register('session', jabber.Session)
extension.register('session', dummy.Session)
#extension.register('session', msn.Session)
if papylib is not None:
extension.register('session', papylib.Session)
extension.set_default('session', papylib.Session)
else:
extension.set_default('session', dummy.Session)
#DBus extension stuffs
if DBusController is not None:
extension.category_register('external api', DBusController)
extension.set_default('external api', DBusController)
self.dbus_ext = extension.get_and_instantiate('external api')
else:
self.dbus_ext = None
if DBusNetworkChecker is not None:
extension.category_register('network checker', DBusNetworkChecker)
extension.set_default('network checker', DBusNetworkChecker)
self.network_checker = extension.get_and_instantiate(
'network checker')
else:
self.network_checker = None
if UnityLauncher is not None:
extension.category_register('unity launcher', UnityLauncher)
extension.set_default('unity launcher', UnityLauncher)
self.unity_launcher = extension.get_and_instantiate(
'unity launcher', self.close_session)
else:
self.unity_launcher = None
extension.category_register('sound', e3.common.Sounds.SoundPlayer,
None, True)
extension.category_register('notification',
e3.common.notification.Notification)
extension.category_register('history exporter',
e3.Logger.save_logs_as_txt)
if self.config.session is None:
default_id = extension.get_category('session').default_id
self.config.session = default_id
else:
default_id = self.config.session
extension.set_default_by_id('session', default_id)
def start(self, session):
'''start the plugin'''
self.session = session
self.running = True
self.category_register()
self.extensions_register()
extension.get_and_instantiate(CATEGORY, session)
return True
def on_preferences_selected(self):
"""called when the preference button is selected"""
self.preferences = extension.get_and_instantiate("preferences", self.session)
if self.session is not self.preferences.session:
self.preferences.remove_subscriptions()
extension.delete_instance("preferences")
self.preferences = extension.get_and_instantiate("preferences", self.session)
self.preferences.show()
self.preferences.present()
def _setup(self):
'''register core extensions'''
#extension.category_register('session', dummy.Session,
# single_instance=True)
#if Info.EMESENE_VERSION.endswith("dev"):
# extension.register('session', dummy.Session)
#if webqq is not None:
# extension.register('session', webqq.Session)
# extension.set_default('session', webqq.Session)
#if xmpp is not None:
# extension.register('session', xmpp.Session)
# extension.set_default('session', xmpp.Session)
if whatsapp is not None:
extension.register('session', whatsapp.Session)
extension.set_default('session', whatsapp.Session)
#if papylib is not None:
# extension.register('session', papylib.Session)
# extension.set_default('session', papylib.Session)
#external API stuff
self.dbus_ext = extension.get_and_instantiate('external api')
self.network_checker = extension.get_and_instantiate(
'network checker')
self.unity_launcher = extension.get_and_instantiate('unity launcher')
extension.category_register('sound', e3.common.Sounds.SoundPlayer,
None, True)
extension.category_register('notification',
e3.common.notification.Notification)
extension.category_register('history exporter', e3.Logger.ExporterTxt)
extension.register('history exporter', e3.Logger.ExporterXml)
extension.register('history exporter', e3.Logger.ExporterHtml)
extension.register('history exporter', e3.Logger.ExporterCsv)
extension.register('history exporter', e3.Logger.ExporterJSON)
# ui callbacks for plugins
extension.category_register('send message callback handler',
e3.common.PriorityList, single_instance=True)
extension.category_register('receive message callback handler',
e3.common.PriorityList, single_instance=True)
if self.config.session is None:
default_id = extension.get_category('session').default_id
self.config.session = default_id
else:
default_id = self.config.session
extension.set_default_by_id('session', default_id)
def close_session(self, do_exit=True, server_disconnected=False):
'''close session'''
# prevent preference window from staying open and breaking things
pref = extension.get_instance('preferences')
if pref:
pref.hide()
# close all dialogs that are open
extension.get_default('dialog').close_all()
self._remove_subscriptions()
if server_disconnected:
for conv_manager in self.conversations:
conv_manager.close_session()
self.conv_manager_available = True # update with new session
else:
for conv_manager in self.conversations:
conv_manager.close_all()
if self.session:
self.session.stop_mail_client()
self.session.quit()
if self.session is not None:
self._save_application_language()
self.session.save_extensions_config()
self._save_login_dimensions()
if self.session and self.logged_in:
self.session.save_config()
self.session = None
self.logged_in = False
self.config.save(self.config_path)
#http://www.lshift.net/blog/2008/11/14/tracing-python-memory-leaks
#http://mg.pov.lt/objgraph/
# install python-objgraph
# also you can run emesene in pdb: pdb ./emesene.py
# then 'r' and CTRL+C when you need the shell.
#import objgraph
##objgraph.show_most_common_types()
#objgraph.show_growth()
if do_exit:
extension.get_and_instantiate('quit')
if os.name == "nt":
os._exit(0)
def start(self, session):
"""start the plugin"""
self.session = session
extension.category_register(CATEGORY, songretriever.BaseMusicHandler, songretriever.BaseMusicHandler, True)
self.extensions_register()
extension.get_and_instantiate(CATEGORY, session)
if hasattr(extension, "unregister"):
extension.register("userpanel button", MusicButton.MusicButton, force_default=True)
else:
extension.register("userpanel button", MusicButton.MusicButton)
return True
def _setup(self):
"""register core extensions"""
extension.category_register("session", dummy.Session, single_instance=True)
# extension.category_register('session', msn.Session,
# single_instance=True)
if jabber is not None:
extension.register("session", jabber.Session)
extension.register("session", dummy.Session)
# extension.register('session', msn.Session)
if papylib is not None:
extension.register("session", papylib.Session)
extension.set_default("session", papylib.Session)
else:
extension.set_default("session", dummy.Session)
# DBus extension stuffs
if DBusController is not None:
extension.category_register("external api", DBusController)
extension.set_default("external api", DBusController)
self.dbus_ext = extension.get_and_instantiate("external api")
else:
self.dbus_ext = None
extension.category_register("sound", e3.common.play_sound.play)
extension.category_register("notification", e3.common.notification.Notification)
extension.category_register("history exporter", e3.Logger.save_logs_as_txt)
if self.config.session is None:
default_id = extension.get_category("session").default_id
self.config.session = default_id
else:
default_id = self.config.session
extension.set_default_by_id("session", default_id)
def _setup(self):
'''register core extensions'''
extension.category_register('session', dummy.Session, single_instance=True)
#extension.category_register('session', msn.Session,
# single_instance=True)
extension.register('session', jabber.Session)
extension.register('session', dummy.Session)
#extension.register('session', msn.Session)
if papylib is not None:
extension.register('session', papylib.Session)
extension.set_default('session', papylib.Session)
else:
extension.set_default('session', dummy.Session)
#DBus extension stuffs
extension.category_register('external api', DBusController)
extension.set_default('external api', DBusController)
self.dbus_ext = extension.get_and_instantiate('external api')
extension.category_register('sound', e3.common.play_sound.play)
extension.category_register('notification',
e3.common.notification.Notification)
extension.category_register('history exporter',
e3.Logger.save_logs_as_txt)
if self.config.session is None:
default_id = extension.get_category('session').default_id
self.config.session = default_id
else:
default_id = self.config.session
extension.set_default_by_id('session', default_id)
def __init__(self, session, cid, update_window, members=None):
'''constructor'''
self.update_window = update_window
self.session = session
self.caches = e3.cache.CacheManager(self.session.config_dir.base_dir)
self.emcache = self.caches.get_emoticon_cache(self.session.account.account)
self.cid = float(cid)
self.icid = self.cid
self.formatter = e3.common.MessageFormatter()
self._header_visible = True
self._image_visible = True
self._toolbar_visible = True
self._message_waiting = False
buffer_size = 10
self.messages = RingBuffer(max=buffer_size)
self.message_offset = 0
if members is None:
self.members = []
else:
self.members = members
self._style = None
self.conv_status = ConversationStatus.ConversationStatus(self.session.config)
# the base class should override this attributes
self.info = None
self.input = None
self.output = None
self.soundPlayer = extension.get_and_instantiate('sound', session)
def __init__(self, session, cid, update_window, members=None):
"""constructor"""
self.update_window = update_window
self.session = session
self.caches = e3.cache.CacheManager(self.session.config_dir.base_dir)
self.emcache = self.caches.get_emoticon_cache(self.session.account.account)
self.cid = float(cid)
self.icid = self.cid
self.formatter = e3.common.MessageFormatter(session.contacts.me)
self.first = True
self._header_visible = True
self._image_visible = True
self._toolbar_visible = True
self._message_waiting = True
buffer_size = session.config.get_or_set("i_msg_history_size", 5)
self.messages = RingBuffer(max=buffer_size)
self.message_offset = 0
if members is None:
self.members = []
else:
self.members = members
self._style = None
# the base class should override this attributes
self.info = None
self.input = None
self.output = None
self.soundPlayer = extension.get_and_instantiate("sound", session)
def _replace_below_userlist(self):
self.remove(self.below_userlist)
self.below_userlist = extension.get_and_instantiate('below userlist', self)
self.pack_start(self.below_userlist, False)
pos = len(self.get_children()) - 1
self.reorder_child(self.below_userlist, pos)
self.below_userlist.show()
def __init__(self, session):
"""
Class Constructor
"""
self.session = session
self.session.config.get_or_set('b_notify_contact_online', True)
self.session.config.get_or_set('b_notify_contact_offline', True)
self.session.config.get_or_set('b_notify_receive_message', True)
self.session.config.get_or_set('b_notify_typing', False)
self.session.config.get_or_set('b_notify_when_focussed', False)
self.session.config.get_or_set('b_notify_only_when_available', True)
self.notifier = extension.get_default('notificationGUI')
self.picture_factory = extension.get_default('notificationImage')
self.sound_player = extension.get_and_instantiate('sound', session)
if self.session:
self.session.signals.conv_message.subscribe(
self._on_message)
self.session.signals.user_typing.subscribe(
self._on_user_typing)
self.session.signals.contact_attr_changed.subscribe(
self._on_contact_attr_changed)
self.session.signals.mail_received.subscribe(
self._on_mail_received)
self.session.signals.filetransfer_completed.subscribe(
self._on_filetransfer_completed)
self.session.signals.filetransfer_canceled.subscribe(
self._on_filetransfer_canceled)
self.session.signals.filetransfer_invitation.subscribe(
self._on_filetransfer_invitation)
self.notify_online = False
self.last_online = None
def on_filetransfer_invitation(self, transfer, conv_id):
""" called when a new file transfer is issued """
if self._conv_id != conv_id:
return
self.transferw = extension.get_and_instantiate("filetransfer widget", self._session, transfer)
self.transferw.show()
def _setup(self):
'''register core extensions'''
extension.category_register('session',
dummy.Session,
single_instance=True)
#extension.category_register('session', msn.Session,
# single_instance=True)
if jabber is not None:
extension.register('session', jabber.Session)
extension.register('session', dummy.Session)
#extension.register('session', msn.Session)
if papylib is not None:
extension.register('session', papylib.Session)
extension.set_default('session', papylib.Session)
else:
extension.set_default('session', dummy.Session)
#DBus extension stuffs
if DBusController is not None:
extension.category_register('external api', DBusController)
extension.set_default('external api', DBusController)
self.dbus_ext = extension.get_and_instantiate('external api')
else:
self.dbus_ext = None
if DBusNetworkChecker is not None:
extension.category_register('network checker', DBusNetworkChecker)
extension.set_default('network checker', DBusNetworkChecker)
self.network_checker = extension.get_and_instantiate(
'network checker')
else:
self.network_checker = None
extension.category_register('sound', e3.common.play_sound.play)
extension.category_register('notification',
e3.common.notification.Notification)
extension.category_register('history exporter',
e3.Logger.save_logs_as_txt)
if self.config.session is None:
default_id = extension.get_category('session').default_id
self.config.session = default_id
else:
default_id = self.config.session
extension.set_default_by_id('session', default_id)
def close_session(self, do_exit=True, server_disconnected=False):
'''close session'''
# prevent preference window from staying open and breaking things
pref = extension.get_instance('preferences')
if pref:
pref.hide()
# close all dialogs that are open
extension.get_default('dialog').close_all()
self._remove_subscriptions()
if server_disconnected:
for conv_manager in self.conversations:
conv_manager.close_session()
self.conv_manager_available = True # update with new session
else:
for conv_manager in self.conversations:
conv_manager.close_all()
if self.session:
self.session.stop_mail_client()
self.session.quit()
self.window.on_disconnect(self.close_session)
if self.session is not None:
self._save_application_language()
self.session.save_extensions_config()
self._save_login_dimensions()
if self.session and self.logged_in:
self.session.save_config()
self.session = None
self.logged_in = False
self.config.save(self.config_path)
if do_exit:
if self.tray_icon is not None:
self.tray_icon.set_visible(False)
extension.get_and_instantiate('quit')
if os.name == "nt":
os._exit(0)
def __init__(self):
Gtk.CellView.__init__(self)
self._model = Gtk.ListStore(str)
self.set_model(self._model)
self.crt = extension.get_and_instantiate('nick renderer')
self.prepare_column()
self._text = ""
extension.subscribe(self._on_nick_renderer_changed, 'nick renderer')
def on_filetransfer_invitation(self, transfer, conv_id):
''' called when a new file transfer is issued '''
if self.icid != conv_id:
return
self.transferw = extension.get_and_instantiate('filetransfer widget',
self.session, transfer)
self.transferw.show()
def _replace_below_userlist(self):
self.remove(self.below_userlist)
self.below_userlist = extension.get_and_instantiate(
'below userlist', self)
self.pack_start(self.below_userlist, False)
pos = len(self.get_children()) - 1
self.reorder_child(self.below_userlist, pos)
self.below_userlist.show()
def on_filetransfer_invitation(self, transfer, conv_id):
''' called when a new file transfer is issued '''
if self.icid != conv_id:
return
self.transferw = extension.get_and_instantiate('filetransfer widget',
self.session, transfer)
self.transferw.show()
def __init__(self):
Gtk.CellView.__init__(self)
self._model = Gtk.ListStore(str)
self.set_model(self._model)
self.crt = extension.get_and_instantiate('nick renderer')
self.prepare_column()
self._text = ""
extension.subscribe(self._on_nick_renderer_changed, 'nick renderer')
def on_login_succeed(self):
'''callback called on login succeed'''
self._save_login_dimensions()
self.config.save(self.config_path)
plugin_manager = get_pluginmanager()
plugin_manager.scan_directory('plugins')
self.draw_main_screen()
for plugin in self.session.config.l_active_plugins:
plugin_manager.plugin_start(plugin, self.session)
# hack: where do we start this? how do we generalize for other
# extensions?
if plugin == "music":
extension.get_and_instantiate('listening to',
self.window.content)
self.set_default_extensions_from_config()
def _setup_plugins(self):
plugin_manager = get_pluginmanager()
plugin_manager.scan_directory('plugins')
plugin_dir = self.config_dir.join('plugins')
if not os.path.exists(plugin_dir):
os.makedirs(plugin_dir)
plugin_manager.scan_directory(plugin_dir)
self.session.config.get_or_set('l_active_plugins', [])
for plugin in self.session.config.l_active_plugins:
plugin_manager.plugin_start(plugin, self.session)
# hack: where do we start this? how do we generalize for other
# extensions?
if plugin == "music" and self.window.content != None:
extension.get_and_instantiate('listening to',
self.window.content)
self.set_default_extensions_from_config()
def __init__(self):
Gtk.CellView.__init__(self)
self._model = Gtk.ListStore(str)
self.set_model(self._model)
self.crt = extension.get_and_instantiate('nick renderer')
self.crt.set_property('ellipsize', Pango.ELLIPSIZE_END)
self.pack_start(self.crt, False)
self.add_attribute(self.crt, 'markup', 0)
self._text = ""
def close_session(self, do_exit=True, server_disconnected=False):
'''close session'''
# prevent preference window from staying open and breaking things
pref = extension.get_instance('preferences')
if pref:
pref.hide()
# close all dialogs that are open
extension.get_default('dialog').close_all()
self._remove_subscriptions()
if server_disconnected:
for conv_manager in self.conversations:
conv_manager.close_session()
self.conv_manager_available = True # update with new session
else:
for conv_manager in self.conversations:
conv_manager.close_all()
if self.session:
self.session.stop_mail_client()
self.session.quit()
self.window.on_disconnect(self.close_session)
self._save_application_language()
if self.session is not None:
self.session.save_extensions_config()
self._save_login_dimensions()
if self.session and self.logged_in:
self.session.save_config()
self.session = None
self.logged_in = False
self.config.save(self.config_path)
if do_exit:
if self.tray_icon is not None:
self.tray_icon.set_visible(False)
extension.get_and_instantiate('quit')
def _setup_plugins(self):
plugin_manager = get_pluginmanager()
plugin_manager.scan_directory('plugins')
plugin_dir = self.config_dir.join('plugins')
if not os.path.exists(plugin_dir):
os.makedirs(plugin_dir)
plugin_manager.scan_directory(plugin_dir)
self.session.config.get_or_set('l_active_plugins', [])
for plugin in self.session.config.l_active_plugins:
plugin_manager.plugin_start(plugin, self.session)
# hack: where do we start this? how do we generalize for other
# extensions?
if plugin == "music" and self.window.content != None:
extension.get_and_instantiate('listening to',
self.window.content)
self.set_default_extensions_from_config()
self.window.content.replace_extensions()
def _setup(self):
'''register core extensions'''
extension.category_register('session', dummy.Session,
single_instance=True)
extension.register('session', dummy.Session)
if webqq is not None:
extension.register('session', webqq.Session)
extension.set_default('session', webqq.Session)
if xmpp is not None:
extension.register('session', xmpp.Session)
extension.set_default('session', xmpp.Session)
if papylib is not None:
extension.register('session', papylib.Session)
extension.set_default('session', papylib.Session)
#external API stuff
self.dbus_ext = extension.get_and_instantiate('external api')
self.network_checker = extension.get_and_instantiate(
'network checker')
self.unity_launcher = extension.get_and_instantiate('unity launcher')
extension.category_register('sound', e3.common.Sounds.SoundPlayer,
None, True)
extension.category_register('notification',
e3.common.notification.Notification)
extension.category_register('history exporter', e3.Logger.ExporterTxt)
extension.register('history exporter', e3.Logger.ExporterXml)
extension.register('history exporter', e3.Logger.ExporterHtml)
extension.register('history exporter', e3.Logger.ExporterCsv)
extension.register('history exporter', e3.Logger.ExporterJSON)
if self.config.session is None:
default_id = extension.get_category('session').default_id
self.config.session = default_id
else:
default_id = self.config.session
extension.set_default_by_id('session', default_id)
def on_contact_list_ready(self):
'''callback called when the contact list is ready to be used'''
self.window.content.contact_list.fill()
self.on_pending_contacts()
glib.timeout_add(500, self.session.logger.check)
notificationcls = extension.get_default('notification')
self.notification = notificationcls(self.session)
self.soundPlayer = extension.get_and_instantiate('sound',self.session)
def on_contact_list_ready(self):
'''callback called when the contact list is ready to be used'''
self.window.content.contact_list.fill()
self.on_pending_contacts()
glib.timeout_add(500, self.session.logger.check)
notificationcls = extension.get_default('notification')
self.notification = notificationcls(self.session)
self.soundPlayer = extension.get_and_instantiate('sound', self.session)
def check_for_updates(self):
'''Search for any updates'''
if not self.session.config.get_or_set('b_check_for_updates', True):
return
updates_time = datetime.date.fromtimestamp(
self.config.get_or_set('f_check_updates_time', 0))
now = datetime.date.today()
delta = datetime.timedelta(weeks=1)
if now - updates_time < delta:
return
self.config.f_check_updates_time = time.time()
preferences = extension.get_and_instantiate('preferences',
self.session)
if self.session is not preferences.session:
extension.delete_instance('preferences')
preferences = extension.get_and_instantiate(
'preferences', self.session)
preferences.check_for_updates()
def on_login_succeed(self):
'''callback called on login succeed'''
self._save_login_dimensions()
self.config.save(self.config_path)
plugin_manager = get_pluginmanager()
plugin_manager.scan_directory('plugins')
self.draw_main_screen()
self.session.config.get_or_set('l_active_plugins', [])
for plugin in self.session.config.l_active_plugins:
plugin_manager.plugin_start(plugin, self.session)
# hack: where do we start this? how do we generalize for other
# extensions?
if plugin == "music":
extension.get_and_instantiate('listening to',
self.window.content)
self.set_default_extensions_from_config()
self._sync_emesene1()
def __init__(self, session, on_new_conversation):
'''class constructor'''
self.session = session
self.on_new_conversation = on_new_conversation
self.session.signals.mail_count_changed.subscribe(
self._on_mail_count_changed)
self.session.signals.social_request.subscribe(self._on_social_request)
self.session.signals.broken_profile.subscribe(self._on_broken_profile)
self.session.config.subscribe(self._on_show_userpanel_changed,
'b_show_userpanel')
self.below_menu = extension.get_and_instantiate('below menu', self)
self.below_panel = extension.get_and_instantiate('below panel', self)
self.below_userlist = extension.get_and_instantiate(
'below userlist', self)
#extension changes
extension.subscribe(self._on_below_userlist_changed, "below userlist")
extension.subscribe(self._on_below_menu_changed, "below menu")
extension.subscribe(self._on_below_panel_changed, "below panel")
def _setup_ui(self):
'''Instantiates the widgets, and sets the layout'''
widget_d = self._widget_d
# FIXME: ok, this should be substituted with the picture handler
# too lazy to do it now -.-'
if not os.path.exists(self._avatar_path):
self._avatar_path = gui.theme.image_theme.logo
avatar_cls = extension.get_default('avatar')
widget_d['display_pic'] = avatar_cls(
default_pic=gui.theme.image_theme.logo, clickable=False)
widget_d['label'] = QtGui.QLabel()
widget_d['progress_bar'] = QtGui.QProgressBar()
widget_d['cancel_btn'] = QtGui.QPushButton(tr('Cancel'))
lay = QtGui.QVBoxLayout()
lay.addSpacing(40)
lay.addWidget(widget_d['display_pic'], 0, Qt.AlignCenter)
lay.addStretch()
lay.addWidget(widget_d['label'], 0, Qt.AlignCenter)
lay.addWidget(widget_d['progress_bar'], 0, Qt.AlignCenter)
lay.addSpacing(35)
lay.addStretch()
lay.addWidget(widget_d['cancel_btn'], 0, Qt.AlignCenter)
lay.addSpacing(45)
hor_lay = QtGui.QHBoxLayout()
hor_lay.addStretch()
hor_lay.addSpacing(40)
hor_lay.addLayout(lay)
hor_lay.addSpacing(40)
hor_lay.addStretch()
self.setLayout(hor_lay)
# _avatar_path is passed to setPixmap/setMovie to avoid dpic's
# flickering
pic_handler = extension.get_and_instantiate('picture handler',
self._avatar_path)
if pic_handler.can_handle():
pixmap = QtGui.QPixmap(self._avatar_path).scaled(
96, 96, transformMode=Qt.SmoothTransformation)
widget_d['display_pic'].setPixmap(pixmap)
else:
movie = QtGui.QMovie(self._avatar_path, parent=self)
movie.setScaledSize(QtCore.QSize(96, 96))
movie.start()
widget_d['display_pic'].setMovie(movie)
widget_d['progress_bar'].setMinimum(0)
widget_d['progress_bar'].setMaximum(0)
widget_d['progress_bar'].setMinimumWidth(220)
def idle_state(self):
#compare idle time with user's preferences
self.timer = extension.get_and_instantiate('idle timer')
idle_time = self.timer.get_idle_duration()
if idle_time >= self.session.config.i_idle_status_duration:
#if idle enough time and ONLINE, set idle status
if self.session.contacts.me.status == e3.status.ONLINE:
self.session.set_status(e3.status.IDLE)
self.is_idle = True
elif idle_time < self.session.config.i_idle_status_duration and self.is_idle:
#if status is idle but the user moved something, set online
self.session.set_status(e3.status.ONLINE)
self.is_idle = False
return True
def _new_session(self):
'''create a new session object'''
if self.session is not None:
self.session.quit()
self.session = extension.get_and_instantiate('session')
# if you add a signal here, add it on _remove_subscriptions
signals = self.session.signals
signals.login_succeed.subscribe(self.on_login_succeed)
signals.login_failed.subscribe(self.on_login_failed)
signals.contact_list_ready.subscribe(self.on_contact_list_ready)
signals.conv_first_action.subscribe(self.on_new_conversation)
signals.disconnected.subscribe(self.on_disconnected)
def _on_add_clicked(self):
'''This slot is executed when the user clicks the 'Add' button.
It shows up a file chooser, than if the image can be manipulate through
toolkit function (Test is performed through PictureHandler) shows an
image area selector. Then, the image in added to the cache (through
AvatarManager object, and to the views'''
def add_and_select(filename):
'''Adds the image with he given filename to the first view and
selects it'''
# append the image to the first tab:
item = self._add_image_to_view(self._vn[0], filename)
# show first tab:
self._widget_d['tab_widget'].setCurrentIndex(0)
# select the new appended image:
self._widget_d[self._vn[0]].selectionModel().\
select(item.index(), QtGui.QItemSelectionModel.Select)
def response_cb(response, pixmap):
'''Callback invoked when the crop_image dialog is closed.
If the user clicks ok calls adds the picture to the cache
and calls add_and_select.'''
if response == gui.stock.ACCEPT:
filename = self._avatar_manager.\
add_new_avatar_from_toolkit_pix(pixmap)
add_and_select(filename)
filename = QtGui.QFileDialog.getOpenFileName(
self, tr('Select an image'), QtCore.QString(),
'Images (*.jpeg *.jpg *.png *.gif')
if filename.isEmpty():
return
filename = unicode(filename)
pic_handler = extension.get_and_instantiate('picture handler',
filename)
# substitute the filename with the name of the cached one:
if pic_handler.can_handle():
Dialog.Dialog.crop_image(response_cb, filename)
else:
filename = self._avatar_manager.add_new_avatar(filename)
add_and_select(filename)
def __init__(self, session, cid, update_window, members=None):
'''constructor'''
self.update_window = update_window
self.session = session
self.caches = self.session.caches
self.emcache = self.caches.get_emoticon_cache(
self.session.account.account)
self.cid = float(cid)
self.icid = self.cid
self._header_visible = True
self._image_visible = True
self._toolbar_visible = True
self._message_waiting = False
buffer_size = 10
self.messages = RingBuffer(max=buffer_size)
self.message_offset = 0
self.message_input = ""
if members is None:
self.members = []
else:
self.members = members
self._style = None
self.conv_status = ConversationStatus.ConversationStatus(
self.session.config)
# the base class should override this attributes
self.info = None
self.header = None
self.input = None
self.output = None
self.below_conversation = None
self.soundPlayer = extension.get_and_instantiate('sound', session)
def __init__(self, session):
"""
Class Constructor
"""
self.session = session
self.session.config.get_or_set('b_mute_notification', False)
self.session.config.get_or_set('b_notify_contact_online', True)
self.session.config.get_or_set('b_notify_contact_offline', True)
self.session.config.get_or_set('b_notify_receive_message', True)
self.session.config.get_or_set('b_notify_typing', False)
self.session.config.get_or_set('b_notify_when_focussed', False)
self.session.config.get_or_set('b_notify_only_when_available', True)
self.notifier = extension.get_default('notificationGUI')
self.picture_factory = extension.get_default('notificationImage')
self.sound_player = extension.get_and_instantiate('sound', session)
if self.session:
self.session.signals.conv_message.subscribe(self._on_message)
self.session.signals.user_typing.subscribe(self._on_user_typing)
self.session.signals.contact_attr_changed.subscribe(
self._on_contact_attr_changed)
self.session.signals.mail_received.subscribe(
self._on_mail_received)
self.session.signals.filetransfer_completed.subscribe(
self._on_filetransfer_completed)
self.session.signals.filetransfer_canceled.subscribe(
self._on_filetransfer_canceled)
self.session.signals.filetransfer_invitation.subscribe(
self._on_filetransfer_invitation)
extension.subscribe(self._on_notification_gui_changed,
'notificationGUI')
extension.subscribe(self._on_notification_image_changed,
'notificationImage')
self.notify_online = False
self.last_online = None
def _new_session(self, account=None):
'''create a new session object'''
if self.session is not None:
self.session.quit()
self.session = extension.get_and_instantiate('session')
# if you add a signal here, add it on _remove_subscriptions
signals = self.session.signals
signals.close.subscribe(self.on_close)
signals.login_succeed.subscribe(self.on_login_succeed)
signals.login_failed.subscribe(self.on_login_failed)
signals.contact_list_ready.subscribe(self.on_contact_list_ready)
signals.conv_first_action.subscribe(self.on_new_conversation)
signals.disconnected.subscribe(self.on_disconnected)
signals.picture_change_succeed.subscribe(self.on_picture_change_succeed)
#let's start dbus and unity launcher
if self.dbus_ext is not None:
self.dbus_ext.set_new_session(self.session, self.window)
if self.unity_launcher is not None:
self.unity_launcher.set_session(self.session)
def _new_session(self):
'''create a new session object'''
if self.session is not None:
self.session.quit()
self.session = extension.get_and_instantiate('session')
# if you add a signal here, add it on _remove_subscriptions
signals = self.session.signals
signals.login_succeed.subscribe(self.on_login_succeed)
signals.login_failed.subscribe(self.on_login_failed)
signals.contact_list_ready.subscribe(self.on_contact_list_ready)
signals.conv_first_action.subscribe(self.on_new_conversation)
signals.disconnected.subscribe(self.on_disconnected)
signals.picture_change_succeed.subscribe(self.on_picture_change_succeed)
signals.contact_added_you.subscribe(self.on_pending_contacts)
#let's start dbus
if self.dbus_ext is not None:
self.dbus_ext.set_new_session(self.session)
if self.network_checker is not None:
self.network_checker.set_new_session(self.session)
def add_new_avatar(self, filename):
''' add a new picture from filename into the avatar cache '''
def gen_filename(source):
# generate a unique (?) filename for the new avatar in cache
# implemented as sha224 digest
infile = open(source, 'rb')
data = infile.read()
infile.close()
return hashlib.sha224(data).hexdigest()
fpath = os.path.join(self.get_avatars_dir(), gen_filename(filename))
try:
if not os.path.exists(self.get_avatars_dir()):
os.makedirs(self.get_avatars_dir())
pix_96 = extension.get_and_instantiate('picture handler', filename)
pix_96.resize(96)
pix_96.save(fpath)
return fpath
except OSError, error:
print error
return None, fpath
def __init__(self, session, cid, update_window, members=None):
'''constructor'''
self.update_window = update_window
self.session = session
self.caches = e3.cache.CacheManager(self.session.config_dir.base_dir)
self.emcache = self.caches.get_emoticon_cache(
self.session.account.account)
self.cid = float(cid)
self.icid = self.cid
self.formatter = e3.common.MessageFormatter()
self._header_visible = True
self._image_visible = True
self._toolbar_visible = True
self._message_waiting = True
buffer_size = session.config.get_or_set("i_msg_history_size", 5)
self.messages = RingBuffer(max=buffer_size)
self.message_offset = 0
if members is None:
self.members = []
else:
self.members = members
self._style = None
self.conv_status = ConversationStatus.ConversationStatus(
self.session.config)
# the base class should override this attributes
self.info = None
self.input = None
self.output = None
self.soundPlayer = extension.get_and_instantiate('sound', session)
def __init__(self, session):
'''class constructor'''
self._model = None
dialog = extension.get_default('dialog')
pbr = extension.get_default('avatar renderer')
self.pbr = pbr()
gui.ContactList.__init__(self, session, dialog)
gtk.TreeView.__init__(self)
self.set_enable_search(
False
) #we enable our searching widget with CTRL+F in MainWindow.py
self.online_group = None # added
self.online_group_iter = None # added
self.no_group = None
self.no_group_iter = None
self.offline_group = None
self.offline_group_iter = None
self.hide_on_filtering = False
self.enable_model_drag_source(gtk.gdk.BUTTON1_MASK,
[('emesene-contact', 0, 0),
('text/html', 0, 1),
('text/plain', 0, 2)],
gtk.gdk.ACTION_COPY)
self.enable_model_drag_dest([('emesene-contact', 0, 0)],
gtk.gdk.ACTION_DEFAULT)
self.contact_handler = gui.base.ContactHandler(session, dialog, self)
self.group_handler = gui.base.GroupHandler(session, dialog, self)
if self.session.config.d_weights is None:
self.session.config.d_weights = {}
# [0] the image (None for groups),
# [1] the object (group or contact),
# [2] the string to display
# [3] a boolean indicating if the pixbuf should
# be shown (False for groups, True for contacts)
# [4] the status image
# [5] an int that is used to allow ordering specified by the user
# [6] a boolean indicating special groups always False for contacts, True
# for special groups like "No group"
# [7] a boolean indicating if the contact is offline
self._model = gtk.TreeStore(gtk.Image, object, str, bool,
gtk.gdk.Pixbuf, int, bool, bool)
self.model = self._model.filter_new(root=None)
self.model.set_visible_func(self._visible_func)
self._model.set_sort_func(1, self._sort_method)
self._model.set_sort_column_id(1, gtk.SORT_ASCENDING)
self.set_model(self.model)
self.tooltips = Tooltips.Tooltips()
self.connect('motion-notify-event', self.tooltips.on_motion)
self.connect('leave-notify-event', self.tooltips.on_leave)
crt = extension.get_and_instantiate('nick renderer')
crt.set_property('ellipsize', pango.ELLIPSIZE_END)
pbr_status = gtk.CellRendererPixbuf()
column = gtk.TreeViewColumn()
column.set_expand(True)
self.exp_column = gtk.TreeViewColumn()
self.exp_column.set_max_width(16)
self.append_column(self.exp_column)
self.append_column(column)
self.set_expander_column(self.exp_column)
column.pack_start(self.pbr, False)
column.pack_start(crt, True)
column.pack_start(pbr_status, False)
column.add_attribute(self.pbr, 'image', 0)
column.add_attribute(crt, 'markup', 2)
column.add_attribute(self.pbr, 'visible', 3)
column.add_attribute(pbr_status, 'visible', 3)
column.add_attribute(pbr_status, 'pixbuf', 4)
column.add_attribute(self.pbr, 'offline', 7)
self.set_search_column(2)
self.set_headers_visible(False)
self.connect('row-activated', self._on_row_activated)
self.connect('button-release-event', self._on_button_press_event)
self.connect('row-expanded', self._on_expand)
self.connect('row-collapsed', self._on_collapse)
self.connect('drag-data-get', self._on_drag_data_get)
self.connect('drag-drop', self._on_drag_drop)
def _on_avatar_click(self, widget, data):
'''method called when user click on his avatar '''
av_chooser = extension.get_and_instantiate('avatar chooser',
self.session)
av_chooser.set_modal(True)
av_chooser.show()
def __init__(self, session, on_new_conversation):
'''class constructor'''
gtk.VBox.__init__(self)
gui.MainWindowBase.__init__(self, session, on_new_conversation)
UserPanel = extension.get_default('user panel')
ContactList = extension.get_default('contact list')
self.below_menu = extension.get_and_instantiate('below menu', self)
self.below_panel = extension.get_and_instantiate('below panel', self)
self.below_userlist = extension.get_and_instantiate(
'below userlist', self)
self.contact_list = ContactList(session)
scroll = gtk.ScrolledWindow()
scroll.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
scroll.set_shadow_type(gtk.SHADOW_IN)
scroll.set_border_width(1)
self.session.signals.contact_attr_changed.subscribe(
self._on_contact_attr_changed)
self.session.signals.close.subscribe(self.on_disconnect)
self.menu = None
self.contact_menu = None
self.group_menu = None
self._build_menus()
self.panel = UserPanel(session)
self.panel.nick.connect('text-changed', self._on_nick_changed)
self.panel.message.connect('text-changed', self._on_message_changed)
self.panel.mail.connect('button_release_event', self._on_mail_click)
self.panel.search.connect('toggled', self._on_search_toggled)
self.panel.enabled = False
self.entry = gtk.Entry()
self.entry.connect('changed', self._on_entry_changed)
self.entry.connect('key-press-event', self._on_entry_key_press)
self.pack_start(self.menu, False)
self.pack_start(self.below_menu, False)
self.pack_start(self.panel, False)
self.pack_start(self.below_panel, False)
self.pack_start(self.entry, False)
self.pack_start(scroll, True, True)
self.pack_start(self.below_userlist, False)
self.contact_list.contact_selected.subscribe(self._on_contact_selected)
self.contact_list.group_selected.subscribe(self._on_group_selected)
self.contact_list.contact_menu_selected.subscribe(
self._on_contact_menu_selected)
self.contact_list.group_menu_selected.subscribe(
self._on_group_menu_selected)
scroll.add(self.contact_list)
scroll.show_all()
if self.session.config.b_show_userpanel:
self.panel.hide()
self.session.config.subscribe(self._on_show_userpanel_changed,
'b_show_userpanel')
def _replace_below_panel(self):
self.remove(self.below_panel)
self.below_panel = extension.get_and_instantiate('below panel', self)
self.pack_start(self.below_panel, False)
self.reorder_child(self.below_panel, 3)
self.below_panel.show()
def _replace_below_menu(self):
self.remove(self.below_menu)
self.below_menu = extension.get_and_instantiate('below menu', self)
self.pack_start(self.below_menu, False)
self.reorder_child(self.below_menu, 1)
self.below_menu.show()
def on_avatar_click(self):
'''method called when user click on his avatar
'''
chooser = extension.get_and_instantiate('avatar chooser', self.session)
chooser.exec_()
def on_contact_list_ready(self):
'''callback called when the contact list is ready to be used'''
notificationcls = extension.get_default('notification')
self.notification = notificationcls(self.session)
self.soundPlayer = extension.get_and_instantiate('sound', self.session)
return path
this_module_path = os.path.dirname(unicode(__file__,
sys.getfilesystemencoding()))
return os.path.abspath(this_module_path)
os.chdir(os.path.abspath(project_path()))
from Language import Language
import extension
extension.category_register('language', Language,
single_instance=True)
language_management = extension.get_and_instantiate('language')
language_management.install_default_translation()
if 'USE_GI' in os.environ:
try:
import pygicompat
except ImportError:
print "error: pygi compat not found"
pass
import glib
import shutil
import signal
import Info
import debugger
def on_set_picture_selected(self, widget, data=None):
'''called when set picture is selected'''
_av_chooser = extension.get_and_instantiate('avatar chooser',
self.session)
_av_chooser.show()
def crop_image(cls, response_cb, filename, title=tr('Select image area')):
'''Shows a dialog to select a portion of an image.'''
dialog = OkCancelDialog(title, expanding=True)
# Actions
act_dict = {}
act_dict['rotate_left'] = QtGui.QAction(tr('Rotate Left'), dialog)
act_dict['rotate_right'] = QtGui.QAction(tr('Rotate right'), dialog)
act_dict['fit_zoom'] = QtGui.QAction(tr('Zoom to fit'), dialog)
act_dict['fit_zoom'] = QtGui.QAction(tr('Zoom to fit'), dialog)
act_dict['reset_zoom'] = QtGui.QAction(tr('Reset zoom'), dialog)
act_dict['select_all'] = QtGui.QAction(tr('Select All'), dialog)
act_dict['select_unsc'] = QtGui.QAction(tr('Select Unscaled'), dialog)
# widgets
toolbar = QtGui.QToolBar()
scroll_area = QtGui.QScrollArea()
area_selector = extension.get_and_instantiate('image area selector',
QtGui.QPixmap(filename))
# layout
lay = QtGui.QVBoxLayout()
lay.addWidget(toolbar)
lay.addWidget(scroll_area)
dialog.setLayout(lay)
# widget setup
toolbar.addAction(act_dict['rotate_left'])
toolbar.addAction(act_dict['rotate_right'])
toolbar.addSeparator()
toolbar.addAction(act_dict['fit_zoom'])
toolbar.addAction(act_dict['reset_zoom'])
toolbar.addSeparator()
toolbar.addAction(act_dict['select_all'])
toolbar.addAction(act_dict['select_unsc'])
scroll_area.setWidget(area_selector)
scroll_area.setWidgetResizable(True)
# Signal connection:
act_dict['rotate_left'].triggered.connect(area_selector.rotate_left)
act_dict['rotate_right'].triggered.connect(area_selector.rotate_right)
act_dict['fit_zoom'].triggered.connect(area_selector.fit_zoom)
act_dict['reset_zoom'].triggered.connect(
lambda: area_selector.set_zoom(1))
act_dict['select_all'].triggered.connect(area_selector.select_all)
act_dict['select_unsc'].triggered.connect(
area_selector.select_unscaled)
# test:
if (False):
preview = QtGui.QLabel()
lay.addWidget(preview)
area_selector.selection_changed.connect(
lambda: preview.setPixmap(area_selector.get_selected_pixmap()))
zoom_sli = QtGui.QSlider(Qt.Horizontal)
zoom_sli.setMinimum(1)
zoom_sli.setMaximum(40)
zoom_sli.setValue(20)
zoom_sli.setSingleStep(1)
lay.addWidget(zoom_sli)
zoom_sli.valueChanged.connect(
lambda z: area_selector.set_zoom(z / 10.0))
# Dialog execution:
response = dialog.exec_()
selected_pixmap = area_selector.get_selected_pixmap()
response_cb(response, selected_pixmap)
