Merge lp:~garyvdm/qbzr/newwtlist into lp:~qbzr-dev/qbzr/trunk

[Gary van der Merwe]

[Gary van der Merwe (garyvdm)]

This replaces wtlist with treewidget in qcommit, qadd, and qrevert.

To do this I have added a mode to the treewidget called changes_mode. This only show changes, and not the whole tree. Like the old wtlist, changes from subdirs are shown in the root, e.g.

In normal mode, you would see:
Dir1
  File1 Modified

but in changes_mode, you will see:
Dir1/File1 Modified

Unless a parent directory is shown, which may happen if you have a unversioned, added, or renamed directory.

e.g. in changes_mode, you will get:

dir1 => dir2 Renamed
  File3 Modified

dir4 Added
  file5 Added

Drive by improvement: qcommit now adjusts the auto complete word list if you change which files are selected in the file list.

[Gary van der Merwe (garyvdm)]

Some screen shots:

http://garyvdm.googlepages.com/qcommit_new_widget.png
http://garyvdm.googlepages.com/qadd_new_widget.png

[Gary van der Merwe (garyvdm)]

I just realised that this does not honer the selected list passed from the command line. I need to fix that.

[lp:~garyvdm/qbzr/newwtlist]

814. By Gary van der Merwe on 2009-07-12

qcommit: Use SubProcessDialog, rather than SubProcessWindow.

815. By Gary van der Merwe on 2009-07-13

Set the width of the external diff menu button.

[Gary van der Merwe (garyvdm)]

The above mentioned problem has now been fixed.

[lp:~garyvdm/qbzr/newwtlist]

816. By Gary van der Merwe on 2009-07-14

Merge Javier's qsend dialog.

817. By Gary van der Merwe on 2009-07-15

qbrowse: Don't check for is_ignored on the tree root.

818. By Gary van der Merwe on 2009-07-15

qcommit: Show spelling suggestions in the message box context menu.

819. By Gary van der Merwe on 2009-07-15

Ext diff - Don't pass old revspec if none was provided for working trees.

820. By Gary van der Merwe on 2009-07-16

Change qcommit, qadd, and qrevert to use new TreeWidget. Remove lib/wtlist.py.

Unmerged revisions

=== modified file 'lib/add.py'
--- lib/add.py	2009-06-11 21:21:01 +0000
+++ lib/add.py	2009-07-10 19:43:43 +0000
@@ -23,11 +23,16 @@
 
 from bzrlib.plugins.qbzr.lib.i18n import gettext
 from bzrlib.plugins.qbzr.lib.subprocess import SubProcessDialog
-from bzrlib.plugins.qbzr.lib.wtlist import (
-    ChangeDesc,
-    WorkingTreeFileList,
-    closure_in_selected_list,
-    )
+from bzrlib.plugins.qbzr.lib.treewidget import (
+    TreeWidget,
+    SelectAllCheckBox,
+    )
+from bzrlib.plugins.qbzr.lib.util import (
+    ThrobberWidget,
+    runs_in_loading_queue,
+    )
+from bzrlib.plugins.qbzr.lib.uifactory import ui_current_widget
+from bzrlib.plugins.qbzr.lib.trace import reports_exception
 
 
 class AddWindow(SubProcessDialog):
@@ -46,22 +51,36 @@
                                   hide_progress=True,
                                   )
     
+        self.throbber = ThrobberWidget(self)
+
         # Display the list of unversioned files
         groupbox = QtGui.QGroupBox(gettext("Unversioned Files"), self)
         vbox = QtGui.QVBoxLayout(groupbox)
 
-        self.filelist = WorkingTreeFileList(groupbox, self.tree)
+        self.filelist = TreeWidget(groupbox)
+        self.filelist.throbber = self.throbber
+        self.filelist.tree_model.is_item_in_select_all = lambda item: (
+            item.change is not None and
+            item.change.is_ignored() is None and
+            not item.change.is_versioned())
+        
+        def filter_context_menu():
+            self.filelist.action_open_file.setEnabled(True)
+            self.filelist.action_open_file.setVisible(True)
+            self.filelist.action_show_file.setVisible(False)
+            self.filelist.action_show_annotate.setVisible(False)
+            self.filelist.action_show_log.setVisible(False)
+            self.filelist.action_show_diff.setVisible(False)
+            self.filelist.action_add.setVisible(False)
+            self.filelist.action_revert.setVisible(False)
+        self.filelist.filter_context_menu = filter_context_menu
+        
         vbox.addWidget(self.filelist)
-        self.filelist.sortItems(0, QtCore.Qt.AscendingOrder)
-        self.filelist.setup_actions()
         
-        selectall_checkbox = QtGui.QCheckBox(
-            gettext(self.filelist.SELECTALL_MESSAGE),
-            groupbox)
+        selectall_checkbox = SelectAllCheckBox(self.filelist, groupbox)
         vbox.addWidget(selectall_checkbox)
         selectall_checkbox.setCheckState(QtCore.Qt.Checked)
         selectall_checkbox.setEnabled(True)
-        self.filelist.set_selectall_checkbox(selectall_checkbox)
 
         self.show_ignored_checkbox = QtGui.QCheckBox(
             gettext("Show ignored files"),
@@ -69,12 +88,6 @@
         vbox.addWidget(self.show_ignored_checkbox)
         self.connect(self.show_ignored_checkbox, QtCore.SIGNAL("toggled(bool)"), self.show_ignored)
         
-        self.tree.lock_read()
-        try:
-            self.filelist.fill(self.iter_changes_and_state())
-        finally:
-            self.tree.unlock()
-
         # groupbox gets disabled as we are executing.
         QtCore.QObject.connect(self,
                                QtCore.SIGNAL("subprocessStarted(bool)"),
@@ -88,44 +101,40 @@
         self.restoreSplitterSizes([150, 150])
 
         layout = QtGui.QVBoxLayout(self)
+        layout.addWidget(self.throbber)
         layout.addWidget(self.splitter)
         layout.addWidget(self.buttonbox)
-
-    def iter_changes_and_state(self):
-        """An iterator for the WorkingTreeFileList widget"""
-
-        in_selected_list = closure_in_selected_list(self.initial_selected_list)
-
-        show_ignored = self.show_ignored_checkbox.isChecked()
-
-        for desc in self.tree.iter_changes(self.tree.basis_tree(),
-                                           want_unversioned=True):
-
-            desc = ChangeDesc(desc)
-            if desc.is_versioned():
-                continue
-
-            pit = desc.path()
-            visible = show_ignored or not self.tree.is_ignored(pit)
-            check_state = visible and in_selected_list(pit)
-            yield desc, visible, check_state
+        self.throbber.show()
+
+
+    def show(self):
+        SubProcessDialog.show(self)
+        QtCore.QTimer.singleShot(1, self.initial_load)
+
+    @runs_in_loading_queue
+    @ui_current_widget
+    @reports_exception()
+    def initial_load(self):
+        self.filelist.tree_model.checkable = True
+        fmodel = self.filelist.tree_filter_model
+        fmodel.setFilter(fmodel.CHANGED, False)
+        self.filelist.set_tree(self.tree, changes_mode = True)
+        self.throbber.hide()
 
     def start(self):
         """Add the files."""
         files = []
-        for desc in self.filelist.iter_checked():
-            files.append(desc.path())
+        for item_data in self.filelist.tree_model.iter_checked():
+            files.append(item_data.change.path())
         
-        self.process_widget.start(self.tree.basedir, "add", *files)
+        self.process_widget.start(self.tree.basedir, "add", "--no-recurse",
+                                  *files)
 
     def show_ignored(self, state):
         """Show/hide ignored files."""
-        state = not state
-        for (tree_item, change_desc) in self.filelist.iter_treeitem_and_desc(True):
-            path = change_desc.path()
-            if self.tree.is_ignored(path):
-                self.filelist.set_item_hidden(tree_item, state)
-        self.filelist.update_selectall_state(None, None)
+        fmodel = self.filelist.tree_filter_model
+        fmodel.setFilter(fmodel.IGNORED, state)
+        #self.filelist.update_selectall_state(None, None)
 
     def saveSize(self):
         SubProcessDialog.saveSize(self)

=== modified file 'lib/commit.py'
--- lib/commit.py	2009-06-12 03:25:55 +0000
+++ lib/commit.py	2009-07-12 14:01:37 +0000
@@ -36,15 +36,18 @@
     get_global_config,
     url_for_display,
     ThrobberWidget,
-    )
-from bzrlib.plugins.qbzr.lib.wtlist import (
-    ChangeDesc,
-    WorkingTreeFileList,
-    closure_in_selected_list,
-    )
+    runs_in_loading_queue,
+    )
+from bzrlib.plugins.qbzr.lib.treewidget import TreeWidget
+
 from bzrlib.plugins.qbzr.lib.logwidget import LogList
 from bzrlib.plugins.qbzr.lib.trace import *
 from bzrlib.plugins.qbzr.lib.uifactory import ui_current_widget
+from bzrlib.plugins.qbzr.lib.treewidget import (
+    TreeWidget,
+    SelectAllCheckBox,
+    )
+from bzrlib.plugins.qbzr.lib.trace import reports_exception
 
 
 MAX_AUTOCOMPLETE_FILES = 20
@@ -143,55 +146,6 @@
     RevisionIdRole = QtCore.Qt.UserRole + 1
     ParentIdRole = QtCore.Qt.UserRole + 2
 
-    def iter_changes_and_state(self):
-        """An iterator for the WorkingTreeFileList widget"""
-        # a word list for message completer
-        words = set()
-        show_nonversioned = self.show_nonversioned_checkbox.isChecked()
-
-        in_selected_list = closure_in_selected_list(self.initial_selected_list)
-
-        num_versioned_files = 0
-        for desc in self.tree.iter_changes(self.tree.basis_tree(),
-                                           want_unversioned=True):
-            desc = ChangeDesc(desc)
-
-            if desc.is_tree_root() or desc.is_misadded():
-                # skip uninteresting enties
-                continue
-
-            is_versioned = desc.is_versioned()
-            path = desc.path()
-
-            if not is_versioned and self.tree.is_ignored(path):
-                continue
-
-            visible = is_versioned or show_nonversioned
-            check_state = None
-            if not self.has_pending_merges:
-                check_state = visible and is_versioned and in_selected_list(path)
-            yield desc, visible, check_state
-
-            if is_versioned:
-                num_versioned_files += 1
-
-                words.update(os.path.split(path))
-                if desc.is_renamed():
-                    words.update(os.path.split(desc.oldpath()))
-                if num_versioned_files < MAX_AUTOCOMPLETE_FILES:
-                    ext = file_extension(path)
-                    builder = get_wordlist_builder(ext)
-                    if builder is not None:
-                        try:
-                            abspath = os.path.join(self.tree.basedir, path)
-                            file = open(abspath, 'rt')
-                            words.update(builder.iter_words(file))
-                        except EnvironmentError:
-                            pass
-        words = list(words)
-        words.sort(lambda a, b: cmp(a.lower(), b.lower()))
-        self.completion_words = words
-
     def __init__(self, tree, selected_list, dialog=True, parent=None,
                  local=None, message=None, ui_mode=True):
         super(CommitWindow, self).__init__(
@@ -202,13 +156,13 @@
                                   dialog = dialog,
                                   parent = parent)
         self.tree = tree
-        tree.lock_read()
-        try:
-            self.basis_tree = self.tree.basis_tree()
-            self.is_bound = bool(tree.branch.get_bound_location())
-            self.has_pending_merges = len(tree.get_parent_ids())>1
-        finally:
-            tree.unlock()
+        #tree.lock_read()
+        #try:
+        #    self.basis_tree = self.tree.basis_tree()
+        self.is_bound = bool(tree.branch.get_bound_location())
+        self.has_pending_merges = len(tree.get_parent_ids())>1
+        #finally:
+        #    tree.unlock()
         
         self.windows = []
         self.initial_selected_list = selected_list
@@ -263,16 +217,27 @@
         self.show_nonversioned_checkbox = QtGui.QCheckBox(
             gettext("Show non-versioned files"))
 
-        self.filelist = WorkingTreeFileList(message_groupbox, self.tree)
-        selectall_checkbox = QtGui.QCheckBox(
-                                gettext(self.filelist.SELECTALL_MESSAGE))
+        self.filelist = TreeWidget(self)
+        self.filelist.throbber = self.throbber
+        self.filelist.tree_model.is_item_in_select_all = lambda item: (
+            item.change is not None and
+            item.change.is_ignored() is None and
+            item.change.is_versioned())
+        
+        self.file_words = {}
+        self.connect(self.filelist.tree_model,
+                     QtCore.SIGNAL("dataChanged(QModelIndex, QModelIndex)"),
+                     self.on_filelist_data_changed)
+        
+        selectall_checkbox = SelectAllCheckBox(self.filelist, self)
         selectall_checkbox.setCheckState(QtCore.Qt.Checked)
-        self.filelist.set_selectall_checkbox(selectall_checkbox)
 
         # Equivalent for 'bzr commit --message'
         self.message = TextEdit(message_groupbox, main_window=self)
         self.message.setToolTip(gettext("Enter the commit message"))
         self.completer = QtGui.QCompleter()
+        self.completer_model = QtGui.QStringListModel(self.completer)
+        self.completer.setModel(self.completer_model)
         self.message.setCompleter(self.completer)
         self.message.setAcceptRichText(False)
 
@@ -328,8 +293,6 @@
     
         vbox.addWidget(selectall_checkbox)
 
-        self.filelist.sortItems(0, QtCore.Qt.AscendingOrder)
-
         # Display a list of pending merges
         if self.has_pending_merges:
             selectall_checkbox.setCheckState(QtCore.Qt.Checked)
@@ -392,7 +355,8 @@
         # we show the bare form as soon as possible.
         SubProcessWindow.show(self)
         QtCore.QTimer.singleShot(1, self.load)
-    
+
+    @runs_in_loading_queue
     @ui_current_widget
     @reports_exception()
     def load(self):
@@ -403,14 +367,56 @@
                                                      None,
                                                      self.tree)
                 self.pending_merges_list.load()
-            self.filelist.fill(self.iter_changes_and_state())
+                self.processEvents()
+            
+            self.filelist.tree_model.checkable = True
+            fmodel = self.filelist.tree_filter_model
+            fmodel.setFilter(fmodel.UNVERSIONED, False)
+            self.filelist.set_tree(self.tree, changes_mode = True)
+            self.processEvents()
+            self.update_compleater_words()
         finally:
             self.tree.unlock()
  
-        self.filelist.setup_actions()        
-        self.completer.setModel(QtGui.QStringListModel(self.completion_words,
-                                                       self.completer))
         self.throbber.hide()
+
+    def on_filelist_data_changed(self, start_index, end_index):
+        self.update_compleater_words()
+    
+    def update_compleater_words(self):
+        num_files_loaded = 0
+        
+        words = set()
+        for item_data in self.filelist.tree_model.iter_checked():
+            path = item_data.change.path()
+            if path not in self.file_words:
+                file_words = set()
+                if num_files_loaded < MAX_AUTOCOMPLETE_FILES:
+                    file_words.add(path)
+                    file_words.add(os.path.split(path)[-1])
+                    if item_data.change.is_renamed():
+                        file_words.add(item_data.change.oldpath())
+                        file_words.add(
+                            os.path.split(item_data.change.oldpath())[-1])
+                    #if num_versioned_files < MAX_AUTOCOMPLETE_FILES:
+                    ext = file_extension(path)
+                    builder = get_wordlist_builder(ext)
+                    if builder is not None:
+                        try:
+                            abspath = os.path.join(self.tree.basedir, path)
+                            file = open(abspath, 'rt')
+                            file_words.update(builder.iter_words(file))
+                            self.processEvents()
+                        except EnvironmentError:
+                            pass
+                    self.file_words[path] = file_words
+                    num_files_loaded += 1
+            else:
+                file_words = self.file_words[path]
+            words.update(file_words)
+        words = list(words)
+        words.sort(lambda a, b: cmp(a.lower(), b.lower()))
+        self.completer_model.setStringList(words)
     
     def enableBugs(self, state):
         if state == QtCore.Qt.Checked:
@@ -460,7 +466,7 @@
 
     def start(self):
         args = ["commit"]
-        files_to_add = ["add"]
+        files_to_add = ["add", "--no-recurse"]
         
         message = unicode(self.message.toPlainText()).strip() 
         if not message: 
@@ -479,12 +485,12 @@
         checkedFiles = 1 
         if not self.has_pending_merges:
             checkedFiles = 0
-            for desc in self.filelist.iter_checked():
-                checkedFiles = checkedFiles+1
-                path = desc.path()
-                if not desc.is_versioned():
+            for item_data in self.filelist.tree_model.iter_checked():
+                path = item_data.change.path()
+                if not item_data.change.is_versioned():
                     files_to_add.append(path)
                 args.append(path)
+                checkedFiles = 1 
         
         if checkedFiles == 0: # BUG: 295116
             # check for availability of --exclude option for commit
@@ -540,11 +546,8 @@
 
     def show_nonversioned(self, state):
         """Show/hide non-versioned files."""
-        state = not state
-        for (tree_item, change_desc) in self.filelist.iter_treeitem_and_desc(True):
-            if change_desc[3] == (False, False):
-                self.filelist.set_item_hidden(tree_item, state)
-        self.filelist.update_selectall_state(None, None)
+        fmodel = self.filelist.tree_filter_model
+        fmodel.setFilter(fmodel.UNVERSIONED, state)
 
     def closeEvent(self, event):
         if not self.process_widget.is_running():
@@ -580,9 +583,9 @@
         # XXX make this function universal for both qcommit and qrevert (?)
         checked = []        # checked versioned
         unversioned = []    # checked unversioned (supposed to be added)
-        for desc in self.filelist.iter_checked():
-            path = desc.path()
-            if desc.is_versioned():
+        for item_data in self.filelist.tree_model.iter_checked():
+            path = item_data.change.path()
+            if item_data.change.is_versioned():
                 checked.append(path)
             else:
                 unversioned.append(path)

=== modified file 'lib/diff.py'
--- lib/diff.py	2009-06-11 21:21:01 +0000
+++ lib/diff.py	2009-07-10 05:16:40 +0000
@@ -69,6 +69,7 @@
         window.process_widget.hide_progress()
         if parent_window:
             parent_window.windows.append(window)
+        window.show()
 
 
 def has_ext_diff():

=== modified file 'lib/diff_arg.py'
--- lib/diff_arg.py	2009-06-23 00:38:58 +0000
+++ lib/diff_arg.py	2009-07-10 05:16:40 +0000
@@ -93,7 +93,9 @@
         from bzrlib import urlutils
 
         args = []
-        args.append(self.get_revspec())
+        revspec = self.get_revspec()
+        if revspec:
+            args.append(revspec)
         
         if not self.old_branch.base == self.new_branch.base: 
             args.append("--old=%s" % self.old_branch.base)
@@ -138,7 +140,10 @@
                 self.specific_files)
 
     def get_revspec(self):
-        return "-r revid:%s" % (self.old_revid,)
+        if self.old_revid is not None:
+            return "-r revid:%s" % (self.old_revid,)
+        else:
+            return None
     
     def need_to_load_paths(self):
         return False

=== modified file 'lib/revert.py'
--- lib/revert.py	2009-06-11 21:21:01 +0000
+++ lib/revert.py	2009-07-10 19:43:43 +0000
@@ -28,11 +28,16 @@
     )
 from bzrlib.plugins.qbzr.lib.i18n import gettext
 from bzrlib.plugins.qbzr.lib.subprocess import SubProcessDialog
