python类TreeView()的实例源码

def __init__(self, window):
        Gtk.ScrolledWindow.__init__(self)

        # Parent window
        self._window = window

        # Tree view
        self._tree_view = Gtk.TreeView(Gtk.ListStore(int, int, str, str))
        self._tree_view.set_headers_visible(False)
        renderer = Gtk.CellRendererText()
        column = Gtk.TreeViewColumn("Message", renderer, text=2, background=3)
        self._tree_view.append_column(column)
        self._tree_view.connect("row-activated", self.on_row_activated)
        self.add(self._tree_view)

        self.show_all()

def on_drag_data_received(self, widget, context, x, y, data, info, time):
        '''????'''
        if not data:
            return
        bx, by = self.iconview.convert_widget_to_bin_window_coords(x, y)
        selected = Gtk.TreeView.get_path_at_pos(self.iconview, bx, by)
        if not selected:
            return
        tree_path = selected[0]
        if tree_path is None:
            return
        target_path = self.liststore[tree_path][PATH_COL]
        is_dir = self.liststore[tree_path][ISDIR_COL]
        if not is_dir or info != TargetInfo.PLAIN_TEXT:
            return
        filelist_str = data.get_text()
        filelist = json.loads(filelist_str)
        for file_item in filelist:
            if file_item['path'] == target_path:
                self.app.toast(_('Error: Move folder to itself!'))
                return
        for file_item in filelist:
            file_item['dest'] = target_path
        gutil.async_call(pcs.move, self.app.cookie, self.app.tokens, filelist,
                         callback=self.parent.reload)

def populate_tree(self, groups):
        """ Accepts an array of n rows made of 2 elements each, and returns a TreeView."""

        store = Gtk.TreeStore(GdkPixbuf.Pixbuf, str, str)

        for group in groups:
            #header = '<span background=\"#5a58ff\" foreground=\"white\"><b> ' + group.replace('_', ' ').capitalize() + '\t</b></span>'
            header = group.replace('_', ' ').capitalize()
            it = store.append(None, [self.pix, header, ''])
            for row in eval('self.' + group):
                store.append(it, [None, row[0], row[1]])

        tv = Gtk.TreeView(store)
        #tv.set_rules_hint(True)
        #tv.set_enable_tree_lines(True)
        tv.set_show_expanders(False)
        tv.set_level_indentation(10)
        tv.expand_all()

        return tv

def __create_gui(self):
        """
        Create and display the GUI components of the gramplet.
        """
        vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)

        self.model = Gtk.ListStore(object, str, int)
        view = Gtk.TreeView(self.model)
        renderer = Gtk.CellRendererText()
        column = Gtk.TreeViewColumn(_("Person"), renderer, text=1)
        view.append_column(column)
        renderer = Gtk.CellRendererText()
        renderer.set_property('editable', True)
        renderer.connect('edited', self.__cell_edited)
        column = Gtk.TreeViewColumn(_("ID"), renderer, text=2)
        view.append_column(column)

        vbox.pack_start(view, expand=True, fill=True, padding=0)
        return vbox

def __init__(self, choices, change_handler=None):
        self.model = gtk.ListStore(GObject.TYPE_STRING)
        self._values = []
        for label, value in choices:
            self.model.append((label,))
            self._values.append(value)
        renderer = gtk.CellRendererText()
        self.control = gtk.ScrolledWindow()
        self.control.show()
        self._treeview = gtk.TreeView(self.model)
        self._treeview.show()
        self.control.add(self._treeview)
        self.control.set_shadow_type(gtk.ShadowType.ETCHED_OUT)
        self.control.set_policy(gtk.PolicyType.AUTOMATIC, gtk.PolicyType.AUTOMATIC)
        # Sadly there seems to be no way to adjust the size of the ScrolledWindow to its content.
        # The default size of the ScrolledWindow is too small (making it hard to select the model).
        self.control.set_size_request(200, -1)
        column = gtk.TreeViewColumn()
        column.pack_start(renderer, expand=False)
        column.set_attributes(renderer, text=0)
        self._treeview.append_column(column)
        self._treeview.set_headers_visible(False)
        self._selection = self._treeview.get_selection()
        self._selection.set_mode(gtk.SelectionMode.MULTIPLE)
        self.connect("changed", change_handler, self._selection)

def create_window(self):
        self.dialog = Gtk.Dialog(None, None, Gtk.DialogFlags.MODAL) 
        self.dialog.set_decorated(False)
        #
        scrolledwindow = Gtk.ScrolledWindow()
        scrolledwindow.set_can_focus(False) 
        scrolledwindow.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
        scrolledwindow.set_shadow_type(Gtk.ShadowType.ETCHED_OUT)
        self.dialog.vbox.pack_start(scrolledwindow, Gtk.AttachOptions.SHRINK, Gtk.AttachOptions.SHRINK,0)
        #
        self.store = Gtk.ListStore(str)
        for value in self.values:
            self.store.append([value])
        self.tree = Gtk.TreeView(self.store)
        self.tree.set_headers_visible(False)
        self.tree.set_can_focus(False) 
        renderer = Gtk.CellRendererText()
        column = Gtk.TreeViewColumn(title=None,cell_renderer=renderer, text=0)
        self.tree.append_column(column)
        #
        scrolledwindow.add(self.tree)
        self.tree.connect('focus-out-event',self.on_focus_out)
        self.dialog.connect('focus-out-event',self.on_focus_out)
        self.tree.connect('cursor-changed',self.on_cursor_changed)
        self.dialog.show_all()

def __init__(self):
        Gtk.ScrolledWindow.__init__(self)
        self.list = Gtk.ListStore(str, bool)
        self.view = Gtk.TreeView(self.list)
        self.view.set_hexpand(True)
        text_renderer = Gtk.CellRendererText()
        check_renderer = Gtk.CellRendererToggle()
        name_column = Gtk.TreeViewColumn('Gtk color list', text_renderer, text=0)
        check_column = Gtk.TreeViewColumn('', check_renderer, active=1)
        self.view.append_column(check_column)
        self.view.append_column(name_column)
        self.view.connect('row-activated', self.row_activated)
        self.add(self.view)

        names = ['active_text_color', 'inactive_text_color',
                 'active_text_shadow_color', 'inactive_text_shadow_color',
                 'active_border_color', 'inactive_border_color',
                 'active_color_1', 'active_color_2', 'active_highlight_1',
                 'active_highlight_2', 'active_mid_1', 'active_mid_2',
                 'active_shadow_1', 'active_shadow_2', 'inactive_color_1',
                 'inactive_color_2', 'inactive_highlight_1',
                 'inactive_highlight_2', 'inactive_mid_1', 'inactive_mid_2',
                 'inactive_shadow_1', 'inactive_shadow_2']
        for name in names:
            self.list.append([name, False])

def refresh_liststore(self, tp):

        for i in self.tabs[self.current_page][0]:
            if type(i) == Gtk.ScrolledWindow:
                for t in i:
                    if type(t) == Gtk.TreeView:

                        ls = t.get_model()
                        ls.clear()

                        if tp == 1: l = bookmarksview()
                        if tp == 2: l = cookiesview()
                        if tp == 3: l = historyview()

                        for a in l: ls.append(list(a))
                        t.set_model(ls)

def __init__(self):
        super(CellRendererFadeWindow, self).__init__(title="CellRendererFade Example")

        self.set_default_size(200, 200)
        self.liststore = Gtk.ListStore(str, str)
        self.liststore.append(["New", Gtk.STOCK_NEW])
        self.liststore.append(["Open", Gtk.STOCK_OPEN])
        self.liststore.append(["Save", Gtk.STOCK_SAVE])

        treeview = Gtk.TreeView(model=self.liststore)
        renderer_text = Gtk.CellRendererText()
        column_text = Gtk.TreeViewColumn("Text", renderer_text, text=0)
        treeview.append_column(column_text)

        renderer_pixbuf = CellRenderFade(param=0.001)
        column_pixbuf = Gtk.TreeViewColumn("Image", renderer_pixbuf, stock_id=1)
        treeview.append_column(column_pixbuf)
        self.add(treeview)

def populate_store(self, store):

        directory = '/home/anon/Documents'
        for filename in os.listdir(directory):
            size = os.path.getsize(os.path.join(directory, filename))
            # the second element is displayed in the second TreeView column
            # but that column is sorted by the third element
            # so the file sizes are sorted as numbers, not as strings
            store.append([filename, '{0:,}'.format(size), size])       

# The main part:

def __init__(self):

        Gtk.Window.__init__(self, title='My Window Title')
        self.connect('delete-event', Gtk.main_quit)        

        store = Gtk.ListStore(str, str, str, str)
        self.populate_store(store)

        self.treeview = Gtk.TreeView(model=store)

        renderer = Gtk.CellRendererText()

        column_catalog = Gtk.TreeViewColumn('Catalog Name', renderer, text=0)
        column_catalog.set_sort_column_id(0)        
        self.treeview.append_column(column_catalog)

        column_dbname = Gtk.TreeViewColumn('Database Name', renderer, text=1)
        column_dbname.set_sort_column_id(1)
        self.treeview.append_column(column_dbname)

        column_charset = Gtk.TreeViewColumn('Character Set', renderer, text=2)
        column_charset.set_sort_column_id(2)
        self.treeview.append_column(column_charset)

        column_collation = Gtk.TreeViewColumn('Collation', renderer, text=3)
        column_collation.set_sort_column_id(3)
        self.treeview.append_column(column_collation)

        scrolled_window = Gtk.ScrolledWindow()
        scrolled_window.set_policy(
            Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
        scrolled_window.add(self.treeview)
        scrolled_window.set_min_content_height(200)

        self.add(scrolled_window)
        self.show_all()

    # Add data to ListStore

def __init__(self):
        Gtk.Frame.__init__(self)
        self.sbrick = None
        self.set_label("SBrick Information")

        self.store = Gtk.ListStore(str, str)
        self.iterSBrickID = self.store.append(["SBrick BlueGiga ID", "--"])
        self.iterHardwareVersion = self.store.append(["Hardware Version", "--"])
        self.iterSoftwareVersion = self.store.append(["Software Version", "--"])
        self.iterNeedAuthentication = self.store.append(["Need Authentication", "--"])
        self.iterIsAuthenticated = self.store.append(["Is Authenticated", "--"])
        self.iterAuthenticationTimeout = self.store.append(["Authentication Timeout", "--"])
        self.iterInputVoltage = self.store.append(["Input Voltage", "--"])
        self.iterTemperature = self.store.append(["Temperature", "--"])
        self.iterPowerCycles = self.store.append(["Power Cycles", "--"])
        self.iterWatchdogTimeout = self.store.append(["Watchdog Timeout", "--"])
        self.iterUpTime = self.store.append(["Up Time", "--"])
        self.iterThermalLimit = self.store.append(["Thermal Limit", "--"])

        self.listView = Gtk.TreeView(self.store)

        renderer = Gtk.CellRendererText()
        column = Gtk.TreeViewColumn("Item", renderer, text=0)
        self.listView.append_column(column)

        renderer = Gtk.CellRendererText()
        column = Gtk.TreeViewColumn("Value", renderer, text=1)
        self.listView.append_column(column)

        self.scrollTree = Gtk.ScrolledWindow()
        self.scrollTree.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
        self.scrollTree.add_with_viewport(self.listView)
        self.scrollTree.set_min_content_height(100)

        self.add(self.scrollTree)
        self.set_sensitive(False)

def __init__(self):
        Gtk.TreeView.__init__(self)
        self.sections = {}
        titles = [(_('Key'), 1, 235),
                  (_('Value'), 2, 325)]
        self.model = ListModel(self, titles, list_mode="tree")

def __init__(self, model, dep_type, label):
        Gtk.TreeView.__init__(self)
        self.current = None
        self.dep_type = dep_type
        self.filter_model = model.filter_new()
        self.filter_model.set_visible_func(self._filter, data=None)
        self.set_model(self.filter_model)
        self.append_column(Gtk.TreeViewColumn(label, Gtk.CellRendererText(), text=COL_DEP_PACKAGE))

def __init__(self, model, label):
        Gtk.TreeView.__init__(self)
        self.current = None
        self.filter_model = model.filter_new()
        self.filter_model.set_visible_func(self._filter)
        self.set_model(self.filter_model)
        self.append_column(Gtk.TreeViewColumn(label, Gtk.CellRendererText(), text=COL_DEP_PARENT))

def on_grid_songs_focus_in_event(self, widget, event):
        """ We don't want 2 treeview with a selection,
            so we walk trougth the siblings and their children
            then call unselect_all() if it's a treeview
        """
        stack = [self.get_view().get_parent()]
        while any(stack):
            element = stack.pop()
            if isinstance(element, Gtk.TreeView) and element is not widget:
                element.get_selection().unselect_all()
            elif isinstance(element, Gtk.Container):
                stack.extend(element.get_children())

def populate_treeview(self, rows):
        """ Accepts an array of n rows made of 2 elements each, and returns a ListView."""

        store = Gtk.ListStore(str, str)
        for row in rows:
            store.append([row[0], row[1]])

        tv = Gtk.TreeView(store)
        tv.set_rules_hint(True)

        return tv

def create_tree(self):
        # Scrolled Window
        self.sw = Gtk.ScrolledWindow()
        self.sw.set_shadow_type(Gtk.ShadowType.ETCHED_IN)
        self.sw.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)

        self.store = Gtk.ListStore(str, str)
        self.tree = Gtk.TreeView(self.store)

        self.sw.add(self.tree)

        self.tree.set_rules_hint(True)

        # Connect right click popup search menu
        self.popup_handler = self.tree.connect('button-press-event', self.popup_menu)

        # Create the column
        bblocks = Gtk.TreeViewColumn()
        bblocks.set_title("Basic Blocks")

        cell = Gtk.CellRendererText()
        bblocks.pack_start(cell, True)
        bblocks.add_attribute(cell, "text", 0)

        self.treestore = Gtk.TreeStore(str)

        # Add column to tree
        self.tree.append_column(bblocks)
        self.tree.set_model(self.treestore)
        self.tree.expand_all()

def on_row_activated( # pylint: disable=no-self-use
            self, treeview, treepath, column):
        '''Signal handler for activating a row in the browsing treeview

        :param treeview: The browsing treeview
        :type treeview: Gtk.TreeView object
        :param treepath: The path of the activated row in the browsing treeview
        :type treepath: Gtk.TreePath object
        :param column: The column of the activated row in the browsing treeview
        :type column: Gtk.TreeViewColumn object
        '''
        if _ARGS.debug:
            sys.stdout.write(
                'on_row_activated() %s %s %s\n'
                %(repr(treeview), repr(treepath), repr(column)))

def treeview_clicked(self, widget, event):
        """Responds to right click events on the TreeView."""
        if event.button == 3:
            store, course_iter = widget.get_selection().get_selected()
            course_id = store.get(course_iter, 4)[0] 
            self.selected_id = course_id  
            self.selected_course = self.course_manager.courses[course_id]

            self.edit_menu.popup(None, None, None, None, event.button, event.time)

def on_treeview_folders_cursor_changed(self, widget):
        selected_row = get_treeview_selected_row(self.ui.treeview_folders)
        if selected_row:
            folder_name = self.model_folders.get_key(selected_row)
            # Check if the folder still exists
            # (model erased while the cursor moves through the Gtk.TreeView)
            if folder_name in self.folders:
                folder_info = self.folders[folder_name]
                # Clear any previous application icon
                self.model_applications.clear()
                # Add new application icons
                applications = folder_info.get_applications()
                for application in applications:
                    desktop_file = applications[application]
                    if desktop_file or preferences.get(
                            preferences.PREFERENCES_SHOW_MISSING):
                        application_file = applications[application]
                        application_info = ApplicationInfo(
                            application,
                            application_file.getName()
                            if desktop_file else 'Missing desktop file',
                            application_file.getComment()
                            if desktop_file else application,
                            application_file.getIcon()
                            if desktop_file else None,
                            # Always show any application, also if hidden
                            True)
                        self.model_applications.add_data(application_info)
            # Disable folder content saving
            self.ui.action_files_save.set_sensitive(False)

def get_font_family_list():

    widget = Gtk.FontChooserWidget()
    treeview = get_descendant(widget, "family_face_list", level=0, doPrint=False)
    famlist = ["serif", "sans-serif", "monospace"]

    if type(treeview) == Gtk.TreeView:
        for i in treeview.get_model():
            fam = i[0].get_name()
            if fam not in famlist: famlist.append(fam)

    return famlist

def __init__(self):
        Gtk.TreeView.__init__(self)
        self.task_store = Gtk.TreeStore(str, str)
        self.set_model(self.task_store)
        column = Gtk.TreeViewColumn(_('Tasks'), Gtk.CellRendererText(), text=0)
        self.append_column(column)
        self.connect('notify::tasks', self.tasks_changed)

def __setup_ui(self, win):
        btn_setting = Gtk.Button("Settings")
        btn_setting.set_margin_right(self.HORIZONTAL_MARGIN)
        btn_reload = Gtk.Button("Reload")
        btn_box = Gtk.HBox()
        btn_box.add(btn_setting)
        btn_box.add(btn_reload)
        self._listbox = Gtk.TreeView(self._list_store)
        self._listbox.set_headers_visible(False)
        self._listbox.connect("row-activated", self.__row_activated)
        self._scrollable = Gtk.ScrolledWindow()
        self._scrollable.add(self._listbox)
        self.__fill_listbox()
        self._frame = Gtk.Frame()
        self._frame.add(self._scrollable)
        self._frame.set_border_width(1)
        self._frame.set_margin_bottom(self.VERTICAL_MARGIN)
        vbox = Gtk.VBox()
        vbox.pack_start(self._frame, 1, 1, 1)
        vbox.pack_end(btn_box, 0, 0, 0)
        vbox.set_margin_top(self.VERTICAL_MARGIN)
        vbox.set_margin_bottom(self.VERTICAL_MARGIN)
        vbox.set_margin_left(self.VERTICAL_MARGIN)
        vbox.set_margin_right(self.VERTICAL_MARGIN)
        win.add(vbox)
        return btn_reload, btn_setting

def __row_activated(self, target: Gtk.TreeView, path: Gtk.TreePath, column: Gtk.TreeViewColumn):
        i = path.get_indices()[0]
        connection = self._manager.get_connection(i)
        self.__command_ssh.run(connection, connection.args)

def set_model(self, model):
        # the set_cell_data_func() calls here are a workaround for bug
        # LP: #986186 - once that is fixed upstream we can revert this
        # and remove the entire "set_model" again
        self._column.set_cell_data_func(self._renderer, None)
        Gtk.TreeView.set_model(self, model)
        self._column.set_cell_data_func(
            self._renderer, self._cell_data_func_cb)

def _on_realize(self, widget, tr):
        # connect to backend events once self is realized so handlers
        # have access to the TreeView's initialised Gdk.Window
        if self._transactions_connected:
            return
        self.backend.connect("transaction-started",
            self._on_transaction_started, tr)
        self.backend.connect("transaction-finished",
            self._on_transaction_finished, tr)
        self.backend.connect("transaction-stopped",
            self._on_transaction_stopped, tr)
        self._transactions_connected = True

def __init__(self, navhistory):
        Gtk.TreeView.__init__(self)
        self.navhistory = navhistory
        model = Gtk.ListStore()
        model.set_column_types(self._COLUMN_TYPES)
        self._build_tree_view(model)
        self.connect("button-press-event", self.on_press_event)
        return

def set_model(self, model):
        # the set_cell_data_func() calls here are a workaround for bug
        # LP: #986186 - once that is fixed upstream we can revert this
        # and remove the entire "set_model" again
        self._column.set_cell_data_func(self._renderer, None)
        Gtk.TreeView.set_model(self, model)
        self._column.set_cell_data_func(
            self._renderer, self._cell_data_func_cb)

def __init__(self, navhistory):
        Gtk.TreeView.__init__(self)
        self.navhistory = navhistory
        model = Gtk.ListStore()
        model.set_column_types(self._COLUMN_TYPES)
        self._build_tree_view(model)
        self.connect("button-press-event", self.on_press_event)
        return