def on_xml_console(action, param):

 def on_manage_proxies(action, param):

             ('history-manager', app_actions.on_history_manager),

             ('preferences', app_actions.on_preferences),

             ('plugins', app_actions.on_plugins),

             ('file-transfer', app_actions.on_file_transfers),

             ('history', app_actions.on_history),

             ('shortcuts', app_actions.on_keyboard_shortcuts),

         from gajim import app_actions as a

         if account == 'Local':

         return [

             ('-bookmarks', a.on_bookmarks, 'online', 's'),

             ('-add-contact', a.on_add_contact, 'online', 'as'),

             ('-services', a.on_service_disco, 'online', 's'),

             ('-profile', a.on_profile, 'feature', 's'),

             ('-server-info', a.on_server_info, 'online', 's'),

             ('-archive', a.on_mam_preferences, 'feature', 's'),

             ('-pep-config', a.on_pep_config, 'online', 's'),

             self.add_message(event.message, kind, tim=event.time,

                 encrypted=event.encrypted, subject=event.subject,

                 xhtml=event.xhtml, displaymarking=event.displaymarking,

             if isinstance(event.msg_log_id, int):

                 message_ids.append(event.msg_log_id)

         self.received_history_pos = 0

         self.orig_msg = None

         self.set_emoticon_popover()

         # Attach speller

         if restored:

             return

         if kind == 'incoming':

             if not self.type_id == message_control.TYPE_GC or \

             app.config.notify_for_muc(jid) or \

                     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)

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

                 types=type_):

                     # There were events to remove

                     self.redraw_after_event_removed(jid)

             # send chatstate inactive to the one we're leaving

             # and active to the one we visit

             if self.msg_textview.has_text():

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

     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

         """

         self.parent_win.redraw_tab(self)

         self.parent_win.show_title()

         # TODO : get the contact and check get_show_in_roster()

     nbxmpp.NS_BYTESTREAM,

     nbxmpp.NS_FILE,

     nbxmpp.NS_MUC,

     nbxmpp.NS_COMMANDS,

     nbxmpp.NS_DISCO_INFO,

     nbxmpp.NS_LAST,

                 obj.session.last_send = time.time()

                 msg_iq.setThread(obj.session.thread_id)

         self._push_stanza_message_outgoing(obj, msg_iq)

     def _push_stanza_message_outgoing(self, obj, msg_iq):

 class ChatEvent(Event):

     type_ = 'chat'

     def __init__(self, message, subject, kind, time_, encrypted, resource,

     displaymarking=None, sent_forwarded=False, show_in_roster=False,

     show_in_systray=True, additional_data=None):

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

         self.encrypted = encrypted

         self.resource = resource

         self.msg_log_id = msg_log_id

         self.correct_id = correct_id

         self.xhtml = xhtml

         self.session = session

 class PrintedChatEvent(Event):

     type_ = 'printed_chat'

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

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

             show_in_systray=show_in_systray)

         self.message = message

         self.subject = subject

         self.control = control

         self.msg_log_id = msg_log_id

 class PrintedGcMsgEvent(PrintedChatEvent):

     type_ = 'printed_gc_msg'

     'bookmarks',

     'caps',

     'carbons',

     'chatstates',

     'delimiter',

     'discovery',

             'timestamp': properties.timestamp,

             'delayed': properties.user_timestamp is not None,

             'muc_pm': properties.is_muc_pm,

         }

         app.nec.push_incoming_event(NetworkEvent('update-client-info',

         </item>

       </section>

       <section>

         <item>

           <attribute name="label" translatable="yes">File Transfer</attribute>

           <attribute name="action">app.file-transfer</attribute>

     <property name="visible">True</property>

     <property name="can_focus">False</property>

     <property name="title" translatable="yes">XML Console</property>

     <property name="show_close_button">True</property>

     <child>

         <property name="visible">True</property>

       </object>

     </child>

   </object>

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

                            msg_log_id=None, encrypted=False,

         # Do we have a queue?

         fjid = self.room_jid + '/' + nick

                                session=session,

                                form_node=None,

                                displaymarking=displaymarking,

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

         autopopup = app.config.get('autopopup')

                 self.on_private_message(

                     nick, obj.sent, obj.msgtxt, obj.timestamp,

                     obj.xhtml, self.session, msg_log_id=obj.msg_log_id,

     def _nec_ping(self, obj):

         if self.contact.jid != obj.contact.room_jid:

 class XMLConsoleWindow(Gtk.ApplicationWindow):

         Gtk.ApplicationWindow.__init__(self)

         self.set_application(app.app)

         self.set_position(Gtk.WindowPosition.CENTER)

         self.set_show_menubar(False)

         self.set_name('XMLConsoleWindow')

         self.presence = True

         self.message = True

         self.iq = True

         self.filter_dialog = None

         self.last_stanza = None

         self.set_titlebar(self._ui.headerbar)

         self.add(self._ui.box)

         self._ui.paned.set_position(self._ui.paned.get_property('max-position'))

         button = get_image_button(

         self._ui.actionbar.pack_start(button)

         button = get_image_button(

         self._ui.actionbar.pack_start(button)

         button = get_image_button(

         button.connect('clicked', self._on_paste_last)

         self._ui.actionbar.pack_start(button)

         button.connect('clicked', self._on_send)

         self._ui.actionbar.pack_end(button)

         app.ged.register_event_handler(

             'stanza-sent', ged.GUI1, self._nec_stanza_sent)

     def _create_tags(self):

         buffer_ = self._ui.textview.get_buffer()

         in_color = app.css_config.get_value(

             self._ui.input_entry.grab_focus()

     def _on_send(self, *args):

             # If offline or connecting

             ErrorDialog(

                 _('Connection not available'),

                 _('Please make sure you are connected with \'%s\'.') %

             return

         buffer_ = self._ui.input_entry.get_buffer()

         begin_iter, end_iter = buffer_.get_bounds()

                 # stream management

                 node = nbxmpp.Protocol(node=stanza,

                                        attrs={'xmlns': 'jabber:client'})

             self.last_stanza = stanza

             buffer_.set_text('')

         if self.filter_dialog:

             self.filter_dialog.present()

             return

             Setting(SettingKind.SWITCH, 'Presence',

                     SettingType.VALUE, self.presence,

             Setting(SettingKind.SWITCH, 'Message',

                     SettingType.VALUE, self.message,

             Setting(SettingKind.SWITCH, 'IQ', SettingType.VALUE, self.iq,

             Setting(SettingKind.SWITCH, 'Stream Management',

                     SettingType.VALUE, self.stream,

             Setting(SettingKind.SWITCH, 'In', SettingType.VALUE, self.incoming,

             Setting(SettingKind.SWITCH, 'Out', SettingType.VALUE, self.outgoing,

         ]

                                             Gtk.DialogFlags.DESTROY_WITH_PARENT,

         self.filter_dialog.connect('destroy', self._on_filter_destroyed)

     def _on_filter_destroyed(self, win):

         app.ged.remove_event_handler(

             'stanza-sent', ged.GUI1, self._nec_stanza_sent)

         setattr(self, data, value)

         value = not value

         table = self._ui.textview.get_buffer().get_tag_table()

         tag.set_property('invisible', value)

     def _nec_stanza_received(self, obj):

     def _nec_stanza_sent(self, obj):

         # Kind must be 'incoming' or 'outgoing'

         if not stanza:

             return

         elif stanza.startswith('<r') or stanza.startswith('<a'):

             type_ = 'stream'

             kind=kind.capitalize(),

             time=time.strftime('%c'),

             stanza=stanza.replace('><', '>\n<'))

         buffer_.insert_with_tags_by_name(end_iter, stanza, type_, kind)

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

             ctrl.remove_session(ctrl.session)

     def handle_event_msgerror(self, obj):

         #'MSGERROR' (account, (jid, error_code, error_msg, msg, time[session]))

         account = obj.conn.name

             'unsubscribed-presence-received': [

                 self.handle_event_unsubscribed_presence],

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

         }

     def register_core_handlers(self):

             ('-pep-config', _('PEP Configuration')),

             ('-sync-history', _('Synchronise History')),

             ('-privacylists', _('Privacy Lists')),

         ]),

         (_('Admin'), [

             ('-send-server-message', _('Send Server Message…')),

         ]),

     ]

     def build_menu(preset):

         menu = Gio.Menu()

         for item in preset:

                 menu.append_submenu(label, submenu)

         return menu

     return build_menu(account_menu)

         acc_menu.append_item(modify_account_item)

         for acc in accounts_list:

             label = escape_mnemonic(app.get_account_label(acc))

     else:

         acc_menu = get_account_menu(accounts_list[0])

         modify_account_item = Gio.MenuItem.new(_('_Modify Account…'),

         if do_event:

             event = event_t(obj.msgtxt, obj.subject, obj.mtype, obj.timestamp,

                 obj.encrypted, obj.resource, obj.msg_log_id,

                 session=self, form_node=obj.form_node,

                 displaymarking=obj.displaymarking,

                 sent_forwarded=obj.forwarded and obj.sent,