Mercurial > libervia-web
view src/browser/libervia_main.py @ 697:b395d1309936
browser_side: clean the code that has been commented or isolated during the refactorisation to base libervia on quick_frontend
author | souliane <souliane@mailoo.org> |
---|---|
date | Mon, 20 Apr 2015 09:14:03 +0200 |
parents | c2f22ca12e23 |
children | be55a782a976 |
line wrap: on
line source
#!/usr/bin/python # -*- coding: utf-8 -*- # Libervia: a Salut à Toi frontend # Copyright (C) 2011, 2012, 2013, 2014, 2015 Jérôme Poisson <goffi@goffi.org> # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU Affero General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # 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 Affero General Public License for more details. # You should have received a copy of the GNU Affero General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. ### logging configuration ### from sat_browser import logging logging.configure() from sat.core.log import getLogger log = getLogger(__name__) ### from sat.core.i18n import D_ from sat_frontends.quick_frontend.quick_app import QuickApp from sat_frontends.quick_frontend import quick_widgets from sat_frontends.quick_frontend import quick_menus from sat_frontends.tools.misc import InputHistory from sat_frontends.tools import strings from sat_frontends.tools import jid from sat_frontends.tools import host_listener from sat.core.i18n import _ from pyjamas.ui.RootPanel import RootPanel from pyjamas.ui.HTML import HTML from pyjamas.ui.KeyboardListener import KEY_ESCAPE from pyjamas.Timer import Timer from pyjamas import Window, DOM from sat_browser import json from sat_browser import register from sat_browser.contact_list import ContactList from sat_browser import widget from sat_browser import main_panel from sat_browser import blog from sat_browser import dialog from sat_browser import xmlui from sat_browser import html_tools from sat_browser import notification from sat_browser import libervia_widget from sat_browser.constants import Const as C import os.path try: # FIXME: import plugin dynamically from sat_browser import plugin_sec_otr except ImportError: pass unicode = str # FIXME: pyjamas workaround MAX_MBLOG_CACHE = 500 # Max microblog entries kept in memories class SatWebFrontend(InputHistory, QuickApp): def onModuleLoad(self): log.info("============ onModuleLoad ==============") self.bridge_signals = json.BridgeSignals(self) QuickApp.__init__(self, json.BridgeCall) self.panel = main_panel.MainPanel(self) self.tab_panel = self.panel.tab_panel self.tab_panel.addTabListener(self) self._register_box = None RootPanel().add(self.panel) self.notification = notification.Notification() DOM.addEventPreview(self) self.importPlugins() self._register = json.RegisterCall() self._register.call('getMenus', self.gotMenus) self._register.call('registerParams', None) self._register.call('isRegistered', self._isRegisteredCB) self.initialised = False self.init_cache = [] # used to cache events until initialisation is done self.cached_params = {} self.next_rsm_index = 0 #FIXME: microblog cache should be managed directly in blog module self.mblog_cache = [] # used to keep our own blog entries in memory, to show them in new mblog panel self._versions={} # SàT and Libervia versions cache @property def whoami(self): # XXX: works because Libervia is mono-profile # if one day Libervia manage several profiles at once, this must be deleted return self.profiles[C.PROF_KEY_NONE].whoami @property def contact_list(self): return self.contact_lists[C.PROF_KEY_NONE] @property def visible_widgets(self): widgets_panel = self.tab_panel.getCurrentPanel() return [wid for wid in widgets_panel.widgets if isinstance(wid, quick_widgets.QuickWidget)] @property def base_location(self): """Return absolute base url of this Libervia instance""" url = Window.getLocation().getHref() if url.endswith(C.LIBERVIA_MAIN_PAGE): url = url[:-len(C.LIBERVIA_MAIN_PAGE)] if url.endswith("/"): url = url[:-1] return url @property def sat_version(self): return self._versions["sat"] @property def libervia_version(self): return self._versions["libervia"] def getVersions(self, callback=None): """Ask libervia server for SàT and Libervia version and fill local cache @param callback: method to call when both versions have been received """ def gotVersion(): if len(self._versions) == 2 and callback is not None: callback() if len(self._versions) == 2: # we already have versions in cache gotVersion() return def gotSat(version): self._versions["sat"] = version gotVersion() def gotLibervia(version): self._versions["libervia"] = version gotVersion() self.bridge.getVersion(callback=gotSat) self.bridge.getLiberviaVersion(callback=gotLibervia, profile=None) # XXX: bridge direct call expect a profile, even for method with no profile needed def registerSignal(self, functionName, handler=None, iface="core", with_profile=True): if handler is None: callback = getattr(self, "{}{}".format(functionName, "Handler")) else: callback = handler self.bridge_signals.register(functionName, callback, with_profile=with_profile) def importPlugins(self): self.plugins = {} try: self.plugins['otr'] = plugin_sec_otr.OTR(self) except TypeError: # plugin_sec_otr has not been imported pass def getSelected(self): wid = self.tab_panel.getCurrentPanel() if not isinstance(wid, libervia_widget.WidgetsPanel): log.error("Tab widget is not a WidgetsPanel, can't get selected widget") return None return wid.selected def setSelected(self, widget): """Define the selected widget""" widgets_panel = self.tab_panel.getCurrentPanel() if not isinstance(widgets_panel, libervia_widget.WidgetsPanel): return selected = widgets_panel.selected if selected == widget: return if selected: selected.removeStyleName('selected_widget') # FIXME: check that widget is in the current WidgetsPanel widgets_panel.selected = widget self.selected_widget = widget if widget: widgets_panel.selected.addStyleName('selected_widget') def resize(self): """Resize elements""" Window.onResize() def onBeforeTabSelected(self, sender, tab_index): return True def onTabSelected(self, sender, tab_index): pass def onEventPreview(self, event): if event.type in ["keydown", "keypress", "keyup"] and event.keyCode == KEY_ESCAPE: #needed to prevent request cancellation in Firefox event.preventDefault() return True # FIXME: must not call _entityDataUpdatedCb by itself # should not get VCard, backend plugin must be fixed too def getAvatarURL(self, jid_): """Return avatar of a jid if in cache, else ask for it. @param jid_ (jid.JID): JID of the contact @return: the URL to the avatar (unicode) """ assert isinstance(jid_, jid.JID) contact_list = self.contact_list # pyjamas issue: need a temporary variable to call a property's method avatar_hash = contact_list.getCache(jid_, 'avatar') if avatar_hash is None: # we have no value for avatar_hash, so we request the vcard self.bridge.getCard(unicode(jid_), profile=C.PROF_KEY_NONE) if not avatar_hash: return C.DEFAULT_AVATAR_URL ret = os.path.join(C.AVATARS_DIR, avatar_hash) return ret def registerWidget(self, wid): log.debug(u"Registering %s" % wid.getDebugName()) self.libervia_widgets.add(wid) def unregisterWidget(self, wid): try: self.libervia_widgets.remove(wid) except KeyError: log.warning(u'trying to remove a non registered Widget: %s' % wid.getDebugName()) def refresh(self): """Refresh the general display.""" self.panel.refresh() for lib_wid in self.libervia_widgets: lib_wid.refresh() self.resize() def addWidget(self, wid, tab_index=None): """ Add a widget at the bottom of the current or specified tab @param wid: LiberviaWidget to add @param tab_index: index of the tab to add the widget to """ if tab_index is None or tab_index < 0 or tab_index >= self.tab_panel.getWidgetCount(): panel = self.tab_panel.getCurrentPanel() else: panel = self.tab_panel.deck.getWidget(tab_index) panel.addWidget(wid) def displayNotification(self, title, body): self.notification.notify(title, body) def gotMenus(self, backend_menus): """Put the menus data in cache and build the main menu bar @param backend_menus (list[tuple]): menu data from backend """ main_menu = self.panel.menu # most of global menu callbacks are in main_menu # Categories (with icons) self.menus.addCategory(C.MENU_GLOBAL, [D_(u"General")], extra={'icon': 'home'}) self.menus.addCategory(C.MENU_GLOBAL, [D_(u"Contacts")], extra={'icon': 'social'}) self.menus.addCategory(C.MENU_GLOBAL, [D_(u"Groups")], extra={'icon': 'social'}) self.menus.addCategory(C.MENU_GLOBAL, [D_(u"Games")], extra={'icon': 'games'}) # menus to have before backend menus self.menus.addMenu(C.MENU_GLOBAL, (D_(u"Groups"), D_(u"Discussion")), callback=main_menu.onJoinRoom) # menus added by the backend/plugins (include other types than C.MENU_GLOBAL) self.menus.addMenus(backend_menus, top_extra={'icon': 'plugins'}) # menus to have under backend menus self.menus.addMenu(C.MENU_GLOBAL, (D_(u"Contacts"), D_(u"Manage groups")), callback=main_menu.onManageContactGroups) # separator and right hand menus self.menus.addMenuItem(C.MENU_GLOBAL, [], quick_menus.MenuSeparator()) self.menus.addMenu(C.MENU_GLOBAL, (D_(u"Help"), D_("Social contract")), top_extra={'icon': 'help'}, callback=main_menu.onSocialContract) self.menus.addMenu(C.MENU_GLOBAL, (D_(u"Help"), D_("About")), callback=main_menu.onAbout) self.menus.addMenu(C.MENU_GLOBAL, (D_(u"Settings"), D_("Account")), top_extra={'icon': 'settings'}, callback=main_menu.onAccount) self.menus.addMenu(C.MENU_GLOBAL, (D_(u"Settings"), D_("Parameters")), callback=main_menu.onParameters) # XXX: temporary, will change when a full profile will be managed in SàT self.menus.addMenu(C.MENU_GLOBAL, (D_(u"Settings"), D_("Upload avatar")), callback=main_menu.onAvatarUpload) # we call listener to have menu added by local classes/plugins self.callListeners('gotMenus') # FIXME: to be done another way or moved to quick_app # and finally the menus which must appear at the bottom self.menus.addMenu(C.MENU_GLOBAL, (D_(u"General"), D_(u"Disconnect")), callback=main_menu.onDisconnect) # we can now display all the menus main_menu.update(C.MENU_GLOBAL) def _isRegisteredCB(self, result): registered, warning = result if not registered: self._register_box = register.RegisterBox(self.logged) self._register_box.centerBox() self._register_box.show() if warning: dialog.InfoDialog(_('Security warning'), warning).show() self._tryAutoConnect(skip_validation=not not warning) else: self._register.call('isConnected', self._isConnectedCB) def _isConnectedCB(self, connected): if not connected: self._register.call('asyncConnect', lambda x: self.logged()) else: self.logged() def logged(self): if self._register_box: self._register_box.hide() del self._register_box # don't work if self._register_box is None # display the presence status panel and tab bar self.presence_status_panel = main_panel.PresenceStatusPanel(self) self.panel.addPresenceStatusPanel(self.presence_status_panel) self.panel.tab_panel.getTabBar().setVisible(True) self.bridge_signals.call('getSignals', self.bridge_signals.signalHandler) def domain_cb(value): self._defaultDomain = value log.info(u"new account domain: %s" % value) def domain_eb(value): self._defaultDomain = "libervia.org" self.bridge.getNewAccountDomain(callback=domain_cb, errback=domain_eb) self.plug_profiles([C.PROF_KEY_NONE]) # XXX: None was used intitially, but pyjamas bug when using variable arguments and None is the only arg. def profilePlugged(self, dummy): # FIXME: to be called as a "profilePlugged" listener? QuickApp.profilePlugged(self, dummy) microblog_widget = self.displayWidget(blog.MicroblogPanel, ()) self.setSelected(microblog_widget) # we fill the panels already here for wid in self.widgets.getWidgets(blog.MicroblogPanel): if wid.accept_all(): self.bridge.getMassiveMblogs('ALL', (), None, profile=C.PROF_KEY_NONE, callback=wid.massiveInsert) else: self.bridge.getMassiveMblogs('GROUP', list(wid.accepted_groups), None, profile=C.PROF_KEY_NONE, callback=wid.massiveInsert) #we ask for our own microblogs: self.loadOurMainEntries() def gotDefaultMUC(default_muc): self.default_muc = default_muc self.bridge.getDefaultMUC(profile=None, callback=gotDefaultMUC) def addContactList(self, dummy): contact_list = ContactList(self) self.panel.addContactList(contact_list) # FIXME: the contact list height has to be set manually the first time self.resize() return contact_list def newWidget(self, wid): log.debug(u"newWidget: {}".format(wid)) self.addWidget(wid) def newMessageHandler(self, from_jid_s, msg, type_, to_jid_s, extra, profile=C.PROF_KEY_NONE): if type_ == C.MESS_TYPE_HEADLINE: from_jid = jid.JID(from_jid_s) if from_jid.domain == self._defaultDomain: # we display announcement from the server in a dialog for better visibility try: title = extra['subject'] except KeyError: title = _('Announcement from %s') % from_jid msg = strings.addURLToText(html_tools.XHTML2Text(msg)) dialog.InfoDialog(title, msg).show() return QuickApp.newMessageHandler(self, from_jid_s, msg, type_, to_jid_s, extra, profile) def disconnectedHandler(self, profile): QuickApp.disconnectedHandler(self, profile) Window.getLocation().reload() def setStatusOnline(self, online=True, show='', statuses={}, profile=C.PROF_KEY_NONE): self.presence_status_panel.setPresence(show) if statuses: # FIXME: retrieve user language status or fallback to 'default' self.presence_status_panel.setStatus(statuses.values()[0]) def _tryAutoConnect(self, skip_validation=False): """This method retrieve the eventual URL parameters to auto-connect the user. @param skip_validation: if True, set the form values but do not validate it """ params = strings.getURLParams(Window.getLocation().getSearch()) if "login" in params: self._register_box._form.right_side.selectTab(0) self._register_box._form.login_box.setText(params["login"]) self._register_box._form.login_pass_box.setFocus(True) if "passwd" in params: # try to connect self._register_box._form.login_pass_box.setText(params["passwd"]) if not skip_validation: self._register_box._form.onLogin(None) return True else: # this would eventually set the browser saved password Timer(5, lambda: self._register_box._form.login_pass_box.setFocus(True)) def _actionCb(self, data): if not data: # action was a one shot, nothing to do pass elif "xmlui" in data: ui = xmlui.create(self, xml_data=data['xmlui']) ui.show() elif "public_blog" in data: # TODO: use the bare instead of node when all blogs can be retrieved node = jid.JID(data['public_blog']).node # FIXME: "/blog/{}" won't work with unicode nodes self.displayWidget(widget.WebWidget, "/blog/{}".format(node), show_url=False, new_tab=_(u"{}'s blog").format(unicode(node))) else: dialog.InfoDialog("Error", "Unmanaged action result", Width="400px").center() def _actionEb(self, err_data): err_code, err_obj = err_data dialog.InfoDialog("Error", unicode(err_obj), Width="400px").center() def launchAction(self, callback_id, data=None, callback=None, profile=C.PROF_KEY_NONE): """ Launch a dynamic action @param callback_id: id of the action to launch @param data: data needed only for certain actions """ if data is None: data = {} self.bridge.launchAction(callback_id, data, profile=profile, callback=self._actionCb, errback=self._actionEb) def _getContactsCB(self, contacts_data): for contact_ in contacts_data: jid, attributes, groups = contact_ self._newContactCb(jid, attributes, groups) def _getParamsUICB(self, xml_ui): """Hide the parameters item if there's nothing to display""" if not xml_ui: self.panel.menu.removeItemParams() def _ownBlogsFills(self, mblogs, mblog_panel=None): """Put our own microblogs in cache, then fill the panels with them. @param mblogs (dict): dictionary mapping a publisher JID to blogs data. @param mblog_panel (MicroblogPanel): the panel to fill, or all if None. """ cache = [] for publisher in mblogs: for mblog in mblogs[publisher][0]: if 'content' not in mblog: log.warning(u"No content found in microblog [%s]" % mblog) continue if 'groups' in mblog: _groups = set(mblog['groups'].split() if mblog['groups'] else []) else: _groups = None mblog_entry = blog.MicroblogItem(mblog) cache.append((_groups, mblog_entry)) self.mblog_cache.extend(cache) if len(self.mblog_cache) > MAX_MBLOG_CACHE: del self.mblog_cache[0:len(self.mblog_cache - MAX_MBLOG_CACHE)] widget_list = [mblog_panel] if mblog_panel else self.widgets.getWidgets(blog.MicroblogPanel) for wid in widget_list: self.fillMicroblogPanel(wid, cache) # FIXME if self.initialised: return self.initialised = True # initialisation phase is finished here for event_data in self.init_cache: # so we have to send all the cached events self.personalEventHandler(*event_data) del self.init_cache def loadOurMainEntries(self, index=0, mblog_panel=None): """Load a page of our own blogs from the cache or ask them to the backend. Then fill the panels with them. @param index (int): starting index of the blog page to retrieve. @param mblog_panel (MicroblogPanel): the panel to fill, or all if None. """ delta = index - self.next_rsm_index if delta < 0: assert mblog_panel is not None self.fillMicroblogPanel(mblog_panel, self.mblog_cache[index:index + C.RSM_MAX_ITEMS]) return def cb(result): self._ownBlogsFills(result, mblog_panel) rsm = {'max': str(delta + C.RSM_MAX_ITEMS), 'index': str(self.next_rsm_index)} self.bridge.getMassiveMblogs('JID', [unicode(self.whoami.bare)], rsm, callback=cb, profile=C.PROF_KEY_NONE) self.next_rsm_index = index + C.RSM_MAX_ITEMS ## Signals callbacks ## def personalEventHandler(self, sender, event_type, data): # FIXME: move some code from here to QuickApp if not self.initialised: self.init_cache.append((sender, event_type, data)) return sender = jid.JID(sender).bare if event_type == "MICROBLOG": if not 'content' in data: log.warning("No content found in microblog data") return if 'groups' in data: _groups = set(data['groups'].split() if data['groups'] else []) else: _groups = None mblog_entry = blog.MicroblogItem(data) for wid in self.widgets.getWidgets(blog.MicroblogPanel): wid.addEntryIfAccepted(sender, _groups, mblog_entry) if sender == self.whoami.bare: found = False for index in xrange(0, len(self.mblog_cache)): entry = self.mblog_cache[index] if entry[1].id == mblog_entry.id: # replace existing entry self.mblog_cache.remove(entry) self.mblog_cache.insert(index, (_groups, mblog_entry)) found = True break if not found: self.mblog_cache.append((_groups, mblog_entry)) if len(self.mblog_cache) > MAX_MBLOG_CACHE: del self.mblog_cache[0:len(self.mblog_cache - MAX_MBLOG_CACHE)] elif event_type == 'MICROBLOG_DELETE': for wid in self.widgets.getWidgets(blog.MicroblogPanel): wid.removeEntry(data['type'], data['id']) if sender == self.whoami.bare and data['type'] == 'main_item': for index in xrange(0, len(self.mblog_cache)): entry = self.mblog_cache[index] if entry[1].id == data['id']: self.mblog_cache.remove(entry) break def fillMicroblogPanel(self, mblog_panel, mblogs): """Fill a microblog panel with entries in cache @param mblog_panel: MicroblogPanel instance """ #XXX: only our own entries are cached for cache_entry in mblogs: _groups, mblog_entry = cache_entry mblog_panel.addEntryIfAccepted(self.whoami.bare, *cache_entry) def getEntityMBlog(self, entity): log.info(u"geting mblog for entity [%s]" % (entity,)) for lib_wid in self.libervia_widgets: if isinstance(lib_wid, blog.MicroblogPanel): if lib_wid.isJidAccepted(entity): self.bridge.call('getMassiveMblogs', lib_wid.massiveInsert, 'JID', [unicode(entity)]) def displayWidget(self, class_, target, dropped=False, new_tab=None, *args, **kwargs): """Get or create a LiberviaWidget and select it. When the user dropped something, a new widget is always created, otherwise we look for an existing widget and re-use it if it's in the current tab. @arg class_(class): see quick_widgets.getOrCreateWidget @arg target: see quick_widgets.getOrCreateWidget @arg dropped(bool): if True, assume the widget has been dropped @arg new_tab(unicode): if not None, it holds the name of a new tab to open for the widget. If None, use the default behavior. @param args(list): optional args to create a new instance of class_ @param kwargs(list): optional kwargs to create a new instance of class_ @return: the widget """ kwargs['profile'] = C.PROF_KEY_NONE if dropped: kwargs['on_new_widget'] = None kwargs['on_existing_widget'] = C.WIDGET_RECREATE wid = self.widgets.getOrCreateWidget(class_, target, *args, **kwargs) self.setSelected(wid) return wid if new_tab: kwargs['on_new_widget'] = None kwargs['on_existing_widget'] = C.WIDGET_RECREATE wid = self.widgets.getOrCreateWidget(class_, target, *args, **kwargs) self.tab_panel.addWidgetsTab(new_tab) self.addWidget(wid, tab_index=self.tab_panel.getWidgetCount() - 1) return wid kwargs['on_existing_widget'] = C.WIDGET_RAISE try: wid = self.widgets.getOrCreateWidget(class_, target, *args, **kwargs) except quick_widgets.WidgetAlreadyExistsError: kwargs['on_existing_widget'] = C.WIDGET_KEEP wid = self.widgets.getOrCreateWidget(class_, target, *args, **kwargs) widgets_panel = wid.getParent(libervia_widget.WidgetsPanel, expect=False) if widgets_panel is None: # The widget exists but is hidden self.addWidget(wid) elif widgets_panel != self.tab_panel.getCurrentPanel(): # the widget is on an other tab, so we add a new one here kwargs['on_existing_widget'] = C.WIDGET_RECREATE wid = self.widgets.getOrCreateWidget(class_, target, *args, **kwargs) self.addWidget(wid) self.setSelected(wid) return wid def _getPresenceStatusesCb(self, presence_data): for entity in presence_data: for resource in presence_data[entity]: args = presence_data[entity][resource] full = ('%s/%s' % (jid.JID(entity).bare, resource)) if resource else entity self._presenceUpdateCb(full, *args) def _getRoomsJoinedCb(self, room_data): for room in room_data: self._roomJoinedCb(*room) def _getWaitingSubCb(self, waiting_sub): for sub in waiting_sub: self._subscribeCb(waiting_sub[sub], sub) def _subscribeCb(self, sub_type, entity): if sub_type == 'subscribed': dialog.InfoDialog('Subscription confirmation', 'The contact <b>%s</b> has added you to his/her contact list' % html_tools.html_sanitize(entity)).show() self.getEntityMBlog(entity) elif sub_type == 'unsubscribed': dialog.InfoDialog('Subscription refusal', 'The contact <b>%s</b> has refused to add you in his/her contact list' % html_tools.html_sanitize(entity)).show() #TODO: remove microblogs from panels elif sub_type == 'subscribe': #The user want to subscribe to our presence _dialog = None msg = HTML('The contact <b>%s</b> want to add you in his/her contact list, do you accept ?' % html_tools.html_sanitize(entity)) def ok_cb(ignore): self.bridge.call('subscription', None, "subscribed", entity) self.bridge.updateContact(entity, '', _dialog.getSelectedGroups()) def cancel_cb(ignore): self.bridge.call('subscription', None, "unsubscribed", entity, '', '') _dialog = dialog.GroupSelector([msg], self.contact_panel.getGroups(), [], "Add", ok_cb, cancel_cb) _dialog.setHTML('<b>Add contact request</b>') _dialog.show() def _contactDeletedCb(self, entity): self.contact_panel.removeContactBox(entity) def _newContactCb(self, contact_jid, attributes, groups): self.contact_panel.updateContact(contact_jid, attributes, groups) def askConfirmationHandler(self, confirmation_id, confirmation_type, data): answer_data = {} def confirm_cb(result): self.bridge.call('confirmationAnswer', None, confirmation_id, result, answer_data) if confirmation_type == "YES/NO": dialog.ConfirmDialog(confirm_cb, text=data["message"], title=data["title"]).show() def _newAlert(self, message, title, alert_type): dialog.InfoDialog(title, message).show() def _paramUpdate(self, name, value, category, refresh=True): """This is called when the paramUpdate signal is received, but also during initialization when the UI parameters values are retrieved. @param refresh: set to True to refresh the general UI """ for param_cat, param_name in C.CACHED_PARAMS: if name == param_name and category == param_cat: self.cached_params[(category, name)] = value if refresh: self.refresh() break def getCachedParam(self, category, name): """Return a parameter cached value (e.g for refreshing the UI) @param category (unicode): the parameter category @pram name (unicode): the parameter name """ return self.cached_params[(category, name)] if (category, name) in self.cached_params else None def sendError(self, errorData): dialog.InfoDialog("Error while sending message", "Your message can't be sent", Width="400px").center() log.error("sendError: %s" % unicode(errorData)) def showWarning(self, type_=None, msg=None): """Display a popup information message, e.g. to notify the recipient of a message being composed. If type_ is None, a popup being currently displayed will be hidden. @type_: a type determining the CSS style to be applied (see WarningPopup.showWarning) @msg: message to be displayed """ if not hasattr(self, "warning_popup"): self.warning_popup = main_panel.WarningPopup() self.warning_popup.showWarning(type_, msg) def showDialog(self, message, title="", type_="info", answer_cb=None, answer_data=None): if type_ == 'info': popup = dialog.InfoDialog(unicode(title), unicode(message), callback=answer_cb) elif type_ == 'error': popup = dialog.InfoDialog(unicode(title), unicode(message), callback=answer_cb) elif type_ == 'yes/no': popup = dialog.ConfirmDialog(lambda answer: answer_cb(answer, answer_data), text=unicode(message), title=unicode(title)) popup.cancel_button.setText(_("No")) else: popup = dialog.InfoDialog(unicode(title), unicode(message), callback=answer_cb) log.error(_('unmanaged dialog type: %s'), type_) popup.show() def showFailure(self, err_data, msg=''): """Show a failure that has been returned by an asynchronous bridge method. @param failure (defer.Failure): Failure instance @param msg (unicode): message to display """ # FIXME: message is lost by JSON, we hardcode it for now... remove msg argument when possible err_code, err_obj = err_data title = err_obj['message']['faultString'] if isinstance(err_obj['message'], dict) else err_obj['message'] self.showDialog(msg, title, 'error') def showFailureRoomInvalid(self, err_data): """Show a failure that has been returned when trying to join an invalid room. @param failure (defer.Failure): Failure instance """ # FIXME: remove asap, see self.showFailure msg = _(u"Invalid room identifier. Please give a room short or full identifier like 'room' or '%s'.") % self.default_muc self.showFailure(err_data, msg) if __name__ == '__main__': app = SatWebFrontend() app.onModuleLoad() host_listener.callListeners(app)