Ticket #1201: modelfilter_v2.patch

src/roster_window.py

@@ -23 +23 @@
 import os
 import time
 import urllib
+import threading
 
 import common.sleepy
 import history_window
@@ -67 +68 @@
 class RosterWindow:
         '''Class for main window of the GTK+ interface'''
 
-        def get_account_iter(self, name):
+        def get_account_iter(self, name, model = None):
                 ''' Returns a gtk.TreeIter of accounts in roster data model or None '''
-                model = self.tree.get_model()
+                if not model:
+                        model = self.tree.get_model()
                 if model is None:
                         return
                 account_iter = model.get_iter_root()
                 if self.regroup:
                         return account_iter
                 while account_iter:
-                        account_name = model[account_iter][C_ACCOUNT].decode('utf-8')
-                        if name == account_name:
+                        account_name = model[account_iter][C_ACCOUNT]
+                        if account_name and name == account_name.decode('utf-8'):
                                 break
                         account_iter = model.iter_next(account_iter)
                 return account_iter
 
-        def get_group_iter(self, name, account):
+        def get_group_iter(self, name, account, model = None):
                 ''' Returns a gtk.TreeIter of groups in roster data model or None '''
-                model = self.tree.get_model()
-                root = self.get_account_iter(account)
+                if not model:
+                        model = self.tree.get_model()
+                root = self.get_account_iter(account, model)
                 group_iter = model.iter_children(root)
                 # C_NAME column contacts the pango escaped group name
                 while group_iter:
@@ -95 +98 @@
                         group_iter = model.iter_next(group_iter)
                 return group_iter
 
-        def get_contact_iter(self, jid, account):
+        def get_contact_iter(self, jid, account, model = None):
                 if jid == gajim.get_jid_from_account(account):
                         iter = self.get_self_contact_iter(account)
                         if iter:
                                 return [iter]
                         else:
                                 return []
-                model = self.tree.get_model()
-                acct = self.get_account_iter(account)
+                if not model:
+                        model = self.tree.get_model()
+                acct = self.get_account_iter(account, model)
                 found = []
                 if model is None: # when closing Gajim model can be none (async pbs?)
                         return found
@@ -111 +115 @@
                 while group_iter:
                         contact_iter = model.iter_children(group_iter)
                         while contact_iter:
-                                if jid == model[contact_iter][C_JID].decode('utf-8') and \
+                                iter_jid = model[contact_iter][C_JID]
+                                if iter_jid and jid == iter_jid.decode('utf-8') and \
                                         account == model[contact_iter][C_ACCOUNT].decode('utf-8'):
                                         found.append(contact_iter)
                                 # find next contact iter
@@ -157 +162 @@
                         # show him
                         self.add_contact_to_roster(jid, account)
                         iters = self.get_contact_iter(jid, account)
+                        #FIXME: adding it doesn't mean it is visible
+                        if not iters:
+                                return
                         path = self.tree.get_model().get_path(iters[0])
                 if self.dragging or not gajim.config.get('scroll_roster_to_last_message'):
                         # do not change selection while DND'ing
@@ -171 +179 @@
         def add_account_to_roster(self, account):
                 ''' Add an account to roster data model. '''
                 model = self.tree.get_model()
+                child_model = model.get_model()
                 if self.get_account_iter(account):
                         return
 
                 # if we merge accounts...
                 if self.regroup:
                         show = helpers.get_global_show()
-                        model.append(None, [self.jabber_state_images['16'][show],
+                        child_model.append(None, [self.jabber_state_images['16'][show],
                                 _('Merged accounts'), 'account', '', 'all', None])
                         self.draw_account(account)
                         return
@@ -191 +200 @@
 
                 our_jid = gajim.get_jid_from_account(account)
 
-                model.append(None, [self.jabber_state_images['16'][show],
+                child_model.append(None, [self.jabber_state_images['16'][show],
                         gobject.markup_escape_text(account),
                         'account', our_jid, account, tls_pixbuf])
 
         def draw_account(self, account):
-                model = self.tree.get_model()
-                iter = self.get_account_iter(account)
+                child_iter = self.get_account_iter(account, self.model)
                 if self.regroup:
                         accounts = gajim.connections.keys()
                 else:
@@ -226 +234 @@
                                                 new_pixels += chr(128)
                                 tls_pixbuf = gtk.gdk.pixbuf_new_from_data(new_pixels, colorspace,
                                         True, bps, width, height, rowstride)
-                        model[iter][C_SECPIXBUF] = tls_pixbuf
+                        self.model[child_iter][C_SECPIXBUF] = tls_pixbuf
                 else:
-                        model[iter][C_SECPIXBUF] = None
-                path = model.get_path(iter)
+                        self.model[child_iter][C_SECPIXBUF] = None
+                path = self.model.get_path(child_iter)
                 account_name = account
                 accounts = [account]
                 if self.regroup:
                         account_name = _('Merged accounts')
                         accounts = []
-                if not self.tree.row_expanded(path) and model.iter_has_child(iter):
+                if not self.tree.row_expanded(path) and self.model.iter_has_child(
+                child_iter):
                         # account row not expanded
                         account_name = '[%s]' % account_name
                 if (gajim.account_is_connected(account) or (self.regroup and \
@@ -244 +253 @@
                         nbr_on, nbr_total = gajim.contacts.get_nb_online_total_contacts(
                                 accounts = accounts)
                         account_name += ' (%s/%s)' % (repr(nbr_on),repr(nbr_total))
-                model[iter][C_NAME] = account_name
+                self.model[child_iter][C_NAME] = account_name
 
         def remove_newly_added(self, jid, account):
                 if jid in gajim.newly_added[account]:
@@ -257 +266 @@
                 is False, because it has online children, so we need to show it.
                 If add_children is True, we also add all children, even if they were not
                 already drawn'''
-                showOffline = gajim.config.get('showoffline')
-                model = self.tree.get_model()
+                model = self.modelfilter
+                child_model = model.get_model()
                 contact = gajim.contacts.get_first_contact_from_jid(account, jid)
                 nb_events = gajim.events.get_nb_roster_events(account, contact.jid)
                 # count events from all resources
@@ -275 +284 @@
                         self.add_self_contact(account)
                         return
                 if gajim.jid_is_transport(contact.jid):
-                        # if jid is transport, check if we wanna show it in roster
-                        if not gajim.config.get('show_transports_group') and not nb_events:
-                                return
                         contact.groups = [_('Transports')]
-                elif not showOffline and not gajim.account_is_connected(account) and \
-                nb_events == 0:
-                        return
 
-                # XEP-0162
-                hide = contact.is_hidden_from_roster()
-                if hide and contact.sub != 'from':
-                        return
                 observer = contact.is_observer()
                 groupchat = contact.is_groupchat()
 
@@ -295 +294 @@
                         tag = gajim.contacts.get_metacontacts_tag(account, jid)
                         if tag:
                                 gajim.contacts.remove_metacontact(account, jid)
+                        contact.groups = [_('Observers')]
 
                 # family is [{'account': acct, 'jid': jid, 'priority': prio}, ]
                 # 'priority' is optional
@@ -310 +310 @@
                                         continue
                                 _jid = data['jid']
 
-                                if self.get_contact_iter(_jid, _account):
+                                if self.get_contact_iter(_jid, _account, self.model):
                                         shown_family.append(data)
+
                                 if _jid == jid and _account == account:
                                         our_data = data
-                        shown_family.append(our_data)
                         big_brother_data = gajim.contacts.get_metacontacts_big_brother(
-                                shown_family)
+                                shown_family + [our_data])
                         big_brother_jid = big_brother_data['jid']
                         big_brother_account = big_brother_data['account']
                         if big_brother_jid != jid or big_brother_account != account:
                                 # We are adding a child contact
-                                if contact.show in ('offline', 'error') and \
-                                not showOffline and len(gajim.events.get_events(account, jid)) == 0:
+                                parent_iters = self.get_contact_iter(big_brother_jid,
+                                        big_brother_account, self.model)
+                                if parent_iters:
+                                        name = contact.get_shown_name()
+                                        added_iters = []
+                                        for child_i in parent_iters:
+                                                # we add some values here. see draw_contact for more
+                                                i_ = child_model.append(child_i, (None, name, 'contact', jid,
+                                                        account, None))
+                                                added_iters.append(i_)
+                                        self.draw_contact(jid, account)
+                                        self.draw_avatar(added_iters)
+                                        self.draw_account(account)
+                                        # Redraw parent to change icon
+                                        self.draw_contact(big_brother_jid, big_brother_account)
                                         return
-                                parent_iters = self.get_contact_iter(big_brother_jid,
-                                        big_brother_account)
-                                name = contact.get_shown_name()
-                                for i in parent_iters:
-                                        # we add some values here. see draw_contact for more
-                                        model.append(i, (None, name, 'contact', jid, account, None))
-                                self.draw_contact(jid, account)
-                                self.draw_avatar(jid, account)
-                                self.draw_account(account)
-                                # Redraw parent to change icon
-                                self.draw_contact(big_brother_jid, big_brother_account)
-                                return
 
-                if (contact.show in ('offline', 'error') or hide) and \
-                not showOffline and (not _('Transports') in contact.groups or \
-                gajim.connections[account].connected < 2) and \
-                len(gajim.contacts.get_contacts(account, jid)) == 1 and nb_events == 0 and\
-                not _('Not in Roster') in contact.groups:
-                        return
-
                 # Remove brother contacts that are already in roster to add them
                 # under this iter
                 for data in shown_family:
@@ -356 +350 @@
                         groups = [_('Observers')]
                 elif not groups:
                         groups = [_('General')]
+                added_iters = []
                 for group in groups:
                         self.draw_group(group, account)
-                        iterG = self.get_group_iter(group, account)
-                        if not iterG:
-                                IterAcct = self.get_account_iter(account)
-                                iterG = model.append(IterAcct, [
+                        child_iterG = self.get_group_iter(group, account, self.model)
+                        if not child_iterG:
+                                child_iterA = self.get_account_iter(account, self.model)
+                                child_iterG = self.model.append(child_iterA, [
                                         self.jabber_state_images['16']['closed'],
                                         gobject.markup_escape_text(group), 'group',
                                         group, account, None])
                                 self.draw_group(group, account)
-                                if model.iter_n_children(IterAcct) == 1: # We added the first one
-                                        self.draw_account(account)
-                        if group not in gajim.groups[account]: # It can probably never append
+                        try:
+                                iterG = model.convert_child_iter_to_iter(child_iterG)
+                        except RuntimeError:
+                                # group is not visible in filtered model
+                                iterG = None
+                        if group not in gajim.groups[account]:
                                 if account + group in self.collapsed_rows:
                                         ishidden = False
                                 else:
                                         ishidden = True
                                 gajim.groups[account][group] = {'expand': ishidden}
-                        if not account in self.collapsed_rows:
+                        if iterG and not account in self.collapsed_rows:
                                 self.tree.expand_row((model.get_path(iterG)[0]), False)
 
                         typestr = 'contact'
@@ -385 +383 @@
 
                         name = contact.get_shown_name()
                         # we add some values here. see draw_contact for more
-                        model.append(iterG, (None, name, typestr, contact.jid, account, None))
+                        i_ = self.model.append(child_iterG, (None, name, typestr, contact.jid,
+                                account, None))
+                        added_iters.append(i_)
 
                         if gajim.groups[account][group]['expand']:
-                                self.tree.expand_row(model.get_path(iterG), False)
-                self.draw_contact(jid, account)
-                self.draw_avatar(jid, account)
+                                #FIXME: why do we need to recall it? because we added a child?
+                                iterG = self.get_group_iter(group, account)
+                                if iterG:
+                                        self.tree.expand_row(model.get_path(iterG), False)
+                if not self.starting:
+                        self.draw_contact(jid, account)
+                        self.draw_avatar(added_iters)
                 self.draw_account(account)
                 # put the children under this iter
                 for data in shown_family:
@@ -399 +403 @@
                         self.add_contact_to_roster(data['jid'], data['account'])
 
         def draw_group(self, group, account):
-                iter = self.get_group_iter(group, account)
-                if not iter:
+                child_iter = self.get_group_iter(group, account, self.model)
+                if not child_iter:
                         return
                 if self.regroup:
                         accounts = []
@@ -413 +417 @@
                         nbr_on, nbr_total = gajim.contacts.get_nb_online_total_contacts(
                                 accounts = accounts, groups = [group])
                         text += ' (%s/%s)' % (repr(nbr_on), repr(nbr_total))
-                model = self.tree.get_model()
-                model.set_value(iter, 1 , text)
+                self.model.set_value(child_iter, 1 , gobject.markup_escape_text(text))
 
         def add_to_not_in_the_roster(self, account, jid, nick = '', resource = ''):
                 ''' add jid to group "not in the roster", he MUST not be in roster yet,
@@ -453 +456 @@
                 return contact
 
         def get_self_contact_iter(self, account):
-                model = self.tree.get_model()
                 iterAcct = self.get_account_iter(account)
-                iter = model.iter_children(iterAcct)
+                iter = self.modelfilter.iter_children(iterAcct)
                 if not iter:
                         return None
-                if model[iter][C_TYPE] == 'self_contact':
+                if self.modelfilter[iter][C_TYPE] == 'self_contact':
                         return iter
                 return None
 
         def add_self_contact(self, account):
+                return
                 jid = gajim.get_jid_from_account(account)
-                if self.get_self_contact_iter(account):
+                self_contact_iter = self.get_self_contact_iter(account)
+                if self_contact_iter:
                         self.draw_contact(jid, account)
-                        self.draw_avatar(jid, account)
+                        child_iter = self.modelfilter.convert_iter_to_child_iter(
+                                self_contact_iter)
+                        self.draw_avatar(child_iter)
                         return
 
                 contact = gajim.contacts.get_first_contact_from_jid(account, jid)
                 if not contact:
                         return
-                showOffline = gajim.config.get('showoffline')
-                if (contact.show in ('offline', 'error')) and not showOffline and \
-                        len(gajim.events.get_events(account, jid)) == 0:
-                        return
 
                 model = self.tree.get_model()
-                iterAcct = self.get_account_iter(account)
-                model.append(iterAcct, (None, gajim.nicks[account], 'self_contact', jid,
-                        account, None))
+                iterA = self.get_account_iter(account)
+                child_model = model.get_model()
+                child_iterA = model.convert_iter_to_child_iter(iterA)
+                i_ = child_model.append(child_iterA, (None, gajim.nicks[account],
+                        'self_contact', jid, account, None))
                 self.draw_contact(jid, account)
-                self.draw_avatar(jid, account)
+                self.draw_avatar([i_])
 
         def add_transport_to_roster(self, account, transport):
                 c = gajim.contacts.create_contact(jid = transport, name = transport,
@@ -497 +501 @@
                         return
                 if contact.jid in gajim.newly_added[account]:
                         return
-                if gajim.jid_is_transport(contact.jid) and gajim.account_is_connected(
-                account) and gajim.config.get('show_transports_group'):
-                        # It's an agent and we show them
-                        return
                 if contact.jid in gajim.to_be_removed[account]:
                         gajim.to_be_removed[account].remove(contact.jid)
+                        # FIXME: refilter only this contact
+#                       for iter in self.get_contact_iter(contact.jid, account, self.model):
+#                               path = self.model.get_path(iter)
+                                # doesn't work
+#                               self.model.row_has_child_toggled(path, iter)
+                        self.modelfilter.refilter()
 
+#               hide = contact.is_hidden_from_roster()
+#
+#               show_offline = gajim.config.get('showoffline')
+#               show_transports = gajim.config.get('show_transports_group')
+#
+#               nb_events = 0
+#               jid_list = [contact.jid]
+#               if contact.get_full_jid() != contact.jid:
+#                       jid_list.append(contact.get_full_jid())
+#               for jid in jid_list:
+#                       # dont't count printed_chat messages
+#                       nb_events += gajim.events.get_nb_roster_events(account, jid, ['chat'])
+#
+#               if (_('Transports') in contact.groups and not show_transports) or \
+#               ((contact.show in ('offline', 'error') or hide) and not show_offline and \
+#               (not _('Transports') in contact.groups or \
+#               gajim.account_is_disconnected(account))) and nb_events == 0:
+#               else:
+#                       self.draw_contact(contact.jid, account)
 
-                hide = contact.is_hidden_from_roster()
-
-                show_offline = gajim.config.get('showoffline')
-                show_transports = gajim.config.get('show_transports_group')
-
-                nb_events = 0
-                jid_list = [contact.jid]
-                if contact.get_full_jid() != contact.jid:
-                        jid_list.append(contact.get_full_jid())
-                for jid in jid_list:
-                        # dont't count printed_chat messages
-                        nb_events += gajim.events.get_nb_roster_events(account, jid, ['chat'])
-
-                if (_('Transports') in contact.groups and not show_transports) or \
-                ((contact.show in ('offline', 'error') or hide) and not show_offline and \
-                (not _('Transports') in contact.groups or \
-                gajim.account_is_disconnected(account))) and nb_events == 0:
-                        self.remove_contact(contact, account)
-                else:
-                        self.draw_contact(contact.jid, account)
-
         def remove_contact(self, contact, account):
                 '''Remove a contact from the roster'''
                 if contact.jid in gajim.to_be_removed[account]:
                         return
-                model = self.tree.get_model()
-                iters = self.get_contact_iter(contact.jid, account)
+                # look for iters in all (even not shown) iters
+                iters = self.get_contact_iter(contact.jid, account, self.model)
                 if not iters:
                         return
-                parent_iter = model.iter_parent(iters[0])
-                parent_type = model[parent_iter][C_TYPE]
+                parent_iter = self.model.iter_parent(iters[0])
+                parent_type = self.model[parent_iter][C_TYPE]
                 # remember children to re-add them
                 children = []
-                child_iter = model.iter_children(iters[0])
-                while child_iter:
-                        c_jid = model[child_iter][C_JID].decode('utf-8')
-                        c_account = model[child_iter][C_ACCOUNT].decode('utf-8')
+                iterC = self.model.iter_children(iters[0])
+                while iterC:
+                        c_jid = self.model[iterC][C_JID].decode('utf-8')
+                        c_account = self.model[iterC][C_ACCOUNT].decode('utf-8')
                         children.append((c_jid, c_account))
-                        child_iter = model.iter_next(child_iter)
+                        iterC = self.model.iter_next(iterC)
 
                 # Remove iters and group iter if they are empty
                 for i in iters:
-                        parent_i = model.iter_parent(i)
-                        model.remove(i)
+                        parent_i = self.model.iter_parent(i)
+                        self.model.remove(i)
                         if parent_type == 'group':
-                                group = model[parent_i][C_JID].decode('utf-8')
-                                if model.iter_n_children(parent_i) == 0:
-                                        model.remove(parent_i)
-                                        # We need to check all contacts, even offline contacts
-                                        for jid in gajim.contacts.get_jid_list(account):
-                                                if group in gajim.contacts.get_contact_with_highest_priority(
-                                                        account, jid).groups:
-                                                        break
-                                        else:
-                                                if gajim.groups[account].has_key(group):
-                                                        del gajim.groups[account][group]
+                                group = self.model[parent_i][C_JID].decode('utf-8')
+                                if self.model.iter_n_children(parent_i) == 0:
+                                        self.model.remove(parent_i)
+                                        if gajim.groups[account].has_key(group):
+                                                del gajim.groups[account][group]
                                 else:
                                         self.draw_group(group, account)
 
@@ -569 +567 @@
                         self.add_contact_to_roster(child[0], child[1])
                 # redraw parent
                 if parent_type == 'contact':
-                        parent_jid = model[parent_iter][C_JID].decode('utf-8')
-                        parent_account = model[parent_iter][C_ACCOUNT].decode('utf-8')
+                        parent_jid = self.model[parent_iter][C_JID].decode('utf-8')
+                        parent_account = self.model[parent_iter][C_ACCOUNT].decode('utf-8')
                         self.draw_contact(parent_jid, parent_account)
 
         def get_appropriate_state_images(self, jid, size = '16',
-                icon_name = 'online'):
+        icon_name = 'online'):
                 '''check jid and return the appropriate state images dict for
                 the demanded size. icon_name is taken into account when jid is from
                 transport: transport iconset doesn't contain all icons, so we fall back
@@ -589 +587 @@
         def draw_contact(self, jid, account, selected = False, focus = False):
                 '''draw the correct state image, name BUT not avatar'''
                 # focus is about if the roster window has toplevel-focus or not
-                model = self.tree.get_model()
-                iters = self.get_contact_iter(jid, account)
-                if len(iters) == 0:
+                child_iters = self.get_contact_iter(jid, account, self.model)
+                if len(child_iters) == 0:
                         return
                 contact_instances = gajim.contacts.get_contacts(account, jid)
                 contact = gajim.contacts.get_highest_prio_contact_from_contacts(
@@ -639 +636 @@
                 if self.regroup:
                         add_acct = False
                         # look through all contacts of all accounts
-                        for account_iter in gajim.connections:
-                                if account_iter == account: # useless to add accout name