libervia-web: browser_side/panels.py comparison

comparison browser_side/panels.py @ 312:b4781a350483

browser_side: display a "New message" button and add a "comment" icon for main entries in MicroblogPanel when the unibox is disabled

author	souliane <souliane@mailoo.org>
date	Mon, 30 Dec 2013 00:33:19 +0100
parents	3135ff840b8e
children	5ad70625867a

comparison

equal deleted inserted replaced

-:3135ff840b8e
+:b4781a350483
 # 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.empty = data.get('new', False)
-self.xhtml = data.get('xhtml')
+self.content = data.get('content', '')
+self.xhtml = data.get('xhtml', '')
 self.author = data['author']
 self.updated = float(data.get('updated', 0))  # XXX: int doesn't work here
 try:
 self.published = float(data['published'])  # XXX: int doesn't work here
 except KeyError:
 self.published = self.updated
 self.comments = data.get('comments', False)
-if self.comments:
+if self.empty and self.type == 'main_item':
+self.service = self.node = None
+self.hash = (self.service, self.node)
+else:
 try:
-self.comments_hash = (data['comments_service'], data['comments_node'])
+self.service = data['comments_service'] if self.comments else data['service']
-self.comments_service = data['comments_service']
+self.node = data['comments_node'] if self.comments else data['node']
-self.comments_node = data['comments_node']
+self.hash = (self.service, self.node)
 except KeyError:
-print "Warning: can't manage comment [%s], some keys are missing in microblog data (%s)" % (data["comments"], data.keys())
+logging.error("Warning: can't manage item [%s] some keys are missing in microblog data (%s)" % (self.id, data.keys()))
 self.comments = False
-if set(("service", "node")).issubset(data.keys()):
-# comment item
-self.service = data["service"]
-self.node = data["node"]
-else:
-# main item
-try:
-self.service = data['comments_service']
-self.node = data['comments_node']
-except KeyError:
-logging.error("Main item %s is missing its comments information!" % self.id)
-self.hash = (self.service, self.node)
 class MicroblogEntry(SimplePanel, ClickHandler, FocusHandler, KeyboardHandler):
-def __init__(self, blog_panel, mblog_entry):
+def __init__(self, blog_panel, data={}):
+"""
+@param blog_panel: the parent panel
+@param data: dict containing the blog item data, or a MicroblogItem instance.
+"""
+if isinstance(data, MicroblogItem):
+self._base_item = data
+else:
+self._base_item = MicroblogItem(data)
 SimplePanel.__init__(self)
 self._blog_panel = blog_panel
-self.entry = mblog_entry
-self.author = mblog_entry.author
-self.updated = mblog_entry.updated
-self.published = mblog_entry.published
-self.comments = mblog_entry.comments
-self.pub_data = (mblog_entry.hash[0], mblog_entry.hash[1], mblog_entry.id)
-self.editable_content = [mblog_entry.xhtml, const.SYNTAX_XHTML] if mblog_entry.xhtml else [mblog_entry.content, None]
 self.panel = FlowPanel()
 self.panel.setStyleName('mb_entry')
-update_text = u" — ✍ " + "<span class='mb_entry_timestamp'>%s</span>" % datetime.fromtimestamp(self.updated)
-header = HTMLPanel("""<div class='mb_entry_header'>
+self.header = HTMLPanel('')
-<span class='mb_entry_author'>%(author)s</span> on
+self.panel.add(self.header)
-<span class='mb_entry_timestamp'>%(published)s</span>%(updated)s
-</div>""" % {'author': html_sanitize(self.author),
+self.entry_actions = VerticalPanel()
-'published': datetime.fromtimestamp(self.published),
+self.entry_actions.setStyleName('mb_entry_actions')
-'updated': update_text if self.published != self.updated else ''
+self.panel.add(self.entry_actions)
-}
-)
-self.panel.add(header)
-if self.author == blog_panel.host.whoami.bare:
-entry_delete_update = VerticalPanel()
-entry_delete_update.setStyleName('mb_entry_delete_update')
-self.delete_label = Label(u"✗")
-self.delete_label.setTitle("Delete this message")
-self.update_label = Label(u"✍")
-self.update_label.setTitle("Edit this message")
-entry_delete_update.add(self.delete_label)
-entry_delete_update.add(self.update_label)
-self.delete_label.addClickListener(self)
-self.update_label.addClickListener(self)
-self.panel.add(entry_delete_update)
-else:
-self.update_label = self.delete_label = None
 entry_avatar = SimplePanel()
 entry_avatar.setStyleName('mb_entry_avatar')
-self.avatar = Image(blog_panel.host.getAvatar(self.author))
+self.avatar = Image(self._blog_panel.host.getAvatar(self.author))
 entry_avatar.add(self.avatar)
 self.panel.add(entry_avatar)
 self.entry_dialog = SimplePanel()
 self.entry_dialog.setStyleName('mb_entry_dialog')
-body = addURLToText(html_sanitize(mblog_entry.content)) if not mblog_entry.xhtml else mblog_entry.xhtml
-self.bubble = HTML(body)
-self.bubble.setStyleName("bubble")
-self.entry_dialog.add(self.bubble)
 self.panel.add(self.entry_dialog)
-self.editbox = None
 self.add(self.panel)
 ClickHandler.__init__(self)
 self.addClickListener(self)
-def onWindowResized(self, width=None, height=None):
+self.pub_data = (self.hash[0], self.hash[1], self.id)
-"""The listener is active when the text is being modified"""
+self._setContent()
-left = self.avatar.getAbsoluteLeft() + self.avatar.getOffsetWidth()
-right = self.delete_label.getAbsoluteLeft()
+def __getattr__(self, name):
-ideal_width = right - left - 60
+"""This allows to directly use the attributes of MicroblogItem"""
-self.entry_dialog.setWidth("%spx" % ideal_width)
+if hasattr(self, name):
+return self.__dict__[name]
+else:
+return getattr(self._base_item, name)
+def _setContent(self):
+"""Actually set the entry content (header, icons, bubble...)"""
+self.delete_label = self.update_label = self.comment_label = None
+self.bubble = self.editbox = None
+self._setHeader()
+if self.empty:
+self.editable_content = ['', const.SYNTAX_XHTML]
+else:
+self.editable_content = [self.xhtml, const.SYNTAX_XHTML] if self.xhtml else [self.content, None]
+self.setEntryDialog()
+self._setIcons()
+def _setHeader(self):
+"""Set the entry header"""
+if self.empty:
+return
+update_text = u" — ✍ " + "<span class='mb_entry_timestamp'>%s</span>" % datetime.fromtimestamp(self.updated)
+self.header.setHTML("""<div class='mb_entry_header'>
+<span class='mb_entry_author'>%(author)s</span> on
+<span class='mb_entry_timestamp'>%(published)s</span>%(updated)s
+</div>""" % {'author': html_sanitize(self.author),
+'published': datetime.fromtimestamp(self.published),
+'updated': update_text if self.published != self.updated else ''
+}
+)
+def _setIcons(self):
+"""Set the entry icons (delete, update, comment)"""
+if self.empty:
+return
+def addIcon(label, title):
+label = Label(label)
+label.setTitle(title)
+label.addClickListener(self)
+self.entry_actions.add(label)
+return label
+if self.author == self._blog_panel.host.whoami.bare:
+self.delete_label = addIcon(u"✗", "Delete this message")
+self.update_label = addIcon(u"✍", "Edit this message")
+if self.comments:
+self.comment_label = addIcon(u"↶", "Comment this message")
 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):
 if sender == self:
 self._blog_panel.setSelectedEntry(self if self.comments else None)
-elif sender == self.update_label:
-self._update()
 elif sender == self.delete_label:
 self._delete()
+elif sender == self.update_label:
+self.setEntryDialog(edit=True)
+elif sender == self.comment_label:
+self._comment()
 def onKeyUp(self, sender, keycode, modifiers):
 """Update is done when ENTER key is pressed within the raw editbox"""
 if sender != self.editbox or not self.editbox.getVisible():
 return
 if keycode == KEY_ENTER:
-self.updateContent()
+self._updateContent()
 def onLostFocus(self, sender):
 """Update is done when the focus leaves the raw editbox"""
 if sender != self.editbox or not self.editbox.getVisible():
 return
-self.updateContent()
+self._updateContent()
-def updateContent(self, cancel=False):
+def _updateContent(self, cancel=False):
-"""Send the new content to the backend"""
+"""Send the new content to the backend, remove the entry if it was
+an empty one (used for creating a new blog post)"""
 if not self.editbox or not self.editbox.getVisible():
 return
-Window.removeWindowResizeListener(self)
 self.entry_dialog.setWidth("auto")
 self.entry_dialog.remove(self.edit_panel)
 self.entry_dialog.add(self.bubble)
 new_text = self.editbox.getText().strip()
 self.edit_panel = self.editbox = None
+def removeNewEntry():
+if self.empty:
+self._blog_panel.removeEntry(self.type, self.id)
+if self.type == 'main_item':
+self._blog_panel.setUniBox(enable=False)
 if cancel or new_text == self.editable_content[0] or new_text == "":
+removeNewEntry()
 return
 self.editable_content[0] = new_text
 extra = {'published': str(self.published)}
-if self.entry.xhtml:
+if self.empty or self.xhtml:
 extra.update({'rich': new_text})
-self._blog_panel.host.bridge.call('updateMblog', None, self.pub_data, self.comments, new_text, extra)
+if self.empty:
+if self.type == 'main_item':
-def _update(self):
+self._blog_panel.host.bridge.call('sendMblog', None, None, self._blog_panel.accepted_groups, new_text, extra)
-"""Change the bubble to an editbox"""
+else:
-if self.editbox and self.editbox.getVisible():
+self._blog_panel.host.bridge.call('sendMblogComment', None, self._parent_entry.comments, new_text, extra)
-return
+else:
+self._blog_panel.host.bridge.call('updateMblog', None, self.pub_data, self.comments, new_text, extra)
-def setOriginalText(text, container):
+removeNewEntry()
-text = text.strip()
-container.original_text = text
+def setEntryDialog(self, edit=False):
-self.editbox.setWidth('100%')
+"""Set the bubble or the editor
-self.editbox.setText(text)
+@param edit: set to True to display the editor"""
-panel = SimplePanel()
+if edit:
-panel.add(container)
+if self.empty or self.xhtml:
-panel.setStyleName("bubble")
+if not self.editbox:
-panel.addStyleName('bubble-editbox')
-Window.addWindowResizeListener(self)
+def cb(result):
-self.onWindowResized()
+self._updateContent(result == richtext.CANCEL)
+options = ('no_recipient', 'no_sync_unibox', 'no_style', 'update_msg', 'no_close')
+editor = richtext.RichTextEditor(self._blog_panel.host, self.panel, cb, options=options)
+editor.setWidth('100%')
+self.editbox = editor.textarea
+editor.setVisible(True)  # needed to build the toolbar
+if self.editable_content[0]:
+self._blog_panel.host.bridge.call('syntaxConvert', lambda d: self._setOriginalText(d, editor),
+self.editable_content[0], self.editable_content[1])
+else:
+self._setOriginalText("", editor)
+else:
+if not self.editbox:
+self.editbox = TextArea()
+self.editbox.addFocusListener(self)
+self.editbox.addKeyboardListener(self)
+self._setOriginalText(self.editable_content[0], self.editbox)
+else:
+if not self.bubble:
+self.bubble = HTML()
+self.bubble.setStyleName("bubble")
+self.bubble.setHTML(addURLToText(html_sanitize(self.content)) if not self.xhtml else self.xhtml)
+self.entry_dialog.add(self.bubble)
+def _setOriginalText(self, text, container):
+"""Set the original text to be modified in the editor"""
+text = text.strip()
+container.original_text = text
+self.editbox.setWidth('100%')
+self.editbox.setText(text)
+panel = SimplePanel()
+panel.add(container)
+panel.setStyleName("bubble")
+panel.addStyleName('bubble-editbox')
+if self.bubble:
 self.entry_dialog.remove(self.bubble)
 self.entry_dialog.add(panel)
 self.editbox.setFocus(True)
+if text:
 self.editbox.setSelectionRange(len(text), 0)
 self.edit_panel = panel
 self.editable_content = [text, container.format if isinstance(container, richtext.RichTextEditor) else None]
-if self.entry.xhtml:
-options = ('no_recipient', 'no_sync_unibox', 'no_style', 'update_msg', 'no_close')
-def cb(result):
-self.updateContent(result == richtext.CANCEL)
-editor = richtext.RichTextEditor(self._blog_panel.host, self.panel, cb, options=options)
-editor.setWidth('100%')
-editor.setVisible(True)  # needed to build the toolbar
-self.editbox = editor.textarea
-self._blog_panel.host.bridge.call('syntaxConvert', lambda d: setOriginalText(d, editor),
-self.editable_content[0], self.editable_content[1])
-else:
-self.editbox = TextArea()
-self.editbox.addFocusListener(self)
-self.editbox.addKeyboardListener(self)
-setOriginalText(self.editable_content[0], self.editbox)
 def _delete(self):
 """Ask confirmation for deletion"""
 def confirm_cb(answer):
 if answer:
 target = 'message and all its comments' if self.comments else 'comment'
 _dialog = ConfirmDialog(confirm_cb, text="Do you really want to delete this %s?" % target)
 _dialog.show()
+def _comment(self):
+"""Add an empty entry for a new comment"""
+data = {'id': str(time()),
+'new': True,
+'type': 'comment',
+'author': self._blog_panel.host.whoami.bare,
+'service': self.service,
+'node': self.node
+}
+entry = self._blog_panel.addEntry(data)
+entry._parent_entry = self
+entry.setEntryDialog(edit=True)
 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>"
 """Panel used to show microblog
 @param accepted_groups: groups displayed in this panel, if empty, show all microblogs from all contacts
 """
 base_widget.LiberviaWidget.__init__(self, host, ", ".join(accepted_groups), selectable=True)
 self.setAcceptedGroup(accepted_groups)
+self.host = host
 self.entries = {}
 self.comments = {}
 self.selected_entry = None
 self.vpanel = VerticalPanel()
 self.vpanel.setStyleName('microblogPanel')
 self.setWidget(self.vpanel)
+self.setUniBox(self.host.uni_box)
+def setUniBox(self, enable=False):
+"""Enable or disable the unibox. If it is disabled,
+display the 'New message' button on top of the panel"""
+if enable:
+return
+if hasattr(self, 'new_button'):
+self.new_button.setVisible(True)
+else:
+def addBox():
+self.new_button.setVisible(False)
+data = {'id': str(time()),
+'new': True,
+'author': self.host.whoami.bare,
+}
+entry = self.addEntry(data)
+entry.setEntryDialog(edit=True)
+self.new_button = Button("New message", listener=addBox)
+self.new_button.setStyleName("microblogNewButton")
+self.vpanel.insert(self.new_button, 0)
 @classmethod
 def registerClass(cls):
 base_widget.LiberviaWidget.addDropKey("GROUP", cls.createPanel)
 base_widget.LiberviaWidget.addDropKey("CONTACT_TITLE", cls.createMetaPanel)
 print "adding blogs for [%s]" % publisher
 for mblog in mblogs[publisher]:
 if not "content" in mblog:
 print ("WARNING: No content found in microblog [%s]", mblog)
 continue
-mblog_item = MicroblogItem(mblog)
+self.addEntry(mblog)
-self.addEntry(mblog_item)
 def mblogsInsert(self, mblogs):
 """ Insert several microblogs at once
 @param mblogs: list of microblogs
 """
 for mblog in mblogs:
 if not "content" in mblog:
 print ("WARNING: No content found in microblog [%s]", mblog)
 continue
-mblog_item = MicroblogItem(mblog)
+self.addEntry(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"""
+if entry.empty:
+entry.published = time()
 # we look for the right index to insert our entry:
 # if reversed, we insert the entry above the first entry
 # in the past
 idx = 0
 break
 idx += 1
 vpanel.insert(entry, idx)
-def addEntry(self, mblog_item):
+def addEntry(self, data):
 """Add an entry to the panel
-@param mblog_item: MicroblogItem instance
+@param data: dict containing the item data
-"""
+@return: the added entry, or None
-if mblog_item.type == "comment":
+"""
-if not mblog_item.hash in self.comments:
+_entry = MicroblogEntry(self, data)
+if _entry.type == "comment":
+if not _entry.hash in self.comments:
 # The comments node is not known in this panel
-return
+return None
-_entry = MicroblogEntry(self, mblog_item)
+parent = self.comments[_entry.hash]
-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.setStyleName('microblogPanel')
 sub_panel.addStyleName('subPanel')
 self.vpanel.insert(sub_panel, parent_idx + 1)
 for idx in xrange(0, len(sub_panel.getChildren())):
 comment = sub_panel.getIndexedChild(idx)
-if comment.pub_data[2] == mblog_item.id:
+if comment.pub_data[2] == _entry.id:
 # update an existing comment
 sub_panel.remove(comment)
 sub_panel.insert(_entry, idx)
-return
+return _entry
 # we want comments to be inserted in chronological order
 self._chronoInsert(sub_panel, _entry, reverse=False)
-return
+return _entry
-update = mblog_item.id in self.entries
+if _entry.id in self.entries:  # update
-_entry = MicroblogEntry(self, mblog_item)
+idx = self.vpanel.getWidgetIndex(self.entries[_entry.id])
-if update:
+self.vpanel.remove(self.entries[_entry.id])
-idx = self.vpanel.getWidgetIndex(self.entries[mblog_item.id])
-self.vpanel.remove(self.entries[mblog_item.id])
 self.vpanel.insert(_entry, idx)
-else:
+else:  # new entry
 self._chronoInsert(self.vpanel, _entry)
-self.entries[mblog_item.id] = _entry
+self.entries[_entry.id] = _entry
-if mblog_item.comments:
+if _entry.comments:
 # entry has comments, we keep the comment node as a reference
-self.comments[mblog_item.comments_hash] = _entry
+self.comments[_entry.hash] = _entry
-self.host.bridge.call('getMblogComments', self.mblogsInsert, mblog_item.comments_service, mblog_item.comments_node)
+self.host.bridge.call('getMblogComments', self.mblogsInsert, _entry.service, _entry.node)
+return _entry
 def removeEntry(self, type_, id_):
 """Remove an entry from the panel
 @param type_: entry type ('main_item' or 'comment')
 @param id_: entry id
 """
 for child in self.vpanel.getChildren():
 if isinstance(child, MicroblogEntry) and type_ == 'main_item':
-print child.pub_data
 if child.pub_data[2] == id_:
 main_idx = self.vpanel.getWidgetIndex(child)
 try:
 sub_panel = self.vpanel.getWidget(main_idx + 1)
 if isinstance(sub_panel, VerticalPanel):

Mercurial > libervia-web

comparison browser_side/panels.py @ 312:b4781a350483