libervia-web: src/browser/libervia

comparison src/browser/libervia_main.py @ 467:97c72fe4a5f2

browser_side: import fixes: - moved browser modules in a sat_browser packages, to avoid import conflicts with std lib (e.g. logging), and let pyjsbuild work normaly - refactored bad import practices: classes are most of time not imported directly, module is imported instead.

author	Goffi <goffi@goffi.org>
date	Mon, 09 Jun 2014 22:15:26 +0200
parents	07433bd892ee
children	830b50593597

comparison

equal deleted inserted replaced

-:01880aa8ea2d
+:97c72fe4a5f2
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 import pyjd  # this is dummy in pyjs
 ### logging configuration ###
-import logging
+from sat_browser import logging
 logging.configure()
 from sat.core.log import getLogger
 log = getLogger(__name__)
 ###
 from pyjamas.ui.KeyboardListener import KEY_ESCAPE
 from pyjamas.Timer import Timer
 from pyjamas import Window, DOM
 from pyjamas.JSONService import JSONProxy
-from register import RegisterBox
+from sat_browser import register
-from contact import ContactPanel
+from sat_browser import contact
-from base_widget import WidgetsPanel
+from sat_browser import base_widget
-from panels import MicroblogItem
+from sat_browser import panels
-import panels
+from sat_browser import dialog
-import dialog
+from sat_browser import jid
-from jid import JID
+from sat_browser import xmlui
-from xmlui import XMLUI
+from sat_browser import html_tools
-from html_tools import html_sanitize
+from sat_browser import notification
-from notification import Notification
+from sat_browser.constants import Const as C
-from constants import Const as C
 MAX_MBLOG_CACHE = 500  # Max microblog entries kept in memories
 # Set to true to not create a new LiberviaWidget when a similar one
 # already exist (i.e. a chat panel with the same target). Instead
 # the existing widget will be eventually removed from its parent
-# and added to new WidgetsPanel, or replaced to the expected
+# and added to new base_widget.WidgetsPanel, or replaced to the expected
 # position if the previous and the new parent are the same.
 REUSE_EXISTING_LIBERVIA_WIDGETS = True
 class LiberviaJsonProxy(JSONProxy):
 self._selected_listeners = set()
 self.bridge = BridgeCall()
 self.bridge_signals = BridgeSignals(self)
 self.uni_box = None
 self.status_panel = HTML('<br />')
-self.contact_panel = ContactPanel(self)
+self.contact_panel = contact.ContactPanel(self)
 self.panel = panels.MainPanel(self)
 self.discuss_panel = self.panel.discuss_panel
 self.tab_panel = self.panel.tab_panel
 self.tab_panel.addTabListener(self)
 self.libervia_widgets = set()  # keep track of all actives LiberviaWidgets
 self.room_list = []  # list of rooms
 self.mblog_cache = []  # used to keep our own blog entries in memory, to show them in new mblog panel
 self.avatars_cache = {}  # keep track of jid's avatar hash (key=jid, value=file)
 self._register_box = None
 RootPanel().add(self.panel)
-self.notification = Notification()
+self.notification = notification.Notification()
 DOM.addEventPreview(self)
 self._register = RegisterCall()
 self._register.call('getMenus', self.panel.menu.createMenus)
 self._register.call('registerParams', None)
 self._register.call('isRegistered', self._isRegisteredCB)
 def addSelectedListener(self, callback):
 self._selected_listeners.add(callback)
 def getSelected(self):
 wid = self.tab_panel.getCurrentPanel()
-if not isinstance(wid, WidgetsPanel):
+if not isinstance(wid, base_widget.WidgetsPanel):
-log.error("Tab widget is not a WidgetsPanel, can't get selected widget")
+log.error("Tab widget is not a base_widget.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, WidgetsPanel):
+if not isinstance(widgets_panel, base_widget.WidgetsPanel):
 return
 selected = widgets_panel.selected
 if selected == widget:
 """Create a new tab and eventually add a widget in
 @param label: label of the tab
 @param wid: LiberviaWidget to add
 @param select: True to select the added tab
 """
-widgets_panel = WidgetsPanel(self)
+widgets_panel = base_widget.WidgetsPanel(self)
 self.tab_panel.add(widgets_panel, label)
 widgets_panel.addWidget(wid)
 if select:
 self.tab_panel.selectTab(self.tab_panel.getWidgetCount() - 1)
 return widgets_panel
 self.notification.notify(title, body)
 def _isRegisteredCB(self, result):
 registered, warning = result
 if not registered:
-self._register_box = RegisterBox(self.logged)
+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)
 def _actionCb(self, data):
 if not data:
 # action was a one shot, nothing to do
 pass
 elif "xmlui" in data:
-ui = XMLUI(self, xml_data=data['xmlui'])
+ui = xmlui.XMLUI(self, xml_data=data['xmlui'])
 options = ['NO_CLOSE'] if ui.type == 'form' else []
 _dialog = dialog.GenericDialog(ui.title, ui, options=options)
 ui.setCloseCb(_dialog.close)
 _dialog.show()
 else:
 if data is None:
 data = {}
 self.bridge.call('launchAction', (self._actionCb, self._actionEb), callback_id, data)
 def _getContactsCB(self, contacts_data):
-for contact in contacts_data:
+for contact_ in contacts_data:
-jid, attributes, groups = contact
+jid, attributes, groups = contact_
 self._newContactCb(jid, attributes, groups)
 def _getSignalsCB(self, signal_data):
 self.bridge_signals.call('getSignals', self._getSignalsCB)
 log.debug("Got signal ==> name: %s, params: %s" % (signal_data[0], signal_data[1]))
 elif name == 'entityDataUpdated':
 self._entityDataUpdatedCb(*args)
 elif name == 'chatStateReceived':
 self._chatStateReceivedCb(*args)
