libervia-web: browser_side/panels.py comparison

comparison browser_side/panels.py @ 202:2bc6cf004e61

browser, server: comments handling: - banner in unibar show a specific message when the message will be a comment - comments are inserted in a subpanel, in chronological order

author	Goffi <goffi@goffi.org>
date	Thu, 20 Jun 2013 12:16:46 +0200
parents	aa76793da353
children	4d7054542751

comparison

equal deleted inserted replaced

-:aa76793da353
+:2bc6cf004e61
 """This text box is used as a main typing point, for message, microblog, etc"""
 def __init__(self, host):
 TextArea.__init__(self)
 #AutoCompleteTextBox.__init__(self)
 self.__size = (0,0)
 self._popup = None
 self._timer = Timer(notify=self._timeCb)
 self.host = host
 self.setStyleName('uniBox')
 self.addKeyboardListener(self)
 def removeKey(self, key):
 try:
 self.getCompletionItems().completions.remove(key)
 except KeyError:
 print "WARNING: trying to remove an unknown key"
 def showWarning(self, target_data):
 target_hook, _type, msg = target_data
 if _type == "NONE":
 return
 self._popup.setStyleName("warningPopup")
 if style:
 self._popup.addStyleName(style)
 left = 0
 top  = 0 #max(0, self.getAbsoluteTop() - contents.getOffsetHeight() - 2)
 self._popup.setPopupPosition(left, top)
 self._popup.show()
 def _timeCb(self, timer):
 if self._popup:
 @return: a tuple (selected, target_type, target info) with:
 - target_hook: None if we use the selected widget, (msg, data) if we have a hook (e.g. "@@: " for a public blog), where msg is the parsed message (i.e. without the "hook key: "@@: bla" become ("bla", None))
 - target_type: one of PUBLIC, GROUP, ONE2ONE, STATUS, MISC
 - msg: HTML message which will appear in the privacy warning banner """
 target = self._selected_cache
 def getSelectedOrStatus():
 if target:
 _type, msg = target.getWarningData()
 target_hook = None # we use the selected widget, not a hook
 else:
 if not txt.startswith('@'):
 target_hook, _type, msg = getSelectedOrStatus()
 elif txt.startswith('@@: '):
 _type = "PUBLIC"
 msg = MicroblogPanel.warning_msg_public
 target_hook = (txt[4:], None)
 elif txt.startswith('@'):
 _end = txt.find(': ')
 if _end == -1:
 target_hook, _type, msg = getSelectedOrStatus()
 else:
 msg = MicroblogPanel.warning_msg_group % group
 target_hook = (txt[_end+2:], group)
 else:
 print "ERROR: Unknown target"
 target_hook, _type, msg = getSelectedOrStatus()
 return (target_hook, _type, msg)
 def onBrowserEvent(self, event):
 #XXX: woraroung a pyjamas bug: self.currentEvent is not set
 #     so the TextBox's cancelKey doens't work. This is a workaround
 def onSelectedChange(self, selected):
 self._selected_cache = selected
 """def complete(self):
 #self.visible=False #XXX: self.visible is not unset in pyjamas when ENTER is pressed and a completion is done
 #XXX: fixed directly on pyjamas, if the patch is accepted, no need to walk around this
 return AutoCompleteTextBox.complete(self)"""
 class MicroblogItem():
 #XXX: should be moved in a separated module
 def __init__(self, data):
 self.id = data['id']
+self.type = data.get('type','main_item')
 self.content = data['content']
 self.author = data['author']
 self.timestamp = float(data.get('timestamp',0)) #XXX: int doesn't work here
+self.comments = data.get('comments', False)
+if self.comments:
+try:
+self.comments_hash = (data['comments_service'], data['comments_node'])
+self.comments_service = data['comments_service']
+self.comments_node = data['comments_node']
+except KeyError:
+print "Warning: can't manage comment [%s], some keys are missing in microblog data (%s)" % (data["comments"], data.keys())
+self.comments = False
+if set(("service","node")).issubset(data.keys()):
+self.service = data["service"]
+self.node = data["node"]
+self.hash = (self.service, self.node)
 class MicroblogEntry(SimplePanel, ClickHandler):
 def __init__(self, blog_panel, mblog_entry):
 SimplePanel.__init__(self)
 self._blog_panel = blog_panel
 self.author = mblog_entry.author
 self.timestamp = mblog_entry.timestamp
 _datetime = datetime.fromtimestamp(mblog_entry.timestamp)
+self.comments = mblog_entry.comments
 self.panel = HTMLPanel("""
 <div class='mb_entry_header'><span class='mb_entry_author'>%(author)s</span> on <span class='mb_entry_timestamp'>%(timestamp)s</span></div>
 <div class="mb_entry_avatar" id='id_avatar'></div>
 <div class="mb_entry_dialog">
 def updateAvatar(self, new_avatar):
 """Change the avatar of the entry
 @param new_avatar: path to the new image"""
 self.avatar.setUrl(new_avatar)
 def onClick(self, sender):
 print "microblog entry selected (author=%s)" % self.author
-self._blog_panel.setSelectedEntry(self)
+self._blog_panel.setSelectedEntry(self if self.comments else None)
 class MicroblogPanel(base_widget.LiberviaWidget):
 warning_msg_public = "This message will be PUBLIC and everybody will be able to see it, even people you don't know"
 warning_msg_group = "This message will be published for all the people of the group <span class='warningTarget'>%s</span>"
 base_widget.LiberviaWidget.__init__(self, host, ", ".join(accepted_groups), selectable = True)
 #base_widget.ScrollPanelWrapper.__init__(self)
 #DropCell.__init__(self)
 self.accepted_groups = accepted_groups
 self.entries = {}
+self.comments = {}
 self.selected_entry = None
 self.vpanel = VerticalPanel()
 self.vpanel.setStyleName('microblogPanel')
 self.setWidget(self.vpanel)
 host.FillMicroblogPanel(_new_panel)
 host.bridge.call('getMassiveLastMblogs', _new_panel.massiveInsert, 'ALL', [], 10)
 return _new_panel
 def getWarningData(self):
-if not self.accepted_groups:
+if self.selected_entry:
+if not self.selected_entry.comments:
+print ("ERROR: an item without comment is selected")
+return ("NONE", None)
+return ("PUBLIC", "This is a <span class='warningTarget'>comment</span> and keep the initial post visibility, so it is potentialy public")
+elif not self.accepted_groups:
 # we have a meta MicroblogPanel, we publish publicly
 return ("PUBLIC", self.warning_msg_public)
 else:
 # we only accept one group at the moment
 # FIXME: manage several groups
 return ("GROUP", self.warning_msg_group %  self.accepted_groups[0])
 def onTextEntered(self, text):
-if not self.accepted_groups:
+if self.selected_entry:
+# we are entering a comment
+comments_node = self.selected_entry.comments
+if not comments_node:
+raise Exception("ERROR: comments node is empty")
+self.host.bridge.call("sendMblogComment", None, comments_node, text)
+elif not self.accepted_groups:
+# we are entering a public microblog
 self.host.bridge.call("sendMblog", None, "PUBLIC", None, text)
 else:
+# we are entering a microblog restricted to a group
 # FIXME: manage several groups
 self.host.bridge.call("sendMblog", None, "GROUP", self.accepted_groups[0], text)
 def accept_all(self):
 return not self.accepted_groups #we accept every microblog only if we are not filtering by groups
 def getEntries(self):
 """Ask all the entries for the currenly accepted groups,
 and fill the panel"""
 def massiveInsert(self, mblogs):
 """Insert several microblogs at once
 @param mblogs: dictionary of microblogs, as the result of getMassiveLastGroupBlogs
 """
 print "Massive insertion of microblogs"
 for publisher in mblogs:
 print "adding blogs for [%s]" % publisher
 for mblog in mblogs[publisher]:
-if not mblog.has_key('content'):
+if not "content" in mblog:
 print ("WARNING: No content found in microblog [%s]", mblog)
 continue
-mblog_entry = MicroblogItem(mblog)
+mblog_item = MicroblogItem(mblog)
-self.addEntry(mblog_entry)
+self.addEntry(mblog_item)
-def addEntry(self, mblog_entry):
+def mblogsInsert(self, mblogs):
-"""Add an entry to the panel
+""" Insert several microblogs at once
-@param mblog_entry: MicroblogItem instance
+@param mblogs: list of microblogs
 """
-if mblog_entry.id in self.entries:
+for mblog in mblogs:
-return
+if not "content" in mblog:
-_entry = MicroblogEntry(self, mblog_entry)
+print ("WARNING: No content found in microblog [%s]", mblog)
-self.entries[mblog_entry.id] = _entry
+continue
+mblog_item = MicroblogItem(mblog)
+self.addEntry(mblog_item)
+def _chronoInsert(self, vpanel, entry, reverse = True):
+""" Insert an entry in chronological order
+@param vpanel: VerticalPanel instance
+@param entry: MicroblogEntry
+@param reverse: more recent entry on top if True, chronological order else"""
 # we look for the right index to insert our entry:
-# we insert the entry above the first entry
+# if reversed, we insert the entry above the first entry
 # in the past
 idx = 0
-for child in self.vpanel.children:
+for child in vpanel.children:
 if not isinstance(child, MicroblogEntry):
-break
+idx+=1
-if child.timestamp < mblog_entry.timestamp:
+continue
-break
+if reverse:
+if child.timestamp < entry.timestamp:
+break
+else:
+if child.timestamp > entry.timestamp:
+break
 idx+=1
-self.vpanel.insert(_entry,idx)
+vpanel.insert(entry, idx)
+def addEntry(self, mblog_item):
+"""Add an entry to the panel
+@param mblog_item: MicroblogItem instance
+"""
+if mblog_item.type == "comment":
+if not mblog_item.hash in self.comments:
+# The comments node is not known in this panel
+return
+_entry = MicroblogEntry(self, mblog_item)
+parent = self.comments[mblog_item.hash]
+parent_idx = self.vpanel.getWidgetIndex(parent)
+# we find or create the panel where the comment must be inserted
+try:
+sub_panel = self.vpanel.getWidget(parent_idx+1)
+except IndexError:
+sub_panel = None
+if not sub_panel or not isinstance(sub_panel, VerticalPanel):
+sub_panel = VerticalPanel()
+sub_panel.setStyleName('microblogPanel')
+sub_panel.addStyleName('subPanel')
+self.vpanel.insert(sub_panel, parent_idx+1)
+# we want comments to be inserted in chronological order
+self._chronoInsert(sub_panel, _entry, reverse=False)
+return
+if mblog_item.id in self.entries:
+return
+_entry = MicroblogEntry(self, mblog_item)
+self.entries[mblog_item.id] = _entry
+self._chronoInsert(self.vpanel, _entry)
+if mblog_item.comments:
+# entry has comments, we keep the comment node as a reference
+self.comments[mblog_item.comments_hash] = _entry
+self.host.bridge.call('getMblogComments', self.mblogsInsert, mblog_item.comments_service, mblog_item.comments_node)
 def setSelectedEntry(self, entry):
 if self.selected_entry == entry:
 entry = None
 if self.selected_entry:
 def updateValue(self, type, jid, value):
 """Update a jid value in entries
 @param type: one of 'avatar', 'nick'
 @param jid: jid concerned
 @param value: new value"""
+def updateVPanel(vpanel):
+for child in vpanel.children:
+if isinstance(child, MicroblogEntry) and child.author == jid:
+child.updateAvatar(value)
+elif isinstance(child, VerticalPanel):
+updateVPanel(child)
 if type=='avatar':
-for entry in self.entries.values():
+updateVPanel(self.vpanel)
-if entry.author == jid:
-entry.updateAvatar(value)
 def setAcceptedGroup(self, group):
 """Set the group which can be displayed in this panel
 @param group: string of the group, or list of string
 """
 def removeOccupant(self, nick):
 try:
 self.remove(self.occupants_list[nick])
 except KeyError:
 print "ERROR: trying to remove an unexisting nick"
 def clear(self):
 self.occupants_list.clear()
 AbsolutePanel.clear(self)
 class ChatPanel(base_widget.LiberviaWidget):
 def onQuit(self):
 base_widget.LiberviaWidget.onQuit(self)
 if self.type == 'group':
 self.host.bridge.call('mucLeave', None, self.target.bare)
 def setUserNick(self, nick):
 """Set the nick of the user, usefull for e.g. change the color of the user"""
 self.nick = nick
 def setPresents(self, nicks):
 """Set the users presents in this room
 @param occupants: list of nicks (string)"""
 self.occupants_list.clear()
 for nick in nicks:
 def getHistoryCB(history):
 for line in history:
 timestamp, from_jid, to_jid, message, mess_type = line
 self.printMessage(from_jid, message, timestamp)
 self.host.bridge.call('getHistory', getHistoryCB, self.host.whoami.bare, self.target.bare, size, True)
 def printInfo(self, msg, type='normal'):
 """Print general info
 @param msg: message to print
 @type: one of:
 normal: general info like "toto has joined the room"
 elif type == 'me':
 _wid.setStyleName('chatTextMe')
 else:
 _wid.setStyleName('chatTextInfo')
 self.content.add(_wid)
 def printMessage(self, from_jid, msg, timestamp=None):
 """Print message in chat window. Must be implemented by child class"""
 _jid=JID(from_jid)
 nick = _jid.node if self.type=='one2one' else _jid.resource
 mymess = _jid.resource == self.nick if self.type == "group" else  _jid.bare == self.host.whoami.bare #mymess = True if message comes from local user
 if msg.startswith('/me '):
 self.printInfo('* %s %s' % (nick, msg[4:]),type='me')
 return
 self.content.add(ChatText(timestamp, nick, mymess, msg))
 self.content_scroll.scrollToBottom()
 def startGame(self, game_type, referee, players):
 """Configure the chat window to start a game"""
 if game_type=="Tarot":
 if hasattr(self, "tarot_panel"):
 return
 self.vpanel.setCellHeight(self.tarot_panel, self.tarot_panel.getHeight())
 elif game_type=="RadioCol":
 #XXX: We can have double panel if we join quickly enough to have the group chat start signal
 #     on invitation + the one triggered on room join
 if hasattr(self, "radiocol_panel"):
 return
 self.radiocol_panel = RadioColPanel(self, referee, self.nick)
 self.vpanel.insert(self.radiocol_panel, 0)
 self.vpanel.setCellHeight(self.radiocol_panel, self.radiocol_panel.getHeight())
 def getGame(self, game_type):
 """Return class managing the game type"""
 #TODO: check that the game is launched, and manage errors
 if game_type=="Tarot":
 return self.tarot_panel
 elif game_type=="RadioCol":
 return self.radiocol_panel
 class WebPanel(base_widget.LiberviaWidget):
 """ (mini)browser like widget """
 def __init__(self, host, url=None):
 """
 @param host: SatWebFrontend instance
 """
 base_widget.LiberviaWidget.__init__(self, host)
 def onUrlClick(self, sender):
 self._frame.setUrl(self._url.getText())
 class ContactTabPanel(HorizontalPanel):
 """ TabPanel with a contacts list which can be hidden """
 def __init__(self, host, locked = False):
 self.host=host
 HorizontalPanel.__init__(self)
 self._left = VerticalPanel()
 contacts_switch = Button('<<', self._contactsSwitch)
 menu = Menu(host)
 #unibox
 unibox_panel = UniBoxPanel(host)
 self.host.setUniBox(unibox_panel.unibox)
 #status bar
 status = host.status_panel
 #contacts
 _contacts = VerticalPanel()
 contacts_switch = Button('<<', self._contactsSwitch)
 contacts_switch.addStyleName('contactsSwitch')
 _contacts.add(contacts_switch)
 _hpanel = HorizontalPanel()
 _hpanel.add(_contacts)
 _hpanel.add(self.tab_panel)
 self.add(_hpanel)
 self.setWidth("100%")
 Window.addWindowResizeListener(self)
 def _contactsSwitch(self, btn):
 """ (Un)hide contacts panel """

Mercurial > libervia-web

comparison browser_side/panels.py @ 202:2bc6cf004e61