-from bzrlib.plugins.qbzr.lib.wtlist import (
-    ChangeDesc,
-    WorkingTreeFileList,
-    closure_in_selected_list,
-    )
+from bzrlib.plugins.qbzr.lib.treewidget import (
+    TreeWidget,
+    SelectAllCheckBox,
+    )
+from bzrlib.plugins.qbzr.lib.util import (
+    ThrobberWidget,
+    runs_in_loading_queue,
+    )
+from bzrlib.plugins.qbzr.lib.uifactory import ui_current_widget
+from bzrlib.plugins.qbzr.lib.trace import reports_exception
 
 
 class RevertWindow(SubProcessDialog):
@@ -51,26 +56,27 @@
                                   parent = parent,
                                   hide_progress=True)
         
+        self.throbber = ThrobberWidget(self) 
+
         # Display the list of changed files
         groupbox = QtGui.QGroupBox(gettext("Changes"), self)
 
-        self.filelist = WorkingTreeFileList(groupbox, self.tree)
-
-        self.tree.lock_read()
-        try:
-            self.filelist.fill(self.iter_changes_and_state())
-        finally:
-            self.tree.unlock()
-
-        self.filelist.setup_actions()
+        self.filelist = TreeWidget(groupbox)
+        self.filelist.throbber = self.throbber 
+        self.filelist.tree_model.is_item_in_select_all = lambda item: ( 
+            item.change is not None and item.change.is_versioned())
+        self.filelist.setRootIsDecorated(False)
+        def filter_context_menu():
+            TreeWidget.filter_context_menu(self.filelist)
+            self.filelist.action_add.setVisible(False)
+            self.filelist.action_revert.setVisible(False)
+        self.filelist.filter_context_menu = filter_context_menu
 
         vbox = QtGui.QVBoxLayout(groupbox)
         vbox.addWidget(self.filelist)
-        selectall_checkbox = QtGui.QCheckBox(
-            gettext(self.filelist.SELECTALL_MESSAGE))
+        selectall_checkbox = SelectAllCheckBox(self.filelist, groupbox)
         selectall_checkbox.setCheckState(QtCore.Qt.Checked)
         selectall_checkbox.setEnabled(True)
-        self.filelist.set_selectall_checkbox(selectall_checkbox)
         vbox.addWidget(selectall_checkbox)
 
         self.no_backup_checkbox = QtGui.QCheckBox(
@@ -80,8 +86,6 @@
         self.no_backup_checkbox.setEnabled(True)
         vbox.addWidget(self.no_backup_checkbox)
 
-        self.filelist.sortItems(0, QtCore.Qt.AscendingOrder)
-
         # groupbox gets disabled as we are executing.
         QtCore.QObject.connect(self,
                                QtCore.SIGNAL("subprocessStarted(bool)"),
@@ -95,6 +99,7 @@
         self.restoreSplitterSizes([150, 150])
 
         layout = QtGui.QVBoxLayout(self)
+        layout.addWidget(self.throbber)
         layout.addWidget(self.splitter)
 
         # Diff button to view changes in files selected to revert
@@ -107,27 +112,31 @@
         hbox.addWidget(self.diffbuttons)
         hbox.addWidget(self.buttonbox)
         layout.addLayout(hbox)
-
-    def iter_changes_and_state(self):
-        """An iterator for the WorkingTreeFileList widget"""
-
-        in_selected_list = closure_in_selected_list(self.initial_selected_list)
-
-        for desc in self.tree.iter_changes(self.tree.basis_tree()):
-            desc = ChangeDesc(desc)
-            if desc.is_tree_root():
-                continue
-            path = desc.path()
-            check_state = in_selected_list(path)
-            yield desc, True, check_state
+        self.throbber.show()
+
+
+    def show(self): 
+        SubProcessDialog.show(self) 
+        QtCore.QTimer.singleShot(1, self.initial_load) 
+ 
+    @runs_in_loading_queue 
+    @ui_current_widget 
+    @reports_exception() 
+    def initial_load(self): 
+        self.filelist.tree_model.checkable = True 
+        fmodel = self.filelist.tree_filter_model 
+        #fmodel.setFilter(fmodel.UNVERSIONED, False) 
+        self.filelist.set_tree(self.tree, changes_mode=True,
+                               want_unversioned=False) 
+        self.throbber.hide()
 
     def start(self):
         """Revert the files."""
         args = ["revert"]
         if self.no_backup_checkbox.checkState():
             args.append("--no-backup")
-        for desc in self.filelist.iter_checked():
-            args.append(desc.path())
+        for item_data in self.filelist.tree_model.iter_checked(): 
+            args.append(item_data.change.path()) 
         self.process_widget.start(self.tree.basedir, *args)
 
     def saveSize(self):

=== modified file 'lib/revtreeview.py'
--- lib/revtreeview.py	2009-07-08 16:20:59 +0000
+++ lib/revtreeview.py	2009-07-10 01:04:24 +0000
@@ -102,6 +102,8 @@
                 break
         
         revids = list(revids)
+        if len(revids) == 0:
+            return
         
         self.load_revisions_call_count += 1
         current_call_count = self.load_revisions_call_count

=== modified file 'lib/tests/modeltest.py'
--- lib/tests/modeltest.py	2009-07-09 01:28:49 +0000
+++ lib/tests/modeltest.py	2009-07-10 01:54:38 +0000
@@ -431,7 +431,8 @@
 
                 # Check that we can get back our real parent
                 p = self.model.parent( index )
-                assert( self.model.parent( index ) == parent )
+                assert( p.internalId() == parent.internalId() )
+                assert( p.row() == parent.row() )
 
                 # recursively go down the children
                 if self.model.hasChildren(index) and depth < 10:

=== modified file 'lib/treewidget.py'
--- lib/treewidget.py	2009-07-10 00:27:28 +0000
+++ lib/treewidget.py	2009-07-12 13:46:24 +0000
@@ -21,6 +21,7 @@
 from time import (strftime, localtime)
 from PyQt4 import QtCore, QtGui
 from bzrlib.workingtree import WorkingTree
+from bzrlib.revisiontree import RevisionTree
 
 from bzrlib.plugins.qbzr.lib.cat import QBzrCatWindow
 from bzrlib.plugins.qbzr.lib.annotate import AnnotateWindow
@@ -37,7 +38,6 @@
     get_apparent_author_name,
     )
 from bzrlib.plugins.qbzr.lib.uifactory import ui_current_widget
-from bzrlib.plugins.qbzr.lib.wtlist import ChangeDesc
 from bzrlib.plugins.qbzr.lib.subprocess import SimpleSubProcessDialog
 from bzrlib.plugins.qbzr.lib.diff import (
     show_diff,
@@ -45,18 +45,159 @@
     ExtDiffMenu,
     InternalWTDiffArgProvider,
     )
-
-
-
-class UnversionedItem():
-    __slots__  = ["name", "path", "kind"]
-    def __init__(self, name, path, kind):
+from bzrlib.plugins.qbzr.lib.i18n import gettext, N_
+
+
+class InternalItem():
+    __slots__  = ["name", "path", "kind", "file_id"]
+    def __init__(self, name, path, kind, file_id):
         self.name = name
         self.path = path
         self.kind = kind
+        self.file_id = file_id
     
     revision = property(lambda self:None)
-    file_id = property(lambda self:None)
+
+class UnversionedItem(InternalItem):
+    def __init__(self, name, path, kind):
+        InternalItem.__init__(self, name, path, kind, None)
+
+class ModelItemData():
+    __slots__ = ["id", "item", "change", "chekced", "children_ids",
+                 "parent_id", "row"]
+    
+    def __init__(self, item, change):
+        self.item = item
+        self.change = change
+        if change is not None and change.is_ignored() is None:
+            self.checked = QtCore.Qt.Checked
+        else:
+            self.checked = QtCore.Qt.Unchecked
+            
+        self.children_ids = None
+        self.parent_id = None
+        self.id = None
+        self.row = None
+
+
+class ChangeDesc(tuple):
+    """Helper class that "knows" about internals of iter_changes' changed entry
+    description tuple, and provides additional helper methods.
+
+    iter_changes return tuple with info about changed entry:
+    [0]: file_id         -> ascii string
+    [1]: paths           -> 2-tuple (old, new) fullpaths unicode/None
+    [2]: changed_content -> bool
+    [3]: versioned       -> 2-tuple (bool, bool)
+    [4]: parent          -> 2-tuple
+    [5]: name            -> 2-tuple (old_name, new_name) utf-8?/None
+    [6]: kind            -> 2-tuple (string/None, string/None)
+    [7]: executable      -> 2-tuple (bool/None, bool/None)
+    
+    --optional--
+    [8]: is_ignored      -> If the file is ignored, pattern which caused it to
+                            be ignored, otherwise None.
+    
+    NOTE: None value used for non-existing entry in corresponding
+          tree, e.g. for added/deleted/ignored/unversioned
+    """
+    
+    # XXX We should may be try get this into bzrlib.
+    # XXX We should use this in qdiff.
+    
+    def fileid(desc):
+        return desc[0]
+
+    def path(desc):
+        """Return a suitable entry for a 'specific_files' param to bzr functions."""
+        oldpath, newpath = desc[1]
+        return newpath or oldpath
+
+    def oldpath(desc):
+        """Return oldpath for renames."""
+        return desc[1][0]
+
+    def kind(desc):
+        oldkind, newkind = desc[6]
+        return newkind or oldkind        
+
+    def is_versioned(desc):
+        return desc[3] != (False, False)
+
+    def is_modified(desc):
+        return (desc[3] != (False, False) and desc[2])
+
+    def is_renamed(desc):
+        return (desc[3] == (True, True)
+                and (desc[4][0], desc[5][0]) != (desc[4][1], desc[5][1]))
+
+    def is_tree_root(desc):
+        """Check if entry actually tree root."""
+        if desc[3] != (False, False) and desc[4] == (None, None):
+            # TREE_ROOT has not parents (desc[4]).
+            # But because we could want to see unversioned files
+            # we need to check for versioned flag (desc[3])
+            return True
+        return False
+
+    def is_missing(desc):
+        """Check if file was present in previous revision but now it's gone
+        (i.e. deleted manually, without invoking `bzr remove` command)
+        """
+        return (desc[3] == (True, True) and desc[6][1] is None)
+
+    def is_misadded(desc):
+        """Check if file was added to the working tree but then gone
+        (i.e. deleted manually, without invoking `bzr remove` command)
+        """
+        return (desc[3] == (False, True) and desc[6][1] is None)
+    
+    def is_ignored(desc):
+        if len(desc) >= 8: 
+            return desc[8]
+        else:
+            return None
+    
+    def status(desc):
+        if len(desc) == 8:
+            (file_id, (path_in_source, path_in_target),
+             changed_content, versioned, parent, name, kind,
+             executable) = desc
+            is_ignored = None
+        elif len(desc) == 9:
+            (file_id, (path_in_source, path_in_target),
+             changed_content, versioned, parent, name, kind,
+             executable, is_ignored) = desc
+        else:
+            raise RuntimeError, "Unkown number of items to unpack."
+            
+        if versioned == (False, False):
+            if is_ignored:
+                return gettext("ignored")
+            else:
+                return gettext("non-versioned")
+        elif versioned == (False, True):
+            return gettext("added")
+        elif versioned == (True, False):
+            return gettext("removed")
+        elif kind[0] is not None and kind[1] is None:
+            return gettext("missing")
+        else:
+            # versioned = True, True - so either renamed or modified
+            # or properties changed (x-bit).
+            renamed = (parent[0], name[0]) != (parent[1], name[1])
+            if renamed:
+                if changed_content:
+                    return gettext("renamed and modified")
+                else:
+                    return gettext("renamed")
+            elif changed_content:
+                return gettext("modified")
+            elif executable[0] != executable[1]:
+                return gettext("modified (x-bit)")
+            else:
+                raise RuntimeError, "what status am I missing??"
+
 
 class TreeModel(QtCore.QAbstractItemModel):
     
@@ -68,10 +209,6 @@
                      gettext("Status")]
     NAME, DATE, REVNO, MESSAGE, AUTHOR, STATUS = range(len(HEADER_LABELS))
 
-    REVID = QtCore.Qt.UserRole + 1
-    FILEID = QtCore.Qt.UserRole + 2
-    PATH = QtCore.Qt.UserRole + 3
-    
     def __init__(self, file_icon, dir_icon, symlink_icon, parent=None):
         QtCore.QAbstractTableModel.__init__(self, parent)
 
@@ -79,39 +216,82 @@
         self.dir_icon = dir_icon
         self.symlink_icon = symlink_icon
         self.tree = None
-        self.inventory_items = []
+        self.inventory_data = []
         self.dir_children_ids = {}
         self.parent_ids = []
+        self.checkable = False
     
-    def set_tree(self, tree, branch):
+    def set_tree(self, tree, branch=None, 
+                 changes_mode=False, want_unversioned=True):
         self.tree = tree
         self.branch = branch
         self.revno_map = None
+        self.changes_mode = changes_mode
         
         self.changes = {}
         self.unver_by_parent = {}
-
+        
         if isinstance(self.tree, WorkingTree):
             tree.lock_read()
             try:
+                root_id = self.tree.get_root_id()
+                dir_fileid_by_path = {}
                 for change in self.tree.iter_changes(self.tree.basis_tree(),
-                                                   want_unversioned=True):
+                                            want_unversioned=want_unversioned):
                     change = ChangeDesc(change)
                     path = change.path()
+                    fileid = change.fileid() 
                     is_ignored = self.tree.is_ignored(path)
                     change = ChangeDesc(change+(is_ignored,))
                     
-                    if change.fileid() is not None:
+                    if fileid is not None and not changes_mode:
                         self.changes[change.fileid()] = change
                     else:
-                        (dir_path, slash, name) = path.rpartition('/')
-                        dir_fileid = self.tree.path2id(dir_path)
+                        if changes_mode:
+                            if (fileid is not None and
+                                change.kind() == "directory"):
+                                dir_fileid_by_path[path] = fileid
+                            dir_path = path
+                            dir_fileid = None
+                            relpath = ""
+                            while dir_path:
+                                (dir_path, slash, name) = dir_path.rpartition('/')
+                                relpath = slash + name + relpath
+                                if dir_path in dir_fileid_by_path:
+                                    dir_fileid = dir_fileid_by_path[dir_path]
+                                    break
+                            if dir_fileid is None:
+                                dir_fileid = root_id
+                                dir_path = ""
+                            
+                            name = relpath.lstrip("/")
+                            if change.is_renamed():
+                                oldpath = change.oldpath()
+                                if oldpath.startswith(dir_path):
+                                    oldpath = oldpath[len(dir_path):]
+                                else:
+                                    # The file was mv from a difirent path. 
+                                    oldpath = '/' + oldpath
+                                name = "%s => %s" % (oldpath, name)
+                        else:
+                            (dir_path, slash, name) = path.rpartition('/')
+                            dir_fileid = self.tree.path2id(dir_path)
+                        
                         
                         if dir_fileid not in self.unver_by_parent:
                             self.unver_by_parent[dir_fileid] = []
-                        self.unver_by_parent[dir_fileid].append((
-                                        UnversionedItem(name, path, change.kind()),
-                                        change))
+                        
+                        if change.is_versioned():
+                            if changes_mode:
+                                item = InternalItem(name, path, change.kind(),
+                                                    change.fileid())
+                            else:
+                                item = self.tree.inventory[change.fileid()]
+                        else:
+                            item = UnversionedItem(name, path, change.kind())
+                            
+                        self.unver_by_parent[dir_fileid].append(
+                                                ModelItemData(item, change))
                 
                 self.process_inventory(self.working_tree_get_children)
             finally:
@@ -119,11 +299,12 @@
         else:
             self.process_inventory(self.revision_tree_get_children)
     
-    def revision_tree_get_children(self, item):
-        for child in item.children.itervalues():
-            yield (child, None)
+    def revision_tree_get_children(self, item_data):
+        for child in item_data.item.children.itervalues():
+            yield ModelItemData(child, None)
     
-    def working_tree_get_children(self, item):
+    def working_tree_get_children(self, item_data):
+        item = item_data.item
         if isinstance(item, UnversionedItem):
             abspath = self.tree.abspath(item.path)
             
@@ -143,9 +324,10 @@
                                      (None, kind),
                                      (None, executable),
                                      is_ignored))
-                yield (child, change)
+                yield ModelItemData(child, change)
         
-        elif item.children is not None:
+        if (not isinstance(item, InternalItem) and
+            item.children is not None and not self.changes_mode):
             #Because we create copies, we have to get the real item.
             item = self.tree.inventory[item.file_id]
             for child in item.children.itervalues():
@@ -155,35 +337,32 @@
                     change = self.changes[child.file_id]
                 else:
                     change = None
-                yield (child, change)
+                yield ModelItemData(child, change)
         if item.file_id in self.unver_by_parent:
-            for (child, change) in self.unver_by_parent[item.file_id]:
-                yield (child, change)
+            for item_data in self.unver_by_parent[item.file_id]:
+                yield item_data
     
     def load_dir(self, dir_id):
         if isinstance(self.tree, WorkingTree):
             self.tree.lock_read()
         try:
-            if dir_id>=len(self.inventory_items):
+            if dir_id>=len(self.inventory_data):
                 return
-            dir_item, dir_change = self.inventory_items[dir_id]
-            dir_children_ids = []
+            dir_item = self.inventory_data[dir_id]
+            dir_item.children_ids = []
             children = sorted(self.get_children(dir_item),
                               self.inventory_dirs_first_cmp,
-                              lambda x: x[0])
+                              lambda x: (x.item.name, x.item.kind))
             
             parent_model_index = self._index_from_id(dir_id, 0)
             self.beginInsertRows(parent_model_index, 0, len(children)-1)
             try:
-                for (child, change) in children:
-                    child_id = self.append_item(child, change, dir_id)
-                    dir_children_ids.append(child_id)
-                    if child.kind == "directory":
-                        self.dir_children_ids[child_id] = None
+                for child in children:
+                    child_id = self.append_item(child, dir_id)
+                    dir_item.children_ids.append(child_id)
                     
-                    if len(dir_children_ids) % 100 == 0:
+                    if len(dir_item.children_ids) % 100 == 0:
                         QtCore.QCoreApplication.processEvents()
-                self.dir_children_ids[dir_id] = dir_children_ids
             finally:
                 self.endInsertRows();
         finally:
@@ -194,37 +373,64 @@
         self.get_children = get_children
         
         self.emit(QtCore.SIGNAL("layoutAboutToBeChanged()"))
-        self.inventory_items = []
+        self.inventory_data = []
         self.dir_children_ids = {}
         self.parent_ids = []
+            
+        root_item = ModelItemData(
+                    self.tree.inventory[self.tree.get_root_id()],
+                    None)
+        root_id = self.append_item(root_item, None)
+        self.load_dir(root_id)
         self.emit(QtCore.SIGNAL("layoutChanged()"))
-            
-        root_item = self.tree.inventory[self.tree.get_root_id()]
-        root_id = self.append_item(root_item, None, None)
-        self.dir_children_ids[root_id] = None
-        self.load_dir(root_id)
     
-    def append_item(self, item, change, parent_id):
-        id = len(self.inventory_items)
-        self.inventory_items.append((item, change))
-        self.parent_ids.append(parent_id)
-        return id
+    def append_item(self, item_data, parent_id):
+        item_data.id = len(self.inventory_data)
+        if parent_id is not None:
+            parent_data = self.inventory_data[parent_id]
+            if self.is_item_in_select_all(item_data):
+                item_data.checked = parent_data.checked
+            else:
+                item_data.checked = False
+            item_data.row = len(parent_data.children_ids)
+        else:
+            item_data.checked = QtCore.Qt.Checked
+            item_data.row = 0
+        item_data.parent_id = parent_id
+        self.inventory_data.append(item_data)
+        return item_data.id
     
     def inventory_dirs_first_cmp(self, x, y):
-        x_is_dir = x.kind =="directory"
-        y_is_dir = y.kind =="directory"
+        (x_name, x_kind) = x
+        (y_name, y_kind) = y
+        x_a = x_name
+        y_a = y_name
+        x_is_dir = x_kind =="directory"
+        y_is_dir = y_kind =="directory"
+        while True:
+            x_b, sep, x_a_t = x_a.partition("/")
+            y_b, sep, y_a_t = y_a.partition("/")
+            if x_a_t == "" and y_a_t == "":
+                break
+            if (x_is_dir or not x_a_t == "") and not (y_is_dir or not y_a_t == ""):
+                return -1
+            if (y_is_dir or not y_a_t == "") and not (x_is_dir or not x_a_t == ""):
+                return 1
+            cmp_r = cmp(x_b, y_b)
+            if not cmp_r == 0:
+                return cmp_r
+            x_a = x_a_t
+            y_a = y_a_t
         if x_is_dir and not y_is_dir:
             return -1
         if y_is_dir and not x_is_dir:
             return 1
-        return cmp(x.name, y.name)
+        return cmp(x_name, y_name)
     
     def set_revno_map(self, revno_map):
         self.revno_map = revno_map
-        for id in xrange(1, len(self.inventory_items)):
-            parent_id = self.parent_ids[id]
-            row = self.dir_children_ids[parent_id].index(id)
-            index = self.createIndex (row, self.REVNO, id)
+        for item_data in self.inventory_data[1:0]:
+            index = self.createIndex (item_data.row, self.REVNO, item_data.id)
             self.emit(QtCore.SIGNAL("dataChanged(QModelIndex, QModelIndex)"),
                       index,index)        
     
@@ -232,43 +438,48 @@
          return len(self.HEADER_LABELS)
 
     def rowCount(self, parent):
-        parent_id = parent.internalId()
-        if parent_id not in self.dir_children_ids:
-            return 0
-        dir_children_ids = self.dir_children_ids[parent_id]
-        if dir_children_ids is None:
-            return 0
-        return len(dir_children_ids)
+        if parent.internalId()>=len(self.inventory_data):
+            return 0
+        parent_data = self.inventory_data[parent.internalId()]
+        if parent_data.children_ids is None:
+            return 0
+        return len(parent_data.children_ids)
     
     def canFetchMore(self, parent):
-        parent_id = parent.internalId()
-        return parent_id in self.dir_children_ids \
-               and self.dir_children_ids[parent_id] is None
+        if parent.internalId()>=len(self.inventory_data):
+            return False
+        parent_data = self.inventory_data[parent.internalId()]
+        return (parent_data.children_ids is None and
+                parent_data.item.kind == "directory")
     
     def fetchMore(self, parent):
         self.load_dir(parent.internalId())
 
     def _index(self, row, column, parent_id):
-        if parent_id not in self.dir_children_ids:
-            return QtCore.QModelIndex()
-        dir_children_ids = self.dir_children_ids[parent_id]
-        if dir_children_ids is None:
-            return QtCore.QModelIndex()
-        if row >= len(dir_children_ids):
-            return QtCore.QModelIndex()
-        item_id = dir_children_ids[row]
+        if parent_id>=len(self.inventory_data):
+            return QtCore.QModelIndex()
+        
+        parent_data = self.inventory_data[parent_id]
+        if parent_data.children_ids is None:
+            return QtCore.QModelIndex()
+        
+        if (row < 0 or
+            row >= len(parent_data.children_ids) or
+            column < 0 or
+            column >= len(self.HEADER_LABELS)):
+            return QtCore.QModelIndex()
+        item_id = parent_data.children_ids[row]
         return self.createIndex(row, column, item_id)
     
     def _index_from_id(self, item_id, column):
-        parent_id = self.parent_ids[item_id]
-        if parent_id is None:
+        if item_id >= len(self.inventory_data):
             return QtCore.QModelIndex()
-        row = self.dir_children_ids[parent_id].index(item_id)
-        return self.createIndex(row, column, item_id)    
+        
+        item_data = self.inventory_data[item_id]
+        return self.createIndex(item_data.row, column, item_id) 
     
     def index(self, row, column, parent = QtCore.QModelIndex()):
-        parent_id = parent.internalId()
-        return self._index(row, column, parent_id)
+        return self._index(row, column, parent.internalId())
     
     def sibling(self, row, column, index):
         sibling_id = index.internalId()
@@ -281,28 +492,109 @@
         child_id = child.internalId()
         if child_id == 0:
             return QtCore.QModelIndex()
-        if child_id not in self.parent_ids:
-            return QtCore.QModelIndex()
-        item_id = self.parent_ids[child_id]
-        if item_id == 0 :
+        item_data = self.inventory_data[child_id]
+        if item_data.parent_id == 0 :
             return QtCore.QModelIndex()
         
-        return self._index_from_id(item_id, 0)
+        return self._index_from_id(item_data.parent_id, 0)
 
     def hasChildren(self, parent):
-        parent_id = parent.internalId()
-        return parent_id in self.dir_children_ids
+        if self.tree is None:
+            return False
+        if parent.internalId() == 0:
+            return True
+        item_data = self.inventory_data[parent.internalId()]
+        return item_data.item.kind == "directory"
+    
+    is_item_in_select_all = lambda self, item: True
+    """Returns wether an item is changed when select all is clicked."""
+    
+    def setData(self, index, value, role):
+        
+        
+        def set_checked(item_data, checked):
+            old_checked = item_data.checked
+            item_data.checked = checked
+            if not old_checked == checked:
+                index = self.createIndex (item_data.row, self.NAME, item_data.id)
+                self.emit(QtCore.SIGNAL("dataChanged(QModelIndex, QModelIndex)"),
+                          index,index)        
+            
+        if index.column() == self.NAME and role == QtCore.Qt.CheckStateRole:
+            value = value.toInt()[0]
+            if index.internalId() >= len(self.inventory_data):
+                return False
+            
+            item_data = self.inventory_data[index.internalId()]
+            set_checked(item_data, value)
+            
+            # Recursively set all children to checked.
+            if item_data.children_ids is not None:
+                children_ids = list(item_data.children_ids)
+                while children_ids:
+                    child = self.inventory_data[children_ids.pop(0)]
+                    
+                    # If unchecking, uncheck everything, but if checking,
+                    # only check those in "select_all" get checked.
+                    if (self.is_item_in_select_all(child) or
+                        value == QtCore.Qt.Unchecked):
+                        
+                        set_checked(child, value)
+                        if child.children_ids is not None:
+                            children_ids.extend(child.children_ids)
+            
+            # Walk up the tree, and update every dir
+            parent_data = item_data
+            while parent_data.parent_id is not None:
+                parent_data = self.inventory_data[parent_data.parent_id]
+                has_checked = False
+                has_unchecked = False
+                for child_id in parent_data.children_ids:
+                    child = self.inventory_data[child_id]
+                    
+                    if child.checked == QtCore.Qt.Checked:
+                        has_checked = True
+                    elif (child.checked == QtCore.Qt.Unchecked and
+                          self.is_item_in_select_all(child)):
+                        has_unchecked = True
+                    elif child.checked == QtCore.Qt.PartiallyChecked:
+                        has_checked = True
+                        if self.is_item_in_select_all(child):
+                            has_unchecked = True
+                    
+                    if has_checked and has_unchecked:
+                        break
+                
+                if has_checked and has_unchecked:
+                    set_checked(parent_data, QtCore.Qt.PartiallyChecked)
+                elif has_checked:
+                    set_checked(parent_data, QtCore.Qt.Checked)
+                else:
+                    set_checked(parent_data, QtCore.Qt.Unchecked)
+            
+            return True
+        
+        return False
+    
+    REVID = QtCore.Qt.UserRole + 1
+    FILEID = QtCore.Qt.UserRole + 2
+    PATH = QtCore.Qt.UserRole + 3
+    INTERNALID = QtCore.Qt.UserRole + 4
     
     def data(self, index, role):
         if not index.isValid():
             return QtCore.QVariant()
         
-        (item, change) = self.inventory_items[index.internalId()]
+        if role == self.INTERNALID:
+            return QtCore.QVariant(index.internalId())
+        
+        item_data = self.inventory_data[index.internalId()]
+        item = item_data.item
         
         if role == self.FILEID:
             return QtCore.QVariant(item.file_id)
         
-        revid = item.revision
+        revid = item_data.item.revision
         if role == self.REVID:
             if revid is None:
                 return QtCore.QVariant()
@@ -321,13 +613,18 @@
                 if item.kind == "symlink":
                     return QtCore.QVariant(self.symlink_icon)
                 return QtCore.QVariant()
+            if role ==  QtCore.Qt.CheckStateRole:
+                if not self.checkable:
+                    return QtCore.QVariant()
+                else:
+                    return QtCore.QVariant(item_data.checked)
         
         if column == self.STATUS:
             if role == QtCore.Qt.DisplayRole:
-                if change is not None:
-                    return QtCore.QVariant(change.status())
+                if item_data.change is not None:
+                    return QtCore.QVariant(item_data.change.status())
                 else:
-                    return QtCore.QVariant()
+                    return QtCore.QVariant("")
         
         if column == self.REVNO:
             if role == QtCore.Qt.DisplayRole:
@@ -336,7 +633,7 @@
                     return QtCore.QVariant(
                         ".".join(["%d" % (revno) for revno in revno_sequence]))
                 else:
-                    return QtCore.QVariant()
+                    return QtCore.QVariant("")
 
         if role == QtCore.Qt.DisplayRole:
             if revid in cached_revisions:
@@ -365,13 +662,21 @@
                         self.tree.unlock()
             return QtCore.QVariant(path)
         
+        if role == QtCore.Qt.DisplayRole:
+            return QtCore.QVariant("")
         return QtCore.QVariant()
     
     def flags(self, index):
-        if not index.isValid():
-            return QtCore.Qt.ItemIsEnabled
+        #if not index.isValid():
+        #    return QtCore.Qt.ItemIsEnabled
 
-        return QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable
+        if self.checkable and index.column() == self.NAME:
+            return (QtCore.Qt.ItemIsEnabled |
+                    QtCore.Qt.ItemIsSelectable |
+                    QtCore.Qt.ItemIsUserCheckable)
+        else:
+            return (QtCore.Qt.ItemIsEnabled |
+                    QtCore.Qt.ItemIsSelectable)
 
     def headerData(self, section, orientation, role):
         if orientation == QtCore.Qt.Horizontal and role == QtCore.Qt.DisplayRole:
@@ -380,19 +685,23 @@
     
     def on_revisions_loaded(self, revisions, last_call):
         inventory = self.tree.inventory
-        for id, (item, change) in enumerate(self.inventory_items):
-            if id == 0:
+        for item_data in self.inventory_data:
+            if item_data.id == 0:
                 continue
             
-            if item.revision in revisions:
-                parent_id = self.parent_ids[id]
-                row = self.dir_children_ids[parent_id].index(id)
+            if item_data.item.revision in revisions:
                 self.emit(QtCore.SIGNAL("dataChanged(QModelIndex, QModelIndex)"),
-                          self.createIndex (row, self.DATE, id),
-                          self.createIndex (row, self.AUTHOR,id))
+                          self.createIndex (item_data.row, self.DATE, item_data.id),
+                          self.createIndex (item_data.row, self.AUTHOR, item_data.id))
 
     def get_repo(self):
         return self.branch.repository
+    
+    def iter_checked(self):
+        return sorted([item_data for item_data in self.inventory_data[1:]
+                       if item_data.checked == QtCore.Qt.Checked],
+                      self.inventory_dirs_first_cmp,
+                      lambda x: (x.change.path(), x.item.kind))
 
 class TreeFilterProxyModel(QtGui.QSortFilterProxyModel):
     source_model = None
@@ -430,7 +739,10 @@
         
         model = self.source_model
         parent_id = source_parent.internalId()
-        id = model.dir_children_ids[parent_id][source_row]
+        children_ids = model.inventory_data[parent_id].children_ids
+        if len(children_ids)<=source_row:
+            return False
+        id = children_ids[source_row]
         return self.filter_id_cached(id)
     
     def filter_id_cached(self, id):
@@ -445,27 +757,26 @@
         (unchanged, changed, unversioned, ignored) = self.filters
 
         model = self.source_model
-        item, change = model.inventory_items[id]
-        
-        if change is None and unchanged: return True
-        
-        is_versioned = not isinstance(item, UnversionedItem)
-        
-        if is_versioned and change is not None and changed: return True
+        item_data = model.inventory_data[id]
+        
+        if item_data.change is None and unchanged: return True
+        
+        is_versioned = not isinstance(item_data.item, UnversionedItem)
+        
+        if is_versioned and item_data.change is not None and changed:
+            return True
         
         if not is_versioned and unversioned:
-            is_ignored = change.is_ignored()
+            is_ignored = item_data.change.is_ignored()
             if not is_ignored: return True
             if is_ignored and ignored: return True
             if is_ignored and not ignored: return False
         
-        if id in model.dir_children_ids:
-            dir_children_ids = model.dir_children_ids[id]
-            if dir_children_ids is None:
+        if item_data.item.kind == "directory":
+            if item_data.children_ids is None:
                 model.load_dir(id)
-                dir_children_ids = model.dir_children_ids[id]
             
-            for child_id in dir_children_ids:
+            for child_id in item_data.children_ids:
                 if self.filter_id_cached(child_id):
                     return True
         
@@ -540,7 +851,6 @@
         self.connect(self,
                      QtCore.SIGNAL("doubleClicked(QModelIndex)"),
                      self.do_default_action)
-        self.default_action = self.show_file_content
         self.tree = None
         self.branch = None
     
@@ -552,7 +862,7 @@
         header.setResizeMode(self.tree_model.REVNO, QtGui.QHeaderView.Interactive)
         header.setResizeMode(self.tree_model.MESSAGE, QtGui.QHeaderView.Stretch)
         header.setResizeMode(self.tree_model.AUTHOR, QtGui.QHeaderView.Interactive)        
-        header.setResizeMode(self.tree_model.STATUS, QtGui.QHeaderView.ResizeToContents)        
+        header.setResizeMode(self.tree_model.STATUS, QtGui.QHeaderView.Stretch)        
         fm = self.fontMetrics()
         # XXX Make this dynamic.
         col_margin = 6
@@ -596,10 +906,34 @@
                                     gettext("&Revert"),
                                     self.revert)
     
-    def set_tree(self, tree, branch):
+    def set_tree(self, tree, branch=None,
+                 changes_mode=False, want_unversioned=True):
+        """Causes a tree to be loaded, and displayed in the widget.
+
+        @param changes_mode: If in changes mode, a list of changes, and
+                             unversioned items, rather than a tree, is diplayed.
+                             e.g., when not in changes mode, one will get:
+                             
+                             dir1
+                                file1              changed
+                             file2                 changed
+                             
+                             but when in changes mode, one will get:
+                             
+                             dir1/file1             changed
+                             file2                  changed
+                             
+                             When in changes mode, no unchanged items are shown.
+        """
         self.tree = tree
+        if isinstance(tree, RevisionTree) and branch is None:
+            raise AttributeError("A branch must be provided if the tree is a \
+                                 RevisionTree")
         self.branch = branch
-        self.tree_model.set_tree(self.tree, self.branch)
+        self.changes_mode = changes_mode
+        self.want_unversioned = want_unversioned
+        self.tree_model.set_tree(self.tree, self.branch,
+                                 changes_mode, want_unversioned)
         self.tree_filter_model.invalidateFilter()
         
         if str(QtCore.QT_VERSION_STR).startswith("4.4"):
@@ -623,7 +957,6 @@
             header.showSection(self.tree_model.STATUS)
             
             self.context_menu.setDefaultAction(self.action_open_file)
-            self.default_action = self.open_file
         else:
             header.showSection(self.tree_model.DATE)
             header.showSection(self.tree_model.REVNO)
@@ -632,10 +965,10 @@
             header.hideSection(self.tree_model.STATUS)
             
             self.context_menu.setDefaultAction(self.action_show_file)
-            self.default_action = self.show_file_content
     
     def refresh(self):
-        self.tree_model.set_tree(self.tree, self.branch)
+        self.tree_model.set_tree(self.tree, self.branch,
+                                 self.changes_mode, self.want_unversioned)
         self.tree_filter_model.invalidateFilter()
 
     def contextMenuEvent(self, event):
@@ -647,32 +980,35 @@
         if indexes == None:
             indexes = self.selectedIndexes()
         rows = {}
-        for index in self.selectedIndexes():
-            if index.row() not in rows:
-                rows[index.internalId()] = index
+        for index in indexes:
+            internal_id = index.data(self.tree_model.INTERNALID).toInt()[0]
+            if internal_id not in rows:
+                rows[internal_id] = index
         return rows.values()
     
     def get_selection_items(self, indexes=None):
         items = []
-        if indexes is None:
+        if indexes is None or len(indexes)==1 and indexes[0] is None:
             indexes = self.get_selection_indexes(indexes) 
         for index in indexes:
             source_index = self.tree_filter_model.mapToSource(index)
-            items.append(self.tree_model.inventory_items[
+            items.append(self.tree_model.inventory_data[
                                                     source_index.internalId()])
         return items
 
     def filter_context_menu(self):
         is_working_tree = isinstance(self.tree, WorkingTree)
         items = self.get_selection_items()
-        versioned = [not isinstance(item[0], UnversionedItem)
+        versioned = [not isinstance(item.item, UnversionedItem)
                      for item in items]
-        changed = [item[1] is not None
+        changed = [item.change is not None
                    for item in items]
+        versioned_changed = [ver and ch for ver,ch in zip(versioned, changed)]
+        
         selection_len = len(items)
         
         single_versioned_file = (selection_len == 1 and versioned[0] and
-                                 items[0][0].kind == "file")
+                                 items[0].item.kind == "file")
         
         self.action_open_file.setEnabled(is_working_tree)
         self.action_open_file.setVisible(is_working_tree)
@@ -680,24 +1016,37 @@
         self.action_show_annotate.setEnabled(single_versioned_file)
         self.action_show_log.setEnabled(any(versioned))
         self.action_show_diff.setVisible(is_working_tree)
-        self.action_show_diff.setEnabled(any(changed))
+        self.action_show_diff.setEnabled(any(versioned_changed))
         
         self.action_add.setVisible(is_working_tree)
         self.action_add.setDisabled(all(versioned))
         self.action_revert.setVisible(is_working_tree)
-        self.action_revert.setEnabled(any(changed) and any(versioned))
+        self.action_revert.setEnabled(any(versioned_changed))
+        
+        if is_working_tree:
+            if any(versioned_changed):
+                self.context_menu.setDefaultAction(self.action_show_diff)
+            else:
+                self.context_menu.setDefaultAction(self.action_open_file)
+            
     
-    def do_default_action(self, index=None):
+    def do_default_action(self, index):
         indexes = self.get_selection_indexes([index])
         if not len(indexes) == 1:
             return
         
-        item = self.get_selection_items(indexes)[0]
-        if item[0].kind == "directory":
+        item_data = self.get_selection_items(indexes)[0]
+        if item_data.item.kind == "directory":
             # Don't do anything, so that the directory can be expanded.
             return
         
-        self.default_action(index)
+        if isinstance(self.tree, WorkingTree):
+            if item_data.change is not None and item_data.change.is_versioned():
+                self.show_differences(index=index)
+            else:
+                self.open_file(index)
+        else:
+            self.show_file_content(index)
 
     @ui_current_widget
     def show_file_content(self, index=None):
@@ -708,7 +1057,7 @@
             return
         
         item = self.get_selection_items(indexes)[0]
-        if isinstance(item[0], UnversionedItem):
+        if isinstance(item.item, UnversionedItem):
             return
         
         index = indexes[0]
@@ -748,8 +1097,8 @@
         """Show qlog for one selected file(s)."""
         
         items = self.get_selection_items()
-        fileids = [item[0].file_id for item in items
-                   if item[0].file_id is not None]
+        fileids = [item.item.file_id for item in items
+                   if item.item.file_id is not None]
         
         window = LogWindow(None, self.branch, fileids)
         window.show()
@@ -767,17 +1116,17 @@
         self.window().windows.append(window)
 
     @ui_current_widget
-    def show_differences(self, ext_diff=None):
+    def show_differences(self, ext_diff=None, index=None):
         """Show differences for selected file(s)."""
         
-        items = self.get_selection_items()
+        items = self.get_selection_items([index])
         if len(items) > 0:
             self.tree.lock_read()
             try:
                 # Only paths that have changes.
-                paths = [self.tree.id2path(item[0].file_id)
+                paths = [self.tree.id2path(item.item.file_id)
                          for item in items
-                         if item[1] is not None]
+                         if item.change is not None]
             finally:
                 self.tree.unlock()
         else:
@@ -800,9 +1149,9 @@
         items = self.get_selection_items()
         
         # Only paths that are not versioned.
-        paths = [item[0].path
+        paths = [item.item.path
                  for item in items
-                 if isinstance(item[0], UnversionedItem)]
+                 if isinstance(item.item, UnversionedItem)]
         
         if len(paths) == 0:
             return
@@ -829,10 +1178,10 @@
         self.tree.lock_read()
         try:
             # Only paths that have changes.
-            paths = [self.tree.id2path(item[0].file_id)
+            paths = [self.tree.id2path(item.item.file_id)
                      for item in items
-                     if item[1] is not None and
-                        not isinstance(item[0], UnversionedItem)]
+                     if item.change is not None and
+                        not isinstance(item.item, UnversionedItem)]
         finally:
             self.tree.unlock()
         
@@ -851,4 +1200,39 @@
         res = revert_dialog.exec_()
         if res == QtGui.QDialog.Accepted:
             self.refresh()
- 
\ No newline at end of file
+
+class SelectAllCheckBox(QtGui.QCheckBox):
+    
+    def __init__(self, tree_widget, parent=None):
+        QtGui.QCheckBox.__init__(self, gettext("Select / deselect all"), parent)
+        
+        self.tree_widget = tree_widget
+        #self.setTristate(True)
+        
+        self.connect(tree_widget.tree_model,
+                     QtCore.SIGNAL("dataChanged(QModelIndex, QModelIndex)"),
+                     self.on_data_changed)
+        
+        self.connect(self, QtCore.SIGNAL("clicked(bool)"),
+                     self.clicked)
+    
+    def on_data_changed(self, start_index, end_index):
+        self.update_state()
+    
+    def update_state(self):
+        model = self.tree_widget.tree_model
+        root_index = model._index_from_id(0, model.NAME)
+        
+        state = model.data(root_index, QtCore.Qt.CheckStateRole)
+        self.setCheckState(state.toInt()[0])
+    
+    def clicked(self, state):
+        model = self.tree_widget.tree_model
+        root_index = model._index_from_id(0, model.NAME)
+        if state:
+            state = QtCore.QVariant(QtCore.Qt.Checked)
+        else:
+            state = QtCore.QVariant(QtCore.Qt.Unchecked)
+        
+        model.setData(root_index, QtCore.QVariant(state),
+                      QtCore.Qt.CheckStateRole)

=== removed file 'lib/wtlist.py'
--- lib/wtlist.py	2009-06-18 03:44:48 +0000
+++ lib/wtlist.py	1970-01-01 00:00:00 +0000
@@ -1,449 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# QBzr - Qt frontend to Bazaar commands
-# Copyright (C) 2006-2007 Lukáš Lalinský <[e-mail]>
-# Copyright (C) 2006 Trolltech ASA
-# Copyright (C) 2006 Jelmer Vernooij <[e-mail]>
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-
-"""A QTreeWidget that shows the items in a working tree, and includes a common
-context menu."""
-
-from PyQt4 import QtCore, QtGui
-
-from bzrlib import osutils
-
-from bzrlib.plugins.qbzr.lib.diff import (
-    show_diff,
-    has_ext_diff,
-    ExtDiffMenu,
-    InternalWTDiffArgProvider,
-    )
-from bzrlib.plugins.qbzr.lib.i18n import gettext, N_
-from bzrlib.plugins.qbzr.lib.subprocess import SimpleSubProcessDialog
-from bzrlib.plugins.qbzr.lib.util import (
-    file_extension,
-    runs_in_loading_queue,
-    )
-
-
-class WorkingTreeFileList(QtGui.QTreeWidget):
-
-    SELECTALL_MESSAGE = N_("Select / deselect all")
-
-    def __init__(self, parent, tree):
-        QtGui.QTreeWidget.__init__(self, parent)
-        self._ignore_select_all_changes = False
-        self.selectall_checkbox = None # added by client.
-        self.tree = tree
-
-    def setup_actions(self):
-        """Setup double-click and context menu"""
-        parent = self.parentWidget()
-        parent.connect(self,
-                       QtCore.SIGNAL("itemDoubleClicked(QTreeWidgetItem *, int)"),
-                       self.itemDoubleClicked)
-
-        self.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
-        parent.connect(self,
-                       QtCore.SIGNAL("itemSelectionChanged()"),
-                       self.update_context_menu_actions)
-        parent.connect(self,
-                       QtCore.SIGNAL("customContextMenuRequested(QPoint)"),
-                       self.show_context_menu)
-
-        self.context_menu = QtGui.QMenu(self)
-        if has_ext_diff():
-            self.diff_menu = ExtDiffMenu(self)
-            self.context_menu.addMenu(self.diff_menu)
-            self.connect(self.diff_menu, QtCore.SIGNAL("triggered(QString)"),
-                         self.show_differences)
-            self.show_diff_ui = self.diff_menu
-        else:
-            self.show_diff_action = self.context_menu.addAction(
-                gettext("Show &differences..."), self.show_differences)
-            self.context_menu.setDefaultAction(self.show_diff_action)
-            self.show_diff_ui = self.show_diff_action
-
-        self.revert_action = self.context_menu.addAction(
-            gettext("&Revert..."), self.revert_selected)
-        # set all actions to disabled so it does the right thing with an empty
-        # list (our itemSelectionChanged() will fire as soon as we select one)
-        self.revert_action.setEnabled(False)
-        self.show_diff_ui.setEnabled(False)
-
-    @runs_in_loading_queue
-    def fill(self, items_iter):
-        self.setTextElideMode(QtCore.Qt.ElideMiddle)
-        self.setSelectionMode(QtGui.QAbstractItemView.ExtendedSelection)
-        self.setSortingEnabled(True)
-        self.setHeaderLabels([gettext("File"), gettext("Extension"), gettext("Status")])
-        header = self.header()
-        header.setStretchLastSection(False)
-        header.setResizeMode(0, QtGui.QHeaderView.Stretch)
-        header.setResizeMode(1, QtGui.QHeaderView.ResizeToContents)
-        header.setResizeMode(2, QtGui.QHeaderView.ResizeToContents)
-        self.setRootIsDecorated(False)
-        self._ignore_select_all_changes = True # don't update as we add items!
-
-        # Each items_iter returns a tuple of (changes_tuple, is_checked)
-        # Where changes_tuple is a single item from iter_changes():
-        # (file_id, (path_in_source, path_in_target),
-        # changed_content, versioned, parent, name, kind,
-        # executable)
-        # Note that the current filter is used to determine if the items are
-        # shown or not
-        self.item_to_data = {}
-        items = []
-        for change_desc, visible, checked in items_iter:
-            (file_id, (path_in_source, path_in_target),
-             changed_content, versioned, parent, name, kind,
-             executable) = change_desc
-
-            if versioned == (False, False):
-                if self.tree.is_ignored(path_in_target):
-                    status = gettext("ignored")
-                else:
-                    status = gettext("non-versioned")
-                ext = file_extension(path_in_target)
-                name = path_in_target
-            elif versioned == (False, True):
-                status = gettext("added")
-                ext = file_extension(path_in_target)
-                name = path_in_target + osutils.kind_marker(kind[1])
-            elif versioned == (True, False):
-                status = gettext("removed")
-                ext = file_extension(path_in_source)
-                name = path_in_source + osutils.kind_marker(kind[0])
-            elif kind[0] is not None and kind[1] is None:
-                status = gettext("missing")
-                ext = file_extension(path_in_source)
-                name = path_in_source + osutils.kind_marker(kind[0])
-            else:
-                # versioned = True, True - so either renamed or modified
-                # or properties changed (x-bit).
-                renamed = (parent[0], name[0]) != (parent[1], name[1])
-                if renamed:
-                    if changed_content:
-                        status = gettext("renamed and modified")
-                    else:
-                        status = gettext("renamed")
-                    name = "%s%s => %s%s" % (path_in_source,
-                                             osutils.kind_marker(kind[0]),
-                                             path_in_target,
-                                             osutils.kind_marker(kind[0]))
-                    ext = file_extension(path_in_target)
-                elif changed_content:
-                    status = gettext("modified")
-                    name = path_in_target +  osutils.kind_marker(kind[1])
-                    ext = file_extension(path_in_target)
-                elif executable[0] != executable[1]:
-                    status = gettext("modified (x-bit)")
-                    name = path_in_target +  osutils.kind_marker(kind[1])
-                    ext = file_extension(path_in_target)
-                else:
-                    raise RuntimeError, "what status am I missing??"
-
-            item = QtGui.QTreeWidgetItem()
-            item.setText(0, name)
-            item.setText(1, ext)
-            item.setText(2, status)
-            if visible:
-                items.append(item)
-
-            if checked is None:
-                item.setCheckState(0, QtCore.Qt.PartiallyChecked)
-                item.setFlags(item.flags() & ~QtCore.Qt.ItemIsUserCheckable)
-            elif checked:
-                item.setCheckState(0, QtCore.Qt.Checked)
-            else:
-                item.setCheckState(0, QtCore.Qt.Unchecked)
-            self.item_to_data[item] = change_desc
-        # add them all to the tree in one hit.
-        self.insertTopLevelItems(0, items)
-        self._ignore_select_all_changes = False
-        if self.selectall_checkbox is not None:
-            self.update_selectall_state(None, None)
-
-    def set_item_hidden(self, item, hide):
-        # Due to what seems a bug in Qt "hiding" an item isn't always
-        # reliable - so a "hidden" item is simply not added to the tree!
-        # See https://bugs.launchpad.net/qbzr/+bug/274295
-        index = self.indexOfTopLevelItem(item)
-        if index == -1 and not hide:
-            self.addTopLevelItem(item)
-        elif index != -1 and hide:
-            self.takeTopLevelItem(index)
-
-    def is_item_hidden(self, item):
-        return self.indexOfTopLevelItem(item) == -1
-
-    def iter_treeitem_and_desc(self, include_hidden=False):
-        """iterators to help work with the selection, checked items, etc"""
-        for ti, desc in self.item_to_data.iteritems():
-            if include_hidden or not self.is_item_hidden(ti):
-                yield ti, desc
-
-    def iter_selection(self):
-        for i in self.selectedItems():
-            yield self.item_to_data[i]
-
-    def iter_checked(self):
-        # XXX - just use self.iter_treeitem_and_desc() - no need to hit the
-        # XXX   tree object at all!?
-        for i in range(self.topLevelItemCount()):
-            item = self.topLevelItem(i)
-            if item.checkState(0) == QtCore.Qt.Checked:
-                yield self.item_to_data[item]
-
-    def show_context_menu(self, pos):
-        """Context menu and double-click related functions..."""
-        self.context_menu.popup(self.viewport().mapToGlobal(pos))
-
-    def update_context_menu_actions(self):
-        contains_non_versioned = False
-        for desc in self.iter_selection():
-            if desc[3] == (False, False):
-                contains_non_versioned = True
-                break
-        self.revert_action.setEnabled(not contains_non_versioned)
-        self.show_diff_ui.setEnabled(not contains_non_versioned)
-
-    def revert_selected(self):
-        """Revert the selected file."""
-        items = self.selectedItems()
-        if not items:
-            return
-        
-        paths = [self.item_to_data[item][1][1] for item in items]
-        
-        args = ["revert"]
-        args.extend(paths)
-        desc = (gettext("Revert %s to latest revision.") % ", ".join(paths))
-        revert_dialog = SimpleSubProcessDialog(gettext("Revert"),
-                                         desc=desc,
-                                         args=args,
-                                         dir=self.tree.basedir,
-                                         parent=self,
-                                         hide_progress=True,
-                                        )
-        res = revert_dialog.exec_()
-        if res == QtGui.QDialog.Accepted:
-            for item in items:
-                index = self.indexOfTopLevelItem(item)
-                self.takeTopLevelItem(index)
-
-    def itemDoubleClicked(self, items=None, column=None):
-        self.show_differences()
-    
-    def show_differences(self, ext_diff=None):
-        """Show differences between the working copy and the last revision."""
-        if not self.show_diff_ui.isEnabled():
-            return
-        
-        entries = [desc.path() for desc in self.iter_selection()]
-        if entries:
-            arg_provider = InternalWTDiffArgProvider(
-                self.tree.basis_tree().get_revision_id(), self.tree,
-                self.tree.branch, self.tree.branch,
-                specific_files=entries)
-            
-            show_diff(arg_provider, ext_diff=ext_diff,
-                      parent_window=self.topLevelWidget())
-
-    def set_selectall_checkbox(self, checkbox):
-        """Helpers for a 'show all' checkbox.  Parent widgets must create the
-        widget and pass it to us.
-        """
-        checkbox.setTristate(True)
-        self.selectall_checkbox = checkbox
-        parent = self.parentWidget()
-        parent.connect(self,
-                     QtCore.SIGNAL("itemChanged(QTreeWidgetItem *, int)"),
-                     self.update_selectall_state)
-        
-        parent.connect(checkbox, QtCore.SIGNAL("stateChanged(int)"),
-                                               self.selectall_changed)
-
-    def update_selectall_state(self, item, column):
-        """Update the state of the 'select all' checkbox to reflect the state
-        of the items in the list.
-        """
-        if self._ignore_select_all_changes:
-            return
-        checked = 0
-        num_items = 0
-
-        for (tree_item, change_desc) in self.iter_treeitem_and_desc():
-            if tree_item.checkState(0) == QtCore.Qt.Checked:
-                checked += 1
-            num_items += 1
-        self._ignore_select_all_changes = True
-        if checked == 0:
-            self.selectall_checkbox.setCheckState(QtCore.Qt.Unchecked)
-        elif checked == num_items:
-            self.selectall_checkbox.setCheckState(QtCore.Qt.Checked)
-        else:
-            self.selectall_checkbox.setCheckState(QtCore.Qt.PartiallyChecked)
-        self._ignore_select_all_changes = False
-
-    def selectall_changed(self, state):
-        if self._ignore_select_all_changes or not self.selectall_checkbox.isEnabled():
-            return
-        if state == QtCore.Qt.PartiallyChecked:
-            self.selectall_checkbox.setCheckState(QtCore.Qt.Checked)
-            return
-
-        self._ignore_select_all_changes = True
-        for (tree_item, change_desc) in self.iter_treeitem_and_desc():
-            tree_item.setCheckState(0, QtCore.Qt.CheckState(state))
-        self._ignore_select_all_changes = False
-
-
-class ChangeDesc(tuple):
-    """Helper class that "knows" about internals of iter_changes' changed entry
-    description tuple, and provides additional helper methods.
-
-    iter_changes return tuple with info about changed entry:
-    [0]: file_id         -> ascii string
-    [1]: paths           -> 2-tuple (old, new) fullpaths unicode/None
-    [2]: changed_content -> bool
-    [3]: versioned       -> 2-tuple (bool, bool)
-    [4]: parent          -> 2-tuple
-    [5]: name            -> 2-tuple (old_name, new_name) utf-8?/None
-    [6]: kind            -> 2-tuple (string/None, string/None)
-    [7]: executable      -> 2-tuple (bool/None, bool/None)
-    
-    --optional--
-    [8]: is_ignored      -> If the file is ignored, pattern which caused it to
-                            be ignored, otherwise None.
-    
-    NOTE: None value used for non-existing entry in corresponding
-          tree, e.g. for added/deleted/ignored/unversioned
-    """
-    
-    # XXX We should may be try get this into bzrlib.
-    # XXX We should use this in qdiff.
-    
-    def fileid(desc):
-        return desc[0]
-
-    def path(desc):
-        """Return a suitable entry for a 'specific_files' param to bzr functions."""
-        oldpath, newpath = desc[1]
-        return newpath or oldpath
-
-    def oldpath(desc):
-        """Return oldpath for renames."""
-        return desc[1][0]
-
-    def kind(desc):
-        oldkind, newkind = desc[6]
-        return newkind or oldkind        
-
-    def is_versioned(desc):
-        return desc[3] != (False, False)
-
-    def is_modified(desc):
-        return (desc[3] != (False, False) and desc[2])
-
-    def is_renamed(desc):
-        return (desc[3] == (True, True)
-                and (desc[4][0], desc[5][0]) != (desc[4][1], desc[5][1]))
-
-    def is_tree_root(desc):
-        """Check if entry actually tree root."""
-        if desc[3] != (False, False) and desc[4] == (None, None):
-            # TREE_ROOT has not parents (desc[4]).
-            # But because we could want to see unversioned files
-            # we need to check for versioned flag (desc[3])
-            return True
-        return False
-
-    def is_missing(desc):
-        """Check if file was present in previous revision but now it's gone
-        (i.e. deleted manually, without invoking `bzr remove` command)
-        """
-        return (desc[3] == (True, True) and desc[6][1] is None)
-
-    def is_misadded(desc):
-        """Check if file was added to the working tree but then gone
-        (i.e. deleted manually, without invoking `bzr remove` command)
-        """
-        return (desc[3] == (False, True) and desc[6][1] is None)
-    
-    def is_ignored(desc):
-        if len(desc) >= 8: 
-            return desc[8]
-        else:
-            return None
-    
-    def status(desc):
-        if len(desc) == 8:
-            (file_id, (path_in_source, path_in_target),
-             changed_content, versioned, parent, name, kind,
-             executable) = desc
-            is_ignored = None
-        elif len(desc) == 9:
-            (file_id, (path_in_source, path_in_target),
-             changed_content, versioned, parent, name, kind,
-             executable, is_ignored) = desc
-        else:
-            raise RuntimeError, "Unkown number of items to unpack."
-            
-        if versioned == (False, False):
-            if is_ignored:
-                return gettext("ignored")
-            else:
-                return gettext("non-versioned")
-        elif versioned == (False, True):
-            return gettext("added")
-        elif versioned == (True, False):
-            return gettext("removed")
-        elif kind[0] is not None and kind[1] is None:
-            return gettext("missing")
-        else:
-            # versioned = True, True - so either renamed or modified
-            # or properties changed (x-bit).
-            renamed = (parent[0], name[0]) != (parent[1], name[1])
-            if renamed:
-                if changed_content:
-                    return gettext("renamed and modified")
-                else:
-                    return gettext("renamed")
-            elif changed_content:
-                return gettext("modified")
-            elif executable[0] != executable[1]:
-                return gettext("modified (x-bit)")
-            else:
-                raise RuntimeError, "what status am I missing??"
-
-
-def closure_in_selected_list(selected_list):
-    """Return in_selected_list(path) function for given selected_list."""
-
-    def in_selected_list(path):
-        """Check: is path belongs to some selected_list."""
-        if path in selected_list:
-            return True
-        for p in selected_list:
-            if path.startswith(p):
-                return True
-        return False
-
-    if not selected_list:
-        return lambda path: True
-    return in_selected_list