<xmpp:version>0.2</xmpp:version>

       </xmpp:SupportedXep>

     </implements>

     <implements>

       <xmpp:SupportedXep>

         <xmpp:xep rdf:resource="https://xmpp.org/extensions/xep-0441.html"/>

     Namespace.JINGLE_BYTESTREAM,

     Namespace.JINGLE_IBB,

     Namespace.AVATAR_METADATA + '+notify',

 ]

     message = _('Hello, I am $name. %s') % message

     return Template(message).safe_substitute({'name': app.nicks[account]})

 def get_user_proxy(account: str) -> Optional[ProxyData]:

     proxy_name = app.settings.get_account_setting(account, 'proxy')

     if not proxy_name:

     return self_contact.affiliation >= contact.affiliation

 def get_tls_error_phrase(tls_error: Gio.TlsCertificateFlags) -> str:

     phrase = GIO_TLS_ERRORS.get(tls_error)

     if phrase is None:

 from gajim.common.const import KindConstant

 from gajim.common.const import SyncThreshold

 from gajim.common.helpers import AdditionalDataDict

 from gajim.common.modules.misc import parse_oob

 from gajim.common.modules.misc import parse_correction

 from gajim.common.modules.util import get_eme_message

             if properties.eme is not None:

                 msgtxt = get_eme_message(properties.eme)

         if not msgtxt:

             # For example Chatstates, Receipts, Chatmarkers

             self._log.debug(stanza.getProperties())

                          account=self._account,

                          additional_data=additional_data,

                          correct_id=parse_correction(properties),

                          archive_jid=properties.mam.archive,

                          msgtxt=properties.body,

                          properties=properties,

         'request_voice',

         'approve_voice_request',

         'destroy',

     ]

     def __init__(self, con):

                           callback=self._on_subject_change,

                           typ='groupchat',

                           priority=49),

             StanzaHandler(name='message',

                           callback=self._on_config_change,

                           ns=Namespace.MUC_USER,

         raise nbxmpp.NodeProcessed

     def _fake_subject_change(self, room_jid):

         # This is for servers which don’t send empty subjects as part of the

         # event order on joining a MUC. For example jabber.ru

 import sqlite3 as sqlite

 from collections import namedtuple

 from gajim.common import app

 from gajim.common import configpaths

 from gajim.common.helpers import AdditionalDataDict

         sql = '''

             SELECT contact_name, time, kind, show, message, subject,

                    error as "error [common_error]",

                    marker as "marker [marker]"

             FROM logs NATURAL JOIN jids WHERE jid IN ({jids})

         sql = '''

             SELECT contact_name, time, kind, show, message, subject,

                    error as "error [common_error]",

                    marker as "marker [marker]"

             FROM logs NATURAL JOIN jids WHERE jid IN ({jids})

                           KindConstant.ERROR])

         sql = '''

             FROM logs NATURAL JOIN jids WHERE jid IN ({jids})

             AND account_id = {account_id}

             AND kind NOT IN ({kinds})

             return True

         return False

     def insert_jid(self, jid, kind=None, type_=JIDConstant.NORMAL_TYPE):

         """

         Insert a new jid into the `jids` table.

 .conversation-row grid textview:not(.sourceview) text {

 	background: transparent;

 }

 @keyframes highlight {

     from { background: rgb(140, 160, 180); }

     to { background: transparent; }

 from gajim.common.i18n import _

 from gajim.common.helpers import get_groupchat_name

 from gajim.common.helpers import get_group_chat_nick

 from gajim.common.helpers import get_uf_relative_time

 from gajim.common.helpers import AdditionalDataDict

 from gajim.common.preview_helpers import filename_from_uri

                           'mam-message-received',

                           'gc-message-received'):

             self._on_message_received(event)

         elif event.name == 'presence-received':

             self._on_presence_received(event)

         elif event.name == 'message-sent':

             row.set_timestamp(event.properties.timestamp)

         row.set_message_text(

             event.msgtxt, additional_data=event.additional_data)

         self._add_unread(row, event.properties)

         self.invalidate_sort()

     def _on_message_sent(self, event):

         msgtext = event.message

         if not msgtext:

         self.contact_name = self.contact.name

         self.timestamp = 0

         self._unread_count = 0

         self._pinned = pinned

             return

         if line.message is not None:

             self.set_message_text(

             if line.kind in (KindConstant.CHAT_MSG_SENT,

                              KindConstant.SINGLE_MSG_SENT):

                 self._ui.nick_label.set_text(_('Me:'))

             uf_timestamp = get_uf_relative_time(line.time)

             self._ui.timestamp_label.set_text(uf_timestamp)

         if line.kind in (KindConstant.FILE_TRANSFER_INCOMING,

                          KindConstant.FILE_TRANSFER_OUTGOING):

             self.set_message_text(

         self.timestamp = timestamp

         self.update_time()

     def update_time(self):

         if self.timestamp == 0:

             return

     'message-received',

     'mam-message-received',

     'gc-message-received',

     'presence-received',

     'message-sent',

     'chatstate-received',

 from gajim.common.nec import EventHelper

 from gajim.common.nec import NetworkEvent

 from gajim.common.helpers import AdditionalDataDict

 from gajim.common.const import KindConstant

 from gajim.common.structs import OutgoingMessage

         method_name = f'_on_{method_name}'

         getattr(self, method_name)(event)

     def _on_conversation_view_key_press(self, _listbox, event):

         if event.get_state() & Gdk.ModifierType.SHIFT_MASK:

             if event.keyval in (Gdk.KEY_Page_Down, Gdk.KEY_Page_Up):

                 tim,

                 display_marking=displaymarking,

                 message_id=message_id,

                 correct_id=correct_id,

                 log_line_id=msg_log_id,

                 additional_data=additional_data)

             if not msg.message:

                 continue

             contact_name = msg.contact_name

             if msg.kind in (

                     KindConstant.SINGLE_MSG_RECV, KindConstant.CHAT_MSG_RECV):

             else:

                 raise ValueError('no kind attribute')

             self.conversation_view.add_message(

                 kind,

                 contact_name,

                 msg.time,

                 additional_data=msg.additional_data,

                 message_id=msg.message_id,

                 log_line_id=msg.log_line_id,

                 marker=msg.marker,

                 error=msg.error)

                          tim=event.properties.mam.timestamp,

                          correct_id=event.correct_id,

                          message_id=event.properties.id,

                          additional_data=event.additional_data)

     def _on_message_received(self, event):

                          displaymarking=event.displaymarking,

                          msg_log_id=event.msg_log_id,

                          message_id=event.properties.id,

                          correct_id=event.correct_id,

                          additional_data=event.additional_data)

                     subject=None,

                     displaymarking=None,

                     msg_log_id=None,

                     correct_id=None,

                     message_id=None,

                     additional_data=None):

                                 displaymarking=displaymarking,

                                 msg_log_id=msg_log_id,

                                 message_id=message_id,

                                 correct_id=correct_id,

                                 additional_data=additional_data)

                          tim=event.properties.mam.timestamp,

                          correct_id=event.correct_id,

                          message_id=event.properties.id,

                          additional_data=event.additional_data)

     def _on_gc_message_received(self, event):

 from gajim.common import app

 from gajim.common.i18n import _

 from gajim.common.helpers import from_one_line

 from ...util import wrap_with_event_box

 @wrap_with_event_box

 class MoreMenuButton(Gtk.MenuButton):

         Gtk.MenuButton.__init__(self)

         self.set_valign(Gtk.Align.START)

         self.set_halign(Gtk.Align.END)

         self.set_relief(Gtk.ReliefStyle.NONE)

         self.get_style_context().add_class('conversation-more-button')

         menu_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=6)

         menu_box.get_style_context().add_class('padding-6')

         quote_button = Gtk.ModelButton()

         quote_button.set_halign(Gtk.Align.START)

         quote_button.set_label(_('Quote…'))

         quote_button.set_image(Gtk.Image.new_from_icon_name(

             'mail-reply-sender-symbolic', Gtk.IconSize.MENU))

         copy_button = Gtk.ModelButton()

         copy_button.set_halign(Gtk.Align.START)

         copy_button.set_label(_('Copy'))

         copy_button.set_image(Gtk.Image.new_from_icon_name(

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

         menu_box.add(copy_button)

         menu_box.show_all()

         popover = Gtk.PopoverMenu()

 from .base import BaseRow

 from .base import MoreMenuButton

 from ..message_widget import MessageWidget

 from ...preview import PreviewWidget

 from ...util import format_fingerprint

 from ...util import get_cursor

                  account,

                  contact,

                  message_id,

                  timestamp,

                  kind,

                  name,

         self.timestamp = datetime.fromtimestamp(timestamp)

         self.db_timestamp = timestamp

         self.message_id = message_id

         self.log_line_id = log_line_id

         self.kind = kind

         self.name = name or ''

         self._has_receipt = marker == 'received'

         self._has_displayed = marker == 'displayed'

         is_previewable = app.interface.preview_manager.get_previewable(

             text, additional_data)

         if is_previewable:

         bottom_box = Gtk.Box(spacing=6)

         bottom_box.add(self._message_widget)

         more_menu_button.set_hexpand(True)

         more_menu_button.set_halign(Gtk.Align.END)

         bottom_box.pack_end(more_menu_button, False, True, 0)

     def on_quote_message(self, _widget):

         self.get_parent().on_quote(self._message_widget.get_text())

     def _get_encryption_image(self, additional_data, encryption_enabled=None):

         details = self._get_encryption_details(additional_data)

         if details is None:

     def set_displayed(self):

         self._has_displayed = True

     def set_correction(self, text, message_id):

         self._corrections.append(self._message_widget.get_text())

         result = process(text)

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

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

 import logging

 import time

                     timestamp,

                     log_line_id=None,

                     message_id=None,

                     correct_id=None,

                     display_marking=None,

                     additional_data=None,

             self._account,

             self._contact,

             message_id,

             timestamp,

             kind,

             name,

                 return row

         return None

     def iter_rows(self):

         for row in self.get_children():

             yield row

             message_row.set_correction(text, message_id)

             message_row.set_merged(False)

     def show_receipt(self, id_):

         message_row = self._get_row_by_message_id(id_)

         if message_row is not None:

             ('message-received', ged.CORE, self._on_event),

             ('mam-message-received', ged.CORE, self._on_event),

             ('gc-message-received', ged.CORE, self._on_event),

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

             ('displayed-received', ged.GUI1, self._on_event),

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