@command('part', 'close', raw=True, empty=True)

     @doc(_("Leave the groupchat, optionally giving a reason, and close tab or window"))

     def leave(self, reason):

         self.parent_win.remove_tab(self, self.parent_win.CLOSE_COMMAND, reason)

     @command(raw=True, empty=True)

 import copy

 import nbxmpp

 from nbxmpp.util import is_error_result

 from nbxmpp.structs import BookmarkData

 from nbxmpp.const import BookmarkStoreType

             if not bookmark_copy.name:

                 # No name was given for this bookmark

                 # Use the first part of JID instead

                 bookmark_copy = bookmark_copy._replace(name=name)

             if short_name:

                         self._account, str(bookmark.jid), bookmark.nick,

                         bookmark.password, minimize=minimize)

         self._bookmarks.append(bookmark)

         self.store_bookmarks()

         if not app.account_is_connected(self._account):

             return

         self._con.get_module('Discovery').disco_muc(

         show = helpers.get_xmpp_show(app.SHOW_LIST[self._con.connected])

         presence = self._con.get_module('Presence').get_presence(

             show=show,

             status=self._con.status)

         muc_x = presence.setTag(nbxmpp.NS_MUC + ' x')

         self._con.connection.send(presence)

     def leave(self, room_jid):

         self._log.info('Leave MUC: %s', room_jid)

         self._set_muc_state(room_jid, MUCJoinedState.NOT_JOINED)

         self._con.get_module('Presence').send_presence(

             typ='unavailable')

     def configure_room(self, room_jid):

         self._nbxmpp('MUC').request_config(room_jid,

         self._log.info('Configure room: %s', result.jid)

         self.set_config(result.jid,

                         result.form,

                         callback=self._on_config_result)

     def update_presence(self, auto=False):

         mucs = self.get_mucs_with_state([MUCJoinedState.JOINED,

                                          MUCJoinedState.JOINING])

         show = app.SHOW_LIST[self._con.connected]

         if show in ('invisible', 'offline'):

             # FIXME: Check if this

             return

         status = self._con.status

         xmpp_show = helpers.get_xmpp_show(show)

             idle_time = time.strftime('%Y-%m-%dT%H:%M:%SZ',

                                       time.gmtime(time.time() - idle_sec))

         self._log.info('Send presence: %s, show: %s, status: %s, idle_time: %s',

         self._con.get_module('Presence').send_presence(

             show=xmpp_show,

             status=status,

             caps=True,

                 muc_x.setTag('history', tags)

     def _on_muc_presence(self, _con, _stanza, properties):

         if (properties.error.type == Error.CONFLICT and

             self._log.info('Nickname conflict: %s change to %s',

             return

         self._raise_muc_event('muc-presence-error', properties)

         if properties.type == PresenceType.ERROR:

             return

         if room_jid not in self._muc_data:

             self._log.warning('Presence from unknown MUC')

             self._log.warning(stanza)

             return

         contact = app.contacts.get_gc_contact(self._account,

                                               properties.muc_nickname)

         if properties.is_nickname_changed:

         if not properties.is_muc_subject:

             return

         contact = app.contacts.get_groupchat_contact(self._account, jid)

         if contact is None:

             return

                          nickname=properties.muc_nickname,

                          user_timestamp=properties.user_timestamp))

             self._set_muc_state(jid, MUCJoinedState.JOINED)

         raise nbxmpp.NodeProcessed

         app.nec.push_incoming_event(

             NetworkEvent('muc-voice-approval',

                          account=self._account,

                          form=properties.voice_request.form))

         raise nbxmpp.NodeProcessed

         if not properties.is_muc_config_change:

             return

         self._log.info('Received config change: %s %s',

                        room_jid, properties.muc_status_codes)

         app.nec.push_incoming_event(

 from collections import namedtuple

 from gajim.common.const import MUCJoinedState

 URI = namedtuple('URI', 'type action data')

 class MUCData:

     def __init__(self, room_jid, nick, password, rejoin, config=None):

         self._nick = nick

         self._password = password

         self._rejoin = rejoin

     def jid(self):

         return self._room_jid

     @property

     def nick(self):

         return self._nick

 from enum import IntEnum, unique

 import nbxmpp

 from nbxmpp.const import StatusCode

 from nbxmpp.const import Affiliation

 from nbxmpp.const import Role

                 prompt, change_nick=True, transient_for=self.parent_win.window)

     def _on_disconnect(self, action, param):

         self.force_non_minimizable = True

         self.parent_win.remove_tab(self, self.parent_win.CLOSE_COMMAND)

         self.force_non_minimizable = False

         password = app.gc_passwords.get(self.room_jid, '')

         con = app.connections[self.account]

         con.get_module('Bookmarks').add_bookmark(self.name,

                                                  True,

                                                  password,

                                                  self.nick)

         for handler in self._event_handlers:

             app.ged.remove_event_handler(*handler)

         nick_list = app.contacts.get_nick_list(self.account, self.room_jid)

         for nick in nick_list:

             # Update pm chat window

 import uuid

 import nbxmpp

 from nbxmpp.util import is_error_result

 from nbxmpp.structs import DiscoIdentity

             return

         con.get_module('Bookmarks').add_bookmark(room_jid.split('@')[0],

                                                  False,

                                                  '',

                                                  '')

 from gi.repository import Gdk

 import nbxmpp

 from nbxmpp.util import is_error_result

 from nbxmpp.structs import DiscoIdentity

         # Add as bookmark, with autojoin and not minimized

         name = app.get_nick_from_jid(self.room_jid)

         con.get_module('Bookmarks').add_bookmark(name,

                                                  autojoin,

                                                  password,

                                                  nickname)

         """

         When disconnect menuitem is activated: disconnect from room

         """

         if jid in app.interface.minimized_controls[account]:

             ctrl = app.interface.minimized_controls[account][jid]

             ctrl.shutdown()