GitLab

at 2019-11-12T18:48:35Z

ChatControls: Refactor register/unregister handlers

ChatControl: Fix pylint errors

ChatControlBase: Move methods so __init__() is the first

ChatControlBase: Fix pylint errors

ChatControls: Remove unused attributes

 from gi.repository import Pango

 from gi.repository import GLib

 from gi.repository import Gdk

-from nbxmpp.protocol import NS_XHTML_IM, NS_FILE, NS_MUC

-from nbxmpp.protocol import NS_JINGLE_RTP_AUDIO, NS_JINGLE_RTP_VIDEO

-from nbxmpp.protocol import NS_JINGLE_ICE_UDP, NS_JINGLE_FILE_TRANSFER_5

+

+from nbxmpp.protocol import NS_XHTML_IM

+from nbxmpp.protocol import NS_FILE

+from nbxmpp.protocol import NS_MUC

+from nbxmpp.protocol import NS_JINGLE_RTP_AUDIO

+from nbxmpp.protocol import NS_JINGLE_RTP_VIDEO

+from nbxmpp.protocol import NS_JINGLE_ICE_UDP

+from nbxmpp.protocol import NS_JINGLE_FILE_TRANSFER_5

 

 from gajim.common import app

 from gajim.common import helpers

     A control for standard 1-1 chat

     """

     (

-            JINGLE_STATE_NULL,

-            JINGLE_STATE_CONNECTING,

-            JINGLE_STATE_CONNECTION_RECEIVED,

-            JINGLE_STATE_CONNECTED,

-            JINGLE_STATE_ERROR

+        JINGLE_STATE_NULL,

+        JINGLE_STATE_CONNECTING,

+        JINGLE_STATE_CONNECTION_RECEIVED,

+        JINGLE_STATE_CONNECTED,

+        JINGLE_STATE_ERROR

     ) = range(5)

 

     TYPE_ID = message_control.TYPE_CHAT

     COMMAND_HOST = ChatCommands  # type: ClassVar[Type[CommandHost]]

 

     def __init__(self, parent_win, contact, acct, session, resource=None):

-        ChatControlBase.__init__(self, self.TYPE_ID, parent_win,

-            'chat_control', contact, acct, resource)

+        ChatControlBase.__init__(self,

+                                 self.TYPE_ID,

+                                 parent_win,

+                                 'chat_control',

+                                 contact,

+                                 acct,

+                                 resource)

 

         self.last_recv_message_id = None

         self.last_recv_message_marks = None

         # Hook up signals

         widget = self.xml.location_eventbox

         id_ = widget.connect('button-release-event',

-            self.on_location_eventbox_button_release_event)

+                             self.on_location_eventbox_button_release_event)

         self.handlers[id_] = widget

         id_ = widget.connect('enter-notify-event',

-            self.on_location_eventbox_enter_notify_event)

+                             self.on_location_eventbox_enter_notify_event)

         self.handlers[id_] = widget

         id_ = widget.connect('leave-notify-event',

-            self.on_location_eventbox_leave_notify_event)

+                             self.on_location_eventbox_leave_notify_event)

         self.handlers[id_] = widget

 

         for key in ('1', '2', '3', '4', '5', '6', '7', '8', '9', '*', '0', '#'):

         self.handlers[id_] = widget

 

         widget = self.xml.sound_hscale

-        id_ = widget.connect('value_changed', self.on_sound_hscale_value_changed)

+        id_ = widget.connect('value_changed',

+                             self.on_sound_hscale_value_changed)

         self.handlers[id_] = widget

 

         self.info_bar = Gtk.InfoBar()

             session.control = self

             self.session = session

 

-        # Enable encryption if needed

-        self.no_autonegotiation = False

         self.add_actions()

         self.update_ui()

         self.set_lock_image()

         self.restore_conversation()

         self.msg_textview.grab_focus()

 

-        app.ged.register_event_handler('nickname-received', ged.GUI1,

-            self._on_nickname_received)

-        app.ged.register_event_handler('mood-received', ged.GUI1,

-            self._on_mood_received)

-        app.ged.register_event_handler('activity-received', ged.GUI1,

-            self._on_activity_received)

-        app.ged.register_event_handler('tune-received', ged.GUI1,

-            self._on_tune_received)

-        app.ged.register_event_handler('location-received', ged.GUI1,

-            self._on_location_received)

-        app.ged.register_event_handler('update-client-info', ged.GUI1,

-            self._on_update_client_info)

+        # pylint: disable=line-too-long

+        self._event_handlers = [

+            ('nickname-received', ged.GUI1, self._on_nickname_received),

+            ('mood-received', ged.GUI1, self._on_mood_received),

+            ('activity-received', ged.GUI1, self._on_activity_received),

+            ('tune-received', ged.GUI1, self._on_tune_received),

+            ('location-received', ged.GUI1, self._on_location_received),

+            ('update-client-info', ged.GUI1, self._on_update_client_info),

+            ('chatstate-received', ged.GUI1, self._nec_chatstate_received),

+            ('caps-update', ged.GUI1, self._nec_caps_received),

+            ('message-sent', ged.OUT_POSTCORE, self._message_sent),

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

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

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

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

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

+        ]

+

         if self.TYPE_ID == message_control.TYPE_CHAT:

             # Dont connect this when PrivateChatControl is used

-            app.ged.register_event_handler('update-roster-avatar', ged.GUI1,

-                self._nec_update_avatar)

-        app.ged.register_event_handler('chatstate-received', ged.GUI1,

-            self._nec_chatstate_received)

-        app.ged.register_event_handler('caps-update', ged.GUI1,

-            self._nec_caps_received)

-        app.ged.register_event_handler('message-sent', ged.OUT_POSTCORE,

-            self._message_sent)

-        app.ged.register_event_handler(

-            'mam-decrypted-message-received',

-            ged.GUI1, self._nec_mam_decrypted_message_received)

-        app.ged.register_event_handler(

-            'decrypted-message-received',

-            ged.GUI1, self._nec_decrypted_message_received)

-        app.ged.register_event_handler(

-            'receipt-received',

-            ged.GUI1, self._receipt_received)

-        app.ged.register_event_handler('message-error',

-                                       ged.GUI1, self._on_message_error)

-        app.ged.register_event_handler('zeroconf-error', ged.GUI1,

-                                       self._on_zeroconf_error)

+            self._event_handlers.append(('update-roster-avatar', ged.GUI1, self._nec_update_avatar))

+        # pylint: enable=line-too-long

+

+        for handler in self._event_handlers:

+            app.ged.register_event_handler(*handler)

 

         # PluginSystem: adding GUI extension point for this ChatControl

         # instance object

         jingle_conditions = (

             (self.contact.supports(NS_FILE) or

              self.contact.supports(NS_JINGLE_FILE_TRANSFER_5)) and

-             self.contact.show != 'offline')

+            self.contact.show != 'offline')

         jingle = win.lookup_action('send-file-jingle-' + self.control_id)

         jingle.set_enabled(online and jingle_conditions)

 

         # Send file

         win.lookup_action(

             'send-file-' + self.control_id).set_enabled(

-            jingle.get_enabled() or httpupload.get_enabled())

+                jingle.get_enabled() or httpupload.get_enabled())

 

         # Set File Transfer Button tooltip

         if online and (httpupload.get_enabled() or jingle.get_enabled()):

 

         return Gdk.EVENT_PROPAGATE

 

-    def _on_add_to_roster(self, action, param):

+    def _on_add_to_roster(self, _action, _param):

         AddNewContactWindow(self.account, self.contact.jid)

 

-    def _on_information(self, action, param):

+    def _on_information(self, _action, _param):

         app.interface.roster.on_info(None, self.contact, self.account)

 

-    def _on_invite_contacts(self, action, param):

+    def _on_invite_contacts(self, _action, _param):

         """

         User wants to invite some friends to chat

         """

             return self.xml.tune_image

         if type_ == PEPEventType.LOCATION:

             return self.xml.location_image

+        return None

 

     @ensure_proper_control

     def _on_mood_received(self, _event):

         else:

             banner_image.show()

         if state == self.JINGLE_STATE_CONNECTING:

-            banner_image.set_from_icon_name(

-                    'network-transmit-symbolic', Gtk.IconSize.MENU)

+            banner_image.set_from_icon_name('network-transmit-symbolic',

+                                            Gtk.IconSize.MENU)

         elif state == self.JINGLE_STATE_CONNECTION_RECEIVED:

-            banner_image.set_from_icon_name(

-                    'network-receive-symbolic', Gtk.IconSize.MENU)

+            banner_image.set_from_icon_name('network-receive-symbolic',

+                                            Gtk.IconSize.MENU)

         elif state == self.JINGLE_STATE_CONNECTED:

-            banner_image.set_from_icon_name(

-                    'network-transmit-receive-symbolic', Gtk.IconSize.MENU)

+            banner_image.set_from_icon_name('network-transmit-receive-symbolic',

+                                            Gtk.IconSize.MENU)

         elif state == self.JINGLE_STATE_ERROR:

-            banner_image.set_from_icon_name(

-                    'network-error-symbolic', Gtk.IconSize.MENU)

+            banner_image.set_from_icon_name('network-error-symbolic',

+                                            Gtk.IconSize.MENU)

         self.update_toolbar()

 

     def update_audio(self):

         # update MessageWindow._controls

         self.parent_win.change_jid(self.account, old_full_jid, new_full_jid)

 

-    def stop_jingle(self, sid=None, reason=None):

+    def stop_jingle(self, sid=None, _reason=None):

         if self.audio_sid and sid in (self.audio_sid, None):

             self.close_jingle_content('audio')

         if self.video_sid and sid in (self.video_sid, None):

             return

         if state in ('connecting', 'connected', 'stop', 'error') and reason:

             info = _('%(type)s state : %(state)s, reason: %(reason)s') % {

-                    'type': jingle_type.capitalize(), 'state': state, 'reason': reason}

+                'type': jingle_type.capitalize(),

+                'state': state,

+                'reason': reason}

             self.add_info_message(info)

 

         states = {'connecting': self.JINGLE_STATE_CONNECTING,

-                'connection_received': self.JINGLE_STATE_CONNECTION_RECEIVED,

-                'connected': self.JINGLE_STATE_CONNECTED,

-                'stop': self.JINGLE_STATE_NULL,

-                'error': self.JINGLE_STATE_ERROR}

+                  'connection_received': self.JINGLE_STATE_CONNECTION_RECEIVED,

+                  'connected': self.JINGLE_STATE_CONNECTED,

+                  'stop': self.JINGLE_STATE_NULL,

+                  'error': self.JINGLE_STATE_ERROR}

 

         jingle_state = states[state]

-        if getattr(self, jingle_type + '_state') == jingle_state or state == 'error':

+        if (getattr(self, jingle_type + '_state') == jingle_state or

+                state == 'error'):

             return

 

-        if state == 'stop' and getattr(self, jingle_type + '_sid') not in (None, sid):

+        if (state == 'stop' and

+                getattr(self, jingle_type + '_sid') not in (None, sid)):

             return

 

         setattr(self, jingle_type + '_state', jingle_state)

         if state in ('connection_received', 'connecting'):

             setattr(self, jingle_type + '_sid', sid)

 

-        v = GLib.Variant.new_boolean(jingle_state != self.JINGLE_STATE_NULL)

-        getattr(self, jingle_type + '_action').change_state(v)

+        var = GLib.Variant.new_boolean(jingle_state != self.JINGLE_STATE_NULL)

+        getattr(self, jingle_type + '_action').change_state(var)

 

         getattr(self, 'update_' + jingle_type)()

 

         self._set_jingle_state('video', state, sid=sid, reason=reason)

 

     def _get_audio_content(self):

-        session = app.connections[self.account].get_module('Jingle').get_jingle_session(

-                self.contact.get_full_jid(), self.audio_sid)

+        con = app.connections[self.account]

+        session = con.get_module('Jingle').get_jingle_session(

+            self.contact.get_full_jid(), self.audio_sid)

         return session.get_content('audio')

 

-    def on_num_button_pressed(self, widget, num):

+    def on_num_button_pressed(self, _widget, num):

         self._get_audio_content()._start_dtmf(num)

 

-    def on_num_button_released(self, released):

+    def on_num_button_released(self, _released):

         self._get_audio_content()._stop_dtmf()

 

-    def on_mic_hscale_value_changed(self, widget, value):

+    def on_mic_hscale_value_changed(self, _widget, value):

         self._get_audio_content().set_mic_volume(value / 100)

         # Save volume to config

         app.config.set('audio_input_volume', value)

 

-    def on_sound_hscale_value_changed(self, widget, value):

+    def on_sound_hscale_value_changed(self, _widget, value):

         self._get_audio_content().set_out_volume(value / 100)

         # Save volume to config

         app.config.set('audio_output_volume', value)

 

-    def on_location_eventbox_button_release_event(self, widget, event):

+    def on_location_eventbox_button_release_event(self, _widget, _event):

         if 'geoloc' in self.contact.pep:

             location = self.contact.pep['geoloc'].data

             if 'lat' in location and 'lon' in location:

                                                  location['lon'])

                 open_uri(uri)

 

-    def on_location_eventbox_leave_notify_event(self, widget, event):

+    def on_location_eventbox_leave_notify_event(self, _widget, _event):

         """

         Just moved the mouse so show the cursor

         """

         cursor = get_cursor('default')

         self.parent_win.window.get_window().set_cursor(cursor)

 

-    def on_location_eventbox_enter_notify_event(self, widget, event):

+    def on_location_eventbox_enter_notify_event(self, _widget, _event):

         cursor = get_cursor('pointer')

         self.parent_win.window.get_window().set_cursor(cursor)

 

 

         # We know our contacts nick, but if another contact has the same nick

         # in another account we need to also display the account.

-        # except if we are talking to two different resources of the same contact

+        # except if we are talking to two different resources of the

+        # same contact

         acct_info = ''

         for account in app.contacts.get_accounts():

             if account == self.account:

             return

         setattr(self, jingle_type + '_sid', None)

         setattr(self, jingle_type + '_state', self.JINGLE_STATE_NULL)

-        session = app.connections[self.account].get_module('Jingle').get_jingle_session(

+        con = app.connections[self.account]

+        session = con.get_module('Jingle').get_jingle_session(

             self.contact.get_full_jid(), sid)

         if session:

             content = session.get_content(jingle_type)

             if content:

                 session.remove_content(content.creator, content.name)

-        v = GLib.Variant.new_boolean(False)

-        getattr(self, jingle_type + '_action').change_state(v)

+        var = GLib.Variant.new_boolean(False)

+        getattr(self, jingle_type + '_action').change_state(var)

         getattr(self, 'update_' + jingle_type)()

 

     def on_jingle_button_toggled(self, state, jingle_type):

                     in_da = self.xml.incoming_drawingarea

                     in_da.realize()

                     in_xid = in_da.get_window().get_xid()

-                    sid = app.connections[self.account].get_module('Jingle').start_video(

+                    con = app.connections[self.account]

+                    sid = con.get_module('Jingle').start_video(

                         self.contact.get_full_jid(), in_xid, out_xid)

                 else:

                     sid = getattr(app.connections[self.account],

 

         if self.encryption:

             self.sendmessage = True

-            app.plugin_manager.extension_point(

-                    'send_message' + self.encryption, self)

+            app.plugin_manager.extension_point('send_message' + self.encryption,

+                                               self)

             if not self.sendmessage:

                 return

 

         message = helpers.remove_invalid_xml_chars(message)

         if message in ('', None, '\n'):

-            return None

+            return

 

         ChatControlBase.send_message(self,

                                      message,

 

         If frm is set to status: it's a status message.

         if frm is set to error: it's an error message. The difference between

-                status and error is mainly that with error, msg count as a new message

-                (in systray and in control).

+            status and error is mainly that with error, msg count as a new

+            message (in systray and in control).

         If frm is set to info: it's a information message.

         If frm is set to print_queue: it is incoming from queue.

         If frm is set to another value: it's an outgoing message.

             if not frm:

                 kind = 'incoming'

                 name = contact.get_shown_name()

-            elif frm == 'print_queue': # incoming message, but do not update time

+            elif frm == 'print_queue':

                 kind = 'incoming_queue'

                 name = contact.get_shown_name()

             else:

                 kind = 'outgoing'

                 name = self.get_our_nick()

 

-        ChatControlBase.add_message(self, text, kind, name, tim,

-            subject=subject, old_kind=self.old_msg_kind,

-            displaymarking=displaymarking,

-            msg_log_id=msg_log_id, message_id=message_id,

-            correct_id=correct_id, additional_data=additional_data,

-            error=error)

+        ChatControlBase.add_message(self,

+                                    text,

+                                    kind,

+                                    name,

+                                    tim,

+                                    subject=subject,

+                                    old_kind=self.old_msg_kind,

+                                    displaymarking=displaymarking,

+                                    msg_log_id=msg_log_id,

+                                    message_id=message_id,

+                                    correct_id=correct_id,

+                                    additional_data=additional_data,

+                                    error=error)

         if text.startswith('/me ') or text.startswith('/me\n'):

             self.old_msg_kind = None

         else:

             jid = self.contact.get_full_jid()

         else:

             jid = self.contact.jid

-        num_unread = len(app.events.get_events(self.account, jid,

-                ['printed_' + self.type_id, self.type_id]))

+        num_unread = len(app.events.get_events(

+            self.account, jid, ['printed_' + self.type_id, self.type_id]))

         if num_unread == 1 and not app.config.get('show_unread_tab_icon'):

             unread = '*'

         elif num_unread > 1:

                 return surface

 

         if count_unread:

-            num_unread = len(app.events.get_events(self.account, jid,

-                    ['printed_' + self.type_id, self.type_id]))

+            num_unread = len(app.events.get_events(

+                self.account, jid, ['printed_' + self.type_id, self.type_id]))

         else:

             num_unread = 0

 

             icon_name = get_icon_name('event', transport=transport)

         else:

             contact = app.contacts.get_contact_with_highest_priority(

-                    self.account, self.contact.jid)

+                self.account, self.contact.jid)

             if not contact or self.resource:

                 # For transient contacts

                 contact = self.contact

         """

         if app.jid_is_transport(self.contact.jid):

             menu = gui_menu_builder.get_transport_menu(self.contact,

-                self.account)

+                                                       self.account)

         else:

-            menu = gui_menu_builder.get_contact_menu(self.contact, self.account,

-                use_multiple_contacts=False, show_start_chat=False,

-                show_encryption=True, control=self,

+            menu = gui_menu_builder.get_contact_menu(

+                self.contact,

+                self.account,

+                use_multiple_contacts=False,

+                show_start_chat=False,

+                show_encryption=True,

+                control=self,

                 show_buttonbar_items=not hide_buttonbar_items)

         return menu

 

         # PluginSystem: removing GUI extension points connected with ChatControl

         # instance object

         app.plugin_manager.remove_gui_extension_point('chat_control', self)

-        app.ged.remove_event_handler('nickname-received', ged.GUI1,

-            self._on_nickname_received)

-        app.ged.remove_event_handler('mood-received', ged.GUI1,

-            self._on_mood_received)

-        app.ged.remove_event_handler('activity-received', ged.GUI1,

-            self._on_activity_received)

-        app.ged.remove_event_handler('tune-received', ged.GUI1,

-            self._on_tune_received)

-        app.ged.remove_event_handler('location-received', ged.GUI1,

-            self._on_location_received)

-        app.ged.remove_event_handler('update-client-info', ged.GUI1,

-            self._on_update_client_info)

-        if self.TYPE_ID == message_control.TYPE_CHAT:

-            app.ged.remove_event_handler('update-roster-avatar', ged.GUI1,

-                self._nec_update_avatar)

-        app.ged.remove_event_handler('chatstate-received', ged.GUI1,

-            self._nec_chatstate_received)

-        app.ged.remove_event_handler('caps-update', ged.GUI1,

-            self._nec_caps_received)

-        app.ged.remove_event_handler('message-sent', ged.OUT_POSTCORE,

-            self._message_sent)

-        app.ged.remove_event_handler(

-            'mam-decrypted-message-received',

-            ged.GUI1, self._nec_mam_decrypted_message_received)

-        app.ged.remove_event_handler(

-            'decrypted-message-received',

-            ged.GUI1, self._nec_decrypted_message_received)

-        app.ged.remove_event_handler(

-            'receipt-received',

-            ged.GUI1, self._receipt_received)

+

+        # Unregister handlers

+        for handler in self._event_handlers:

+            app.ged.remove_event_handler(*handler)

 

         self.unsubscribe_events()

 

             self.session.control = None

 

         # Clean events

-        app.events.remove_events(self.account, self.get_full_jid(),

-                types=['printed_' + self.type_id, self.type_id])

+        app.events.remove_events(

+            self.account,

+            self.get_full_jid(),

+            types=['printed_' + self.type_id, self.type_id])

         # Remove contact instance if contact has been removed

         key = (self.contact.jid, self.account)

         roster = app.interface.roster

-        if key in roster.contacts_to_be_removed.keys() and \

-        not roster.contact_has_pending_roster_events(self.contact,

-        self.account):

+        has_pending = roster.contact_has_pending_roster_events(self.contact,

+                                                               self.account)

+        if key in roster.contacts_to_be_removed.keys() and not has_pending:

             backend = roster.contacts_to_be_removed[key]['backend']

             del roster.contacts_to_be_removed[key]

-            roster.remove_contact(self.contact.jid, self.account, force=True,

-                backend=backend)

+            roster.remove_contact(self.contact.jid,

+                                  self.account,

+                                  force=True,

+                                  backend=backend)

         # remove all register handlers on widgets, created by self.xml

         # to prevent circular references among objects

         for i in list(self.handlers.keys()):

 

         # get contact info (check for PM = private chat)

         if self.TYPE_ID == message_control.TYPE_PM:

-            c = self.gc_contact.as_contact()

+            contact = self.gc_contact.as_contact()

         else:

-            c = self.contact

+            contact = self.contact

 

         if target_type == self.TARGET_TYPE_URI_LIST:

             # File drag and drop (handled in chat_control_base)

-            self.drag_data_file_transfer(c, selection, self)

+            self.drag_data_file_transfer(contact, selection, self)

         else:

             # Convert single chat to MUC

             treeview = app.interface.roster.tree

             dropped_jid = data

 

             dropped_transport = app.get_transport_name_from_jid(dropped_jid)

-            c_transport = app.get_transport_name_from_jid(c.jid)

+            c_transport = app.get_transport_name_from_jid(contact.jid)

             if dropped_transport or c_transport:

                 return # transport contacts cannot be invited

 

-            dialogs.TransformChatToMUC(self.account, [c.jid], [dropped_jid])

+            dialogs.TransformChatToMUC(self.account,

+                                       [contact.jid],

+                                       [dropped_jid])

 

     def restore_conversation(self):

         jid = self.contact.jid

 

         # number of messages that are in queue and are already logged, we want

         # to avoid duplication

-        pending = len(app.events.get_events(self.account, jid,

-                ['chat', 'pm']))

+        pending = len(app.events.get_events(self.account, jid, ['chat', 'pm']))

         if self.resource:

             pending += len(app.events.get_events(self.account,

-                    self.contact.get_full_jid(), ['chat', 'pm']))

+                                                 self.contact.get_full_jid(),

+                                                 ['chat', 'pm']))

 

         rows = app.logger.get_last_conversation_lines(

             self.account, jid, pending)

                 kind = 'outgoing'

                 name = self.get_our_nick()

             elif row.kind in (KindConstant.SINGLE_MSG_RECV,

-                            KindConstant.CHAT_MSG_RECV):

+                              KindConstant.CHAT_MSG_RECV):

                 kind = 'incoming'

                 name = self.contact.get_shown_name()

             elif row.kind == KindConstant.ERROR:

                                         message_id=row.message_id,

                                         marker=row.marker,

                                         error=row.error)

-            if row.message.startswith('/me ') or row.message.startswith('/me\n'):

+            if (row.message.startswith('/me ') or

+                    row.message.startswith('/me\n')):

                 local_old_kind = None

             else:

                 local_old_kind = kind

                 self.set_session(event.session)

         if message_ids:

             app.logger.set_read_messages(message_ids)

-        app.events.remove_events(self.account, jid_with_resource,

-                types=[self.type_id])

+        app.events.remove_events(self.account,

+                                 jid_with_resource,

+                                 types=[self.type_id])

 

         typ = 'chat' # Is it a normal chat or a pm ?

 

         # Is it a pm ?

         room_jid, nick = app.get_room_and_nick_from_fjid(jid)

         control = app.interface.msg_win_mgr.get_gc_control(room_jid,

-                self.account)

+                                                           self.account)

         if control and control.type_id == message_control.TYPE_GC:

             control.update_ui()

             control.parent_win.show_title()

             (not show_offline and typ == 'chat' and \

             len(app.contacts.get_contacts(self.account, jid)) < 2):

                 app.interface.roster.remove_to_be_removed(self.contact.jid,

-                        self.account)

+                                                          self.account)

             elif typ == 'pm':

                 control.remove_contact(nick)

 

-    def _on_convert_to_gc_menuitem_activate(self, widget):

+    def _on_convert_to_gc_menuitem_activate(self, _widget):

         """

         User wants to invite some friends to chat

         """

         ChatControlBase.got_connected(self)

         # Refreshing contact

         contact = app.contacts.get_contact_with_highest_priority(

-                self.account, self.contact.jid)

+            self.account, self.contact.jid)

         if isinstance(contact, GC_Contact):

             contact = contact.as_contact()

         if contact:

 

         # Remove old buttons

         area = self.info_bar.get_action_area()

-        for b in area.get_children():

-            area.remove(b)

+        for button in area.get_children():

+            area.remove(button)

 

         # Add new buttons

         for button in buttons:

                 return ev

         return None

 

-    def _on_accept_file_request(self, widget, file_props):

+    def _on_accept_file_request(self, _widget, file_props):

         app.interface.instances['file_transfers'].on_file_request_accepted(

             self.account, self.contact, file_props)

         ev = self._get_file_props_event(file_props, 'file-request')

         if ev:

             app.events.remove_events(self.account, self.contact.jid, event=ev)

 

-    def _on_cancel_file_request(self, widget, file_props):

-        app.connections[self.account].get_module('Bytestream').send_file_rejection(file_props)

+    def _on_cancel_file_request(self, _widget, file_props):

+        con = app.connections[self.account]

+        con.get_module('Bytestream').send_file_rejection(file_props)

         ev = self._get_file_props_event(file_props, 'file-request')

         if ev:

             app.events.remove_events(self.account, self.contact.jid, event=ev)

             file_props,

             Gtk.MessageType.QUESTION)

 

-    def _on_open_ft_folder(self, widget, file_props):

+    def _on_open_ft_folder(self, _widget, file_props):

         path = os.path.split(file_props.file_name)[0]

         if os.path.exists(path) and os.path.isdir(path):

             open_file(path)

         if ev:

             app.events.remove_events(self.account, self.contact.jid, event=ev)

 

-    def _on_ok(self, widget, file_props, type_):

+    def _on_ok(self, _widget, file_props, type_):

         ev = self._get_file_props_event(file_props, type_)

         if ev:

             app.events.remove_events(self.account, self.contact.jid, event=ev)

 

     def _got_file_completed(self, file_props):

         markup = '<b>%s</b>\n%s' % (_('File Transfer Completed'),

-            file_props.name)

+                                    file_props.name)

         if file_props.desc:

             markup += '\n(%s)' % file_props.desc

         b1 = Gtk.Button.new_with_mnemonic(_('Open _Folder'))

 

     def _got_file_error(self, file_props, type_, pri_txt, sec_txt):

         markup = '<b>%s</b>\n%s' % (pri_txt, sec_txt)

-        b = Gtk.Button.new_with_mnemonic(_('_Close'))

-        b.connect('clicked', self._on_ok, file_props, type_)

+        button = Gtk.Button.new_with_mnemonic(_('_Close'))

+        button.connect('clicked', self._on_ok, file_props, type_)

         self._add_info_bar_message(

             markup,

-            [b],

+            [button],

             file_props,

             Gtk.MessageType.ERROR)

 

-    def _on_accept_gc_invitation(self, widget, event):

+    def _on_accept_gc_invitation(self, _widget, event):

         app.interface.show_or_join_groupchat(self.account,

                                              str(event.muc),

                                              password=event.password)

         app.events.remove_events(self.account, self.contact.jid, event=event)

 

-    def _on_cancel_gc_invitation(self, widget, event):

+    def _on_cancel_gc_invitation(self, _widget, event):

         app.events.remove_events(self.account, self.contact.jid, event=event)

 

     def _get_gc_invitation(self, event):

             elif event.file_props.error == -6:

                 msg_err = _('Error opening file')

             self._got_file_error(event.file_props, event.type_,

-                _('File transfer stopped'), msg_err)

+                                 _('File transfer stopped'), msg_err)

         elif event.type_ in ('file-request-error', 'file-send-error'):

-            self._got_file_error(event.file_props, event.type_,

+            self._got_file_error(

+                event.file_props,

+                event.type_,

                 _('File transfer cancelled'),

                 _('Connection with peer cannot be established.'))

         elif event.type_ == 'gc-invitation':

                 continue

             if ev.jid != self.contact.jid:

                 continue

-            if ev.type_ not in ('file-request', 'file-completed', 'file-error',

-            'file-stopped', 'file-request-error', 'file-send-error',

-            'gc-invitation'):

+            if ev.type_ not in ('file-request',

+                                'file-completed',

+                                'file-error',

+                                'file-stopped',

+                                'file-request-error',

+                                'file-send-error',

+                                'gc-invitation'):

                 continue

             i = 0

             removed = False

     # Multiple hardware keycodes can trigger a keyval like Gdk.KEY_c.

     keycodes_c = get_hardware_key_codes(Gdk.KEY_c)

 

-    def get_nb_unread(self):

-        jid = self.contact.jid

-        if self.resource:

-            jid += '/' + self.resource

-        type_ = self.type_id

-        return len(app.events.get_events(self.account, jid, ['printed_' + type_,

-                type_]))

-

-    def draw_banner(self):

-        """

-        Draw the fat line at the top of the window that houses the icon, jid, etc

-

-        Derived types MAY implement this.

-        """

-        self.draw_banner_text()

-        self._update_banner_state_image()

-        app.plugin_manager.gui_extension_point('chat_control_base_draw_banner',

-            self)

-

-    def update_toolbar(self):

-        """

-        update state of buttons in toolbar

-        """

-        self._update_toolbar()

-        app.plugin_manager.gui_extension_point(

-            'chat_control_base_update_toolbar', self)

-

-    def draw_banner_text(self):

-        """

-        Derived types SHOULD implement this

-        """

-

-    def update_ui(self):

-        """

-        Derived types SHOULD implement this

-        """

-        self.draw_banner()

-

-    def repaint_themed_widgets(self):

-        """

-        Derived types MAY implement this

-        """

-        self.draw_banner()

-

-    def _update_banner_state_image(self):

-        """

-        Derived types MAY implement this

-        """

-

-    def _update_toolbar(self):

-        """

-        Derived types MAY implement this

-        """

-

-    def _nec_our_status(self, obj):

-        if self.account != obj.conn.name:

-            return

-        if obj.show == 'offline' or (obj.show == 'invisible' and \

-        obj.conn.is_zeroconf):

-            self.got_disconnected()

-        else:

-            # Other code rejoins all GCs, so we don't do it here

-            if not self.type_id == message_control.TYPE_GC:

-                self.got_connected()

-        if self.parent_win:

-            self.parent_win.redraw_tab(self)

-

-    def setup_seclabel(self):

-        self.xml.label_selector.hide()

-        self.xml.label_selector.set_no_show_all(True)

-        lb = Gtk.ListStore(str)

-        self.xml.label_selector.set_model(lb)

-        cell = Gtk.CellRendererText()

-        cell.set_property('xpad', 5)  # padding for status text

-        self.xml.label_selector.pack_start(cell, True)

-        # text to show is in in first column of liststore

-        self.xml.label_selector.add_attribute(cell, 'text', 0)

-        con = app.connections[self.account]

-        jid = self.contact.jid

-        if self.TYPE_ID == 'pm':

-            jid = self.gc_contact.room_jid

-        if con.get_module('SecLabels').supported:

-            con.get_module('SecLabels').request_catalog(jid)

-

-    def _sec_labels_received(self, event):

-        if event.account != self.account:

-            return

-

-        jid = self.contact.jid

-        if self.TYPE_ID == 'pm':

-            jid = self.gc_contact.room_jid

-

-        if event.jid != jid:

-            return

-        model = self.xml.label_selector.get_model()

-        model.clear()

-

-        sel = 0

-        _label, labellist, default = event.catalog

-        for index, label in enumerate(labellist):

-            model.append([label])

-            if label == default:

-                sel = index

-

-        self.xml.label_selector.set_active(sel)

-        self.xml.label_selector.set_no_show_all(False)

-        self.xml.label_selector.show_all()

-

     def __init__(self, type_id, parent_win, widget_name, contact, acct,

-    resource=None):

+                 resource=None):

         # Undo needs this variable to know if space has been pressed.

         # Initialize it to True so empty textview is saved in undo list

         self.space_pressed = True

         if resource is None:

             # We very likely got a contact with a random resource.

             # This is bad, we need the highest for caps etc.

-            c = app.contacts.get_contact_with_highest_priority(acct,

-                contact.jid)

-            if c and not isinstance(c, GC_Contact):

-                contact = c

+            _contact = app.contacts.get_contact_with_highest_priority(

+                acct, contact.jid)

+            if _contact and not isinstance(_contact, GC_Contact):

+                contact = _contact

 

         MessageControl.__init__(self, type_id, parent_win, widget_name,

-            contact, acct, resource=resource)

+                                contact, acct, resource=resource)

 

         if self.TYPE_ID != message_control.TYPE_GC:

             # Create banner and connect signals

         self.conv_scrolledwindow.add(self.conv_textview.tv)

         widget = self.conv_scrolledwindow.get_vadjustment()

         id_ = widget.connect('changed',

-            self.on_conversation_vadjustment_changed)

+                             self.on_conversation_vadjustment_changed)

         self.handlers[id_] = widget

 

         vscrollbar = self.conv_scrolledwindow.get_vscrollbar()

         self.xml.hbox.pack_start(self.msg_scrolledwindow, True, True, 0)

 

         id_ = self.msg_textview.connect('paste-clipboard',

-            self._on_message_textview_paste_event)

+                                        self._on_message_textview_paste_event)

         self.handlers[id_] = self.msg_textview

-        id_ = self.msg_textview.connect('key_press_event',

+        id_ = self.msg_textview.connect(

+            'key_press_event',

             self._on_message_textview_key_press_event)

         self.handlers[id_] = self.msg_textview

         id_ = self.msg_textview.connect('populate_popup',

-            self.on_msg_textview_populate_popup)

+                                        self.on_msg_textview_populate_popup)

         self.handlers[id_] = self.msg_textview

 

         # Setup DND

         self.command_hits = []

         self.last_key_tabs = False

 

+        self.sendmessage = True

+

         con = app.connections[self.account]

         con.get_module('Chatstate').set_active(self.contact)

 

         id_ = self.msg_textview.connect('text-changed',

-            self._on_message_tv_buffer_changed)

+                                        self._on_message_tv_buffer_changed)

         self.handlers[id_] = self.msg_textview

         if parent_win is not None:

             id_ = parent_win.window.connect('motion-notify-event',

-                self._on_window_motion_notify)

+                                            self._on_window_motion_notify)

             self.handlers[id_] = parent_win.window

 

         self.encryption = self.get_encryption_state()

         # instance object (also subclasses, eg. ChatControl or GroupchatControl)

         app.plugin_manager.gui_extension_point('chat_control_base', self)

 

-        app.ged.register_event_handler('our-show', ged.GUI1,

-            self._nec_our_status)

-        app.ged.register_event_handler('ping-sent', ged.GUI1,

-            self._nec_ping)

-        app.ged.register_event_handler('ping-reply', ged.GUI1,

-            self._nec_ping)

-        app.ged.register_event_handler('ping-error', ged.GUI1,

-            self._nec_ping)

-        app.ged.register_event_handler('sec-catalog-received', ged.GUI1,

-            self._sec_labels_received)

-        app.ged.register_event_handler('style-changed', ged.GUI1,

-            self._style_changed)

+        # pylint: disable=line-too-long

+        self._base_event_handlers = [

+            ('our-show', ged.GUI1, self._nec_our_status),

+            ('ping-sent', ged.GUI1, self._nec_ping),

+            ('ping-reply', ged.GUI1, self._nec_ping),

+            ('ping-error', ged.GUI1, self._nec_ping),

+            ('sec-catalog-received', ged.GUI1, self._sec_labels_received),

+            ('style-changed', ged.GUI1, self._style_changed),

+        ]

+        # pylint: enable=line-too-long

+

+        for handler in self._base_event_handlers:

+            app.ged.register_event_handler(*handler)

 

         # This is basically a very nasty hack to surpass the inability

         # to properly use the super, because of the old code.

         CommandTools.__init__(self)

 

+    def get_nb_unread(self):

+        jid = self.contact.jid

+        if self.resource:

+            jid += '/' + self.resource

+        type_ = self.type_id

+        return len(app.events.get_events(self.account,

+                                         jid,

+                                         ['printed_' + type_, type_]))

+

+    def draw_banner(self):

+        """

+        Draw the fat line at the top of the window

+        that houses the icon, jid, etc

+

+        Derived types MAY implement this.

+        """

+        self.draw_banner_text()

+        self._update_banner_state_image()

+        app.plugin_manager.gui_extension_point('chat_control_base_draw_banner',

+                                               self)

+

+    def update_toolbar(self):

+        """

+        update state of buttons in toolbar

+        """

+        self._update_toolbar()

+        app.plugin_manager.gui_extension_point(

+            'chat_control_base_update_toolbar', self)

+

+    def draw_banner_text(self):

+        """

+        Derived types SHOULD implement this

+        """

+

+    def update_ui(self):

+        """

+        Derived types SHOULD implement this

+        """

+        self.draw_banner()

+

+    def repaint_themed_widgets(self):

+        """

+        Derived types MAY implement this

+        """

+        self.draw_banner()

+

+    def _update_banner_state_image(self):

+        """

+        Derived types MAY implement this

+        """

+

+    def _update_toolbar(self):

+        """

+        Derived types MAY implement this

+        """

+

+    def _nec_our_status(self, obj):

+        if self.account != obj.conn.name:

+            return

+        if obj.show == 'offline' or (obj.show == 'invisible' and \

+        obj.conn.is_zeroconf):

+            self.got_disconnected()

+        else:

+            # Other code rejoins all GCs, so we don't do it here

+            if not self.type_id == message_control.TYPE_GC:

+                self.got_connected()

+        if self.parent_win:

+            self.parent_win.redraw_tab(self)

+

+    def _nec_ping(self, obj):

+        raise NotImplementedError

+

+    def setup_seclabel(self):

+        self.xml.label_selector.hide()

+        self.xml.label_selector.set_no_show_all(True)

+        lb = Gtk.ListStore(str)

+        self.xml.label_selector.set_model(lb)

+        cell = Gtk.CellRendererText()

+        cell.set_property('xpad', 5)  # padding for status text

+        self.xml.label_selector.pack_start(cell, True)

+        # text to show is in in first column of liststore

+        self.xml.label_selector.add_attribute(cell, 'text', 0)

+        con = app.connections[self.account]

+        jid = self.contact.jid

+        if self.TYPE_ID == 'pm':

+            jid = self.gc_contact.room_jid

+        if con.get_module('SecLabels').supported:

+            con.get_module('SecLabels').request_catalog(jid)

+

+    def _sec_labels_received(self, event):

+        if event.account != self.account:

+            return

+

+        jid = self.contact.jid

+        if self.TYPE_ID == 'pm':

+            jid = self.gc_contact.room_jid

+

+        if event.jid != jid:

+            return

+        model = self.xml.label_selector.get_model()

+        model.clear()

+

+        sel = 0

+        _label, labellist, default = event.catalog

+        for index, label in enumerate(labellist):

+            model.append([label])

+            if label == default:

+                sel = index

+

+        self.xml.label_selector.set_active(sel)

+        self.xml.label_selector.set_no_show_all(False)

+        self.xml.label_selector.show_all()

+

     def delegate_action(self, action):

         if action == 'browse-history':

             dict_ = {'jid': GLib.Variant('s', self.contact.jid),

             gspell_lang = Gspell.language_get_default()

         return gspell_lang

 

-    def on_language_changed(self, checker, param):

+    def on_language_changed(self, checker, _param):

         gspell_lang = checker.get_language()

         per_type = 'contacts'

         if self.type_id == message_control.TYPE_GC:

         self.msg_textview.grab_focus()

         return Gdk.EVENT_STOP

 

-    def on_banner_label_populate_popup(self, label, menu):

+    def on_banner_label_populate_popup(self, _label, menu):

         """

         Override the default context menu and add our own menuitems

         """

 

     def shutdown(self):

         super(ChatControlBase, self).shutdown()

-        # PluginSystem: removing GUI extension points connected with ChatControlBase

-        # instance object

+        # PluginSystem: removing GUI extension points

+        # connected with ChatControlBase instance object

         app.plugin_manager.remove_gui_extension_point('chat_control_base', self)

         app.plugin_manager.remove_gui_extension_point(

             'chat_control_base_draw_banner', self)

         app.plugin_manager.remove_gui_extension_point(

             'chat_control_base_update_toolbar', self)

-        app.ged.remove_event_handler('our-show', ged.GUI1,

-            self._nec_our_status)

-        app.ged.remove_event_handler('sec-catalog-received', ged.GUI1,

-            self._sec_labels_received)

-        app.ged.remove_event_handler('style-changed', ged.GUI1,

-            self._style_changed)

 

+        # Unregister handlers

+        for handler in self._base_event_handlers:

+            app.ged.remove_event_handler(*handler)

 

-    def on_msg_textview_populate_popup(self, textview, menu):

+    def on_msg_textview_populate_popup(self, _textview, menu):

         """

         Override the default context menu and we prepend an option to switch

         languages

         text = clipboard.wait_for_text()

         self.insert_as_quote(text)

 

-    def on_quote(self, widget, text):

+    def on_quote(self, _widget, text):

         self.insert_as_quote(text)

 

     # moved from ChatControl

-    def _on_banner_eventbox_button_press_event(self, widget, event):

+    def _on_banner_eventbox_button_press_event(self, _widget, event):

         """

         If right-clicked, show popup

         """

         if event.button == 3:  # right click

             self.parent_win.popup_menu(event)

 

-    def _on_message_textview_paste_event(self, texview):

+    def _on_message_textview_paste_event(self, _texview):

         clipboard = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD)

         image = clipboard.wait_for_image()

         if image is not None:

             # pressing Control again (as in ctrl+z)

             _buffer = widget.get_buffer()

             start_iter, end_iter = _buffer.get_bounds()

-            self.msg_textview.save_undo(_buffer.get_text(start_iter, end_iter, True))

+            self.msg_textview.save_undo(_buffer.get_text(start_iter,

+                                                         end_iter,

+                                                         True))

             self.space_pressed = False

 

         # Ctrl [+ Shift] + Tab are not forwarded to notebook. We handle it here

             end = message_buffer.get_iter_at_mark(position)

             text = message_buffer.get_text(start, end, False)

             splitted = text.split()

-            if (text.startswith(self.COMMAND_PREFIX) and not

-            text.startswith(self.COMMAND_PREFIX * 2) and len(splitted) == 1):

+            if (text.startswith(self.COMMAND_PREFIX) and

+                    not text.startswith(self.COMMAND_PREFIX * 2) and

+                    len(splitted) == 1):

                 text = splitted[0]

                 bare = text.lstrip(self.COMMAND_PREFIX)

                 if len(text) == 1:

         return False

 

     def _on_drag_data_received(self, widget, context, x, y, selection,

-                    target_type, timestamp):

+                               target_type, timestamp):

         """

         Derived types SHOULD implement this

         """

     def _on_drag_motion(self, *args):

         # FIXME: DND on non editable TextView, find a better way

         if not self.drag_entered:

-            # We drag new data over the TextView, make it editable to catch dnd

-            self.drag_entered_conv = True

             self.conv_textview.tv.set_editable(True)

 

-    def drag_data_file_transfer(self, contact, selection, widget):

+    def drag_data_file_transfer(self, contact, selection, _widget):

         # get file transfer preference

         ft_pref = app.config.get_per('accounts', self.account,

                                      'filetransfer_preference')

     def get_seclabel(self):

         idx = self.xml.label_selector.get_active()

         if idx == -1:

-            return

+            return None

 

         con = app.connections[self.account]

         jid = self.contact.jid

         label = labels[lname]

         return label

 

-    def send_message(self, message, type_='chat',

-    resource=None, xhtml=None, process_commands=True, attention=False):

+    def send_message(self,

+                     message,

+                     type_='chat',

+                     resource=None,

+                     xhtml=None,

+                     process_commands=True,

+                     attention=False):

         """

         Send the given message to the active tab. Doesn't return None if error

         """

         self.conv_textview.print_conversation_line(

             text, 'status', '', None)

 

-    def add_message(self, text, kind, name, tim,

-                    other_tags_for_name=None, other_tags_for_time=None,

-                    other_tags_for_text=None, restored=False, subject=None,

+    def add_message(self,

+                    text,

+                    kind,

+                    name,

+                    tim,

+                    other_tags_for_name=None,

+                    other_tags_for_time=None,

+                    other_tags_for_text=None,

+                    restored=False,

+                    subject=None,

                     old_kind=None,

-                    displaymarking=None, msg_log_id=None,

-                    message_id=None, correct_id=None, additional_data=None,

-                    marker=None, error=None):

+                    displaymarking=None,

+                    msg_log_id=None,

+                    message_id=None,

+                    correct_id=None,

+                    additional_data=None,

+                    marker=None,

+                    error=None):

         """

         Print 'chat' type messages

         correct_id = (message_id, correct_id)

         if additional_data is None:

             additional_data = AdditionalDataDict()

 

-        textview.print_conversation_line(text, kind, name, tim,

-            other_tags_for_name, other_tags_for_time, other_tags_for_text,

-            subject, old_kind,

-            displaymarking=displaymarking, message_id=message_id,

-            correct_id=correct_id, additional_data=additional_data,

-            marker=marker, error=error)

+        textview.print_conversation_line(text,

+                                         kind,

+                                         name,

+                                         tim,

+                                         other_tags_for_name,

+                                         other_tags_for_time,

+                                         other_tags_for_text,

+                                         subject,

+                                         old_kind,

+                                         displaymarking=displaymarking,

+                                         message_id=message_id,

+                                         correct_id=correct_id,

+                                         additional_data=additional_data,

+                                         marker=marker,

+                                         error=error)

 

         if restored:

             return

                 show_in_systray = get_show_in_systray(

                     event_type.type_, self.contact.jid)

 

-                event = event_type(text, subject, self, msg_log_id,

-                    show_in_roster=show_in_roster,

-                    show_in_systray=show_in_systray)

+                event = event_type(text,

+                                   subject,

+                                   self, msg_log_id,

+                                   show_in_roster=show_in_roster,

+                                   show_in_systray=show_in_systray)

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

                 # We need to redraw contact if we show in roster

                 if show_in_roster:

                     app.interface.roster.draw_contact(self.contact.jid,

-                        self.account)

+                                                      self.account)

 

         if not self.parent_win:

             return

         emoji_chooser.text_widget = self.msg_textview

         self.xml.emoticons_button.set_popover(emoji_chooser)

 

-    def on_color_menuitem_activate(self, widget):

+    def on_color_menuitem_activate(self, _widget):

         color_dialog = Gtk.ColorChooserDialog(None, self.parent_win.window)

         color_dialog.set_use_alpha(False)

         color_dialog.connect('response', self.msg_textview.color_set)

         color_dialog.show_all()

 

-    def on_font_menuitem_activate(self, widget):

+    def on_font_menuitem_activate(self, _widget):

         font_dialog = Gtk.FontChooserDialog(None, self.parent_win.window)

         start, finish = self.msg_textview.get_active_iters()

         font_dialog.connect('response', self.msg_textview.font_set, start, finish)

         tag = widget.get_name()

         self.msg_textview.set_tag(tag)

 

-    def on_clear_formatting_menuitem_activate(self, widget):

+    def on_clear_formatting_menuitem_activate(self, _widget):

         self.msg_textview.clear_tags()

 

     def _style_changed(self, *args):

     def update_tags(self):

         self.conv_textview.update_tags()

 

-    def clear(self, tv):

+    @staticmethod

+    def clear(tv):

         buffer_ = tv.get_buffer()

         start, end = buffer_.get_bounds()

         buffer_.delete(start, end)

 

-    def _on_send_file(self, action, param):

+    def _on_send_file(self, _action, _param):

         # get file transfer preference

         ft_pref = app.config.get_per('accounts', self.account,

                                      'filetransfer_preference')

         elif jingle.get_enabled():

             jingle.activate()

 

-    def _on_send_httpupload(self, action, param):

+    def _on_send_httpupload(self, _action, _param):

         app.interface.send_httpupload(self)

 

-    def _on_send_jingle(self, action, param):

+    def _on_send_jingle(self, _action, _param):

         self._on_send_file_jingle()

 

     def _on_send_file_jingle(self, gc_contact=None):

         """

         gc_contact can be set when we are in a groupchat control

         """

-        def _on_ok(c):

+        def _on_ok(_contact):

             app.interface.instances['file_transfers'].show_file_send_request(

-                self.account, c)

+                self.account, _contact)

+

         if self.type_id == message_control.TYPE_PM:

             gc_contact = self.gc_contact

 

         _on_ok(gc_contact)

 

     def on_notify_menuitem_toggled(self, widget):

-        app.config.set_per('rooms', self.contact.jid, 'notify_on_all_messages',

-            widget.get_active())

+        app.config.set_per('rooms',

+                           self.contact.jid,

+                           'notify_on_all_messages',

+                           widget.get_active())

 

     def set_control_active(self, state):

         con = app.connections[self.account]

                 type_ = ['printed_' + self.type_id]

                 if self.type_id == message_control.TYPE_GC:

                     type_ = ['printed_gc_msg', 'printed_marked_gc_msg']

-                if not app.events.remove_events(self.account, self.get_full_jid(),

-                types=type_):

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

+                                                self.get_full_jid(),

+                                                types=type_):

                     # There were events to remove

                     self.redraw_after_event_removed(jid)

             # send chatstate inactive to the one we're leaving

     def scroll_to_end(self, force=False):

         self.conv_textview.scroll_to_end(force)

 

-    def _on_edge_reached(self, scrolledwindow, pos):

+    def _on_edge_reached(self, _scrolledwindow, pos):

         if pos != Gtk.PositionType.BOTTOM:

             return

         # Remove all events and set autoscroll True

             app.log('autoscroll').info('Autoscroll disabled')

             self.conv_textview.autoscroll = False

 

-    def on_conversation_vadjustment_changed(self, adjustment):

+    def on_conversation_vadjustment_changed(self, _adjustment):

         self.scroll_to_end()

 

     def redraw_after_event_removed(self, jid):

         if self.type_id == message_control.TYPE_PM:

             room_jid, nick = app.get_room_and_nick_from_fjid(jid)

             groupchat_control = app.interface.msg_win_mgr.get_gc_control(

-                    room_jid, self.account)

+                room_jid, self.account)

             if room_jid in app.interface.minimized_controls[self.account]:

                 groupchat_control = \

                         app.interface.minimized_controls[self.account][room_jid]

         self.msg_textview.set_editable(False)

         self.conv_textview.tv.grab_focus()

 

-        self.no_autonegotiation = False

         self.update_toolbar()

 

 

         ChatControl.__init__(self, parent_win, contact, account, session)

         self.TYPE_ID = 'pm'

 

+        # pylint: disable=line-too-long

         self.__event_handlers = [

             ('update-gc-avatar', ged.GUI1, self._nec_update_avatar),

             ('caps-update', ged.GUI1, self._nec_caps_received_pm),

             ('muc-user-status-show-changed', ged.GUI1, self._on_status_show_changed),

             ('muc-destroyed', ged.GUI1, self._on_diconnected),

         ]

+        # pylint: enable=line-too-long

 

         for handler in self.__event_handlers:

             app.ged.register_event_handler(*handler)

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

Commits:

3 changed files:

Changes: