results_view.py

import gtk

class ResultsDownloadView(gtk.VBox):

    def show_data(self, results, root_type):
        self.treeViewResults.show_data(results, root_type)

    def __init__(self, *args, **kwargs):
        super(ResultsDownloadView, self).__init__(*args, **kwargs)

        sw_results = gtk.ScrolledWindow()
        sw_results.set_shadow_type(gtk.SHADOW_ETCHED_IN)
        sw_results.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
        self.pack_start(sw_results,expand=True, fill=True)

        self.treeViewResults = TreeViewResults()
        sw_results.add(self.treeViewResults)

        buttonBox_download = gtk.HButtonBox()
        self.pack_end(buttonBox_download,expand=False, fill=False)

        def event_clicked_download(button, *_):
            import gobject
            import xnat_search
            enabled = (d for d in self.treeViewResults.store if d[0])
            for d in enabled:
                def stop_spinner(_row):
                    _row[2] = False # Hide spinner
                    _row[0] = False # Checkbox to false
                d[3] = 0
                d[2] = True # Show Spinner
                xnat_search.download_async(d[1], button.destination, cb=stop_spinner, cb_args=(d,))

        def event_clicked_toggle_selection(*_):
            self.treeViewResults.toggle_selection()

        button_toggle_selection = gtk.Button(label="toggle Selection")
        button_toggle_selection.connect("clicked", event_clicked_toggle_selection)
        buttonBox_download.add(button_toggle_selection)

        def event_selection_changed(filechooserbutton, *_):
            self.button_download.destination = filechooserbutton.get_filename()

        button_folder = gtk.FileChooserButton("Select Folder")
        button_folder.set_action(gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER)
        button_folder.connect("selection-changed", event_selection_changed)
        buttonBox_download.add(button_folder)

        self.button_download = ButtonDownloadResults(label="Download Selected Items")
        self.button_download.connect("clicked", event_clicked_download)
        buttonBox_download.add(self.button_download)

class ButtonDownloadResults(gtk.Button):

    count = 0
    _destination = ""

    @property
    def destination(self):
        return self._destination

    @destination.setter
    def destination(self, value):
        self._destination = value

    def __init__(self, *args, **kwargs):
        super(ButtonDownloadResults, self).__init__(*args, **kwargs)



class TreeViewResults(gtk.TreeView):

    store = []
    def __init__(self):
        import gobject
        super(TreeViewResults, self).__init__()

        self.show_data([], None)

        gobject.timeout_add(150, self.move_spinners)

    def move_spinners(self):
        for r in self.store:
            if r[2]: # if spinner is visible
                r[3] += 1
        return True


    def create_columns(self, column_labels):

        for c in self.get_columns():
            self.remove_column(c)

        def callback_toggled(cellrenderertoggle, path_string, col, *_):
            it = self.store.get_iter_from_string(path_string)
            is_active = cellrenderertoggle.get_active()
            self.store.set(it, col, not is_active)

        renderer = gtk.CellRendererToggle()
        renderer.set_property('activatable', True)
        renderer.connect("toggled", callback_toggled, 0)
        column = gtk.TreeViewColumn("", renderer)
        column.add_attribute(renderer, "active", 0)
        column.set_sort_column_id(0)
        column.set_resizable(False)
        self.append_column(column)

        renderer = gtk.CellRendererSpinner()
        column = gtk.TreeViewColumn("", renderer, active=2, pulse=3)
        self.append_column(column)

        for i,cl in enumerate(column_labels, start=4):
            column = gtk.TreeViewColumn(cl, gtk.CellRendererText(), text=i)
            column.set_sort_column_id(i)
            column.set_resizable(True)
            self.append_column(column)

    def toggle_selection(self):
        for row in self.store:
            row[0] = not row[0]

    def show_data(self, data, root_type):
        import gobject
        if data == []:
            self.create_columns([])
            return


        keys = data.headers()

        model_columns = []
        model_columns.append(bool)                  # 0 is selected (for download selection)
        model_columns.append(gobject.TYPE_PYOBJECT) # 1 query result
        model_columns.append(bool)                  # 2 is spinner visible
        model_columns.append(int)                   # 3 spinner pulse
        for k in keys:
            model_columns.append(str)

        self.store = gtk.ListStore(*model_columns)

        for d in data:
            result = []
            result.append(True)
            result.append(d)
            result.append(False)
            result.append(0)
            for k in keys:
                result.append(d[k])

            self.store.append(result)

        import xnat_search
        keys_ = list(xnat_search.get_field_label(root_type, key) for key in keys)
        self.create_columns(keys_)    # TODO labels
        self.set_model(self.store)