-def _getParamsUICB(self, xmlui):
+def _getParamsUICB(self, xml_ui):
 """Hide the parameters item if there's nothing to display"""
-if not xmlui:
+if not xml_ui:
 self.panel.menu.removeItemParams()
 def _ownBlogsFills(self, mblogs):
 #put our own microblogs in cache, then fill all panels with them
 for publisher in mblogs:
 continue
 if 'groups' in mblog:
 _groups = set(mblog['groups'].split() if mblog['groups'] else [])
 else:
 _groups = None
-mblog_entry = MicroblogItem(mblog)
+mblog_entry = panels.MicroblogItem(mblog)
 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)]
 for lib_wid in self.libervia_widgets:
 for event_data in self.init_cache:  # so we have to send all the cached events
 self._personalEventCb(*event_data)
 del self.init_cache
 def _getProfileJidCB(self, jid):
-self.whoami = JID(jid)
+self.whoami = jid.JID(jid)
 #we can now ask our status
 self.bridge.call('getPresenceStatuses', self._getPresenceStatusesCb)
 #the rooms where we are
 self.bridge.call('getRoomsJoined', self._getRoomsJoinedCb)
 #and if there is any subscription request waiting for us
 def _personalEventCb(self, sender, event_type, data):
 if not self.initialised:
 self.init_cache.append((sender, event_type, data))
 return
-sender = JID(sender).bare
+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 = MicroblogItem(data)
+mblog_entry = panels.MicroblogItem(data)
 for lib_wid in self.libervia_widgets:
 if isinstance(lib_wid, panels.MicroblogPanel):
 self.addBlogEntry(lib_wid, sender, _groups, mblog_entry)
 def addBlogEntry(self, mblog_panel, sender, _groups, mblog_entry):
 """Check if an entry can go in MicroblogPanel and add to it
 @param mblog_panel: MicroblogPanel instance
 @param sender: jid of the entry sender
 @param _groups: groups which can receive this entry
-@param mblog_entry: MicroblogItem instance"""
+@param mblog_entry: panels.MicroblogItem instance"""
 if mblog_entry.type == "comment" or mblog_panel.isJidAccepted(sender) or (_groups == None and self.whoami and sender == self.whoami.bare) \
 or (_groups and _groups.intersection(mblog_panel.accepted_groups)):
 mblog_panel.addEntry(mblog_entry)
 def FillMicroblogPanel(self, mblog_panel):
 self.setSelected(lib_wid)
 lib_wid.refresh()
 return lib_wid
 def _newMessageCb(self, from_jid, msg, msg_type, to_jid, extra):
-_from = JID(from_jid)
+_from = jid.JID(from_jid)
-_to = JID(to_jid)
+_to = jid.JID(to_jid)
 other = _to if _from.bare == self.whoami.bare else _from
 lib_wid = self.getLiberviaWidget(panels.ChatPanel, other, ignoreOtherTabs=False)
 self.displayNotification(_from, msg)
 if msg_type == 'headline' and from_jid == self._defaultDomain:
 try:
 self.contact_panel.updateContact(other.bare, {}, [C.GROUP_NOT_IN_ROSTER])
 # The message has not been shown, we must indicate it
 self.contact_panel.setContactMessageWaiting(other.bare, True)
 def _presenceUpdateCb(self, entity, show, priority, statuses):
-entity_jid = JID(entity)
+entity_jid = jid.JID(entity)
 if self.whoami and self.whoami == entity_jid:  # XXX: QnD way to get our presence/status
 self.status_panel.setPresence(show)
 if statuses:
 self.status_panel.setStatus(statuses.values()[0])
 else:
 self.contact_panel.setConnected(entity_jid.bare, entity_jid.resource, show, priority, statuses)
 def _roomJoinedCb(self, room_jid, room_nicks, user_nick):
-_target = JID(room_jid)
+_target = jid.JID(room_jid)
 if _target not in self.room_list:
 self.room_list.append(_target)
 chat_panel = panels.ChatPanel(self, _target, type_='group')
 chat_panel.setUserNick(user_nick)
 if _target.node.startswith('sat_tarot_'):  # XXX: it's not really beautiful, but it works :)
 chat_panel.setPresents(room_nicks)
 chat_panel.historyPrint()
 chat_panel.refresh()
 def _roomLeftCb(self, room_jid, room_nicks, user_nick):
-# FIXME: room_list contains JID instances so why MUST we do
+# FIXME: room_list contains jid.JID instances so why MUST we do
-# 'remove(room_jid)' and not 'remove(JID(room_jid))' ????!!
+# 'remove(room_jid)' and not 'remove(jid.JID(room_jid))' ????!!
 # This looks like a pyjamas bug --> check/report
 try:
 self.room_list.remove(room_jid)
 except KeyError:
 pass
 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_sanitize(entity)).show()
+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_sanitize(entity)).show()
+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_sanitize(entity))
+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, '', _dialog.getSelectedGroups())
 def cancel_cb(ignore):
 """
 if from_jid_s == '@ALL@':
 target = '@ALL@'
 nick = C.ALL_OCCUPANTS
 else:
-from_jid = JID(from_jid_s)
+from_jid = jid.JID(from_jid_s)
 target = from_jid.bare
 nick = from_jid.resource
 for lib_wid in self.libervia_widgets:
 if isinstance(lib_wid, panels.ChatPanel):

Mercurial > libervia-web

comparison src/browser/libervia_main.py @ 467:97c72fe4a5f2