GitLab

at 2020-10-12T21:59:55+02:00

Blocking: Refactor module

VCard: Fix requesting software version

Add Chat Markers (XEP-0333)

Improvements

 

         # Menu for the HeaderBar

         self.control_menu = gui_menu_builder.get_singlechat_menu(

-            self.control_id, self.account, self.contact.jid)

+            self.control_id, self.account, self.contact.jid, self._type)

 

         # Settings menu

         self.xml.settings_menu.set_menu_model(self.control_menu)

             ('mam-decrypted-message-received', ged.GUI1, self._on_mam_decrypted_message_received),

             ('decrypted-message-received', ged.GUI1, self._on_decrypted_message_received),

             ('receipt-received', ged.GUI1, self._receipt_received),

+            ('displayed-received', ged.GUI1, self._displayed_received),

             ('message-error', ged.GUI1, self._on_message_error),

             ('zeroconf-error', ged.GUI1, self._on_zeroconf_error),

         ])

         act.connect('change-state', self._on_send_chatstate)

         self.parent_win.window.add_action(act)

 

+        marker = self.contact.settings.get('send_marker')

+

+        act = Gio.SimpleAction.new_stateful(

+            f'send-marker-{self.control_id}',

+            None,

+            GLib.Variant.new_boolean(marker))

+        act.connect('change-state', self._on_send_marker)

+        self.parent_win.window.add_action(act)

+

     def update_actions(self):

         win = self.parent_win.window

         online = app.account_is_connected(self.account)

             'information-',

             'start-call-',

             'send-chatstate-',

+            'send-marker',

         ]

         for action in actions:

             self.parent_win.window.remove_action(f'{action}{self.control_id}')

         action.set_state(param)

         self.contact.settings.set('send_chatstate', param.get_string())

 

+    def _on_send_marker(self, action, param):

+        action.set_state(param)

+        self.contact.settings.set('send_marker', param.get_boolean())

+

     def subscribe_events(self):

         """

         Register listeners to the events class

     def _receipt_received(self, event):

         self.conv_textview.show_receipt(event.receipt_id)

 

+    @event_filter(['account', 'jid'])

+    def _displayed_received(self, event):

+        self.conv_textview.show_displayed(event.marker_id)

+

     @event_filter(['account', 'jid'])

     def _on_zeroconf_error(self, event):

         self.add_status_message(event.message)

                 self.set_session(event.session)

         if message_ids:

             app.storage.archive.set_read_messages(message_ids)

+

+        # XEP-0333 Send <displayed> marker

+        con = app.connections[self.account]

+        con.get_module('ChatMarkers').send_displayed_marker(

+            self.contact,

+            self.last_msg_id,

+            self._type)

+        self.last_msg_id = None

         app.events.remove_events(self.account,

                                  jid_with_resource,

                                  types=[str(self._type)])

         self.received_history_pos = 0

         self.orig_msg = None

 

+        # For XEP-0333

+        self.last_msg_id = None

+

         self.correcting = False

         self.last_sent_msg = None

 

                     displaymarking=None,

                     msg_log_id=None,

                     message_id=None,

+                    stanza_id=None,

                     correct_id=None,

                     additional_data=None,

                     marker=None,

         if restored:

             return

 

+        if message_id:

+            if self._type.is_groupchat:

+                self.last_msg_id = stanza_id

+            else:

+                self.last_msg_id = message_id

+

         if kind == 'incoming':

             if (not self._type.is_groupchat or

                     self.contact.can_notify() or

 

                 event = event_type(text,

                                    subject,

-                                   self, msg_log_id,

+                                   self,

+                                   msg_log_id,

+                                   message_id=message_id,

+                                   stanza_id=stanza_id,

                                    show_in_roster=show_in_roster,

                                    show_in_systray=show_in_systray)

                 app.events.add_event(self.account, full_jid, event)

             jid = self.contact.jid

             if self.conv_textview.autoscroll:

                 # we are at the end

-                type_ = ['printed_%s' % self._type]

+                type_ = [f'printed_{self._type}']

                 if self._type.is_groupchat:

                     type_ = ['printed_gc_msg', 'printed_marked_gc_msg']

                 if not app.events.remove_events(self.account,

                                                 types=type_):

                     # There were events to remove

                     self.redraw_after_event_removed(jid)

+                    # XEP-0333 Send <displayed> marker

+                    con.get_module('ChatMarkers').send_displayed_marker(

+                        self.contact,

+                        self.last_msg_id,

+                        self._type)

+                    self.last_msg_id = None

             # send chatstate inactive to the one we're leaving

             # and active to the one we visit

             if self.msg_textview.has_text():

         types_list = []

         if self._type.is_groupchat:

             types_list = ['printed_gc_msg', 'gc_msg', 'printed_marked_gc_msg']

-        else: # Not a GC

-            types_list = ['printed_%s' % self._type, str(self._type)]

+        else:

+            types_list = [f'printed_{self._type}', str(self._type)]

 

         if not app.events.get_events(self.account, jid, types_list):

             return

         if not self.parent_win:

             return

-        if self.parent_win.get_active_control() == self and \

-        self.parent_win.window.is_active():

+        if (self.parent_win.get_active_control() == self and

+                self.parent_win.window.is_active()):

             # we are at the end

             if not app.events.remove_events(

                     self.account, jid, types=types_list):

                 # There were events to remove

                 self.redraw_after_event_removed(jid)

+                # XEP-0333 Send <displayed> tag

+                con = app.connections[self.account]

+                con.get_module('ChatMarkers').send_displayed_marker(

+                    self.contact,

+                    self.last_msg_id,

+                    self._type)

+                self.last_msg_id = None

 

     def _on_scrollbar_button_release(self, scrollbar, event):

         if event.get_button()[1] != 1:

         We just removed a 'printed_*' event, redraw contact in roster or

         gc_roster and titles in roster and msg_win

         """

