GitLab

at 2020-11-03T18:00:05+01:00

HTTPUpload: Correctly unpack headers

Fixes #10337

Portable: Move config path parameter to application

If a user called bin/Gajim.exe directly config_path parameter was ignored,
which could lead to problems with non-portable user settings.

Init: Fix IS_PORTABLE check

Init: Remove os dependency

Raise nbxmpp version

Windows: Remove unused function from build script

Windows: Fix build instructions

Windows: Clean up build instructions

MusicTrackListener: Get currently playing song asynchronously

Fixes #10339.

Add Chat Markers (XEP-0333)

Improvements

Improvements 2

-import os

 import subprocess

+import sys

+from pathlib import Path

 __version__ = "1.2.91"

-IS_FLATPAK = False

-if os.path.exists('/app/share/run-as-flatpak'):

-    IS_FLATPAK = True

+IS_FLATPAK = Path('/app/share/run-as-flatpak').exists()

-IS_PORTABLE = False

-portable_path = os.path.join(os.getcwd(), 'is_portable')

-if os.path.exists(portable_path):

-    IS_PORTABLE = True

+portable_path = Path(sys.executable).parent / 'is_portable'

+IS_PORTABLE = portable_path.exists()

 try:

     p = subprocess.Popen('git rev-parse --short=12 HEAD', shell=True,

         # 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)

             tooltip_text = _('No File Transfer available')

         self.xml.sendfile_button.set_tooltip_text(tooltip_text)

+        # Chat markers

+        state = GLib.Variant.new_boolean(

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

+        win.lookup_action(

+            f'send-marker-{self.control_id}').change_state(state)

+

         # Convert to GC

         if app.settings.get_account_setting(self.account, 'is_zeroconf'):

             win.lookup_action(

             '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 or message_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()

         self.custom_config_root = None  # type: Optional[Path]

         if os.name == 'nt':

-            try:

+            if gajim.IS_PORTABLE:

+                application_path = Path(sys.executable).parent

+                self.config_root = self.cache_root = self.data_root = \

+                        application_path.parent / 'UserData'

+            else:

                 # Documents and Settings\[User Name]\Application Data\Gajim

                 self.config_root = self.cache_root = self.data_root = \

                         Path(os.environ['appdata']) / 'Gajim'

-            except KeyError:

-                # win9x, in cwd

-                self.config_root = self.cache_root = self.data_root = Path('.')

         else:

             self.config_root = Path(GLib.get_user_config_dir()) / 'gajim'

             self.cache_root = Path(GLib.get_user_cache_dir()) / 'gajim'

     Namespace.SECLABEL,

     Namespace.CONFERENCE,

     Namespace.CORRECT,

+    Namespace.CHATMARKERS,

     Namespace.EME,

     Namespace.XHTML_IM,

     Namespace.HASHES_2,

                 self._add_player(name)

         for name in list(self.players):

-            info = self._get_playing_track(name)

-            if info is not None:

-                self._emit(info)

+            self._get_playing_track(name)

     def stop(self):

         for name in list(self.players):

         '''Signal handler for PropertiesChanged event'''

         log.info('Signal received: %s - %s', interface_name, parameters)

-

-        info = self._get_playing_track(user_data[0])

-

-        self._emit(info)

+        self._get_playing_track(user_data[0])

     @staticmethod

     def _get_music_info(properties):

             'org.freedesktop.DBus.Properties',

             None)

-        try:

-            result = proxy.call_sync(

-                "GetAll",

-                GLib.Variant('(s)', ('org.mpris.MediaPlayer2.Player',)),

-                Gio.DBusCallFlags.NONE,

-                -1,

-                None)

-        except GLib.Error as error:

-            log.debug("Could not enable music listener: %s", error.message)

-            return None

+        def proxy_call_finished(proxy, res):

+            try:

+                result = proxy.call_finish(res)

+            except GLib.Error as error:

+                log.debug("Could not enable music listener: %s", error.message)

+                return

+

+            info = self._get_music_info(result[0])

+            if info is not None:

+                self._emit(info)

-        return self._get_music_info(result[0])

+        proxy.call("GetAll",

+                   GLib.Variant('(s)', ('org.mpris.MediaPlayer2.Player',)),

+                   Gio.DBusCallFlags.NONE,

+                   -1,

+                   None,

+                   proxy_call_finished)

 def enable():

 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',

+# 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)

+

+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

+from gajim.common.structs import OutgoingMessage

+

+

+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'):

+            disco_info = app.storage.cache.get_last_disco_info(jid)

+

+            context = 'public'

+            if disco_info is not None and disco_info.muc_is_members_only:

+                context = 'private'

+

+            if not app.settings.get_group_chat_setting(

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

+                return

+        else:

+            if not app.settings.get_contact_setting(

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

+                return

+

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

+        message = OutgoingMessage(account=self._account,

+                                  contact=contact,

+                                  message=None,

+                                  type_=typ,

+                                  marker=(marker, id_),

+                                  play_sound=False)

+        self._con.send_message(message)

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

+

+    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'

         message.props.request_headers.set_content_type(transfer.mime, None)

         message.props.request_headers.set_content_length(transfer.size)

-        for name, value in transfer.headers:

+        for name, value in transfer.headers.items():

             message.props.request_headers.append(name, value)

         message.connect('wrote-headers', self._on_wrote_headers, transfer)

                 stanza.setTag('no-store',

                               namespace=Namespace.MSG_HINTS)

+        # XEP-0333

+        if message.message:

+            stanza.setMarkable()

+        if message.marker:

+            marker, id_ = message.marker

+            stanza.setMarker(marker, id_)

+

         # 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_private_default': True,

+        'gc_send_marker_public_default': False,

         '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,

     },

     def set_group_chat_settings(self,

                                 setting: str,

-                                value: SETTING_TYPE) -> None:

+                                value: SETTING_TYPE,

+                                context: str = None) -> None:

         for account in self._account_settings:

             for jid in self._account_settings[account]['group_chat']:

-                self.set_group_chat_setting(account, jid, setting, value)

+                self.set_group_chat_setting(

+                    account, jid, setting, value, context)

     def get_contact_setting(self,

                             account: str,

                  type_,

                  subject=None,

                  chatstate=None,

+                 marker=None,

                  resource=None,

                  user_nick=None,

                  label=None,

         if type_ not in ('chat', 'groupchat', 'normal', 'headline'):

             raise ValueError('Unknown message type: %s' % type_)

-        if not message and chatstate is None:

+        if not message and chatstate is None and marker is None:

             raise ValueError('Trying to send message without content')

         self.account = account

         self.subject = subject

         self.chatstate = chatstate

+        self.marker = marker

         self.resource = resource

         self.user_nick = user_nick

         self.label = label

 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;}

 from gajim.common import i18n

-_MIN_NBXMPP_VER = '1.91.0'

+_MIN_NBXMPP_VER = '1.99.0'

 _MIN_GTK_VER = '3.22.27'

 _MIN_CAIRO_VER = '1.16.0'

 _MIN_PYGOBJECT_VER = '3.32.0'

         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)

         else:

             if event.properties.muc_nickname == self.nick:

                 self.last_sent_txt = event.msgtxt

+            stanza_id = None

+            if event.properties.stanza_id:

+                stanza_id = event.properties.stanza_id.id

             self.add_message(event.msgtxt,

                              contact=event.properties.muc_nickname,

                              tim=event.properties.timestamp,

                              displaymarking=event.displaymarking,

                              correct_id=event.correct_id,

                              message_id=event.properties.id,

+                             stanza_id=stanza_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)

                            'button-style': 'destructive-action',

                            'button-callback': self._reset_gc_send_chatstate}),

