Changeset 9598

Show
Ignore:
Timestamp:
05/08/08 23:53:26 (3 months ago)
Author:
steve-e
Message:

Do not redefine built-in 'iter'. Follow recommendation and use 'titer' instead.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/src/roster_window.py

    r9597 r9598  
    166166 
    167167                if jid == gajim.get_jid_from_account(account): 
    168                         iter = self._get_self_contact_iter(jid, account, model) 
    169                         if iter: 
    170                                 return [iter] 
     168                        contact_iter = self._get_self_contact_iter(jid, account, model) 
     169                        if contact_iter: 
     170                                return [contact_iter] 
    171171                        else: 
    172172                                return [] 
     
    215215         
    216216         
    217         def _iter_is_separator(self, model, iter): 
     217        def _iter_is_separator(self, model, titer): 
    218218                ''' Return True if the given iter is a separator. 
    219219                 
     
    222222                iter -- the gtk.TreeIter to test  
    223223                ''' 
    224                 if model[iter][0] == 'SEPARATOR': 
     224                if model[titer][0] == 'SEPARATOR': 
    225225                        return True 
    226226                return False 
     
    418418                        all_iters = iters[:] 
    419419                        group_iters = [self._get_group_iter(group, account) for group in groups] 
    420                         iters = [iter for iter in all_iters  
    421                                 if self.model.iter_parent(iter) in group_iters]  
     420                        iters = [titer for titer in all_iters  
     421                                if self.model.iter_parent(titer) in group_iters]  
    422422 
    423423                iter_children = self.model.iter_children(iters[0]) 
     
    10631063                if iters and self.modelfilter.iter_has_child(iters[0]): 
    10641064                        # We are big brother contact and visible in the roster 
    1065                         iter = iters[0] 
    1066                         path = self.modelfilter.get_path(iter) 
     1065                        titer = iters[0] 
     1066                        path = self.modelfilter.get_path(titer) 
    10671067 
    10681068                        if not self.tree.row_expanded(path) and \ 
    10691069                        icon_name not in ('event', 'muc_active', 'muc_inactive'): 
    10701070 
    1071                                 iterC = self.modelfilter.iter_children(iter) 
     1071                                iterC = self.modelfilter.iter_children(titer) 
    10721072                                if icon_name in ('error', 'offline'): 
    10731073                                        # get the icon from the first child as they are sorted by show 
     
    12301230##############################################################################                   
    12311231                 
    1232         def _search_roster_func(self, model, column, key, iter): 
    1233                 if model[iter][C_NAME].decode('utf-8').lower().startswith( 
     1232        def _search_roster_func(self, model, column, key, titer): 
     1233                if model[titer][C_NAME].decode('utf-8').lower().startswith( 
    12341234                gobject.markup_escape_text(key.lower())): 
    12351235                        return False 
     
    12621262                return True              
    12631263         
    1264         def _visible_func(self, model, iter): 
     1264        def _visible_func(self, model, titer): 
    12651265                '''Determine whether iter should be visible in the treeview'''  
    1266                 type_ = model[iter][C_TYPE] 
     1266                type_ = model[titer][C_TYPE] 
    12671267                if not type_: 
    12681268                        return False 
     
    12711271                        return True 
    12721272 
    1273                 account = model[iter][C_ACCOUNT] 
     1273                account = model[titer][C_ACCOUNT] 
    12741274                if not account: 
    12751275                        return False 
    12761276 
    12771277                account = account.decode('utf-8') 
    1278                 jid = model[iter][C_JID] 
     1278                jid = model[titer][C_JID] 
    12791279                if not jid: 
    12801280                        return False 
     
    22872287                if props: 
    22882288                        [row, col, x, y] = props 
    2289                         iter = None 
     2289                        titer = None 
    22902290                        try: 
    2291                                 iter = model.get_iter(row) 
     2291                                titer = model.get_iter(row) 
    22922292                        except: 
    22932293                                self.tooltip.hide_tooltip() 
    22942294                                return 
    2295                         if model[iter][C_TYPE] in ('contact', 'self_contact'): 
     2295                        if model[titer][C_TYPE] in ('contact', 'self_contact'): 
    22962296                                # we're on a contact entry in the roster 
    2297                                 account = model[iter][C_ACCOUNT].decode('utf-8') 
    2298                                 jid = model[iter][C_JID].decode('utf-8') 
     2297                                account = model[titer][C_ACCOUNT].decode('utf-8') 
     2298                                jid = model[titer][C_JID].decode('utf-8') 
    22992299                                if self.tooltip.timeout == 0 or self.tooltip.id != props[0]: 
    23002300                                        self.tooltip.id = row 
     
    23102310                                        self.tooltip.timeout = gobject.timeout_add(500, 
    23112311                                                self.show_tooltip, connected_contacts) 
    2312                         elif model[iter][C_TYPE] == 'groupchat': 
    2313                                 account = model[iter][C_ACCOUNT].decode('utf-8') 
    2314                                 jid = model[iter][C_JID].decode('utf-8') 
     2312                        elif model[titer][C_TYPE] == 'groupchat': 
     2313                                account = model[titer][C_ACCOUNT].decode('utf-8') 
     2314                                jid = model[titer][C_JID].decode('utf-8') 
    23152315                                if self.tooltip.timeout == 0 or self.tooltip.id != props[0]: 
    23162316                                        self.tooltip.id = row 
     
    23192319                                        self.tooltip.timeout = gobject.timeout_add(500, 
    23202320                                                self.show_tooltip, contact) 
    2321                         elif model[iter][C_TYPE] == 'account': 
     2321                        elif model[titer][C_TYPE] == 'account': 
    23222322                                # we're on an account entry in the roster 
    2323                                 account = model[iter][C_ACCOUNT].decode('utf-8') 
     2323                                account = model[titer][C_ACCOUNT].decode('utf-8') 
    23242324                                if account == 'all': 
    23252325                                        if self.tooltip.timeout == 0 or self.tooltip.id != props[0]: 
     
    24392439                        on_response_ok = (remove, list_)) 
    24402440 
    2441         def on_block(self, widget, iter, group_list): 
     2441        def on_block(self, widget, titer, group_list): 
    24422442                ''' When clicked on the 'block' button in context menu. ''' 
    24432443                model = self.modelfilter 
     
    24452445                msg = self.get_status_message('offline') 
    24462446                if group_list is None: 
    2447                         jid = model[iter][C_JID].decode('utf-8') 
    2448                         account = model[iter][C_ACCOUNT].decode('utf-8') 
     2447                        jid = model[titer][C_JID].decode('utf-8') 
     2448                        account = model[titer][C_ACCOUNT].decode('utf-8') 
    24492449                        accounts.append(account) 
    24502450                        self.send_status(account, 'offline', msg, to = jid) 
     
    24562456                        self.draw_contact(jid, account) 
    24572457                else: 
    2458                         if iter is None: 
     2458                        if titer is None: 
    24592459                                for (contact, account) in group_list: 
    24602460                                        if account not in accounts: 
     
    24712471                                        self.draw_contact(contact.jid, account) 
    24722472                        else: 
    2473                                 group = model[iter][C_JID].decode('utf-8') 
     2473                                group = model[titer][C_JID].decode('utf-8') 
    24742474                                for (contact, account) in group_list: 
    24752475                                        if account not in accounts: 
     
    24932493                gajim.connections[account].get_privacy_list('block') 
    24942494 
    2495         def on_unblock(self, widget, iter, group_list): 
     2495        def on_unblock(self, widget, titer, group_list): 
    24962496                ''' When clicked on the 'unblock' button in context menu. ''' 
    24972497                model = self.modelfilter 
    24982498                accounts = [] 
    24992499                if group_list is None: 
    2500                         jid = model[iter][C_JID].decode('utf-8') 
    2501                         jid_account = model[iter][C_ACCOUNT].decode('utf-8') 
     2500                        jid = model[titer][C_JID].decode('utf-8') 
     2501                        jid_account = model[titer][C_ACCOUNT].decode('utf-8') 
    25022502                        accounts.append(jid_account) 
    25032503                        gajim.connections[jid_account].new_blocked_list = [] 
     
    25112511                        self.draw_contact(jid, jid_account) 
    25122512                else: 
    2513                         if iter is None: 
     2513                        if titer is None: 
    25142514                                for (contact, account) in group_list: 
    25152515                                        if account not in accounts: 
     
    25322532                                                        gajim.connections[account].new_blocked_list.append(rule) 
    25332533                        else: 
    2534                                 group = model[iter][C_JID].decode('utf-8') 
     2534                                group = model[titer][C_JID].decode('utf-8') 
    25352535                                for (contact, account) in group_list: 
    25362536                                        if account not in accounts: 
     
    25852585                                                gajim.connections[account].status, to=contact.jid) 
    25862586 
    2587         def on_rename(self, widget, iter, path): 
     2587        def on_rename(self, widget, titer, path): 
    25882588                # this function is called either by F2 or by Rename menuitem 
    25892589                if gajim.interface.instances.has_key('rename'): 
     
    25922592                model = self.modelfilter 
    25932593 
    2594                 row_type = model[iter][C_TYPE] 
    2595                 jid = model[iter][C_JID].decode('utf-8') 
    2596                 account = model[iter][C_ACCOUNT].decode('utf-8') 
     2594                row_type = model[titer][C_TYPE] 
     2595                jid = model[titer][C_JID].decode('utf-8') 
     2596                account = model[titer][C_ACCOUNT].decode('utf-8') 
    25972597                # account is offline, don't allow to rename 
    25982598                if gajim.connections[account].connected < 2: 
     
    26072607                        if jid in helpers.special_groups + (_('General'),): 
    26082608                                return 
    2609                         old_text = model[iter][C_JID].decode('utf-8') 
     2609                        old_text = model[titer][C_JID].decode('utf-8') 
    26102610                        title = _('Rename Group') 
    26112611                        message = _('Enter a new name for group %s') % old_text 
     
    29152915                        type_ = model[path][C_TYPE] 
    29162916                        if type_ in ('contact', 'group', 'agent'): 
    2917                                 iter = model.get_iter(path) 
    2918                                 self.on_rename(widget, iter, path) 
     2917                                titer = model.get_iter(path) 
     2918                                self.on_rename(widget, titer, path) 
    29192919 
    29202920                elif event.keyval == gtk.keysyms.Delete: 
     
    30213021                        not event.state & gtk.gdk.CONTROL_MASK: 
    30223022                                # Don't handle dubble click if we press icon of a metacontact 
    3023                                 iter = model.get_iter(path) 
     3023                                titer = model.get_iter(path) 
    30243024                                if x > x_min and x < x_min + 27 and type_ == 'contact' and \ 
    3025                                 model.iter_has_child(iter): 
     3025                                model.iter_has_child(titer): 
    30263026                                        # FIXME: Expand all meta contacts or only the current one? 
    30273027                                        #account = model[path][C_ACCOUNT].decode('utf-8') 
     
    30293029                                        # first cell in 1st column (the arrow SINGLE clicked) 
    30303030                                        #iters = self._get_contact_iter(jid, account) 
    3031                                         #for iter in iters: 
    3032                                         #       path = model.get_path(iter) 
     3031                                        #for titer in iters: 
     3032                                        #       path = model.get_path(titer) 
    30333033                                        if (self.tree.row_expanded(path)): 
    30343034                                                self.tree.collapse_row(path) 
     
    30543054                                        # first cell in 1st column (the arrow SINGLE clicked) 
    30553055                                        #iters = self._get_contact_iter(jid, account) 
    3056                                         #for iter in iters: 
    3057                                         #       path = model.get_path(iter) 
     3056                                        #for titer in iters: 
     3057                                        #       path = model.get_path(titer) 
    30583058                                        if (self.tree.row_expanded(path)): 
    30593059                                                self.tree.collapse_row(path) 
     
    33603360                resource = None 
    33613361                contact = None 
    3362                 iter = model.get_iter(path) 
     3362                titer = model.get_iter(path) 
    33633363                if type_ in ('group', 'account'): 
    33643364                        if self.tree.row_expanded(path): 
     
    33783378                                                resource = c.resource 
    33793379                                                break 
    3380                         if not first_ev and model.iter_has_child(iter): 
    3381                                 child_iter = model.iter_children(iter) 
     3380                        if not first_ev and model.iter_has_child(titer): 
     3381                                child_iter = model.iter_children(titer) 
    33823382                                while not first_ev and child_iter: 
    33833383                                        child_jid = model[child_iter][C_JID].decode('utf-8') 
     
    34113411                        self.on_row_activated(widget, path) 
    34123412 
    3413         def on_roster_treeview_row_expanded(self, widget, iter, path): 
     3413        def on_roster_treeview_row_expanded(self, widget, titer, path): 
    34143414                '''When a row is expanded change the icon of the arrow''' 
    34153415                self._toggeling_row = True 
    34163416                model = widget.get_model() 
    34173417                child_model = model.get_model() 
    3418                 child_iter =  model.convert_iter_to_child_iter(iter) 
     3418                child_iter =  model.convert_iter_to_child_iter(titer) 
    34193419 
    34203420                if self.regroup: # merged accounts 
    34213421                        accounts = gajim.connections.keys() 
    34223422                else: 
    3423                         accounts = [model[iter][C_ACCOUNT].decode('utf-8')] 
     3423                        accounts = [model[titer][C_ACCOUNT].decode('utf-8')] 
    34243424                         
    3425                 type_ = model[iter][C_TYPE] 
     3425                type_ = model[titer][C_TYPE] 
    34263426                if type_ == 'group': 
    34273427                        child_model[child_iter][C_IMG] = gajim.interface.jabber_state_images[ 
    34283428                                '16']['opened'] 
    3429                         group = model[iter][C_JID].decode('utf-8') 
     3429                        group = model[titer][C_JID].decode('utf-8') 
    34303430                        for account in accounts: 
    34313431                                if group in gajim.groups[account]: # This account has this group 
     
    34413441                        for group in gajim.groups[account]: 
    34423442                                if gajim.groups[account][group]['expand']: 
    3443                                         iter = self._get_group_iter(group, account) 
    3444                                         if iter:       
    3445                                                 path = model.get_path(iter) 
     3443                                        titer = self._get_group_iter(group, account) 
     3444                                        if titer:      
     3445                                                path = model.get_path(titer) 
    34463446                                                self.tree.expand_row(path, False) 
    34473447                elif type_ == 'contact': 
    34483448                        # Metacontact got toggled, update icon 
    3449                         jid = model[iter][C_JID].decode('utf-8') 
    3450                         account = model[iter][C_ACCOUNT].decode('utf-8') 
     3449                        jid = model[titer][C_JID].decode('utf-8') 
     3450                        account = model[titer][C_ACCOUNT].decode('utf-8') 
    34513451                        self.draw_contact(jid, account) 
    34523452 
    34533453                self._toggeling_row = False 
    34543454                 
    3455         def on_roster_treeview_row_collapsed(self, widget, iter, path): 
     3455        def on_roster_treeview_row_collapsed(self, widget, titer, path): 
    34563456                '''When a row is collapsed change the icon of the arrow''' 
    34573457                self._toggeling_row = True 
    34583458                model = widget.get_model() 
    34593459                child_model = model.get_model() 
    3460                 child_iter =  model.convert_iter_to_child_iter(iter) 
     3460                child_iter =  model.convert_iter_to_child_iter(titer) 
    34613461 
    34623462                if self.regroup: # merged accounts 
    34633463                        accounts = gajim.connections.keys() 
    34643464                else: 
    3465                         accounts = [model[iter][C_ACCOUNT].decode('utf-8')] 
     3465                        accounts = [model[titer][C_ACCOUNT].decode('utf-8')] 
    34663466                         
    3467                 type_ = model[iter][C_TYPE] 
     3467                type_ = model[titer][C_TYPE] 
    34683468                if type_ == 'group': 
    34693469                        child_model[child_iter][C_IMG] = gajim.interface.jabber_state_images[ 
    34703470                                '16']['closed'] 
    3471                         group = model[iter][C_JID].decode('utf-8') 
     3471                        group = model[titer][C_JID].decode('utf-8') 
    34723472                        for account in accounts: 
    34733473                                if group in gajim.groups[account]: # This account has this group 
     
    34823482                elif type_ == 'contact': 
    34833483                        # Metacontact got toggled, update icon 
    3484                         jid = model[iter][C_JID].decode('utf-8') 
    3485                         account = model[iter][C_ACCOUNT].decode('utf-8') 
     3484                        jid = model[titer][C_JID].decode('utf-8') 
     3485                        account = model[titer][C_ACCOUNT].decode('utf-8') 
    34863486                        self.draw_contact(jid, account) 
    34873487                         
    34883488                self._toggeling_row = False 
    34893489 
    3490         def on_model_row_has_child_toggled(self, model, path, iter): 
     3490        def on_model_row_has_child_toggled(self, model, path, titer): 
    34913491                '''Called when a row has gotten the first or lost its last child row. 
    34923492 
     
    34973497                        return 
    34983498                         
    3499                 type_ = model[iter][C_TYPE] 
    3500                 account = model[iter][C_ACCOUNT] 
     3499                type_ = model[titer][C_TYPE] 
     3500                account = model[titer][C_ACCOUNT] 
    35013501                if not account: 
    35023502                        return 
     
    35053505                 
    35063506                if type_ == 'contact': 
    3507                         child_iter = model.convert_iter_to_child_iter(iter) 
     3507                        child_iter = model.convert_iter_to_child_iter(titer) 
    35083508                        if self.model.iter_has_child(child_iter): 
    35093509                                # we are a bigbrother metacontact 
     
    35113511                                if self.filtering: 
    35123512                                        # Prevent endless loops 
    3513                                         jid = model[iter][C_JID].decode('utf-8') 
     3513                                        jid = model[titer][C_JID].decode('utf-8') 
    35143514                                        gobject.idle_add(self.draw_contact, jid, account) 
    35153515                elif type_ == 'group': 
    3516                         group = model[iter][C_JID].decode('utf-8') 
     3516                        group = model[titer][C_JID].decode('utf-8') 
    35173517                        self._adjust_group_expand_collapse_state(group, account) 
    35183518                elif type_ == 'account': 
     
    39553955                # Update the status combobox 
    39563956                model = self.status_combobox.get_model() 
    3957                 iter = model.get_iter_root() 
    3958                 while iter: 
    3959                         if model[iter][2] != '': 
     3957                titer = model.get_iter_root() 
     3958                while titer: 
     3959                        if model[titer][2] != '': 
    39603960                                # If it's not change status message iter 
    39613961                                # eg. if it has show parameter not '' 
    3962                                 model[iter][1] = gajim.interface.jabber_state_images['16'][model[iter][2]] 
    3963                         iter = model.iter_next(iter) 
     3962                                model[titer][1] = gajim.interface.jabber_state_images['16'][model[titer][2]] 
     3963                        titer = model.iter_next(titer) 
    39643964                # Update the systray 
    39653965                if gajim.interface.systray_enabled: 
     
    40204020                gtkgui_helpers.set_unset_urgency_hint(self.window, nb_unread) 
    40214021         
    4022         def _change_style(self, model, path, iter, option): 
    4023                 if option is None or model[iter][C_TYPE] == option: 
     4022        def _change_style(self, model, path, titer, option): 
     4023                if option is None or model[titer][C_TYPE] == option: 
    40244024                        # We changed style for this type of row 
    4025                         model[iter][C_NAME] = model[iter][C_NAME] 
     4025                        model[titer][C_NAME] = model[titer][C_NAME] 
    40264026 
    40274027        def change_roster_style(self, option): 
     
    40674067                        renderer.set_property('foreground-gdk', fgcolor) 
    40684068         
    4069         def _iconCellDataFunc(self, column, renderer, model, iter, data = None): 
     4069        def _iconCellDataFunc(self, column, renderer, model, titer, data = None): 
    40704070                '''When a row is added, set properties for icon renderer''' 
    40714071                theme = gajim.config.get('roster_theme') 
    4072                 type_ = model[iter][C_TYPE] 
     4072                type_ = model[titer][C_TYPE] 
    40734073                if type_ == 'account': 
    40744074                        color = gajim.config.get_per('themes', theme, 'accountbgcolor') 
     
    40864086                        renderer.set_property('xalign', 0.2) 
    40874087                elif type_: # prevent type_ = None, see http://trac.gajim.org/ticket/2534 
    4088                         if not model[iter][C_JID] or not model[iter][C_ACCOUNT]: 
     4088                        if not model[titer][C_JID] or not model[titer][C_ACCOUNT]: 
    40894089                                # This can append when at the moment we add the row 
    40904090                                return 
    4091                         jid = model[iter][C_JID].decode('utf-8') 
    4092                         account = model[iter][C_ACCOUNT].decode('utf-8') 
     4091                        jid = model[titer][C_JID].decode('utf-8') 
     4092                        account = model[titer][C_ACCOUNT].decode('utf-8') 
    40934093                        if jid in gajim.newly_added[account]: 
    40944094                                renderer.set_property('cell-background', gajim.config.get( 
     
    41034103                                else: 
    41044104                                        renderer.set_property('cell-background', None) 
    4105                         parent_iter = model.iter_parent(iter) 
     4105                        parent_iter = model.iter_parent(titer) 
    41064106                        if model[parent_iter][C_TYPE] == 'contact': 
    41074107                                renderer.set_property('xalign', 1) 
     
    41104110                renderer.set_property('width', 26) 
    41114111         
    4112         def _nameCellDataFunc(self, column, renderer, model, iter, data = None): 
     4112        def _nameCellDataFunc(self, column, renderer, model, titer, data = None): 
    41134113                '''When a row is added, set properties for name renderer''' 
    41144114                theme = gajim.config.get('roster_theme') 
    4115                 type_ = model[iter][C_TYPE] 
     4115                type_ = model[titer][C_TYPE] 
    41164116                if type_ == 'account': 
    41174117                        color = gajim.config.get_per('themes', theme, 'accounttextcolor') 
     
    41444144                        renderer.set_property('xpad', 4) 
    41454145                elif type_: # prevent type_ = None, see http://trac.gajim.org/ticket/2534 
    4146                         if not model[iter][C_JID] or not model[iter][C_ACCOUNT]: 
     4146                        if not model[titer][C_JID] or not model[titer][C_ACCOUNT]: 
    41474147                                # This can append when at the moment we add the row 
    41484148                                return 
    4149                         jid = model[iter][C_JID].decode('utf-8') 
    4150                         account = model[iter][C_ACCOUNT].decode('utf-8') 
     4149                        jid = model[titer][C_JID].decode('utf-8') 
     4150                        account = model[titer][C_ACCOUNT].decode('utf-8') 
    41514151                        color = gajim.config.get_per('themes', theme, 'contacttextcolor') 
    41524152                        if color: 
     
    41684168                        renderer.set_property('font', 
    41694169                                gtkgui_helpers.get_theme_font_for_option(theme, 'contactfont')) 
    4170                         parent_iter = model.iter_parent(iter) 
     4170                        parent_iter = model.iter_parent(titer) 
    41714171                        if model[parent_iter][C_TYPE] == 'contact': 
    41724172                                renderer.set_property('xpad', 16) 
     
    41744174                                renderer.set_property('xpad', 8) 
    41754175 
    4176         def _fill_avatar_pixbuf_rederer(self, column, renderer, model, iter, 
     4176        def _fill_avatar_pixbuf_rederer(self, column, renderer, model, titer, 
    41774177        data = None): 
    41784178                '''When a row is added, set properties for avatar renderer''' 
    41794179                theme = gajim.config.get('roster_theme') 
    4180                 type_ = model[iter][C_TYPE] 
     4180                type_ = model[titer][C_TYPE] 
    41814181                if type_ in ('group', 'account'): 
    41824182                        renderer.set_property('visible', False) 
     
    41844184 
    41854185                # allocate space for the icon only if needed 
    4186                 if model[iter][C_AVATAR_PIXBUF] or \ 
     4186                if model[titer][C_AVATAR_PIXBUF] or \ 
    41874187                gajim.config.get('avatar_position_in_roster') == 'left': 
    41884188                        renderer.set_property('visible', True) 
     
    41904190                        renderer.set_property('visible', False) 
    41914191                if type_: # prevent type_ = None, see http://trac.gajim.org/ticket/2534 
    4192                         if not model[iter][C_JID] or not model[iter][C_ACCOUNT]: 
     4192                        if not model[titer][C_JID] or not model[titer][C_ACCOUNT]: 
    41934193                                # This can append at the moment we add the row 
    41944194                                return 
    4195                         jid = model[iter][C_JID].decode('utf-8') 
    4196                         account = model[iter][C_ACCOUNT].decode('utf-8') 
     4195                        jid = model[titer][C_JID].decode('utf-8') 
     4196                        account = model[titer][C_ACCOUNT].decode('utf-8') 
    41974197                        if jid in gajim.newly_added[account]: 
    41984198                                renderer.set_property('cell-background', gajim.config.get( 
     
    42134213                        renderer.set_property('xalign', 1) # align pixbuf to the right 
    42144214 
    4215         def _fill_padlock_pixbuf_rederer(self, column, renderer, model, iter, 
     4215        def _fill_padlock_pixbuf_rederer(self, column, renderer, model, titer, 
    42164216        data = None): 
    42174217                '''When a row is added, set properties for padlock renderer''' 
    42184218                theme = gajim.config.get('roster_theme') 
    4219                 type_ = model[iter][C_TYPE] 
     4219                type_ = model[titer][C_TYPE] 
    42204220                # allocate space for the icon only if needed 
    4221                 if type_ == 'account' and model[iter][C_PADLOCK_PIXBUF]: 
     4221                if type_ == 'account' and model[titer][C_PADLOCK_PIXBUF]: 
    42224222                        renderer.set_property('visible', True) 
    42234223                        color = gajim.config.get_per('themes', theme, 'accountbgcolor') 
     
    46854685                return account_context_menu 
    46864686 
    4687         def make_account_menu(self, event, iter): 
     4687        def make_account_menu(self, event, titer): 
    46884688                '''Make account's popup menu''' 
    46894689                model = self.modelfilter 
    4690                 account = model[iter][C_ACCOUNT].decode('utf-8') 
     4690                account = model[titer][C_ACCOUNT].decode('utf-8') 
    46914691 
    46924692                if account != 'all': # not in merged mode 
     
    47174717                menu.popup(None, None, None, event_button, event.time) 
    47184718         
    4719         def make_group_menu(self, event, iter): 
     4719        def make_group_menu(self, event, titer): 
    47204720                '''Make group's popup menu''' 
    47214721                model = self.modelfilter 
    4722                 path = model.get_path(iter) 
    4723                 group = model[iter][C_JID].decode('utf-8') 
    4724                 account = model[iter][C_ACCOUNT].decode('utf-8') 
     4722                path = model.get_path(titer) 
     4723                group = model[titer][C_JID].decode('utf-8') 
     4724                account = model[titer][C_ACCOUNT].decode('utf-8') 
    47254725 
    47264726                list_ = [] # list of (jid, account) tuples 
    47274727                list_online = [] # list of (jid, account) tuples 
    47284728 
    4729                 group = model[iter][C_JID] 
     4729                group = model[titer][C_JID] 
    47304730                for jid in gajim.contacts.get_jid_list(account): 
    47314731                        contact = gajim.contacts.get_contact_with_highest_priority(account, 
     
    48194819                        rename_item.set_image(img) 
    48204820                        menu.append(rename_item) 
    4821                         rename_item.connect('activate', self.on_rename, iter, path) 
     4821                        rename_item.connect('activate', self.on_rename, titer, path) 
    48224822 
    48234823                        # Block group 
     
    48354835                                icon = gtk.image_new_from_stock(gtk.STOCK_STOP, gtk.ICON_SIZE_MENU) 
    48364836                                unblock_menuitem.set_image(icon) 
    4837                                 unblock_menuitem.connect('activate', self.on_unblock, iter, list_) 
     4837                                unblock_menuitem.connect('activate', self.on_unblock, titer, list_) 
    48384838                                menu.append(unblock_menuitem) 
    48394839                        else: 
     
    48414841                                icon = gtk.image_new_from_stock(gtk.STOCK_STOP, gtk.ICON_SIZE_MENU) 
    48424842                                block_menuitem.set_image(icon) 
    4843                                 block_menuitem.connect('activate', self.on_block, iter, list_) 
     4843                                block_menuitem.connect('activate', self.on_block, titer, list_) 
    48444844                                menu.append(block_menuitem) 
    48454845                                if not gajim.connections[account].privacy_rules_supported: 
     
    48714871                menu.popup(None, None, None, event_button, event.time)   
    48724872                 
    4873         def make_contact_menu(self, event, iter): 
     4873        def make_contact_menu(self, event, titer): 
    48744874                '''Make contact\'s popup menu''' 
    48754875                model = self.modelfilter 
    4876                 jid = model[iter][C_JID].decode('utf-8') 
    4877                 tree_path = model.get_path(iter) 
    4878                 account = model[iter][C_ACCOUNT].decode('utf-8') 
     4876                jid = model[titer][C_JID].decode('utf-8') 
     4877                tree_path = model.get_path(titer) 
     4878                account = model[titer][C_ACCOUNT].decode('utf-8') 
    48794879                our_jid = jid == gajim.get_jid_from_account(account) 
    48804880                contact = gajim.contacts.get_contact_with_highest_priority(account, jid) 
     
    49404940                                send_file_menuitem.set_sensitive(False) 
    49414941 
    4942                         rename_menuitem.connect('activate', self.on_rename, iter, tree_path) 
     4942                        rename_menuitem.connect('activate', self.on_rename, titer, tree_path) 
    49434943                        if contact.show in ('offline', 'error'): 
    49444944                                information_menuitem.set_sensitive(False) 
     
    51125112                        self.on_send_single_message_menuitem_activate, account, contact) 
    51135113 
    5114                 rename_menuitem.connect('activate', self.on_rename, iter, tree_path) 
     5114                rename_menuitem.connect('activate', self.on_rename, titer, tree_path) 
    51155115                remove_from_roster_menuitem.connect('activate', self.on_req_usub, 
    51165116                        [(contact, account)]) 
     
    51805180                        if jid in gajim.connections[account].blocked_contacts: 
    51815181                                block_menuitem.set_no_show_all(True) 
    5182                                 unblock_menuitem.connect('activate', self.on_unblock, iter, None) 
     5182                                unblock_menuitem.connect('activate', self.on_unblock, titer, None) 
    51835183                                block_menuitem.hide() 
    51845184                        else: 
    51855185                                unblock_menuitem.set_no_show_all(True) 
    5186                                 block_menuitem.connect('activate', self.on_block, iter, None) 
     5186                                block_menuitem.connect('activate', self.on_block, titer, None) 
    51875187                                unblock_menuitem.hide() 
    51885188                else: 
     
    52065206                one_account_offline = False 
    52075207                is_blocked = True 
    5208                 for iter in iters: 
    5209                         jid = model[iter][C_JID].decode('utf-8') 
    5210                         account = model[iter][C_ACCOUNT].decode('utf-8') 
     5208                for titer in iters: 
     5209                        jid = model[titer][C_JID].decode('utf-8') 
     5210                        account = model[titer][C_ACCOUNT].decode('utf-8') 
    52115211                        if gajim.connections[account].connected < 2: 
    52125212                                one_account_offline = True 
     
    52975297                menu.popup(None, None, None, event_button, event.time) 
    52985298                 
    5299         def make_transport_menu(self, event, iter): 
     5299        def make_transport_menu(self, event, titer): 
    53005300                '''Make transport\'s popup menu''' 
    53015301                model = self.modelfilter 
    5302                 jid = model[iter][C_JID].decode('utf-8') 
    5303                 path = model.get_path(iter) 
    5304                 account = model[iter][C_ACCOUNT].decode('utf-8') 
     5302                jid = model[titer][C_JID].decode('utf-8') 
     5303                path = model.get_path(titer) 
     5304                account = model[titer][C_ACCOUNT].decode('utf-8') 
    53055305                contact = gajim.contacts.get_contact_with_highest_priority(account, jid) 
    53065306                menu = gtk.Menu() 
     
    53875387                item.set_image(img) 
    53885388                manage_transport_submenu.append(item) 
    5389                 item.connect('activate', self.on_rename, iter, path) 
     5389                item.connect('activate', self.on_rename, titer, path) 
    53905390                if gajim.account_is_disconnected(account): 
    53915391                        item.set_sensitive(False) 
     
    53975397                if blocked: 
    53985398                        item = gtk.ImageMenuItem(_('_Unblock')) 
    5399                         item.connect('activate', self.on_unblock, iter, None) 
     5399                        item.connect('activate', self.on_unblock, titer, None) 
    54005400                else: 
    54015401                        item = gtk.ImageMenuItem(_('_Block')) 
    5402                         item.connect('activate', self.on_block, iter, None) 
     5402                        item.connect('activate', self.on_block, titer, None) 
    54035403 
    54045404                icon = gtk.image_new_from_stock(gtk.STOCK_STOP, gtk.ICON_SIZE_MENU) 
     
    54355435                menu.popup(None, None, None, event_button, event.time) 
    54365436 
    5437         def make_groupchat_menu(self, event, iter): 
     5437        def make_groupchat_menu(self, event, titer): 
    54385438                model = self.modelfilter 
    54395439 
    5440                 path = model.get_path(iter) 
    5441                 jid = model[iter][C_JID].decode('utf-8') 
    5442                 account = model[iter][C_ACCOUNT].decode('utf-8') 
     5440                path = model.get_path(titer) 
     5441                jid = model[titer][C_JID].decode('utf-8') 
     5442                account = model[titer][C_ACCOUNT].decode