+        if not self.parent_win:  # minimized groupchat

+            return

         self.parent_win.redraw_tab(self)

         self.parent_win.show_title()

         # TODO : get the contact and check get_show_in_roster()

     Namespace.SECLABEL,

     Namespace.CONFERENCE,

     Namespace.CORRECT,

+    Namespace.CHATMARKERS,

     Namespace.EME,

     Namespace.XHTML_IM,

     Namespace.HASHES_2,

 class PrintedChatEvent(Event):

     type_ = 'printed_chat'

     def __init__(self, message, subject, control, msg_log_id, time_=None,

-    show_in_roster=False, show_in_systray=True):

+                 message_id=None, stanza_id=None, show_in_roster=False,

+                 show_in_systray=True):

         Event.__init__(self, time_, show_in_roster=show_in_roster,

-            show_in_systray=show_in_systray)

+                       show_in_systray=show_in_systray)

         self.message = message

         self.subject = subject

         self.control = control

         self.msg_log_id = msg_log_id

+        self.message_id = message_id

+        self.stanza_id = stanza_id

 

 class PrintedGcMsgEvent(PrintedChatEvent):

     type_ = 'printed_gc_msg'

     'bookmarks',

     'caps',

     'carbons',

+    'chat_markers',

     'chatstates',

     'delimiter',

     'discovery',

 # XEP-0191: Blocking Command

 

 import nbxmpp

+from nbxmpp.protocol import JID

 from nbxmpp.namespaces import Namespace

 from nbxmpp.structs import StanzaHandler

-from nbxmpp.util import is_error_result

+from nbxmpp.modules.util import raise_if_error

 

 from gajim.common import app

 from gajim.common.nec import NetworkEvent

-from gajim.common.nec import NetworkIncomingEvent

 from gajim.common.modules.base import BaseModule

+from gajim.common.modules.util import as_task

 

 

 class Blocking(BaseModule):

     _nbxmpp_methods = [

         'block',

         'unblock',

-        'get_blocking_list',

+        'request_blocking_list',

     ]

 

     def __init__(self, con):

                           ns=Namespace.BLOCKING),

         ]

 

-        self._register_callback('get_blocking_list',

-                                self._blocking_list_received)

-

         self.supported = False

 

     def pass_disco(self, info):

 

         self._log.info('Discovered blocking: %s', info.jid)

 

-    def _blocking_list_received(self, result):

-        if is_error_result(result):

-            self._log.info(result)

-            return

+    @as_task

+    def get_blocking_list(self):

+        _task = yield

 

-        self.blocked = result.blocking_list

-        app.nec.push_incoming_event(

-            BlockingEvent(None, conn=self._con, changed=self.blocked))

+        blocking_list = yield self._nbxmpp('Blocking').request_blocking_list()

+

+        raise_if_error(blocking_list)

+

+        self.blocked = blocking_list

+        app.nec.push_incoming_event(NetworkEvent('blocking',

+                                                 conn=self._con,

+                                                 changed=self.blocked))

+        yield blocking_list

+

+    @as_task

+    def update_blocking_list(self, block, unblock):

+        _task = yield

+

+        if block:

+            result = yield self.block(block)

+            raise_if_error(result)

 

-    def _blocking_push_received(self, _con, stanza, _properties):

-        reply = stanza.buildReply('result')

-        children = reply.getChildren()

-        for child in children:

-            reply.delChild(child)

-        self._nbxmpp().send(reply)

+        if unblock:

+            result = yield self.unblock(unblock)

+            raise_if_error(result)

+

+        yield True

+

+    def _blocking_push_received(self, _con, _stanza, properties):

+        if not properties.is_blocking:

+            return

 

         changed_list = []

 

-        unblock = stanza.getTag('unblock', namespace=Namespace.BLOCKING)

-        if unblock is not None:

-            items = unblock.getTags('item')

-            if not items:

-                # Unblock all

-                changed_list = list(self.blocked)

-                self.blocked = []

-                for jid in self.blocked:

-                    self._presence_probe(jid)

-                self._log.info('Unblock all Push')

-                raise nbxmpp.NodeProcessed

-

-            for item in items:

-                # Unblock some contacts

-                jid = item.getAttr('jid')

-                changed_list.append(jid)

-                if jid not in self.blocked:

-                    continue

-                self.blocked.remove(jid)

+        if properties.blocking.unblock_all:

+            self.blocked = []

+            for jid in self.blocked:

                 self._presence_probe(jid)

-                self._log.info('Unblock Push: %s', jid)

-

-        block = stanza.getTag('block', namespace=Namespace.BLOCKING)

-        if block is not None:

-            for item in block.getTags('item'):

-                jid = item.getAttr('jid')

-                if jid in self.blocked:

-                    continue

-                changed_list.append(jid)

-                self.blocked.append(jid)

-                self._set_contact_offline(jid)

-                self._log.info('Block Push: %s', jid)

-

-        app.nec.push_incoming_event(

-            BlockingEvent(None, conn=self._con, changed=changed_list))

+            self._log.info('Unblock all Push')

+

+        for jid in properties.blocking.unblock:

+            changed_list.append(jid)

+            if jid not in self.blocked:

+                continue

+            self.blocked.remove(jid)

+            self._presence_probe(jid)

+            self._log.info('Unblock Push: %s', jid)

+

+        for jid in properties.blocking.block:

+            if jid in self.blocked:

+                continue

+            changed_list.append(jid)

+            self.blocked.append(jid)

+            self._set_contact_offline(str(jid))

+            self._log.info('Block Push: %s', jid)

+

+        app.nec.push_incoming_event(NetworkEvent('blocking',

+                                                 conn=self._con,

+                                                 changed=changed_list))

 

         raise nbxmpp.NodeProcessed

 

         for contact in contact_list:

             contact.show = 'offline'

 

-    def _presence_probe(self, jid: str) -> None:

+    def _presence_probe(self, jid: JID) -> None:

         self._log.info('Presence probe: %s', jid)

         # Send a presence Probe to get the current Status

         probe = nbxmpp.Presence(jid, 'probe', frm=self._con.get_own_jid())

         self._nbxmpp().send(probe)

 

 

-class BlockingEvent(NetworkIncomingEvent):

-    name = 'blocking'

-

-

 def get_instance(*args, **kwargs):

     return Blocking(*args, **kwargs), 'Blocking'
+# This file is part of Gajim.

+#

+# Gajim is free software; you can redistribute it and/or modify

+# it under the terms of the GNU General Public License as published

+# by the Free Software Foundation; version 3 only.

+#

+# Gajim 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 General Public License for more details.

+#

+# You should have received a copy of the GNU General Public License

+# along with Gajim.  If not, see <http://www.gnu.org/licenses/>.

+

+# Chat Markers (XEP-0333)

+

+import nbxmpp

+from nbxmpp.namespaces import Namespace

+from nbxmpp.structs import StanzaHandler

+

+from gajim.common import app

+from gajim.common.nec import NetworkEvent

+from gajim.common.modules.base import BaseModule

+

+

+class ChatMarkers(BaseModule):

+

+    _nbxmpp_extends = 'ChatMarkers'

+

+    def __init__(self, con):

+        BaseModule.__init__(self, con)

+

+        self.handlers = [

+            StanzaHandler(name='message',

+                          callback=self._process_chat_marker,

+                          ns=Namespace.CHATMARKERS,

+                          priority=47),

+        ]

+

+    def _process_chat_marker(self, _con, _stanza, properties):

+        if not properties.is_marker or not properties.marker.is_displayed:

+            return

+

+        if properties.type.is_error:

+            return

+

+        if properties.type.is_groupchat:

+            manager = self._con.get_module('MUC').get_manager()

+            muc_data = manager.get(properties.muc_jid)

+            if muc_data is None:

+                return

+

+            if properties.muc_nickname != muc_data.nick:

+                return

+

+            self._raise_event('read-state-sync', properties)

+            return

+

+        if properties.is_carbon_message and properties.carbon.is_sent:

+            self._raise_event('read-state-sync', properties)

+            return

+

+        if properties.is_mam_message:

+            if properties.from_.bareMatch(self._con.get_own_jid()):

+                return

+

+        self._raise_event('displayed-received', properties)

+

+    def _raise_event(self, name, properties):

+        self._log.info('%s: %s %s',

+                       name,

+                       properties.jid,

+                       properties.marker.id)

+

+        jid = properties.jid

+        if not properties.is_muc_pm and not properties.type.is_groupchat:

+            jid = properties.jid.bare

+

+        app.nec.push_outgoing_event(

+            NetworkEvent(name,

+                         account=self._account,

+                         jid=jid,

+                         properties=properties,

+                         type=properties.type,

+                         is_muc_pm=properties.is_muc_pm,

+                         marker_id=properties.marker.id))

+

+    def _send_marker(self, contact, marker, id_, type_):

+        jid = contact.jid

+        if contact.is_pm_contact:

+            jid = app.get_jid_without_resource(contact.jid)

+

+        if type_ in ('gc', 'pm'):

+            if not app.settings.get_group_chat_setting(

+                    self._account, jid, 'send_marker'):

+                return

+        else:

+            if not app.settings.get_contact_setting(

+                    self._account, jid, 'send_marker'):

+                return

+

+        typ = 'groupchat' if type_ == 'gc' else 'chat'

+        message = nbxmpp.Message(to=contact.jid, typ=typ)

+        message.setMarker(marker, id_)

+        self._log.info('Send %s: %s', marker, contact.jid)

+        self._nbxmpp().send(message)

+

+    def send_displayed_marker(self, contact, id_, type_):

+        self._send_marker(contact, 'displayed', id_, str(type_))

+

+

+def get_instance(*args, **kwargs):

+    return ChatMarkers(*args, **kwargs), 'ChatMarkers'
         stanza.setID(message.message_id)

         stanza.setOriginID(message.message_id)

 

+        stanza.setMarkable()

+

         if message.label:

             stanza.addChild(node=message.label)

 

                 stanza.setTag('no-store',

                               namespace=Namespace.MSG_HINTS)

 

+        # XEP-0333

+        if message.message:

+            stanza.setMarkable()

+

         # Add other nodes

         if message.nodes is not None:

             for node in message.nodes:

         'filetransfer_preference': 'httpupload',

         'send_chatstate_default': 'composing_only',

         'gc_send_chatstate_default': 'composing_only',

+        'send_marker_default': True,

+        'gc_send_marker_default': True,

         'chat_history_max_age': -1,

     },

 

     'contact': {

         'speller_language': '',

         'send_chatstate': HAS_ACCOUNT_DEFAULT,

+        'send_marker': HAS_ACCOUNT_DEFAULT,

         'encryption': '',

     },

 

         'minimize_on_autojoin': True,

         'minimize_on_close': True,

         'send_chatstate': HAS_ACCOUNT_DEFAULT,

+        'send_marker': HAS_ACCOUNT_DEFAULT,

         'encryption': '',

         'sync_threshold': HAS_APP_DEFAULT,

     },

 from gajim.common import helpers

 from gajim.common import i18n

 from gajim.common.i18n import _