+            Setting(SettingKind.SWITCH,

+                    _('Send Read Markers'),

+                    SettingType.VALUE,

+                    app.settings.get_account_setting(

+                        account, 'send_marker_default'),

+                    callback=self._send_read_marker,

+                    desc=_('Default for chats and private group chats'),

+                    props={'button-text': _('Reset'),

+                           'button-tooltip': _('Reset all chats to the '

+                                               'current default value'),

+                           'button-style': 'destructive-action',

+                           'button-callback': self._reset_send_read_marker}),

+

             Setting(SettingKind.POPOVER,

                     _('Keep Chat History'),

                     SettingType.ACCOUNT_CONFIG,

         button.set_sensitive(False)

         app.settings.set_group_chat_settings('send_chatstate', None)

+    def _send_read_marker(self, state, _data):

+        app.settings.set_account_setting(

+            self._account, 'send_marker_default', state)

+        app.settings.set_account_setting(

+            self._account, 'gc_send_marker_private_default', state)

+

+    def _reset_send_read_marker(self, button):

+        button.set_sensitive(False)

+        app.settings.set_contact_settings('send_marker', None)

+        app.settings.set_group_chat_settings(

+            'send_marker', None, context='private')

+        for ctrl in app.interface.msg_win_mgr.get_controls(acct=self._account):

+            ctrl.update_actions()

+

 class ConnectionPage(GenericSettingPage):

                     'send_chatstate',

                     props={'entries': chat_state}),

+            Setting(SettingKind.SWITCH,

+                    _('Send Chat Markers'),

+                    SettingType.GROUP_CHAT,

+                    'send_marker',

+                    context=context,

+                    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 or events_[-1].message_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),

 install_requires =

     css-parser

     keyring

-    nbxmpp>=1.91.0

+    nbxmpp>=1.99.0

     packaging

     precis-i18n>=1.0.0

     pyOpenSSL>=16.2

 # Windows Installer

-We use [msys2](http://www.msys2.org/) for creating the Windows installer

+We use [msys2](https://www.msys2.org/) for creating the Windows installer

 and development on Windows.

-### Development

------------

+## Development

-Download [msys2](http://www.msys2.org/) (msys2-x86_64-xxx.exe) and follow the install instructions on the [msys2](http://www.msys2.org/) startpage (**Important!**)

+Download [msys2](https://www.msys2.org/) (msys2-x86_64-xxx.exe) and follow the install instructions on the [msys2](https://www.msys2.org/) startpage (**Important!**)

 * Fork the master branch on dev.gajim.org

-* Execute ``C:\msys64\msys2_shell.cmd -mingw64``

-* Run ``pacman -S git`` to install git

-* Run ``git clone https://dev.gajim.org/USERNAME/gajim.git``

-* Run ``cd gajim/win`` to end up where this README exists.

-* Execute ``./dev_env.sh`` to install all the needed dependencies.

-* Now go to the git root dir ``cd ..``

-* Launch Gajim ``./launch.py``

+* Execute `C:\msys64\msys2_shell.cmd -mingw64`

+* Run `pacman -S git` to install git

+* Run `git clone https://dev.gajim.org/USERNAME/gajim.git`

+* Run `cd gajim/win` to end up where this README exists.

+* Execute `./dev_env.sh` to install all the needed dependencies.

+* Now go to the git root dir `cd ..`

+* Launch Gajim `./launch.py`

-### Build Gajim / Creating an Installer

----------------------

+## Build Gajim / Create an Installer

-Follow the steps in the Development section, but instead of ``./dev_env.sh`` execute ``./build.sh``.

-

-You can supply a git tag ``./build.sh [git-tag]``.

-

-Or dont supply it, then current HEAD is build.

+Follow the steps in the Development section, but instead of `./dev_env.sh` execute `./build.sh i686` or `./build.sh x86_64`.

 Both the installer and the portable installer should appear in ``C:\msys64\home\USER\gajim\win\_build_root``.

     build_pacman --noconfirm -S base

 }

-function download_install_dep () {

-    curl -o "${BUILD_ROOT}"/mingw-w64-"${ARCH}"-"$1"-any.pkg.tar.xz \

-    http://repo.msys2.org/mingw/"${ARCH}"/mingw-w64-"${ARCH}"-"$1"-any.pkg.tar.xz

-    build_pacman --noconfirm -U "${BUILD_ROOT}"/mingw-w64-"${ARCH}"-"$1"-any.pkg.tar.xz

-}

-

 function install_deps {

     build_pacman --noconfirm -S mingw-w64-"${ARCH}"-"${PYTHON_ID}" \

         mingw-w64-"${ARCH}"-"${PYTHON_ID}"-gobject \

     SetOutPath "$INSTDIR\bin"

     CreateShortCut "$INSTDIR\Gajim-Portable.lnk" "$INSTDIR\bin\Gajim.exe" \

-    "-c ..\UserData" "" "" SW_SHOWNORMAL "" "Gajim Portable"

+    "" "" "" SW_SHOWNORMAL "" "Gajim Portable"

     CreateShortCut "$INSTDIR\Gajim-Portable-Debug.lnk" "$INSTDIR\bin\Gajim-Debug.exe" \

-    "-c ..\UserData" "" "" SW_SHOWNORMAL "" "Gajim Portable Debug"

+    "" "" "" SW_SHOWNORMAL "" "Gajim Portable Debug"

     FileOpen $0 "is_portable" w

     FileClose $0

Philipp Hörist pushed to branch chat_markers at gajim / gajim

Commits:

26 changed files:

Changes: