# close old stage

         self.stage_finish()

         self.stages_notebook.set_current_page(

             self.stages_notebook.page_num(self.command_list_stage_vbox))

         """

         Create new window... only if we have anything to show

         """

         self.entry = None # the entry actually displayed

         """

         Get next entry from the queue and display it in the window

         """

         newentry = self.__class__.entries.pop(0)

                 local_old_kind = None

             else:

                 local_old_kind = kind

             self.conv_textview.print_empty_line()

     def read_queue(self):

         else: # Not a GC

             types_list = ['printed_' + type_, type_]

             return

         if not self.parent_win:

             return

     # host is now f.e. icq.foo.org or just icq (sometimes on hacky transports)

     host_splitted = host.split('.')

         # now we support both 'icq.' and 'icq' but not icqsucks.org

         host = host_splitted[0]

         for mech in auth_mechs:

             if mech not in nbxmpp.auth_nb.SASL_AUTHENTICATION_MECHANISMS | set(['XEP-0078']):

                 log.warning("Unknown authentication mechanisms %s" % mech)

             auth_mechs = None

         else:

             auth_mechs = set(auth_mechs)

                 self._on_stun_resolved)

     def _on_stun_resolved(self, host, result_array):

             self._stun_servers = self._hosts = [i for i in result_array]

     @helpers.call_counter

             return False

         if self.sub in ('none', 'from') and self.ask == 'subscribe':

             return False

             return False

         if _('Not in Roster') in self.groups:

             return False

             return

         if contact in self._contacts[contact.jid]:

             self._contacts[contact.jid].remove(contact)

             del self._contacts[contact.jid]

     def remove_jid(self, jid):

             return

         del self._rooms[gc_contact.room_jid][gc_contact.name]

         # It was the last nick in room ?

             del self._rooms[gc_contact.room_jid]

     def remove_room(self, room_jid):

         if server is not None:

             if server.endswith('.'):  # RFC7622, 3.2

                 server = server[:-1]

                 raise InvalidFormat(_('Server must be between 1 and 1023 bytes'))

             try:

                 from nbxmpp.stringprepare import nameprep

             raise InvalidFormat(_('Server address required.'))

     if user is not None:

             raise InvalidFormat(_('Username must be between 1 and 1023 bytes'))

         try:

             if HAS_PRECIS_I18N:

         user = None

     if resource is not None:

             raise InvalidFormat(_('Resource must be between 1 and 1023 bytes'))

         try:

             if HAS_PRECIS_I18N:

     accounts = get_notification_icon_tooltip_dict()

         # No configured account

         return _('Gajim')

     def update_config(self, old_version, new_version):

         old_version_list = old_version.split('.') # convert '0.x.y' to (0, x, y)

         old = []

             old.append(int(old_version_list.pop(0)))

         new_version_list = new_version.split('.')

         new = []

             new.append(int(new_version_list.pop(0)))

         if old < [0, 14, 0, 1] and new >= [0, 14, 0, 1]:

                     self.remove_sender_by_key(key, do_disconnect=do_disconnect)

                     if not remove_all:

                         break

                 self.listener.disconnect()

                 self.listener = None

                 self.connected -= 1

         except Exception:

             add = b''

         received += add

             self.disconnect()

         return add

                 self.file_props.error = -7 # unable to read from file

                 return -1

             buff = self.file.read(MAX_BUFF_LEN)

             lenn = 0

             try:

                 lenn = self._send(buff)

                 self.file_props.last_time

             self.file_props.last_time = current_time

             self.file_props.received_len += len(buff)

                 # Transfer stopped  somehow:

                 # reset, paused or network error

                 self.rem_fd(fd)

         except socket.gaierror as e:

             log.info('Lookup failure for %s: %s[%s]', self.host, e[1],

                 repr(e[0]), exc_info=True)

         else:

             self.connect_to_next_ip()

     def connect_to_next_ip(self):

             log.error('Connection failure to %s', str(self.host), exc_info=True)

             self.disconnect()

             return

         ai = self.ais.pop(0)

     def read_timeout(self):

         ids = self.client.conn_holder.ids_of_awaiting_messages

             for (id_, thread_id) in ids[self.fd]:

                 if hasattr(self._owner, 'Dispatcher'):

                     self._owner.Dispatcher.Event('', DATA_ERROR, (

             self.up_button.set_sensitive(False)

             self.down_button.set_sensitive(False)

             self.clear_button.set_sensitive(False)

         else:

             self.clear_button.set_sensitive(True)

         return _('%(hours)02.d:%(minutes)02.d:%(seconds)02.d') % times

     def _get_eta_and_speed(self, full_size, transfered_size, file_props):

             return 0., 0.

         elif len(file_props.transfered_size) == 1:

             speed = round(float(transfered_size) / file_props.elapsed_time)

         Check if there are transfer rows and set cleanup_button sensitive, or

         insensitive if model is empty

         """

             self.cleanup_button.set_sensitive(False)

         else:

             self.cleanup_button.set_sensitive(True)

             str_ = _('Usage: %(basename)s %(command)s %(arguments)s \n\t %(help)s')\

                     % {'basename': BASENAME, 'command': command,

                     'arguments': arguments_str, 'help': command_props[0]}

                 str_ += '\n\n' + _('Arguments:') + '\n'

                 for argument in command_props[1]:

                     str_ += ' ' + argument[0] + ' - ' + argument[1] + '\n'

         gc_contact = app.contacts.get_gc_contact(self.account, self.room_jid,

                 nick)

         theme = Gtk.IconTheme.get_default()

             icon_name = gtkgui_helpers.get_iconset_name_for('event')

             surface = theme.load_surface(icon_name, 16, self.scale_factor, None, 0)

         else:

                     self.autorejoin = False

                     self.print_conversation(obj.reason, 'info', graphics=False)

                 self.remove_contact(obj.nick)

                 self.draw_all_roles()

             else:

             # nick completion

             # check if tab is pressed with empty message

                 begin = splitted_text[-1] # last word we typed

             else:

                 begin = ''

             gc_refer_to_nick_char + ' '):

                 with_refer_to_nick_char = True

                 after_nick_len = len(gc_refer_to_nick_char + ' ')

                text[:-after_nick_len].endswith(self.nick_hits[0]):

                 # we should cycle

                 # Previous nick in list may had a space inside, so we check text

                        helpers.jid_is_blocked(self.account, fjid):

                         # the word is the beginning of a nick

                         self.nick_hits.append(nick)

                 if len(splitted_text) < 2 or with_refer_to_nick_char:

                 # This is the 1st word of the line or no word or we are cycling

                 # at the beginning, possibly with a space in one nick

                 app.config.get('gc_proposed_nick_char'))

     def check_next(self):

             self.cancel_handler = None

             self.dialog.destroy()

             if 'change_nick_dialog' in app.interface.instances:

         Return the value of the option opt if it's the same in all accounts else

         returns "mixed"

         """

             # a non existent key return default value

             return app.config.get_per('accounts', '__default__', opt)

         val = None

                 self.max_order = int(rule['order'])

             self.global_rules[text_item] = rule

             model.append([text_item])

             self.title_hbox.set_sensitive(False)

             self.list_of_rules_combobox.set_sensitive(False)

             self.delete_rule_button.set_sensitive(False)

         self.draw_widgets()

     def draw_widgets(self):

             self.list_of_privacy_lists_combobox.set_sensitive(False)

             self.open_privacy_list_button.set_sensitive(False)

             self.delete_privacy_list_button.set_sensitive(False)

                 if s.control:

                     session = s

                     break

                 # there are no sessions with chat controls, just take the first

                 # one

                 session = sessions[0]

         mw.new_tab(chat_control)

             # We call this here to avoid race conditions with widget validation

             chat_control.read_queue()

         if not ctrl:

             ctrl = self.new_chat(contact, account,

                 resource=resource)

                 ctrl.read_queue()

         if message:

 #        except Exception:

 #            pass

         # add default status messages if there is not in the config file

             default = app.config.statusmsg_default

             for msg in default:

                 app.config.add_per('statusmsg', msg)

                     default[msg][5])

         # Add Tor proxy if there is not in the config

             default = app.config.proxies_default

             for proxy in default:

                 app.config.add_per('proxies', proxy)

                     self.callbacks.remove((acct, cb))

         else:

             self.callbacks = []

             self.dialog.window.destroy()

     def run_callback(self, account, callback):

         for (c, a) in list_:

             if c.supports(NS_MUC):

                 list2.append((c, a))

             invite_to_new_room_menuitem.connect('activate',

                 roster.on_invite_to_new_room, list2, None)

         else:

         app.gc_connected[acct][room_jid] and \

         contacts_transport in ['jabber', None]:

             rooms.append((room_jid, acct))

         item = Gtk.SeparatorMenuItem.new() # separator

         invite_to_submenu.append(item)

         for (room_jid, account) in rooms:

             del self._controls[ctrl.account][fjid]

                 del self._controls[ctrl.account]

             self.check_tabs()

         info.title = meta.get('xesam:title')

         info.album = meta.get('xesam:album')

         artist = meta.get('xesam:artist')

             info.artist = artist[0]

         else:

             info.artist = None

             parent_iters = self._get_contact_iter(

                     big_brother_contact.jid, big_brother_account,

                     big_brother_contact, self.model)

             # Do not confuse get_contact_iter: Sync groups of family members

             contact.groups = big_brother_contact.groups[:]

                 if group not in app.groups[account]:

                     app.groups[account][group] = {'expand': is_expanded}

         return added_iters

     def _remove_entity(self, contact, account, groups=None):

         big_brother_contact = app.contacts.get_first_contact_from_jid(

                 big_brother_account, big_brother_jid)

                 'Big brother %s already in roster\n Family: %s' \

                 % (big_brother_jid, family)

         self._add_entity(big_brother_contact, big_brother_account)

                 # or brother already added

                 continue

                     "%s already in roster.\n Family: %s" % (_jid, nearby_family)

             self._add_entity(_contact, _account,

                     big_brother_contact = big_brother_contact,

             ok = self._remove_entity(_contact, _account)

             assert ok, '%s was not removed' % _jid

         if not family_in_roster:

             return False

             (nearby_family, family)

         iters = self._get_contact_iter(old_big_jid, old_big_account,

             old_big_contact, self.model)

             old_big_jid

         assert not self.model.iter_children(iters[0]), \

             'Old Big Brother %s still has children' % old_big_jid

         ok = self._remove_entity(old_big_contact, old_big_account)

         assert ok, "Old Big Brother %s not removed" % old_big_jid

             'Old Big Brother %s is removed but still in roster' % old_big_jid

         return True

         jid = app.get_jid_from_account(account)

         contact = app.contacts.get_first_contact_from_jid(account, jid)

         child_iterA = self._get_account_iter(account, self.model)

         self._iters[account]['contacts'][jid] = [self.model.append(child_iterA,

         account -- the corresponding account.

         """

         contact = app.contacts.get_contact_with_highest_priority(account, jid)

             # If contact already in roster, do nothing

             return

         to_hide = []

         while(iterG):

             parent = self.modelfilter.iter_parent(iterG)

                 to_hide.append(iterG)

                 if not parent or self.modelfilter[parent][Column.TYPE] != \

                 'group':

                         # a child has awaiting messages?

                         jidC = self.model[iterC][Column.JID]

                         accountC = self.model[iterC][Column.ACCOUNT]

                             icon_name = 'event'

                             break

                         iterC = self.model.iter_next(iterC)

                 GLib.idle_add(ctrl.parent_win.set_active_tab, ctrl)

             else:

                 ctrl = app.interface.new_chat(obj.contact, account)

                     ctrl.read_queue()

     def _nec_gc_presence_received(self, obj):

             contact = app.contacts.get_contact(obj.conn.name, obj.jid)

             obj.session.control = app.interface.new_chat(contact,

                 obj.conn.name, session=obj.session)

                 obj.session.control.read_queue()

         if obj.show_in_roster:

         elif event.keyval == Gdk.KEY_Delete:

             treeselection = self.tree.get_selection()

             model, list_of_paths = treeselection.get_selected_rows()

                 return

             type_ = model[list_of_paths[0]][Column.TYPE]

             account = model[list_of_paths[0]][Column.ACCOUNT]

             self.previous_status_combobox_active = active

             return

         accounts = list(app.connections.keys())

             ErrorDialog(_('No account available'),

                 _('You must create an account before you can chat with other '

                 'contacts.'))

         # if a contact row is selected, update colors (eg. for status msg)

         # because gtk engines may differ in bg when window is selected

         # or not

             for (jid, account) in self._last_selected_contact:

                 self.draw_contact(jid, account, selected=True, focus=True)

         # if a contact row is selected, update colors (eg. for status msg)

         # because gtk engines may differ in bg when window is selected

         # or not

             for (jid, account) in self._last_selected_contact:

                 self.draw_contact(jid, account, selected=True, focus=False)

                 # let message window close the tab

                 return