+from gajim.common.i18n import Q_

 from gajim.common.helpers import AdditionalDataDict

 from gajim.common.const import StyleAttr

 from gajim.common.const import Trust

             return

         line.set_receipt()

 

+    def show_displayed(self, id_):

+        line = self._get_message_line(id_)

+        if line is None:

+            return

+        line.set_displayed()

+

     def show_error(self, id_, error):

         line = self._get_message_line(id_)

         if line is None:

         self.timestamp = timestamp

         self.start_mark = start_mark

         self._has_receipt = False

+        self._has_displayed = False

         self._message_icons = message_icons

 

     @property

     def has_receipt(self):

         return self._has_receipt

 

+    @property

+    def has_displayed(self):

+        return self._has_displayed

+

     def set_receipt(self):

         self._has_receipt = True

+        if self._has_displayed:

+            return

         self._message_icons.set_receipt_icon_visible(True)

 

+    def set_displayed(self):

+        self._has_displayed = True

+        self._message_icons.set_displayed_icon_visible(True)

+

     def set_correction(self, tooltip):

         self._message_icons.set_correction_icon_visible(True)

         self._message_icons.set_correction_tooltip(tooltip)

             'document-edit-symbolic', Gtk.IconSize.MENU)

         self._correction_image.set_no_show_all(True)

 

-        self._receipt_image = Gtk.Image.new_from_icon_name(

+        self._marker_image = Gtk.Image.new_from_icon_name(

             'emblem-ok-symbolic', Gtk.IconSize.MENU)

-        self._receipt_image.get_style_context().add_class(

+        self._marker_image.get_style_context().add_class(

             'receipt-received-color')

-        self._receipt_image.set_tooltip_text(_('Received'))

-        self._receipt_image.set_no_show_all(True)

+        self._marker_image.set_tooltip_text(_('Received'))

+        self._marker_image.set_no_show_all(True)

 

         self._error_image = Gtk.Image.new_from_icon_name(

             'dialog-warning-symbolic', Gtk.IconSize.MENU)

         self._error_image.set_no_show_all(True)

 

         self.add(self._correction_image)

-        self.add(self._receipt_image)

+        self.add(self._marker_image)

         self.add(self._error_image)

         self.show_all()

 

     def set_receipt_icon_visible(self, visible):

         if not app.settings.get('positive_184_ack'):

             return

-        self._receipt_image.set_visible(visible)

+        self._marker_image.set_visible(visible)

+

+    def set_displayed_icon_visible(self, visible):

+        self._marker_image.set_visible(visible)

+        self._marker_image.get_style_context().remove_class(

+            'receipt-received-color')

+        self._marker_image.get_style_context().add_class(

+            'displayed-received-color')

+        self._marker_image.set_tooltip_text(Q_('?Message state:Read'))

 

     def set_correction_icon_visible(self, visible):

         self._correction_image.set_visible(visible)

 

 /*Receipts*/

 .receipt-received-color { color: rgb(75, 181, 67); }

+.displayed-received-color { color: rgb(0, 141, 242); }

 

 /*Dataforms*/

 .field-fixed { font-size: 16px; font-weight: bold; padding-top:5px;}

         self.update_actions()

         self.set_lock_image()

         self.draw_banner_text()

+        type_ = ['printed_gc_msg', 'printed_marked_gc_msg']

+        if not app.events.remove_events(self.account,

+                                        self.get_full_jid(),

+                                        types=type_):

+            # XEP-0333 Send <displayed> marker

+            con = app.connections[self.account]

+            con.get_module('ChatMarkers').send_displayed_marker(

+                self.contact,

+                self.last_msg_id,

+                self._type)

+            self.last_msg_id = None

 

     def _on_roster_row_activated(self, _roster, nick):

         self._start_private_message(nick)

                              displaymarking=event.displaymarking,

                              correct_id=event.correct_id,

                              message_id=event.properties.id,

+                             stanza_id=event.properties.stanza_id.id,

                              additional_data=event.additional_data)

         event.needs_highlight = self.needs_visual_notification(event.msgtxt)

 

     def on_private_message(self, nick, sent, msg, tim, session, additional_data,

-                           msg_log_id=None, displaymarking=None):

+                           message_id, msg_log_id=None, displaymarking=None):

         # Do we have a queue?

         fjid = self.room_jid + '/' + nick

 

                                session=session,

                                displaymarking=displaymarking,

                                sent_forwarded=sent,

-                               additional_data=additional_data)

+                               additional_data=additional_data,

+                               message_id=message_id)

+

         app.events.add_event(self.account, fjid, event)

 

         if allow_popup_window(self.account):

 

     def add_message(self, text, contact='', tim=None,

                     displaymarking=None, correct_id=None, message_id=None,

-                    additional_data=None):

+                    stanza_id=None, additional_data=None):

         """

         Add message to the ConversationsTextview

 

                                     displaymarking=displaymarking,

                                     correct_id=correct_id,

                                     message_id=message_id,

+                                    stanza_id=stanza_id,

                                     additional_data=additional_data)

 

     def get_nb_unread(self):

                                     event.properties.timestamp,

                                     self.session,

                                     event.additional_data,

+                                    event.properties.id,

                                     msg_log_id=event.msg_log_id,

                                     displaymarking=event.displaymarking)

 

 

 import logging

 

-from nbxmpp.util import is_error_result

+from nbxmpp.errors import StanzaError

 from gi.repository import Gtk

 from gi.repository import Gdk

 from gi.repository import GLib

         self.account = account

         self._con = app.connections[account]

         self._prev_blocked_jids = set()

-        self._await_results = 2

-        self._received_errors = False

 

         self._ui = get_builder('blocking_list.ui')

         self.add(self._ui.blocking_grid)

 

         self._activate_spinner()

 

-        self._con.get_module('Blocking').get_blocking_list(

+        self._con.get_module('Blocking').request_blocking_list(

             callback=self._on_blocking_list_received)

 

-    def _reset_after_error(self):

-        self._received_errors = False

-        self._await_results = 2

-        self._disable_spinner()

-        self._set_grid_state(True)

-

     def _show_error(self, error):

         dialog = HigDialog(

             self, Gtk.MessageType.INFO, Gtk.ButtonsType.OK,

             GLib.markup_escape_text(error))

         dialog.popup()

 

-    def _on_blocking_list_received(self, result):

-        is_error = is_error_result(result)

-        self._disable_spinner()

-        self._set_grid_state(not is_error)

+    def _on_blocking_list_received(self, task):

+        try:

+            blocking_list = task.finish()

+        except StanzaError as error:

+            self._set_grid_state(False)

+            self._show_error(to_user_string(error))

+            return

 

-        if is_error:

-            self._show_error(to_user_string(result))

+        self._prev_blocked_jids = set(blocking_list)

+        self._ui.blocking_store.clear()

+        for item in blocking_list:

+            self._ui.blocking_store.append((item,))

 

-        else:

-            self._prev_blocked_jids = set(result.blocking_list)

-            self._ui.blocking_store.clear()

-            for item in result.blocking_list:

-                self._ui.blocking_store.append((item,))

+        self._set_grid_state(True)

+        self._disable_spinner()

 

-    def _on_save_result(self, result):

-        self._await_results -= 1

-        if is_error_result(result) and not self._received_errors:

-            self._show_error(to_user_string(result))

-            self._received_errors = True

+    def _on_save_result(self, task):

+        try:

+            _successful = task.finish()

+        except StanzaError as error:

+            self._show_error(to_user_string(error))

+            self._disable_spinner()

+            self._set_grid_state(True)

+            return

 

-        if not self._await_results:

-            if self._received_errors:

-                self._reset_after_error()

-            else:

-                self.destroy()

+        self.destroy()

 

     def _set_grid_state(self, state):

         self._ui.blocking_grid.set_sensitive(state)

             blocked_jids.add(item[0].lower())

 

         unblock_jids = self._prev_blocked_jids - blocked_jids

-        if unblock_jids:

-            self._con.get_module('Blocking').unblock(

-                unblock_jids, callback=self._on_save_result)

-        else:

-            self._await_results -= 1

-

         block_jids = blocked_jids - self._prev_blocked_jids

-        if block_jids:

-            self._con.get_module('Blocking').block(

-                block_jids, callback=self._on_save_result)

-        else:

-            self._await_results -= 1

-

-        if not self._await_results:

-            # No changes

-            self.destroy()

+

+        self._con.get_module('Blocking').update_blocking_list(

+            block_jids, unblock_jids, callback=self._on_save_result)

 

     def _activate_spinner(self):

         self._spinner.show()

                     'send_chatstate',

                     props={'entries': chat_state}),

 

+            Setting(SettingKind.SWITCH,

+                    _('Send Chat Markers'),

+                    SettingType.GROUP_CHAT,

+                    'send_marker',

+                    desc=_('Let others know if you read up to this point')),

+

             Setting(SettingKind.POPOVER,

                     _('Sync Threshold'),

                     SettingType.GROUP_CHAT,

         if ctrl and ctrl.session and len(obj.contact_list) > 1:

             ctrl.remove_session(ctrl.session)

 

+    @staticmethod

+    def handle_event_read_state_sync(event):

+        if event.type.is_groupchat:

+            control = app.get_groupchat_control(

+                event.account, event.jid.bare)

+            if control is None:

+                log.warning('Groupchat control not found')

+                return

+

+            jid = event.jid.bare

+            types = ['printed_gc_msg', 'printed_marked_gc_msg']

+

+        else:

+            types = ['chat', 'pm', 'printed_chat', 'printed_pm']

+            jid = event.jid

+

+            control = app.interface.msg_win_mgr.get_control(jid, event.account)

+

+        # Compare with control.last_msg_id.

+        events_ = app.events.get_events(event.account, jid, types)

+        if not events_:

+            log.warning('No Events')

+            return

+

+        if event.type.is_groupchat:

+            id_ = events_[-1].stanza_id

+        else:

+            id_ = events_[-1].message_id

+

+        if id_ != event.marker_id:

+            return

+

+        if not app.events.remove_events(event.account, jid, types=types):

+            # There were events to remove

+            if control is not None:

+                control.redraw_after_event_removed(event.jid)

+

     @staticmethod

     def handle_event_msgsent(obj):

         if not obj.play_sound:

             'unsubscribed-presence-received': [

                 self.handle_event_unsubscribed_presence],

             'zeroconf-name-conflict': [self.handle_event_zc_name_conflict],

+            'read-state-sync': [self.handle_event_read_state_sync],

         }

 

     def register_core_handlers(self):

     return menu

 

 

-def get_singlechat_menu(control_id, account, jid):

+def get_singlechat_menu(control_id, account, jid, type_):

     singlechat_menu = [

         (_('Send File'), [

             ('win.send-file-httpupload-', _('Upload File…')),

             ('win.send-file-jingle-', _('Send File Directly…')),

             ]),

+        ('win.send-marker-', _('Send Read Markers')),

         (_('Send Chatstate'), ['chatstate']),

         ('win.invite-contacts-', _('Invite Contacts…')),

         ('win.add-to-roster-', _('Add to Contact List…')),

         for item in preset:

             if isinstance(item[1], str):

                 action_name, label = item

+                if action_name == 'win.send-marker-' and type_ == 'pm':

+                    continue

+

                 if action_name == 'app.browse-history':

                     menuitem = Gio.MenuItem.new(label, action_name)

                     dict_ = {'account': GLib.Variant('s', account),

 

     def _nec_blocking(self, obj):

         for jid in obj.changed:

-            self.draw_contact(jid, obj.conn.name)

+            self.draw_contact(str(jid), obj.conn.name)

 

     def on_block(self, widget, list_):

         """

 from gi.repository import GLib

 from gi.repository import Gdk

 from nbxmpp.structs import AnnotationNote

-from nbxmpp.util import is_error_result

+from nbxmpp.errors import StanzaError

 from nbxmpp.protocol import JID

 from nbxmpp.errors import is_error

 

         self._set_values(vcard.data, str(jid))

         self._load_avatar(vcard)

 

-    def set_os_info(self, result, jid):

+    def set_os_info(self, task):

+        error = False

+        try:

+            result = task.finish()

+        except StanzaError:

+            error = True

+

+        jid = task.get_user_data()

+

         if self.xml.get_object('information_notebook').get_n_pages() < 5:

             return

 

-        error = is_error_result(result)

         i = 0

         client = ''

         os_info = ''

Daniel Brötzmann pushed to branch chat_markers at gajim / gajim

Commits:

18 changed files:

Changes: